Some lockscreen restructure

Modules/Lock/Lock.qml

@@ -8,81 +8,54 @@ import qs.Services
 Item {
     id: root
 
-    function activate() {
+    property string sharedPasswordBuffer: ""
-        loader.activeAsync = true
+    property bool shouldLock: false
-    }
 
     Component.onCompleted: {
-        if (SessionService.loginctlAvailable || SessionService.sessionPath) {
+        IdleService.lockComponent = root
-            if (SessionService.locked || SessionService.lockedHint) {
-                console.log("Lock: Session locked on startup")
-                loader.activeAsync = true
-            }
-        }
     }
 
-    Connections {
+    function activate() {
-        target: IdleService
+        shouldLock = true
-        function onLockRequested() {
-            console.log("Lock: Received lock request from IdleService")
-            loader.activeAsync = true
-        }
     }
 
     Connections {
         target: SessionService
 
         function onSessionLocked() {
-            console.log("Lock: Lock signal received -> show lock")
+            shouldLock = true
-            loader.activeAsync = true
         }
 
         function onSessionUnlocked() {
-            console.log("Lock: Unlock signal received -> hide lock")
+            shouldLock = false
-            loader.active = false
-        }
-
-        function onLoginctlStateChanged() {
-            if (SessionService.lockedHint && !loader.active) {
-                console.log("Lock: LockedHint=true -> show lock")
-                loader.activeAsync = true
-            } else if (!SessionService.locked && !SessionService.lockedHint && loader.active) {
-                console.log("Lock: LockedHint=false -> hide lock")
-                loader.active = false
-            }
-        }
-
-        function onPrepareForSleep() {
-            if (SessionService.preparingForSleep && SessionData.lockBeforeSuspend) {
-                console.log("Lock: PrepareForSleep -> lock before suspend")
-                loader.activeAsync = true
-            }
         }
     }
 
-    LazyLoader {
+    Connections {
-        id: loader
+        target: IdleService
 
-        WlSessionLock {
+        function onLockRequested() {
-            id: sessionLock
+            shouldLock = true
+        }
+    }
 
-            property bool unlocked: false
+    WlSessionLock {
-            property string sharedPasswordBuffer: ""
+        id: sessionLock
 
-            locked: true
+        locked: root.shouldLock
 
-            onLockedChanged: {
+        WlSessionLockSurface {
-                if (!locked) {
+            color: "transparent"
-                    loader.active = false
-                }
-            }
 
             LockSurface {
-                id: lockSurface
+                anchors.fill: parent
                 lock: sessionLock
-                sharedPasswordBuffer: sessionLock.sharedPasswordBuffer
+                sharedPasswordBuffer: root.sharedPasswordBuffer
+                onUnlockRequested: {
+                    root.shouldLock = false
+                }
                 onPasswordChanged: newPassword => {
-                                       sessionLock.sharedPasswordBuffer = newPassword
+                                       root.sharedPasswordBuffer = newPassword
                                    }
             }
         }
@@ -96,17 +69,15 @@ Item {
         target: "lock"
 
         function lock() {
-            console.log("Lock screen requested via IPC")
+            shouldLock = true
-            loader.activeAsync = true
         }
 
         function demo() {
-            console.log("Lock screen DEMO mode requested via IPC")
             demoWindow.showDemo()
         }
 
         function isLocked(): bool {
-            return SessionService.locked || loader.active
+            return sessionLock.locked
         }
     }
 }

Modules/Lock/LockSurface.qml

@@ -4,33 +4,26 @@ import Quickshell
 import Quickshell.Wayland
 import qs.Common
 
-WlSessionLockSurface {
+Rectangle {
     id: root
 
     required property WlSessionLock lock
     required property string sharedPasswordBuffer
 
     signal passwordChanged(string newPassword)
-
+    signal unlockRequested()
-    readonly property bool locked: lock && !lock.locked
-
-    function unlock(): void {
-        lock.locked = false
-    }
 
     color: "transparent"
 
-    Loader {
+    LockScreenContent {
         anchors.fill: parent
-        sourceComponent: LockScreenContent {
+        demoMode: false
-            demoMode: false
+        passwordBuffer: root.sharedPasswordBuffer
-            passwordBuffer: root.sharedPasswordBuffer
+        screenName: ""
-            screenName: root.screen?.name ?? ""
+        onUnlockRequested: root.unlockRequested()
-            onUnlockRequested: root.unlock()
+        onPasswordBufferChanged: {
-            onPasswordBufferChanged: {
+            if (root.sharedPasswordBuffer !== passwordBuffer) {
-                if (root.sharedPasswordBuffer !== passwordBuffer) {
+                root.passwordChanged(passwordBuffer)
-                    root.passwordChanged(passwordBuffer)
-                }
             }
         }
     }

Services/SessionService.qml

@@ -366,6 +366,8 @@ Singleton {
     }
 
     function updateLoginctlState(state) {
+        const wasLocked = locked
+
         sessionId = state.sessionId || ""
         sessionPath = state.sessionPath || ""
         locked = state.locked || false
@@ -384,6 +386,12 @@ Singleton {
             prepareForSleep()
         }
 
+        if (locked && !wasLocked) {
+            sessionLocked()
+        } else if (!locked && wasLocked) {
+            sessionUnlocked()
+        }
+
         loginctlStateChanged()
     }
 
@@ -483,10 +491,4 @@ Singleton {
         }
     }
 
-    Process {
-        id: lockSessionFallback
-        command: ["loginctl", "lock-session"]
-        running: false
-    }
-
 }