Treat any same-app window as popup risk for window capture

Owned popups composite their parent even when the windows do not
overlap, so the intersection test missed DBeaver-style floating dialogs.
Any other window from the same app now routes the pick to the screen
crop.

💘 Generated with Crush

Assisted-by: Crush:deepseek-v4-flash-0731

Sources/Kapture/App.swift

@@ -21,6 +21,17 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
             runOCRSelfTest()
             return
         }
+        // Single instance: stale copies keep their own hotkey + overlays alive
+        // after app updates and eat clicks meant for the new instance.
+        let myPid = ProcessInfo.processInfo.processIdentifier
+        let others = NSRunningApplication.runningApplications(withBundleIdentifier: "dev.tzgyn.kapture")
+            .filter { $0.processIdentifier != myPid }
+        if !others.isEmpty {
+            CaptureController.log("launch: other Kapture instances pids=\(others.map { String($0.processIdentifier) }.joined(separator: ",")) — terminating them")
+            for other in others {
+                other.forceTerminate()
+            }
+        }
         HotkeyManager.shared.onTrigger = { CaptureController.shared.begin() }
         HotkeyManager.shared.register()
     }
@@ -79,6 +90,13 @@ enum PermissionManager {
     static func request() {
         CGRequestScreenCaptureAccess()
     }
+
+    static var isAccessibilityGranted: Bool { AXIsProcessTrusted() }
+
+    static func requestAccessibility() {
+        let opts = [kAXTrustedCheckOptionPrompt.takeUnretainedValue(): true] as CFDictionary
+        _ = AXIsProcessTrustedWithOptions(opts)
+    }
 }
 
 enum LoginItem {

Sources/Kapture/CaptureController.swift

@@ -1,19 +1,51 @@
 import AppKit
 import CoreGraphics
 import ScreenCaptureKit
+import ApplicationServices
 
 final class CaptureController: NSObject {
     static let shared = CaptureController()
 
-    private var overlays: [NSWindow] = []
+    private var overlays: [OverlayWindow] = []
     private(set) var isSelecting = false
     private var previousApp: NSRunningApplication?
     private var overlayIDs: [Int] = []
 
+    // Selection state (driven by the event tap; AppKit global coordinates)
+    private var marqueeStart: NSPoint?
+    private(set) var marqueeRect: NSRect?
+    private(set) var hoverWindow: (id: CGWindowID, frame: NSRect, pid: Int)?
+    var hoverFrame: NSRect? { hoverWindow?.frame }
+    private var trackedWindows: [(id: CGWindowID, frame: NSRect, pid: Int)] = []
+    private var lastWindowScan = Date.distantPast
+    private var eventTap: CFMachPort?
+
+    /// Session event log for debugging (dumped via Copy Diagnostics).
+    /// Also appended to /tmp/kapture-debug.log so it survives relaunches.
+    static var sessionLog: [String] = []
+    static func log(_ line: String) {
+        let stamped = String(format: "%@ %@", DateFormatter.localizedString(from: Date(), dateStyle: .none, timeStyle: .medium), line)
+        sessionLog.append(stamped)
+        if sessionLog.count > 200 { sessionLog.removeFirst() }
+        NSLog("[Kapture] \(line)")
+        let path = "/tmp/kapture-debug.log"
+        if let handle = FileHandle(forWritingAtPath: path) {
+            handle.seekToEndOfFile()
+            handle.write((stamped + "\n").data(using: .utf8)!)
+            handle.closeFile()
+        } else {
+            FileManager.default.createFile(atPath: path, contents: (stamped + "\n").data(using: .utf8))
+        }
+    }
+
     /// Diagnostic snapshot for "Copy Diagnostics" menu item.
     func diagnostics() -> String {
         var lines: [String] = []
-        lines.append("Kapture diagnostics")
+        lines.append("Kapture diagnostics — version \(Bundle.main.infoDictionary?["CFBundleShortVersionString"] ?? "?")")
+        lines.append("accessibility=\(AXIsProcessTrusted()) eventTap=\(eventTap != nil)")
+        lines.append("--- session log (newest last) ---")
+        lines.append(contentsOf: Self.sessionLog)
+        lines.append("--- screens ---")
         for (i, s) in NSScreen.screens.enumerated() {
             let scale = s.backingScaleFactor
             let cgID = (s.deviceDescription[NSDeviceDescriptionKey("NSScreenNumber")] as? NSNumber)?.uint32Value ?? 0
@@ -42,6 +74,8 @@ final class CaptureController: NSObject {
         return lines.joined(separator: "\n")
     }
 
+    // MARK: - Session lifecycle
+
     func begin() {
         guard !isSelecting else { return }
         guard PermissionManager.isGranted else {
@@ -50,31 +84,38 @@ final class CaptureController: NSObject {
         }
         isSelecting = true
         previousApp = NSWorkspace.shared.frontmostApplication
-        if #available(macOS 14.0, *) {
-            NSApp.activate()
-        } else {
-            NSApp.activate(ignoringOtherApps: true)
+        // Activation is async on macOS 26; wait a tick so the app is active
+        // before the overlays appear (otherwise clicks pass through).
+        NSApp.activate(ignoringOtherApps: true)
+        CaptureController.log("begin: activate issued, active=\(NSApp.isActive)")
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.05) { [weak self] in
+            guard let self, self.isSelecting else { return }
+            CaptureController.log("begin: active=\(NSApp.isActive) — showing overlays")
+            self.overlays = NSScreen.screens.map { screen in
+                let panel = OverlayWindow(screen: screen, controller: self)
+                (panel.contentView as? OverlayView)?.controller = self
+                return panel
+            }
+            self.overlays.forEach { $0.makeKeyAndOrderFront(nil) }
+            self.overlayIDs = self.overlays.map { $0.windowNumber }
+            CaptureController.log("begin: \(self.overlays.count) overlays, ids=\(self.overlayIDs), active=\(NSApp.isActive)")
+            self.installEventTap()
         }
-        overlays = NSScreen.screens.map { screen in
-            OverlayWindow(
-                screen: screen,
-                onComplete: { [weak self] rect in self?.finishSelection(rect) },
-                onCancel: { [weak self] in self?.cancelSelection() },
-                onWindowPick: { [weak self] rect in self?.finishWindowPick(rect) }
-            )
-        }
-        overlays.forEach { $0.makeKeyAndOrderFront(nil) }
-        overlayIDs = overlays.map { $0.windowNumber }
     }
 
-    /// A window was picked from hover — capture it with rounded corners.
-    private func finishWindowPick(_ rect: NSRect) {
+    /// A window was picked from hover — capture it directly (real rounded
+    /// corners come from the window's own alpha).
+    private func finishWindowPick(_ windowID: CGWindowID, _ rect: NSRect, ownedRisk: Bool) {
         let ids = overlayIDs
         hideOverlays()
         isSelecting = false
         restorePreviousApp()
         DispatchQueue.main.async { [self] in
-            capture(rect, excludingWindowIDs: ids, roundedCorners: true)
+            if ownedRisk {
+                capture(rect, excludingWindowIDs: ids, roundedCorners: true)
+            } else {
+                capture(rect, excludingWindowIDs: ids, windowID: windowID)
+            }
         }
     }
 
@@ -97,8 +138,12 @@ final class CaptureController: NSObject {
     }
 
     private func hideOverlays() {
+        removeEventTap()
         overlays.forEach { $0.orderOut(nil) }
         overlays = []
+        marqueeRect = nil
+        hoverWindow = nil
+        marqueeStart = nil
     }
 
     private func restorePreviousApp() {
@@ -106,8 +151,206 @@ final class CaptureController: NSObject {
         previousApp = nil
     }
 
-    private func capture(_ rect: NSRect, excludingWindowIDs ids: [Int], roundedCorners: Bool = false) {
-        ScreenCapture.shared.capture(rect, excludingWindowIDs: ids, roundedCorners: roundedCorners) { [weak self] image in
+    private func renderOverlays() {
+        for overlay in overlays {
+            (overlay.contentView as? OverlayView)?.needsDisplay = true
+        }
+    }
+
+    // MARK: - Event tap
+
+    private func installEventTap() {
+        guard eventTap == nil else { return }
+        guard AXIsProcessTrusted() else {
+            CaptureController.log("tap: accessibility not granted — falling back to panel events")
+            PermissionManager.requestAccessibility()
+            return
+        }
+        let mask: CGEventMask = (1 << CGEventType.mouseMoved.rawValue)
+            | (1 << CGEventType.leftMouseDown.rawValue)
+            | (1 << CGEventType.leftMouseDragged.rawValue)
+            | (1 << CGEventType.leftMouseUp.rawValue)
+            | (1 << CGEventType.keyDown.rawValue)
+        guard let tap = CGEvent.tapCreate(
+            tap: .cghidEventTap,
+            place: .headInsertEventTap,
+            options: .defaultTap,
+            eventsOfInterest: CGEventMask(mask),
+            callback: Self.tapCallback,
+            userInfo: Unmanaged.passUnretained(self).toOpaque()
+        ) else {
+            CaptureController.log("tap: creation FAILED — falling back to panel events")
+            return
+        }
+        eventTap = tap
+        if let source = CFMachPortCreateRunLoopSource(nil, tap, 0) {
+            CFRunLoopAddSource(CFRunLoopGetMain(), source, .commonModes)
+        }
+        CGEvent.tapEnable(tap: tap, enable: true)
+        CaptureController.log("tap: installed")
+    }
+
+    private func removeEventTap() {
+        guard let tap = eventTap else { return }
+        CGEvent.tapEnable(tap: tap, enable: false)
+        if let source = CFMachPortCreateRunLoopSource(nil, tap, 0) {
+            CFRunLoopRemoveSource(CFRunLoopGetMain(), source, .commonModes)
+        }
+        CFMachPortInvalidate(tap)
+        eventTap = nil
+        CaptureController.log("tap: removed")
+    }
+
+    private static let tapCallback: CGEventTapCallBack = { _, type, event, refcon in
+        guard let refcon else { return Unmanaged.passUnretained(event) }
+        let controller = Unmanaged<CaptureController>.fromOpaque(refcon).takeUnretainedValue()
+        if let result = controller.handleTap(type, event) {
+            return Unmanaged.passUnretained(result)
+        }
+        return nil
+    }
+
+    /// Convert a CG global point (top-left origin) to AppKit global.
+    private func cgPointToAppKit(_ p: NSPoint) -> NSPoint {
+        guard let mainScreen = NSScreen.screens.first else { return p }
+        return NSPoint(x: p.x, y: mainScreen.frame.height - p.y)
+    }
+
+    /// Scan on-screen windows (AppKit global frames), front to back.
+    private func refreshTrackedWindows() {
+        guard let list = CGWindowListCopyWindowInfo(
+            [ .optionOnScreenOnly, .excludeDesktopElements ], kCGNullWindowID
+        ) as? [[String: Any]] else { trackedWindows = []; return }
+
+        let ownIDs = Set(overlayIDs)
+        var found: [(id: CGWindowID, frame: NSRect, pid: Int)] = []
+        for info in list {
+            guard let cid = info[kCGWindowNumber as String] as? CGWindowID,
+                  let bounds = info[kCGWindowBounds as String] as? [String: CGFloat],
+                  let layer = info[kCGWindowLayer as String] as? Int,
+                  let pid = info[kCGWindowOwnerPID as String] as? Int,
+                  layer == 0
+            else { continue }
+            if ownIDs.contains(Int(cid)) { continue }
+            let cgRect = NSRect(
+                x: bounds["X"] ?? 0,
+                y: bounds["Y"] ?? 0,
+                width: bounds["Width"] ?? 0,
+                height: bounds["Height"] ?? 0
+            )
+            guard cgRect.width >= 80, cgRect.height >= 60 else { continue }
+            let rect = Self.cgToAppKit(rect: cgRect)
+            found.append((id: cid, frame: rect, pid: pid))
+        }
+        trackedWindows = found
+    }
+
+    /// Convert a CGWindowList (top-left origin) frame into AppKit screen
+    /// coordinates (bottom-left origin).
+    private static func cgToAppKit(rect: NSRect) -> NSRect {
+        guard let mainScreen = NSScreen.screens.first else { return rect }
+        let y = mainScreen.frame.height - rect.origin.y - rect.height
+        return NSRect(x: rect.origin.x, y: y, width: rect.width, height: rect.height)
+    }
+
+    private func topmostWindowContaining(_ appKitPoint: NSPoint) -> (id: CGWindowID, frame: NSRect, pid: Int)? {
+        for entry in trackedWindows {
+            if entry.frame.contains(appKitPoint) {
+                return entry
+            }
+        }
+        return nil
+    }
+
+    /// Returns the event to pass through, or nil to consume it.
+    func handleTap(_ type: CGEventType, _ event: CGEvent) -> CGEvent? {
+        guard isSelecting else { return event }
+
+        switch type {
+        case .tapDisabledByUserInput, .tapDisabledByTimeout:
+            // A timed-out tap must be re-enabled; guard against a torn-down tap.
+            if let tap = eventTap {
+                CGEvent.tapEnable(tap: tap, enable: true)
+                CaptureController.log("tap: re-enabled after \(type)")
+            }
+            return event
+        case .keyDown:
+            if event.getIntegerValueField(.keyboardEventKeycode) == 53 {
+                CaptureController.log("tap: Esc — cancel")
+                cancelSelection()
+                return nil
+            }
+            return event
+        case .mouseMoved, .leftMouseDragged:
+            // Throttle window scans while moving
+            if Date().timeIntervalSince(lastWindowScan) > 0.15 {
+                lastWindowScan = Date()
+                refreshTrackedWindows()
+            }
+            let appKitPoint = cgPointToAppKit(NSPoint(x: event.location.x, y: event.location.y))
+            if type == .mouseMoved {
+                let window = topmostWindowContaining(appKitPoint)
+                if window?.frame != hoverFrame {
+                    hoverWindow = window
+                    if let w = window {
+                        CaptureController.log("hover: picked id=\(w.id) frame=\(w.frame) (tracked=\(trackedWindows.count))")
+                    } else {
+                        CaptureController.log("hover: none (tracked=\(trackedWindows.count))")
+                    }
+                    renderOverlays()
+                }
+                return event
+            }
+            // Drag: grow the marquee
+            guard let start = marqueeStart else { return nil }
+            let rect = NSRect(
+                x: min(start.x, appKitPoint.x),
+                y: min(start.y, appKitPoint.y),
+                width: abs(appKitPoint.x - start.x),
+                height: abs(appKitPoint.y - start.y)
+            )
+            marqueeRect = rect
+            hoverWindow = nil
+            renderOverlays()
+            return nil
+        case .leftMouseDown:
+            marqueeStart = cgPointToAppKit(NSPoint(x: event.location.x, y: event.location.y))
+            marqueeRect = nil
+            CaptureController.log("tap: mouseDown at \(marqueeStart.map { "\($0)" } ?? "?")")
+            return nil
+        case .leftMouseUp:
+            defer { marqueeStart = nil; marqueeRect = nil }
+            let appKitPoint = cgPointToAppKit(NSPoint(x: event.location.x, y: event.location.y))
+            let dragDistance = marqueeStart.map { hypot($0.x - appKitPoint.x, $0.y - appKitPoint.y) } ?? 0
+            if let rect = marqueeRect, dragDistance >= 4, rect.width >= 2, rect.height >= 2 {
+                CaptureController.log("tap: marquee complete \(rect)")
+                finishSelection(rect)
+            } else if let hover = hoverWindow {
+                // An overlapping window from the same app means this is an
+                // owned popup — desktopIndependentWindow would composite the
+                // parent too, so capture the screen crop instead.
+                // Owned popups composite their parent even when the windows
+                // don't overlap, so ANY other same-app window on screen means
+                // crop (correct region) instead of the group composite.
+                let ownedRisk = trackedWindows.contains {
+                    $0.id != hover.id && $0.pid == hover.pid
+                }
+                CaptureController.log("tap: window pick id=\(hover.id) pid=\(hover.pid) ownedRisk=\(ownedRisk) \(hover.frame)")
+                finishWindowPick(hover.id, hover.frame, ownedRisk: ownedRisk)
+            } else {
+                CaptureController.log("tap: click with no hover/marquee — cancel")
+                cancelSelection()
+            }
+            return nil
+        default:
+            return event
+        }
+    }
+
+    // MARK: - Capture
+
+    private func capture(_ rect: NSRect, excludingWindowIDs ids: [Int], roundedCorners: Bool = false, windowID: CGWindowID? = nil) {
+        ScreenCapture.shared.capture(rect, excludingWindowIDs: ids, roundedCorners: roundedCorners, windowID: windowID) { [weak self] image in
             DispatchQueue.main.async {
                 self?.isSelecting = false
                 self?.restorePreviousApp()
@@ -116,6 +359,7 @@ final class CaptureController: NSObject {
                         ResultWindow.shared.show(image: ResultWindow.failureImage("Capture failed. Check Screen Recording permission."))
                         return
                     }
+                    CaptureController.log("capture done: \(image.width)x\(image.height) — showing result window")
                     ResultWindow.shared.show(image: image)
                 }
             }
@@ -191,7 +435,7 @@ final class ScreenCapture {
         return content.displays.first(where: { $0.displayID == cgID }) ?? content.displays.first
     }
 
-    func capture(_ rect: NSRect, excludingWindowIDs excludedIDs: [Int], roundedCorners: Bool = false, completion: @escaping (CGImage?) -> Void) {
+    func capture(_ rect: NSRect, excludingWindowIDs excludedIDs: [Int], roundedCorners: Bool = false, windowID: CGWindowID? = nil, completion: @escaping (CGImage?) -> Void) {
         if #available(macOS 14.0, *) {
             Task {
                 guard let content = try? await SCShareableContent.current,
@@ -214,7 +458,7 @@ final class ScreenCapture {
                 let backingScale = screen.backingScaleFactor
                 config.width = Int(CGFloat(display.width) * backingScale)
                 config.height = Int(CGFloat(display.height) * backingScale)
-                config.showsCursor = true
+                config.showsCursor = false
 
                 // ScreenCaptureKit uses a different origin than AppKit for
                 // screens stacked around the main display: per-display,
@@ -226,10 +470,42 @@ final class ScreenCapture {
                     height: rect.height
                 )
 
+                // Window pick: capture the window DIRECTLY — the image comes
+                // with the app's real rounded-corner alpha (no mask guessing).
+                if let windowID,
+                   let scWindow = content.windows.first(where: { $0.windowID == windowID }) {
+                    var windowConfig = SCStreamConfiguration()
+                    windowConfig.width = Int(scWindow.frame.width * backingScale)
+                    windowConfig.height = Int(scWindow.frame.height * backingScale)
+                            windowConfig.showsCursor = false
+                    if let windowImage = try? await SCScreenshotManager.captureImage(
+                        contentFilter: SCContentFilter(desktopIndependentWindow: scWindow),
+                        configuration: windowConfig
+                    ) {
+                        let expectedW = CGFloat(scWindow.frame.width) * backingScale
+                        let expectedH = CGFloat(scWindow.frame.height) * backingScale
+                        let overflow = max(
+                            CGFloat(windowImage.width) / max(expectedW, 1),
+                            CGFloat(windowImage.height) / max(expectedH, 1)
+                        )
+                        if overflow > 1.35 {
+                            // SCKit composited extra windows (owned popups etc.)
+                            // — reject and use the screen crop instead.
+                            CaptureController.log("capture: WINDOW id=\(windowID) overflow=\(overflow) (\(windowImage.width)x\(windowImage.height) vs \(Int(expectedW))x\(Int(expectedH))) — rejecting, using crop+mask")
+                        } else {
+                            CaptureController.log("capture: WINDOW id=\(windowID) image=\(windowImage.width)x\(windowImage.height) (native alpha corners)")
+                            completion(windowImage)
+                            return
+                        }
+                    }
+                    CaptureController.log("capture: window filter failed for id=\(windowID) — falling back to crop+mask")
+                }
+
                 guard let image = try? await SCScreenshotManager.captureImage(contentFilter: filter, configuration: config) else {
                     completion(nil)
                     return
                 }
+                CaptureController.log("capture: rect=\(rect) screen=\(screen.frame) display=\(display.frame) backing=\(backingScale) image=\(image.width)x\(image.height) scRect=\(scRect)")
                 completion(self.crop(image, to: scRect, display: display, roundedCorners: roundedCorners))
             }
         } else {

Sources/Kapture/OverlayView.swift

@@ -1,17 +1,20 @@
 import AppKit
 
+/// Renders the capture overlay. All interaction state lives in
+/// CaptureController (driven by the CGEventTap); this view only draws.
 final class OverlayWindow: NSPanel {
-    init(screen: NSScreen, onComplete: @escaping (NSRect) -> Void, onCancel: @escaping () -> Void, onWindowPick: @escaping (NSRect) -> Void) {
-        let content = OverlayView(onComplete: onComplete, onCancel: onCancel, onWindowPick: onWindowPick)
+    init(screen: NSScreen, controller: CaptureController) {
+        let content = OverlayView()
         super.init(
             contentRect: screen.frame,
-            styleMask: [.borderless, .nonactivatingPanel],
+            styleMask: [.borderless],
             backing: .buffered,
             defer: false
         )
         contentView = content
+        content.controller = controller
         level = .screenSaver
-        collectionBehavior = [.canJoinAllSpaces, .fullScreenAuxiliary, .stationary, .transient]
+        collectionBehavior = [.canJoinAllSpaces, .fullScreenAuxiliary, .stationary]
         backgroundColor = .clear
         isOpaque = false
         hasShadow = false
@@ -23,29 +26,7 @@ final class OverlayWindow: NSPanel {
 }
 
 final class OverlayView: NSView {
-    private let onComplete: (NSRect) -> Void
-    private let onCancel: () -> Void
-    private let onWindowPick: (NSRect) -> Void
-
-    private var startPoint: NSPoint?
-    private(set) var selection: NSRect?
-    private var isDragging = false
-
-    // Window detection
-    private var trackedWindows: [(id: CGWindowID, frame: NSRect)] = []
-    private var hoveredWindowFrame: NSRect?
-    private var excludedIDs: [Int] = []
-
-    init(onComplete: @escaping (NSRect) -> Void, onCancel: @escaping () -> Void, onWindowPick: @escaping (NSRect) -> Void) {
-        self.onComplete = onComplete
-        self.onCancel = onCancel
-        self.onWindowPick = onWindowPick
-        super.init(frame: .zero)
-    }
-
-    required init?(coder: NSCoder) {
-        fatalError("init(coder:) has not been implemented")
-    }
+    weak var controller: CaptureController?
 
     override var acceptsFirstResponder: Bool { true }
 
@@ -55,167 +36,56 @@ final class OverlayView: NSView {
         addCursorRect(bounds, cursor: .crosshair)
     }
 
-    // MARK: - Window detection
-
-    /// Rebuild the list of capturable windows intersecting this screen.
-    /// Called lazily on mouse moves; cheap enough for interactive hover.
-    private func refreshTrackedWindows() {
-        guard let window = window else { return }
-        let screenFrame = window.convertToScreen(NSRect(origin: .zero, size: bounds.size))
-        // Exclude this overlay's own window (the other overlays don't intersect
-        // this screen, so the on-screen filter handles them).
-        let ownID = window.windowNumber
-
-        guard let list = CGWindowListCopyWindowInfo(
-            [ .optionOnScreenOnly, .excludeDesktopElements ], kCGNullWindowID
-        ) as? [[String: Any]] else { trackedWindows = []; return }
-
-        var found: [(CGWindowID, NSRect)] = []
-        for info in list {
-            guard let cid = info[kCGWindowNumber as String] as? CGWindowID,
-                  let bounds = info[kCGWindowBounds as String] as? [String: CGFloat],
-                  let layer = info[kCGWindowLayer as String] as? Int,
-                  layer == 0
-            else { continue }
-            // Skip our own overlays
-            if Int(cid) == ownID { continue }
-            let rect = NSRect(
-                x: bounds["X"] ?? 0,
-                y: bounds["Y"] ?? 0,
-                width: bounds["Width"] ?? 0,
-                height: bounds["Height"] ?? 0
-            )
-            guard rect.width >= 80, rect.height >= 60 else { continue }
-            // Skip tiny/utility windows
-            guard rect.width < screenFrame.width || rect.height < screenFrame.height else { continue }
-            // Only windows intersecting this screen
-            guard rect.intersects(screenFrame) else { continue }
-            found.append((cid, rect))
-        }
-        trackedWindows = found
+    /// The screen frame this overlay covers, in AppKit global space.
+    private var screenFrame: NSRect {
+        guard let window else { return .zero }
+        return window.convertToScreen(NSRect(origin: .zero, size: bounds.size))
     }
 
-    private func windowFrame(at point: NSPoint) -> NSRect? {
-        guard let window = window else { return nil }
-        // convertToScreen gives AppKit-global coordinates; convert tracked
-        // CG frames to the same space and pick the frontmost containing it.
-        let screenPoint = window.convertToScreen(NSRect(origin: point, size: .zero)).origin
-        for (_, frame) in trackedWindows {
-            if Self.cgToAppKit(rect: frame).contains(screenPoint) {
-                return frame
-            }
-        }
-        return nil
-    }
-
-    /// Convert a CGWindowList (top-left origin, CG global space) frame into
-    /// AppKit screen coordinates (bottom-left origin) for capture.
-    private static func cgToAppKit(rect: NSRect) -> NSRect {
-        guard let mainScreen = NSScreen.screens.first else { return rect }
-        let y = mainScreen.frame.height - rect.origin.y - rect.height
-        return NSRect(x: rect.origin.x, y: y, width: rect.width, height: rect.height)
-    }
-
-    // MARK: - Events
-
-    override func mouseMoved(with event: NSEvent) {
-        guard !isDragging else { return }
-        refreshTrackedWindows()
-        let p = convert(event.locationInWindow, from: nil)
-        let frame = windowFrame(at: p)
-        if frame != hoveredWindowFrame {
-            hoveredWindowFrame = frame
-            needsDisplay = true
-        }
-    }
-
-    override func mouseDown(with event: NSEvent) {
-        let p = convert(event.locationInWindow, from: nil)
-        startPoint = p
-        selection = NSRect(origin: p, size: .zero)
-        needsDisplay = true
-    }
-
-    override func mouseDragged(with event: NSEvent) {
-        guard let start = startPoint else { return }
-        isDragging = true
-        hoveredWindowFrame = nil
-        let p = convert(event.locationInWindow, from: nil)
-        selection = NSRect(
-            x: min(start.x, p.x),
-            y: min(start.y, p.y),
-            width: abs(p.x - start.x),
-            height: abs(p.y - start.y)
+    /// Convert an AppKit-global rect into this view's coordinates.
+    private func viewRect(_ global: NSRect) -> NSRect {
+        let sf = screenFrame
+        return NSRect(
+            x: global.origin.x - sf.origin.x,
+            y: global.origin.y - sf.origin.y,
+            width: global.width,
+            height: global.height
         )
-        needsDisplay = true
-    }
-
-    override func mouseUp(with event: NSEvent) {
-        if isDragging {
-            guard let sel = selection else { return }
-            if sel.width >= 2, sel.height >= 2 {
-                onComplete(window!.convertToScreen(sel))
-            } else {
-                onCancel()
-            }
-            return
-        }
-
-        // No drag: it was a click. If a window is hovered, capture it with
-        // rounded corners; otherwise treat as an empty marquee (cancel).
-        if let frame = hoveredWindowFrame {
-            onWindowPick(Self.cgToAppKit(rect: frame))
-        } else {
-            onCancel()
-        }
-    }
-
-    override func keyDown(with event: NSEvent) {
-        if event.keyCode == 53 {
-            onCancel()
-        } else {
-            super.keyDown(with: event)
-        }
     }
 
     override func draw(_ dirtyRect: NSRect) {
         NSColor.black.withAlphaComponent(0.35).setFill()
         NSBezierPath(rect: bounds).fill()
 
-        // Highlight the hovered window (rounded, like the real window corners)
-        if let frame = hoveredWindowFrame {
-            // Convert the CG frame to AppKit-global, then to this view's space.
-            guard let window = window else { return }
-            let screenFrame = window.convertToScreen(NSRect(origin: .zero, size: bounds.size))
-            let appKitFrame = Self.cgToAppKit(rect: frame)
-            let viewFrame = NSRect(
-                x: appKitFrame.origin.x - screenFrame.origin.x,
-                y: appKitFrame.origin.y - screenFrame.origin.y,
-                width: frame.width,
-                height: frame.height
-            )
+        guard let controller else { return }
+
+        // Highlight the hovered window (rounded, like real window corners)
+        if let frame = controller.hoverFrame {
+            let vf = viewRect(frame)
             NSGraphicsContext.current?.saveGraphicsState()
             NSGraphicsContext.current?.compositingOperation = .clear
             NSColor.black.setFill()
-            NSBezierPath(roundedRect: viewFrame, xRadius: 10, yRadius: 10).fill()
+            NSBezierPath(roundedRect: vf, xRadius: 10, yRadius: 10).fill()
             NSGraphicsContext.current?.restoreGraphicsState()
 
-            let border = NSBezierPath(roundedRect: viewFrame, xRadius: 10, yRadius: 10)
+            let border = NSBezierPath(roundedRect: vf, xRadius: 10, yRadius: 10)
             border.lineWidth = 2
             NSColor.controlAccentColor.setStroke()
             border.stroke()
             return
         }
 
-        guard let sel = selection, sel.width > 0, sel.height > 0 else { return }
+        // Marquee selection
+        guard let sel = controller.marqueeRect, sel.width > 0, sel.height > 0 else { return }
+        let vf = viewRect(sel)
 
         NSGraphicsContext.current?.saveGraphicsState()
         NSGraphicsContext.current?.compositingOperation = .clear
         NSColor.black.setFill()
-        NSBezierPath(rect: sel).fill()
+        NSBezierPath(rect: vf).fill()
         NSGraphicsContext.current?.restoreGraphicsState()
 
-        let border = NSBezierPath(rect: sel)
+        let border = NSBezierPath(rect: vf)
         border.lineWidth = 1.5
         NSColor.controlAccentColor.setStroke()
         border.stroke()
@@ -227,8 +97,8 @@ final class OverlayView: NSView {
         ]
         let labelSize = label.size(withAttributes: attrs)
         let labelRect = NSRect(
-            x: sel.maxX - labelSize.width - 8,
-            y: sel.minY - labelSize.height - 10,
+            x: vf.maxX - labelSize.width - 8,
+            y: vf.minY - labelSize.height - 10,
             width: labelSize.width + 8,
             height: labelSize.height + 6
         )

Sources/Kapture/ResultWindow.swift

@@ -95,14 +95,18 @@ final class CaptureModel: ObservableObject {
     /// Redo stack of removed strokes
     @Published var redoStack: [Stroke] = []
     /// Whether the pen is active (drag draws instead of selecting)
-    @Published var isDrawing = false
-    /// Whether drawing redacts (black bar) instead of pen strokes
-    @Published var isRedacting = false
+    @Published var tool: Tool = .select
     /// Current drawing color
     @Published var drawColor: NSColor = .systemRed
     /// Stroke thickness in points (image space)
     @Published var strokeWidth: CGFloat = 3.0
 
+    enum Tool {
+        case select
+        case draw
+        case redact
+    }
+
     struct Stroke {
         let points: [CGPoint]
         let width: CGFloat
@@ -193,7 +197,7 @@ final class CaptureModel: ObservableObject {
 
     func addStroke(_ points: [CGPoint]) {
         guard points.count > 1 else { return }
-        if isRedacting {
+        if tool == .redact {
             // Redaction: a filled black bar from start to end, as thick as the
             // current stroke width (drawn as a rect for clean edges).
             strokes.append(Stroke(points: points, width: max(strokeWidth, 12), color: .black, isRedaction: true))
@@ -333,14 +337,24 @@ struct ResultView: View {
                 Divider().frame(height: 18)
 
                 Button {
-                    model.isDrawing.toggle()
-                    if model.isDrawing { model.selection = nil }
+                    model.tool = model.tool == .draw ? .select : .draw
+                    if model.tool != .select { model.selection = nil }
                 } label: {
-                    Label("Draw", systemImage: model.isDrawing ? "pencil.tip.crop.circle.fill" : "pencil.tip.crop.circle")
+                    Label("Draw", systemImage: model.tool == .draw ? "pencil.tip.crop.circle.fill" : "pencil.tip.crop.circle")
                 }
                 .buttonStyle(.bordered)
-                .foregroundStyle(model.isDrawing ? .primary : .secondary)
-                .help("Toggle drawing on the screenshot")
+                .foregroundStyle(model.tool == .draw ? .primary : .secondary)
+                .help("Draw on the screenshot")
+
+                Button {
+                    model.tool = model.tool == .redact ? .select : .redact
+                    if model.tool != .select { model.selection = nil }
+                } label: {
+                    Label("Redact", systemImage: model.tool == .redact ? "rectangle.fill.on.rectangle.fill" : "rectangle.dashed")
+                }
+                .buttonStyle(.bordered)
+                .foregroundStyle(model.tool == .redact ? .primary : .secondary)
+                .help("Cover sensitive areas with black bars")
 
                 Button {
                     model.copyImage()
@@ -372,20 +386,16 @@ struct ResultView: View {
 
             Divider()
 
-            // Draw toolbar (only when drawing)
-            if model.isDrawing {
+            // Tool toolbar (only when a draw tool is active)
+            if model.tool != .select {
                 HStack(spacing: 14) {
-                    Picker("", selection: $model.isRedacting) {
-                        Label("Pen", systemImage: "pencil.tip").tag(false)
-                        Label("Redact", systemImage: "rectangle.fill").tag(true)
-                    }
-                    .pickerStyle(.segmented)
-                    .fixedSize()
-                    .help("Pen draws strokes; Redact covers text with a black bar")
+                    Label(model.tool == .redact ? "Redact" : "Draw", systemImage: model.tool == .redact ? "rectangle.fill" : "pencil.tip")
+                        .font(.caption)
+                        .foregroundStyle(.secondary)
 
                     Divider().frame(height: 18)
 
-                    if !model.isRedacting {
+                    if model.tool == .draw {
                         HStack(spacing: 6) {
                             Image(systemName: "circle.fill").font(.system(size: 4))
                             Image(systemName: "circle.fill").font(.system(size: 7))
@@ -405,6 +415,10 @@ struct ResultView: View {
                         .labelsHidden()
                         .frame(width: 28)
                         .help("Drawing color")
+                    } else {
+                        Label("Drag to cover sensitive text", systemImage: "eye.slash")
+                            .font(.caption)
+                            .foregroundStyle(.secondary)
                     }
 
                     Spacer()
@@ -582,7 +596,7 @@ struct ScreenshotPane: View {
                     .allowsHitTesting(false)
                 }
 
-                if !model.isDrawing, let sel = model.selection {
+                if model.tool == .select, let sel = model.selection {
                     let viewRect = CGRect(
                         x: origin.x + sel.minX * scale,
                         y: origin.y + sel.minY * scale,
@@ -601,7 +615,7 @@ struct ScreenshotPane: View {
             .gesture(
                 DragGesture(minimumDistance: 0)
                     .onChanged { value in
-                        if model.isDrawing {
+                        if model.tool != .select {
                             let p = toImagePoint(value.location, scale: scale, origin: origin)
                             let imgRect = CGRect(origin: .zero, size: imageSize)
                             if imgRect.contains(p) {
@@ -620,7 +634,7 @@ struct ScreenshotPane: View {
                         }
                     }
                     .onEnded { _ in
-                        if model.isDrawing {
+                        if model.tool != .select {
                             if currentStroke.count > 1 {
                                 model.addStroke(currentStroke)
                             }

build-app.sh

@@ -108,9 +108,9 @@ cat > "$APP/Contents/Info.plist" <<'PLIST'
     <key>CFBundleIconFile</key>
     <string>Icon</string>
     <key>CFBundleShortVersionString</key>
-    <string>1.5.1</string>
+    <string>1.8.3</string>
     <key>CFBundleVersion</key>
-    <string>51</string>
+    <string>83</string>
     <key>LSUIElement</key>
     <true/>
     <key>NSHighResolutionCapable</key>