public enum FocusMode: String, Sendable, Equatable, Codable, CaseIterable { case focus, noPeek, cleanSpace } public struct FocusModes: Sendable, Equatable, Codable { public var focusedWindow: WindowID? public var noPeek: Bool public var cleanSpace: Bool public init(focusedWindow: WindowID? = nil, noPeek: Bool = false, cleanSpace: Bool = false) { self.focusedWindow = focusedWindow self.noPeek = noPeek self.cleanSpace = cleanSpace } } extension State { public func modes(for key: WorkspaceKey) -> FocusModes { focusModes?[key] ?? FocusModes() } public var activeFocusModes: FocusModes { activeWorkspace.map(modes(for:)) ?? FocusModes() } mutating func toggle(_ mode: FocusMode, effects: inout [Effect]) { guard let key = activeWorkspace, isActive(key) else { effects.append(.report(.noActiveWorkspace)) return } toggle(mode, in: key, effects: &effects) } mutating func toggle(_ mode: FocusMode, in key: WorkspaceKey, effects: inout [Effect]) { var modes = modes(for: key) let hasFocusedWindow = focusedWindow.flatMap(workspace(containing:)) == key let enabled: Bool switch mode { case .focus: if modes.focusedWindow != nil { modes.focusedWindow = nil enabled = false } else { guard let window = focusedWindow, workspace(containing: window) == key else { effects.append(.report(.noFocusedWindow)) return } guard windows[window]?.isFloating == false else { effects.append(.report(.notTiled(window))) return } guard let frame = focusFrame(in: key), frame.size.width > 0, frame.size.height > 0 else { effects.append(.report(.invalidGeometry)) return } if let minimum = windows[window]?.minimumSize, minimum.width > frame.size.width || minimum.height > frame.size.height { effects.append(.report(.cannotFit([window]))) return } modes.focusedWindow = window enabled = true effects.append(.raiseWindow(window)) } case .noPeek: guard modes.noPeek || hasFocusedWindow else { effects.append(.report(.noFocusedWindow)) return } modes.noPeek.toggle() enabled = modes.noPeek case .cleanSpace: guard modes.cleanSpace || hasFocusedWindow else { effects.append(.report(.noFocusedWindow)) return } modes.cleanSpace.toggle() enabled = modes.cleanSpace } let layout = currentLayout if focusModes == nil { focusModes = [:] } focusModes?[key] = modes if mode != .focus, let layout { cacheLayout(layout) } effects.append(.announce(.focusModeChanged(mode, enabled: enabled))) } func focusFrame(in key: WorkspaceKey) -> Rect? { guard let display = displays[key.display], let workspace = workspaces[key] else { return nil } return display.frame.inset(by: workspace.reservedEdges).inset(by: workspace.gaps.outer).roundedToWholePoints() } mutating func endFocus(in key: WorkspaceKey, effects: inout [Effect]) { guard focusModes?[key]?.focusedWindow != nil else { return } focusModes?[key]?.focusedWindow = nil effects.append(.announce(.focusModeChanged(.focus, enabled: false))) } mutating func endCleanSpace(on displays: Set, effects: inout [Effect]) { for key in (focusModes?.keys.sorted() ?? []) where displays.contains(key.display) { guard focusModes?[key]?.cleanSpace == true else { continue } focusModes?[key]?.cleanSpace = false effects.append(.announce(.focusModeChanged(.cleanSpace, enabled: false))) } } private func focusMembership(in key: WorkspaceKey) -> Set { Set((workspaces[key]?.order ?? []).filter { windows[$0]?.isFloatingAuxiliary != true }) } func focusMembership(for event: Event) -> [WorkspaceKey: Set] { var membership: [WorkspaceKey: Set] = [:] for (key, modes) in focusModes ?? [:] where modes.focusedWindow != nil { membership[key] = focusMembership(in: key) } let enablingFocus: WorkspaceKey? switch event { case .commandIssued(.toggleFocus): enablingFocus = activeWorkspace case .workspaceCommandIssued(.toggleFocus, let key): enablingFocus = key case .commandForWindow(let window, .toggleFocus, _): enablingFocus = workspace(containing: window) default: enablingFocus = nil } if let key = enablingFocus { membership[key] = focusMembership(in: key) } return membership } mutating func reconcileFocusModes( previousMembership: [WorkspaceKey: Set], effects: inout [Effect] ) { for key in focusModes?.keys.sorted() ?? [] { guard let focused = modes(for: key).focusedWindow else { continue } if workspace(containing: focused) != key || windows[focused]?.isFloating != false || previousMembership[key] != focusMembership(in: key) { endFocus(in: key, effects: &effects) } } } mutating func prepareFocusModes(for event: Event, effects: inout [Effect]) { switch event { case .windowDisappeared(let window): if let key = workspace(containing: window), modes(for: key).focusedWindow == window { endFocus(in: key, effects: &effects) } case .windowMovedByUser(let window, _), .windowResizedByUser(let window, _), .windowFrameEdited(let window, _), .windowDragBegan(let window): if windows[window]?.isFloatingAuxiliary != true, let key = workspace(containing: window) { endFocus(in: key, effects: &effects) } case .windowDropped(let source, _, _): if let key = workspace(containing: source) { endFocus(in: key, effects: &effects) } case .tileEdgeResized(let edge, _), .tileEdgeReset(let edge): endFocus(in: edge.workspace, effects: &effects) case .commandIssued(let command): if command.endsFocus, let key = activeWorkspace { endFocus(in: key, effects: &effects) } case .displaySetChanged(let updated): let disconnected = Set(displays.keys).subtracting(updated.map(\.id)) endCleanSpace(on: disconnected, effects: &effects) for key in focusModes?.keys.sorted() ?? [] where disconnected.contains(key.display) { endFocus(in: key, effects: &effects) } case .sessionSuspended(let displays): endCleanSpace(on: displays, effects: &effects) default: break } } } extension ManagedWindow { var isFloatingAuxiliary: Bool { guard isFloating else { return false } return facts?.hasParent == true || facts?.isModal == true || ["AXSheet", "AXDialog", "AXPopover", "AXMenu", "AXMenuBar"].contains(role) || ["AXDialog", "AXSystemDialog", "AXFloatingWindow", "AXSystemFloatingWindow"].contains(subrole ?? "") } } extension Command { var endsFocus: Bool { switch self { case .cycleLayout, .setLayout, .setRatio, .nudgeRatio, .retile, .resetSizes, .setWindowCap, .split, .balance, .rotate, .mirror, .makePrimary, .swap, .move, .stack, .join, .unstack, .toggleFloat, .tileWindow, .snap, .moveToDisplay, .toggleFullscreen: true default: false } } }