5/n WIP! Convert TreeNode.workspace to nillable

Because not all windows have an assigned workspace (macOS hidden
windows, sticky windows in the future)

#18

src/command/CloseAllWindowsButCurrentCommand.swift

@@ -10,7 +10,11 @@ struct CloseAllWindowsButCurrentCommand: Command {
             return false
         }
         var result = true
-        for window in focused.workspace.allLeafWindowsRecursive {
+        guard let workspace = focused.workspace else {
+            state.stderr.append("Focused window '\(focused.title)'")
+            return false
+        }
+        for window in workspace.allLeafWindowsRecursive {
             if window != focused {
                 state.subject = .window(window)
                 result = CloseCommand(args: args.closeArgs).run(state) && result

src/command/Command.swift

@@ -83,7 +83,7 @@ extension CommandSubject {
     var workspace: Workspace {
         switch self {
         case .window(let window):
-            return window.workspace
+            return window.nodeMonitor?.activeWorkspace ?? Workspace.focused
         case .emptyWorkspace(let workspaceName):
             return Workspace.get(byName: workspaceName)
         }

src/command/FocusCommand.swift

@@ -109,7 +109,7 @@ private func makeFloatingWindowsSeenAsTiling(workspace: Workspace) -> [FloatingW
             let center = window.isMacosFullscreen ? workspace.monitor.rect.topLeftCorner : window.getCenter()
             guard let center else { return nil }
             // todo bug: what if there are no tiling windows on the workspace?
-            guard let target = center.coerceIn(rect: window.workspace.monitor.visibleRectPaddedByOuterGaps).findIn(tree: workspace.rootTilingContainer, virtual: true) else { return nil }
+            guard let target = center.coerceIn(rect: workspace.monitor.visibleRectPaddedByOuterGaps).findIn(tree: workspace.rootTilingContainer, virtual: true) else { return nil }
             guard let targetCenter = target.getCenter() else { return nil }
             guard let tilingParent = target.parent as? TilingContainer else { return nil }
             let index = center.getProjection(tilingParent.orientation) >= targetCenter.getProjection(tilingParent.orientation)

src/command/LayoutCommand.swift

@@ -36,21 +36,19 @@ struct LayoutCommand: Command {
                 return false
             case .tilingContainer:
                 return true // Nothing to do
-            case .workspace:
+            case .workspace(let workspace):
                 window.lastFloatingSize = window.getSize() ?? window.lastFloatingSize
-                let data = getBindingDataForNewTilingWindow(window.unbindFromParent().parent.workspace)
+                window.unbindFromParent()
+                let data = getBindingDataForNewTilingWindow(workspace)
                 window.bind(to: data.parent, adaptiveWeight: data.adaptiveWeight, index: data.index)
                 return true
             }
         case .floating:
-            let workspace = window.unbindFromParent().parent.workspace
+            let workspace = state.subject.workspace // Capture workspace before unbind ID-1A4CF7C5
+            window.unbindFromParent() // ID-1A4CF7C5
             window.bindAsFloatingWindow(to: workspace)
             guard let topLeftCorner = window.getTopLeftCorner() else { return false }
-            let offset = CGPoint(
-                x: abs(topLeftCorner.x - workspace.monitor.rect.topLeftX).takeIf { $0 < 30 } ?? 0,
-                y: abs(topLeftCorner.y - workspace.monitor.rect.topLeftY).takeIf { $0 < 30 } ?? 0
-            )
-            return window.setFrame(topLeftCorner + offset, window.lastFloatingSize)
+            return window.setFrame(topLeftCorner, window.lastFloatingSize)
         }
     }
 }

src/command/MacosNativeFullscreenCommand.swift

@@ -1,6 +1,11 @@
 import Common
 
-struct MacosNativeFullscreenCommand: Command {
+/// Problem B6E178F2: It's not first-class citizen command in AeroSpace model, since it interacts with macOS API directly.
+/// Consecutive macos-native-fullscreen commands may not works as expected (because macOS may report correct state with a
+/// delay), or may flicker
+///
+/// The same applies to macos-native-minimize command
+struct MacosNativeFullscreenCommand: Command { // todo only allow as the latest command in sequence
     let args: MacosNativeFullscreenCmdArgs
 
     func _run(_ state: CommandMutableState, stdin: String) -> Bool {
@@ -12,6 +17,7 @@ struct MacosNativeFullscreenCommand: Command {
         let axWindow = window.asMacWindow().axWindow
         let success = axWindow.set(Ax.isFullscreenAttr, !window.isMacosFullscreen)
         if !success { state.stderr.append("Failed") }
+        // todo attach or detach to appropriate parent
         return success
     }
 }

src/command/MacosNativeMinimizeCommand.swift

@@ -1,5 +1,6 @@
 import Common
 
+/// See: MacosNativeFullscreenCommand. Problem B6E178F2
 struct MacosNativeMinimizeCommand: Command {
     let args: MacosNativeMinimizeCmdArgs
 

src/command/MoveCommand.swift

@@ -57,7 +57,7 @@ private func moveOut(_ state: CommandMutableState, window: Window, direction: Ca
     case .workspace(let parent): // create implicit container
         let prevRoot = parent.rootTilingContainer
         prevRoot.unbindFromParent()
-        // Force list layout
+        // Force tiles layout
         _ = TilingContainer(parent: parent, adaptiveWeight: WEIGHT_AUTO, direction.orientation, .tiles, index: 0)
         check(prevRoot != parent.rootTilingContainer)
         prevRoot.bind(to: parent.rootTilingContainer, adaptiveWeight: WEIGHT_AUTO, index: 0)

src/command/MoveNodeToWorkspaceCommand.swift

@@ -8,21 +8,21 @@ struct MoveNodeToWorkspaceCommand: Command {
             state.stderr.append(noWindowIsFocused)
             return false
         }
-        let preserveWorkspace = focused.workspace
+        let prevWorkspace = focused.workspace ?? Workspace.focused
         let targetWorkspace: Workspace
         switch args.target {
         case .relative(let relative):
-            guard let workspace = getNextPrevWorkspace(current: state.subject.workspace, relative: relative, stdin: stdin) else { return false }
+            guard let workspace = getNextPrevWorkspace(current: prevWorkspace, relative: relative, stdin: stdin) else { return false }
             targetWorkspace = workspace
         case .direct(let direct):
             targetWorkspace = Workspace.get(byName: direct.name.raw)
         }
-        if preserveWorkspace == targetWorkspace {
+        if prevWorkspace == targetWorkspace {
             return true
         }
         let targetContainer: NonLeafTreeNodeObject = focused.isFloating ? targetWorkspace : targetWorkspace.rootTilingContainer
         focused.unbindFromParent()
         focused.bind(to: targetContainer, adaptiveWeight: WEIGHT_AUTO, index: INDEX_BIND_LAST)
-        return WorkspaceCommand.run(state, preserveWorkspace.name)
+        return WorkspaceCommand.run(state, prevWorkspace.name)
     }
 }

src/command/MoveWorkspaceToMonitorCommand.swift

@@ -5,7 +5,7 @@ struct MoveWorkspaceToMonitorCommand: Command {
 
     func _run(_ state: CommandMutableState, stdin: String) -> Bool {
         check(Thread.current.isMainThread)
-        let focusedWorkspace = state.subject.workspace
+        let focusedWorkspace = state.subject.workspace ?? Workspace.focused
         let prevMonitor = focusedWorkspace.monitor
         let sortedMonitors = sortedMonitors
         guard let index = sortedMonitors.firstIndex(where: { $0.rect.topLeftCorner == prevMonitor.rect.topLeftCorner }) else { return false }

src/command/query/DebugWindowsCommand.swift

@@ -81,7 +81,8 @@ func debugWindowsIfRecording(_ window: Window) {
     var result: [String] = []
 
     result.append("\(windowPrefix) windowId: \(window.windowId)")
-    result.append("\(windowPrefix) workspace: \(window.workspace.name)")
+    result.append("\(windowPrefix) workspace: \(window.workspace?.name ?? "nil")")
+    result.append("\(windowPrefix) treeNodeParent: \(window.parent)")
     result.append("\(windowPrefix) recognizedAsDialog: \(shouldFloat(window.axWindow, app))")
     result.append(dumpAx(window.axWindow, windowPrefix, .window))
 

src/command/query/ListWindowsCommand.swift

@@ -51,7 +51,7 @@ struct ListWindowsCommand: Command {
         }
         state.stdout += windows
             .map { window in
-                [String(window.windowId), window.app.name ?? "NULL-APP-NAME", window.title ?? "NULL-TITLE"]
+                [String(window.windowId), window.app.name ?? "NULL-APP-NAME", window.title]
             }
             .toPaddingTable()
         return true

src/config/parseConfig.swift

@@ -151,6 +151,7 @@ private extension ParsedCmd where T == any Command {
     }
 }
 
+// todo Problem B6E178F2. Make macos-native* commands to be the last commands in the sequence
 func parseCommandOrCommands(_ raw: TOMLValueConvertible) -> Parsed<[any Command]> {
     if let rawString = raw.string {
         return parseCommand(rawString).toEither().map { [$0] }

src/mouse/moveWithMouse.swift

@@ -35,7 +35,7 @@ private func moveTilingWindow(_ window: Window) {
     window.lastAppliedLayoutPhysicalRect = nil
     let mouseLocation = mouseLocation
     let targetWorkspace = mouseLocation.monitorApproximation.activeWorkspace
-    let swapTarget = mouseLocation.findIn(tree: targetWorkspace.workspace.rootTilingContainer, virtual: false)?.takeIf({ $0 != window })
+    let swapTarget = mouseLocation.findIn(tree: targetWorkspace.rootTilingContainer, virtual: false)?.takeIf({ $0 != window })
     if targetWorkspace != window.workspace { // Move window to a different monitor
         let index: Int
         if let swapTarget, let parent = swapTarget.parent as? TilingContainer, let targetRect = swapTarget.lastAppliedLayoutPhysicalRect {

src/refresh.swift

@@ -65,16 +65,19 @@ func takeFocusFromMacOs(_ nativeFocused: Window?, startup: Bool) { // alternativ
 }
 
 private func refreshFocusedWorkspaceBasedOnFocusedWindow() { // todo drop. It should no longer be necessary
-    if let focusedWindow = focusedWindow {
-        let focusedWorkspace: Workspace = focusedWindow.workspace
+    if let focusedWindow = focusedWindow, let monitor = focusedWindow.nodeMonitor {
+        // todo it's rather refresh focused monitor
+        let focusedWorkspace: Workspace = monitor.activeWorkspace
         check(focusedWorkspace.monitor.setActiveWorkspace(focusedWorkspace))
         focusedWorkspaceName = focusedWorkspace.name
     }
 }
 
 private func normalizeLayoutReason() {
     let workspace = Workspace.focused
-    for window in workspace.allLeafWindowsRecursive {
+    let windows: [Window] = workspace.allLeafWindowsRecursive +
+        macosInvisibleWindowsContainer.children.filterIsInstance(of: Window.self)
+    for window in windows {
         let isMacosFullscreen = window.isMacosFullscreen
         let isMacosInvisible = !isMacosFullscreen && (window.isMacosMinimized || window.macAppUnsafe.nsApp.isHidden)
         if isMacosFullscreen && !window.layoutReason.isMacos {
@@ -87,7 +90,7 @@ private func normalizeLayoutReason() {
             window.unbindFromParent()
             window.bind(to: macosInvisibleWindowsContainer, adaptiveWeight: 1, index: INDEX_BIND_LAST)
         }
-        if case .macos(let prevParentKind) = window.layoutReason, !isMacosFullscreen {
+        if case .macos(let prevParentKind) = window.layoutReason, !isMacosFullscreen && !isMacosInvisible {
             window.layoutReason = .standard
             window.unbindFromParent()
             switch prevParentKind {

src/tree/MacWindow.swift

@@ -63,14 +63,14 @@ final class MacWindow: Window, CustomStringConvertible {
         if MacWindow.allWindowsMap.removeValue(forKey: windowId) == nil {
             return
         }
-        let workspace = unbindFromParent().parent.workspace.name
+        let workspace = unbindFromParent().parent.workspace?.name
         for obs in axObservers {
             AXObserverRemoveNotification(obs.obs, obs.ax, obs.notif)
         }
         axObservers = []
         // todo the if is an approximation to filter out cases when window just closed itself (or was killed remotely)
         //  we might want to track the time of the latest workspace switch to make the approximation more accurate
-        if workspace == previousFocusedWorkspaceName || workspace == focusedWorkspaceName {
+        if let workspace, workspace == previousFocusedWorkspaceName || workspace == focusedWorkspaceName {
             refreshSession(forceFocus: true) {
                 _ = WorkspaceCommand.run(.focused, workspace)
             }
@@ -83,7 +83,7 @@ final class MacWindow: Window, CustomStringConvertible {
         return true
     }
 
-    override var title: String? { axWindow.get(Ax.titleAttr) }
+    override var title: String { axWindow.get(Ax.titleAttr) ?? "" }
     override var isMacosFullscreen: Bool { axWindow.get(Ax.isFullscreenAttr) == true }
     override var isMacosMinimized: Bool { axWindow.get(Ax.minimizedAttr) == true }
 
@@ -105,16 +105,18 @@ final class MacWindow: Window, CustomStringConvertible {
         if !isHiddenViaEmulation {
             debug("hideViaEmulation: Hide \(self)")
             guard let topLeftCorner = getTopLeftCorner() else { return }
+            guard let workspace else { return } // hiding only makes sense for workspace windows
             prevUnhiddenEmulationPositionRelativeToWorkspaceAssignedRect =
                     topLeftCorner - workspace.monitor.rect.topLeftCorner
         }
-        setTopLeftCorner(allMonitorsRectsUnion.bottomRightCorner)
+        _ = setTopLeftCorner(allMonitorsRectsUnion.bottomRightCorner)
     }
 
     func unhideViaEmulation() {
         guard let prevUnhiddenEmulationPositionRelativeToWorkspaceAssignedRect else { return }
+        guard let workspace else { return } // hiding only makes sense for workspace windows
 
-        setTopLeftCorner(workspace.monitor.rect.topLeftCorner + prevUnhiddenEmulationPositionRelativeToWorkspaceAssignedRect)
+        _ = setTopLeftCorner(workspace.monitor.rect.topLeftCorner + prevUnhiddenEmulationPositionRelativeToWorkspaceAssignedRect)
 
         self.prevUnhiddenEmulationPositionRelativeToWorkspaceAssignedRect = nil
     }
@@ -277,7 +279,7 @@ extension WindowDetectedCallback {
         if let startupMatcher = matcher.duringAeroSpaceStartup, startupMatcher != startup {
             return false
         }
-        if let regex = matcher.windowTitleRegexSubstring, !(window.title ?? "").contains(regex) {
+        if let regex = matcher.windowTitleRegexSubstring, !(window.title).contains(regex) {
             return false
         }
         if let appId = matcher.appId, appId != window.app.id {

src/tree/TreeNodeEx.swift

@@ -23,8 +23,20 @@ extension TreeNode {
     var parents: [NonLeafTreeNodeObject] { parent.flatMap { [$0] + $0.parents } ?? [] }
     var parentsWithSelf: [TreeNode] { parent.flatMap { [self] + $0.parentsWithSelf } ?? [self] }
 
-    var workspace: Workspace {
-        self as? Workspace ?? parent?.workspace ?? errorT("Unknown type \(Self.self)")
+    var workspace: Workspace? {
+        self as? Workspace ?? parent?.workspace
+    }
+
+    var nodeMonitor: Monitor? {
+        guard let parent else { return nil }
+        switch parent.cases {
+        case .workspace(let parent):
+            return parent.monitor
+        case .tilingContainer(let parent):
+            return parent.nodeMonitor
+        case .macosInvisibleWindowsContainer:
+            return nil
+        }
     }
 
     var mostRecentWindow: Window? {

src/tree/Window.swift

@@ -26,9 +26,9 @@ class Window: TreeNode, Hashable {
 
     func getTopLeftCorner() -> CGPoint? { error("Not implemented") }
     func getSize() -> CGSize? { error("Not implemented") }
-    var title: String? { error("Not implemented") }
+    var title: String { error("Not implemented") }
     var isMacosFullscreen: Bool { false }
-    var isMacosMinimized: Bool { false }
+    var isMacosMinimized: Bool { false } // todo replace with enum MacOsWindowNativeState { normal, fullscreen, invisible }
     var isHiddenViaEmulation: Bool { error("Not implemented") }
     func setSize(_ size: CGSize) -> Bool { error("Not implemented") }
 
@@ -59,10 +59,14 @@ extension Window {
 
     var ownIndex: Int { ownIndexOrNil! }
 
-    func focus() { // todo rename: focusWindowAndWorkspace
+    func focus() -> Bool { // todo rename: focusWindowAndWorkspace
         markAsMostRecentChild()
         // todo bug make the workspace active first...
-        focusedWorkspaceName = workspace.name
+        if let workspace = workspace ?? nodeMonitor?.activeWorkspace { // todo change focusedWorkspaceName to focused monitor
+            focusedWorkspaceName = workspace.name
+            return nodeMonitor?.setActiveWorkspace(workspace) ?? true
+        } // else if We should exit-native-fullscreen/unminimize window if we want to fix B6E178F2
+        return true
     }
 
     func setFrame(_ topLeft: CGPoint?, _ size: CGSize?) -> Bool {

src/tree/Workspace.swift

@@ -93,7 +93,7 @@ class Workspace: TreeNode, NonLeafTreeNodeObject, Hashable, Identifiable, Custom
 
 extension Workspace {
     var isVisible: Bool { visibleWorkspaceToScreenPoint.keys.contains(self) }
-    var monitor: Monitor {
+    var monitor: Monitor { // todo rename to workspaceMonitor (to distinguish from nodeMonitor)
         forceAssignedMonitor
             ?? visibleWorkspaceToScreenPoint[self]?.monitorApproximation
             ?? assignedMonitorPoint?.monitorApproximation

src/tree/WorkspaceEx.swift

@@ -29,7 +29,7 @@ extension Workspace {
     }
 
     var floatingAndMacosFullscreenWindows: [Window] {
-        workspace.children.filterIsInstance(of: Window.self)
+        children.filterIsInstance(of: Window.self)
     }
 
     var forceAssignedMonitor: Monitor? {
@@ -39,13 +39,4 @@ extension Workspace {
             .compactMap { $0.resolveMonitor(sortedMonitors: sortedMonitors) }
             .first
     }
-
-    func layoutWorkspace() {
-        if isEffectivelyEmpty { return }
-        let rect = monitor.visibleRectPaddedByOuterGaps
-        // If monitors are aligned vertically and the monitor below has smaller width, then macOS may not allow the
-        // window on the upper monitor to take full width. rect.height - 1 resolves this problem
-        // But I also faced this problem in mointors horizontal configuration. ¯\_(ツ)_/¯
-        layoutRecursive(rect.topLeftCorner, width: rect.width, height: rect.height - 1, virtual: rect)
-    }
 }