public import AppKit public import ParcelConfig import QuartzCore import SwiftUI import os public struct MenuShortcut { public let keyEquivalent: String public let modifierMask: NSEvent.ModifierFlags public init(_ chord: KeyChord?) { guard let chord else { keyEquivalent = "" modifierMask = [] return } keyEquivalent = Self.equivalent(chord.key) var flags: NSEvent.ModifierFlags = [] if chord.modifiers.contains(.ctrl) { flags.insert(.control) } if chord.modifiers.contains(.alt) { flags.insert(.option) } if chord.modifiers.contains(.cmd) { flags.insert(.command) } if chord.modifiers.contains(.shift) { flags.insert(.shift) } if chord.modifiers.contains(.fn) { flags.insert(.function) } if chord.key.rawValue.hasPrefix("keypad") { flags.insert(.numericPad) } modifierMask = flags } private static let equivalents: [ANSIKey: String] = [ .minus: "-", .keypadMinus: "-", .return: "\r", .keypadEnter: "\r", .space: " ", .tab: "\t", .escape: "\u{1b}", .delete: "\u{8}", .forwardDelete: "\u{f728}", .left: "\u{f702}", .right: "\u{f703}", .up: "\u{f700}", .down: "\u{f701}", .home: "\u{f729}", .end: "\u{f72b}", .pageUp: "\u{f72c}", .pageDown: "\u{f72d}", .help: "\u{f746}", .capsLock: "⇪", .keypadClear: "\u{f739}", .keypadDecimal: ".", .keypadMultiply: "*", .keypadPlus: "+", .keypadDivide: "/", .keypadEqual: "=", ] private static func equivalent(_ key: ANSIKey) -> String { if let equivalent = equivalents[key] { return equivalent } let raw = key.rawValue if raw.hasPrefix("keypad") { return String(raw.suffix(1)) } if raw.hasPrefix("f"), let number = Int(raw.dropFirst()), let scalar = UnicodeScalar(0xf703 + number) { return String(scalar) } return raw } } enum WindowCountPreset: Int, CaseIterable { case one = 1 case two, three, four, five var command: ConfigCommand { .setWindowCap(rawValue) } var title: String { rawValue.formatted(.number) } func disabledReason(in snapshot: LayoutSnapshot) -> String? { let maximum = snapshot.layout.capabilities(in: snapshot.capabilityBounds).maximumWindowCount guard rawValue > maximum else { return nil } return String( format: UIStrings.text("Maximum %lld for %@ on this display."), locale: .current, Int64(maximum), snapshot.layout.uiTitle) } } @MainActor final class CommandMenuItem: NSMenuItem { let command: ConfigCommand var invoke: @MainActor (ConfigCommand) -> Void init(title: String, command: ConfigCommand, chord: KeyChord?, invoke: @escaping @MainActor (ConfigCommand) -> Void) { self.command = command self.invoke = invoke let shortcut = MenuShortcut(chord) super.init(title: title, action: #selector(performCommand), keyEquivalent: shortcut.keyEquivalent) keyEquivalentModifierMask = shortcut.modifierMask identifier = NSUserInterfaceItemIdentifier(command.rawValue) target = self setAccessibilityLabel(title) } required init(coder: NSCoder) { fatalError("init(coder:) is unavailable") } @objc private func performCommand() { invoke(command) } } @MainActor final class ActionMenuItem: NSMenuItem { var invoke: @MainActor () -> Void init(title: String, invoke: @escaping @MainActor () -> Void) { self.invoke = invoke super.init(title: title, action: #selector(dismiss), keyEquivalent: "") target = self setAccessibilityLabel(title) } required init(coder: NSCoder) { fatalError("init(coder:) is unavailable") } @objc private func dismiss() { invoke() } } @MainActor private final class SystemNoticeMenuItem: NSMenuItem { var invoke: @MainActor () -> Void init(title: String, invoke: @escaping @MainActor () -> Void) { self.invoke = invoke super.init(title: title, action: #selector(openSettings), keyEquivalent: "") target = self setAccessibilityLabel(title) } required init(coder: NSCoder) { fatalError("init(coder:) is unavailable") } @objc private func openSettings() { invoke() } } final class CommandMenu: NSMenu { let routing = MenuRouting() override func performKeyEquivalent(with event: NSEvent) -> Bool { let routing = routing let keyCode = event.keyCode let flags = event.modifierFlags return MainActor.assumeIsolated { routing.perform(keyCode: keyCode, flags: flags) } } } @MainActor final class MenuRouting { var bindings: [ConfigCommand: KeyChord] = [:] var invoke: (@MainActor (ConfigCommand) -> Void)? func perform( keyCode: UInt16, flags: NSEvent.ModifierFlags, beforeInvoke: @MainActor () -> Void = {} ) -> Bool { guard let key = ANSIKey.allCases.first(where: { $0.keyCode == keyCode }) else { return false } var modifiers: KeyModifiers = [] if flags.contains(.control) { modifiers.insert(.ctrl) } if flags.contains(.option) { modifiers.insert(.alt) } if flags.contains(.command) { modifiers.insert(.cmd) } if flags.contains(.shift) { modifiers.insert(.shift) } // AppKit marks navigation and function keys with .function even without the Fn key held. let intrinsicFunction = [.left, .right, .up, .down, .home, .end, .pageUp, .pageDown, .forwardDelete].contains(key) || (key.rawValue.hasPrefix("f") && Int(key.rawValue.dropFirst()) != nil) if flags.contains(.function), !intrinsicFunction { modifiers.insert(.fn) } let chord = KeyChord(modifiers: modifiers, key: key) guard let command = bindings.first(where: { $0.value == chord })?.key else { return false } beforeInvoke() invoke?(command) return true } } func commandBindings( _ configuration: ParcelConfiguration, mode: String?, effectiveShortcuts: [ConfigCommand: KeyChord]? = nil ) -> [ConfigCommand: KeyChord] { var commands: [ConfigCommand: KeyChord] if let effectiveShortcuts { commands = effectiveShortcuts } else if let mode { commands = [:] for (action, chord) in configuration.modes[mode] ?? [:] { if case .command(let command) = action { commands[command] = chord } } } else { commands = configuration.keybindings } if mode != nil, commands[.openSettings] == nil { commands[.openSettings] = configuration.keybindings[.openSettings] } return commands } enum MenuSetupAction: Equatable { case finish, review var title: String { MenuText.text("Continue Setup…") } } @MainActor public final class MenuBarController: NSObject, NSMenuDelegate, NSPopoverDelegate { public let statusItem: NSStatusItem public let menu: NSMenu public var onMenuRendered: (@MainActor (NSMenu) -> Void)? public var onMenuNeedsUpdate: (@MainActor () -> Void)? public var activeScreenForPresentation: (@MainActor () -> NSScreen?)? public var onPresentationUnavailable: (@MainActor () -> Void)? public var workspaceForActivation: (@MainActor (MenuWorkspaceActivation) -> Result)? public var invokeInWorkspace: (@MainActor (ConfigCommand, MenuWorkspace) -> Void)? public var applicationForMenu: (@MainActor () -> MenuApplication?)? public var toggleApplication: (@MainActor (MenuApplication) -> Void)? public var onProblemRequested: (@MainActor (MenuProblem) -> Void)? public var onKeyboardShortcutsRequested: (@MainActor () -> Void)? public var onNoPeekLevelChanged: (@MainActor (Double) -> Void)? public var onSupportRequested: (@MainActor (SupportKind) -> Void)? public var onInstallUpdate: (@MainActor () -> Void)? public var onDeferUpdate: (@MainActor () -> Void)? private let shortMenu: CommandMenu private let popover = NSPopover() private var panelKeyMonitor: (any NSObjectProtocol)? private let renderer: MenuIconRenderer private var morph: MiniMapMorph private var displayLink: (any MenuIconDisplayLink)? private let clock: @MainActor () -> Double private let visibility: (@MainActor () -> Bool)? private var animationStartedAt = 0.0 private var lastFrameTimestamp: Double? private let signposter = OSSignposter(subsystem: "com.parcel", category: .pointsOfInterest) private var appearanceObservation: NSKeyValueObservation? private var pointerMonitor: (any NSObjectProtocol)? private var pointerActivation: (id: UUID, menu: NSMenu, location: CGPoint)? private var lastActivationEvent: NSEvent? private var openingPointer: CGPoint? private var trackingMenu: NSMenu? private var stopped = false private var lastContrast = false private var cleanSpaceMark = false private var updateMark = false private var lastPresentation: MenuPresentation? private var lastFullContent: MenuContent? private var lastShortContent: MenuContent? private let invoke: @MainActor (ConfigCommand) -> Void private let openSystemSettings: @MainActor () -> Void private let showTour: @MainActor () -> Void var setupActionForMenu: @MainActor () -> MenuSetupAction? = { nil } package var developerTourForMenu: @MainActor () -> Bool = { false } public convenience init( invoke: @escaping @MainActor (ConfigCommand) -> Void, openSystemSettings: @escaping @MainActor () -> Void = {}, showTour: @escaping @MainActor () -> Void = {} ) throws { try self.init( invoke: invoke, openSystemSettings: openSystemSettings, showTour: showTour, displayLink: nil) } init( invoke: @escaping @MainActor (ConfigCommand) -> Void, openSystemSettings: @escaping @MainActor () -> Void = {}, showTour: @escaping @MainActor () -> Void = {}, displayLink: (any MenuIconDisplayLink)?, clock: @escaping @MainActor () -> Double = { CACurrentMediaTime() }, visibility: (@MainActor () -> Bool)? = nil, nativeAutosave: Bool = true ) throws { self.displayLink = displayLink self.clock = clock self.visibility = visibility self.invoke = invoke self.openSystemSettings = openSystemSettings self.showTour = showTour renderer = try MenuIconRenderer() morph = MiniMapMorph(icon: .logo(count: nil)) let initialWidth = ceil(NSStatusBar.system.thickness) statusItem = NSStatusBar.system.statusItem(withLength: initialWidth) if nativeAutosave { statusItem.autosaveName = "Parcel" } menu = CommandMenu(title: UIStrings.text("Parcel")) shortMenu = CommandMenu(title: UIStrings.text("Parcel")) super.init() menu.delegate = self shortMenu.delegate = self popover.behavior = .transient popover.animates = false popover.delegate = self if let button = statusItem.button { self.displayLink = displayLink ?? StatusButtonDisplayLink(button: button) button.setAccessibilityLabel(UIStrings.text("Parcel")) draw() button.imagePosition = .imageLeading button.target = self button.action = #selector(activateMenu) button.sendAction(on: [.leftMouseUp, .rightMouseUp]) appearanceObservation = button.observe(\.effectiveAppearance, options: [.new]) { [weak self] _, _ in MainActor.assumeIsolated { self?.draw() } } } guard let pointerMonitor = NSEvent.addLocalMonitorForEvents( matching: [.leftMouseUp, .rightMouseUp], handler: { [weak self] event in MainActor.assumeIsolated { self?.recordPointerActivation(event) } return event }) as? any NSObjectProtocol else { preconditionFailure("The status item input monitor could not be installed.") } self.pointerMonitor = pointerMonitor DistributedNotificationCenter.default().addObserver( self, selector: #selector(themeChanged), name: NSNotification.Name("AppleInterfaceThemeChangedNotification"), object: nil) NotificationCenter.default.addObserver( self, selector: #selector(backingChanged(_:)), name: NSWindow.didChangeBackingPropertiesNotification, object: nil) NotificationCenter.default.addObserver( self, selector: #selector(visibilityChanged(_:)), name: NSWindow.didChangeOcclusionStateNotification, object: nil) NotificationCenter.default.addObserver( self, selector: #selector(themeChanged), name: NSLocale.currentLocaleDidChangeNotification, object: nil) } public func update( snapshot: LayoutSnapshot, configuration: ParcelConfiguration, permission: PermissionStatus, reduceMotion: Bool, increaseContrast: Bool, problem: MenuProblem? = nil, suspensionStatus: String? = nil, activeMode: String? = nil, effectiveShortcuts: [ConfigCommand: KeyChord]? = nil, updateReady: Bool = false, updateVersion: String? = nil, showUpdateCard: Bool = true, shortcutConflict: Bool = false ) { let presentation = MenuPresentation( snapshot: snapshot, configuration: configuration, permission: permission, reduceMotion: reduceMotion, increaseContrast: increaseContrast, problem: problem, suspensionStatus: suspensionStatus, visible: isVisible, activeMode: activeMode, effectiveShortcuts: effectiveShortcuts, updateReady: updateReady, updateVersion: updateVersion, showUpdateCard: showUpdateCard, shortcutConflict: shortcutConflict) guard !stopped, lastPresentation != presentation else { return } lastPresentation = presentation let status = Self.accessibilityValue( snapshot: snapshot, permission: permission, problem: problem, suspensionStatus: suspensionStatus) statusItem.button?.setAccessibilityValue(status) let label: String switch (snapshot.cleanSpace, updateReady) { case (true, true): label = MenuText.text("Parcel, Clean Space on, update ready") case (true, false): label = MenuText.text("Parcel, Clean Space on") case (false, true): label = MenuText.text("Parcel, update ready") case (false, false): label = UIStrings.text("Parcel") } statusItem.button?.setAccessibilityLabel(label) statusItem.button?.toolTip = status statusItem.button?.title = "" let changed = morph.retarget( MenuIcon(snapshot: snapshot, style: configuration.motion.menuBarIcon), configuration: configuration.motion, reduceMotion: reduceMotion, visible: presentation.visible) let contrastChanged = lastContrast != increaseContrast let markChanged = cleanSpaceMark != snapshot.cleanSpace || updateMark != updateReady lastContrast = increaseContrast cleanSpaceMark = snapshot.cleanSpace updateMark = updateReady guard changed || contrastChanged || markChanged else { return } if changed { animationStartedAt = max(clock(), lastFrameTimestamp ?? -.infinity) } draw() if morph.remainingFrames > 0 { guard let displayLink else { preconditionFailure("An animated menu icon needs a status button.") } if !displayLink.isRunning { displayLink.start { [weak self] timestamp in self?.advanceAnimation(at: timestamp) } } } else { displayLink?.stop() } } public func menuNeedsUpdate(_ menu: NSMenu) { onMenuNeedsUpdate?() guard !stopped, trackingMenu == nil, !popover.isShown, let presentation = lastPresentation, let commandMenu = menu as? CommandMenu, menu === self.menu || menu === shortMenu else { return } fill(commandMenu, presentation: presentation, short: menu === shortMenu) } public func menuWillOpen(_ menu: NSMenu) { trackingMenu = menu } public func menuDidClose(_ menu: NSMenu) { if trackingMenu === menu { trackingMenu = nil } openingPointer = nil } func menuForActivation(_ event: NSEvent?) -> NSMenu { let secondary = event?.type == .rightMouseUp || (event?.type == .leftMouseUp && event?.modifierFlags.contains(.control) == true) return secondary ? shortMenu : menu } func recordPointerActivation(_ event: NSEvent) { guard !stopped, trackingMenu == nil, let window = statusItem.button?.window, event.window === window, event.type == .leftMouseUp || event.type == .rightMouseUp else { return } let id = UUID() pointerActivation = (id, menuForActivation(event), window.convertPoint(toScreen: event.locationInWindow)) DispatchQueue.main.async { [weak self] in if self?.pointerActivation?.id == id { self?.pointerActivation = nil } } } func consumeActivationMenu(_ event: NSEvent? = nil) -> NSMenu { defer { pointerActivation = nil } // Status-item clicks can bypass local monitors. Consume their current event once, // since AXPress can leave currentEvent pointing at the previous click. let nativeEvent: NSEvent? if let event, event !== lastActivationEvent, let window = statusItem.button?.window, event.window === window, event.type == .leftMouseUp || event.type == .rightMouseUp { nativeEvent = event lastActivationEvent = event } else { nativeEvent = nil } openingPointer = pointerActivation?.location ?? nativeEvent.flatMap { $0.window?.convertPoint(toScreen: $0.locationInWindow) } return pointerActivation?.menu ?? menuForActivation(nativeEvent) } private var statusAnchor: StatusItemAnchor { let button = statusItem.button let window = button?.window let frame = button.flatMap { button in window?.convertToScreen(button.convert(button.bounds, to: nil)) } return StatusItemAnchor( frame: frame, isVisible: statusItem.isVisible && NSMenu.menuBarVisible() && button?.isHiddenOrHasHiddenAncestor == false && window?.isVisible == true && window?.occlusionState.contains(.visible) == true, excludedFrames: NSScreen.screens.compactMap { MenuBarPlacement.notchFrame( screen: $0.frame, topInset: $0.safeAreaInsets.top, leftArea: $0.auxiliaryTopLeftArea, rightArea: $0.auxiliaryTopRightArea) }) } private func fallbackScreen(in screens: [NSScreen]) -> NSScreen? { let active = (activeScreenForPresentation?()).flatMap { screens.firstIndex(of: $0) } let main = NSScreen.main.flatMap { screens.firstIndex(of: $0) } let frames = screens.map { screen in MenuBarPlacement.isValid(screen.visibleFrame) && screen.frame.contains(screen.visibleFrame) ? screen.frame : .zero } return MenuBarPlacement.preferredScreenIndex( active: active, main: main, pointer: NSEvent.mouseLocation, frames: frames ).map { screens[$0] } } @objc private func activateMenu() { guard !stopped else { return } let menu = consumeActivationMenu(NSApp.currentEvent) if popover.isShown { closePanel() pointerActivation = nil return } guard trackingMenu == nil else { return } let screens = NSScreen.screens let placement = MenuBarPlacement.resolve( anchor: statusAnchor, screens: screens.map(\.frame), activeVisibleFrame: fallbackScreen(in: screens)?.visibleFrame) switch placement { case .statusItem: guard let button = statusItem.button else { preconditionFailure("A visible status item needs a button") } if menu === self.menu, showPanel(relativeTo: button) { return } statusItem.menu = menu defer { statusItem.menu = nil } // Let the status button own highlighting and accessibility while the native menu tracks. button.performClick(nil) case .fallback(let point): openingPointer = point menu.popUp(positioning: nil, at: point, in: nil) case .unavailable: onPresentationUnavailable?() } } func panelContent() -> MenuPanelContent? { guard let content = lastFullContent else { return nil } let snapshot = content.workspace?.snapshot ?? content.presentation.snapshot let title = MenuText.text("Windows on this screen") return MenuPanelContent( snapshot: snapshot, scope: content.workspace.map { title + " · " + $0.title } ?? title, items: menu.items, dismiss: { [weak self] in self?.closePanel() }) } private func showPanel(relativeTo button: NSStatusBarButton) -> Bool { menuNeedsUpdate(menu) guard let content = panelContent(), !stopped else { return false } let availableHeight = button.window?.screen?.visibleFrame.height ?? 700 let height = min(content.canArrange ? 728.0 : 440.0, max(200, availableHeight - 32)) let host = NSHostingController(rootView: MenuPanelView(content: content, height: height)) host.preferredContentSize = NSSize(width: 380, height: height) popover.contentViewController = host popover.contentSize = host.preferredContentSize button.highlight(true) popover.show(relativeTo: button.bounds, of: button, preferredEdge: .minY) guard popover.isShown else { button.highlight(false) popover.contentViewController = nil return false } popover.contentViewController?.view.window?.makeKey() guard let monitor = NSEvent.addLocalMonitorForEvents( matching: .keyDown, handler: { [weak self] event in let consumed = MainActor.assumeIsolated { guard let self, self.popover.isShown, event.window === self.popover.contentViewController?.view.window, let menu = self.menu as? CommandMenu else { return false } return menu.routing.perform( keyCode: event.keyCode, flags: event.modifierFlags, beforeInvoke: { self.closePanel() }) } return consumed ? nil : event }) as? any NSObjectProtocol else { preconditionFailure("The panel keyboard monitor could not be installed.") } panelKeyMonitor = monitor return true } private func closePanel() { popover.performClose(nil) releasePanel() } public func dismiss() { closePanel() trackingMenu?.cancelTrackingWithoutAnimation() menu.cancelTrackingWithoutAnimation() } public func popoverDidClose(_ notification: Notification) { releasePanel() } private func releasePanel() { if let panelKeyMonitor { NSEvent.removeMonitor(panelKeyMonitor) } panelKeyMonitor = nil statusItem.button?.highlight(false) popover.contentViewController = nil openingPointer = nil } @objc private func backingChanged(_ notification: Notification) { guard let window = notification.object as? NSWindow, window === statusItem.button?.window else { return } draw() } @objc private func visibilityChanged(_ notification: Notification) { guard let window = notification.object as? NSWindow, window === statusItem.button?.window, !isVisible, morph.remainingFrames > 0 else { return } morph.finish() displayLink?.stop() draw() } @objc private func themeChanged() { guard !stopped else { return } renderer.invalidate() draw() DispatchQueue.main.async { [weak self] in guard let self, !self.stopped else { return } self.renderer.invalidate() self.draw() } } private func fill(_ menu: CommandMenu, presentation: MenuPresentation, short: Bool) { let target = short ? nil : workspaceForActivation?( MenuWorkspaceActivation( pointer: openingPointer, statusScreen: statusAnchor.isUsable(on: NSScreen.screens.map(\.frame)) ? statusItem.button?.window?.screen : nil)) let workspace: MenuWorkspace? let unavailability: MenuWorkspace.Unavailability? switch target { case .success(let selected): (workspace, unavailability) = (selected, nil) case .failure(let reason): (workspace, unavailability) = (nil, reason) case nil: (workspace, unavailability) = (nil, nil) } let snapshot = workspace?.snapshot ?? presentation.snapshot let unavailable = unavailability != nil let invoke: @MainActor (ConfigCommand) -> Void = { [weak self] command in guard let self else { return } if command == .toggleAutomaticTiling, snapshot.isWaitingForSetup || self.setupActionForMenu() != nil { self.showTour() return } if command.targetsMenuWorkspace, let workspace { guard workspace.disabledReason(for: command) == nil else { return } guard let send = self.invokeInWorkspace else { preconditionFailure("A workspace menu needs a command sink") } send(command, workspace) } else if !command.targetsMenuWorkspace || !unavailable { self.invoke(command) } } let permission = presentation.permission let shortcuts = commandBindings( presentation.configuration, mode: presentation.activeMode, effectiveShortcuts: presentation.effectiveShortcuts) let application = toggleApplication == nil ? nil : applicationForMenu?() let setupAction = short ? nil : setupActionForMenu() let developerTour = !short && developerTourForMenu() let content = MenuContent( presentation: presentation, workspace: workspace, unavailability: unavailability, application: application, setupAction: setupAction, developerTour: developerTour) if (short ? lastShortContent : lastFullContent) == content { if !short { onMenuRendered?(menu) } return } if short { lastShortContent = content } else { lastFullContent = content } let candidate = NSMenu(title: menu.title) candidate.autoenablesItems = false menu.autoenablesItems = false menu.routing.bindings = [:] menu.routing.invoke = invoke func add(_ title: String, _ command: ConfigCommand, to destination: NSMenu) -> NSMenuItem { let item = CommandMenuItem(title: title, command: command, chord: shortcuts[command], invoke: invoke) destination.addItem(item) let reason = command.targetsMenuWorkspace ? unavailability?.detail ?? workspace?.disabledReason(for: command) : nil if let reason { item.isEnabled = false item.toolTip = reason item.setAccessibilityHelp(reason) } else { menu.routing.bindings[command] = shortcuts[command] } return item } func separator() { let item = NSMenuItem.separator() item.identifier = NSUserInterfaceItemIdentifier( "menu.separator.\(candidate.items.filter(\.isSeparatorItem).count)") candidate.addItem(item) } if !short { let arrangementStatus: String? = if workspace != nil { snapshot.arrangementStatus } else if unavailable { nil } else { presentation.suspensionStatus ?? snapshot.arrangementStatus } var title = snapshot.isWaitingForSetup ? snapshot.accessibilityDescription : arrangementStatus ?? unavailability?.detail ?? snapshot.accessibilityDescription if let workspace, workspace.hasMultipleDisplays { title = String(format: MenuText.text("%@ · %@"), locale: .current, title, workspace.title) } let summary = NSMenuItem.sectionHeader(title: title) summary.identifier = NSUserInterfaceItemIdentifier("menu.status") summary.setAccessibilityLabel(title) summary.isEnabled = false let minimap = unavailable ? nil : image( for: MenuIcon(snapshot: snapshot, style: .minimap), increaseContrast: presentation.increaseContrast) summary.view = MenuStatusView(title: title, image: minimap) candidate.addItem(summary) } if let setupAction, !(permission == .granted && presentation.problem == .startupFailure) { let item = ActionMenuItem(title: setupAction.title, invoke: showTour) item.identifier = NSUserInterfaceItemIdentifier("menu.problem") candidate.addItem(item) } let automatic = add(MenuText.text("Automatic tiling"), .toggleAutomaticTiling, to: candidate) automatic.state = snapshot.isAutomaticTilingEnabled ? .on : .off if let status = candidate.items.first?.view as? MenuStatusView, let command = automatic as? CommandMenuItem { status.configureAutomatic(command, dismiss: { [weak menu] in menu?.cancelTracking() }) } if !short { if let application, let toggleApplication { let appItem = ActionMenuItem(title: application.title) { toggleApplication(application) } appItem.identifier = NSUserInterfaceItemIdentifier("menu.application") appItem.state = application.isTiled ? .on : .off appItem.image = MenuApplicationIdentity( bundleIdentifier: application.bundleIdentifier, name: application.name, processIdentifier: application.processIdentifier ).icon candidate.addItem(appItem) } separator() func addProblem(_ problem: MenuProblem) { let item = ActionMenuItem(title: problem.title) { [weak self] in self?.onProblemRequested?(problem) } item.identifier = NSUserInterfaceItemIdentifier("menu.problem") item.isEnabled = problem.isActionable item.toolTip = problem.detail item.setAccessibilityHelp(problem.detail) candidate.addItem(item) } if permission == .granted, presentation.problem == .startupFailure { addProblem(.startupFailure) } else if setupAction == nil && permission != .granted { let item = SystemNoticeMenuItem( title: MenuText.text("Turn on Accessibility for Parcel…"), invoke: openSystemSettings) item.identifier = NSUserInterfaceItemIdentifier("menu.problem") candidate.addItem(item) } else if setupAction == nil, let problem = presentation.problem, problem != .updateReady { addProblem(problem) } else if setupAction == nil && presentation.updateReady && presentation.showUpdateCard { let install: @MainActor () -> Void = { [weak self] in self?.menu.cancelTracking() self?.onInstallUpdate?() } let later: @MainActor () -> Void = { [weak self] in self?.menu.cancelTracking() self?.onDeferUpdate?() } let title = UpdateMenuCard.title(version: presentation.updateVersion) let item = NSMenuItem(title: title, action: nil, keyEquivalent: "") item.identifier = NSUserInterfaceItemIdentifier("menu.problem") item.setAccessibilityLabel(title) item.view = UpdateMenuCard(version: presentation.updateVersion, install: install, later: later) let actions = NSMenu(title: title) actions.autoenablesItems = false let installItem = ActionMenuItem(title: MenuText.text("Install and Relaunch"), invoke: install) installItem.identifier = NSUserInterfaceItemIdentifier("menu.update.install") let laterItem = ActionMenuItem(title: MenuText.text("Later"), invoke: later) laterItem.identifier = NSUserInterfaceItemIdentifier("menu.update.later") actions.addItem(installItem) actions.addItem(laterItem) item.submenu = actions candidate.addItem(item) } else if setupAction == nil && presentation.problem == .updateReady && !presentation.updateReady { let item = ActionMenuItem(title: MenuProblem.updateReady.title) { [weak self] in self?.onProblemRequested?(.updateReady) } item.identifier = NSUserInterfaceItemIdentifier("menu.problem") candidate.addItem(item) } let layoutItem = NSMenuItem(title: UIStrings.text("Layout"), action: nil, keyEquivalent: "") layoutItem.identifier = NSUserInterfaceItemIdentifier("menu.layout") let layouts = NSMenu(title: layoutItem.title) layouts.autoenablesItems = false for layout in ConfigLayout.allCases { let item = add(layout.uiTitle, layout.command, to: layouts) item.state = !unavailable && snapshot.layout == layout ? .on : .off guard !unavailable else { continue } let count = MenuLayoutPreview.count(for: layout, in: snapshot) item.image = image( for: MenuIcon( snapshot: MenuLayoutPreview.snapshot( layout: layout, count: count, bounds: snapshot.bounds, ratio: snapshot.ratio, unlimited: snapshot.hasNoWindowLimit, capabilityBounds: snapshot.capabilityBounds), style: .minimap), increaseContrast: presentation.increaseContrast) } let countItem = NSMenuItem(title: MenuText.text("Windows"), action: nil, keyEquivalent: "") countItem.identifier = NSUserInterfaceItemIdentifier("menu.windows") let counts = NSMenu(title: countItem.title) counts.autoenablesItems = false for count in [1, 2, 3, 4, 5, 0] { let preset = WindowCountPreset(rawValue: count) let reason = unavailability?.detail ?? preset?.disabledReason(in: snapshot) ?? workspace?.disabledReason(for: .setWindowCap(count)) let item = add(preset?.title ?? MenuText.text("No limit"), .setWindowCap(count), to: counts) item.state = !unavailable && (count == 0 ? snapshot.windowCap == Int.max || snapshot.windowCap == 0 : snapshot.effectiveWindowCap == count) ? .on : .off if !unavailable { item.image = image( for: MenuIcon( snapshot: MenuLayoutPreview.snapshot( layout: snapshot.layout, count: count == 0 ? max(1, snapshot.tiles.count) : count, bounds: snapshot.bounds, ratio: snapshot.ratio, unlimited: count == 0, capabilityBounds: snapshot.capabilityBounds), style: .minimap), increaseContrast: presentation.increaseContrast) } item.isEnabled = reason == nil item.toolTip = reason item.setAccessibilityHelp(reason) if reason != nil { menu.routing.bindings.removeValue(forKey: .setWindowCap(count)) } } countItem.submenu = counts candidate.addItem(countItem) let sizeSeparator = NSMenuItem.separator() sizeSeparator.identifier = NSUserInterfaceItemIdentifier("menu.layout.sizes-separator") layouts.addItem(sizeSeparator) let mainSize = NSMenuItem(title: MenuText.text("Main Size"), action: nil, keyEquivalent: "") mainSize.identifier = NSUserInterfaceItemIdentifier("menu.main-size") let sizes = NSMenu(title: mainSize.title) sizes.autoenablesItems = false let selectedSize = MainSizePreset(ratio: snapshot.mainSizeRatio) for preset in [MainSizePreset.half, .threeFifths, .twoThirds] { guard let command = preset.command else { preconditionFailure("A main-size preset needs a command") } let item = add(preset.title, command, to: sizes) let reason = unavailability?.detail ?? (snapshot.layout == .accordion ? MenuText.text("Main size is unavailable in Accordion layout.") : nil) ?? workspace?.disabledReason(for: command) item.isEnabled = reason == nil item.toolTip = reason item.setAccessibilityHelp(reason) item.state = !unavailable && snapshot.layout != .accordion && selectedSize == preset ? .on : .off if reason != nil { menu.routing.bindings.removeValue(forKey: command) } } if selectedSize == .custom && !unavailable && snapshot.layout != .accordion { let custom = NSMenuItem(title: MainSizePreset.custom.title, action: nil, keyEquivalent: "") custom.identifier = NSUserInterfaceItemIdentifier("menu.main-size.custom") custom.state = .on custom.isEnabled = false sizes.addItem(custom) } mainSize.setAccessibilityLabel(mainSize.title) mainSize.submenu = sizes layouts.addItem(mainSize) let canReset = snapshot.hasCustomSizes && !snapshot.isWaitingForSetup && !unavailable && workspace?.disabledReason(for: .resetSizes) == nil if canReset { _ = add(MenuText.text("Reset sizes"), .resetSizes, to: layouts) } layoutItem.setAccessibilityLabel(layoutItem.title) layoutItem.submenu = layouts candidate.insertItem(layoutItem, at: candidate.index(of: countItem)) separator() for (title, command, enabled) in [ ( AppearanceText.string("Borders"), ConfigCommand.toggleBorders, presentation.configuration.motion.highlight != .none ), ( MenuText.text("Hover Focus"), .toggleHoverFocus, snapshot.hoverFocus ?? presentation.configuration.mouse.focusFollowsMouse ), (MenuText.text("Focus"), .toggleFocus, snapshot.isFocused), (MenuText.text("No Peek"), .toggleNoPeek, snapshot.noPeek), (MenuText.text("Clean Space"), .toggleCleanSpace, snapshot.cleanSpace), ] { let item = add(title, command, to: candidate) item.state = enabled ? .on : .off if command == .toggleBorders { item.image = NSImage(systemSymbolName: "square.dashed", accessibilityDescription: nil) } else if command == .toggleHoverFocus { item.image = NSImage(systemSymbolName: "cursorarrow.rays", accessibilityDescription: nil) } if command == .toggleNoPeek, onNoPeekLevelChanged != nil { let level = presentation.configuration.focusModes.noPeekLevel let change: @MainActor (Double) -> Void = { [weak self] value in self?.onNoPeekLevelChanged?(value) } let dim = NSMenuItem(title: MenuText.text("Dimming level"), action: nil, keyEquivalent: "") dim.identifier = NSUserInterfaceItemIdentifier("menu.no-peek.level") dim.view = MenuDimSlider(value: level, change: change) dim.setAccessibilityLabel(dim.title) candidate.addItem(dim) } } let retile = add(UIStrings.text("Retile"), .retile, to: candidate) retile.image = NSImage(systemSymbolName: "arrow.clockwise", accessibilityDescription: nil) if !unavailable && !snapshot.isWaitingForSetup && permission == .granted && snapshot.arrangementStatus == nil && (workspace != nil || presentation.suspensionStatus == nil) && presentation.problem != .startupFailure { let title = MenuText.text("Windows on this screen") let panel = NSMenuItem(title: title, action: nil, keyEquivalent: "") panel.identifier = NSUserInterfaceItemIdentifier("menu.quick-controls") let commands = (layouts.items + counts.items + candidate.items).compactMap { $0 as? CommandMenuItem } panel.view = MenuQuickControlsView( snapshot: snapshot, scope: workspace.map { title + " · " + $0.title } ?? title, items: commands, dismiss: { [weak menu] in menu?.cancelTracking() }) candidate.insertItem(panel, at: candidate.index(of: layoutItem)) } separator() } _ = add(UIStrings.text("Settings…"), .openSettings, to: candidate) if !short { if developerTour { let tour = TourMenuItem(invoke: showTour) tour.identifier = NSUserInterfaceItemIdentifier("menu.tour") candidate.addItem(tour) } let moreItem = NSMenuItem(title: MenuText.text("More"), action: nil, keyEquivalent: "") moreItem.identifier = NSUserInterfaceItemIdentifier("menu.more") moreItem.setAccessibilityLabel( MenuText.text(presentation.updateReady ? "More, update ready" : "More")) if presentation.updateReady { moreItem.image = NSImage(systemSymbolName: "circle.fill", accessibilityDescription: nil)? .withSymbolConfiguration(.init(pointSize: 6, weight: .regular)) } let more = NSMenu(title: moreItem.title) more.autoenablesItems = false let shortcutsItem = ActionMenuItem(title: MenuText.text("Keyboard Shortcuts…")) { [weak self] in self?.onKeyboardShortcutsRequested?() } shortcutsItem.identifier = NSUserInterfaceItemIdentifier("menu.shortcuts") shortcutsItem.isEnabled = onKeyboardShortcutsRequested != nil if presentation.shortcutConflict { let warning = MenuText.text("Keyboard shortcuts — conflicts found") shortcutsItem.image = NSImage( systemSymbolName: "exclamationmark.triangle", accessibilityDescription: nil) shortcutsItem.toolTip = warning shortcutsItem.setAccessibilityHelp(warning) } candidate.addItem(shortcutsItem) let feedback = ActionMenuItem(title: MenuText.text("Send Feedback…")) { [weak self] in self?.onSupportRequested?(.problem) } feedback.identifier = NSUserInterfaceItemIdentifier("menu.support") feedback.isEnabled = onSupportRequested != nil more.addItem(feedback) moreItem.submenu = more candidate.addItem(moreItem) } _ = add(UIStrings.text("Quit Parcel"), .quit, to: candidate) Self.reconcile(menu, with: candidate) if !short { onMenuRendered?(menu) } } static func reconcile(_ menu: NSMenu, with candidate: NSMenu) { let old = menu.items let desiredItems = candidate.items for (index, desired) in desiredItems.enumerated() { let existing = old.first { item in return desired.identifier != nil && item.identifier == desired.identifier && type(of: item) == type(of: desired) } let item = existing ?? desired if let existing { if existing.title != desired.title { existing.title = desired.title; existing.setAccessibilityLabel(desired.title) } if existing.accessibilityLabel() != desired.accessibilityLabel() { existing.setAccessibilityLabel(desired.accessibilityLabel()) } if existing.state != desired.state { existing.state = desired.state } if existing.isEnabled != desired.isEnabled { existing.isEnabled = desired.isEnabled } if existing.keyEquivalent != desired.keyEquivalent { existing.keyEquivalent = desired.keyEquivalent } if existing.keyEquivalentModifierMask != desired.keyEquivalentModifierMask { existing.keyEquivalentModifierMask = desired.keyEquivalentModifierMask } if existing.image !== desired.image { existing.image = desired.image } if existing.toolTip != desired.toolTip { existing.toolTip = desired.toolTip; existing.setAccessibilityHelp(desired.toolTip) } if let existing = existing as? CommandMenuItem, let desired = desired as? CommandMenuItem { existing.invoke = desired.invoke } if let existing = existing as? ActionMenuItem, let desired = desired as? ActionMenuItem { existing.invoke = desired.invoke } if let existing = existing as? SystemNoticeMenuItem, let desired = desired as? SystemNoticeMenuItem { existing.invoke = desired.invoke } if let status = existing.view as? MenuStatusView, let desiredStatus = desired.view as? MenuStatusView { status.update(from: desiredStatus) } else if let card = existing.view as? UpdateMenuCard, let desiredCard = desired.view as? UpdateMenuCard { card.update(from: desiredCard) } else if let slider = existing.view as? MenuDimSlider, let desiredSlider = desired.view as? MenuDimSlider { slider.update(from: desiredSlider) } if existing.view is MenuQuickControlsView || desired.view is MenuQuickControlsView { existing.view = desired.view } if let submenu = existing.submenu, let desiredSubmenu = desired.submenu { reconcile(submenu, with: desiredSubmenu) } else if let desiredSubmenu = desired.submenu { desired.submenu = nil existing.submenu = desiredSubmenu } else { existing.submenu = nil } } if menu.items.indices.contains(index), menu.items[index] === item { continue } item.menu?.removeItem(item) menu.insertItem(item, at: index) } let retained = Set(menu.items.prefix(desiredItems.count).map(ObjectIdentifier.init)) for item in menu.items where !retained.contains(ObjectIdentifier(item)) { menu.removeItem(item) } } public func stop() { guard !stopped else { return } stopped = true closePanel() popover.delegate = nil displayLink?.stop() displayLink = nil appearanceObservation?.invalidate() appearanceObservation = nil if let pointerMonitor { NSEvent.removeMonitor(pointerMonitor) } pointerMonitor = nil pointerActivation = nil DistributedNotificationCenter.default().removeObserver(self) NotificationCenter.default.removeObserver(self) menu.delegate = nil shortMenu.delegate = nil statusItem.button?.target = nil statusItem.button?.action = nil statusItem.menu = nil NSStatusBar.system.removeStatusItem(statusItem) } static func accessibilityValue( snapshot: LayoutSnapshot, permission: PermissionStatus, problem: MenuProblem?, suspensionStatus: String? = nil ) -> String { var parts = [ snapshot.isWaitingForSetup ? snapshot.accessibilityDescription : suspensionStatus ?? snapshot.accessibilityDescription ] if permission != .granted { parts.append(MenuText.text("Turn on Accessibility for Parcel…")) } else if let problem { parts.append(problem.title) } return parts.joined(separator: "\n") } private var isVisible: Bool { visibility?() ?? (statusItem.isVisible && NSMenu.menuBarVisible() && statusItem.button?.window?.occlusionState.contains(.visible) == true) } private func advanceAnimation(at timestamp: Double) { guard !stopped, displayLink?.isRunning == true else { return } precondition(timestamp.isFinite) lastFrameTimestamp = max(timestamp, lastFrameTimestamp ?? -.infinity) let previous = morph.current if isVisible { morph.sample(at: max(0, timestamp - animationStartedAt)) } else { morph.finish() } if previous != morph.current { draw() } if morph.remainingFrames == 0 { displayLink?.stop() } } private func image(for icon: MenuIcon, increaseContrast: Bool) -> NSImage { renderer.image( for: icon, increaseContrast: increaseContrast, appearance: statusItem.button?.effectiveAppearance, scale: statusItem.button?.window?.backingScaleFactor ?? 1) } private func draw() { guard !stopped, let button = statusItem.button else { return } let image = renderer.image( for: morph.current, increaseContrast: lastContrast, appearance: button.effectiveAppearance, scale: button.window?.backingScaleFactor ?? 1, cleanSpace: cleanSpaceMark, updateReady: updateMark) guard button.image !== image else { return } signposter.emitEvent("menu.icon.draw") button.image = image } isolated deinit { stop() } } @MainActor protocol MenuIconDisplayLink: AnyObject { var isRunning: Bool { get } func start(tick: @escaping @MainActor (Double) -> Void) func stop() } @MainActor private final class StatusButtonDisplayLink: MenuIconDisplayLink { private let button: NSStatusBarButton private var link: CADisplayLink? private var callback: (@MainActor (Double) -> Void)? var isRunning: Bool { link != nil } init(button: NSStatusBarButton) { self.button = button } func start(tick: @escaping @MainActor (Double) -> Void) { guard link == nil else { return } let relay = MenuIconDisplayLinkRelay(source: self) let link = button.displayLink(target: relay, selector: #selector(MenuIconDisplayLinkRelay.tick(_:))) self.link = link callback = tick link.add(to: .main, forMode: .common) } func stop() { link?.invalidate() link = nil callback = nil } func tick(_ link: CADisplayLink) { guard link === self.link else { return } callback?(link.targetTimestamp) } isolated deinit { stop() } } @MainActor private final class MenuIconDisplayLinkRelay: NSObject { weak var source: StatusButtonDisplayLink? init(source: StatusButtonDisplayLink) { self.source = source } @objc func tick(_ link: CADisplayLink) { source?.tick(link) } } private struct MenuPresentation: Equatable { let snapshot: LayoutSnapshot let configuration: ParcelConfiguration let permission: PermissionStatus let reduceMotion: Bool let increaseContrast: Bool let problem: MenuProblem? let suspensionStatus: String? let visible: Bool let activeMode: String? let effectiveShortcuts: [ConfigCommand: KeyChord]? let updateReady: Bool let updateVersion: String? let showUpdateCard: Bool let shortcutConflict: Bool } private struct MenuContent: Equatable { let presentation: MenuPresentation let workspace: MenuWorkspace? let unavailability: MenuWorkspace.Unavailability? let application: MenuApplication? let setupAction: MenuSetupAction? let developerTour: Bool }