add noctalia and fuzzel

2026-05-23 21:20:58 +02:00
parent 364801f1a3
commit 9a3eceb3ab
599 changed files with 204318 additions and 0 deletions
@@ -0,0 +1,163 @@
+import QtQuick
+import Quickshell
+import Quickshell.Wayland
+import qs.Commons
+import qs.Services.Compositor
+
+/**
+* Detects which screen the cursor is currently on by creating a temporary
+* invisible PanelWindow. Use withCurrentScreen() to get the screen asynchronously.
+*
+* Usage:
+*   CurrentScreenDetector {
+*     id: screenDetector
+*   }
+*
+*   function doSomething() {
+*     screenDetector.withCurrentScreen(function(screen) {
+*       // screen is the ShellScreen where cursor is
+*     })
+*   }
+*/
+Item {
+  id: root
+
+  // Pending callback to execute once screen is detected
+  property var pendingCallback: null
+  property bool pendingSkipBarCheck: false
+
+  // Detected screen
+  property var detectedScreen: null
+
+  // Signal emitted when screen is detected from the PanelWindow
+  signal screenDetected(var detectedScreen)
+
+  onScreenDetected: function (detectedScreen) {
+    root.detectedScreen = detectedScreen;
+    screenDetectorDebounce.restart();
+  }
+
+  /**
+  * Find a fallback screen that has a bar configured.
+  * Prioritizes the screen at position 0x0 (likely the primary screen).
+  */
+  function findScreenWithBar(): var {
+  const monitors = Settings.data.bar.monitors || [];
+  let primaryCandidate = null;
+  let firstWithBar = null;
+
+  for (let i = 0; i < Quickshell.screens.length; i++) {
+    const s = Quickshell.screens[i];
+    const hasBar = monitors.length === 0 || monitors.includes(s.name);
+
+    if (hasBar) {
+      // Check if this is at 0x0 (primary position)
+      if (s.x === 0 && s.y === 0) {
+        primaryCandidate = s;
+      }
+        // Track first screen with bar as fallback
+        if (!firstWithBar) {
+          firstWithBar = s;
+        }
+        }
+        }
+
+          // Prefer primary (0x0), then first with bar, then just first screen
+          return primaryCandidate || firstWithBar || Quickshell.screens[0];
+        }
+
+          /**
+          * Execute callback with the screen where the cursor currently is.
+          * On single-monitor setups, executes immediately.
+          * On multi-monitor setups, briefly opens an invisible window to detect the screen.
+          */
+          function withCurrentScreen(callback: var, skipBarCheck: bool) {
+          if (root.pendingCallback) {
+            Logger.w("CurrentScreenDetector", "Another detection is pending, ignoring new call");
+            return;
+          }
+
+            // Single monitor setup can execute immediately
+            if (Quickshell.screens.length === 1) {
+              callback(Quickshell.screens[0]);
+              return;
+            }
+
+              // Try compositor-specific focused monitor detection first
+              let screen = CompositorService.getFocusedScreen();
+
+              if (screen) {
+                // Apply the bar check if configured (skip for overlay launcher etc.)
+                if (!skipBarCheck && !Settings.data.general.allowPanelsOnScreenWithoutBar) {
+                  const monitors = Settings.data.bar.monitors || [];
+                  const hasBar = monitors.length === 0 || monitors.includes(screen.name);
+                  if (!hasBar) {
+                    screen = findScreenWithBar();
+                  }
+                  }
+                    Logger.d("CurrentScreenDetector", "Using compositor-detected screen:", screen.name);
+                    callback(screen);
+                    return;
+                  }
+
+                    // Fallback: Multi-monitor setup needs async detection via invisible PanelWindow
+                    root.detectedScreen = null;
+                    root.pendingCallback = callback;
+                    root.pendingSkipBarCheck = !!skipBarCheck;
+                    screenDetectorLoader.active = true;
+                  }
+
+                    Timer {
+                      id: screenDetectorDebounce
+                      running: false
+                      interval: 40
+                      onTriggered: {
+                        Logger.d("CurrentScreenDetector", "Screen debounced to:", root.detectedScreen?.name || "null");
+
+                        // Execute pending callback if any
+                        if (root.pendingCallback) {
+                          if (!root.pendingSkipBarCheck && !Settings.data.general.allowPanelsOnScreenWithoutBar) {
+                            // If we explicitly disabled panels on screen without bar, check if bar is configured
+                            // for this screen, and fallback to primary screen if necessary
+                            var monitors = Settings.data.bar.monitors || [];
+                            const hasBar = monitors.length === 0 || monitors.includes(root.detectedScreen?.name);
+                            if (!hasBar) {
+                              root.detectedScreen = findScreenWithBar();
+                            }
+                          }
+
+                          Logger.d("CurrentScreenDetector", "Executing callback on screen:", root.detectedScreen.name);
+                          // Store callback locally and clear pendingCallback first to prevent deadlock
+                          // if the callback throws an error
+                          var callback = root.pendingCallback;
+                          root.pendingCallback = null;
+                          root.pendingSkipBarCheck = false;
+                          try {
+                            callback(root.detectedScreen);
+                          } catch (e) {
+                            Logger.e("CurrentScreenDetector", "Callback failed:", e);
+                          }
+                        }
+
+                        // Clean up
+                        screenDetectorLoader.active = false;
+                      }
+                    }
+
+                    // Invisible dummy PanelWindow to detect which screen should receive the action
+                    Loader {
+                      id: screenDetectorLoader
+                      active: false
+
+                      sourceComponent: PanelWindow {
+                        implicitWidth: 0
+                        implicitHeight: 0
+                        color: "transparent"
+                        WlrLayershell.exclusionMode: ExclusionMode.Ignore
+                        WlrLayershell.namespace: "noctalia-screen-detector"
+                        mask: Region {}
+
+                        onScreenChanged: root.screenDetected(screen)
+                      }
+                    }
+                  }