Add #105 PR from main

Services/Workspaces.qml

@@ -1,6 +1,5 @@
 pragma Singleton
-
+pragma ComponentBehavior: Bound
-pragma ComponentBehavior
 
 import QtQuick
 import Quickshell
@@ -9,146 +8,149 @@ import Quickshell.Hyprland
 import qs.Services
 
 Singleton {
-  id: root
+    id: root
 
-  property ListModel workspaces: ListModel {}
+    property ListModel workspaces: ListModel {}
-  property bool isHyprland: false
+    property bool isHyprland: false
-  property bool isNiri: false
+    property bool isNiri: false
-  property var hlWorkspaces: Hyprland.workspaces.values
+    property var hlWorkspaces: Hyprland.workspaces.values
-  // Detect which compositor we're using
+    // Detect which compositor we're using
-  Component.onCompleted: {
+    Component.onCompleted: {
-    console.log("Workspace initializing...")
+        console.log("WorkspaceManager initializing...");
-    detectCompositor()
+        detectCompositor();
-  }
+    }
 
-  function detectCompositor() {
+    function detectCompositor() {
-    try {
+        try {
-      try {
+            try {
-        if (Hyprland.eventSocketPath) {
+                if (Hyprland.eventSocketPath) {
-          console.log("Detected Hyprland compositor")
+                    console.log("Detected Hyprland compositor");
-          isHyprland = true
+                    isHyprland = true;
-          isNiri = false
+                    isNiri = false;
-          initHyprland()
+                    initHyprland();
-          return
+                    return;
+                }
+            } catch (e) {
+                console.log("Hyprland not available:", e);
+            }
+
+            if (typeof Niri !== "undefined") {
+                console.log("Detected Niri service");
+                isHyprland = false;
+                isNiri = true;
+                initNiri();
+                return;
+            }
+
+            console.log("No supported compositor detected");
+        } catch (e) {
+            console.error("Error detecting compositor:", e);
         }
-      } catch (e) {
-        console.log("Hyprland not available:", e)
-      }
-
-      if (typeof Niri !== "undefined") {
-        console.log("Detected Niri service")
-        isHyprland = false
-        isNiri = true
-        initNiri()
-        return
-      }
-
-      console.log("No supported compositor detected")
-    } catch (e) {
-      console.error("Error detecting compositor:", e)
-    }
-  }
-
-  // Initialize Hyprland integration
-  function initHyprland() {
-    try {
-      // Fixes the odd workspace issue.
-      Hyprland.refreshWorkspaces()
-      // hlWorkspaces = Hyprland.workspaces.values;
-      // updateHyprlandWorkspaces();
-      return true
-    } catch (e) {
-      console.error("Error initializing Hyprland:", e)
-      isHyprland = false
-      return false
-    }
-  }
-
-  onHlWorkspacesChanged: {
-    updateHyprlandWorkspaces()
-  }
-
-  Connections {
-    target: Hyprland.workspaces
-    function onValuesChanged() {
-      updateHyprlandWorkspaces()
-    }
-  }
-
-  Connections {
-    target: Hyprland
-    function onRawEvent(event) {
-      updateHyprlandWorkspaces()
-    }
-  }
-
-  function updateHyprlandWorkspaces() {
-    workspaces.clear()
-    try {
-      for (var i = 0; i < hlWorkspaces.length; i++) {
-        const ws = hlWorkspaces[i]
-        workspaces.append({
-                            "id": i,
-                            "idx": ws.id,
-                            "name": ws.name || "",
-                            "output": ws.monitor?.name || "",
-                            "isActive": ws.active === true,
-                            "isFocused": ws.focused === true,
-                            "isUrgent": ws.urgent === true
-                          })
-      }
-      workspacesChanged()
-    } catch (e) {
-      console.error("Error updating Hyprland workspaces:", e)
-    }
-  }
-
-  function initNiri() {
-    updateNiriWorkspaces()
-  }
-
-  Connections {
-    target: Niri
-    function onWorkspacesChanged() {
-      updateNiriWorkspaces()
-    }
-  }
-
-  function updateNiriWorkspaces() {
-    const niriWorkspaces = Niri.workspaces || []
-    workspaces.clear()
-    for (var i = 0; i < niriWorkspaces.length; i++) {
-      const ws = niriWorkspaces[i]
-      workspaces.append({
-                          "id": ws.id,
-                          "idx": ws.idx || 1,
-                          "name": ws.name || "",
-                          "output": ws.output || "",
-                          "isFocused": ws.isFocused === true,
-                          "isActive": ws.isActive === true,
-                          "isUrgent": ws.isUrgent === true,
-                          "isOccupied": ws.isOccupied === true
-                        })
     }
 
-    workspacesChanged()
+    // Initialize Hyprland integration
-  }
+    function initHyprland() {
-
+        try {
-  function switchToWorkspace(workspaceId) {
+            // Fixes the odd workspace issue.
-    if (isHyprland) {
+            Hyprland.refreshWorkspaces();
-      try {
+            // hlWorkspaces = Hyprland.workspaces.values;
-        Hyprland.dispatch(`workspace ${workspaceId}`)
+            // updateHyprlandWorkspaces();
-      } catch (e) {
+            return true;
-        console.error("Error switching Hyprland workspace:", e)
+        } catch (e) {
-      }
+            console.error("Error initializing Hyprland:", e);
-    } else if (isNiri) {
+            isHyprland = false;
-      try {
+            return false;
-        Quickshell.execDetached(["niri", "msg", "action", "focus-workspace", workspaceId.toString()])
+        }
-      } catch (e) {
-        console.error("Error switching Niri workspace:", e)
-      }
-    } else {
-      console.warn("No supported compositor detected for workspace switching")
     }
-  }
+
-}
+    onHlWorkspacesChanged: {
+        updateHyprlandWorkspaces();
+    }
+
+    Connections {
+        target: Hyprland.workspaces
+        function onValuesChanged() {
+            updateHyprlandWorkspaces();
+        }
+    }
+
+    Connections {
+        target: Hyprland
+        function onRawEvent(event) {
+            updateHyprlandWorkspaces();
+        }
+    }
+
+    function updateHyprlandWorkspaces() {
+        workspaces.clear();
+        try {
+            for (let i = 0; i < hlWorkspaces.length; i++) {
+                const ws = hlWorkspaces[i];
+                // Only append workspaces with id >= 1
+                if (ws.id >= 1) {
+                    workspaces.append({
+                        id: i,
+                        idx: ws.id,
+                        name: ws.name || "",
+                        output: ws.monitor?.name || "",
+                        isActive: ws.active === true,
+                        isFocused: ws.focused === true,
+                        isUrgent: ws.urgent === true
+                    });
+                }
+            }
+            workspacesChanged();
+        } catch (e) {
+            console.error("Error updating Hyprland workspaces:", e);
+        }
+    }
+
+    function initNiri() {
+        updateNiriWorkspaces();
+    }
+
+    Connections {
+        target: Niri
+        function onWorkspacesChanged() {
+            updateNiriWorkspaces();
+        }
+    }
+
+    function updateNiriWorkspaces() {
+        const niriWorkspaces = Niri.workspaces || [];
+        workspaces.clear();
+        for (let i = 0; i < niriWorkspaces.length; i++) {
+            const ws = niriWorkspaces[i];
+            workspaces.append({
+                id: ws.id,
+                idx: ws.idx || 1,
+                name: ws.name || "",
+                output: ws.output || "",
+                isFocused: ws.isFocused === true,
+                isActive: ws.isActive === true,
+                isUrgent: ws.isUrgent === true,
+                isOccupied: ws.isOccupied === true,
+            });
+        }
+
+        workspacesChanged();
+    }
+
+    function switchToWorkspace(workspaceId) {
+        if (isHyprland) {
+            try {
+                Hyprland.dispatch(`workspace ${workspaceId}`);
+            } catch (e) {
+                console.error("Error switching Hyprland workspace:", e);
+            }
+        } else if (isNiri) {
+            try {
+                Quickshell.execDetached(["niri", "msg", "action", "focus-workspace", workspaceId.toString()]);
+            } catch (e) {
+                console.error("Error switching Niri workspace:", e);
+            }
+        } else {
+            console.warn("No supported compositor detected for workspace switching");
+        }
+    }
+}