Some lockscreen restructure

Modules/Lock/Lock.qml

@@ -8,81 +8,54 @@ import qs.Services
 Item {
     id: root
 
-    function activate() {
-        loader.activeAsync = true
-    }
+    property string sharedPasswordBuffer: ""
+    property bool shouldLock: false
 
     Component.onCompleted: {
-        if (SessionService.loginctlAvailable || SessionService.sessionPath) {
-            if (SessionService.locked || SessionService.lockedHint) {
-                console.log("Lock: Session locked on startup")
-                loader.activeAsync = true
-            }
-        }
+        IdleService.lockComponent = root
     }
 
-    Connections {
-        target: IdleService
-        function onLockRequested() {
-            console.log("Lock: Received lock request from IdleService")
-            loader.activeAsync = true
-        }
+    function activate() {
+        shouldLock = true
     }
 
     Connections {
         target: SessionService
 
         function onSessionLocked() {
-            console.log("Lock: Lock signal received -> show lock")
-            loader.activeAsync = true
+            shouldLock = true
         }
 
         function onSessionUnlocked() {
-            console.log("Lock: Unlock signal received -> hide lock")
-            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
+            shouldLock = false
         }
     }
 
-        function onPrepareForSleep() {
-            if (SessionService.preparingForSleep && SessionData.lockBeforeSuspend) {
-                console.log("Lock: PrepareForSleep -> lock before suspend")
-                loader.activeAsync = true
-            }
-        }
-    }
+    Connections {
+        target: IdleService
 
-    LazyLoader {
-        id: loader
+        function onLockRequested() {
+            shouldLock = true
+        }
+    }
 
     WlSessionLock {
         id: sessionLock
 
-            property bool unlocked: false
-            property string sharedPasswordBuffer: ""
+        locked: root.shouldLock
 
-            locked: true
-
-            onLockedChanged: {
-                if (!locked) {
-                    loader.active = false
-                }
-            }
+        WlSessionLockSurface {
+            color: "transparent"
 
             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")
-            loader.activeAsync = true
+            shouldLock = 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,34 +4,27 @@ import Quickshell
 import Quickshell.Wayland
 import qs.Common
 
-WlSessionLockSurface {
+Rectangle {
     id: root
 
     required property WlSessionLock lock
     required property string sharedPasswordBuffer
 
     signal passwordChanged(string newPassword)
-
-    readonly property bool locked: lock && !lock.locked
-
-    function unlock(): void {
-        lock.locked = false
-    }
+    signal unlockRequested()
 
     color: "transparent"
 
-    Loader {
+    LockScreenContent {
         anchors.fill: parent
-        sourceComponent: LockScreenContent {
         demoMode: false
         passwordBuffer: root.sharedPasswordBuffer
-            screenName: root.screen?.name ?? ""
-            onUnlockRequested: root.unlock()
+        screenName: ""
+        onUnlockRequested: root.unlockRequested()
         onPasswordBufferChanged: {
             if (root.sharedPasswordBuffer !== 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
-    }
-
 }