public import AppKit import CoreFoundation public import ParcelConfig import SwiftUI @MainActor public final class ParcelShell: NSObject { public let settings: SettingsModel public let onboarding: OnboardingModel public private(set) var menuBar: MenuBarController? private let layouts: any LayoutSnapshotProviding private let permissions: any PermissionStatusProviding private let commands: any UICommandSink private let defaults: UserDefaults private let preview: Bool private var snapshot: LayoutSnapshot? private var configuration = ParcelConfiguration.defaults { didSet { AccessibilityDragController.shared.motion = configuration.motion } } private var tasks: [Task] = [] private var commandTasks: [UUID: Task] = [:] private var dimmingSave: Task? private var pendingDimmingLevel: Double? private var settingsWindow: NSWindow? private let appIcons: AppIconPreferences private let whatsNew = WhatsNewController() private let support = SupportController() private var isStarted = false // AppKit autosave bypasses the injected defaults suite. package var usesNativeAutosave = true private var problem: MenuProblem? private var setupProgressErrorReported = false private var updateReady = false private var updateVersion: String? private var showUpdateCard = true private var suspensionStatus: String? private var activeMode: String? private var effectiveShortcuts: [ConfigCommand: KeyChord]? private var applicationMenu: CommandMenu? private var applicationMenuInputs: ApplicationMenuInputs? private struct ApplicationMenuInputs: Equatable { let configuration: ParcelConfiguration let shortcuts: [ConfigCommand: KeyChord] let activeMode: String? let hasInspector: Bool } public var onProblemRequested: (@MainActor (MenuProblem) -> Void)? public var onInstallUpdate: (@MainActor () -> Void)? public var onDeferUpdate: (@MainActor () -> Void)? public var onTransientNotice: (@MainActor (String) -> Void)? public var onActiveModeChanged: (@MainActor (String?) -> Void)? public var onFailure: (@MainActor (any Error) -> Void)? public var onSupportDiagnostics: (@MainActor () async throws -> SupportRuntimeDiagnostics)? public var onTourRequested: (@MainActor (_ afterOnboarding: Bool) -> Void)? public var onMenuRendered: (@MainActor (NSMenu) -> Void)? public var onApplicationMenuRendered: (@MainActor (NSMenu) -> Void)? public var onInspectorRequested: (@MainActor () -> Void)? { didSet { renderApplicationMenu() } } public func showSupport(_ kind: SupportKind) { support.show(kind, collect: onSupportDiagnostics) } public func setActiveMode(_ mode: String?) { guard activeMode != mode else { return } activeMode = mode onActiveModeChanged?(mode) renderMenu() } public func setEffectiveShortcuts(_ shortcuts: [ConfigCommand: KeyChord]?) { guard effectiveShortcuts != shortcuts else { return } effectiveShortcuts = shortcuts renderMenu() } public func showNotice(_ notice: String?) { if let notice { onTransientNotice?(notice) } } public func showSuspensionStatus(_ status: String?) { guard suspensionStatus != status else { return } suspensionStatus = status updateStatusMenu() } public func showProblem(_ problem: MenuProblem?) { guard self.problem != problem else { return } self.problem = problem updateStatusMenu() } public func showUpdate(ready: Bool, version: String?, showCard: Bool) { guard updateReady != ready || updateVersion != version || showUpdateCard != showCard else { return } updateReady = ready updateVersion = version showUpdateCard = showCard updateStatusMenu() } public init( layouts: any LayoutSnapshotProviding, permissions: any PermissionStatusProviding, commands: any UICommandSink, configStore: ConfigStore = ConfigStore(), defaults: UserDefaults = .standard, preview: Bool = false, settingsModel: SettingsModel? = nil ) { self.layouts = layouts self.permissions = permissions self.commands = commands self.defaults = defaults self.preview = preview settings = settingsModel ?? SettingsModel(store: configStore) appIcons = AppIconPreferences(defaults: defaults) settings.appIcons = appIcons onboarding = OnboardingModel(provider: permissions) super.init() } public func start() async throws { guard !isStarted else { return } let menuBar = try MenuBarController( invoke: { [weak self] command in self?.dispatch(command) }, openSystemSettings: { [weak self] in guard let self else { return } do { try self.permissions.openAccessibilitySettings() } catch { self.showError(error) } }, showTour: { [weak self] in self?.onTourRequested?(false) }, displayLink: nil, nativeAutosave: usesNativeAutosave && !preview) menuBar.setupActionForMenu = { [weak self] in self?.setupActionForMenu() } menuBar.developerTourForMenu = { [weak self] in self?.defaults.bool(forKey: "developer.showGuidedTour") ?? false } menuBar.onProblemRequested = { [weak self] in self?.onProblemRequested?($0) } menuBar.onKeyboardShortcutsRequested = { [weak self] in self?.showSettings(initialSection: .shortcuts) } menuBar.onNoPeekLevelChanged = { [weak self] in self?.saveDimmingLevel($0) } menuBar.onSupportRequested = { [weak self] in self?.showSupport($0) } menuBar.onInstallUpdate = { [weak self] in self?.onInstallUpdate?() } menuBar.onDeferUpdate = { [weak self] in self?.onDeferUpdate?() } menuBar.onPresentationUnavailable = { [weak self] in self?.showNotice(MenuText.text("Display unavailable")) } menuBar.onMenuRendered = { [weak self] menu in guard let self else { return } self.onMenuRendered?(menu) } self.menuBar = menuBar isStarted = true appIcons.restore() DistributedNotificationCenter.default().addObserver( self, selector: #selector(iconThemeChanged), name: NSNotification.Name("AppleInterfaceThemeChangedNotification"), object: nil) settings.onWhatsNewRequested = { [weak self] in self?.whatsNew.show() } settings.onSupportRequested = { [weak self] in self?.showSupport($0) } settings.onShortcutNoticeChanged = { [weak self] in guard let self else { return } self.updateStatusMenu() } await settings.start() configuration = settings.configuration renderMenu() tasks.append( Task { @MainActor [weak self, layouts] in for await snapshot in layouts.snapshots() { guard !Task.isCancelled, let self else { return } if self.snapshot != snapshot { self.snapshot = snapshot self.updateStatusMenu() } } }) tasks.append( Task { @MainActor [weak self, permissions] in for await permission in permissions.permissionUpdates() { guard !Task.isCancelled, let self else { return } self.onboarding.receive(permission) self.updateStatusMenu() } }) tasks.append( Task { @MainActor [weak self, store = settings.store] in for await snapshot in await store.updates() { guard !Task.isCancelled, let self else { return } self.configuration = snapshot.activeConfiguration self.renderMenu() if snapshot.loadState == .rejected { self.showSettings() } } }) NSWorkspace.shared.notificationCenter.addObserver( self, selector: #selector(accessibilityChanged), name: NSWorkspace.accessibilityDisplayOptionsDidChangeNotification, object: nil ) NotificationCenter.default.addObserver( self, selector: #selector(applicationActivated), name: NSApplication.didBecomeActiveNotification, object: nil ) if !preview { do { let progress = try TourSetupProgressStore(defaults: defaults).load() if Self.onboardingShowsTour( progress: progress, legacyCompleted: defaults.bool(forKey: "guidedTour.v2.completed")) { onTourRequested?(true) } } catch { showError(error) onTourRequested?(true) } } if settings.error != nil { showSettings() } if appIcons.failure != nil { showSettings(initialSection: .appearance) } if !preview, defaults.bool(forKey: "guidedTour.v2.completed"), let version = Bundle.main.object(forInfoDictionaryKey: "CFBundleShortVersionString") as? String { whatsNew.showAfterUpdate(version: version, defaults: defaults) } await permissions.refreshPermission() } public func stop() async { guard isStarted else { return } isStarted = false for task in tasks { task.cancel() } tasks = [] for task in commandTasks.values { task.cancel() } commandTasks = [:] dimmingSave?.cancel() await dimmingSave?.value dimmingSave = nil pendingDimmingLevel = nil DistributedNotificationCenter.default().removeObserver(self) NSWorkspace.shared.notificationCenter.removeObserver(self) NotificationCenter.default.removeObserver(self) menuBar?.stop() menuBar = nil applicationMenu = nil applicationMenuInputs = nil whatsNew.close() support.close() AccessibilityDragController.shared.close() settings.onSupportRequested = nil settingsWindow?.close() settingsWindow = nil await settings.stop() } public func showSettings() { showSettings(initialSection: .general) } public func showKeyboardShortcuts() { showSettings(initialSection: .shortcuts) } private func showSettings(initialSection: SettingsSection) { let view = SettingsView( model: settings, permissions: AnyView(PermissionsView(model: onboarding)), initialSection: initialSection) if settingsWindow == nil { settingsWindow = makeWindow(title: UIStrings.text("Parcel Settings"), view: view) if usesNativeAutosave && !preview { settingsWindow?.setFrameAutosaveName("ParcelSettings") } NotificationCenter.default.addObserver( self, selector: #selector(settingsWindowWillClose), name: NSWindow.willCloseNotification, object: settingsWindow) } else if initialSection != .general { settingsWindow?.contentView = NSHostingView(rootView: view) } show(settingsWindow) } @objc private func settingsWindowWillClose(_ notification: Notification) { guard let window = notification.object as? NSWindow, window === settingsWindow else { return } settings.settingsWindowDidClose() } public func reopen() { if setupActionForMenu() != nil { onTourRequested?(true) } else { showSettings() } } public func showOnboarding() { do { let progress = try TourSetupProgressStore(defaults: defaults).load() if Self.onboardingShowsTour( progress: progress, legacyCompleted: defaults.bool(forKey: "guidedTour.v2.completed")) { onTourRequested?(true) } else { showSettings(initialSection: .permissions) } } catch { showError(error) onTourRequested?(true) } } static func onboardingShowsTour(progress: TourSetupProgress?, legacyCompleted: Bool) -> Bool { progress?.shouldPresentAtLaunch ?? !legacyCompleted } static func setupAction(progress: TourSetupProgress?, legacyCompleted: Bool) -> MenuSetupAction? { if progress?.recovery == .recoveryRequired { return .review } return (progress?.shouldPresentAtLaunch ?? !legacyCompleted) ? .finish : nil } private func setupActionForMenu() -> MenuSetupAction? { do { let progress = try TourSetupProgressStore(defaults: defaults).load() let legacyCompleted: Bool if progress != nil { legacyCompleted = false } else if let stored = defaults.object(forKey: "guidedTour.v2.completed") { guard let value = stored as? NSNumber, CFGetTypeID(value) == CFBooleanGetTypeID() else { throw TourProgressFailure.invalid } legacyCompleted = value.boolValue } else { legacyCompleted = false } setupProgressErrorReported = false return Self.setupAction(progress: progress, legacyCompleted: legacyCompleted) } catch { if !setupProgressErrorReported { setupProgressErrorReported = true showError(error) } return .review } } public func showError(_ error: any Error) { if let onFailure { onFailure(error) return } let alert = NSAlert() alert.messageText = UIStrings.text("Parcel Needs Your Attention") alert.informativeText = Bundle.module.localizedString( forKey: "This action could not finish. Try again or check the app log for details.", value: nil, table: "NoticeActions") alert.addButton(withTitle: UIStrings.text("OK")) NSApplication.shared.activate(ignoringOtherApps: true) alert.runModal() } private func saveDimmingLevel(_ value: Double) { precondition(FocusModeConfiguration.noPeekLevels.contains(value)) pendingDimmingLevel = value guard dimmingSave == nil else { return } dimmingSave = Task { @MainActor [weak self] in guard let self else { return } defer { self.dimmingSave = nil } while let value = self.pendingDimmingLevel, !Task.isCancelled { self.pendingDimmingLevel = nil do { try await self.settings.setValue(.float(value), for: .focusModes(.noPeekLevel)) } catch is CancellationError { return } catch { self.pendingDimmingLevel = nil self.showError(error) return } } } } private func dispatch(_ command: ConfigCommand) { switch command { case .openSettings: showSettings() case .quit: NSApplication.shared.terminate(nil) default: let id = UUID() commandTasks[id] = Task { @MainActor [weak self, commands] in defer { self?.commandTasks.removeValue(forKey: id) } do { try await commands.send(command) } catch is CancellationError { return } catch { self?.showError(error) } } } } @objc private func iconThemeChanged() { appIcons.refreshAppearance() } @objc private func accessibilityChanged() { updateStatusMenu() } @objc private func applicationActivated() { let id = UUID() commandTasks[id] = Task { @MainActor [weak self, permissions] in await permissions.refreshPermission() self?.commandTasks.removeValue(forKey: id) } } private func renderMenu() { updateStatusMenu() renderApplicationMenu() } private func updateStatusMenu() { guard let snapshot else { return } let workspace = NSWorkspace.shared menuBar?.update( snapshot: snapshot, configuration: configuration, permission: onboarding.permission, reduceMotion: workspace.accessibilityDisplayShouldReduceMotion, increaseContrast: workspace.accessibilityDisplayShouldIncreaseContrast, problem: problem, suspensionStatus: suspensionStatus, activeMode: activeMode, effectiveShortcuts: effectiveShortcuts, updateReady: updateReady, updateVersion: updateVersion, showUpdateCard: showUpdateCard, shortcutConflict: !settings.shortcutWarnings.isEmpty || !settings.modeShortcutNotices.isEmpty) } private func renderApplicationMenu() { guard isStarted else { return } let shortcuts = commandBindings(configuration, mode: activeMode, effectiveShortcuts: effectiveShortcuts) let inputs = ApplicationMenuInputs( configuration: configuration, shortcuts: shortcuts, activeMode: activeMode, hasInspector: onInspectorRequested != nil) guard applicationMenuInputs != inputs else { return } applicationMenuInputs = inputs let appMenu = CommandMenu(title: UIStrings.text("Parcel")) appMenu.routing.invoke = { [weak self] command in self?.dispatch(command) } for (title, command) in [("Settings…", ConfigCommand.openSettings), ("Quit Parcel", ConfigCommand.quit)] { appMenu.routing.bindings[command] = shortcuts[command] appMenu.addItem( CommandMenuItem( title: UIStrings.text(title), command: command, chord: shortcuts[command] ) { [weak self] command in self?.dispatch(command) }) } appMenu.addItem(WhatsNewMenuItem { [weak self] in self?.whatsNew.show() }) for kind in [SupportKind.problem, .feature] { let item = ActionMenuItem(title: kind.title) { [weak self] in self?.showSupport(kind) } item.identifier = NSUserInterfaceItemIdentifier( kind == .problem ? "menu.support.problem" : "menu.support.feature") appMenu.addItem(item) } appMenu.addItem( NSMenuItem( title: UIStrings.text("Close Window"), action: #selector(NSWindow.performClose(_:)), keyEquivalent: "")) if onInspectorRequested != nil { appMenu.addItem(FloatingInspectorMenuItem { [weak self] in self?.onInspectorRequested?() }) } let menu: CommandMenu if let applicationMenu { MenuBarController.reconcile(applicationMenu, with: appMenu) applicationMenu.routing.bindings = appMenu.routing.bindings applicationMenu.routing.invoke = appMenu.routing.invoke menu = applicationMenu } else { applicationMenu = appMenu menu = appMenu let root = NSMenu() let item = NSMenuItem(title: UIStrings.text("Parcel"), action: nil, keyEquivalent: "") item.submenu = menu root.addItem(item) NSApplication.shared.mainMenu = root } onApplicationMenuRendered?(menu) } private func makeWindow(title: String, view: Content) -> NSWindow { let window = NSWindow(contentViewController: NSHostingController(rootView: view)) window.title = title window.styleMask = [.titled, .closable, .miniaturizable, .resizable] window.isReleasedWhenClosed = false AppWindowPresentation.configure(window) window.center() return window } private func show(_ window: NSWindow?) { NSApplication.shared.activate(ignoringOtherApps: true) window?.makeKeyAndOrderFront(nil) } deinit { for task in tasks { task.cancel() } for task in commandTasks.values { task.cancel() } dimmingSave?.cancel() } }