Pika 2.0.0

Pika/AppDelegate.swift

@@ -82,6 +82,11 @@ class AppDelegate: NSObject, NSApplicationDelegate {
         validateColorSpace()
         showPikaIfConfigured()
         registerGlobalKeyMonitor()
+
+        // Refresh the colour-name list from color.pizza (catalogue + selected list) and cache
+        // it; the eyedroppers rebuild via `.colorNamesUpdated`. Best-effort — falls back to
+        // the bundled default offline.
+        ColorNamesManager.shared.updateOnLaunch()
     }
 
     private func removeUpdatesMenuItemIfNeeded() {
@@ -113,10 +118,27 @@ class AppDelegate: NSObject, NSApplicationDelegate {
                 NSApp.sendAction(#selector(AppDelegate.triggerPickForeground), to: nil, from: nil)
             }
         }
+        KeyboardShortcuts.onKeyUp(for: .pickPair) { [] in
+            if Defaults[.viewedSplash] {
+                NSApp.sendAction(#selector(AppDelegate.triggerPickContrast), to: nil, from: nil)
+            }
+        }
+    }
+
+    /// The splash shows on every launch unless the user ticked its (pre-selected) "Don't show
+    /// this again" checkbox — EXCEPT when a new onboarding version hasn't been seen yet, in which
+    /// case it shows once for everyone (see `PikaConstants.currentSplashVersion`).
+    private var shouldShowSplash: Bool {
+        !Defaults[.hideSplashOnLaunch]
+            || Defaults[.lastSeenSplashVersion] < PikaConstants.currentSplashVersion
     }
 
     private func presentSplashIfNeeded() {
-        if !Defaults[.viewedSplash] {
+        // `viewedSplash` still records the first run so the pick shortcuts stay gated until
+        // onboarding is dismissed the first time. `lastSeenSplashVersion` is recorded on
+        // dismissal (`closeSplashWindow`), not here — recording it now would make
+        // `showPikaIfConfigured` reveal the main window behind the splash.
+        if shouldShowSplash {
             openSplashWindow(nil)
             NSApp.activate(ignoringOtherApps: true)
         }
@@ -129,6 +151,13 @@ class AppDelegate: NSObject, NSApplicationDelegate {
     }
 
     private func showPikaIfConfigured() {
+        // Pika should only ever appear once the splash has been dismissed. When the splash
+        // is up, defer the main window until `closeSplashWindow` fires; otherwise show it now.
+        guard !shouldShowSplash else { return }
+        presentConfiguredPika()
+    }
+
+    private func presentConfiguredPika() {
         if Defaults[.alwaysShowOnLaunch], !Defaults[.appMode].usesPopover {
             showPika(self)
         }
@@ -215,7 +244,15 @@ class AppDelegate: NSObject, NSApplicationDelegate {
 // MARK: - Window forwarding
 
 extension AppDelegate {
-    @objc func closeSplashWindow() { windowCoordinator.closeSplashWindow() }
+    @objc func closeSplashWindow() {
+        windowCoordinator.closeSplashWindow()
+        // Record that this onboarding version has been seen, so the version gate doesn't
+        // re-show it next launch (the user's "Don't show again" choice governs from here).
+        Defaults[.lastSeenSplashVersion] = PikaConstants.currentSplashVersion
+        // Now that onboarding is dismissed, show Pika if the user has it set to launch shown.
+        presentConfiguredPika()
+    }
+
     @objc func togglePopover(_: AnyObject?) { windowCoordinator.togglePopover() }
 
     @IBAction func openAboutWindow(_: Any?) { windowCoordinator.openAboutWindow() }
@@ -240,6 +277,7 @@ extension AppDelegate {
 
     @IBAction func triggerPickContrast(_: Any) {
         notificationCenter.post(name: .triggerPickForeground, object: self, userInfo: ["chain": true])
+        notificationCenter.post(name: .triggerPickPair, object: self)
     }
 
     @IBAction func triggerCopyForeground(_: Any) {
@@ -286,12 +324,30 @@ extension AppDelegate {
         notificationCenter.post(name: .triggerSwap, object: self)
     }
 
+    /// The `NSTextView` field editor of whichever `ScrubTextField` is currently being edited, if
+    /// any — `ScrubTextField.becomeFirstResponder` makes the field editor (not the field itself)
+    /// the window's first responder while editing, so this is the one place both `triggerUndo`
+    /// and `triggerRedo` need to check to keep Cmd-Z scoped to "whatever the user is actually
+    /// looking at": a value being typed, if one is focused, otherwise colour-pick history.
+    private var focusedFieldUndoManager: UndoManager? {
+        guard let editor = NSApp.keyWindow?.firstResponder as? NSTextView, editor.isFieldEditor else { return nil }
+        return editor.undoManager
+    }
+
     @IBAction func triggerUndo(_: Any) {
+        if let manager = focusedFieldUndoManager, manager.canUndo {
+            manager.undo()
+            return
+        }
         notificationCenter.post(name: .triggerUndo, object: self)
         eyedroppers.undo()
     }
 
     @IBAction func triggerRedo(_: Any) {
+        if let manager = focusedFieldUndoManager, manager.canRedo {
+            manager.redo()
+            return
+        }
         notificationCenter.post(name: .triggerRedo, object: self)
         eyedroppers.redo()
     }

Pika/Assets/en.lproj/Localizable.strings

@@ -202,6 +202,9 @@
 /* Background */
 "color.background" = "Background";
 
+/* Invalid input */
+"color.edit.invalid" = "Invalid input";
+
 /* WCAG 3:1 */
 "color.wcag.30" = "WCAG 2 level AA requires a contrast ratio of at least 3:1 for large (18pt / ~24px) or bold (14pt / ~18.6px) text, and for non-text content like UI.";
 

Pika/Constants/Constants.swift

@@ -4,6 +4,9 @@ import SwiftUI
 
 extension KeyboardShortcuts.Name {
     static let togglePika = Self("togglePika")
+    // Global, user-rebindable "pick a pair" shortcut (foreground → background chain).
+    // Defaults to ⌥⌘D, matching the in-window menu equivalent it replaces.
+    static let pickPair = Self("pickPair", default: .init(.d, modifiers: [.command, .option]))
 }
 
 enum PikaConstants {
@@ -14,6 +17,11 @@ enum PikaConstants {
             : "https://superhighfives.com/releases/pika"
     }
 
+    // Bump when a release has onboarding worth re-showing: the splash then appears once for
+    // everyone (even those who ticked "Don't show again") whose `lastSeenSplashVersion` is lower.
+    // v1: the custom (Pro) colour picker.
+    static let currentSplashVersion = 1
+
     static let pikaWebsiteURL = "https://superhighfives.com/pika"
     static let gitHubRepoURL = "https://github.com/superhighfives/pika"
     static let gitHubIssueURL = "https://github.com/superhighfives/pika/issues/new/choose"
@@ -42,6 +50,7 @@ enum PikaConstants {
     static let ncTriggerCopyData = "triggerCopyData"
     static let ncTriggerPickForeground = "triggerPickForeground"
     static let ncTriggerPickBackground = "triggerPickBackground"
+    static let ncTriggerPickPair = "triggerPickPair"
     static let ncTriggerSystemPickerForeground = "triggerSystemPickerForeground"
     static let ncTriggerSystemPickerBackground = "triggerSystemPickerBackground"
     static let ncTriggerSwap = "triggerSwap"
@@ -67,6 +76,7 @@ enum PikaConstants {
     static let ncExportPalette = "exportPalette"
     static let ncSystemColorChanged = "systemColorChanged"
     static let ncExpandToFit = "expandToFit"
+    static let ncColorNamesUpdated = "colorNamesUpdated"
 
     // Disabled formats for SwiftUI copy format
     static let disabledFormats: [ColorFormat] = [.hex, .hsl, .opengl, .lab, .oklch]
@@ -75,6 +85,9 @@ enum PikaConstants {
 extension Notification.Name {
     static let triggerPickForeground = Notification.Name(PikaConstants.ncTriggerPickForeground)
     static let triggerPickBackground = Notification.Name(PikaConstants.ncTriggerPickBackground)
+    /// Help-grid-only: fired alongside the chained `.triggerPickForeground` post so
+    /// "Pick pair"'s own row highlights instead of piggybacking on "Pick foreground"'s.
+    static let triggerPickPair = Notification.Name(PikaConstants.ncTriggerPickPair)
     static let triggerCopyForeground = Notification.Name(PikaConstants.ncTriggerCopyForeground)
     static let triggerCopyBackground = Notification.Name(PikaConstants.ncTriggerCopyBackground)
     static let triggerCopyText = Notification.Name(PikaConstants.ncTriggerCopyText)
@@ -104,4 +117,5 @@ extension Notification.Name {
     static let exportPalette = Notification.Name(PikaConstants.ncExportPalette)
     static let systemColorChanged = Notification.Name(PikaConstants.ncSystemColorChanged)
     static let expandToFit = Notification.Name(PikaConstants.ncExpandToFit)
+    static let colorNamesUpdated = Notification.Name(PikaConstants.ncColorNamesUpdated)
 }

Pika/Constants/Defaults.swift

@@ -60,6 +60,25 @@ enum WindowShadow: String, Codable, CaseIterable {
     var showsShadowAtRest: Bool { self != .never }
 }
 
+enum PickerStyle: String, Codable, CaseIterable, Equatable {
+    case system // NSColorSampler (default, today's behaviour)
+    case custom // Pika-native loupe
+}
+
+enum LoupeTheme: String, Codable, CaseIterable, Equatable {
+    case lens // colour-filled rim engraved with the format + colour name (SF Pro)
+    case badge // white rounded badges hugging the inside edge (monospaced)
+    case card // plain magnifier with a readout card beside it
+
+    var localizedName: String {
+        switch self {
+        case .lens: return PikaText.textLoupeThemeLens
+        case .badge: return PikaText.textLoupeThemeBadge
+        case .card: return PikaText.textLoupeThemeCard
+        }
+    }
+}
+
 enum AppMode: String, Codable, CaseIterable {
     case menubar = "preferences.app.mode.menubar"
     case regular = "preferences.app.mode.regular"
@@ -84,9 +103,21 @@ enum AppMode: String, Codable, CaseIterable {
 extension Defaults.Keys {
     static let colorFormat = Key<ColorFormat>("colorFormat", default: .hex)
     static let viewedSplash = Key<Bool>("viewedSplash", default: false)
+    // The colour-name list to use, keyed to color.pizza's `/v1/lists/`. `default` is the
+    // list bundled at build time as the offline fallback.
+    static let colorNameList = Key<String>("colorNameList", default: "default")
+    // When false, the splash is shown on launch. The splash's pre-selected "Don't show
+    // this again" checkbox sets this to true on dismissal.
+    static let hideSplashOnLaunch = Key<Bool>("hideSplashOnLaunch", default: false)
+    // The `PikaConstants.currentSplashVersion` last shown to the user. Bumping that constant
+    // re-shows the splash once for everyone (even those who ticked "Don't show again"), so a
+    // release with new onboarding gets in front of existing users.
+    static let lastSeenSplashVersion = Key<Int>("lastSeenSplashVersion", default: 0)
     static let hidePikaWhilePicking = Key<Bool>("hidePikaWhilePicking", default: false)
     static let windowShadow = Key<WindowShadow>("windowShadow", default: .always)
     static let pickContrastingColor = Key<Bool>("pickContrastingColor", default: false)
+    static let pickerStyle = Key<PickerStyle>("pickerStyle", default: .system)
+    static let loupeTheme = Key<LoupeTheme>("loupeTheme", default: .lens)
     static let copyColorOnPick = Key<Bool>("copyColorOnPick", default: false)
     static let hideMenuBarIcon = Key<Bool>("hideMenuBarIcon", default: false)
     static let betaUpdates = Key<Bool>("betaUpdates", default: false)

Pika/Constants/PikaShortcuts.swift

@@ -13,6 +13,29 @@ struct PikaShortcut {
     let modifiers: NSEvent.ModifierFlags
     let action: Selector
     let notificationName: Notification.Name
+    /// True when this shortcut is also registered as a global `KeyboardShortcuts`
+    /// hotkey (see `AppDelegate.registerTogglePikaShortcut`). Such shortcuts fire
+    /// regardless of focus, so the popover local monitor must NOT dispatch them
+    /// again — otherwise the action double-fires. Still shown in the Help grid.
+    let hasGlobalBinding: Bool
+
+    init(
+        title: String,
+        displayKeys: [String],
+        character: String,
+        modifiers: NSEvent.ModifierFlags,
+        action: Selector,
+        notificationName: Notification.Name,
+        hasGlobalBinding: Bool = false
+    ) {
+        self.title = title
+        self.displayKeys = displayKeys
+        self.character = character
+        self.modifiers = modifiers
+        self.action = action
+        self.notificationName = notificationName
+        self.hasGlobalBinding = hasGlobalBinding
+    }
 }
 
 enum PikaShortcuts {
@@ -29,6 +52,16 @@ enum PikaShortcuts {
             action: #selector(AppDelegate.triggerPickBackground),
             notificationName: .triggerPickBackground
         ),
+        PikaShortcut(
+            title: PikaText.textPickPair,
+            displayKeys: ["⌥", "⌘", "D"], character: "d", modifiers: [.command, .option],
+            action: #selector(AppDelegate.triggerPickContrast),
+            notificationName: .triggerPickPair,
+            // Already bound globally as `KeyboardShortcuts.Name.pickPair`, which
+            // fires regardless of focus — skip local-monitor dispatch to avoid a
+            // double pick (mirrors the menu-accelerator omission in PikaApp.swift).
+            hasGlobalBinding: true
+        ),
         PikaShortcut(
             title: PikaText.textCopyForeground,
             displayKeys: ["⌘", "C"], character: "c", modifiers: .command,
@@ -133,10 +166,12 @@ enum PikaShortcuts {
         ),
     ]
 
-    /// Returns the shortcut matching the given key event, if any.
+    /// Returns the shortcut matching the given key event, if any. Shortcuts that
+    /// are also globally bound are excluded — the global hotkey already dispatches
+    /// them regardless of focus, so matching here would double-fire the action.
     static func match(_ event: NSEvent) -> PikaShortcut? {
         let chars = event.charactersIgnoringModifiers?.lowercased() ?? ""
         let mods = event.modifierFlags.intersection(.deviceIndependentFlagsMask)
-        return all.first { $0.character == chars && $0.modifiers == mods }
+        return all.first { $0.character == chars && $0.modifiers == mods && !$0.hasGlobalBinding }
     }
 }