Something went wrong. Try again.
An auto tiler for macOS
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349import Foundationimport ParcelAnimationpublic import ParcelCoreimport ParcelPlatform
private enum MouseWriteFailure: Error { case missingReadback(WindowID)}
extension EnginePlatformFailure { fileprivate func affectsMouseCommit(_ commit: PendingMouseCommit, state: State) -> Bool { let app = state.windows[commit.window]?.app switch self { case .appUnavailable(let failed), .accessibility(let failed, _, _), .appThread(let failed, _), .timedOut(let failed): return failed == app case .vanished(let window), .correctiveWriteLimit(let window, _): return window == commit.window case .operation, .unexpected, .permissionLost: return true } }}
extension ParcelEngine { func rememberEcho(_ window: WindowID, frame: Rect, transaction: UInt64, generation: UInt64) { var recent = echoes[window, default: []].filter { echoIsRecent($0, window: window) } if let previous = actualFrames[window], previous != frame { // CG can still show the old frame after AX has confirmed the write. recent.append( Echo(frame: previous, transaction: transaction, generation: generation, completedAt: nil)) } // Size goes first, so AX can report the old position with the new size. if let previous = actualFrames[window], previous.size != frame.size { recent.append( Echo( frame: Rect(origin: previous.origin, size: frame.size), transaction: transaction, generation: generation, completedAt: nil)) recent.append( Echo( frame: Rect(origin: frame.origin, size: previous.size), transaction: transaction, generation: generation, completedAt: nil)) } recent.append(Echo(frame: frame, transaction: transaction, generation: generation, completedAt: nil)) echoes[window] = Array(recent.suffix(64)) }
func completeEchoes(_ batch: FrameBatch, receipt: EngineWriteReceipt) { if let app = snapshot.state.windows.values.first(where: { $0.app.motionID == batch.appID })?.app, receipt.duration.isFinite, receipt.duration >= 0 { echoLatencies[app] = max(echoLatencies[app, default: 0], receipt.duration) } for sent in batch.frames { guard let window = WindowID(exactly: sent.windowID) else { continue } for index in echoes[window, default: []].indices where echoes[window]?[index].transaction == batch.identifier { echoes[window]?[index].completedAt = clock.now } if let observed = receipt.frames.first(where: { $0.window == window }), coalescer.generation(for: sent.windowID) == sent.generation { echoes[window, default: []].append( Echo( frame: observed.frame, transaction: batch.identifier, generation: sent.generation, completedAt: clock.now)) } } }
func echoIsRecent(_ echo: Echo, window: WindowID) -> Bool { guard let completed = echo.completedAt else { return true } let latency = snapshot.state.windows[window].map { echoLatencies[$0.app, default: 0] } ?? 0 return clock.now - completed <= max(0.5, latency * 2 + 0.1) }
func isEcho(_ window: WindowID, frame: Rect, origin: FrameChangeOrigin) -> Bool { if origin == .user { return false } let recent = echoes[window, default: []].filter { echoIsRecent($0, window: window) } if origin == .reconciled { return actualFrames[window] == frame || recent.contains { $0.frame == frame } } // AX queues notifications behind writes. Until receipt, their shape and delay tell us nothing. if case .engine = origin { return true } if targets[window] != nil, actualFrames[window]?.matches(frame) == true { return true } return !recent.isEmpty }
func acceptReadback( _ observed: WindowFrame, sent: MotionFrame, frameWrite: AppThreadFrameWriteDiagnostics? = nil ) { actualFrames[observed.window] = observed.frame if let frameWrite { frameWriteDiagnostics[observed.window] = frameWrite } let commitsMouse = pendingMouseCommit?.window == observed.window && pendingMouseCommit?.generation == sent.generation let gestureFinal = commitsMouse || finalResizeWindows.contains(observed.window) || dropping.contains(observed.window) guard sent.isFinal, commitsMouse || !liveResizeWindows.contains(observed.window) else { return } initialFloatPlacements.remove(observed.window) defer { if commitsMouse { finishMouseCommit(observed) } } if let plan = motionPlans[observed.window]?.plan, plan.revision == sent.revision, plan.request.generation == sent.generation { if let display = placements[observed.window], animators[display]?.plan(for: observed.window.motionID)?.revision == sent.revision { animators[display]?.cancel(observed.window.motionID) if animators[display]?.isIdle == true { links[display]?.stop() } } motionPlans[observed.window] = nil writtenMotionPlans[observed.window] = nil finalizedMotionPlans[observed.window] = nil dispatchedMotionTimes[observed.window] = nil } snapshot.readbackFrames[observed.window] = observed.frame updateFocusedMotionPlan() finalResizeWindows.remove(observed.window) defer { rememberWorkspaceState() } let requested = Rect(sent.rect) var accepted = acceptedReadbacks[observed.window, default: []] let previousAdjustment = accepted.last(where: { $0.requested == requested }) ?? frameAdjustments[observed.window] accepted.removeAll { $0.requested == requested } accepted.append(EngineFrameAdjustment(requested: requested, accepted: observed.frame)) acceptedReadbacks[observed.window] = Array(accepted.suffix(16)) if acceptExplicitFloatReadback(observed, sent: sent) { return } defer { if manualCommandFrames[observed.window] == Rect(sent.rect) { manualCommandFrames[observed.window] = nil } } var managed = snapshot.state.windows[observed.window] if let window = managed { let native = window.facts?.minimumSize ?? observations[window.id]?.window.minimumSize let supported = MinimumSizeLearning.combinedMinimum( native.map { LearnedMinimumSize(size: $0) }, inheritedMinimum(window.minimum, for: window.id)) if supported != window.minimum { managed?.minimum = supported enqueue(.minimumSizeChanged(window.id, minimum: supported)) } } let desired = manualRestorationFrames[observed.window] ?? snapshot.state.frames[observed.window] let known = MinimumSizeLearning.combinedMinimum( managed?.minimum, managed.flatMap { inheritedMinimum(minimumLearning.learned[$0.app.bundleID], for: $0.id) })?.size ?? Size() if !gestureFinal, managed?.isFloating == false, let previous = minimumCandidates[observed.window], previous.confirmations == 1, let original = frameAdjustments[observed.window], original.requested == desired, original.requested != requested, requested == MinimumSizeLearning.confirmationFrame( requested: original.requested, accepted: original.accepted, knownMinimum: managed?.minimumSize ?? Size()) { acceptMinimumProbe(observed, original: original.requested, previous: previous.size, known: known) return } let protrudes = managed?.isFloating == false && !gestureFinal && !observed.frame.fitsInside(requested) guard !observed.frame.matches(requested) || protrudes else { minimumCandidates[observed.window] = nil if observed.frame == requested { frameAdjustments[observed.window] = nil } else { let adjustment = EngineFrameAdjustment( requested: requested, accepted: observed.frame, frameWrite: frameWrite) frameAdjustments[observed.window] = adjustment log.record(.frameAdjusted(observed.window, adjustment)) } correctiveWrites[observed.window] = nil protrusionAttempts[observed.window] = nil return } // A grid can round down as well as up. Accept this target's read-back instead of chasing it. let adjustment = EngineFrameAdjustment(requested: requested, accepted: observed.frame, frameWrite: frameWrite) let stableAdjustment = previousAdjustment?.requested == requested && previousAdjustment?.accepted == observed.frame frameAdjustments[observed.window] = adjustment log.record(.frameAdjusted(observed.window, adjustment)) if managed?.isFloating == false, gestureFinal || desired == requested, let minimum = MinimumSizeLearning.refusedMinimum( requested: requested, accepted: observed.frame, knownMinimum: known) { let previous = minimumCandidates[observed.window] let confirmations = previous?.size == minimum ? (previous?.confirmations ?? 0) + 1 : 1 minimumCandidates[observed.window] = (minimum, confirmations) if confirmations >= 2 { confirmMinimum(minimum, for: observed.window) } else if !gestureFinal { // Only automatic tiles need a probe; gestures supply their own independent final read-backs. targets[observed.window] = nil needsRetile = true scheduleTurn() } } else { minimumCandidates[observed.window] = nil } if protrudes { noteProtrusion(observed.window, requested: requested, accepted: observed.frame) } else { protrusionAttempts[observed.window] = nil if managed?.isFloating == false, observed.frame.fitsInside(requested), stableAdjustment || gestureFinal { correctiveWrites[observed.window] = nil } else { noteCorrectiveWrite(observed.window) } } if protrudes, !blockedWindows.contains(observed.window) { targets[observed.window] = nil needsRetile = true scheduleTurn() } }
private func acceptMinimumProbe(_ observed: WindowFrame, original: Rect, previous: Size, known: Size) { let adjustment = EngineFrameAdjustment(requested: original, accepted: observed.frame) frameAdjustments[observed.window] = adjustment targets[observed.window] = original log.record(.frameAdjusted(observed.window, adjustment)) guard let minimum = MinimumSizeLearning.refusedMinimum( requested: original, accepted: observed.frame, knownMinimum: known) else { minimumCandidates[observed.window] = nil correctiveWrites[observed.window] = nil return } let stableWidth = minimum.width == known.width || minimum.width == previous.width let stableHeight = minimum.height == known.height || minimum.height == previous.height if stableWidth && stableHeight { minimumCandidates[observed.window] = (minimum, 2) confirmMinimum(minimum, for: observed.window) } else { minimumCandidates[observed.window] = (minimum, 1) targets[observed.window] = nil needsRetile = true scheduleTurn() } noteCorrectiveWrite(observed.window) }
private func confirmMinimum(_ minimum: Size, for id: WindowID) { guard let bundleID = snapshot.state.windows[id]?.app.bundleID else { return } let learned = LearnedMinimumSize(size: minimum) persistConfirmedMinimum(learned, for: id) let sharesBounds = !bundleID.isEmpty && !bundleID.contains(where: \.isWhitespace) for window in snapshot.state.windows.values.sorted(by: { $0.id < $1.id }) where window.id == id || (sharesBounds && window.app.bundleID == bundleID) { let applicable = window.id == id ? learned : inheritedMinimum(learned, for: window.id) let existing = window.id == id ? window.minimum : inheritedMinimum(window.minimum, for: window.id) let native = window.facts?.minimumSize ?? observations[window.id]?.window.minimumSize let minimum = MinimumSizeLearning.combinedMinimum( native.map { LearnedMinimumSize(size: $0) }, MinimumSizeLearning.combinedMinimum(existing, applicable)) enqueue( .minimumSizeChanged(window.id, minimum: minimum)) } }
func needsMinimumConfirmation(_ window: WindowID) -> Bool { snapshot.state.windows[window]?.isFloating == false && minimumCandidates[window]?.confirmations == 1 && targets[window] == nil && !liveResizeWindows.contains(window) && !finalResizeWindows.contains(window) && !dragging.contains(window) && pendingMouseCommit?.window != window }
func noteCorrectiveWrite(_ window: WindowID) { guard !blockedWindows.contains(window) else { return } var attempts = correctiveWrites[window, default: []].filter { clock.now - $0 <= 2 } attempts.append(clock.now) correctiveWrites[window] = attempts if attempts.count >= 6 { blockedWindows.insert(window) cancelMotion(window, remove: false) log.record(.platform(.correctiveWriteLimit(window, limit: 6))) } }
public func resetFrameAdjustments(for window: WindowID) { frameAdjustments[window] = nil frameWriteDiagnostics[window] = nil acceptedReadbacks[window] = nil pendingSizeFitResets.insert(window) targets[window] = nil protrusionAttempts[window] = nil exhaustedProtrusionTargets[window] = nil correctiveWrites[window] = nil blockedWindows.remove(window) needsRetile = true if isRunning { scheduleTurn() } }
func handle(_ reported: EnginePlatformFailure) { let failure: EnginePlatformFailure if case .accessibility(let app, let window, .notPermitted) = reported, world.accessibilityPermissionGranted == true { failure = .accessibility( app, window: window, cause: .unavailable("AXError.apiDisabled (-25211, notPermitted) while Parcel remains trusted")) } else { failure = reported } log.record(.platform(failure)) if let window = failure.vanishedWindow { cancelMotion(window, remove: true) enqueue(.windowDisappeared(window)) } if case .appUnavailable(let app) = failure { unmanageableApps.insert(app) for window in snapshot.state.windows.values where window.app == app { cancelMotion(window.id, remove: false) } } if failure.isPermissionLoss { writesPermitted = false cancelMouseGesture() for window in Array(placements.keys) { cancelMotion(window, remove: false) } } else if let pending = pendingMouseCommit, failure.affectsMouseCommit(pending, state: snapshot.state) { abandonMouseCommit() } }
func finishMouseWrite(_ batch: FrameBatch, receipt: EngineWriteReceipt) { guard let pending = pendingMouseCommit, batch.frames.contains(where: { $0.windowID == pending.window.motionID && $0.generation == pending.generation }), !receipt.frames.contains(where: { $0.window == pending.window }) else { return } if receipt.failures.isEmpty { log.record(.internalFailure(MouseWriteFailure.missingReadback(pending.window))) deliver(.invalidGeometry) } abandonMouseCommit() }
func motionFailure(_ error: any Error, window: WindowID? = nil) { if let window { cancelMotion(window, remove: false) } else { for window in Array(placements.keys) { cancelMotion(window, remove: false) } } if let motion = error as? MotionError { log.record(.motion(motion)) } else { log.record(.internalFailure(error)) } }}