Switched to qmlformat.

2026-08-15 18:43:59 +00:00 · 2025-11-16 17:07:03 -05:00
parent 32905224b9
commit 3ff5b7639f
223 changed files with 9970 additions and 9658 deletions
@@ -27,82 +27,82 @@ Singleton {
  // Choose icon based on charge and charging state
  function getIcon(percent, charging, isReady) {
    if (!isReady) {
-      return "battery-exclamation"
+      return "battery-exclamation";
    }

    if (charging) {
-      return "battery-charging"
+      return "battery-charging";
    } else {
      if (percent >= 90)
-        return "battery-4"
+        return "battery-4";
      if (percent >= 50)
-        return "battery-3"
+        return "battery-3";
      if (percent >= 25)
-        return "battery-2"
+        return "battery-2";
      if (percent >= 0)
-        return "battery-1"
-      return "battery"
+        return "battery-1";
+      return "battery";
    }
  }

  function getThresholdValue(chargingMode) {
    switch (chargingMode) {
    case BatteryService.ChargingMode.Full:
-      return "100"
+      return "100";
    case BatteryService.ChargingMode.Balanced:
-      return "80"
+      return "80";
    case BatteryService.ChargingMode.Lifespan:
-      return "60"
+      return "60";
    }
  }

  function toggleEnabled(enabled) {
    if (enabled) {
-      setChargingMode(BatteryService.ChargingMode.Full)
+      setChargingMode(BatteryService.ChargingMode.Full);
    } else {
-      BatteryService.initialSetter = true
-      ToastService.showNotice(I18n.tr("toast.battery-manager.title"), I18n.tr("toast.battery-manager.uninstall-setup"))
-      PanelService.getPanel("batteryPanel", screen)?.toggle(this)
-      uninstallerProcess.running = true
+      BatteryService.initialSetter = true;
+      ToastService.showNotice(I18n.tr("toast.battery-manager.title"), I18n.tr("toast.battery-manager.uninstall-setup"));
+      PanelService.getPanel("batteryPanel", screen)?.toggle(this);
+      uninstallerProcess.running = true;
    }
  }

  function setChargingMode(newMode) {
    if (newMode !== BatteryService.ChargingMode.Full && newMode !== BatteryService.ChargingMode.Balanced && newMode !== BatteryService.ChargingMode.Lifespan) {
-      Logger.w("BatteryService", `Invalid charging mode set ${newMode}`)
-      return
+      Logger.w("BatteryService", `Invalid charging mode set ${newMode}`);
+      return;
    }
-    BatteryService.chargingMode = newMode
-    BatteryService.applyChargingMode()
+    BatteryService.chargingMode = newMode;
+    BatteryService.applyChargingMode();
  }

  function cycleModes() {
    // Cycles charging modes from full to lifespan while skipping disabled
-    const nextMode = (chargingMode % 3) + 1
-    setChargingMode(nextMode)
+    const nextMode = (chargingMode % 3) + 1;
+    setChargingMode(nextMode);
  }

  function applyChargingMode() {
-    let command = [batterySetterScript]
+    let command = [batterySetterScript];

    // Currently the script sends notifications by default but quickshell
    // uses toast messages so the flag is passed to supress notifs
-    command.push("-q")
+    command.push("-q");

-    command.push(BatteryService.getThresholdValue(BatteryService.chargingMode))
+    command.push(BatteryService.getThresholdValue(BatteryService.chargingMode));

-    setterProcess.command = command
-    setterProcess.running = true
+    setterProcess.command = command;
+    setterProcess.running = true;
  }

  function runInstaller() {
-    installerProcess.command = ["pkexec", batteryInstallerScript]
-    installerProcess.running = true
+    installerProcess.command = ["pkexec", batteryInstallerScript];
+    installerProcess.running = true;
  }

  function init() {
    if (BatteryService.chargingMode !== BatteryService.ChargingMode.Disabled && BatteryService.chargingMode !== BatteryService.ChargingMode.Full) {
-      BatteryService.applyChargingMode()
+      BatteryService.applyChargingMode();
    }
  }

@@ -112,35 +112,35 @@ Singleton {
    running: false
    onExited: (exitCode, exitStatus) => {
      if (exitCode === 0) {
-        Logger.i("BatteryService", "Battery threshold set successfully")
+        Logger.i("BatteryService", "Battery threshold set successfully");
        if (BatteryService.initialSetter) {
-          BatteryService.initialSetter = false
-          return
+          BatteryService.initialSetter = false;
+          return;
        }
        ToastService.showNotice(I18n.tr("toast.battery-manager.title"), I18n.tr("toast.battery-manager.set-success-desc", {
                                                                                  "percent": BatteryService.getThresholdValue(BatteryService.chargingMode)
-                                                                                }), "battery")
-        Settings.data.battery.chargingMode = BatteryService.chargingMode
+                                                                                }), "battery");
+        Settings.data.battery.chargingMode = BatteryService.chargingMode;
      } else if (exitCode === 2) {
-        ToastService.showWarning(I18n.tr("toast.battery-manager.title"), I18n.tr("toast.battery-manager.initial-setup"))
-        PanelService.getPanel("batteryPanel", null)?.toggle(this)
-        BatteryService.runInstaller()
+        ToastService.showWarning(I18n.tr("toast.battery-manager.title"), I18n.tr("toast.battery-manager.initial-setup"));
+        PanelService.getPanel("batteryPanel", null)?.toggle(this);
+        BatteryService.runInstaller();
      } else {
-        ToastService.showError(I18n.tr("toast.battery-manager.title"), I18n.tr("toast.battery-manager.set-failed"))
-        Logger.e("BatteryService", `Setter process failed with exit code: ${exitCode}`)
+        ToastService.showError(I18n.tr("toast.battery-manager.title"), I18n.tr("toast.battery-manager.set-failed"));
+        Logger.e("BatteryService", `Setter process failed with exit code: ${exitCode}`);
      }
    }
    stderr: StdioCollector {
      onStreamFinished: {
        if (this.text) {
-          Logger.w("BatteryService", "SetterProcess stderr:", this.text)
+          Logger.w("BatteryService", "SetterProcess stderr:", this.text);
        }
      }
    }
    stdout: StdioCollector {
      onStreamFinished: {
        if (this.text) {
-          Logger.i("BatteryService", "SetterProcess stdout:", this.text)
+          Logger.i("BatteryService", "SetterProcess stdout:", this.text);
        }
      }
    }
