extension State { mutating func handle( _ event: Event, baseline: inout [WindowID: Rect], effects: inout [Effect], closingNativeTabs: Set = [] ) -> Report? { if event.adaptsWorkspaces || currentLayout == nil { adaptWorkspaces(effects: &effects) } if case .windowMinimized(let window) = event { prepareFocusModes(for: .windowDisappeared(window), effects: &effects) } else { prepareFocusModes(for: event, effects: &effects) } switch event { case .relayout: invalidateLayout() case .windowDragBegan, .sessionSuspended, .undoGestureBegan, .undoGestureEnded: break case .windowAppeared(let window, let key, let frame): guard frame.isValid, window.minimumSize?.isValid != false, window.initialPosition.map({ $0 >= 0 }) != false else { return .invalidGeometry } if let version = window.minimum?.schemaVersion, version != LearnedMinimumSize.currentVersion { return .unsupportedMinimumVersion(version) } appear( window, key: key, frame: frame, baseline: &baseline, effects: &effects, closingNativeTabs: closingNativeTabs) case .windowDisappeared(let window): forgetMinimized(window) disappear(window, effects: &effects) case .windowMinimized(let window): minimize(window, effects: &effects) case .windowMovedByUser(let window, let frame), .windowResizedByUser(let window, let frame), .windowFrameEdited(let window, let frame): return userFrame(window, frame: frame, baseline: &baseline) case .windowDropped(let source, let target, let stacking): return drop(source, target: target, stacking: stacking, effects: &effects) case .gestureCommitted(let gesture): return commitGesture(gesture, effects: &effects) case .tileEdgeResized(let edge, let delta): return changeTileEdge(edge, delta: delta) case .tileEdgeReset(let edge): if let issue = changeTileEdge(edge, delta: nil) { return issue } effects.append(.announce(.sizesReset)) case .focusChanged(let window): return observedFocus(window, effects: &effects) case .displaySetChanged(let displays): return changeDisplays(displays, effects: &effects) case .activeSpaceChanged(let display, let space): return changeSpace(display, space: space, effects: &effects) case .commandIssued(let command): apply(command, effects: &effects) case .commandForWindow(let window, let command, let workspace): return applyControl(command, to: window, workspace: workspace, effects: &effects) case .hoverFocusConfigured(let enabled): hoverFocusEnabled = enabled case .hoverFocusSettled(let window, let key): guard hoverFocusEnabled, isActive(key), workspace(containing: window) == key, visibleWindows.contains(window) else { return nil } focus(window, effects: &effects) case .workspaceCommandIssued(let command, let key): return apply(command, in: key, effects: &effects) case .minimumSizeChanged(let window, let minimum): return changeMinimum(window, minimum: minimum) case .resolveRoom(let window, let workspace, let action): return resolveRoom(window, workspace: workspace, action: action, baseline: &baseline, effects: &effects) } return nil } mutating func changeTileEdge(_ edge: TileEdge, delta: Double?) -> Report? { guard delta?.isFinite != false, let target = edge.firstWindows.first, !edge.secondWindows.isEmpty else { return .invalidGeometry } guard edge.fraction.isFinite, (0...1).contains(edge.fraction) else { return .invalidRatio } guard var workspace = workspaces[edge.workspace], isActive(edge.workspace), let tree = workspace.tree, tree.hasSameTopology(as: edge.topology), let node = tree.node(at: edge.path[...]) else { return .invalidDropTarget(target) } guard let screen = displays[edge.workspace.display]?.frame, screen.isValid, let capturedTree = tree.replacingFraction(at: edge.path[...], with: edge.fraction) else { return .invalidGeometry } var captured = workspace captured.tree = capturedTree guard edge.geometry.isValid, edge.geometry.size.width > 0, edge.geometry.size.height > 0, edge.contentExtent.isFinite, edge.contentExtent > 0 else { return .invalidGeometry } let minimums: TileEdgeMinimums if let cached = validatedEdgeMinimums(edge, in: captured, screen: screen) { minimums = cached } else { guard let original = LayoutEngine.edge(captured, at: edge.path, in: screen, windows: windows), edge.hasSameGeometry(as: original), let capturedMinimums = original.minimums else { return .invalidGeometry } minimums = capturedMinimums recordValidatedEdge(edge, minimums: minimums, in: captured, screen: screen) } if case .tile = node { return .invalidDropTarget(target) } let changesMainRatio = workspace.primaryExpandsTile && edge.path == workspace.mainRatioPath let fraction: Double if let delta { guard let requested = edge.fraction(forDelta: delta) else { return .invalidGeometry } fraction = requested } else { fraction = workspace.resetFraction(at: edge.path, node: node) } guard (0...1).contains(fraction), !changesMainRatio || MainRatio.bounds.contains(fraction) else { return .invalidRatio } if let delta { let extent = edge.axis == .horizontal ? edge.geometry.size.width : edge.geometry.size.height let firstLength = edge.firstExtent + delta let secondLength = extent - edge.gap - firstLength let firstMinimum = minimums.first let secondMinimum = minimums.second let firstSize = edge.axis == .horizontal ? Size(width: firstLength, height: edge.geometry.size.height) : Size(width: edge.geometry.size.width, height: firstLength) let secondSize = edge.axis == .horizontal ? Size(width: secondLength, height: edge.geometry.size.height) : Size(width: edge.geometry.size.width, height: secondLength) var cannotFit: [WindowID] = [] if firstSize.width < firstMinimum.width || firstSize.height < firstMinimum.height { cannotFit += edge.firstWindows } if secondSize.width < secondMinimum.width || secondSize.height < secondMinimum.height { cannotFit += edge.secondWindows } if !cannotFit.isEmpty { return .cannotFit(cannotFit.sorted()) } } guard let updated = tree.replacingFraction(at: edge.path[...], with: fraction) else { return .invalidDropTarget(target) } workspace.tree = updated if changesMainRatio { let primaryFraction = workspace.primaryExpandsTile && workspace.primaryOnRight ? 1 - fraction : fraction workspace.changeRatio(MainRatio(primaryFraction)) } let layout = LayoutEngine.arrange(workspace, in: screen, windows: windows) let affected = Set(edge.affectedWindows) let cannotFit = layout.cannotFit.filter(affected.contains) if !cannotFit.isEmpty { return .cannotFit(cannotFit) } applyWorkspaceLayout(workspace, layout: layout) return nil } private mutating func appear( _ window: ManagedWindow, key: WorkspaceKey, frame: Rect, baseline: inout [WindowID: Rect], effects: inout [Effect], closingNativeTabs: Set ) { let previous = windows[window.id] let placement = minimizedPlacements?[window.id] let isRestoring = previous == nil && (placement?.window.app == window.app || window.isRestoringMinimized) let key = isRestoring ? (minimizedRestoreWorkspace(for: window) ?? key) : key let existing = workspace(containing: window.id) if let existing, existing != key { modifyWorkspace(existing) { $0.removeObservedWindow(window.id) } } let reportsChangedPlacement = previous == nil && placement?.window.app == window.app var window = window window.isRestoringMinimized = false let remembered = previous ?? (placement?.window.app == window.app ? placement?.window : nil) if let previous = remembered, (previous.managementReason == .user && window.managementReason != .rule) || (previous.managementReason == .whenFull && window.managementReason == .automatic) { window.isFloating = previous.isFloating window.managementReason = previous.managementReason } let repeatsOverflowObservation = existing == key && previous?.managementReason == .whenFull && previous?.isFloating == true && window.isFloating && observedFrames[window.id] == frame let repeatsUserFloat = existing == key && previous?.isFloating == true && previous?.managementReason == .user && window.isFloating windows[window.id] = window observedFrames[window.id] = frame baseline[window.id] = frame // Metadata discovery must not replace an explicit floating target; frame events track actual moves. if (window.isFloating && !repeatsOverflowObservation && !repeatsUserFloat) || !isActive(key) { frames[window.id] = frame } if workspaces[key] == nil { setWorkspace(newWorkspace(key)) } guard var workspace = workspaces[key] else { return } if let placement { if restorePlacement(window, placement: placement, in: &workspace) { setWorkspace(workspace) forgetRestored(window.id) if isActive(key), !window.isFloatingAuxiliary { focus(window.id, effects: &effects) } return } forgetRestored(window.id) } let rememberedFocus = workspace.focus let releasedTile = window.isFloating && workspace.tree?.contains(window.id) == true if previous?.isFloating != window.isFloating || nativeTabDetached(window, previous: previous, workspace: workspace, closingWindows: closingNativeTabs) { workspace.removeTile(window.id) } let tabPeer = nativeTabPeer(for: window, workspace: key, frame: frame) if let tabPeer, workspace.insertNativeTab(window.id, alongside: tabPeer) { workspace.select(window.id) } else { insertWindow( window.id, into: &workspace, floating: window.isFloating, frame: frame, position: isRestoring ? workspace.order.count : (previous == nil ? window.initialPosition : nil), reobservingFloatingWindow: previous?.isFloating == true, effects: &effects) } if releasedTile { workspace.restoreAutomaticTiles() } if window.isFloatingAuxiliary { workspace.focus = rememberedFocus } else if existing == key, let rememberedFocus { workspace.select(rememberedFocus) } setWorkspace(workspace) if isActive(key), !window.isFloatingAuxiliary, previous == nil || existing != key { focus(window.id, effects: &effects) } if reportsChangedPlacement { effects.append(.report(.minimizedPlacementChanged(window.id))) } } private mutating func minimize(_ id: WindowID, effects: inout [Effect]) { guard let window = windows[id], let key = workspace(containing: id), let current = workspaces[key] else { return } var placement = MinimizedPlacement(window: window, workspace: current, removed: []) if let compatible = (minimizedPlacements?.keys.sorted() ?? []).compactMap({ minimizedPlacements?[$0] }).first( where: { $0.workspace.key == key && $0.projected().matchesPlacement(current) } ) { placement.workspace = compatible.workspace placement.removed = compatible.removed } placement.removed.append(id) if minimizedPlacements == nil { minimizedPlacements = [:] } for other in minimizedPlacements?.keys.sorted() ?? [] { guard let existing = minimizedPlacements?[other], existing.workspace == placement.workspace, existing.removed == Array(placement.removed.dropLast()) else { continue } minimizedPlacements?[other]?.removed = placement.removed } minimizedPlacements?[id] = placement disappear(id, effects: &effects) } public func minimizedRestoreWorkspace(for observed: ManagedWindow) -> WorkspaceKey? { var window = observed if let remembered = minimizedPlacements?[window.id]?.window, remembered.app == window.app, (remembered.managementReason == .user && window.managementReason != .rule) || (remembered.managementReason == .whenFull && window.managementReason == .automatic) { window.isFloating = remembered.isFloating } if let placement = minimizedPlacements?[window.id], isActive(placement.workspace.key), var workspace = workspaces[placement.workspace.key], restorePlacement(window, placement: placement, in: &workspace) { return workspace.key } if let focusedWindow, let key = workspace(containing: focusedWindow), isActive(key) { return key } return activeWorkspace.flatMap { isActive($0) ? $0 : nil } } private func restorePlacement( _ window: ManagedWindow, placement: MinimizedPlacement, in workspace: inout Workspace ) -> Bool { guard placement.window.app == window.app, placement.workspace.key == workspace.key, placement.window.isFloating == window.isFloating, placement.removed.contains(window.id), placement.projected().matchesPlacement(workspace) else { return false } let absent = Set(placement.removed) guard placement.workspace.order.allSatisfy({ id in if absent.contains(id) { return id == window.id || minimizedPlacements?[id] != nil } return windows[id] != nil && workspace.order.contains(id) }) else { return false } var restored = placement.projected(restoring: window.id) if let current = workspace.tree { restored.tree = restored.tree?.mappingStacks { stack in var updated = stack if let visible = current.stacks.first(where: { !Set($0.windows).isDisjoint(with: stack.windows) })? .visible { updated.select(visible) } return updated } } workspace.order = restored.order workspace.openingOrder = restored.openingOrder workspace.tree = restored.tree workspace.adaptiveTileMemory = restored.adaptiveTileMemory var alternate = restored.alternateSideTree let tiled = Set(restored.tree?.windows ?? []) for id in alternate?.windows ?? [] where !tiled.contains(id) { alternate = alternate?.removing(id) } workspace.alternateSideTree = alternate return true } private mutating func forgetRestored(_ id: WindowID) { minimizedPlacements?[id] = nil for other in minimizedPlacements?.keys.sorted() ?? [] { minimizedPlacements?[other]?.removed.removeAll { $0 == id } } if minimizedPlacements?.isEmpty == true { minimizedPlacements = nil } } private mutating func forgetMinimized(_ id: WindowID) { minimizedPlacements?[id] = nil for other in minimizedPlacements?.keys.sorted() ?? [] { minimizedPlacements?[other]?.workspace.removeObservedWindow(id) minimizedPlacements?[other]?.removed.removeAll { $0 == id } } if minimizedPlacements?.isEmpty == true { minimizedPlacements = nil } } private mutating func disappear(_ window: WindowID, effects: inout [Effect]) { guard let managed = windows[window] else { return } let key = workspace(containing: window) let nativeSurvivor = nativeTabSurvivor(closing: window) let wasSelected = key.map { workspaces[$0]?.focus == window } == true windows.removeValue(forKey: window) if let key { modifyWorkspace(key) { $0.removeObservedWindow(window) if wasSelected, let nativeSurvivor { $0.select(nativeSurvivor) } } } frames.removeValue(forKey: window) observedFrames.removeValue(forKey: window) snapHistory?[window] = nil undoHistory?.windowClosed(window) if focusedWindow == window { focusedWindow = nil if !managed.isFloatingAuxiliary, let key, isActive(key), let replacement = workspaces[key]?.focus { focus(replacement, effects: &effects) } } } private mutating func userFrame(_ window: WindowID, frame: Rect, baseline: inout [WindowID: Rect]) -> Report? { guard frame.isValid else { return .invalidGeometry } guard let managed = windows[window] else { return .unknownWindow(window) } observedFrames[window] = frame baseline[window] = frame if managed.isFloating || workspace(containing: window).map(isActive) != true { recordFrame(frame, for: window) } return nil } private mutating func observedFocus(_ window: WindowID?, effects: inout [Effect]) -> Report? { guard let window else { focusedWindow = nil return nil } guard windows[window] != nil else { return .unknownWindow(window) } guard let key = workspace(containing: window), isActive(key) else { return nil } focus(window, requestingFocus: false, effects: &effects) return nil } private mutating func changeMinimum(_ window: WindowID, minimum: LearnedMinimumSize?) -> Report? { guard windows[window] != nil else { return .unknownWindow(window) } guard minimum?.size.isValid != false else { return .invalidGeometry } if let version = minimum?.schemaVersion, version != LearnedMinimumSize.currentVersion { return .unsupportedMinimumVersion(version) } windows[window]?.minimum = minimum return nil } private mutating func changeDisplays(_ updated: [Display], effects: inout [Effect]) -> Report? { guard updated.allSatisfy(\.isValid), Set(updated.map(\.id)).count == updated.count else { return .invalidGeometry } displays = Dictionary(uniqueKeysWithValues: updated.map { ($0.id, $0) }) adaptWorkspaces(effects: &effects) if activeDisplay.flatMap({ displays[$0] }) == nil { activeDisplay = updated.first?.id } migrateDisconnected(effects: &effects) if updated.isEmpty { focusedWindow = nil } return nil } private mutating func migrateDisconnected(effects: inout [Effect]) { guard let destination = activeWorkspace, isActive(destination) else { return } let sources = workspaces.keys.sorted().filter { displays[$0.display] == nil && activeSpaces[$0.display] == $0.space && workspaces[$0]?.order.isEmpty == false } let preserved = focusedWindow ?? sources.first.flatMap { workspaces[$0]?.focus } for source in sources { for window in workspaces[source]?.order ?? [] { transfer(window, to: destination, effects: &effects) } } if let preserved { focus(preserved, effects: &effects) } } private mutating func changeSpace(_ display: DisplayID, space: SpaceID, effects: inout [Effect]) -> Report? { guard displays[display] != nil else { return .unavailableDisplay(display) } let changed = activeSpaces[display] != space activeSpaces[display] = space let key = WorkspaceKey(display: display, space: space) if workspaces[key] == nil { setWorkspace(newWorkspace(key)) } if activeDisplay == nil { activeDisplay = display } migrateDisconnected(effects: &effects) if changed && activeDisplay == display { focusedWindow = nil if let window = workspaces[key]?.focus { focus(window, effects: &effects) } } return nil } } extension MinimizedPlacement { fileprivate func projected(restoring window: WindowID? = nil) -> Workspace { var result = workspace for id in removed where id != window { result.removeObservedWindow(id) } return result } } extension Workspace { fileprivate mutating func removeObservedWindow(_ window: WindowID) { remove(window, restoringAutomaticTiles: tree?.contains(window) == true) } fileprivate func matchesPlacement(_ other: Workspace) -> Bool { func normalized(_ tree: TileTree?) -> TileTree? { tree?.mappingStacks { stack in var result = stack if let first = stack.windows.first { result.select(first) } return result } } return key == other.key && layout == other.layout && ratio == other.ratio && configuredRatio == other.configuredRatio && gaps == other.gaps && reservedEdges == other.reservedEdges && whenFull == other.whenFull && windowCap == other.windowCap && layoutVariant == other.layoutVariant && displaySize == other.displaySize && capabilitySize == other.capabilitySize && adaptiveTileMemory == other.adaptiveTileMemory && normalized(alternateSideTree) == normalized(other.alternateSideTree) && order == other.order && openingOrder == other.openingOrder && normalized(tree) == normalized(other.tree) } } extension Event { var adaptsWorkspaces: Bool { switch self { case .relayout, .windowAppeared, .windowDisappeared, .windowMinimized, .displaySetChanged, .activeSpaceChanged, .minimumSizeChanged: true case .commandIssued(let command), .workspaceCommandIssued(let command, _): command.affectsWorkspace default: false } } var needsRollback: Bool { switch self { case .windowAppeared, .windowMovedByUser, .windowResizedByUser, .windowFrameEdited, .windowDropped, .tileEdgeResized, .tileEdgeReset, .displaySetChanged: true default: false } } var changesBaseline: Bool { switch self { case .windowAppeared, .windowMovedByUser, .windowResizedByUser, .windowFrameEdited, .resolveRoom: true default: false } } }