hyprland for running apps workspace only

Modules/Settings/WidgetTweaksTab.qml

@@ -272,7 +272,7 @@ Item {
                     DankToggle {
                         width: parent.width
                         text: "Running Apps Only In Current Workspace"
-                        description: "Show only apps running in current workspace (currently niri only)"
+                        description: "Show only apps running in current workspace"
                         checked: SettingsData.runningAppsCurrentWorkspace
                         onToggled: checked => {
                                        return SettingsData.setRunningAppsCurrentWorkspace(

Services/CompositorService.qml

@@ -70,13 +70,49 @@ Singleton {
         detectCompositor()
     }
 
-    // return only the toplevels on the current workspace on the given screen
     function filterCurrentWorkspace(toplevels, screen){
-	    if (useNiriSorting) {
+        if (useNiriSorting) {
-		    return NiriService.filterCurrentWorkspace(toplevels, screen)
+            return NiriService.filterCurrentWorkspace(toplevels, screen)
-	    }
+        }
-	    //fallback to returning everything
+        if (isHyprland) {
-	    return toplevels
+            return filterHyprlandCurrentWorkspace(toplevels, screen)
+        }
+        return toplevels
+    }
+
+    function filterHyprlandCurrentWorkspace(toplevels, screenName) {
+        if (!toplevels || toplevels.length === 0 || !Hyprland.toplevels) {
+            return toplevels
+        }
+
+        var currentWorkspaceId = null
+        const hyprlandToplevels = Array.from(Hyprland.toplevels.values)
+        
+        for (var i = 0; i < hyprlandToplevels.length; i++) {
+            var hyprToplevel = hyprlandToplevels[i]
+            if (hyprToplevel.activated && hyprToplevel.monitor && hyprToplevel.monitor.name === screenName) {
+                currentWorkspaceId = hyprToplevel.workspace ? hyprToplevel.workspace.id : null
+                break
+            }
+        }
+
+        if (currentWorkspaceId === null && Hyprland.focusedWorkspace) {
+            currentWorkspaceId = Hyprland.focusedWorkspace.id
+        }
+
+        if (currentWorkspaceId === null) {
+            return toplevels
+        }
+
+        return toplevels.filter(toplevel => {
+            for (var j = 0; j < hyprlandToplevels.length; j++) {
+                var hyprToplevel = hyprlandToplevels[j]
+                if (hyprToplevel.wayland === toplevel) {
+                    return hyprToplevel.workspace && hyprToplevel.workspace.id === currentWorkspaceId
+                }
+            }
+            return false
+        })
     }
 
     function detectCompositor() {

Services/NiriService.qml

@@ -33,6 +33,10 @@ Singleton {
 
     readonly property string socketPath: Quickshell.env("NIRI_SOCKET")
 
+    Component.onCompleted: {
+        fetchOutputs()
+    }
+
     function fetchOutputs() {
         if (CompositorService.isNiri) {
             outputsProcess.running = true
@@ -451,82 +455,87 @@ Singleton {
 
 
 
-    function getToplevelToNiriMap(toplevels){
+    function findNiriWindow(toplevel) {
-        // Create a map to match toplevels to niri windows
+        if (!toplevel.appId) return null
-        // We'll match by appId and title since toplevels don't have numeric IDs
-        var toplevelToNiriMap = {}
         
-        for (var i = 0; i < toplevels.length; i++) {
+        for (var j = 0; j < windows.length; j++) {
-            var toplevel = toplevels[i]
+            var niriWindow = windows[j]
-            if (!toplevel.appId) continue
+            if (niriWindow.app_id === toplevel.appId) {
-            
+                if (!niriWindow.title || niriWindow.title === toplevel.title) {
-            // Find matching niri window by appId and optionally title
+                    return { niriIndex: j, niriWindow: niriWindow }
-            for (var j = 0; j < windows.length; j++) {
-                var niriWindow = windows[j]
-                
-                // Match by appId
-                if (niriWindow.app_id === toplevel.appId) {
-                    // If title also matches or niri window has no title, use this match
-                    if (!niriWindow.title || niriWindow.title === toplevel.title) {
-                        toplevelToNiriMap[i] = {
-                            niriIndex: j,
-                            niriWindow: niriWindow
-                        }
-                        break
-                    }
-                    // If we found appId match but no title match yet, store as fallback
-                    if (!(i in toplevelToNiriMap)) {
-                        toplevelToNiriMap[i] = {
-                            niriIndex: j,
-                            niriWindow: niriWindow
-                        }
-                    }
                 }
             }
         }
-        return toplevelToNiriMap
+        return null
     }
 
     function sortToplevels(toplevels) {
         if (!toplevels || toplevels.length === 0 || !CompositorService.isNiri || windows.length === 0) {
             return [...toplevels]
         }
-
-        const toplevelToNiriMap = getToplevelToNiriMap(toplevels)
         
-        // Sort toplevels using niri's ordering
         return [...toplevels].sort((a, b) => {
-            var aIndex = toplevels.indexOf(a)
+            var aNiri = findNiriWindow(a)
-            var bIndex = toplevels.indexOf(b)
+            var bNiri = findNiriWindow(b)
             
-            var aNiri = toplevelToNiriMap[aIndex]
+            if (!aNiri && !bNiri) return 0
-            var bNiri = toplevelToNiriMap[bIndex]
+            if (!aNiri) return 1
+            if (!bNiri) return -1
             
-            // If both have niri data, use niri ordering
+            var aWindow = aNiri.niriWindow
-            if (aNiri && bNiri) {
+            var bWindow = bNiri.niriWindow
-                return aNiri.niriIndex - bNiri.niriIndex
+            var aWorkspace = allWorkspaces.find(ws => ws.id === aWindow.workspace_id)
+            var bWorkspace = allWorkspaces.find(ws => ws.id === bWindow.workspace_id)
+            
+            if (aWorkspace && bWorkspace) {
+                if (aWorkspace.output !== bWorkspace.output) {
+                    return aWorkspace.output.localeCompare(bWorkspace.output)
+                }
+                
+                if (aWorkspace.output === bWorkspace.output && aWorkspace.idx !== bWorkspace.idx) {
+                    return aWorkspace.idx - bWorkspace.idx
+                }
             }
             
-            // If only one has niri data, prioritize it
+            if (aWindow.workspace_id === bWindow.workspace_id && 
-            if (aNiri && !bNiri) return -1
+                aWindow.layout && bWindow.layout && 
-            if (!aNiri && bNiri) return 1
+                aWindow.layout.pos_in_scrolling_layout && 
+                bWindow.layout.pos_in_scrolling_layout) {
+                var aPos = aWindow.layout.pos_in_scrolling_layout
+                var bPos = bWindow.layout.pos_in_scrolling_layout
+                
+                if (aPos.length > 1 && bPos.length > 1) {
+                    if (aPos[0] !== bPos[0]) {
+                        return aPos[0] - bPos[0]
+                    }
+                    if (aPos[1] !== bPos[1]) {
+                        return aPos[1] - bPos[1]
+                    }
+                }
+            }
             
-            // If neither has niri data, keep original toplevel order
+            return aWindow.id - bWindow.id
-            return 0
         })
     }
 
     function filterCurrentWorkspace(toplevels, screenName){
-        const toplevelToNiriMap = getToplevelToNiriMap(toplevels)
         var currentWorkspaceId = null
-        for (var i = 0; i < NiriService.allWorkspaces.length; i++) {
+        for (var i = 0; i < allWorkspaces.length; i++) {
-            var ws = NiriService.allWorkspaces[i]
+            var ws = allWorkspaces[i]
             if (ws.output === screenName && ws.is_active){
                 currentWorkspaceId = ws.id
+                break
             }
-
         }
-        return toplevels.filter((t, idx) => toplevelToNiriMap[idx] && toplevelToNiriMap[idx].niriWindow.workspace_id == currentWorkspaceId)
+        
+        if (currentWorkspaceId === null) {
+            return toplevels
+        }
+
+        return toplevels.filter(toplevel => {
+            var niriMatch = findNiriWindow(toplevel)
+            return niriMatch && niriMatch.niriWindow.workspace_id === currentWorkspaceId
+        })
     }
 
 }