2/n Population and invalidation of closedWindowsCache

#445

Sources/AppBundle/GlobalObserver.swift

@@ -6,11 +6,11 @@ class GlobalObserver {
         if (notification.userInfo?[NSWorkspace.applicationUserInfoKey] as? NSRunningApplication)?.bundleIdentifier == lockScreenAppBundleId {
             return
         }
-        refreshAndLayout()
+        refreshAndLayout(screenIsDefinitelyUnlocked: false)
     }
 
     private static func onHideApp(_ notification: Notification) {
-        refreshSession(body: {
+        refreshSession(screenIsDefinitelyUnlocked: false) {
             if TrayMenuModel.shared.isEnabled && config.automaticallyUnhideMacosHiddenApps {
                 if let w = prevFocus?.windowOrNil,
                    w.macAppUnsafe.nsApp.isHidden,
@@ -26,7 +26,7 @@ class GlobalObserver {
                     app.nsApp.unhide()
                 }
             }
-        })
+        }
     }
 
     static func initObserver() {
@@ -47,12 +47,12 @@ class GlobalObserver {
             switch () {
                 // Detect clicks on desktop of different monitors
                 case _ where clickedMonitor.activeWorkspace != focus.workspace:
-                    _ = refreshSession {
+                    _ = refreshSession(screenIsDefinitelyUnlocked: true) {
                         clickedMonitor.activeWorkspace.focusWorkspace()
                     }
                 // Detect close button clicks for unfocused windows
                 case _ where  focus.windowOrNil?.getRect()?.contains(mouseLocation) == false: // todo replace getRect with preflushRect when it later becomes available
-                    refreshAndLayout()
+                    refreshAndLayout(screenIsDefinitelyUnlocked: true)
                 default:
                     break
             }

Sources/AppBundle/MenuBar.swift

@@ -14,7 +14,7 @@ public func menuBar(viewModel: TrayMenuModel) -> some Scene {
             Text("Workspaces:")
             ForEach(Workspace.all) { (workspace: Workspace) in
                 Button {
-                    refreshSession { _ = workspace.focusWorkspace() }
+                    refreshSession(screenIsDefinitelyUnlocked: true) { _ = workspace.focusWorkspace() }
                 } label: {
                     Toggle(isOn: workspace == focus.workspace
                         ? Binding(get: { true }, set: { _, _ in })
@@ -28,7 +28,7 @@ public func menuBar(viewModel: TrayMenuModel) -> some Scene {
             Divider()
         }
         Button(viewModel.isEnabled ? "Disable" : "Enable") {
-            refreshSession {
+            refreshSession(screenIsDefinitelyUnlocked: true) {
                 _ = EnableCommand(args: EnableCmdArgs(rawArgs: [], targetState: .toggle)).run(.defaultEnv, .emptyStdin)
             }
         }.keyboardShortcut("E", modifiers: .command)
@@ -47,7 +47,7 @@ public func menuBar(viewModel: TrayMenuModel) -> some Scene {
         }.keyboardShortcut("O", modifiers: .command)
         if viewModel.isEnabled {
             Button("Reload config") {
-                refreshSession { _ = reloadConfig() }
+                refreshSession(screenIsDefinitelyUnlocked: true) { _ = reloadConfig() }
             }.keyboardShortcut("R", modifiers: .command)
         }
         Button("Quit \(aeroSpaceAppName)") {

Sources/AppBundle/command/impl/CloseCommand.swift

@@ -13,14 +13,14 @@ struct CloseCommand: Command {
         // Access ax directly. Not cool :(
         if args.quitIfLastWindow && window.macAppUnsafe.axApp.get(Ax.windowsAttr)?.count == 1 {
             if window.macAppUnsafe.nsApp.terminate() {
-                window.asMacWindow().garbageCollect()
+                window.asMacWindow().garbageCollect(skipClosedWindowsCache: true)
                 return true
             } else {
                 return io.err("Failed to quit '\(window.app.name ?? "Unknown app")'")
             }
         } else {
             if window.close() {
-                if !isUnitTest { window.asMacWindow().garbageCollect() }
+                if !isUnitTest { window.asMacWindow().garbageCollect(skipClosedWindowsCache: true) }
                 return true
             } else {
                 return io.err("Can't close '\(window.app.name ?? "Unknown app")' window. Probably the window doesn't have a close button")

Sources/AppBundle/config/HotkeyBinding.swift

@@ -28,7 +28,7 @@ func activateMode(_ targetMode: String?) {
         hotkeys[binding.descriptionWithKeyCode] = HotKey(key: binding.keyCode, modifiers: binding.modifiers, keyDownHandler: {
             check(Thread.current.isMainThread)
             if let activeMode {
-                refreshSession {
+                refreshSession(screenIsDefinitelyUnlocked: true) {
                     _ = config.modes[activeMode]?.bindings[binding.descriptionWithKeyCode]?.commands
                         .runCmdSeq(.defaultEnv, .emptyStdin)
                 }

Sources/AppBundle/initAppBundle.swift

@@ -25,8 +25,8 @@ public func initAppBundle() {
     AXUIElementSetMessagingTimeout(systemWideAx, 1.0)
     startUnixSocketServer()
     GlobalObserver.initObserver()
-    refreshAndLayout(startup: true)
-    refreshSession {
+    refreshAndLayout(screenIsDefinitelyUnlocked: false, startup: true)
+    refreshSession(screenIsDefinitelyUnlocked: false) {
         if serverArgs.startedAtLogin {
             _ = config.afterLoginCommand.runCmdSeq(.defaultEnv, .emptyStdin)
         }

Sources/AppBundle/layout/refresh.swift

@@ -4,8 +4,9 @@ import Common
 /// It's one of the most important function of the whole application.
 /// The function is called as a feedback response on every user input.
 /// The function is idempotent.
-func refreshSession<T>(startup: Bool = false, forceFocus: Bool = false, body: () -> T) -> T {
+func refreshSession<T>(screenIsDefinitelyUnlocked: Bool, startup: Bool = false, forceFocus: Bool = false, body: () -> T) -> T {
     check(Thread.current.isMainThread)
+    if screenIsDefinitelyUnlocked { resetClosedWindowsCache() }
     gc()
     gcMonitors()
 
@@ -38,8 +39,8 @@ func refreshSession<T>(startup: Bool = false, forceFocus: Bool = false, body: ()
     return result
 }
 
-func refreshAndLayout(startup: Bool = false) {
-    refreshSession(startup: startup, body: {})
+func refreshAndLayout(screenIsDefinitelyUnlocked: Bool, startup: Bool = false) {
+    refreshSession(screenIsDefinitelyUnlocked: screenIsDefinitelyUnlocked, startup: startup, body: {})
 }
 
 func refreshModel() {
@@ -66,12 +67,12 @@ func gcWindows() {
     // recovering from unlock
     if toKill.count == MacWindow.allWindowsMap.count { return }
     for window in toKill {
-        window.value.garbageCollect()
+        window.value.garbageCollect(skipClosedWindowsCache: false)
     }
 }
 
 func refreshObs(_ obs: AXObserver, ax: AXUIElement, notif: CFString, data: UnsafeMutableRawPointer?) {
-    refreshAndLayout()
+    refreshAndLayout(screenIsDefinitelyUnlocked: false)
 }
 
 enum OptimalHideCorner {

Sources/AppBundle/mouse/moveWithMouse.swift

@@ -4,7 +4,7 @@ func movedObs(_ obs: AXObserver, ax: AXUIElement, notif: CFString, data: UnsafeM
     if let window = data?.window, TrayMenuModel.shared.isEnabled {
         moveWithMouseIfTheCase(window)
     }
-    refreshAndLayout()
+    refreshAndLayout(screenIsDefinitelyUnlocked: false)
 }
 
 private func moveWithMouseIfTheCase(_ window: Window) { // todo cover with tests
@@ -15,6 +15,7 @@ private func moveWithMouseIfTheCase(_ window: Window) { // todo cover with tests
     {
         return
     }
+    resetClosedWindowsCache()
     switch window.parent.cases {
         case .workspace:
             moveFloatingWindow(window)

Sources/AppBundle/mouse/resizeWithMouse.swift

@@ -5,7 +5,7 @@ func resizedObs(_ obs: AXObserver, ax: AXUIElement, notif: CFString, data: Unsaf
     if let window = data?.window, TrayMenuModel.shared.isEnabled {
         resizeWithMouseIfTheCase(window)
     }
-    refreshAndLayout()
+    refreshAndLayout(screenIsDefinitelyUnlocked: false)
 }
 
 func resetManipulatedWithMouseIfPossible() {
@@ -15,7 +15,7 @@ func resetManipulatedWithMouseIfPossible() {
         for workspace in Workspace.all {
             workspace.resetResizeWeightBeforeResizeRecursive()
         }
-        refreshAndLayout()
+        refreshAndLayout(screenIsDefinitelyUnlocked: true)
     }
 }
 
@@ -29,6 +29,7 @@ private func resizeWithMouseIfTheCase(_ window: Window) { // todo cover with tes
     {
         return
     }
+    resetClosedWindowsCache()
     switch window.parent.cases {
         case .workspace, .macosMinimizedWindowsContainer, .macosFullscreenWindowsContainer,
              .macosPopupWindowsContainer, .macosHiddenAppsWindowsContainer:

Sources/AppBundle/server.swift

@@ -89,7 +89,7 @@ private func newConnection(_ socket: Socket) async { // todo add exit codes
         }
         if let command {
             let _answer: Result<ServerAnswer, Error> = await Task { @MainActor in
-                refreshSession {
+                refreshSession(screenIsDefinitelyUnlocked: false) {
                     let cmdResult = command.run(.defaultEnv, CmdStdin(request.stdin)) // todo pass AEROSPACE_ env vars from CLI instead of defaultEnv
                     return ServerAnswer(
                         exitCode: cmdResult.exitCode,

Sources/AppBundle/tree/MacApp.swift

@@ -34,24 +34,24 @@ final class MacApp: AbstractApp {
                 allAppsMap[pid] = app
                 return app
             } else {
-                app.garbageCollect()
+                app.garbageCollect(skipClosedWindowsCache: true)
                 return nil
             }
         }
     }
 
-    private func garbageCollect() {
+    private func garbageCollect(skipClosedWindowsCache: Bool) {
         MacApp.allAppsMap.removeValue(forKey: nsApp.processIdentifier)
         for obs in axObservers {
             AXObserverRemoveNotification(obs.obs, obs.ax, obs.notif)
         }
-        MacWindow.allWindows.lazy.filter { $0.app == self }.forEach { $0.garbageCollect() }
+        MacWindow.allWindows.lazy.filter { $0.app == self }.forEach { $0.garbageCollect(skipClosedWindowsCache: skipClosedWindowsCache) }
         axObservers = []
     }
 
     static func garbageCollectTerminatedApps() {
         for app in Array(allAppsMap.values) where app.nsApp.isTerminated {
-            app.garbageCollect()
+            app.garbageCollect(skipClosedWindowsCache: true)
         }
     }
 

Sources/AppBundle/tree/MacWindow.swift

@@ -40,7 +40,7 @@ final class MacWindow: Window, CustomStringConvertible {
                 tryOnWindowDetected(window, startup: startup)
                 return window
             } else {
-                window.garbageCollect()
+                window.garbageCollect(skipClosedWindowsCache: true)
                 return nil
             }
         }
@@ -58,7 +58,10 @@ final class MacWindow: Window, CustomStringConvertible {
         return "Window(\(description))"
     }
 
-    func garbageCollect() {
+    // skipClosedWindowsCache is an optimization when it's definitely not necessary to cache closed window.
+    //                        If you are unsure, it's better to pass `false`
+    func garbageCollect(skipClosedWindowsCache: Bool) {
+        if !skipClosedWindowsCache { cacheClosedWindowIfNeeded(window: self) }
         if MacWindow.allWindowsMap.removeValue(forKey: windowId) == nil {
             return
         }
@@ -74,7 +77,8 @@ final class MacWindow: Window, CustomStringConvertible {
         if let workspace, workspace == focus.workspace.name || workspace == prevFocusedWorkspace?.name {
             switch parent.cases {
                 case .tilingContainer, .workspace, .macosHiddenAppsWindowsContainer, .macosFullscreenWindowsContainer:
-                    refreshSession(forceFocus: focus.windowOrNil?.app != app) {
+                    // todo is this refreshSession necessary? garbageCollect should already be called in a refreshSession
+                    refreshSession(screenIsDefinitelyUnlocked: false, forceFocus: focus.windowOrNil?.app != app) {
                         _ = Workspace.get(byName: workspace).focusWorkspace()
                     }
                 case .macosPopupWindowsContainer, .macosMinimizedWindowsContainer:

Sources/AppBundle/tree/frozen/FrozenTree.swift

@@ -141,6 +141,17 @@ private func restoreTreeRecursive(frozenContainer: FrozenContainer, parent: NonL
     }
 }
 
+// Consider the following case:
+// 1. Close window
+// 2. The previous step lead to caching the whole world
+// 3. Change something in the layout
+// 4. Lock the screen
+// 5. The cache won't be updated because all alive windows are already cached
+// 6. Unlock the screen
+// 7. The wrong cache is used
+//
+// That's why we have to reset the cache every time layout changes. The layout can only be changed by running commands
+// and with mouse manipulations
 func resetClosedWindowsCache() {
     closedWindowsCache = FrozenWorld(workspaces: [], monitors: [])
 }