From e32622ac48dca960753fcb253ae3d7b550bad688 Mon Sep 17 00:00:00 2001
From: bbedward <bbedward@gmail.com>
Date: Thu, 9 Oct 2025 11:30:02 -0400
Subject: [PATCH] Some lockscreen restructure

---
 Modules/Lock/Lock.qml        | 81 ++++++++++++------------------------
 Modules/Lock/LockSurface.qml | 27 +++++-------
 Services/SessionService.qml  | 14 ++++---
 3 files changed, 44 insertions(+), 78 deletions(-)

diff --git a/Modules/Lock/Lock.qml b/Modules/Lock/Lock.qml
index 208cd483..4d3e9745 100644
--- a/Modules/Lock/Lock.qml
+++ b/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
-            }
-        }
-
-        function onPrepareForSleep() {
-            if (SessionService.preparingForSleep && SessionData.lockBeforeSuspend) {
-                console.log("Lock: PrepareForSleep -> lock before suspend")
-                loader.activeAsync = true
-            }
+            shouldLock = false
         }
     }
 
-    LazyLoader {
-        id: loader
+    Connections {
+        target: IdleService
 
-        WlSessionLock {
-            id: sessionLock
+        function onLockRequested() {
+            shouldLock = true
+        }
+    }
 
-            property bool unlocked: false
-            property string sharedPasswordBuffer: ""
+    WlSessionLock {
+        id: sessionLock
 
-            locked: true
+        locked: root.shouldLock
 
-            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
         }
     }
 }
diff --git a/Modules/Lock/LockSurface.qml b/Modules/Lock/LockSurface.qml
index 77ca4a9b..414aa13d 100644
--- a/Modules/Lock/LockSurface.qml
+++ b/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)
-
-    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()
-            onPasswordBufferChanged: {
-                if (root.sharedPasswordBuffer !== passwordBuffer) {
-                    root.passwordChanged(passwordBuffer)
-                }
+        demoMode: false
+        passwordBuffer: root.sharedPasswordBuffer
+        screenName: ""
+        onUnlockRequested: root.unlockRequested()
+        onPasswordBufferChanged: {
+            if (root.sharedPasswordBuffer !== passwordBuffer) {
+                root.passwordChanged(passwordBuffer)
             }
         }
     }
diff --git a/Services/SessionService.qml b/Services/SessionService.qml
index 699ad576..e97bbe87 100644
--- a/Services/SessionService.qml
+++ b/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
-    }
-
 }