Something went wrong. Try again.
An auto tiler for macOS
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543import Foundationimport ParcelAnimationimport ParcelCoreimport ParcelPlatform
extension ParcelEngine { func intentionalFrameWindows(for pending: [Pending], previous: State, next: State) -> Set<WindowID> { var windows: Set<WindowID> = [] for item in pending { let command: Command let key: WorkspaceKey? switch item.event { case .commandIssued(let value): command = value key = previous.activeWorkspace case .workspaceCommandIssued(let value, let workspace): command = value key = workspace case .commandForWindow(let window, let value, let workspace): command = value key = workspace ?? previous.workspace(containing: window) default: continue } guard let key else { continue } var candidates = next.workspaces[key]?.visibleWindows ?? [] if command == .toggleFloat { candidates += (next.workspaces[key]?.order ?? []).filter { previous.windows[$0]?.isFloating == false && next.windows[$0]?.isFloating == true } } for window in candidates where command == .retile || command == .resetSizes || next.frames[window] != previous.frames[window] { windows.insert(window) } } return windows }
func planFrames(manualWindows: Set<WindowID> = [], intentionalWindows: Set<WindowID> = []) { guard !isWaitingForTour || tourFrameScope != nil, writesPermitted, !spaceCommandRunning, isAutomaticTilingEnabled || !manualWindows.isEmpty || manualWorkspaceRestoration != nil || !manualCommandFrames.isEmpty || tourFrameScope != nil else { return } prepareAcceptedFrames() updateMotion() let now = animationTime let snappedForBudget = windowsOutsideAnimationBudget() for window in snapshot.state.frames.keys.sorted() { guard !dragging.contains(window), !blockedWindows.contains(window), !operatingWindows.contains(window) else { continue } guard let managed = snapshot.state.windows[window], let key = snapshot.state.workspace(containing: window), !unmanageableApps.contains(managed.app), !wedgedApps.contains(managed.app), !suspendedDisplays.contains(key.display), tourAllowsFrame(window, in: key), snapshot.state.isActive(key), isAutomaticTilingEnabled || manualWindows.contains(window) || manualWorkspaceRestoration == key || manualCommandFrames[window] != nil || tourFrameScope?.workspace == key, let desired = manualCommandFrames[window] ?? manualRestorationFrames[window] ?? snapshot.state.frames[window], let screen = snapshot.state.displays[key.display] else { continue } let restoringFrame = manualWorkspaceRestoration == key && manualRestorationFrames[window] != nil guard let target = restoringFrame ? desired : targetAvoidingAcceptedFrames(desired, for: window, in: key) else { cancelMotion(window, remove: false) deliver(.cannotFit([window])) continue } let revalidate = manualWindows.contains(window) if revalidate, animators[key.display]?.contains(window.motionID) != true { // A missed notification must not turn an explicit command into a cache hit. cancelMotion(window, remove: false, preservingUnboundFloat: true) } if !revalidate, explicitFloatPlacements[window] == nil, manualCommandFrames[window] == target, actualFrames[window] == target, motionPlans[window] == nil, pendingFrames[window.motionID] == nil { manualCommandFrames[window] = nil continue } if !revalidate, let adjustment = frameAdjustments[window], adjustment.requested == target, !needsMinimumConfirmation(window), managed.isFloating || adjustment.accepted.fitsInside(target), actualFrames[window]?.matches(adjustment.accepted) == true { targets[window] = target continue } if dropping.contains(window), !finalResizeWindows.contains(window), actualFrames[window] == target { dropping.remove(window) } if !revalidate, !finalResizeWindows.contains(window), targets[window] == target && (liveResizeWindows.contains(window) || actualFrames[window] == target || animators[key.display]?.contains(window.motionID) == true) { continue } // Capturing an edge must not consume its first changed sample's timestamp and revision. if !revalidate, !finalResizeWindows.contains(window), actualFrames[window] == target, liveResizeWindows.contains(window) ? targets[window] == nil : motionPlans[window] == nil && pendingFrames[window.motionID] == nil { targets[window] = target continue } do { if placements[window] != key.display { cancelMotion(window, remove: false, preservingUnboundFloat: true) _ = coalescer.activate(window.motionID, appID: managed.app.motionID) placements[window] = key.display } if coalescer.generation(for: window.motionID) == nil { _ = coalescer.activate(window.motionID, appID: managed.app.motionID) } if let generation = coalescer.generation(for: window.motionID) { bindExplicitFloatPlacement(window, generation: generation) } var animator = animators[key.display] ?? Animator( policy: applied.motionPolicy(reduceMotion: reduceMotion, snap: snapNextPass), settings: applied.motionSettings) let minimum = managed.minimumSize ?? Size() let confirmation = needsMinimumConfirmation(window) let destination: Rect if confirmation, let adjustment = frameAdjustments[window], adjustment.requested == target { destination = MinimumSizeLearning.confirmationFrame( requested: target, accepted: adjustment.accepted, knownMinimum: minimum) } else { destination = target } let start = actualFrames[window] ?? target let oversizedFloat = managed.isFloating && (target.size.width > screen.frame.size.width || target.size.height > screen.frame.size.height) let bounds: Rect if oversizedFloat || restoringFrame { let left = min(screen.frame.minX, start.minX, target.minX) let top = min(screen.frame.minY, start.minY, target.minY) bounds = Rect( x: left, y: top, width: max(screen.frame.maxX, start.maxX, target.maxX) - left, height: max(screen.frame.maxY, start.maxY, target.maxY) - top) } else { bounds = screen.frame } let request = MotionRequest( windowID: window.motionID, appID: managed.app.motionID, start: start.motionRect, target: destination.motionRect, screen: bounds.motionRect, minimumSize: MotionSize( width: min(minimum.width, destination.size.width), height: min(minimum.height, destination.size.height)), token: dropping.contains(window) || intentionalWindows.contains(window) ? .drop : .settle, metrics: coalescer.metricsSnapshot[managed.app.motionID] ?? AppWriteMetrics(), generation: coalescer.generation(for: window.motionID) ?? 0, animationAllowed: !snappedForBudget.contains(window) && !confirmation && !oversizedFloat ) if liveResizeWindows.contains(window) { var live = Animator(policy: MotionPolicy(enabled: false), settings: applied.motionSettings) try live.schedule([request], at: now) if let plan = live.plan(for: window.motionID) { bindActivity(plan, window: window) } for frame in try live.tick(at: now) where try coalescer.submit(frame) { pendingFrames[frame.windowID] = frame if let transaction = planningTrace { frameTransactions[window] = (frame.generation, frame.revision, transaction) beginMotionTrace(transaction) } } targets[window] = target continue } try animator.schedule([request], at: now) if let plan = animator.plan(for: window.motionID) { rememberMotionPlan(plan, window: window) } if let transaction = planningTrace, let sample = try animator.presentation(for: window.motionID, at: now) { frameTransactions[window] = (sample.frame.generation, sample.frame.revision, transaction) beginMotionTrace(transaction) } dropping.remove(window) targets[window] = target animators[key.display] = animator if links[key.display] == nil { links[key.display] = try makeDisplayLink(key.display) } } catch { motionFailure(error, window: window) } } updateFocusedMotionPlan() for display in animators.keys.sorted() { tick(display, at: now) } pump() }
func rememberMotionPlan(_ plan: FramePlan, window: WindowID) { bindRetile(window, plan: plan) bindActivity(plan, window: window) if let existing = motionPlans[window]?.plan, existing.revision == plan.revision && existing.request.generation == plan.request.generation { return } nextMotionPlan += 1 motionPlans[window] = EngineFocusMotionPlan(id: nextMotionPlan, plan: plan) dispatchedMotionTimes[window] = nil }
func updateFocusedMotionPlan() { snapshot.focusedMotionPlan = snapshot.focusedWindow.flatMap { motionPlans[$0] } }
private func windowsOutsideAnimationBudget() -> Set<WindowID> { var apps: [AppID: [WindowID]] = [:] for (window, target) in snapshot.state.frames where actualFrames[window] != target { guard let managed = snapshot.state.windows[window], !dragging.contains(window) else { continue } apps[managed.app, default: []].append(window) } var snapped: Set<WindowID> = [] for (app, windows) in apps { guard let budget = coalescer.metricsSnapshot[app.motionID]?.animationWindowBudget(), windows.count > budget else { continue } let ordered = windows.sorted { left, right in if left == snapshot.focusedWindow { return true } if right == snapshot.focusedWindow { return false } @MainActor func distance(_ window: WindowID) -> Double { guard let before = actualFrames[window], let target = snapshot.state.frames[window] else { return 0 } return abs(before.minX - target.minX) + abs(before.minY - target.minY) } let a = distance(left) let b = distance(right) return a == b ? left < right : a > b } snapped.formUnion(ordered.dropFirst(budget)) } return snapped }
var animationTime: Double { // Display links lead the clock. Removing the leading display must not rewind the writer. engineTime = max(engineTime, max(clock.now, animators.values.compactMap(\.timestamp).max() ?? clock.now)) return engineTime }
func updateMotion() { let now = animationTime for display in animators.keys { do { let policy = applied.motionPolicy(reduceMotion: reduceMotion, snap: snapNextPass) let changed = animators[display]?.policy != policy || animators[display]?.settings != applied.motionSettings if animators[display]?.policy != policy { try animators[display]?.updatePolicy(policy, at: now) } if animators[display]?.settings != applied.motionSettings { try animators[display]?.updateSettings(applied.motionSettings, at: now) } if changed { for id in animators[display]?.activeWindowIDs ?? [] { if let window = WindowID(exactly: id), let plan = animators[display]?.plan(for: id) { rememberMotionPlan(plan, window: window) } } updateFocusedMotionPlan() } if changed, trace != nil { for id in animators[display]?.activeWindowIDs ?? [] { if let window = WindowID(exactly: id), let previous = frameTransactions[window], let sample = try animators[display]?.presentation(for: id, at: now) { frameTransactions[window] = ( sample.frame.generation, sample.frame.revision, planningTrace ?? previous.transaction ) } } } } catch { motionFailure(error) } } if reduceMotion { for display in animators.keys.sorted() { tick(display, at: now) } } }
func tick(_ display: DisplayID, at timestamp: Double) { guard isRunning, !suspendedDisplays.contains(display) else { return } let interval = emissionTrace.emits(.tick) ? emissionTrace.beginInterval( .tick, value: UInt64(animators[display]?.activeWindowCount ?? 0), detail: 0) : nil defer { emissionTrace.endIfStarted(.tick, interval) } do { guard timestamp.isFinite else { throw MotionError.invalidTimestamp } engineTime = max(timestamp, animationTime) let now = engineTime motionTick += 1 if let link = links[display] { MotionWriteTrace.tick(motionTick, interval: 1 / link.frameRate) } let frames = try animators[display]?.tick(at: now) ?? [] for frame in frames { if let window = WindowID(exactly: frame.windowID), let finalized = finalizedMotionPlans[window], finalized == motionPlans[window]?.id { continue } if try coalescer.submit(frame) { pendingFrames[frame.windowID] = frame } } if animators[display]?.isIdle == true { links[display]?.stop() } else if links[display]?.isRunning == false { links[display]?.start { [weak self] timestamp in guard let self, self.links[display]?.isRunning == true else { return } self.tick(display, at: timestamp) } } pump() } catch { motionFailure(error) } settleIfIdle() }
func pump() { guard isRunning, !spaceCommandRunning, !pumping else { return } pumping = true pumpWake?.cancel() pumpWake = nil do { var rates: [MotionAppID: Double] = [:] for frame in pendingFrames.values { guard let window = WindowID(exactly: frame.windowID), let display = placements[window], let link = links[display] else { continue } rates[frame.appID] = max(rates[frame.appID] ?? 0, link.frameRate) } for (app, rate) in rates { coalescer.setDisplayRate(rate, for: app) } for pending in try coalescer.takeReady(at: animationTime) { let latency = (coalescer.metricsSnapshot[pending.appID]?.p50WriteDuration ?? 0) * Double(pending.frames.count) let batch = try pending.resampled { frame in guard !frame.isFinal, let window = WindowID(exactly: frame.windowID), let plan = motionPlans[window]?.plan, plan.revision == frame.revision, plan.request.generation == frame.generation else { return frame } // Display targets already lead the clock; latency must not add that lead twice. let arrival = max(frame.timestamp, clock.now + latency) let sampleTime = min( plan.endTime, max(arrival, dispatchedMotionTimes[window] ?? frame.timestamp)) dispatchedMotionTimes[window] = sampleTime return try plan.sample(at: sampleTime).frame } for frame in batch.frames where frame.isFinal { if let window = WindowID(exactly: frame.windowID) { finalizedMotionPlans[window] = motionPlans[window]?.id } } MotionWriteTrace.dispatch(app: batch.appID.rawValue, tick: motionTick) busyApps.insert(batch.appID) activeBatches[batch.appID] = batch.identifier lastDispatch[batch.appID] = batch.dispatchedAt for frame in batch.frames { pendingFrames[frame.windowID] = nil } let writes = batch.frames.compactMap { frame -> EngineFrameWrite? in guard let window = WindowID(exactly: frame.windowID), let managed = snapshot.state.windows[window], managed.app.motionID == batch.appID, let workspace = snapshot.state.workspace(containing: window), snapshot.state.isActive(workspace), tourAllowsFrame(window, in: workspace), !suspendedDisplays.contains(workspace.display) else { return nil } let rect = Rect(frame.rect) let planID = motionPlans[window]?.id let firstWrite = planID != nil && writtenMotionPlans[window] != planID guard actualFrames[window] != rect || frame.isFinal || firstWrite else { return nil } writtenMotionPlans[window] = planID rememberEcho(window, frame: rect, transaction: batch.identifier, generation: frame.generation) return EngineFrameWrite( window: window, frame: rect, transaction: batch.identifier, generation: frame.generation, isFinal: frame.isFinal, capturesInitialFrame: capturesRetileBaseline(window, sent: frame) || capturesActivityBaseline(window, sent: frame), resetsSizeFit: pendingSizeFitResets.contains(window)) } if let activity, activity.isEnabled { activityBatchGenerations[batch.identifier] = activity.generation } let generation = lifetime if writes.isEmpty { complete(batch, receipt: EngineWriteReceipt(frames: [], duration: 0), recordMetrics: false) continue } guard let first = writes.first, let app = snapshot.state.windows[first.window]?.app else { preconditionFailure("A write batch must belong to a managed app") } if let trace { for frame in batch.frames where writes.contains(where: { $0.window.motionID == frame.windowID }) { if let window = WindowID(exactly: frame.windowID), let planned = frameTransactions[window], planned.generation == frame.generation, planned.revision == frame.revision { finishFirstWriteTrace(planned.transaction) } } openWrites.insert(batch.identifier) trace.begin(.write, transaction: batch.identifier) } let emissionTrace = emissionTrace let writeInterval = emissionTrace.beginIfEnabled( .write, value: UInt64(UInt32(bitPattern: batch.appID.rawValue)), detail: batch.identifier) for write in writes { workspaceWriteAttempts[write.window, default: 0] += 1 snapshot.readbackFrames[write.window] = nil } world.write(writes, for: app) { [weak self] receipt in if let writeInterval { let outcome: UInt64 = receipt.failures.isEmpty ? 0 : receipt.failures.contains(where: \.isTimeout) ? 2 : 1 emissionTrace.endInterval(.write, writeInterval, value: outcome, detail: batch.identifier) } guard let self, self.isRunning, self.lifetime == generation, self.activeBatches[batch.appID] == batch.identifier else { return } if let trace = self.trace { self.openWrites.remove(batch.identifier) trace.end(.write, transaction: batch.identifier) } self.complete(batch, receipt: receipt) } } } catch { motionFailure(error) } pumping = false schedulePumpIfNeeded() }
func complete(_ batch: FrameBatch, receipt: EngineWriteReceipt, recordMetrics: Bool = true) { let activityGeneration = activityBatchGenerations.removeValue(forKey: batch.identifier) completeEchoes(batch, receipt: receipt) let previousMetrics = coalescer.metricsSnapshot[batch.appID] do { try coalescer.complete( batch, duration: receipt.duration, writtenWindows: receipt.writtenWindowCount, timedOut: receipt.failures.contains(where: \.isTimeout), at: animationTime) if !recordMetrics { if let previousMetrics { coalescer.setMetrics(previousMetrics, for: batch.appID) } else { coalescer.resetMetrics(for: batch.appID) } } busyApps.remove(batch.appID) activeBatches[batch.appID] = nil for initial in receipt.initialFrames { guard let sent = batch.frames.first(where: { $0.windowID == initial.window.motionID }), coalescer.generation(for: sent.windowID) == sent.generation else { continue } acceptRetileBaseline(initial, sent: sent) acceptActivityBaseline(initial, sent: sent, collectionGeneration: activityGeneration) } for observed in receipt.frames { guard let sent = batch.frames.first(where: { $0.windowID == observed.window.motionID }), coalescer.generation(for: sent.windowID) == sent.generation else { continue } acceptRetileReadback(observed, sent: sent) acceptActivityReadback(observed, sent: sent) if receipt.frameWriteDiagnostics[observed.window] != nil { pendingSizeFitResets.remove(observed.window) } acceptReadback(observed, sent: sent, frameWrite: receipt.frameWriteDiagnostics[observed.window]) if sent.isFinal, !liveResizeWindows.contains(observed.window), let app = snapshot.state.windows[observed.window]?.app { settledApps.insert(app) } } if !receipt.frames.isEmpty { for subscriber in subscribers.values { subscriber.yield(snapshot) } } if !recordMetrics { for frame in batch.frames where frame.isFinal { if let window = WindowID(exactly: frame.windowID), let app = snapshot.state.windows[window]?.app, coalescer.generation(for: frame.windowID) == frame.generation, !liveResizeWindows.contains(window) { settledApps.insert(app) } } } for failure in receipt.failures { if let window = failure.vanishedWindow, let sent = batch.frames.first(where: { $0.windowID == window.motionID }), coalescer.generation(for: sent.windowID) != sent.generation { continue } handle(failure) } if !receipt.failures.isEmpty { for frame in batch.frames where frame.isFinal { if let window = WindowID(exactly: frame.windowID), coalescer.generation(for: frame.windowID) == frame.generation, !liveResizeWindows.contains(window), echoes[window, default: []].contains(where: { $0.transaction == batch.identifier }), !receipt.frames.contains(where: { $0.window == window }) { noteCorrectiveWrite(window) } } } finishMouseWrite(batch, receipt: receipt) } catch { coalescer.removeApp(batch.appID) if let previousMetrics { coalescer.setMetrics(previousMetrics, for: batch.appID) } busyApps.remove(batch.appID) activeBatches[batch.appID] = nil for window in snapshot.state.windows.values where window.app.motionID == batch.appID { cancelMotion(window.id, remove: false) } if let motion = error as? MotionError { log.record(.motion(motion)) } else { log.record(.internalFailure(error)) } } onMouseInputChanged?() pump() settleIfIdle() }
func schedulePumpIfNeeded() { guard pumpWake == nil, !pendingFrames.isEmpty, animators.values.allSatisfy(\.isIdle) else { return } let now = animationTime let apps = Set(pendingFrames.values.map(\.appID)).subtracting(busyApps) let delays = apps.map { app in let rate = coalescer.frameRate(for: app) return max(0, (lastDispatch[app] ?? now - 1 / rate) + 1 / rate - now) } guard let delay = delays.min() else { return } pumpWake = scheduler.schedule(after: max(delay, 0.000_001)) { [weak self] in self?.pumpWake = nil self?.pump() self?.settleIfIdle() } }
}