Something went wrong. Try again.
An auto tiler for macOS
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611extension Command { var affectsWorkspace: Bool { switch self { case .cycleLayout, .setLayout, .setRatio, .nudgeRatio, .retile, .resetSizes, .setWindowCap, .split, .balance, .rotate, .mirror: true default: false } }}
extension State { mutating func apply(_ command: Command, effects: inout [Effect]) { switch command { case .toggleFocus: toggle(.focus, effects: &effects) return case .toggleNoPeek: toggle(.noPeek, effects: &effects) return case .toggleCleanSpace: toggle(.cleanSpace, effects: &effects) return case .toggleHoverFocus: hoverFocusEnabled.toggle() effects.append(.announce(.hoverFocusChanged(hoverFocusEnabled))) return case .undoLastRule: effects.append(.undoLastRule) return case .toggleBorders: effects.append(.report(.unsupported)) return default: break } if command == .undo { undo(effects: &effects) return } if case .enterMode(let mode) = command { activeMode = mode effects.append(.announce(.modeChanged(mode))) return } if case .tileWindow(let window) = command { guard let key = workspace(containing: window), windows[window] != nil else { effects.append(.report(.unknownWindow(window))) return } guard isActive(key) else { effects.append(.report(.noActiveWorkspace)) return } if windows[window]?.isFloating == true { toggleFloat(window, key: key, effects: &effects) } } else if command.affectsWorkspace { guard let key = activeWorkspace, isActive(key) else { effects.append(.report(.noActiveWorkspace)) return } applyWorkspace(command, key: key, effects: &effects) } else { guard let window = focusedWindow, let key = workspace(containing: window), isActive(key) else { effects.append(.report(.noFocusedWindow)) return } applyFocused(command, window: window, key: key, effects: &effects) } }
mutating func applyWorkspace(_ command: Command, key: WorkspaceKey, effects: inout [Effect]) { guard var workspace = workspaces[key] else { return } let previous = workspace switch command { case .cycleLayout: workspace.changeLayout(workspace.layout.next) effects.append(.announce(.layoutChanged(workspace.layout))) case .setLayout(let layout): workspace.changeLayout(layout) effects.append(.announce(.layoutChanged(layout))) case .setRatio(let ratio): workspace.changeRatio(ratio, effects: &effects) case .nudgeRatio(let delta): guard delta.isFinite else { effects.append(.report(.invalidRatio)) return } guard delta != 0 else { return } let currentRatio = workspace.mainSizeRatio let ratio = MainRatio(currentRatio + min(1, max(-1, delta))) if delta > 0 ? ratio.value <= currentRatio : ratio.value >= currentRatio { effects.append(.report(delta > 0 ? .maximumSizeReached : .minimumSizeReached)) return } if (workspace.tree?.tileCount ?? 0) > 1, let screen = displays[key.display]?.frame { let before = currentLayout?.frames ?? LayoutEngine.arrange(workspace, in: screen, windows: windows).frames var resized = workspace resized.changeRatio(ratio) let layout = LayoutEngine.arrange(resized, in: screen, windows: windows) if layout.frames.allSatisfy({ before[$0.key] == $0.value }) { effects.append(.report(delta > 0 ? .maximumSizeReached : .minimumSizeReached)) return } effects.append(.announce(.ratioChanged(ratio))) resized.announceMergedTiles(since: previous, effects: &effects) applyWorkspaceLayout(resized, layout: layout) return } workspace.changeRatio(ratio, effects: &effects) case .retile: if let tree = workspace.tree, tree.tileCount < min(workspace.effectiveWindowCap, tree.windows.count), let display = displays[key.display], display.hasUsableGeometry { workspace.adapt(to: display.frame, fullFrame: display.fullFrame) workspace.setWindowCap(workspace.windowCap, in: display.frame, windows: windows) } else { workspace.restoreAutomaticTiles() } workspace.rebuild(stacks: workspace.tree?.stacks ?? []) case .resetSizes: workspace.resetSizes() effects.append(.announce(.sizesReset)) case .setWindowCap(let cap): guard Workspace.windowCapBounds.contains(cap) else { effects.append(.report(.invalidWindowCap(cap))) return } let requestedCap = cap == 0 ? Int.max : cap if let display = displays[key.display], display.hasUsableGeometry { workspace.setWindowCap(requestedCap, in: display.frame, windows: windows) } else { workspace.setWindowCap(requestedCap) } guard workspace != previous else { return } if workspace.effectiveWindowCap < requestedCap { effects.append( .report(.layoutCapabilityLimit(layout: workspace.layout, maximum: workspace.effectiveWindowCap))) } effects.append(.announce(.windowCapChanged(cap))) case .split(let axis): if workspace.layout == .tree { workspace.pendingSplitAxis = axis } case .balance: workspace.tree = workspace.tree?.balancedSplits() workspace.synchronizeTreeOrder() case .rotate: workspace.tree = workspace.tree?.rotatedClockwise() workspace.synchronizeTreeOrder() case .mirror(let axis): workspace.tree = workspace.tree?.mirrored(along: axis) workspace.synchronizeTreeOrder() default: break } switch command { case .balance, .rotate, .mirror: if workspace.primaryExpandsTile, let primary = previous.primaryWindow, let stack = workspace.tree?.stack(containing: primary) { workspace.designatePrimary(stack) } default: break } workspace.announceMergedTiles(since: previous, effects: &effects) setWorkspace(workspace) }
private mutating func applyFocused(_ command: Command, window: WindowID, key: WorkspaceKey, effects: inout [Effect]) { switch command { case .focus(let direction): guard let target = neighbor(of: window, direction: direction) else { effects.append(.report(.noNeighbor(direction))) return } focus(target, effects: &effects) case .swap(let direction): swap(window, direction: direction, effects: &effects) case .move(let direction): move(window, direction: direction, stacking: false, effects: &effects) case .join(let direction): join(window, key: key, direction: direction, effects: &effects) case .stack(let direction): move(window, direction: direction, stacking: true, effects: &effects) case .toggleFloat: toggleFloat(window, key: key, effects: &effects) case .snap(let action): snap(action, window: window, key: key, effects: &effects) case .moveToDisplay(let direction): moveToDisplay(window, from: key, direction: direction, effects: &effects) case .unstack: unstack(window, key: key, effects: &effects) case .focusNextInStack, .focusPreviousInStack: cycleStack(window, key: key, forward: command == .focusNextInStack, effects: &effects) case .focusNextWindow, .focusPreviousWindow: cycleWindow(window, key: key, forward: command == .focusNextWindow, effects: &effects) case .makePrimary: makePrimary(window, key: key, effects: &effects) case .alwaysFloat: effects.append(.saveFloatingRule(window)) case .close: effects.append(.closeWindow(window)) case .toggleFullscreen: effects.append(.toggleFullscreen(window)) default: break } }
private mutating func makePrimary(_ window: WindowID, key: WorkspaceKey, effects: inout [Effect]) { guard windows[window]?.isFloating == false, var workspace = workspaces[key], let source = workspace.tree?.stack(containing: window), let screen = displays[key.display]?.frame else { effects.append(.report(.notTiled(window))) return } guard workspace.primaryWindow.map(source.windows.contains) != true else { return } let before = LayoutEngine.arrange(workspace, in: screen, windows: windows).frames let right = workspace.sourceOnRight(window, frames: before, screen: screen) workspace.promotePrimary(window, onRight: right, frames: before) let candidate = LayoutEngine.arrange(workspace, in: screen, windows: windows) guard candidate.cannotFit.isEmpty else { effects.append(.report(.cannotFit(candidate.cannotFit))) return } setWorkspace(workspace) effects.append(.announce(.primaryChanged(window))) }
private mutating func cycleWindow(_ window: WindowID, key: WorkspaceKey, forward: Bool, effects: inout [Effect]) { guard let order = workspaces[key]?.openingOrder, let index = order.firstIndex(of: window), order.count > 1 else { return } focus(order[(index + (forward ? 1 : order.count - 1)) % order.count], effects: &effects) }
mutating func drop(_ window: WindowID, target: WindowID, stacking: Bool, effects: inout [Effect]) -> Report? { guard windows[window] != nil else { return .unknownWindow(window) } guard windows[target] != nil else { return .unknownWindow(target) } guard window != target, windows[window]?.isFloating == false, windows[target]?.isFloating == false, let key = workspace(containing: window), let destination = workspace(containing: target), isActive(key), isActive(destination), let sourceStack = workspaces[key]?.tree?.stacks.first(where: { $0.windows.contains(window) }), workspaces[destination]?.tree?.windows.contains(target) == true, !sourceStack.windows.contains(target) else { return .invalidDropTarget(target) } if stacking { move(window, direction: .right, stacking: true, target: target, effects: &effects) } else { // An explicit drop owns these occupants even if native focus selected another stack member. modifyWorkspace(key, preservingGeometry: true) { $0.select(window) } modifyWorkspace(destination, preservingGeometry: true) { $0.select(target) } swap(window, direction: .right, target: target, effects: &effects) } return nil }
private mutating func swap( _ window: WindowID, direction: Direction, target: WindowID? = nil, effects: inout [Effect] ) { guard windows[window]?.isFloating == false, let source = workspace(containing: window) else { effects.append(.report(.noNeighbor(direction))) return } let localTarget = target ?? neighbor(of: window, direction: direction, tiledOnly: true, within: source) let target: WindowID if let localTarget { target = localTarget } else { guard let display = displayNeighbor(from: source.display, direction: direction), let space = activeSpaces[display] else { effects.append(.report(.noNeighbor(direction))) return } let key = WorkspaceKey(display: display, space: space) let destination = workspaces[key] ?? newWorkspace(key) if (destination.tree?.tileCount ?? 0) < destination.effectiveWindowCap { transfer(window, to: key, effects: &effects) focus(window, effects: &effects) effects.append(.announce(.movedToDisplay(window, display))) return } guard let neighbor = neighbor(of: window, direction: direction, tiledOnly: true, within: key) ?? destination.tree?.firstStack.visible else { effects.append(.report(.noNeighbor(direction))) return } if whenDisplayFull == .stack || destination.whenFull == .stack { move( window, direction: direction, stacking: true, target: neighbor, userMadeStack: false, effects: &effects) effects.append(.announce(.movedToDisplay(window, display))) return } target = neighbor } guard let destination = workspace(containing: target) else { effects.append(.report(.noNeighbor(direction))) return } for key in Set([source, destination]).sorted() { guard var workspace = workspaces[key] else { continue } workspace.adaptiveTileMemory = nil workspace.tree = workspace.tree?.mappingStacks { stack in if stack.windows.contains(window) { return stack.replacing(window, with: target) } if stack.windows.contains(target) { return stack.replacing(target, with: window) } return stack } workspace.order = workspace.order.map { $0 == window ? target : ($0 == target ? window : $0) } if source != destination { workspace.openingOrder = workspace.openingOrder.map { $0 == window ? target : ($0 == target ? window : $0) } } setWorkspace(workspace) } modifyWorkspace(source, preservingGeometry: true) { $0.focus = target } focus(window, effects: &effects) }
private mutating func move( _ window: WindowID, direction: Direction, stacking: Bool, target: WindowID? = nil, userMadeStack: Bool = true, effects: inout [Effect] ) { guard windows[window]?.isFloating == false, let target = target ?? neighbor(of: window, direction: direction, tiledOnly: true), let source = workspace(containing: window), let destination = workspace(containing: target), var workspace = workspaces[destination] else { effects.append(.report(.noNeighbor(direction))) return } let openingOrder = workspaces[source]?.openingOrder ?? [] workspace.adaptiveTileMemory = nil modifyWorkspace(source) { $0.adaptiveTileMemory = nil $0.remove(window, restoringAutomaticTiles: source != destination) } if source == destination, let updated = workspaces[source] { workspace = updated } let index = workspace.order.firstIndex(of: target) ?? workspace.order.count if source != destination && !stacking && workspace.whenFull == .float && (workspace.tree?.tileCount ?? 0) >= workspace.effectiveWindowCap { insertWindow( window, into: &workspace, floating: false, frame: frames[window] ?? observedFrames[window] ?? Rect(), position: index, effects: &effects) setWorkspace(workspace) focus(window, effects: &effects) return } workspace.order.insert(window, at: min(workspace.order.count, index + (direction.isBefore ? 0 : 1))) if stacking || (workspace.tree?.tileCount ?? 0) >= workspace.effectiveWindowCap { workspace.tree = workspace.tree?.mappingStacks { stack in var updated = stack if stack.windows.contains(target) { updated.append(window) if stacking && userMadeStack { updated.isUserMade = true } } return updated } } else { workspace.tree = workspace.tree?.inserting( window, beside: target, axis: direction.axis, before: direction.isBefore) } if source == destination { workspace.openingOrder = openingOrder } else { workspace.openingOrder.append(window) } workspace.select(window) setWorkspace(workspace) focus(window, effects: &effects) if stacking { let count = workspace.tree?.stack(containing: window)?.windows.count ?? 1 effects.append(.announce(.stackChanged(window: window, count: count))) } }
private mutating func join(_ window: WindowID, key: WorkspaceKey, direction: Direction, effects: inout [Effect]) { guard windows[window]?.isFloating == false, var workspace = workspaces[key], let tree = workspace.tree, let stack = tree.stack(containing: window), let screen = displays[key.display]?.frame else { effects.append(.report(.noNeighbor(direction))) return } let frames = currentLayout != nil ? self.frames : LayoutEngine.arrange(workspace, in: screen, windows: windows).frames guard let source = frames[window] else { effects.append(.report(.noNeighbor(direction))) return } let target = tree.visibleWindows.filter { !stack.windows.contains($0) }.compactMap { candidate -> (WindowID, DirectionalDistance)? in guard let frame = frames[candidate], let distance = direction.distance(from: source, to: frame) else { return nil } return (candidate, distance) }.min { $0.1 == $1.1 ? $0.0 < $1.0 : $0.1 < $1.1 }?.0 guard let target else { effects.append(.report(.noNeighbor(direction))) return } var remaining: TileTree? = tree for member in stack.windows { remaining = remaining?.removing(member) } guard let remaining else { return } workspace.tree = remaining.inserting( .tile(stack), beside: target, axis: direction.axis, before: direction.isBefore) workspace.synchronizeTreeOrder() workspace.select(window) setWorkspace(workspace) }
private mutating func toggleFloat(_ window: WindowID, key: WorkspaceKey, effects: inout [Effect]) { guard let managed = windows[window], var workspace = workspaces[key], let display = displays[key.display], display.hasUsableGeometry else { return } let wasFloating = managed.isFloating let previousTileCount = workspace.tree?.tileCount ?? 0 if wasFloating { var candidate = self var feedback: [Effect] = [] candidate.windows[window]?.isFloating = false candidate.windows[window]?.managementReason = .user let openingOrder = workspace.openingOrder workspace.remove(window, restoringAutomaticTiles: false) candidate.insertWindow( window, into: &workspace, floating: false, frame: frames[window] ?? observedFrames[window] ?? Rect(), effects: &feedback) workspace.openingOrder = openingOrder workspace.rebalanceFloatTransition(from: previousTileCount, in: display.frame, windows: candidate.windows) candidate.setWorkspace(workspace) if candidate.windows[window]?.isFloating == false { let proposed = candidate.layoutFrames(in: [key]) if !proposed.cannotFit.isEmpty { candidate.resolveMinimumCapacity(proposed, effects: &feedback) } } guard candidate.windows[window]?.isFloating == false else { effects += feedback.filter { if case .report = $0 { true } else { false } } return } self = candidate effects += feedback } else { let area = display.frame.inset(by: workspace.reservedEdges).inset(by: workspace.gaps.outer) guard let frame = FloatingWindowPlacement.frame(in: area, minimum: managed.minimumSize ?? Size()) else { effects.append(.report(.cannotFit([window]))) return } windows[window]?.isFloating = true windows[window]?.managementReason = .user workspace.removeTile(window) workspace.restoreAutomaticTiles() workspace.rebalanceFloatTransition(from: previousTileCount, in: display.frame, windows: windows) setWorkspace(workspace) frames[window] = frame effects.append(.raiseWindow(window)) } effects.append(.announce(.floatingChanged(window, isFloating: !wasFloating))) }
private mutating func moveToDisplay( _ window: WindowID, from key: WorkspaceKey, direction: Direction, effects: inout [Effect] ) { guard let display = displayNeighbor(from: key.display, direction: direction), let space = activeSpaces[display] else { effects.append(.report(.noNeighbor(direction))) return } transfer(window, to: WorkspaceKey(display: display, space: space), effects: &effects) focus(window, effects: &effects) effects.append(.announce(.movedToDisplay(window, display))) }
private mutating func unstack(_ window: WindowID, key: WorkspaceKey, effects: inout [Effect]) { guard var workspace = workspaces[key], let stack = workspace.tree?.stack(containing: window), stack.windows.count > 1 else { return } guard (workspace.tree?.tileCount ?? 0) < workspace.effectiveWindowCap else { effects.append(.report(.atWindowCap(workspace.effectiveWindowCap))) return } guard let display = displays[key.display], display.hasUsableGeometry else { effects.append(.report(.unavailableDisplay(key.display))) return } let openingOrder = workspace.openingOrder workspace.remove(window, restoringAutomaticTiles: false) workspace.insert(window, floating: false, in: display.frame, windows: windows) workspace.openingOrder = openingOrder setWorkspace(workspace) effects.append(.announce(.stackChanged(window: window, count: 1))) }
mutating func cycleStack(_ window: WindowID, key: WorkspaceKey, forward: Bool, effects: inout [Effect]) { guard var stack = workspaces[key]?.tree?.stack(containing: window) else { return } stack.cycle(forward: forward) focus(stack.visible, effects: &effects) }}
extension Workspace { public var hasCustomSizes: Bool { var reset = self reset.resetSizes() if ratio != reset.ratio { return true } let unchangedProjection: Bool if let tree, let memory = adaptiveTileMemory, let neutral = reset.adaptiveTileMemory, memory.original == neutral.original, tree.hasSameTopology(as: memory.projection) { let placeholder = WindowStack(WindowID(rawValue: 0)) let visibleSizes = tree.mappingStacks { _ in placeholder } let projectedSizes = memory.projection.mappingStacks { _ in placeholder } unchangedProjection = visibleSizes == projectedSizes } else { unchangedProjection = false } if tree != reset.tree && !unchangedProjection { return true } if let original = adaptiveTileMemory?.original, let neutral = reset.adaptiveTileMemory?.original, original != neutral { return true } guard let alternateSideTree else { return false } var alternate = self alternate.layoutVariant = layoutVariant == .ultrawide ? .standard : .ultrawide return alternateSideTree != alternate.resettingSizes(of: alternateSideTree) }
mutating func resetSizes() { let original = adaptiveTileMemory.flatMap { memory in tree?.hasSameTopology(as: memory.projection) == true ? memory.original : nil } ratio = configuredRatio alternateSideTree = nil tree = tree.map { resettingSizes(of: $0) } // Each slot count needs its own neutral geometry, including temporarily hidden tiles. if let original, let projection = tree { adaptiveTileMemory = AdaptiveTileMemory(original: resettingSizes(of: original), projection: projection) } else { adaptiveTileMemory = nil } }
private func resettingSizes(of tree: TileTree) -> TileTree { var resized = tree.resettingSizes() guard primaryExpandsTile else { return resized } let wide = layoutVariant == .ultrawide && tree.tileCount >= 3 let path: [TileEdge.Child] = wide ? [primaryOnRight ? .second : .first] : [] resized = resized.replacingFraction( at: path[...], with: primaryOnRight ? 1 - configuredRatio.value : configuredRatio.value) ?? resized if wide { resized = resized.replacingFraction(at: [], with: primaryOnRight ? 0.25 : 0.75) ?? resized } return resized }
public mutating func changeLayout(_ layout: Layout) { restoreAdaptiveTiles() layoutDefaults = nil let enteringAccordion = layout == .accordion && self.layout != .accordion let enteringSide = layout == .side && self.layout != .side let previousPrimary = primaryWindow let previousSide = primaryOnRight self.layout = layout alternateSideTree = nil layoutVariant = (capabilitySize ?? displaySize).map { layout.capabilities(in: Rect(origin: Point(), size: $0)).variant } ?? .standard var stacks = tree?.stacks ?? [] if enteringAccordion { tree = nil } if enteringSide, let previousPrimary, let index = stacks.firstIndex(where: { $0.windows.contains(previousPrimary) }) { let primary = stacks.remove(at: index) stacks.insert(primary, at: 0) tree = TileTree.balanced(stacks, layout: .side, ratio: ratio, variant: layoutVariant) if previousSide { tree = tree?.mirrored(along: .horizontal) } designatePrimary(primary) stacks = tree?.stacks ?? stacks } rebuild(stacks: stacks) }
public mutating func changeRatio(_ ratio: MainRatio) { restoreAdaptiveTiles() self.ratio = ratio if layout != .accordion { tree = tree?.replacingFraction( at: mainRatioPath[...], with: primaryExpandsTile && primaryOnRight ? 1 - ratio.value : ratio.value) ?? tree if layout == .side, let alternateSideTree { var alternate = self alternate.tree = alternateSideTree alternate.layoutVariant = layoutVariant == .ultrawide ? .standard : .ultrawide self.alternateSideTree = alternateSideTree.replacingFraction( at: alternate.mainRatioPath[...], with: alternate.primaryOnRight ? 1 - ratio.value : ratio.value) ?? alternateSideTree } } constrainTileCount() }
mutating func changeRatio(_ ratio: MainRatio, effects: inout [Effect]) { changeRatio(ratio) effects.append(.announce(.ratioChanged(ratio))) }}