Match Windows ZoomIt behavior: bug fixes and UI polish

Sources/ZoomItMacCore/Annotations/AnnotationController.swift

@@ -6,7 +6,7 @@ final class AnnotationController {
     var currentStyle: AnnotationStyle = .default
 
     // Typing mode state, mirroring ZoomIt's font scaling and justification.
-    static let defaultFontSize: CGFloat = 36
+    static let defaultFontSize: CGFloat = 20
     var typingFontSize: CGFloat = AnnotationController.defaultFontSize
     var typingRightAligned: Bool = false
     /// PostScript/font family name used for typing mode. Empty means the
@@ -32,7 +32,7 @@ final class AnnotationController {
         if !name.isEmpty, let font = NSFont(name: name, size: size) {
             return font
         }
-        return NSFont.systemFont(ofSize: size, weight: .semibold)
+        return NSFont.systemFont(ofSize: size, weight: .regular)
     }
 
     func reset() {

Sources/ZoomItMacCore/App/AppController.swift

@@ -36,6 +36,10 @@ final class AppController: NSObject {
         modeCoordinator.handle(.activateStaticZoom)
     }
 
+    @objc func activateDrawWithoutZoom() {
+        modeCoordinator.handle(.activateDrawWithoutZoom)
+    }
+
     @objc func activateLiveZoom() {
         modeCoordinator.handle(.activateLiveZoom)
     }
@@ -94,6 +98,12 @@ final class AppController: NSObject {
         alert.addButton(withTitle: screenGranted ? "Screen Recording Settings…" : "Grant Screen Recording…")
         alert.addButton(withTitle: micStatus == .notDetermined ? "Grant Microphone…" : "Microphone Settings…")
         alert.addButton(withTitle: camStatus == .notDetermined ? "Grant Camera…" : "Camera Settings…")
+        // Use a standard macOS-style rounded-square icon so the dialog matches
+        // the look of system permission prompts and the icon top lines up with
+        // the message text.
+        if let icon = ZoomItAppIcon.standardIcon() {
+            alert.icon = icon
+        }
         alert.window.animationBehavior = .none
         NSApp.activate(ignoringOtherApps: true)
 

Sources/ZoomItMacCore/App/AppDelegate.swift

@@ -94,7 +94,7 @@ public final class AppDelegate: NSObject, NSApplicationDelegate {
             let config = NSImage.SymbolConfiguration(paletteColors: [.systemRed])
             let image = NSImage(systemSymbolName: "record.circle.fill", accessibilityDescription: "Recording")?
                 .withSymbolConfiguration(config)
-            image?.size = NSSize(width: 18, height: 18)
+            image?.size = NSSize(width: Self.menuBarIconGlyph, height: Self.menuBarIconGlyph)
             button.image = image
         } else {
             button.image = Self.menuBarIcon()
@@ -116,22 +116,13 @@ public final class AppDelegate: NSObject, NSApplicationDelegate {
         }
 
         let menu = NSMenu()
-        let staticZoomItem = NSMenuItem(title: "Static Zoom", action: #selector(AppController.activateStaticZoom), keyEquivalent: "")
-        menu.addItem(staticZoomItem)
-        let liveZoomItem = NSMenuItem(title: "Live Zoom", action: #selector(AppController.activateLiveZoom), keyEquivalent: "")
-        menu.addItem(liveZoomItem)
-        let recordItem = NSMenuItem(title: "Record Screen", action: #selector(AppController.toggleRecording), keyEquivalent: "")
-        menu.addItem(recordItem)
-        let panoramaItem = NSMenuItem(title: "Panorama Capture", action: #selector(AppController.startPanorama), keyEquivalent: "")
-        menu.addItem(panoramaItem)
-        let breakItem = NSMenuItem(title: "Break Timer", action: #selector(AppController.toggleBreakTimer), keyEquivalent: "")
-        menu.addItem(breakItem)
-        menu.addItem(.separator())
-        let settingsItem = NSMenuItem(title: "Settings…", action: #selector(AppController.showSettings), keyEquivalent: ",")
-        menu.addItem(settingsItem)
-        menu.addItem(NSMenuItem(title: "Check Permissions", action: #selector(AppController.checkPermissions), keyEquivalent: ""))
-        menu.addItem(.separator())
-        menu.addItem(NSMenuItem(title: "Quit", action: #selector(AppController.quit), keyEquivalent: "q"))
+        for entry in Self.statusMenuEntries() {
+            if entry.isSeparator {
+                menu.addItem(.separator())
+            } else {
+                menu.addItem(NSMenuItem(title: entry.title, action: entry.action, keyEquivalent: entry.keyEquivalent))
+            }
+        }
 
         for item in menu.items {
             item.target = controller
@@ -141,12 +132,72 @@ public final class AppDelegate: NSObject, NSApplicationDelegate {
         return item
     }
 
+    /// A single status-bar menu entry (or a separator when `action` is nil).
+    struct StatusMenuEntry {
+        let title: String
+        let action: Selector?
+        let keyEquivalent: String
+
+        var isSeparator: Bool { action == nil }
+
+        static let separator = StatusMenuEntry(title: "", action: nil, keyEquivalent: "")
+
+        init(title: String, action: Selector?, keyEquivalent: String) {
+            self.title = title
+            self.action = action
+            self.keyEquivalent = keyEquivalent
+        }
+    }
+
+    /// The status-bar menu. It broadly follows the Windows ZoomIt tray order
+    /// (Options first, then the modes, then Check Permissions and Quit), with
+    /// Panorama Capture as a macOS-only addition after Record and the Break
+    /// Timer placed at the end of the mode group (below Panorama Capture).
+    static func statusMenuEntries() -> [StatusMenuEntry] {
+        [
+            StatusMenuEntry(title: "Settings…", action: #selector(AppController.showSettings), keyEquivalent: ","),
+            .separator,
+            StatusMenuEntry(title: "Draw", action: #selector(AppController.activateDrawWithoutZoom), keyEquivalent: ""),
+            StatusMenuEntry(title: "Static Zoom", action: #selector(AppController.activateStaticZoom), keyEquivalent: ""),
+            StatusMenuEntry(title: "Live Zoom", action: #selector(AppController.activateLiveZoom), keyEquivalent: ""),
+            StatusMenuEntry(title: "Record Screen", action: #selector(AppController.toggleRecording), keyEquivalent: ""),
+            StatusMenuEntry(title: "Panorama Capture", action: #selector(AppController.startPanorama), keyEquivalent: ""),
+            StatusMenuEntry(title: "Break Timer", action: #selector(AppController.toggleBreakTimer), keyEquivalent: ""),
+            .separator,
+            StatusMenuEntry(title: "Check Permissions", action: #selector(AppController.checkPermissions), keyEquivalent: ""),
+            StatusMenuEntry(title: "Quit", action: #selector(AppController.quit), keyEquivalent: "q")
+        ]
+    }
+
     /// Loads the bundled black template version of the Windows ZoomIt icon and
     /// sizes it for the menu bar. As a template image it is tinted by the system
     /// (black on a light menu bar, white on a dark one).
     private static func menuBarIcon() -> NSImage? {
-        guard let image = loadZoomItIcon() else { return nil }
-        image.size = NSSize(width: 18, height: 18)
+        guard let source = loadZoomItIcon() else { return nil }
+        return Self.menuBarImage(from: source)
+    }
+
+    /// The square point size of the menu-bar item's image slot.
+    static let menuBarIconCanvas: CGFloat = 18
+    /// The glyph is drawn smaller than the canvas so ZoomIt's icon carries the
+    /// same interior padding as system menu-bar icons; a full-bleed image made
+    /// it look oversized and misaligned next to them.
+    static let menuBarIconGlyph: CGFloat = 15
+
+    /// Renders `source` centered inside a padded, square template image so it
+    /// matches the size and vertical alignment of other menu-bar icons.
+    static func menuBarImage(from source: NSImage) -> NSImage {
+        let canvas = NSSize(width: menuBarIconCanvas, height: menuBarIconCanvas)
+        let image = NSImage(size: canvas)
+        image.lockFocus()
+        let rect = NSRect(
+            x: (canvas.width - menuBarIconGlyph) / 2,
+            y: (canvas.height - menuBarIconGlyph) / 2,
+            width: menuBarIconGlyph,
+            height: menuBarIconGlyph
+        )
+        source.draw(in: rect, from: .zero, operation: .sourceOver, fraction: 1)
+        image.unlockFocus()
         image.isTemplate = true
         return image
     }

Sources/ZoomItMacCore/App/AppIcon.swift

@@ -18,6 +18,26 @@ enum ZoomItAppIcon {
         loadImage(named: "ZoomItIcon")
     }
 
+    /// A standard macOS-style app icon: the (full-bleed) artwork inset within a
+    /// rounded square with a margin, matching the silhouette of other app icons
+    /// so it looks right in pickers and the permissions dialog. The margin also
+    /// brings the visible top of the icon down to line up with dialog text.
+    static func standardIcon(size: CGFloat = 128) -> NSImage? {
+        guard let source = loadColorIcon() ?? loadTemplateIcon() else { return nil }
+        let canvas = NSSize(width: size, height: size)
+        let image = NSImage(size: canvas)
+        image.lockFocus()
+        // Apple's large-icon grid leaves roughly a 10% margin and uses a
+        // continuous-corner radius near 22% of the icon body.
+        let margin = (size * 0.10).rounded()
+        let body = NSRect(x: margin, y: margin, width: size - 2 * margin, height: size - 2 * margin)
+        let radius = body.width * 0.2237
+        NSBezierPath(roundedRect: body, xRadius: radius, yRadius: radius).addClip()
+        source.draw(in: body, from: .zero, operation: .sourceOver, fraction: 1)
+        image.unlockFocus()
+        return image
+    }
+
     private static func loadColorIcon() -> NSImage? {
         loadImage(named: "ZoomItColorIcon")
     }

Sources/ZoomItMacCore/App/IdleSleepAssertion.swift

@@ -0,0 +1,60 @@
+import Foundation
+import IOKit.pwr_mgt
+
+/// Prevents the display from idle-sleeping — and therefore the screen saver
+/// from starting — while held. Windows ZoomIt keeps the screen saver from
+/// kicking in during the break timer; this is the macOS equivalent using an
+/// `IOPMAssertion`.
+///
+/// The IOKit calls are injectable so the begin/end lifecycle can be unit
+/// tested without touching real power management.
+final class IdleSleepAssertion {
+    private let create: (String) -> IOPMAssertionID?
+    private let release: (IOPMAssertionID) -> Void
+    private var assertionID: IOPMAssertionID?
+
+    /// True while the assertion is held (display sleep / screen saver blocked).
+    var isActive: Bool { assertionID != nil }
+
+    init(
+        create: @escaping (String) -> IOPMAssertionID? = IdleSleepAssertion.systemCreate,
+        release: @escaping (IOPMAssertionID) -> Void = IdleSleepAssertion.systemRelease
+    ) {
+        self.create = create
+        self.release = release
+    }
+
+    deinit {
+        if let assertionID {
+            release(assertionID)
+        }
+    }
+
+    /// Acquires the assertion if not already held. Idempotent.
+    func begin(reason: String) {
+        guard assertionID == nil else { return }
+        assertionID = create(reason)
+    }
+
+    /// Releases the assertion if held. Idempotent.
+    func end() {
+        guard let assertionID else { return }
+        release(assertionID)
+        self.assertionID = nil
+    }
+
+    private static func systemCreate(_ reason: String) -> IOPMAssertionID? {
+        var id: IOPMAssertionID = IOPMAssertionID(0)
+        let result = IOPMAssertionCreateWithName(
+            kIOPMAssertionTypePreventUserIdleDisplaySleep as CFString,
+            IOPMAssertionLevel(kIOPMAssertionLevelOn),
+            reason as CFString,
+            &id
+        )
+        return result == kIOReturnSuccess ? id : nil
+    }
+
+    private static func systemRelease(_ id: IOPMAssertionID) {
+        IOPMAssertionRelease(id)
+    }
+}

Sources/ZoomItMacCore/Capture/PanoramaController.swift

@@ -3,8 +3,8 @@ import AppKit
 
 /// Draws a blue capture border plus an instruction banner around the panorama
 /// region. It lives in a click-through, non-shareable window so it never
-/// appears in the captured frames (mirroring the Windows excluded-from-capture
-/// SelectRectangle border).
+/// appears in the captured frames. Blue keeps it distinct from the orange
+/// screen-recording border.
 @MainActor
 private final class PanoramaBorderView: NSView {
     override var isFlipped: Bool { true }
@@ -53,6 +53,13 @@ final class PanoramaController {
 
     private(set) var isCapturing = false
     private var stopRequested = false
+    /// Set when the user presses Escape during the scrolling capture so the run
+    /// is discarded (matches Windows ZoomIt, where Escape cancels panorama).
+    private var captureCancelled = false
+    /// Event monitors that watch for Escape while capturing, so the user can
+    /// cancel even while another app is frontmost (they scroll it).
+    private var escapeGlobalMonitor: Any?
+    private var escapeLocalMonitor: Any?
     /// True from the moment a panorama is initiated (region selection) until it
     /// finishes, so a second trigger can't stack a new selection.
     private var isActive = false
@@ -153,7 +160,8 @@ final class PanoramaController {
 
             let view = SnipSelectionView(
                 frame: CGRect(origin: .zero, size: display.frame.size),
-                image: frame.image
+                image: frame.image,
+                borderColor: .systemBlue
             )
             var holder: NSWindow? = window
             var cursorLease: CrosshairCursorLease?
@@ -180,6 +188,8 @@ final class PanoramaController {
         showBorder(display: display, region: region)
         isCapturing = true
         stopRequested = false
+        captureCancelled = false
+        installEscapeMonitor()
         onStateChange?(true)
 
         Task { @MainActor in
@@ -219,6 +229,15 @@ final class PanoramaController {
                 try? await Task.sleep(nanoseconds: 16_000_000)
             }
 
+            // Escape cancels the whole panorama (Windows behaviour): discard the
+            // captured frames instead of stitching them.
+            if captureCancelled {
+                isCapturing = false
+                onStateChange?(false)
+                showCompletion(message: "Panorama cancelled")
+                return
+            }
+
             if stopRequested && frames.count < maxFrames && totalBytes + frameBytes <= maxFrameBytes {
                 let image = try? await SCScreenshotManager.captureImage(contentFilter: filter, configuration: configuration)
                 if let image, let frame = Self.makeFrame(from: image) {
@@ -550,6 +569,7 @@ final class PanoramaController {
     }
 
     private func hideOverlays() {
+        removeEscapeMonitor()
         borderWindow?.orderOut(nil)
         borderWindow = nil
         bannerWindow?.orderOut(nil)
@@ -561,6 +581,46 @@ final class PanoramaController {
         stitchTask = nil
     }
 
+    /// Requests cancellation of an in-progress scrolling capture (Escape).
+    private func cancelCapture() {
+        guard Self.shouldCancelOnEscape(isCapturing: isCapturing, alreadyCancelled: captureCancelled) else { return }
+        captureCancelled = true
+        stopRequested = true
+    }
+
+    /// Decides whether an Escape press should cancel the panorama. Escape only
+    /// cancels while actively capturing and ignores repeats once cancelled.
+    static func shouldCancelOnEscape(isCapturing: Bool, alreadyCancelled: Bool) -> Bool {
+        isCapturing && !alreadyCancelled
+    }
+
+    /// Watches for Escape during capture. A global monitor handles the common
+    /// case where the user is scrolling another (frontmost) app; a local
+    /// monitor covers the case where ZoomIt itself is frontmost.
+    private func installEscapeMonitor() {
+        removeEscapeMonitor()
+        escapeGlobalMonitor = NSEvent.addGlobalMonitorForEvents(matching: [.keyDown]) { [weak self] event in
+            guard event.keyCode == 53 else { return }
+            Task { @MainActor in self?.cancelCapture() }
+        }
+        escapeLocalMonitor = NSEvent.addLocalMonitorForEvents(matching: [.keyDown]) { [weak self] event in
+            guard event.keyCode == 53 else { return event }
+            Task { @MainActor in self?.cancelCapture() }
+            return nil
+        }
+    }
+
+    private func removeEscapeMonitor() {
+        if let monitor = escapeGlobalMonitor {
+            NSEvent.removeMonitor(monitor)
+            escapeGlobalMonitor = nil
+        }
+        if let monitor = escapeLocalMonitor {
+            NSEvent.removeMonitor(monitor)
+            escapeLocalMonitor = nil
+        }
+    }
+
     // MARK: - CGImage <-> Frame
 
     /// Convert a captured CGImage into a top-down RGBA frame for stitching.