@@ -153,31 +153,31 @@ Singleton {
    running: false
    onExited: (exitCode, exitStatus) => {
      if (exitCode === 0) {
-        ToastService.showNotice(I18n.tr("toast.battery-manager.title"), I18n.tr("toast.battery-manager.install-success"))
-        BatteryService.applyChargingMode()
+        ToastService.showNotice(I18n.tr("toast.battery-manager.title"), I18n.tr("toast.battery-manager.install-success"));
+        BatteryService.applyChargingMode();
      } else if (exitCode === 2) {
-        ToastService.showError(I18n.tr("toast.battery-manager.title"), I18n.tr("toast.battery-manager.install-missing"))
+        ToastService.showError(I18n.tr("toast.battery-manager.title"), I18n.tr("toast.battery-manager.install-missing"));
      } else if (exitCode === 3) {
-        ToastService.showError(I18n.tr("toast.battery-manager.title"), I18n.tr("toast.battery-manager.install-unsupported"))
+        ToastService.showError(I18n.tr("toast.battery-manager.title"), I18n.tr("toast.battery-manager.install-unsupported"));
      } else {
-        ToastService.showError(I18n.tr("toast.battery-manager.title"), I18n.tr("toast.battery-manager.install-failed"))
+        ToastService.showError(I18n.tr("toast.battery-manager.title"), I18n.tr("toast.battery-manager.install-failed"));
      }

      if (exitCode !== 0) {
-        BatteryService.chargingMode = BatteryService.ChargingMode.Disabled
+        BatteryService.chargingMode = BatteryService.ChargingMode.Disabled;
      }
    }
    stderr: StdioCollector {
      onStreamFinished: {
        if (this.text) {
-          Logger.w("BatteryService", "InstallerProcess stderr:", this.text)
+          Logger.w("BatteryService", "InstallerProcess stderr:", this.text);
        }
      }
    }
    stdout: StdioCollector {
      onStreamFinished: {
        if (this.text) {
-          Logger.i("BatteryService", "InstallerProcess stdout:", this.text)
+          Logger.i("BatteryService", "InstallerProcess stdout:", this.text);
        }
      }
    }
@@ -190,27 +190,27 @@ Singleton {
    running: false
    onExited: (exitCode, exitStatus) => {
      if (exitCode === 0) {
-        Logger.i("BatteryService", "Battery Manager uninstalled successfully")
-        ToastService.showNotice(I18n.tr("toast.battery-manager.title"), I18n.tr("toast.battery-manager.uninstall-success"))
-        Settings.data.battery.chargingMode = BatteryService.chargingMode
-        BatteryService.chargingMode = BatteryService.ChargingMode.Disabled
-        cleanupProcess.running = true
+        Logger.i("BatteryService", "Battery Manager uninstalled successfully");
+        ToastService.showNotice(I18n.tr("toast.battery-manager.title"), I18n.tr("toast.battery-manager.uninstall-success"));
+        Settings.data.battery.chargingMode = BatteryService.chargingMode;
+        BatteryService.chargingMode = BatteryService.ChargingMode.Disabled;
+        cleanupProcess.running = true;
      } else {
-        ToastService.showError(I18n.tr("toast.battery-manager.title"), I18n.tr("toast.battery-manager.uninstall-failed"))
-        Logger.e("BatteryService", `Uninstaller process failed with exit code: ${exitCode}`)
+        ToastService.showError(I18n.tr("toast.battery-manager.title"), I18n.tr("toast.battery-manager.uninstall-failed"));
+        Logger.e("BatteryService", `Uninstaller process failed with exit code: ${exitCode}`);
      }
    }
    stderr: StdioCollector {
      onStreamFinished: {
        if (this.text) {
-          Logger.w("BatteryService", "UninstallerProcess stderr:", this.text)
+          Logger.w("BatteryService", "UninstallerProcess stderr:", this.text);
        }
      }
    }
    stdout: StdioCollector {
      onStreamFinished: {
        if (this.text) {
-          Logger.i("BatteryService", "UninstallerProcess stdout:", this.text)
+          Logger.i("BatteryService", "UninstallerProcess stdout:", this.text);
        }
      }
    }
@@ -224,22 +224,22 @@ Singleton {
    running: false
    onExited: (exitCode, exitStatus) => {
      if (exitCode === 0) {
-        Logger.i("BatteryService", "Battery Manager uninstalled successfully")
+        Logger.i("BatteryService", "Battery Manager uninstalled successfully");
      } else {
-        Logger.e("BatteryService", `Cleanup process failed with exit code: ${exitCode}`)
+        Logger.e("BatteryService", `Cleanup process failed with exit code: ${exitCode}`);
      }
    }
    stderr: StdioCollector {
      onStreamFinished: {
        if (this.text) {
-          Logger.w("BatteryService", "CleanupProcess stderr:", this.text)
+          Logger.w("BatteryService", "CleanupProcess stderr:", this.text);
        }
      }
    }
    stdout: StdioCollector {
      onStreamFinished: {
        if (this.text) {
-          Logger.i("BatteryService", "CleanupProcess stdout:", this.text)
+          Logger.i("BatteryService", "CleanupProcess stdout:", this.text);
        }
      }
    }
@@ -13,49 +13,49 @@ Singleton {
  property bool appleDisplayPresent: false

  function getMonitorForScreen(screen: ShellScreen): var {
-    return monitors.find(m => m.modelData === screen)
+    return monitors.find(m => m.modelData === screen);
  }

  // Signal emitted when a specific monitor's brightness changes, includes monitor context
  signal monitorBrightnessChanged(var monitor, real newBrightness)

  function getAvailableMethods(): list<string> {
-    var methods = []
+    var methods = [];
    if (Settings.data.brightness.enableDdcSupport && monitors.some(m => m.isDdc))
-      methods.push("ddcutil")
+      methods.push("ddcutil");
    if (monitors.some(m => !m.isDdc))
-      methods.push("internal")
+      methods.push("internal");
    if (appleDisplayPresent)
-      methods.push("apple")
-    return methods
+      methods.push("apple");
+    return methods;
  }

  // Global helpers for IPC and shortcuts
  function increaseBrightness(): void {
-    monitors.forEach(m => m.increaseBrightness())
+    monitors.forEach(m => m.increaseBrightness());
  }

  function decreaseBrightness(): void {
-    monitors.forEach(m => m.decreaseBrightness())
+    monitors.forEach(m => m.decreaseBrightness());
  }

  function getDetectedDisplays(): list<var> {
-    return detectedDisplays
+    return detectedDisplays;
  }

  reloadableId: "brightness"

  Component.onCompleted: {
-    Logger.i("Brightness", "Service started")
+    Logger.i("Brightness", "Service started");
    if (Settings.data.brightness.enableDdcSupport) {
-      ddcProc.running = true
+      ddcProc.running = true;
    }
  }

  onMonitorsChanged: {
-    ddcMonitors = []
+    ddcMonitors = [];
    if (Settings.data.brightness.enableDdcSupport) {
-      ddcProc.running = true
+      ddcProc.running = true;
    }
  }

@@ -64,11 +64,11 @@ Singleton {
    function onEnableDdcSupportChanged() {
      if (Settings.data.brightness.enableDdcSupport) {
        // Re-detect DDC monitors when enabled
-        ddcMonitors = []
-        ddcProc.running = true
+        ddcMonitors = [];
+        ddcProc.running = true;
      } else {
        // Clear DDC monitors when disabled
-        ddcMonitors = []
+        ddcMonitors = [];
      }
    }
  }
@@ -95,23 +95,22 @@ Singleton {
    command: ["ddcutil", "detect", "--sleep-multiplier=0.5"]
    stdout: StdioCollector {
      onStreamFinished: {
-        var displays = text.trim().split("\n\n")
+        var displays = text.trim().split("\n\n");
        ddcProc.ddcMonitors = displays.map(d => {
-
-                                             var ddcModelMatch = d.match(/(This monitor does not support DDC\/CI|Invalid display)/)
-                                             var modelMatch = d.match(/Model:\s*(.*)/)
-                                             var busMatch = d.match(/I2C bus:[ ]*\/dev\/i2c-([0-9]+)/)
-                                             var ddcModel = ddcModelMatch ? ddcModelMatch.length > 0 : false
-                                             var model = modelMatch ? modelMatch[1] : "Unknown"
-                                             var bus = busMatch ? busMatch[1] : "Unknown"
-                                             Logger.i("Brigthness", "Detected DDC Monitor:", model, "on bus", bus, "is DDC:", !ddcModel)
+                                             var ddcModelMatch = d.match(/(This monitor does not support DDC\/CI|Invalid display)/);
+                                             var modelMatch = d.match(/Model:\s*(.*)/);
+                                             var busMatch = d.match(/I2C bus:[ ]*\/dev\/i2c-([0-9]+)/);
+                                             var ddcModel = ddcModelMatch ? ddcModelMatch.length > 0 : false;
+                                             var model = modelMatch ? modelMatch[1] : "Unknown";
+                                             var bus = busMatch ? busMatch[1] : "Unknown";
+                                             Logger.i("Brigthness", "Detected DDC Monitor:", model, "on bus", bus, "is DDC:", !ddcModel);
                                             return {
                                               "model": model,
                                               "busNum": bus,
                                               "isDdc": !ddcModel
-                                             }
-                                           })
-        root.ddcMonitors = ddcProc.ddcMonitors.filter(m => m.isDdc)
+                                             };
+                                           });
+        root.ddcMonitors = ddcProc.ddcMonitors.filter(m => m.isDdc);
      }
    }
  }
@@ -128,11 +127,11 @@ Singleton {
    // Check if brightness control is available for this monitor
    readonly property bool brightnessControlAvailable: {
      if (isAppleDisplay)
-      return true
+      return true;
      if (isDdc)
-      return true
+      return true;
      // For internal displays, check if we have a brightness path
-      return brightnessPath !== ""
+      return brightnessPath !== "";
    }

    property real brightness
@@ -153,23 +152,23 @@ Singleton {
    readonly property Process refreshProc: Process {
      stdout: StdioCollector {
        onStreamFinished: {
-          var dataText = text.trim()
+          var dataText = text.trim();
          if (dataText === "") {
-            return
+            return;
          }

-          var lines = dataText.split("\n")
+          var lines = dataText.split("\n");
          if (lines.length >= 2) {
-            var current = parseInt(lines[0].trim())
-            var max = parseInt(lines[1].trim())
+            var current = parseInt(lines[0].trim());
+            var max = parseInt(lines[1].trim());
            if (!isNaN(current) && !isNaN(max) && max > 0) {
-              var newBrightness = current / max
+              var newBrightness = current / max;
              // Only update if it's actually different (avoid feedback loops)
              if (Math.abs(newBrightness - monitor.brightness) > 0.01) {
                // Update internal value to match system state
-                monitor.brightness = newBrightness
-                monitor.brightnessUpdated(monitor.brightness)
-                root.monitorBrightnessChanged(monitor, monitor.brightness)
+                monitor.brightness = newBrightness;
+                monitor.brightnessUpdated(monitor.brightness);
+                root.monitorBrightnessChanged(monitor, monitor.brightness);
                //Logger.i("Brightness", "Refreshed brightness from system:", monitor.modelData.name, monitor.brightness)
              }
            }
@@ -182,16 +181,16 @@ Singleton {
    function refreshBrightnessFromSystem() {
      if (!monitor.isDdc && !monitor.isAppleDisplay) {
        // For internal displays, query the system directly
-        refreshProc.command = ["sh", "-c", "cat " + monitor.brightnessPath + " && " + "cat " + monitor.maxBrightnessPath]
-        refreshProc.running = true
+        refreshProc.command = ["sh", "-c", "cat " + monitor.brightnessPath + " && " + "cat " + monitor.maxBrightnessPath];
+        refreshProc.running = true;
      } else if (monitor.isDdc) {
        // For DDC displays, get the current value
-        refreshProc.command = ["ddcutil", "-b", monitor.busNum, "getvcp", "10", "--brief"]
-        refreshProc.running = true
+        refreshProc.command = ["ddcutil", "-b", monitor.busNum, "getvcp", "10", "--brief"];
+        refreshProc.running = true;
      } else if (monitor.isAppleDisplay) {
        // For Apple displays, get the current value
-        refreshProc.command = ["asdbctl", "get"]
-        refreshProc.running = true
+        refreshProc.command = ["asdbctl", "get"];
+        refreshProc.running = true;
      }
    }

@@ -205,8 +204,8 @@ Singleton {
        // When a file change is detected, actively refresh from system
        // to ensure we get the most up-to-date value
        Qt.callLater(() => {
-                       monitor.refreshBrightnessFromSystem()
-                     })
+                       monitor.refreshBrightnessFromSystem();
+                     });
      }
    }

@@ -214,50 +213,50 @@ Singleton {
    readonly property Process initProc: Process {
      stdout: StdioCollector {
        onStreamFinished: {
-          var dataText = text.trim()
+          var dataText = text.trim();
          if (dataText === "") {
-            return
+            return;
          }

          //Logger.i("Brightness", "Raw brightness data for", monitor.modelData.name + ":", dataText)
          if (monitor.isAppleDisplay) {
-            var val = parseInt(dataText)
+            var val = parseInt(dataText);
            if (!isNaN(val)) {
-              monitor.brightness = val / 101
-              Logger.d("Brightness", "Apple display brightness:", monitor.brightness)
+              monitor.brightness = val / 101;
+              Logger.d("Brightness", "Apple display brightness:", monitor.brightness);
            }
          } else if (monitor.isDdc) {
-            var parts = dataText.split(" ")
+            var parts = dataText.split(" ");
            if (parts.length >= 4) {
-              var current = parseInt(parts[3])
-              var max = parseInt(parts[4])
+              var current = parseInt(parts[3]);
+              var max = parseInt(parts[4]);
              if (!isNaN(current) && !isNaN(max) && max > 0) {
-                monitor.brightness = current / max
-                Logger.d("Brightness", "DDC brightness:", current + "/" + max + " =", monitor.brightness)
+                monitor.brightness = current / max;
+                Logger.d("Brightness", "DDC brightness:", current + "/" + max + " =", monitor.brightness);
              }
            }
          } else {
            // Internal backlight - parse the response which includes device path
-            var lines = dataText.split("\n")
+            var lines = dataText.split("\n");
            if (lines.length >= 3) {
-              monitor.backlightDevice = lines[0]
-              monitor.brightnessPath = monitor.backlightDevice + "/brightness"
-              monitor.maxBrightnessPath = monitor.backlightDevice + "/max_brightness"
+              monitor.backlightDevice = lines[0];
+              monitor.brightnessPath = monitor.backlightDevice + "/brightness";
+              monitor.maxBrightnessPath = monitor.backlightDevice + "/max_brightness";

-              var current = parseInt(lines[1])
-              var max = parseInt(lines[2])
+              var current = parseInt(lines[1]);
+              var max = parseInt(lines[2]);
              if (!isNaN(current) && !isNaN(max) && max > 0) {
-                monitor.maxBrightness = max
-                monitor.brightness = current / max
-                Logger.d("Brightness", "Internal brightness:", current + "/" + max + " =", monitor.brightness)
-                Logger.d("Brightness", "Using backlight device:", monitor.backlightDevice)
+                monitor.maxBrightness = max;
+                monitor.brightness = current / max;
+                Logger.d("Brightness", "Internal brightness:", current + "/" + max + " =", monitor.brightness);
+                Logger.d("Brightness", "Using backlight device:", monitor.backlightDevice);
              }
            }
          }

          // Always update
-          monitor.brightnessUpdated(monitor.brightness)
-          root.monitorBrightnessChanged(monitor, monitor.brightness)
+          monitor.brightnessUpdated(monitor.brightness);
+          root.monitorBrightnessChanged(monitor, monitor.brightness);
        }
      }
    }
@@ -270,74 +269,74 @@ Singleton {
      interval: 100
      onTriggered: {
        if (!isNaN(monitor.queuedBrightness)) {
-          monitor.setBrightness(monitor.queuedBrightness)
-          monitor.queuedBrightness = NaN
+          monitor.setBrightness(monitor.queuedBrightness);
+          monitor.queuedBrightness = NaN;
        }
      }
    }

    function setBrightnessDebounced(value: real): void {
-      monitor.queuedBrightness = value
-      timer.start()
+      monitor.queuedBrightness = value;
+      timer.start();
    }

    function increaseBrightness(): void {
-      const value = !isNaN(monitor.queuedBrightness) ? monitor.queuedBrightness : monitor.brightness
+      const value = !isNaN(monitor.queuedBrightness) ? monitor.queuedBrightness : monitor.brightness;
      // Enforce minimum brightness if enabled
      if (Settings.data.brightness.enforceMinimum && value <= minBrightnessValue) {
-        setBrightnessDebounced(Math.max(stepSize, minBrightnessValue))
+        setBrightnessDebounced(Math.max(stepSize, minBrightnessValue));
      } else {
        // Normal brightness increase
-        setBrightnessDebounced(value + stepSize)
+        setBrightnessDebounced(value + stepSize);
      }
    }

    function decreaseBrightness(): void {
-      const value = !isNaN(monitor.queuedBrightness) ? monitor.queuedBrightness : monitor.brightness
-      setBrightnessDebounced(value - stepSize)
+      const value = !isNaN(monitor.queuedBrightness) ? monitor.queuedBrightness : monitor.brightness;
+      setBrightnessDebounced(value - stepSize);
    }

    function setBrightness(value: real): void {
-      value = Math.max(minBrightnessValue, Math.min(1, value))
-      var rounded = Math.round(value * 100)
+      value = Math.max(minBrightnessValue, Math.min(1, value));
+      var rounded = Math.round(value * 100);

      if (timer.running) {
-        monitor.queuedBrightness = value
-        return
+        monitor.queuedBrightness = value;
+        return;
      }

      // Update internal value and trigger UI feedback
-      monitor.brightness = value
-      monitor.brightnessUpdated(value)
-      root.monitorBrightnessChanged(monitor, monitor.brightness)
+      monitor.brightness = value;
+      monitor.brightnessUpdated(value);
+      root.monitorBrightnessChanged(monitor, monitor.brightness);

      if (isAppleDisplay) {
-        monitor.ignoreNextChange = true
-        Quickshell.execDetached(["asdbctl", "set", rounded])
+        monitor.ignoreNextChange = true;
+        Quickshell.execDetached(["asdbctl", "set", rounded]);
      } else if (isDdc) {
-        monitor.ignoreNextChange = true
-        Quickshell.execDetached(["ddcutil", "-b", busNum, "setvcp", "10", rounded])
+        monitor.ignoreNextChange = true;
+        Quickshell.execDetached(["ddcutil", "-b", busNum, "setvcp", "10", rounded]);
      } else {
-        monitor.ignoreNextChange = true
-        Quickshell.execDetached(["brightnessctl", "s", rounded + "%"])
+        monitor.ignoreNextChange = true;
+        Quickshell.execDetached(["brightnessctl", "s", rounded + "%"]);
      }

      if (isDdc) {
-        timer.restart()
+        timer.restart();
      }
    }

    function initBrightness(): void {
      if (isAppleDisplay) {
-        initProc.command = ["asdbctl", "get"]
+        initProc.command = ["asdbctl", "get"];
      } else if (isDdc) {
-        initProc.command = ["ddcutil", "-b", busNum, "getvcp", "10", "--brief"]
+        initProc.command = ["ddcutil", "-b", busNum, "getvcp", "10", "--brief"];
      } else {
        // Internal backlight - find the first available backlight device and get its info
        // This now returns: device_path, current_brightness, max_brightness (on separate lines)
-        initProc.command = ["sh", "-c", "for dev in /sys/class/backlight/*; do " + "  if [ -f \"$dev/brightness\" ] && [ -f \"$dev/max_brightness\" ]; then " + "    echo \"$dev\"; " + "    cat \"$dev/brightness\"; " + "    cat \"$dev/max_brightness\"; " + "    break; " + "  fi; " + "done"]
+        initProc.command = ["sh", "-c", "for dev in /sys/class/backlight/*; do " + "  if [ -f \"$dev/brightness\" ] && [ -f \"$dev/max_brightness\" ]; then " + "    echo \"$dev\"; " + "    cat \"$dev/brightness\"; " + "    cat \"$dev/max_brightness\"; " + "    break; " + "  fi; " + "done"];
      }
-      initProc.running = true
+      initProc.running = true;
    }

    onBusNumChanged: initBrightness()