native macOS codings agent orchestrator prowl.onev.cat
Something went wrong. Try again.
Swift
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427import AppKitimport SwiftUI
/// Unified color logic for the window *chrome* tint — the nav-panel band/// behind the floating glass sidebar and the toolbar band behind the/// transparent titlebar — shared across every view mode (Normal, Shelf,/// Canvas).////// The tint is "driven from the detail side": both bands are overlays on/// the full-bleed detail content that bleed up under the titlebar and left/// under the sidebar glass, so one resolved color paints the nav and the/// toolbar as a single continuous "L".////// `WindowTintMode` selects the source:/// - `.none` ⇒ no band (neutral system chrome)./// - `.repositoryColor` ⇒ the active repo's pinned color, or a neutral/// surface when uncolored. Shelf spines can use the same repo-color pair,/// or their own user-selected fallback behavior./// - `.custom` ⇒ a single user-chosen color, ignoring per-repo colors.enum WindowChromeTint { enum ToolbarFallbackEvent { case windowState(isFullScreen: Bool) case willEnterFullScreen case didEnterFullScreen case willExitFullScreen case didExitFullScreen }
struct RGBComponents: Equatable { var red: Double var green: Double var blue: Double
var color: Color { Color(.sRGB, red: red, green: green, blue: blue) }
var luminance: Double { 0.2126 * red + 0.7152 * green + 0.0722 * blue } }
/// A resolved chrome band: a base color plus the alpha it should be /// filled at. `nil` from `fill(...)` means "draw no band". struct Fill: Equatable { var color: Color var alpha: Double }
/// Peak fill alpha for a saturated tint (a colored repo, or a custom /// color). Matches the Shelf spine's open-book peak so the chrome and /// the spine read at the same intensity. static let saturatedPeakAlpha: Double = 0.20 /// Gentler peak for the neutral fallback: `Color.primary` reads as a /// distinct panel at far lower opacity than a saturated hue, so 0.20 /// would look like a glaring mid-gray instead of the subtle near-black / /// near-white surface we want. static let neutralPeakAlpha: Double = 0.10
/// Base hue for a repository-color surface: the pinned color, or /// `Color.primary` for the neutral fallback. Used by `.repositoryColor` /// chrome bands. static func repositoryBase(for color: RepositoryColorChoice?) -> Color { color?.color ?? .primary }
/// Peak alpha for a repository-color surface — the saturated peak for a /// pinned color, the neutral peak when uncolored. static func repositoryPeakAlpha(for color: RepositoryColorChoice?) -> Double { color == nil ? neutralPeakAlpha : saturatedPeakAlpha }
/// Surface hue and peak alpha for a Shelf spine. When /// `followsRepositoryColor` is true, a pinned repo color wins (saturated /// peak); otherwise every spine uses the user's fallback style — `.neutral` /// stays gentler, `.systemTint` uses the saturated shelf/chrome peak. Base /// and alpha share one branch so they can never disagree. static func shelfSpineSurface( for color: RepositoryColorChoice?, fallback: ShelfSpineTintFallback, followsRepositoryColor: Bool ) -> (base: Color, peakAlpha: Double) { if followsRepositoryColor, let color { return (color.color, saturatedPeakAlpha) } let peakAlpha = fallback == .neutral ? neutralPeakAlpha : saturatedPeakAlpha return (shelfSpineFallbackBase(fallback), peakAlpha) }
private static func shelfSpineFallbackBase(_ fallback: ShelfSpineTintFallback) -> Color { switch fallback { case .neutral: return .primary case .systemTint: return .accentColor } }
/// Resolves the chrome band for the given tint mode. Returns `nil` when /// no band should be drawn (`.none`, or `.custom` without a color). /// /// - Parameters: /// - mode: the user's window tint mode. /// - customColor: the user's custom color, for `.custom` mode. /// - repositoryColor: the active repo's pinned color (the open book in /// Shelf, the selected worktree's repo in Normal, the focused card's /// repo in Canvas), used by `.repositoryColor` mode. static func fill( mode: WindowTintMode, customColor: Color?, repositoryColor: RepositoryColorChoice? ) -> Fill? { switch mode { case .none: return nil case .repositoryColor: return Fill( color: repositoryBase(for: repositoryColor), alpha: repositoryPeakAlpha(for: repositoryColor) ) case .custom: guard let customColor else { return nil } return Fill(color: customColor, alpha: saturatedPeakAlpha) } }
/// Resolves the fallback fullscreen toolbar background to an opaque sRGB /// color under the requested app appearance. The normal window path keeps /// the toolbar background hidden so the original content tint / system /// material composition remains untouched; this fallback is only for the /// fullscreen AppKit toolbar surface, which can stop sampling the content /// behind it. static func fullscreenToolbarBackgroundComponents( fill: Fill?, colorScheme: ColorScheme ) -> RGBComponents { let base = resolvedComponents(for: NSColor.windowBackgroundColor, colorScheme: colorScheme) guard let fill else { return base }
let overlay = resolvedComponents(for: fill.color, colorScheme: colorScheme) let alpha = min(max(fill.alpha, 0), 1) return RGBComponents( red: overlay.red * alpha + base.red * (1 - alpha), green: overlay.green * alpha + base.green * (1 - alpha), blue: overlay.blue * alpha + base.blue * (1 - alpha) ) }
private static func resolvedComponents(for color: Color, colorScheme: ColorScheme) -> RGBComponents { resolvedComponents(for: NSColor(color), colorScheme: colorScheme) }
private static func resolvedComponents(for color: NSColor, colorScheme: ColorScheme) -> RGBComponents { withAppearance(for: colorScheme) { let resolved = color.usingColorSpace(.sRGB) ?? fallbackColor(for: colorScheme) return RGBComponents( red: Double(resolved.redComponent), green: Double(resolved.greenComponent), blue: Double(resolved.blueComponent) ) } }
private static func withAppearance<T>(for colorScheme: ColorScheme, _ body: () -> T) -> T { guard let appearance = NSAppearance(named: colorScheme == .dark ? .darkAqua : .aqua) else { return body() }
var result: T? appearance.performAsCurrentDrawingAppearance { result = body() } return result! }
private static func fallbackColor(for colorScheme: ColorScheme) -> NSColor { colorScheme == .dark ? .black : .white }
static func usesExplicitToolbarBackground(isFullScreen: Bool) -> Bool { isFullScreen }
static func toolbarFallbackState(current: Bool, event: ToolbarFallbackEvent) -> Bool { switch event { case .windowState(let isFullScreen): return isFullScreen case .willEnterFullScreen, .didEnterFullScreen, .willExitFullScreen: return true case .didExitFullScreen: return false } }}
extension View { /// Overlays chrome tint bands on full-bleed detail content. The bands /// fill the safe-area insets the window reserves for the toolbar (top) /// and the floating sidebar (leading), bleeding past them via /// `ignoresSafeArea` so the color reaches under the titlebar / sidebar /// glass. A `nil` fill draws nothing. /// /// - Parameters: /// - fill: the resolved band fill, or `nil` for no tint. /// - edges: which chrome regions to tint — `.top` (toolbar) and/or /// `.leading` (nav). Normal uses both; Canvas uses `.leading` only. func windowChromeTint(_ fill: WindowChromeTint.Fill?, edges: Edge.Set) -> some View { modifier(WindowChromeTintModifier(fill: fill, edges: edges)) }
/// Sets the real SwiftUI/AppKit window toolbar background. This is kept /// separate from `windowChromeTint`: the tint bands color the content /// behind full-bleed chrome, while the toolbar itself must also have an /// explicit background because macOS can stop sampling that content when /// a window is zoomed or fullscreen. func windowToolbarChromeBackground( _ fill: WindowChromeTint.Fill?, forceMaterialScrim: Bool = false ) -> some View { modifier(WindowToolbarChromeBackgroundModifier(fill: fill, forceMaterialScrim: forceMaterialScrim)) }}
/// Measures the toolbar (top) and sidebar (leading) safe-area insets of/// the detail content and paints a band into each requested edge.private struct WindowChromeTintModifier: ViewModifier { let fill: WindowChromeTint.Fill? let edges: Edge.Set
@State private var topInset: CGFloat = 0 @State private var leadingInset: CGFloat = 0
func body(content: Content) -> some View { content // Content draws under the transparent titlebar, so the top // safe-area inset equals the toolbar/titlebar height — exactly the // region the top band should fill. .onGeometryChange(for: CGFloat.self) { $0.safeAreaInsets.top } action: { topInset = $0 } // The detail is laid out full-bleed beneath the floating glass // sidebar, so the leading inset equals the sidebar width — the span // the leading band fills to color the nav. .onGeometryChange(for: CGFloat.self) { $0.safeAreaInsets.leading } action: { leadingInset = $0 } .overlay(alignment: .top) { if let fill, edges.contains(.top) { band(fill) .frame(height: topInset) .frame(maxWidth: .infinity) .ignoresSafeArea(.container, edges: .top) } } .overlay(alignment: .leading) { if let fill, edges.contains(.leading) { band(fill) .frame(width: leadingInset) .frame(maxHeight: .infinity) .ignoresSafeArea(.container, edges: [.leading, .top, .bottom]) } } }
private func band(_ fill: WindowChromeTint.Fill) -> some View { fill.color .opacity(fill.alpha) .allowsHitTesting(false) }}
private struct WindowToolbarChromeBackgroundModifier: ViewModifier { let fill: WindowChromeTint.Fill? /// When true (a Canvas card is expanded in place), forces a neutral material /// scrim onto the otherwise-transparent Canvas toolbar so the background cards /// don't show through above the expanded card. Crucially this stays the same /// modifier (only its inputs change), so toggling it never re-creates the /// detail content / Canvas view. let forceMaterialScrim: Bool @Environment(\.colorScheme) private var colorScheme @State private var isFullScreen = false
@ViewBuilder func body(content: Content) -> some View { let colorBackground = WindowChromeTint.fullscreenToolbarBackgroundComponents( fill: fill, colorScheme: colorScheme ).color // `.bar` is a theme-adaptive material (light → pale grey, dark → dark grey). let background: AnyShapeStyle = forceMaterialScrim ? AnyShapeStyle(.bar) : AnyShapeStyle(colorBackground) let visibility: Visibility = forceMaterialScrim || WindowChromeTint.usesExplicitToolbarBackground(isFullScreen: isFullScreen) ? .visible : .hidden
content .toolbarBackground(background, for: .windowToolbar) .toolbarBackgroundVisibility(visibility, for: .windowToolbar) .background { WindowFullScreenReader(isFullScreen: $isFullScreen) } }}
private struct WindowFullScreenReader: NSViewRepresentable { @Binding var isFullScreen: Bool
func makeNSView(context: Context) -> WindowFullScreenReaderView { let view = WindowFullScreenReaderView() view.onFullScreenChange = makeChangeHandler() return view }
func updateNSView(_ nsView: WindowFullScreenReaderView, context: Context) { nsView.onFullScreenChange = makeChangeHandler() nsView.refresh() }
private func makeChangeHandler() -> (Bool) -> Void { let binding = $isFullScreen return { isFullScreen in guard binding.wrappedValue != isFullScreen else { return } DispatchQueue.main.async { guard binding.wrappedValue != isFullScreen else { return } binding.wrappedValue = isFullScreen } } }}
@MainActorprivate final class WindowFullScreenReaderView: NSView { var onFullScreenChange: ((Bool) -> Void)?
private weak var observedWindow: NSWindow? private var observers: [NSObjectProtocol] = []
deinit { MainActor.assumeIsolated { removeObservers() } }
override func viewDidMoveToWindow() { super.viewDidMoveToWindow() updateObservedWindow() }
func refresh() { updateObservedWindow() publishFullScreenState() }
private func updateObservedWindow() { guard observedWindow !== window else { return }
removeObservers() observedWindow = window
guard let window else { // SwiftUI can temporarily detach this reader while rebuilding the // toolbar host. Detach is not an exit-fullscreen signal; publishing // `false` here would hide the fallback background for one frame and // produce a visible flicker. return }
observe(window, name: NSWindow.willEnterFullScreenNotification) { [weak self] in self?.publishFullScreenEvent(.willEnterFullScreen) } observe(window, name: NSWindow.didEnterFullScreenNotification) { [weak self] in self?.publishFullScreenEvent(.didEnterFullScreen) } observe(window, name: NSWindow.willExitFullScreenNotification) { [weak self] in self?.publishFullScreenEvent(.willExitFullScreen) } observe(window, name: NSWindow.didExitFullScreenNotification) { [weak self] in self?.publishFullScreenEvent(.didExitFullScreen) }
publishFullScreenState() }
private func observe( _ window: NSWindow, name: NSNotification.Name, handler: @escaping @MainActor () -> Void ) { let observer = NotificationCenter.default.addObserver( forName: name, object: window, queue: .main ) { _ in MainActor.assumeIsolated { handler() } } observers.append(observer) }
private func removeObservers() { let notificationCenter = NotificationCenter.default for observer in observers { notificationCenter.removeObserver(observer) } observers.removeAll() }
private func publishFullScreenState() { guard let window else { return } publishFullScreenEvent(.windowState(isFullScreen: window.styleMask.contains(.fullScreen))) }
private func publishFullScreenEvent(_ event: WindowChromeTint.ToolbarFallbackEvent) { onFullScreenChange?( WindowChromeTint.toolbarFallbackState( current: window?.styleMask.contains(.fullScreen) == true, event: event ) ) }}