Fix multi-display window detection and click-to-capture; separate Redact tool

Window frames are now converted to AppKit space once at detection time, so
hover highlighting and picking work on every display. A click is only
treated as a drag after 4pt of movement, so clicking a detected window
captures it instead of passing a stray marquee. Redact is now a standalone
tool (Select/Draw/Redact) with its own toolbar hints instead of a toggle
inside the draw bar.

💘 Generated with Crush

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

README.md

@@ -25,11 +25,14 @@ No network calls, no API keys — everything runs locally.
 ## Install with Homebrew
 
 ```bash
-brew tap TZGyn/tap
+brew tap TZGyn/tap https://gitea.tzgyn.dev/TZGyn/homebrew-tap.git
-brew trust TZGyn/tap          # Homebrew 6+ requires trusting third-party taps
+brew trust TZGyn/tap
 brew install --cask kapture
 ```
 
+The tap is hosted on Gitea, so the full URL is required. Homebrew may print
+an "Unsupported tap" warning — it's harmless.
+
 Releases are published as zips on GitHub Releases; `release.sh` packages a
 new one (`./release.sh 1.0.1 && git tag v1.0.1 && git push origin v1.0.1`).
 The cask lives in the [TZGyn/homebrew-tap](https://github.com/TZGyn/homebrew-tap)

Sources/Kapture/OverlayView.swift

@@ -30,11 +30,11 @@ final class OverlayView: NSView {
     private var startPoint: NSPoint?
     private(set) var selection: NSRect?
     private var isDragging = false
+    private var dragDistance: CGFloat = 0
 
-    // Window detection
+    // Window detection (frames stored in AppKit global space)
     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
@@ -79,14 +79,17 @@ final class OverlayView: NSView {
             else { continue }
             // Skip our own overlays
             if Int(cid) == ownID { continue }
-            let rect = NSRect(
+            let cgRect = 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 }
+            guard cgRect.width >= 80, cgRect.height >= 60 else { continue }
-            // Skip tiny/utility windows
+            // Convert to AppKit space FIRST — CG and AppKit Y axes disagree on
+            // multi-desktop layouts, so intersect tests must use one space.
+            let rect = Self.cgToAppKit(rect: cgRect)
+            // Skip windows filling the whole screen (fullscreen apps)
             guard rect.width < screenFrame.width || rect.height < screenFrame.height else { continue }
             // Only windows intersecting this screen
             guard rect.intersects(screenFrame) else { continue }
@@ -97,24 +100,19 @@ final class OverlayView: NSView {
 
     private func windowFrame(at point: NSPoint) -> NSRect? {
         guard let window = window else { return nil }
-        let screenPoint = window.convertToScreen(NSRect(origin: point, size: .zero))
+        // convertToScreen gives AppKit-global coordinates; tracked frames are
-        // CGWindowList bounds use a TOP-LEFT origin; convert the cursor point.
+        // already in that space.
-        guard let mainScreen = NSScreen.screens.first else { return nil }
+        let screenPoint = window.convertToScreen(NSRect(origin: point, size: .zero)).origin
-        let topLeftPoint = NSPoint(
-            x: screenPoint.origin.x,
-            y: mainScreen.frame.height - screenPoint.origin.y
-        )
-        // Pick the frontmost (list order) window containing the point
         for (_, frame) in trackedWindows {
-            if frame.contains(topLeftPoint) {
+            if frame.contains(screenPoint) {
                 return frame
             }
         }
         return nil
     }
 
-    /// Convert a CGWindowList (top-left origin) frame into AppKit screen
+    /// Convert a CGWindowList (top-left origin, CG global space) frame into
-    /// coordinates (bottom-left origin) for capture.
+    /// 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
@@ -137,15 +135,20 @@ final class OverlayView: NSView {
     override func mouseDown(with event: NSEvent) {
         let p = convert(event.locationInWindow, from: nil)
         startPoint = p
+        dragDistance = 0
         selection = NSRect(origin: p, size: .zero)
         needsDisplay = true
     }
 
     override func mouseDragged(with event: NSEvent) {
         guard let start = startPoint else { return }
+        let p = convert(event.locationInWindow, from: nil)
+        dragDistance = hypot(p.x - start.x, p.y - start.y)
+        // Only become a marquee after real movement; micro-jitter from a
+        // click must not cancel window-pick mode.
+        guard dragDistance >= 4 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),
@@ -156,6 +159,10 @@ final class OverlayView: NSView {
     }
 
     override func mouseUp(with event: NSEvent) {
+        defer {
+            isDragging = false
+            dragDistance = 0
+        }
         if isDragging {
             guard let sel = selection else { return }
             if sel.width >= 2, sel.height >= 2 {
@@ -166,10 +173,10 @@ final class OverlayView: NSView {
             return
         }
 
-        // No drag: it was a click. If a window is hovered, capture it with
+        // It was a click. If a window is hovered, capture it with rounded
-        // rounded corners; otherwise treat as an empty marquee (cancel).
+        // corners; otherwise treat as an empty marquee (cancel).
         if let frame = hoveredWindowFrame {
-            onWindowPick(Self.cgToAppKit(rect: frame))
+            onWindowPick(frame)
         } else {
             onCancel()
         }
@@ -189,12 +196,12 @@ final class OverlayView: NSView {
 
         // Highlight the hovered window (rounded, like the real window corners)
         if let frame = hoveredWindowFrame {
-            // Convert CGWindowList (top-left) frame to view (bottom-left) space
+            // Tracked frames are AppKit-global; view space = global - window origin.
-            guard let window = window, let mainScreen = NSScreen.screens.first else { return }
+            guard let window = window else { return }
             let screenFrame = window.convertToScreen(NSRect(origin: .zero, size: bounds.size))
             let viewFrame = NSRect(
                 x: frame.origin.x - screenFrame.origin.x,
-                y: mainScreen.frame.height - frame.origin.y - frame.height - screenFrame.origin.y,
+                y: frame.origin.y - screenFrame.origin.y,
                 width: frame.width,
                 height: frame.height
             )

Sources/Kapture/ResultWindow.swift

@@ -95,16 +95,23 @@ 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
+    @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
         let color: NSColor
+        var isRedaction: Bool = false
     }
 
     enum CaptureMode {
@@ -159,6 +166,20 @@ final class CaptureModel: ObservableObject {
         ctx.setLineJoin(.round)
         for stroke in strokes {
             guard stroke.points.count > 1 else { continue }
+            if stroke.isRedaction {
+                // Redaction bar: filled black rect covering the stroke bounds,
+                // padded so it fully covers text.
+                let xs = stroke.points.map { $0.x }
+                let ys = stroke.points.map { $0.y }
+                let bar = NSRect(
+                    x: xs.min()! - 2,
+                    y: ys.min()! - 2,
+                    width: (xs.max()! - xs.min()!) + 4,
+                    height: max(stroke.width, ys.max()! - ys.min()!) + 4
+                )
+                NSColor.black.setFill()
+                NSBezierPath(rect: bar).fill()
+            } else {
                 stroke.color.setStroke()
                 ctx.setLineWidth(stroke.width)
                 ctx.beginPath()
@@ -168,6 +189,7 @@ final class CaptureModel: ObservableObject {
                 }
                 ctx.strokePath()
             }
+        }
         ctx.restoreGState()
         NSGraphicsContext.restoreGraphicsState()
         return rep.cgImage ?? image
@@ -175,7 +197,13 @@ final class CaptureModel: ObservableObject {
 
     func addStroke(_ points: [CGPoint]) {
         guard points.count > 1 else { return }
+        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))
+        } else {
             strokes.append(Stroke(points: points, width: strokeWidth, color: drawColor))
+        }
         redoStack = []
     }
 
@@ -309,14 +337,24 @@ struct ResultView: View {
                 Divider().frame(height: 18)
 
                 Button {
-                    model.isDrawing.toggle()
+                    model.tool = model.tool == .draw ? .select : .draw
-                    if model.isDrawing { model.selection = nil }
+                    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)
+                .foregroundStyle(model.tool == .draw ? .primary : .secondary)
-                .help("Toggle drawing on the screenshot")
+                .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()
@@ -348,15 +386,16 @@ struct ResultView: View {
 
             Divider()
 
-            // Draw toolbar (only when drawing)
+            // Tool toolbar (only when a draw tool is active)
-            if model.isDrawing {
+            if model.tool != .select {
                 HStack(spacing: 14) {
-                    Label("Draw", systemImage: "pencil.tip")
+                    Label(model.tool == .redact ? "Redact" : "Draw", systemImage: model.tool == .redact ? "rectangle.fill" : "pencil.tip")
                         .font(.caption)
                         .foregroundStyle(.secondary)
 
                     Divider().frame(height: 18)
 
+                    if model.tool == .draw {
                         HStack(spacing: 6) {
                             Image(systemName: "circle.fill").font(.system(size: 4))
                             Image(systemName: "circle.fill").font(.system(size: 7))
@@ -376,6 +415,11 @@ 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()
 
@@ -515,6 +559,17 @@ struct ScreenshotPane: View {
                 Canvas { context, _ in
                     for stroke in model.strokes {
                         guard stroke.points.count > 1 else { continue }
+                        if stroke.isRedaction {
+                            let xs = stroke.points.map { $0.x }
+                            let ys = stroke.points.map { $0.y }
+                            let bar = CGRect(
+                                x: origin.x + (xs.min()! - 2) * scale,
+                                y: origin.y + (ys.min()! - 2) * scale,
+                                width: ((xs.max()! - xs.min()!) + 4) * scale,
+                                height: (max(stroke.width, ys.max()! - ys.min()!) + 4) * scale
+                            )
+                            context.fill(Path(bar), with: .color(.black))
+                        } else {
                             var path = Path()
                             path.move(to: CGPoint(x: origin.x + stroke.points[0].x * scale, y: origin.y + stroke.points[0].y * scale))
                             for point in stroke.points.dropFirst() {
@@ -523,6 +578,7 @@ struct ScreenshotPane: View {
                             context.stroke(path, with: .color(Color(nsColor: stroke.color)), lineWidth: stroke.width)
                         }
                     }
+                }
                 .allowsHitTesting(false)
 
                 // In-progress stroke
@@ -540,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,
@@ -559,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) {
@@ -578,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.0</string>
+    <string>1.6.0</string>
     <key>CFBundleVersion</key>
-    <string>50</string>
+    <string>60</string>
     <key>LSUIElement</key>
     <true/>
     <key>NSHighResolutionCapable</key>