Something went wrong. Try again.
An auto tiler for macOS
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530import ParcelAnimationimport ParcelCore
import class ParcelPlatform.DetectionTrace
extension ParcelEngine { func receive(_ event: EnginePlatformEvent, detections: [DetectionTrace]? = nil) { switch event { case .detected(let event, let traces): precondition(detections == nil, "Nested detection metadata") if trace == nil { for detection in traces { detection.dropIfUnowned() } receive(event) } else { receive(event, detections: traces) for detection in traces { detection.dropIfUnowned() } } case .observed(let event): enqueue(event, detections: detections) case .placementReadBack(let initial, let target, let final): if initial != final, final.fitsInside(target) { activity?.record(placements: 1, source: .other) } case .pointerButton(let isDown): pointerChanged(isDown) case .frameChanged(let window, let frame, let resized, let origin): if origin == .user { cancelExplicitFloatPlacement(window) } if frame.isValid, !pointerIsDown, origin == .unknown || origin == .reconciled { if coalesceInitialFrame(window, frame: frame) || (isAutomaticTilingEnabled && initialFloatPlacements.contains(window) && !blockedWindows.contains(window)) { for detection in detections ?? [] { detection.dropIfUnowned() } return } } else if origin == .user || pointerIsDown { initialFloatPlacements.remove(window) } guard !isEcho(window, frame: frame, origin: origin) else { for detection in detections ?? [] { detection.dropIfUnowned() } return } if mouseModel.isActive { nativeMouseFrames[window] = frame } snapshot.readbackFrames[window] = nil if pointerIsDown && !usesMouseSamples && !liveResizeWindows.contains(window) { dragging.insert(window) } if !liveResizeWindows.contains(window) { cancelMotion(window, remove: false) } if origin == .user || dragging.contains(window) || dropping.contains(window) { enqueue(.windowFrameEdited(window, frame: frame), detections: detections) } else { enqueue( resized ? .windowResizedByUser(window, frame: frame) : .windowMovedByUser(window, frame: frame), detections: detections) } case .appLaunched(let app, let timestamp): guard timestamp.isFinite else { log.record(.configuration("Invalid application launch timestamp")) return } coalescer.setMetrics(AppWriteMetrics(launchedAt: timestamp), for: app.motionID) case .appAvailable(let app): if unmanageableApps.remove(app) != nil { needsRetile = true scheduleTurn() } case .appResponsivenessChanged(let app, let isResponsive): if isResponsive { if wedgedApps.remove(app) != nil { needsRetile = true scheduleTurn() } } else { wedgedApps.insert(app) for window in snapshot.state.windows.values where window.app == app { cancelMotion(window.id, remove: false) } } resolveWorkspaceWaiters() case .appExited(let app): appExited(app, detections: detections) log.forgetFailures(for: app) case .suspendedDisplaysChanged(let displays): updateSuspendedDisplays(displays) case .displaySuspensionsChanged(let suspensions, let provisional): let confirmed = Set(suspensions.map(\.display)) let suspended = confirmed.union(provisional) guard snapshot.displaySuspensions != suspensions || suspendedDisplays != suspended else { return } displaySuspensions = suspensions snapshot.displaySuspensions = suspensions updateSuspendedDisplays(suspended) if let opening = setupOpening, opening.setup.memory.records.contains(where: { confirmed.contains($0.workspace.key.display) }) { cancelSetupOpening() onFailure?(SetupOperationError.destinationsUnavailable) } for subscriber in subscribers.values { subscriber.yield(snapshot) } case .systemWindowConflictChanged(let conflict): systemWindowConflict = conflict onSystemWindowConflictChanged?(conflict) resolveWorkspaceWaiters() case .failure(let failure): handle(failure) } }
private func coalesceInitialFrame(_ window: WindowID, frame: Rect) -> Bool { guard snapshot.state.windows[window] == nil, !queue.contains(where: { pending in switch pending.event { case .windowFrameEdited(let id, _), .windowMovedByUser(let id, _), .windowResizedByUser(let id, _), .windowDisappeared(let id), .windowMinimized(let id): id == window default: false } }) else { return false } var updated = false for index in queue.indices { guard case .windowAppeared(let candidate, let key, _) = queue[index].event, candidate.id == window else { continue } queue[index].event = .windowAppeared(candidate, workspace: key, frame: frame) updated = true } return updated }
private func updateSuspendedDisplays(_ displays: Set<DisplayID>) { guard displays != suspendedDisplays else { return } let newlySuspended = displays.subtracting(suspendedDisplays) let resumed = suspendedDisplays.subtracting(displays) suspendedDisplays = displays for (window, display) in placements where newlySuspended.contains(display) { cancelMotion(window, remove: false) } if !resumed.isEmpty { snapNextPass = true needsRetile = true scheduleTurn() } for subscriber in subscribers.values { subscriber.yield(snapshot) } }
private func pointerChanged(_ isDown: Bool) { guard !usesMouseSamples, !mouseModel.isActive, liveResizeWindows.isEmpty else { return } guard pointerIsDown != isDown else { return } pointerIsDown = isDown enqueue(isDown ? .undoGestureBegan : .undoGestureEnded) if isDown { if let window = snapshot.focusedWindow, snapshot.state.windows[window]?.isFloating == false { dragging.insert(window) cancelMotion(window, remove: false) } } else if !dragging.isEmpty { dropping.formUnion(dragging) dragging.removeAll() needsRetile = true scheduleTurn() } }
private func appExited(_ app: AppID, detections: [DetectionTrace]?) { unmanageableApps.remove(app) wedgedApps.remove(app) settledApps.remove(app) let windows = snapshot.state.windows.values.filter { $0.app == app }.map(\.id) + (snapshot.state.minimizedPlacements?.values.filter { $0.window.app == app }.map { $0.window.id } ?? []) + observations.values.filter { $0.window.app == app }.map { $0.window.id } + queue.compactMap { pending in if case .windowAppeared(let window, _, _) = pending.event, window.app == app { return window.id } return nil } for window in Set(windows) { enqueue(.windowDisappeared(window), detections: detections) } coalescer.removeApp(app.motionID) busyApps.remove(app.motionID) for window in Set(windows) { activityPlacements[window] = nil workspaceWriteAttempts[window] = nil } if let batch = activeBatches.removeValue(forKey: app.motionID) { activityBatchGenerations[batch] = nil if openWrites.remove(batch) != nil { trace?.end(.write, transaction: batch) } } }
func flush() { guard isRunning else { return } isFlushing = true defer { isFlushing = false if !queue.isEmpty { scheduleTurn() } settleIfIdle() } let transaction = turnTrace turnTrace = nil planningTrace = transaction defer { planningTrace = nil } let refresh = queue.filter(\.isConfigurationRefresh) let candidates: [Pending] if refresh.isEmpty { candidates = takeMovementBatch() } else { queue.removeAll(where: \.isConfigurationRefresh) candidates = refresh } let pending = candidates for item in pending where item.permitsRuleSpaceMove { if case .windowAppeared(let window, _, _) = item.event { eligibleRuleSpaceWindows.insert(window.id) } } let setupUndoRequested = pending.contains(where: { $0.event.isSetupUndo }) if setupUndoRequested { cancelSetupOpening() } let callbackPrevious = snapshot.state rememberDepartingWorkspaces(pending.map(\.event), state: snapshot.state) if trace != nil { for item in pending { for detection in item.detections ?? [] { detection.dequeue(.flushed) } } } var state = snapshot.state var displays = state.displays var events = pending.map { item in if item.explicitFloatReadback != nil { return item.event } if case .displaySetChanged(let updated) = item.event, updated.allSatisfy(\.isValid), Set(updated.map(\.id)).count == updated.count { displays = Dictionary(uniqueKeysWithValues: updated.map { ($0.id, $0) }) } return prepare(item.event, state: &state, displays: displays) } if needsRetile { events.append(.relayout) } needsRetile = false guard !events.isEmpty else { return } revision += 1 let reductionTrace: ((ReductionStage, ReductionPhase) -> Void)? if let transaction, let trace { reductionTrace = { stage, phase in let stage: EngineTraceStage = switch stage { case .apply: .apply case .layout: .layout case .diff: .diff } switch phase { case .begin: trace.begin(stage, transaction: transaction) case .end: trace.end(stage, transaction: transaction) } } trace.begin(.reduce, transaction: transaction) } else { reductionTrace = nil } var commandFailures: [Int: EngineCommandSuspensionError] = [:] var discardedFloatReadbacks: Set<Int> = [] var setupUndoHistories: [Int: UndoHistory] = [:] let (reduced, reducedEffects) = reduce( state, events, trace: reductionTrace, accepting: { state, event, index in if index < pending.count, !self.acceptsExplicitFloatReadback(pending[index], in: state) { discardedFloatReadbacks.insert(index) return false } if let failure = self.suspensionFailure(for: event, state: state) { commandFailures[index] = failure return false } if setupUndoRequested, event.isSetupUndo, let history = state.undoHistory { setupUndoHistories[index] = history } return true }) if !setupUndoHistories.isEmpty { for (index, effects) in reducedEffects.enumerated() { guard let history = setupUndoHistories[index] else { continue } for effect in effects { if case .announce(.undone(let window)) = effect { onSetupUndo?(window, history) } } } } let acceptedEvents = events.enumerated().compactMap { commandFailures[$0.offset] == nil && !discardedFloatReadbacks.contains($0.offset) ? $0.element : nil } if !acceptedEvents.isEmpty { recorder?.record(acceptedEvents) } var effectsByEvent = reducedEffects var next = restoreWorkspaceState(reduced, previous: state, events: events, effects: &effectsByEvent) let setupWindows = applyPendingSetup(to: &next, events: events, effects: &effectsByEvent) if let transaction { trace?.end(.reduce, transaction: transaction) } layoutPassCount += 1 snapshot = EngineSnapshot( revision: revision, state: next, readbackFrames: snapshot.readbackFrames.filter { next.windows[$0.key] != nil }, displaySuspensions: snapshot.displaySuspensions) if isAutomaticTilingEnabled { for (id, window) in next.windows where state.windows[id] == nil && window.isFloating && window.managementReason == .whenFull { let userEdited = events.contains { event in switch event { case .windowFrameEdited(let edited, _), .windowMovedByUser(let edited, _), .windowResizedByUser(let edited, _): edited == id default: false } } if !userEdited { initialFloatPlacements.insert(id) } } } publishPlacementState() markWorkspaceMemoryChanges(previous: state, next: next, events: events) let effects = effectsByEvent.flatMap { $0 } updateWindowManagement() continueRetileCorrections(acceptedEvents) pruneMotion() for (index, effects) in effectsByEvent.enumerated() { let command = index < pending.count ? pending[index] : nil if let failure = commandFailures[index] { log.record(.internalFailure(failure)) onFailure?(failure) command?.reply?.resume(throwing: failure) } else if !finishRoomResolution(command, effects: effects) { finishCommand(command, effects: effects) } } let authorized = pending.indices.filter { commandFailures[$0] == nil } let manual = manualWindows(for: authorized.map { pending[$0] }, previous: state, next: next) .union(setupWindows) prepareExplicitFloatPlacements(authorized.map { pending[$0] }, previous: state, next: next) if !isAutomaticTilingEnabled { for window in manual { manualCommandFrames[window] = next.frames[window] } } if let transaction { trace?.begin(.plan, transaction: transaction) } let retileWindows = Set( effects.flatMap { effect -> [WindowID] in if case .confirmRetile(let candidates) = effect { return candidates.map(\.window) } return [] }) prepareActivity(authorized.map { pending[$0] }, previous: state) planFrames( manualWindows: manual.union(retileWindows), intentionalWindows: intentionalFrameWindows( for: authorized.map { pending[$0] }, previous: state, next: next)) initialFloatPlacements = initialFloatPlacements.filter { id in next.windows[id]?.isFloating == true && next.windows[id]?.managementReason == .whenFull && actualFrames[id] != next.frames[id] } planningActivity.removeAll(keepingCapacity: true) rememberWorkspaceState() if let transaction { trace?.end(.plan, transaction: transaction) if !frameTransactions.values.contains(where: { $0.transaction == transaction }) { finishFirstWriteTrace(transaction) } } snapNextPass = false execute(effects) onMouseInputChanged?() scheduleRuleSpaceAssignments() publishCallbacks( previous: callbackPrevious, current: snapshot.state, isConfigurationRefresh: !pending.isEmpty && pending.allSatisfy(\.isConfigurationRefresh)) let publication = emissionTrace.beginIfEnabled(.publish, value: UInt64(subscribers.count), detail: revision) defer { emissionTrace.endIfStarted(.publish, publication) } for subscriber in subscribers.values { subscriber.yield(snapshot) } publishSetupProgress() }
private func prepare(_ event: Event, state: inout State, displays: [DisplayID: Display]) -> Event { switch event { case .windowAppeared(let window, let key, let frame): return prepareAppearance(window, key: key, frame: frame, state: &state, displays: displays) case .resolveRoom(let window, let workspace, let action): prepareRoomResolution(window, workspace: workspace, action: action, state: &state) case .focusChanged(let window): if let window, classifications[window]?.disposition == .ignore || state.windows[window] == nil && observations[window] == nil { return .focusChanged(nil) } case .activeSpaceChanged(let display, let space): let key = WorkspaceKey(display: display, space: space) if state.workspaces[key] == nil { state.workspaces[key] = applied.workspace( key, in: displays[key.display]?.frame, fullFrame: displays[key.display]?.fullFrame) } snapNextPass = snapNextPass || state.activeSpaces[display] != space case .displaySetChanged(let displays): snapNextPass = snapNextPass || state.displays.values.sorted { $0.id < $1.id } != displays.sorted { $0.id < $1.id } case .windowMovedByUser(let window, let frame), .windowResizedByUser(let window, let frame), .windowFrameEdited(let window, let frame): actualFrames[window] = frame if !liveResizeWindows.contains(window) { cancelMotion(window, remove: false) } case .windowMinimized(let window): observations[window] = nil dirtyRuleSpaceWindows.remove(window) classifications[window] = nil cancelMotion(window, remove: true) case .windowDisappeared(let window): observations[window] = nil attemptedRuleSpaces[window] = nil eligibleRuleSpaceWindows.remove(window) dirtyRuleSpaceWindows.remove(window) appliedRuleLayouts[window] = nil classifications[window] = nil manualFloating[window] = nil cancelMotion(window, remove: true) case .minimumSizeChanged(let window, _): if liveResizeWindows.contains(window) { deferredResizeMinimums[window] = event return .relayout } minimumCandidates[window] = nil case .commandIssued(.snap(let action)) where action == .nextDisplay || action == .previousDisplay || action == .restore: for (display, space) in state.activeSpaces { let key = WorkspaceKey(display: display, space: space) if state.workspaces[key] == nil { state.workspaces[key] = applied.workspace( key, in: displays[key.display]?.frame, fullFrame: displays[key.display]?.fullFrame) } } case .workspaceCommandIssued(let command, let key) where (command == .retile || command == .resetSizes) && state.isActive(key): for window in state.workspaces[key]?.order ?? [] { frameAdjustments[window] = nil if command == .retile { if state.windows[window]?.isFloating == false { targets[window] = nil } attemptedRuleSpaces[window] = nil dirtyRuleSpaceWindows.insert(window) } } case .commandIssued(.retile): if let key = state.activeWorkspace { for window in state.workspaces[key]?.order ?? [] where state.windows[window]?.isFloating == false { targets[window] = nil } } frameAdjustments.removeAll() attemptedRuleSpaces.removeAll() dirtyRuleSpaceWindows.formUnion(eligibleRuleSpaceWindows) case .commandIssued(.resetSizes), .commandIssued(.undo): if let key = state.activeWorkspace { for window in state.workspaces[key]?.order ?? [] { frameAdjustments[window] = nil } } default: break } return event }
private func prepareAppearance( _ observed: ManagedWindow, key: WorkspaceKey, frame: Rect, state: inout State, displays: [DisplayID: Display] ) -> Event { var remembered = observed remembered.isRestoringMinimized = false observations[observed.id] = (remembered, key, frame) dirtyRuleSpaceWindows.insert(observed.id) if intrinsicFloating[observed.id] == nil { intrinsicFloating[observed.id] = observed.isFloating } let classification = classify(observed) classifications[observed.id] = classification if classification.disposition == .ignore { cancelMotion(observed.id, remove: true) return .windowDisappeared(observed.id) } var window = observed window.isFloating = classification.disposition == .float switch classification.reason { case .rule, .legacyRule: window.managementReason = .rule case .manual: window.managementReason = .user default: window.managementReason = .automatic } window.initialPosition = observed.isRestoringMinimized ? nil : classification.position let minimized = state.minimizedPlacements?[window.id]?.window let previousMinimum = state.windows[window.id]?.minimum ?? (minimized?.app == window.app ? minimized?.minimum : nil) window.minimum = MinimumSizeLearning.combinedMinimum( window.minimum, inheritedMinimum( MinimumSizeLearning.combinedMinimum(previousMinimum, minimumLearning.learned[window.app.bundleID]), for: window.id)) var destination = key if !observed.isRestoringMinimized, let display = classification.display { if let actual = state.activeSpaces.keys.first(where: { $0.rawValue.uppercased() == display.rawValue.uppercased() }), let space = state.activeSpaces[actual] { destination = key.display == actual ? key : WorkspaceKey(display: actual, space: space) } else { log.record(.configuration("The rule's display \(display.rawValue) is unavailable")) } } if state.workspaces[destination] == nil { state.workspaces[destination] = applied.workspace( destination, in: displays[destination.display]?.frame, fullFrame: displays[destination.display]?.fullFrame) } if let layout = classification.layout { let assignment = RuleLayoutAssignment(workspace: destination, layout: layout) if appliedRuleLayouts[window.id] != assignment { state.workspaces[destination]?.changeLayout(layout) appliedRuleLayouts[window.id] = assignment } } else { appliedRuleLayouts[window.id] = nil } if state.windows[window.id] == nil || state.workspace(containing: window.id) != destination { actualFrames[window.id] = frame } return .windowAppeared(window, workspace: destination, frame: frame) }
private func updateWindowManagement() { for (id, window) in snapshot.state.windows { manualFloating[id] = window.managementReason == .user ? window.isFloating : nil switch window.managementReason { case .user: classifications[id]?.disposition = window.isFloating ? .float : .tile classifications[id]?.reason = .manual case .whenFull: classifications[id]?.disposition = window.isFloating ? .float : .tile classifications[id]?.reason = .whenFull case .automatic, .rule: break } } }}