Initial hyprland workspace support

Services/CompositorService.qml

@@ -19,6 +19,7 @@ Singleton {
     readonly property string niriSocket: Quickshell.env("NIRI_SOCKET")
 
     property bool useNiriSorting: isNiri && NiriService
+    property bool useHyprlandSorting: isHyprland && HyprlandService
 
     // Unified sorted toplevels - automatically chooses sorting based on compositor
     property var sortedToplevels: {
@@ -31,12 +32,16 @@ Singleton {
             return NiriService.sortToplevels(ToplevelManager.toplevels.values)
         }
 
-        // For non-niri compositors or when niri isn't ready yet, return unsorted toplevels
+        // Use Hyprland sorting when both compositor is Hyprland AND hyprland service is ready
+        if (useHyprlandSorting) {
+            return HyprlandService.sortToplevels(ToplevelManager.toplevels.values)
+        }
+
+        // For other compositors or when services aren't ready yet, return unsorted toplevels
         return ToplevelManager.toplevels.values
     }
 
     Component.onCompleted: {
-        console.log("CompositorService: Starting detection...")
         detectCompositor()
     }
 
@@ -46,7 +51,7 @@ Singleton {
             isHyprland = true
             isNiri = false
             compositor = "hyprland"
-            console.log("CompositorService: Detected Hyprland with signature:", hyprlandSignature)
+            console.log("CompositorService: Detected Hyprland")
             return
         }
 

Services/HyprlandService.qml

@@ -0,0 +1,176 @@
+pragma Singleton
+
+pragma ComponentBehavior
+
+import QtQuick
+import Quickshell
+import Quickshell.Hyprland
+
+Singleton {
+    id: root
+
+    property bool hyprlandAvailable: {
+        const signature = Quickshell.env("HYPRLAND_INSTANCE_SIGNATURE")
+        return signature && signature.length > 0
+    }
+
+    property var allWorkspaces: hyprlandAvailable && Hyprland.workspaces ? Hyprland.workspaces.values : []
+    property var focusedWorkspace: hyprlandAvailable ? Hyprland.focusedWorkspace : null
+    property var monitors: hyprlandAvailable ? Hyprland.monitors : []
+    property var focusedMonitor: hyprlandAvailable ? Hyprland.focusedMonitor : null
+
+    function getWorkspacesForMonitor(monitorName) {
+        if (!hyprlandAvailable) return []
+        
+        const workspaces = Hyprland.workspaces ? Hyprland.workspaces.values : []
+        if (!workspaces || workspaces.length === 0) return []
+        
+        // If no monitor name specified, return all workspaces
+        if (!monitorName) {
+            const allWorkspacesCopy = []
+            for (let i = 0; i < workspaces.length; i++) {
+                const workspace = workspaces[i]
+                if (workspace) {
+                    allWorkspacesCopy.push(workspace)
+                }
+            }
+            allWorkspacesCopy.sort((a, b) => a.id - b.id)
+            return allWorkspacesCopy
+        }
+        
+        const filtered = []
+        for (let i = 0; i < workspaces.length; i++) {
+            const workspace = workspaces[i]
+            if (workspace && workspace.monitor && workspace.monitor.name === monitorName) {
+                filtered.push(workspace)
+            }
+        }
+        
+        // Sort by workspace ID
+        filtered.sort((a, b) => a.id - b.id)
+        return filtered
+    }
+
+    function getCurrentWorkspaceForMonitor(monitorName) {
+        if (!hyprlandAvailable) return null
+        
+        // If no monitor name specified, return the globally focused workspace
+        if (!monitorName) {
+            return focusedWorkspace
+        }
+        
+        if (focusedMonitor && focusedMonitor.name === monitorName) {
+            return focusedWorkspace
+        }
+        
+        const monitorWorkspaces = getWorkspacesForMonitor(monitorName)
+        for (let i = 0; i < monitorWorkspaces.length; i++) {
+            const ws = monitorWorkspaces[i]
+            if (ws && ws.active) {
+                return ws
+            }
+        }
+        return null
+    }
+
+    function switchToWorkspace(workspaceId) {
+        if (!hyprlandAvailable) return
+        
+        Hyprland.dispatch(`workspace ${workspaceId}`)
+    }
+
+    function switchToWorkspaceByName(workspaceName) {
+        if (!hyprlandAvailable) return
+        
+        Hyprland.dispatch(`workspace name:${workspaceName}`)
+    }
+
+    function moveToWorkspace(workspaceId) {
+        if (!hyprlandAvailable) return
+        
+        Hyprland.dispatch(`movetoworkspace ${workspaceId}`)
+    }
+
+    function createWorkspace(workspaceId) {
+        if (!hyprlandAvailable) return
+        
+        Hyprland.dispatch(`workspace ${workspaceId}`)
+    }
+
+    function getWorkspaceDisplayNumbers() {
+        if (!hyprlandAvailable) return [1, 2, 3, 4]
+        
+        // Get all existing workspaces from Hyprland.workspaces.values
+        const workspaces = Hyprland.workspaces ? Hyprland.workspaces.values : []
+        if (!workspaces || workspaces.length === 0) {
+            // If no workspaces detected, show at least current + a few more
+            const current = getCurrentWorkspaceNumber()
+            return [Math.max(1, current - 1), current, current + 1, current + 2].filter((ws, i, arr) => arr.indexOf(ws) === i && ws > 0)
+        }
+        
+        // Get workspace IDs and ensure we show a reasonable range
+        const numbers = []
+        let maxId = 0
+        
+        for (let i = 0; i < workspaces.length; i++) {
+            const ws = workspaces[i]
+            if (ws && ws.id > 0) {
+                numbers.push(ws.id)
+                maxId = Math.max(maxId, ws.id)
+            }
+        }
+        
+        // Always ensure we have at least one workspace beyond the highest
+        // to allow easy navigation to new workspaces
+        if (maxId > 0 && numbers.indexOf(maxId + 1) === -1) {
+            numbers.push(maxId + 1)
+        }
+        
+        return numbers.sort((a, b) => a - b)
+    }
+
+    function getCurrentWorkspaceNumber() {
+        if (!hyprlandAvailable) return 1
+        
+        // Use the focused workspace directly
+        const focused = Hyprland.focusedWorkspace
+        return focused ? focused.id : 1
+    }
+
+    function sortToplevels(toplevels) {
+        if (!hyprlandAvailable || !toplevels) return []
+        
+        // Create a copy of the array since the original might be readonly
+        const sortedArray = Array.from(toplevels)
+        
+        return sortedArray.sort((a, b) => {
+            if (a.workspace && b.workspace) {
+                if (a.workspace.monitor && b.workspace.monitor) {
+                    const monitorCompare = a.workspace.monitor.name.localeCompare(b.workspace.monitor.name)
+                    if (monitorCompare !== 0) return monitorCompare
+                }
+                
+                const workspaceCompare = a.workspace.id - b.workspace.id
+                if (workspaceCompare !== 0) return workspaceCompare
+            }
+            
+            return 0
+        })
+    }
+
+    // Signals for workspace changes that WorkspaceSwitcher can connect to
+    signal workspacesUpdated()
+    signal focusedWorkspaceUpdated() 
+    signal focusedMonitorUpdated()
+
+    // Monitor changes to properties and emit our signals
+    onAllWorkspacesChanged: workspacesUpdated()
+    onFocusedWorkspaceChanged: focusedWorkspaceUpdated()
+    onFocusedMonitorChanged: focusedMonitorUpdated()
+
+    Component.onCompleted: {
+        if (hyprlandAvailable) {
+            console.log("HyprlandService: Initialized with Hyprland support")
+        }
+    }
+}