Something went wrong. Try again.
An auto tiler for macOS
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562import CoreGraphicspublic import ParcelConfigpublic import ParcelCorepublic import ParcelPlatform
public enum EngineMouseFeedback: Equatable, Sendable { case targetChanged(WindowFrame?) case layoutPreview(DragLayoutPreview?) case dropped(velocity: Point) case refused(Direction)}
public enum MouseEffect: Equatable, Sendable { case suspend(WindowID) case resume(WindowID, dropping: Bool) case beginResize([WindowID]) case endResize case beginDirect(WindowID) case writeFrame(WindowFrame) case commitDirect(window: WindowID, workspace: WorkspaceKey, frame: Rect, dropVelocity: Point?) case endDirect(WindowID) case event(Event) case report(Report) case feedback(EngineMouseFeedback)}
public struct MouseModel: Sendable { private enum Gesture: Sendable { case window(WindowID, Rect, floating: Bool) case edge(TileEdge) case direct(WindowID, Rect, resizing: Bool) }
private enum Intent: Sendable { case settle, swap, stack }
private struct Session: Sendable { let baseline: State var candidate: Event? var previewFrames: [WindowFrame] = [] var candidateRegion: Rect? let gesture: Gesture let start: Point let button: DragSample.Button var last: Point var timestamp: Double var velocity = Point() var moved = false var cancelled = false var refused = false }
public let minimumDistance: Double public let edgeTolerance: Double private var session: Session? public var isActive: Bool { session != nil }
var activeEdge: TileEdge? { guard let session, !session.cancelled, case .edge(let edge) = session.gesture else { return nil } return edge }
public static func divider( at point: Point, topmost: DragWindow?, state: State, observedFrames: [WindowID: Rect] = [:], tolerance: Double = 5, gapOnly: Bool = true ) -> TileEdge? { let location = CGPoint(x: point.xCoordinate, y: point.yCoordinate) guard location.x.isFinite, location.y.isFinite else { return nil } return state.tileEdges.filter { edge in let region = edgeRegion(edge, state: state, observedFrames: observedFrames, tolerance: tolerance) return (!gapOnly || region.gapArea.contains(location)) && region.claim(at: location, topmost: topmost, doubleClick: gapOnly) }.min { left, right in let a = edgePriority(left, at: point) let b = edgePriority(right, at: point) if a != b { return a < b } if left.workspace != right.workspace { return left.workspace < right.workspace } return left.path.map(\.rawValue).lexicographicallyPrecedes(right.path.map(\.rawValue)) } }
public func activeNativeWindow(state: State, observedFrames: [WindowID: Rect]) -> WindowID? { guard let session, session.moved, case .window(let window, let startFrame, _) = session.gesture, let current = observedFrames[window] ?? state.observedFrames[window] ?? state.frames[window], !current.matches(startFrame) else { return nil } return window }
public func consumesEscape(state: State, observedFrames: [WindowID: Rect]) -> Bool { guard let session else { return false } switch session.gesture { case .direct, .edge: return true case .window: return activeNativeWindow(state: state, observedFrames: observedFrames) != nil } }
public func consumes(_ sample: DragSample, state: State, observedFrames: [WindowID: Rect]) -> Bool { guard let session else { return false } if sample.kind == .cancel { return consumesEscape(state: state, observedFrames: observedFrames) } guard sample.button == session.button, sample.kind == .down || sample.kind == .dragged || sample.kind == .up else { return false } switch session.gesture { case .direct, .edge: return true case .window: return false } }
public init(minimumDistance: Double = 4, edgeTolerance: Double = 5) { precondition(minimumDistance.isFinite && minimumDistance >= 0) precondition(edgeTolerance.isFinite && edgeTolerance >= 0) self.minimumDistance = minimumDistance self.edgeTolerance = edgeTolerance }
public mutating func reduce( _ sample: DragSample, windowAtStart: DragWindow? = nil, state: State, configuration: MouseConfiguration, observedFrames: [WindowID: Rect] = [:] ) -> [MouseEffect] { if sample.kind == .cancel { return cancel(state: state) } if sample.kind == .interrupted { return cancel(state: state, awaitingMouseUp: false) } let point = Point(x: sample.location.x, y: sample.location.y) guard point.xCoordinate.isFinite && point.yCoordinate.isFinite else { return cancel(state: state) + [.report(.invalidGeometry), .feedback(.refused(.right))] } if sample.kind == .down { var effects = cancel(state: state, awaitingMouseUp: false) if configuration.enabled, sample.wasClaimed != false, sample.button == .left, sample.modifiers.isEmpty, let edge = Self.divider( at: point, topmost: windowAtStart, state: state, observedFrames: observedFrames, tolerance: edgeTolerance, gapOnly: sample.clickCount == 2) { if sample.clickCount == 2 { effects += validated(.tileEdgeReset(edge), direction: direction(edge, delta: 1), state: state) } else { session = Session( baseline: state, gesture: .edge(edge), start: point, button: sample.button, last: point, timestamp: sample.timestamp) effects.append(.beginResize(edge.affectedWindows)) } return effects } guard let windowAtStart, windowAtStart.layer == 0 else { return effects } let window = WindowID(rawValue: windowAtStart.windowNumber) guard let managed = state.windows[window], managed.app.pid == windowAtStart.pid, let key = state.workspace(containing: window), state.isActive(key), let frame = observedFrames[window] ?? state.frames[window], managed.facts?.isFullScreen != true, managed.facts?.isMinimized != true, managed.facts?.isModal != true, managed.facts?.hasSheet != true, managed.facts?.isResizable != false, frame.isValid else { return effects } let directMove = configuration.enabled && sample.wasClaimed != false && sample.button == .left && matches(sample.modifiers, configuration.moveModifiers) let directResize = configuration.enabled && sample.wasClaimed != false && sample.button == .right && matches(sample.modifiers, configuration.resizeModifiers) if directMove || directResize { session = Session( baseline: state, gesture: .direct(window, frame, resizing: directResize), start: point, button: sample.button, last: point, timestamp: sample.timestamp) effects.append(.beginDirect(window)) } else if sample.button == .left, !managed.isFloating || (configuration.enabled && configuration.edgeSnapping) { session = Session( baseline: state, gesture: .window(window, frame, floating: managed.isFloating), start: point, button: sample.button, last: point, timestamp: sample.timestamp) effects.append(.suspend(window)) } return effects } guard var active = session else { return [] } guard sample.kind == .modifiersChanged || sample.button == active.button else { return [] } if active.cancelled { return sample.kind == .up ? finish(active, state: state) : [] } let dx = point.xCoordinate - active.start.xCoordinate let dy = point.yCoordinate - active.start.yCoordinate if sample.timestamp > active.timestamp { let interval = sample.timestamp - active.timestamp active.velocity = Point( x: (point.xCoordinate - active.last.xCoordinate) / interval, y: (point.yCoordinate - active.last.yCoordinate) / interval) } active.last = point active.timestamp = sample.timestamp active.moved = active.moved || dx * dx + dy * dy >= minimumDistance * minimumDistance session = active var effects: [MouseEffect] = [] if active.moved { switch active.gesture { case .edge(let edge): let delta = edge.axis == .horizontal ? dx : dy effects += validated( .tileEdgeResized(edge, delta: delta), direction: direction(edge, delta: delta), state: state) case .window(let window, let startFrame, let floating): let current = observedFrames[window] ?? state.frames[window] if let current, !current.matches(startFrame) { if floating { effects += floatingDrop( window, frame: current, at: point, sample: sample, state: state, configuration: configuration) } else { if abs(current.size.width - startFrame.size.width) > 1 || abs(current.size.height - startFrame.size.height) > 1 { effects += nativeResize( window, start: startFrame, current: current, sample: sample, state: state) } else { effects += tiledDrop( window, at: point, sample: sample, state: state, configuration: configuration) } } } else { session?.candidate = nil session?.previewFrames = [] effects += [.feedback(.targetChanged(nil)), .feedback(.layoutPreview(nil))] } case .direct(let window, let startFrame, let resizing): let requested = MouseGestureGeometry.directFrame( start: startFrame, from: active.start, to: point, resizing: resizing, minimum: state.windows[window]?.minimumSize ?? Size()) let frame = MouseGestureGeometry.bounded(requested, state: state) guard frame.isValid, frame.maxX.isFinite, frame.maxY.isFinite else { return cancel(state: state, awaitingMouseUp: sample.kind != .up) + [.report(.invalidGeometry)] } let minimum = state.windows[window]?.minimumSize ?? Size() guard frame.size.width >= minimum.width, frame.size.height >= minimum.height else { let refusal = refuse(.cannotFit([window]), direction: .right) return refusal + (sample.kind == .up ? finish(active, state: state) : []) } if sample.kind != .up { effects.append(.writeFrame(WindowFrame(window: window, frame: frame))) } effects += floatingDrop( window, frame: frame, at: point, sample: sample, state: state, configuration: configuration, allowsSnapping: !resizing, commitWithoutSnap: true) } } if sample.kind == .up { effects += finish(active, state: state) } return effects }
public mutating func cancel(state: State, awaitingMouseUp: Bool = true) -> [MouseEffect] { guard var active = session else { return [] } if !awaitingMouseUp { active.cancelled = true return finish(active, state: state) } guard !active.cancelled else { return [] } active.cancelled = true session = active return [.feedback(.targetChanged(nil)), .feedback(.layoutPreview(nil))] }
private mutating func finish(_ active: Session, state: State) -> [MouseEffect] { var effects: [MouseEffect] switch active.gesture { case .window(let window, _, _): effects = [.resume(window, dropping: active.moved)] case .direct(let window, let startFrame, _): effects = active.cancelled ? [.writeFrame(WindowFrame(window: window, frame: startFrame))] : [] effects.append(.endDirect(window)) case .edge(let edge): effects = active.cancelled ? validated(.tileEdgeResized(edge, delta: 0), direction: direction(edge, delta: 1), state: state) : [] effects.append(.endResize) } session = nil return effects + [.feedback(.targetChanged(nil)), .feedback(.layoutPreview(nil))] }
private func intent(for flags: HotKey.Modifiers, configuration: MouseConfiguration) -> Intent { guard configuration.enabled, !flags.contains(.function) else { return .settle } let modifiers = MouseModifiers(rawValue: UInt8(flags.rawValue & 0x0F)) if modifiers == configuration.stackModifiers { return .stack } if modifiers == configuration.swapModifiers { return .swap } return .settle }
public static func edgeRegion( _ edge: TileEdge, state: State, observedFrames: [WindowID: Rect], tolerance: Double = 5 ) -> MouseEdgeRegion { let windows = edge.affectedWindows.compactMap { id -> DragWindow? in guard let window = state.windows[id], !window.isFloating, let frame = observedFrames[id] ?? state.observedFrames[id] ?? state.frames[id] else { return nil } return DragWindow(pid: window.app.pid, windowNumber: id.rawValue, bounds: frame.cgRect) } let halfGap = (edge.axis == .horizontal ? edge.frame.size.width : edge.frame.size.height) / 2 let band = max(tolerance, halfGap + MouseEdgeRegion.ownedEdgeTolerance) return MouseEdgeRegion( hitArea: edge.hitArea(tolerance: band).cgRect, gapArea: edge.frame.cgRect, windows: windows, verticalDivider: edge.axis == .horizontal) }
private static func edgePriority(_ edge: TileEdge, at point: Point) -> (Double, Int) { let coordinate = edge.axis == .horizontal ? point.xCoordinate : point.yCoordinate return (abs(coordinate - edge.position), edge.path.count) }
private func matches(_ flags: HotKey.Modifiers, _ modifiers: MouseModifiers) -> Bool { !modifiers.isEmpty && !flags.contains(.function) && MouseModifiers(rawValue: UInt8(flags.rawValue & 0x0F)) == modifiers }
private mutating func tiledDrop( _ window: WindowID, at point: Point, sample: DragSample, state: State, configuration: MouseConfiguration ) -> [MouseEffect] { guard let active = session else { return [] } guard nativeTopologyMatches(active.baseline, state: state, source: window) else { return cancel(state: state, awaitingMouseUp: sample.kind != .up) } if sample.kind == .up, active.candidateRegion?.contains(point) == false { return [] } let intent = intent(for: sample.modifiers, configuration: configuration) let dropIntent: WindowDropIntent = intent == .stack ? .stack : intent == .swap ? .swap : .move let key = MouseGestureGeometry.workspace(at: point, state: state) guard let key else { return preview(nil, source: window, targets: [], selected: nil, state: state) + refuse(.invalidDropTarget(window), direction: .right) } var targets: [DragLayoutTarget] = [] if let stacks = state.workspaces[key]?.tree?.stacks { targets = stacks.enumerated().compactMap { index, stack in guard let frame = state.frames[stack.visible] else { return nil } return DragLayoutTarget(id: index + 1, kind: .tile(index + 1), frame: frame) } } let ratio = configuration.dropToRatio && intent != .settle ? MouseGestureGeometry.ratioDrop(source: window, at: point, state: state, tolerance: 24) : nil var event = (ratio ?? MouseGestureGeometry.drop( source: window, at: point, intent: dropIntent, state: active.baseline, wholeTiles: sample.modifiers.isEmpty))? .event var selected = targets.first(where: { $0.frame.contains(point) })?.id if key == state.workspace(containing: window), let screen = state.displays[key.display]?.frame { let full = Event.gestureCommitted(.fullHeight(window: window)) let (candidate, issues) = ParcelCore.reduce(state, full) if !issues.contains(where: { if case .report = $0 { true } else { false } }), candidate.frames[window] != state.frames[window] { let id = targets.count + 1 let region = Rect(x: screen.center.xCoordinate - 60, y: screen.minY + 40, width: 120, height: 36) targets.append(DragLayoutTarget(id: id, kind: .fullHeight, frame: region)) if region.contains(point) { event = full; selected = id } } } let feedback = preview(event, source: window, targets: targets, selected: selected, state: state) return feedback + (sample.kind == .up ? commitPreview(state: state) : []) }
private func nativeTopologyMatches(_ baseline: State, state: State, source: WindowID) -> Bool { guard baseline.displays == state.displays, baseline.activeSpaces == state.activeSpaces, baseline.windows.count == state.windows.count, baseline.workspaces.count == state.workspaces.count, baseline.windows.allSatisfy({ id, window in guard let current = state.windows[id] else { return false } return window.app == current.app && window.isFloating == current.isFloating }) else { return false } return baseline.workspaces.allSatisfy { key, before in guard let after = state.workspaces[key], before.layout == after.layout, before.ratio == after.ratio, before.layoutVariant == after.layoutVariant, before.gaps == after.gaps, before.reservedEdges == after.reservedEdges, before.windowCap == after.windowCap, before.whenFull == after.whenFull, before.order == after.order, before.layout != .accordion || before.focus == after.focus else { return false } let previousFocus = baseline.modes(for: key).focusedWindow let currentFocus = state.modes(for: key).focusedWindow guard previousFocus == currentFocus || (previousFocus == source && currentFocus == nil) else { return false } switch (before.tree, after.tree) { case (.none, .none): return true case (.some(let first), .some(let second)): return nativeTreeMatches(first, second) default: return false } } }
private func nativeTreeMatches(_ first: TileTree, _ second: TileTree) -> Bool { var pending = [(first, second)] while let (left, right) = pending.popLast() { switch (left, right) { case (.tile(let a), .tile(let b)): guard a.windows == b.windows, a.isUserMade == b.isUserMade else { return false } case (.split(let axis, let fraction, let a, let b), .split(let otherAxis, let otherFraction, let c, let d)), ( .partition(let axis, let fraction, let a, let b), .partition(let otherAxis, let otherFraction, let c, let d) ): guard axis == otherAxis, fraction == otherFraction else { return false } pending.append((a, c)) pending.append((b, d)) default: return false } } return true }
private mutating func nativeResize( _ window: WindowID, start: Rect, current: Rect, sample: DragSample, state: State ) -> [MouseEffect] { guard let active = session, nativeTopologyMatches(active.baseline, state: state, source: window) else { return cancel(state: state, awaitingMouseUp: sample.kind != .up) } var changes: [TileResizeChange] = [] for axis in [Axis.horizontal, .vertical] { let sizeDelta = axis == .horizontal ? current.size.width - start.size.width : current.size.height - start.size.height guard abs(sizeDelta) > 1 else { continue } let leadingMoved = axis == .horizontal ? abs(current.minX - start.minX) > 1 : abs(current.minY - start.minY) > 1 let coordinate = axis == .horizontal ? (leadingMoved ? start.minX : start.maxX) : (leadingMoved ? start.minY : start.maxY) let candidates = state.tileEdges.filter { $0.axis == axis && $0.affectedWindows.contains(window) } let edge = candidates.min { first, second in let firstDistance = abs(first.position - coordinate) let secondDistance = abs(second.position - coordinate) return firstDistance == secondDistance ? first.path.count < second.path.count : firstDistance < secondDistance } guard let edge else { continue } let delta = edge.firstWindows.contains(window) ? sizeDelta : -sizeDelta changes.append(TileResizeChange(edge: edge, delta: delta)) } let event: Event? = changes.isEmpty ? nil : .gestureCommitted(.resizeTile(window: window, changes: changes)) let feedback = preview(event, source: window, targets: [], selected: nil, state: state) return feedback + (sample.kind == .up ? commitPreview(state: state) : []) }
private mutating func preview( _ event: Event?, source: WindowID, targets: [DragLayoutTarget], selected: Int?, state: State ) -> [MouseEffect] { session?.candidate = nil session?.previewFrames = [] session?.candidateRegion = nil var frames: [WindowFrame] = [] var accepted = false var refusals: [MouseEffect] = [] if let event { let (next, effects) = ParcelCore.reduce(state, event) let reports = effects.compactMap { effect -> Report? in if case .report(let report) = effect { return report } return nil } if reports.isEmpty { frames = next.frames.keys.sorted().compactMap { window in guard next.windows[window]?.isFloating == false, let frame = next.frames[window] else { return nil } return WindowFrame(window: window, frame: frame) } session?.candidate = event session?.previewFrames = frames accepted = true session?.refused = false } else if session?.refused != true { session?.refused = true refusals = reports.map { .report($0) } + [.feedback(.refused(.right))] } } let target = accepted ? targets.first(where: { $0.id == selected }) : nil session?.candidateRegion = target?.frame let targetWindow = state.visibleWindows.first { $0 != source && state.frames[$0] == target?.frame } ?? source let outline: Rect? if let event, case .gestureCommitted(.swapTiles) = event { outline = frames.first { $0.window == source }?.frame } else { outline = target?.frame } return refusals + [ .feedback( .targetChanged(target.flatMap { _ in outline.map { WindowFrame(window: targetWindow, frame: $0) } })), .feedback( .layoutPreview( DragLayoutPreview( source: source, targets: targets, selectedTarget: accepted ? selected : nil, frames: frames))), ] }
private mutating func commitPreview(state: State) -> [MouseEffect] { guard let active = session, let event = active.candidate else { return [] } let (next, effects) = ParcelCore.reduce(state, event) guard !effects.contains(where: { if case .report = $0 { true } else { false } }), active.previewFrames.allSatisfy({ next.frames[$0.window] == $0.frame }) else { return [] } return [.event(event), .feedback(.dropped(velocity: active.velocity))] }
private mutating func floatingDrop( _ window: WindowID, frame: Rect, at point: Point, sample: DragSample, state: State, configuration: MouseConfiguration, allowsSnapping: Bool = true, commitWithoutSnap: Bool = false ) -> [MouseEffect] { do { let snap = configuration.enabled && configuration.edgeSnapping && allowsSnapping ? try MouseGestureGeometry.snap(at: point, current: frame, state: state, tolerance: 20) : nil let key = snap?.0 ?? MouseGestureGeometry.workspace(at: point, state: state) ?? state.workspace(containing: window) guard let key else { return [.feedback(.targetChanged(nil))] } let target = snap?.1 ?? frame let event = Event.gestureCommitted(.floatingFrame(window: window, workspace: key, frame: target)) var effects: [MouseEffect] = [] if snap != nil || commitWithoutSnap || sample.kind == .up { effects = validated(event, direction: .right, state: state) let accepted = effects.contains(.event(event)) if sample.kind != .up { effects.removeAll { if case .event = $0 { true } else { false } } } else if commitWithoutSnap, accepted { effects.removeAll { if case .event = $0 { true } else { false } } effects.append( .commitDirect( window: window, workspace: key, frame: target, dropVelocity: snap != nil ? session?.velocity ?? Point() : nil)) } effects.append( .feedback( .targetChanged(snap != nil && accepted ? WindowFrame(window: window, frame: target) : nil))) if sample.kind == .up, snap != nil, accepted, !commitWithoutSnap { effects.append(.feedback(.dropped(velocity: session?.velocity ?? Point()))) } } else { effects.append(.feedback(.targetChanged(nil))) } return effects } catch { return refuse(.invalidGeometry, direction: .right) + [.feedback(.targetChanged(nil))] } }
private mutating func validated(_ event: Event, direction: Direction, state: State) -> [MouseEffect] { let (_, effects) = ParcelCore.reduce(state, event) let reports = effects.compactMap { effect -> Report? in if case .report(let report) = effect { return report } return nil } if !reports.isEmpty { guard session?.refused != true else { return [] } session?.refused = true return reports.map { .report($0) } + [.feedback(.refused(direction))] } session?.refused = false return [.event(event)] }
private mutating func refuse(_ report: Report, direction: Direction) -> [MouseEffect] { guard session?.refused != true else { return [] } session?.refused = true return [.report(report), .feedback(.refused(direction))] }
private func direction(_ edge: TileEdge, delta: Double) -> Direction { edge.axis == .horizontal ? (delta < 0 ? .left : .right) : (delta < 0 ? .up : .down) }}