Merge branch 'rebuild' of github.com:Ly-sec/Noctalia into rebuild

Services/BrightnessService.qml

@@ -0,0 +1,289 @@
+pragma Singleton
+pragma ComponentBehavior: Bound
+
+import QtQuick
+import Quickshell
+import Quickshell.Io
+
+Singleton {
+  id: root
+
+  property list<var> ddcMonitors: []
+  readonly property list<Monitor> monitors: variants.instances
+  property bool appleDisplayPresent: false
+
+  // Public properties for backward compatibility
+  readonly property real brightness: focusedMonitor ? focusedMonitor.brightness * 100 : Settings.data.brightness.lastBrightness
+  readonly property bool available: focusedMonitor !== null
+  readonly property string currentMethod: focusedMonitor ? focusedMonitor.method : Settings.data.brightness.lastMethod
+  readonly property var detectedDisplays: monitors.map(m => ({
+    name: m.modelData.name,
+    type: m.isDdc ? "external" : "internal",
+    method: m.method,
+    index: m.busNum
+  }))
+
+  // Get the currently focused monitor
+  readonly property Monitor focusedMonitor: {
+    if (monitors.length === 0) return null
+    // For now, return the first monitor. Could be enhanced to detect focused monitor
+    return monitors[0]
+  }
+
+  function getMonitorForScreen(screen: ShellScreen): var {
+    return monitors.find(m => m.modelData === screen)
+  }
+
+  function increaseBrightness(step = null): void {
+    if (focusedMonitor) {
+      var stepSize = step !== null ? step : Settings.data.brightness.brightnessStep
+      focusedMonitor.setBrightness(focusedMonitor.brightness + (stepSize / 100))
+    }
+  }
+
+  function decreaseBrightness(step = null): void {
+    if (focusedMonitor) {
+      var stepSize = step !== null ? step : Settings.data.brightness.brightnessStep
+      focusedMonitor.setBrightness(focusedMonitor.brightness - (stepSize / 100))
+    }
+  }
+
+  function setBrightness(newBrightness: real): void {
+    if (focusedMonitor) {
+      focusedMonitor.setBrightness(newBrightness / 100)
+    }
+  }
+
+  function setBrightnessDebounced(newBrightness: real): void {
+    if (focusedMonitor) {
+      focusedMonitor.setBrightnessDebounced(newBrightness / 100)
+    }
+  }
+
+  // Backward compatibility functions
+  function updateBrightness(): void {
+    // No longer needed with the new architecture
+  }
+
+  function setDisplay(displayIndex: int): bool {
+    // No longer needed with the new architecture
+    return true
+  }
+
+  function getDisplayInfo(): var {
+    return focusedMonitor ? {
+      name: focusedMonitor.modelData.name,
+      type: focusedMonitor.isDdc ? "external" : "internal",
+      method: focusedMonitor.method,
+      index: focusedMonitor.busNum
+    } : null
+  }
+
+  function getAvailableMethods(): list<string> {
+    var methods = []
+    if (monitors.some(m => m.isDdc)) methods.push("ddcutil")
+    if (monitors.some(m => !m.isDdc)) methods.push("internal")
+    if (appleDisplayPresent) methods.push("apple")
+    return methods
+  }
+
+  function getDetectedDisplays(): list<var> {
+    return detectedDisplays
+  }
+
+  reloadableId: "brightness"
+
+  onMonitorsChanged: {
+    ddcMonitors = []
+    ddcProc.running = true
+  }
+
+  Variants {
+    id: variants
+    model: Quickshell.screens
+    Monitor {}
+  }
+
+  // Check for Apple Display support
+  Process {
+    running: true
+    command: ["sh", "-c", "which asdbctl >/dev/null 2>&1 && asdbctl get || echo ''"]
+    stdout: StdioCollector {
+      onStreamFinished: root.appleDisplayPresent = text.trim().length > 0
+    }
+  }
+
+  // Detect DDC monitors
+  Process {
+    id: ddcProc
+    command: ["ddcutil", "detect", "--brief"]
+    stdout: StdioCollector {
+      onStreamFinished: {
+        var displays = text.trim().split("\n\n").filter(d => d.startsWith("Display "))
+        root.ddcMonitors = displays.map(d => {
+          var modelMatch = d.match(/Monitor:.*:(.*):.*/)
+          var busMatch = d.match(/I2C bus:[ ]*\/dev\/i2c-([0-9]+)/)
+          return {
+            model: modelMatch ? modelMatch[1] : "",
+            busNum: busMatch ? busMatch[1] : ""
+          }
+        })
+      }
+    }
+  }
+
+
+
+  component Monitor: QtObject {
+    id: monitor
+
+    required property ShellScreen modelData
+    readonly property bool isDdc: root.ddcMonitors.some(m => m.model === modelData.model)
+    readonly property string busNum: root.ddcMonitors.find(m => m.model === modelData.model)?.busNum ?? ""
+    readonly property bool isAppleDisplay: root.appleDisplayPresent && modelData.model.startsWith("StudioDisplay")
+    readonly property string method: isAppleDisplay ? "apple" : (isDdc ? "ddcutil" : "internal")
+    
+    property real brightness: getStoredBrightness()
+    property real queuedBrightness: NaN
+
+    // Signal for brightness changes
+    signal brightnessUpdated(real newBrightness)
+
+        // Initialize brightness
+    readonly property Process initProc: Process {
+      stdout: StdioCollector {
+        onStreamFinished: {
+          console.log("[BrightnessService] Raw brightness data for", monitor.modelData.name + ":", text.trim())
+          
+          if (monitor.isAppleDisplay) {
+            var val = parseInt(text.trim())
+            if (!isNaN(val)) {
+              monitor.brightness = val / 101
+              console.log("[BrightnessService] Apple display brightness:", monitor.brightness)
+            }
+          } else if (monitor.isDdc) {
+            var parts = text.trim().split(" ")
+            if (parts.length >= 2) {
+              var current = parseInt(parts[0])
+              var max = parseInt(parts[1])
+              if (!isNaN(current) && !isNaN(max) && max > 0) {
+                monitor.brightness = current / max
+                console.log("[BrightnessService] DDC brightness:", current + "/" + max + " =", monitor.brightness)
+              }
+            }
+          } else {
+            // Internal backlight
+            var parts = text.trim().split(" ")
+            if (parts.length >= 2) {
+              var current = parseInt(parts[0])
+              var max = parseInt(parts[1])
+              if (!isNaN(current) && !isNaN(max) && max > 0) {
+                monitor.brightness = current / max
+                console.log("[BrightnessService] Internal brightness:", current + "/" + max + " =", monitor.brightness)
+              }
+            }
+          }
+          
+          if (monitor.brightness > 0) {
+            // Save the detected brightness to settings
+            monitor.saveBrightness(monitor.brightness)
+            monitor.brightnessUpdated(monitor.brightness)
+          }
+        }
+      }
+    }
+
+    // Timer for debouncing rapid changes
+    readonly property Timer timer: Timer {
+      interval: 200
+      onTriggered: {
+        if (!isNaN(monitor.queuedBrightness)) {
+          monitor.setBrightness(monitor.queuedBrightness)
+          monitor.queuedBrightness = NaN
+        }
+      }
+    }
+
+        function getStoredBrightness(): real {
+      // Try to get stored brightness for this specific monitor
+      var stored = Settings.data.brightness.monitorBrightness.find(m => m.name === modelData.name)
+      if (stored) {
+        return stored.brightness / 100
+      }
+      // Fallback to general last brightness
+      return Settings.data.brightness.lastBrightness / 100
+    }
+
+    function saveBrightness(value: real): void {
+      var brightnessPercent = Math.round(value * 100)
+      
+      // Update general last brightness
+      Settings.data.brightness.lastBrightness = brightnessPercent
+      Settings.data.brightness.lastMethod = method
+      
+      // Update monitor-specific brightness
+      var monitorIndex = Settings.data.brightness.monitorBrightness.findIndex(m => m.name === modelData.name)
+      var monitorData = {
+        name: modelData.name,
+        brightness: brightnessPercent,
+        method: method
+      }
+      
+      if (monitorIndex >= 0) {
+        Settings.data.brightness.monitorBrightness[monitorIndex] = monitorData
+      } else {
+        Settings.data.brightness.monitorBrightness.push(monitorData)
+      }
+    }
+
+    function setBrightness(value: real): void {
+      value = Math.max(0, Math.min(1, value))
+      var rounded = Math.round(value * 100)
+      
+      if (Math.round(brightness * 100) === rounded) return
+
+      if (isDdc && timer.running) {
+        queuedBrightness = value
+        return
+      }
+
+      brightness = value
+      brightnessUpdated(brightness)
+      
+      // Save to settings
+      saveBrightness(value)
+
+      if (isAppleDisplay) {
+        Quickshell.execDetached(["asdbctl", "set", rounded])
+      } else if (isDdc) {
+        Quickshell.execDetached(["ddcutil", "-b", busNum, "setvcp", "10", rounded])
+      } else {
+        Quickshell.execDetached(["brightnessctl", "s", rounded + "%"])
+      }
+
+      if (isDdc) {
+        timer.restart()
+      }
+    }
+
+    function setBrightnessDebounced(value: real): void {
+      queuedBrightness = value
+      timer.restart()
+    }
+
+    function initBrightness(): void {
+      if (isAppleDisplay) {
+        initProc.command = ["asdbctl", "get"]
+      } else if (isDdc) {
+        initProc.command = ["ddcutil", "-b", busNum, "getvcp", "10", "--brief"]
+             } else {
+         // Internal backlight - try to find the first available backlight device
+         initProc.command = ["sh", "-c", "for dev in /sys/class/backlight/*; do if [ -f \"$dev/brightness\" ] && [ -f \"$dev/max_brightness\" ]; then echo \"$(cat $dev/brightness) $(cat $dev/max_brightness)\"; break; fi; done"]
+       }
+      initProc.running = true
+    }
+
+    onBusNumChanged: initBrightness()
+    Component.onCompleted: initBrightness()
+  }
+} 

Services/IPCManager.qml

@@ -48,4 +48,16 @@ Item {
       lockScreen.locked = !lockScreen.locked
     }
   }
+
+  IpcHandler {
+    target: "brightness"
+
+    function increase() {
+      BrightnessService.increaseBrightness()
+    }
+
+    function decrease() {
+      BrightnessService.decreaseBrightness()
+    }
+  }
 }

Services/Settings.qml

@@ -177,6 +177,16 @@ Singleton {
         property string fontFamily: "Roboto" // Family for all text
         property list<string> monitorsScale: []
       }
+
+      // brightness
+      property JsonObject brightness
+
+      brightness: JsonObject {
+        property real lastBrightness: 50.0
+        property string lastMethod: "internal"
+        property list<var> monitorBrightness: []
+        property int brightnessStep: 5
+      }
     }
   }
 }