extension State { mutating func insertWindow( _ window: WindowID, into workspace: inout Workspace, floating: Bool, frame: Rect, position: Int? = nil, reobservingFloatingWindow: Bool = false, effects: inout [Effect] ) { let display = displays[workspace.key.display].flatMap { $0.hasUsableGeometry ? $0 : nil } if let display { workspace.adapt(to: display.frame, fullFrame: display.fullFrame) } let full = !floating && workspace.whenFull == .float && workspace.tree?.windows.contains(window) != true && (workspace.tree?.tileCount ?? 0) >= workspace.effectiveWindowCap workspace.insert( window, floating: floating || full, in: display?.frame, windows: windows, position: position) guard full else { return } windows[window]?.isFloating = true windows[window]?.managementReason = .whenFull if reobservingFloatingWindow { // Repeating a tile rule must not overwrite an overflow float's retained frame. frames[window] = frames[window] ?? frame return } let screen = displays[workspace.key.display]?.frame ?? frame let area = screen.inset(by: workspace.reservedEdges).inset(by: workspace.gaps.outer) let minimum = windows[window]?.minimumSize ?? Size() let width = max(minimum.width, min(area.size.width, frame.size.width)) let height = max(minimum.height, min(area.size.height, frame.size.height)) frames[window] = Rect( x: area.minX + (area.size.width - width) / 2, y: area.minY + (area.size.height - height) / 2, width: width, height: height ).roundedToWholePoints() effects.append(.announce(.floatingChanged(window, isFloating: true))) effects.append(.report(.spaceFull(window))) } mutating func resolveMinimumCapacity(_ layout: LayoutResult, effects: inout [Effect]) { let failing = Set(layout.cannotFit) for key in workspaceKeys where isActive(key) { guard var workspace = workspaces[key], let display = displays[key.display], display.hasUsableGeometry, workspace.order.contains(where: failing.contains) else { continue } let area = display.frame.inset(by: workspace.reservedEdges).inset(by: workspace.gaps.outer) .roundedToWholePoints() var failures = workspace.order.filter(failing.contains) while !failures.isEmpty, let tree = workspace.tree { if let balanced = balancedCapacityWorkspace(workspace, in: display.frame) { workspace = balanced break } if let redistributed = redistributedCapacityWorkspace(workspace, in: display.frame) { workspace = redistributed for stack in workspace.tree?.stacks ?? [] where stack.windows.count > 1 { for member in stack.windows { windows[member]?.managementReason = .whenFull } } break } // An obstruction cannot be rescued by sacrificing its neighbors. let obstruction = failures.first(where: { exceedsArea($0, area: area) }) let candidate = obstruction == nil ? fittingCapacityCandidate(in: workspace, frame: display.frame) : nil guard let window = obstruction ?? candidate?.window ?? failures.first, let source = tree.stack(containing: window) else { break } let minimum = windows[window]?.minimumSize ?? Size() if workspace.whenFull == .float || exceedsArea(window, area: area) || (tree.tileCount == 1 && source.windows.count > 1) { if modes(for: workspace.key).focusedWindow == window { endFocus(in: workspace.key, effects: &effects) } windows[window]?.isFloating = true windows[window]?.managementReason = .whenFull workspace.removeTile(window) let before = observedFrames[window] ?? frames[window] ?? area let size = Size( width: max(minimum.width.rounded(.up), min(area.size.width, before.size.width)), height: max(minimum.height.rounded(.up), min(area.size.height, before.size.height))) frames[window] = Rect( x: area.minX + (area.size.width - size.width) / 2, y: area.minY + (area.size.height - size.height) / 2, width: size.width, height: size.height ).roundedToWholePoints() effects.append(.announce(.floatingChanged(window, isFloating: true))) effects.append(.report(.spaceFull(window))) } else { guard let members = workspace.mergeCapacityStack( containing: window, into: candidate?.window == window ? candidate?.destination : nil) else { preconditionFailure("A minimum fitting the whole tile must have room after stacking") } for member in members { windows[member]?.managementReason = .whenFull } } let remaining = Set(capacityFailures(in: workspace, frame: display.frame)) failures = workspace.order.filter(remaining.contains) } if workspace.whenFull == .stack, !workspace.layout.preservesTree { // Merging constrained windows can free room for a flexible member of their stack. workspace.setWindowCap(workspace.windowCap, in: display.frame, windows: windows) } setWorkspace(workspace) } } private func balancedCapacityWorkspace(_ workspace: Workspace, in frame: Rect) -> Workspace? { guard !workspace.layout.preservesTree, let tree = workspace.tree else { return nil } var balanced = workspace balanced.tree = TileTree.balanced( tree.stacks, layout: workspace.layout, ratio: workspace.ratio, variant: workspace.layoutVariant) guard capacityFailures(in: balanced, frame: frame).isEmpty else { return nil } balanced.adaptiveTileMemory = nil balanced.alternateSideTree = nil return balanced } private func redistributedCapacityWorkspace(_ workspace: Workspace, in frame: Rect) -> Workspace? { guard workspace.whenFull == .stack, !workspace.layout.preservesTree, modes(for: workspace.key).focusedWindow == nil, let tree = workspace.tree, tree.tileCount == 2, tree.windows.count > 2, !tree.stacks.contains(where: \.isUserMade) else { return nil } // A later minimum can invalidate an earlier merge. Recover one flexible tile before collapsing everything. let flexible = tree.windows.min { first, second in let lhs = windows[first]?.minimumSize ?? Size() let rhs = windows[second]?.minimumSize ?? Size() return lhs.width / frame.size.width + lhs.height / frame.size.height < rhs.width / frame.size.width + rhs.height / frame.size.height } guard let flexible else { return nil } let remaining = tree.windows.filter { $0 != flexible } guard let first = remaining.first else { return nil } var stacks = [WindowStack(first, others: Array(remaining.dropFirst())), WindowStack(flexible)] if let focus = workspace.focus { for index in stacks.indices { stacks[index].select(focus) } } var candidate = workspace candidate.tree = TileTree.balanced( stacks, layout: workspace.layout, ratio: workspace.ratio, variant: workspace.layoutVariant) guard capacityFailures(in: candidate, frame: frame).isEmpty else { return nil } candidate.adaptiveTileMemory = nil candidate.alternateSideTree = nil return candidate } private func fittingCapacityCandidate( in workspace: Workspace, frame: Rect ) -> (window: WindowID, destination: WindowID?)? { guard let tree = workspace.tree else { return nil } let protected = modes(for: workspace.key).focusedWindow for window in workspace.openingOrder.reversed() { guard let source = tree.stack(containing: window) else { continue } if workspace.whenFull == .float || tree.tileCount == 1 { guard window != protected else { continue } var candidate = workspace candidate.removeTile(window) return capacityFits(candidate, frame: frame) ? (window, nil) : nil } guard protected.map(source.windows.contains) != true else { continue } // Group shared constraints before sacrificing a flexible tile as later minimums arrive. let minimum = stackMinimum(source) let stacks = tree.stacks guard let index = stacks.firstIndex(of: source) else { return nil } let neighbor = stacks[index == 0 ? 1 : index - 1] let compatible = stacks.filter { $0 != source }.reduce(neighbor) { best, stack in sharedMinimum(minimum, stackMinimum(stack), frame: frame) > sharedMinimum(minimum, stackMinimum(best), frame: frame) ? stack : best } // Two layout trials keep crowded workspaces bounded. for destination in [compatible.visible, nil] as [WindowID?] { var candidate = workspace guard candidate.mergeCapacityStack(containing: window, into: destination) != nil else { continue } if capacityFits(candidate, frame: frame) { return (window, destination) } } return nil } return nil } private func capacityFits(_ workspace: Workspace, frame: Rect) -> Bool { capacityFailures(in: workspace, frame: frame).isEmpty || balancedCapacityWorkspace(workspace, in: frame) != nil } private func stackMinimum(_ stack: WindowStack) -> Size { LayoutEngine.minimum(.tile(stack), gap: 0, windows: windows) } private func sharedMinimum(_ first: Size, _ second: Size, frame: Rect) -> Double { min(first.width, second.width) / frame.size.width + min(first.height, second.height) / frame.size.height } private func capacityFailures(in workspace: Workspace, frame: Rect) -> [WindowID] { let failures = LayoutEngine.arrange(workspace, in: frame, windows: windows).cannotFit guard let protected = modes(for: workspace.key).focusedWindow else { return failures } let area = frame.inset(by: workspace.reservedEdges).inset(by: workspace.gaps.outer).roundedToWholePoints() return failures.filter { $0 != protected || exceedsArea($0, area: area) } } private func exceedsArea(_ window: WindowID, area: Rect) -> Bool { let minimum = windows[window]?.minimumSize ?? Size() return minimum.width.rounded(.up) > area.size.width || minimum.height.rounded(.up) > area.size.height } } extension Workspace { mutating func mergeCapacityStack(containing window: WindowID, into target: WindowID? = nil) -> [WindowID]? { guard let tree, let source = tree.stack(containing: window) else { return nil } let stacks = tree.stacks guard let index = stacks.firstIndex(of: source), stacks.count > 1 else { return nil } let destination = target.flatMap { tree.stack(containing: $0) } ?? stacks[index == 0 ? 1 : index - 1] guard destination != source else { return nil } var reduced = tree for member in source.windows { guard let remaining = reduced.removing(member) else { preconditionFailure("A stack merge must retain its destination") } reduced = remaining } self.tree = reduced.mappingStacks { stack in guard stack.windows == destination.windows else { return stack } var merged = stack merged.isUserMade = merged.isUserMade || source.isUserMade for member in source.windows { merged.append(member) } if let focus { merged.select(focus) } return merged } adaptiveTileMemory = nil return source.windows } } extension TileTree { func resettingSizes() -> TileTree { fold( { .tile($0) }, { node, first, second in switch node { case .tile: preconditionFailure("A folded branch must be a split or partition") case .split(let axis, _, _, _): return .split( axis: axis, fraction: LayoutEngine.balancedFraction(node), first: first, second: second) case .partition(let axis, _, _, _): return .partition(axis: axis, fraction: 0.5, first: first, second: second) } }) } }