import AppKit import ParcelConfig import ParcelCore import ParcelPlatform import ParcelUI @MainActor final class AppTabView { private let hotkeys: HotKeyCenter private let choose: @MainActor (WindowID, Bool) -> Void private var history: [WindowID] = [] private var context: AppTabViewContext? private var selection: TabViewSelection? private var minimized: Set = [] private var observers: [(NotificationCenter, any NSObjectProtocol)] = [] private var distributedObservers: [any NSObjectProtocol] = [] private lazy var panels = TabViewPanelController { [weak self] window in self?.chooseWindow(window) } init(hotkeys: HotKeyCenter, choose: @escaping @MainActor (WindowID, Bool) -> Void) { self.hotkeys = hotkeys self.choose = choose let workspace = NSWorkspace.shared.notificationCenter for name in [NSWorkspace.willSleepNotification, NSWorkspace.sessionDidResignActiveNotification] { let token = workspace.addObserver(forName: name, object: nil, queue: .main) { [weak self] _ in MainActor.assumeIsolated { self?.suspend() } } observers.append((workspace, token)) } var names = [Notification.Name("com.apple.screenIsLocked")] #if DEBUG let environment = ProcessInfo.processInfo.environment if environment["PARCEL_E2E"] == "1", let token = environment["PARCEL_E2E_TOKEN"], !token.isEmpty { names.append(Notification.Name("dev.vinnymac.parcel.e2e.\(token).sleep")) } #endif for name in names { let token = DistributedNotificationCenter.default().addObserver(forName: name, object: nil, queue: .main) { [weak self] _ in MainActor.assumeIsolated { self?.suspend() } } distributedObservers.append(token) } } isolated deinit { for (center, token) in observers { center.removeObserver(token) } for token in distributedObservers { DistributedNotificationCenter.default().removeObserver(token) } } private func suspend() { if selection != nil { cancel(immediately: true) } } func observe(_ state: State, minimized: Set = []) { if let context, context != AppTabViewContext(state) { cancel(immediately: true) } let retained = Set(state.windows.keys).union(minimized) history.removeAll { !retained.contains($0) } guard let focused = state.focusedWindow, state.windows[focused] != nil, history.last != focused else { return } history.removeAll { $0 == focused } history.append(focused) } func open( press: HotKeyPress?, state: State, minimized: [AppTabViewMinimized], configuration: MotionConfiguration, classifier: WindowClassifier = WindowClassifier() ) throws { guard selection == nil else { return } let presentation = hotkeys.switcherPresentationTrace let voiceOver = VoiceOverStatus.isRunning try hotkeys.beginSwitcherCapture( modifiers: voiceOver ? [] : (press?.hotKey.modifiers ?? []), openingKeyCode: press?.hotKey.keyCode, onVoiceOverInput: { [weak self] in self?.panels.prepareVoiceOverInput() } ) { [weak self] event in self?.receive(event) } do { let layout = try AppTabViewLayout.make(state: state, minimized: minimized, classifier: classifier) presentation?.checkpoint("layout") let cards = layout.flatMap(\.cards) guard !cards.isEmpty else { presentation?.cancel() hotkeys.endSwitcherCapture() return } observe(state, minimized: Set(minimized.map { $0.window.id })) let ranks = Dictionary(uniqueKeysWithValues: history.enumerated().map { ($0.element, $0.offset) }) let entries = layout.flatMap { display in display.cards.map { TabViewSelection.Entry(window: $0.window.id, display: display.id, frame: $0.frame) } }.sorted { let left = ranks[$0.window] ?? -1 let right = ranks[$1.window] ?? -1 return left == right ? $0.window < $1.window : left < right } let focused = state.focusedWindow.flatMap { id in entries.contains { $0.window == id } ? id : nil } selection = try TabViewSelection( entries: entries, focusedWindow: focused, opening: press?.isReverse == true ? .backward : .forward) context = AppTabViewContext(state) self.minimized = Set(cards.filter(\.isMinimized).map { $0.window.id }) let displays = layout.map { display in TabViewPanelDisplay( id: display.id, frame: display.frame, cards: display.cards.map { card in let kind: TabViewPanelCard.Kind if card.isMinimized { kind = .minimized } else if card.window.isFloating { kind = .floating } else { kind = .tile } return TabViewPanelCard( id: card.window.id, appName: NSRunningApplication(processIdentifier: card.window.app.pid)?.localizedName ?? card.window.app.bundleID, title: card.window.title, pid: card.window.app.pid, frame: card.frame, position: card.position, total: card.total, kind: kind) }) } presentation?.checkpoint("cards") panels.show( displays: displays, selected: selection?.selectedWindow, configuration: configuration, presentation: presentation) } catch { presentation?.cancel() hotkeys.endSwitcherCapture() selection = nil context = nil self.minimized = [] throw error } } func cancel(immediately: Bool = false) { hotkeys.endSwitcherCapture() selection = nil context = nil minimized = [] panels.close(immediately: immediately) } private func receive(_ event: SwitcherInputEvent) { guard var current = selection else { return } switch event { case .next: current.step(.forward) case .previous: current.step(.backward) case .left: current.move(.left) case .right: current.move(.right) case .up: current.move(.up) case .down: current.move(.down) case .confirm: if let window = current.selectedWindow { chooseWindow(window) } else { cancel() } return case .cancel: cancel() return } selection = current panels.updateSelection(current.selectedWindow) } private func chooseWindow(_ window: WindowID) { guard selection?.select(window) == true else { return } let isMinimized = minimized.contains(window) cancel() choose(window, isMinimized) } }