Something went wrong. Try again.
An auto tiler for macOS
Something went wrong. Try again.
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145public import AppKitpublic import ParcelConfigimport QuartzCoreimport SwiftUIimport 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) }}
@MainActorfinal 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) }}
@MainActorfinal 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() }}
@MainActorprivate 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) } }}
@MainActorfinal 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…") }}
@MainActorpublic 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<MenuWorkspace, MenuWorkspace.Unavailability>)? 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() }}
@MainActorprotocol MenuIconDisplayLink: AnyObject { var isRunning: Bool { get } func start(tick: @escaping @MainActor (Double) -> Void) func stop()}
@MainActorprivate 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() }}
@MainActorprivate 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}