DankMaterialShell/DMSShell.qml

//@ pragma Env QSG_RENDER_LOOP=threaded
//@ pragma UseQApplication

import QtQuick
import Quickshell
import Quickshell.Io
import qs.Common
import qs.Modals
import qs.Modals.Clipboard
import qs.Modals.Common
import qs.Modals.Settings
import qs.Modals.Spotlight
import qs.Modules
import qs.Modules.AppDrawer
import qs.Modules.DankDash
import qs.Modules.ControlCenter
import qs.Modules.Dock
import qs.Modules.Lock
import qs.Modules.Notepad
import qs.Modules.Notifications.Center
import qs.Widgets
import qs.Modules.Notifications.Popup
import qs.Modules.OSD
import qs.Modules.ProcessList
import qs.Modules.Settings
import qs.Modules.DankBar
import qs.Modules.DankBar.Popouts
import qs.Modules.Plugins
import qs.Services


ShellRoot {
  id: root

  Component.onCompleted: {
    PortalService.init()
    // Initialize DisplayService night mode functionality
    DisplayService.nightModeEnabled
    // Initialize WallpaperCyclingService
    WallpaperCyclingService.cyclingActive
    // Initialize PluginService by accessing its properties
    PluginService.pluginDirectory
  }

  WallpaperBackground {}

  Lock {
      id: lock

      anchors.fill: parent
  }

  Loader {
      id: dankBarLoader
      asynchronous: false

      property var currentPosition: SettingsData.dankBarPosition

      sourceComponent: DankBar {
          onColorPickerRequested: colorPickerModal.show()
      }

      onCurrentPositionChanged: {
          const component = sourceComponent
          sourceComponent = null
          Qt.callLater(() => {
              sourceComponent = component
          })
      }
  }

  Loader {
      id: dockLoader
      active: true
      asynchronous: false

      property var currentPosition: SettingsData.dockPosition

      sourceComponent: Dock {
          contextMenu: dockContextMenuLoader.item ? dockContextMenuLoader.item : null
      }

      onLoaded: {
          if (item) {
              dockContextMenuLoader.active = true
          }
      }

      onCurrentPositionChanged: {
          console.log("DEBUG: Dock position changed to:", currentPosition, "- recreating dock")
          const comp = sourceComponent
          sourceComponent = null
          Qt.callLater(() => {
              sourceComponent = comp
          })
      }
  }

  Loader {
      id: dankDashPopoutLoader

      active: false
      asynchronous: true

      sourceComponent: Component {
          DankDashPopout {
              id: dankDashPopout
          }
      }
  }

  LazyLoader {
      id: dockContextMenuLoader

      active: false

      DockContextMenu {
          id: dockContextMenu
      }
  }

  LazyLoader {
      id: notificationCenterLoader

      active: false

      NotificationCenterPopout {
          id: notificationCenter
      }
  }

  Variants {
      model: SettingsData.getFilteredScreens("notifications")

      delegate: NotificationPopupManager {
          modelData: item
      }
  }

  LazyLoader {
      id: controlCenterLoader

      active: false

      property var modalRef: colorPickerModal
      property LazyLoader powerModalLoaderRef: powerMenuModalLoader

      ControlCenterPopout {
          id: controlCenterPopout
          colorPickerModal: controlCenterLoader.modalRef
          powerMenuModalLoader: controlCenterLoader.powerModalLoaderRef

          onLockRequested: {
              lock.activate()
          }
      }
  }

  LazyLoader {
      id: wifiPasswordModalLoader

      active: false

      WifiPasswordModal {
          id: wifiPasswordModal
      }
  }

  LazyLoader {
      id: networkInfoModalLoader

      active: false

      NetworkInfoModal {
          id: networkInfoModal
      }
  }

  LazyLoader {
      id: batteryPopoutLoader

      active: false

      BatteryPopout {
          id: batteryPopout
      }
  }

  LazyLoader {
      id: vpnPopoutLoader

      active: false

      VpnPopout {
          id: vpnPopout
      }
  }

  LazyLoader {
      id: powerMenuLoader

      active: false

      PowerMenu {
          id: powerMenu

          onPowerActionRequested: (action, title, message) => {
                                      powerConfirmModalLoader.active = true
                                      if (powerConfirmModalLoader.item) {
                                          powerConfirmModalLoader.item.confirmButtonColor = action === "poweroff" ? Theme.error : action === "reboot" ? Theme.warning : Theme.primary
                                          powerConfirmModalLoader.item.show(title, message, function () {
                                              switch (action) {
                                              case "logout":
                                                  SessionService.logout()
                                                  break
                                              case "suspend":
                                                  SessionService.suspend()
                                                  break
                                              case "hibernate":
                                                  SessionService.hibernate()
                                                  break
                                              case "reboot":
                                                  SessionService.reboot()
                                                  break
                                              case "poweroff":
                                                  SessionService.poweroff()
                                                  break
                                              }
                                          }, function () {})
                                      }
                                  }
      }
  }

  LazyLoader {
      id: powerConfirmModalLoader

      active: false

      ConfirmModal {
          id: powerConfirmModal
      }
  }

  LazyLoader {
      id: processListPopoutLoader

      active: false

      ProcessListPopout {
          id: processListPopout
      }
  }

  SettingsModal {
      id: settingsModal
  }

  LazyLoader {
      id: appDrawerLoader

      active: false

      AppDrawerPopout {
          id: appDrawerPopout
      }
  }

  SpotlightModal {
      id: spotlightModal
  }

  ClipboardHistoryModal {
      id: clipboardHistoryModalPopup
  }

  NotificationModal {
      id: notificationModal
  }
  ColorPickerModal {
      id: colorPickerModal
  }

  LazyLoader {
      id: processListModalLoader

      active: false

      ProcessListModal {
          id: processListModal
      }
  }

  LazyLoader {
      id: systemUpdateLoader

      active: false

      SystemUpdatePopout {
          id: systemUpdatePopout
      }
  }

  Variants {
      id: notepadSlideoutVariants
      model: SettingsData.getFilteredScreens("notepad")

      delegate: DankSlideout {
          id: notepadSlideout
          modelData: item
          title: qsTr("Notepad")
          slideoutWidth: 480
          expandable: true
          expandedWidthValue: 960
          customTransparency: SettingsData.notepadTransparencyOverride

          content: Component {
              Notepad {
                  onHideRequested: {
                      notepadSlideout.hide()
                  }
              }
          }

          function toggle() {
              if (isVisible) {
                  hide()
              } else {
                  show()
              }
          }
      }
  }

  LazyLoader {
      id: powerMenuModalLoader

      active: false

      PowerMenuModal {
          id: powerMenuModal

          onPowerActionRequested: (action, title, message) => {
                                      powerConfirmModalLoader.active = true
                                      if (powerConfirmModalLoader.item) {
                                          powerConfirmModalLoader.item.confirmButtonColor = action === "poweroff" ? Theme.error : action === "reboot" ? Theme.warning : Theme.primary
                                          powerConfirmModalLoader.item.show(title, message, function () {
                                              switch (action) {
                                              case "logout":
                                                  SessionService.logout()
                                                  break
                                              case "suspend":
                                                  SessionService.suspend()
                                                  break
                                              case "hibernate":
                                                  SessionService.hibernate()
                                                  break
                                              case "reboot":
                                                  SessionService.reboot()
                                                  break
                                              case "poweroff":
                                                  SessionService.poweroff()
                                                  break
                                              }
                                          }, function () {})
                                      }
                                  }
      }
  }

  IpcHandler {
      function open() {
          powerMenuModalLoader.active = true
          if (powerMenuModalLoader.item)
              powerMenuModalLoader.item.open()

          return "POWERMENU_OPEN_SUCCESS"
      }

      function close() {
          if (powerMenuModalLoader.item)
              powerMenuModalLoader.item.close()

          return "POWERMENU_CLOSE_SUCCESS"
      }

      function toggle() {
          powerMenuModalLoader.active = true
          if (powerMenuModalLoader.item)
              powerMenuModalLoader.item.toggle()

          return "POWERMENU_TOGGLE_SUCCESS"
      }

      target: "powermenu"
  }

  IpcHandler {
      function open(): string {
          processListModalLoader.active = true
          if (processListModalLoader.item)
              processListModalLoader.item.show()

          return "PROCESSLIST_OPEN_SUCCESS"
      }

      function close(): string {
          if (processListModalLoader.item)
              processListModalLoader.item.hide()

          return "PROCESSLIST_CLOSE_SUCCESS"
      }

      function toggle(): string {
          processListModalLoader.active = true
          if (processListModalLoader.item)
              processListModalLoader.item.toggle()

          return "PROCESSLIST_TOGGLE_SUCCESS"
      }

      target: "processlist"
  }

  IpcHandler {
      function open(): string {
          controlCenterLoader.active = true
          if (controlCenterLoader.item) {
              controlCenterLoader.item.open()
              return "CONTROL_CENTER_OPEN_SUCCESS"
          }
          return "CONTROL_CENTER_OPEN_FAILED"
      }

      function close(): string {
          if (controlCenterLoader.item) {
              controlCenterLoader.item.close()
              return "CONTROL_CENTER_CLOSE_SUCCESS"
          }
          return "CONTROL_CENTER_CLOSE_FAILED"
      }

      function toggle(): string {
          controlCenterLoader.active = true
          if (controlCenterLoader.item) {
              controlCenterLoader.item.toggle()
              return "CONTROL_CENTER_TOGGLE_SUCCESS"
          }
          return "CONTROL_CENTER_TOGGLE_FAILED"
      }

      target: "control-center"
  }

  IpcHandler {
      function open(tab: string): string {
          dankDashPopoutLoader.active = true
          if (dankDashPopoutLoader.item) {
              switch (tab.toLowerCase()) {
              case "media":
                  dankDashPopoutLoader.item.currentTabIndex = 1
                  break
              case "weather":
                  dankDashPopoutLoader.item.currentTabIndex = SettingsData.weatherEnabled ? 2 : 0
                  break
              default:
                  dankDashPopoutLoader.item.currentTabIndex = 0
                  break
              }
              dankDashPopoutLoader.item.setTriggerPosition(Screen.width / 2, Theme.barHeight + Theme.spacingS, 100, "center", Screen)
              dankDashPopoutLoader.item.dashVisible = true
              return "DASH_OPEN_SUCCESS"
          }
          return "DASH_OPEN_FAILED"
      }

      function close(): string {
          if (dankDashPopoutLoader.item) {
              dankDashPopoutLoader.item.dashVisible = false
              return "DASH_CLOSE_SUCCESS"
          }
          return "DASH_CLOSE_FAILED"
      }

      function toggle(tab: string): string {
          dankDashPopoutLoader.active = true
          if (dankDashPopoutLoader.item) {
              if (dankDashPopoutLoader.item.dashVisible) {
                  dankDashPopoutLoader.item.dashVisible = false
              } else {
                  switch (tab.toLowerCase()) {
                  case "media":
                      dankDashPopoutLoader.item.currentTabIndex = 1
                      break
                  case "weather":
                      dankDashPopoutLoader.item.currentTabIndex = SettingsData.weatherEnabled ? 2 : 0
                      break
                  default:
                      dankDashPopoutLoader.item.currentTabIndex = 0
                      break
                  }
                  dankDashPopoutLoader.item.setTriggerPosition(Screen.width / 2, Theme.barHeight + Theme.spacingS, 100, "center", Screen)
                  dankDashPopoutLoader.item.dashVisible = true
              }
              return "DASH_TOGGLE_SUCCESS"
          }
          return "DASH_TOGGLE_FAILED"
      }

      target: "dash"
  }

  IpcHandler {
      function getFocusedScreenName() {
          if (CompositorService.isHyprland && Hyprland.focusedWorkspace && Hyprland.focusedWorkspace.monitor) {
              return Hyprland.focusedWorkspace.monitor.name
          }
          if (CompositorService.isNiri && NiriService.currentOutput) {
              return NiriService.currentOutput
          }
          return ""
      }

      function getActiveNotepadInstance() {
          if (notepadSlideoutVariants.instances.length === 0) {
              return null
          }

          if (notepadSlideoutVariants.instances.length === 1) {
              return notepadSlideoutVariants.instances[0]
          }

          var focusedScreen = getFocusedScreenName()
          if (focusedScreen && notepadSlideoutVariants.instances.length > 0) {
              for (var i = 0; i < notepadSlideoutVariants.instances.length; i++) {
                  var slideout = notepadSlideoutVariants.instances[i]
                  if (slideout.modelData && slideout.modelData.name === focusedScreen) {
                      return slideout
                  }
              }
          }

          for (var i = 0; i < notepadSlideoutVariants.instances.length; i++) {
              var slideout = notepadSlideoutVariants.instances[i]
              if (slideout.isVisible) {
                  return slideout
              }
          }

          return notepadSlideoutVariants.instances[0]
      }

      function open(): string {
          var instance = getActiveNotepadInstance()
          if (instance) {
              instance.show()
              return "NOTEPAD_OPEN_SUCCESS"
          }
          return "NOTEPAD_OPEN_FAILED"
      }

      function close(): string {
          var instance = getActiveNotepadInstance()
          if (instance) {
              instance.hide()
              return "NOTEPAD_CLOSE_SUCCESS"
          }
          return "NOTEPAD_CLOSE_FAILED"
      }

      function toggle(): string {
          var instance = getActiveNotepadInstance()
          if (instance) {
              instance.toggle()
              return "NOTEPAD_TOGGLE_SUCCESS"
          }
          return "NOTEPAD_TOGGLE_FAILED"
      }

      target: "notepad"
  }

  Variants {
      model: SettingsData.getFilteredScreens("toast")

      delegate: Toast {
          modelData: item
          visible: ToastService.toastVisible
      }
  }

  Variants {
      model: SettingsData.getFilteredScreens("osd")

      delegate: VolumeOSD {
          modelData: item
      }
  }

  Variants {
      model: SettingsData.getFilteredScreens("osd")

      delegate: MicMuteOSD {
          modelData: item
      }
  }

  Variants {
      model: SettingsData.getFilteredScreens("osd")

      delegate: BrightnessOSD {
          modelData: item
      }
  }

  Variants {
      model: SettingsData.getFilteredScreens("osd")

      delegate: IdleInhibitorOSD {
          modelData: item
      }
  }
}