Make Kapture screenshot-first with marquee text selection

The result window now works like a screenshot tool: drag on the image to
select a region, then click Get Selection Text to OCR only that area
(full-image OCR stays as Get All Text). Selection is rendered in image
coordinates so it stays accurate at any window size.

💘 Generated with Crush

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

Sources/Kapture/App.swift

@@ -48,6 +48,13 @@ struct MenuView: View {
 
         Divider()
 
+        Button("Copy Diagnostics") {
+            let diag = CaptureController.shared.diagnostics()
+            let pasteboard = NSPasteboard.general
+            pasteboard.clearContents()
+            pasteboard.setString(diag, forType: .string)
+        }
+
         Button(LoginItem.isEnabled ? "Disable Launch at Login" : "Launch at Login") {
             if !LoginItem.toggle() {
                 let alert = NSAlert()

Sources/Kapture/CaptureController.swift

@@ -10,6 +10,38 @@ final class CaptureController: NSObject {
     private var previousApp: NSRunningApplication?
     private var overlayIDs: [Int] = []
 
+    /// Diagnostic snapshot for "Copy Diagnostics" menu item.
+    func diagnostics() -> String {
+        var lines: [String] = []
+        lines.append("Kapture diagnostics")
+        for (i, s) in NSScreen.screens.enumerated() {
+            let scale = s.backingScaleFactor
+            let cgID = (s.deviceDescription[NSDeviceDescriptionKey("NSScreenNumber")] as? NSNumber)?.uint32Value ?? 0
+            lines.append("screen[\(i)]: frame=\(s.frame) scale=\(scale) backingSize=\(s.frame.width*scale)x\(s.frame.height*scale) cgID=\(cgID)")
+        }
+        if #available(macOS 14.0, *) {
+            Task {
+                if let content = try? await SCShareableContent.current {
+                    for (i, d) in content.displays.enumerated() {
+                        lines.append("SCDisplay[\(i)]: frame=\(d.frame) width=\(d.width)x\(d.height) id=\(d.displayID)")
+                    }
+                } else {
+                    lines.append("SCShareableContent: unavailable (no Screen Recording permission?)")
+                }
+                let text = lines.joined(separator: "\n")
+                let pb = NSPasteboard.general
+                pb.clearContents()
+                pb.setString(text, forType: .string)
+            }
+        } else {
+            let text = lines.joined(separator: "\n")
+            let pb = NSPasteboard.general
+            pb.clearContents()
+            pb.setString(text, forType: .string)
+        }
+        return lines.joined(separator: "\n")
+    }
+
     func begin() {
         guard !isSelecting else { return }
         guard PermissionManager.isGranted else {
@@ -85,19 +117,13 @@ final class ScreenCapture {
     private init() {}
 
     @available(macOS 14.0, *)
-    private func crop(_ image: CGImage, to rect: NSRect, display: SCDisplay) -> CGImage? {
-        // The captured image may be at any scale (retina 2x, secondary display
-        // 1x, or trimmed by ScreenCaptureKit). Derive the pixel scale from the
-        // image we actually got, relative to the display's point frame.
+    private func crop(_ image: CGImage, to cgRect: CGRect, display: SCDisplay) -> CGImage? {
+        // cgRect is already in SCDisplay space (Y flipped relative to AppKit).
+        // Derive the pixel scale from the image we actually got, relative to
+        // the display's point frame.
         let scaleX = CGFloat(image.width) / display.frame.width
         let scaleY = CGFloat(image.height) / display.frame.height
         guard scaleX > 0, scaleY > 0 else { return nil }
-        let cgRect = CGRect(
-            x: rect.minX,
-            y: rect.minY,
-            width: rect.width,
-            height: rect.height
-        )
         let pxRect = CGRect(
             x: (cgRect.minX - display.frame.minX) * scaleX,
             y: (cgRect.minY - display.frame.minY) * scaleY,
@@ -141,17 +167,34 @@ final class ScreenCapture {
                 let excluded = content.windows.filter { excludedSet.contains($0.windowID) }
                 let filter = SCContentFilter(display: display, excludingWindows: excluded)
                 let config = SCStreamConfiguration()
-                // display.width/height are pixels; request the display's full
-                // native resolution so ScreenCaptureKit gives us every pixel.
-                config.width = Int(display.width)
-                config.height = Int(display.height)
+                // SCDisplay.width/height are in POINTS; SCStreamConfiguration
+                // width/height are output PIXELS. Multiply by the backing scale
+                // of the screen containing the selection so retina displays are
+                // captured at full resolution and 1x displays stay 1x.
+                guard let screen = NSScreen.screens.first(where: { $0.frame.contains(NSPoint(x: rect.midX, y: rect.midY)) }) else {
+                    completion(nil)
+                    return
+                }
+                let backingScale = screen.backingScaleFactor
+                config.width = Int(CGFloat(display.width) * backingScale)
+                config.height = Int(CGFloat(display.height) * backingScale)
                 config.showsCursor = true
 
+                // ScreenCaptureKit uses a different origin than AppKit for
+                // screens stacked around the main display: per-display,
+                // SCDisplay y = appKitY - NSScreen.maxY + SCDisplay.maxY.
+                let scRect = CGRect(
+                    x: rect.minX,
+                    y: rect.minY - screen.frame.maxY + display.frame.maxY,
+                    width: rect.width,
+                    height: rect.height
+                )
+
                 guard let image = try? await SCScreenshotManager.captureImage(contentFilter: filter, configuration: config) else {
                     completion(nil)
                     return
                 }
-                completion(self.crop(image, to: rect, display: display))
+                completion(self.crop(image, to: scRect, display: display))
             }
         } else {
             guard let primary = NSScreen.screens.first(where: { $0.frame.origin == .zero }) ?? NSScreen.screens.first else {

Sources/Kapture/ResultWindow.swift

@@ -88,6 +88,8 @@ final class CaptureModel: ObservableObject {
     @Published var extractedText: String?
     @Published var isOCRRunning = false
     @Published var statusMessage: String?
+    /// Drag selection rect in IMAGE point space (nil = none)
+    @Published var selection: CGRect?
 
     enum CaptureMode {
         case screenshot
@@ -98,24 +100,43 @@ final class CaptureModel: ObservableObject {
         self.image = image
     }
 
+    var hasSelection: Bool { selection != nil && selection!.width >= 2 && selection!.height >= 2 }
+
     var displayText: String {
         if isOCRRunning {
             return "Recognizing text…"
         }
-        return extractedText ?? "Text appears here — click “Get Text”."
+        return extractedText ?? "Select text in the screenshot, then click “Get Text”."
     }
 
-    func runOCR() {
+    func cropImage(to rectInImage: CGRect) -> CGImage? {
+        return image.cropping(to: rectInImage)
+    }
+
+    func runOCR(over selectionOnly: CGRect? = nil) {
         guard !isOCRRunning else { return }
         isOCRRunning = true
         statusMessage = nil
-        OCRService.shared.recognize(image) { [weak self] text in
+
+        let targetImage: CGImage
+        if let sel = selectionOnly {
+            guard let cropped = image.cropping(to: sel) else {
+                self.isOCRRunning = false
+                self.statusMessage = "Selection too small."
+                return
+            }
+            targetImage = cropped
+        } else {
+            targetImage = image
+        }
+
+        OCRService.shared.recognize(targetImage) { [weak self] text in
             Task { @MainActor in
                 guard let self else { return }
                 self.isOCRRunning = false
                 self.mode = .text
                 if text.isEmpty {
-                    self.extractedText = "No text found in the screenshot."
+                    self.extractedText = "No text found in the selection."
                 } else {
                     self.extractedText = text
                     let pasteboard = NSPasteboard.general
@@ -127,6 +148,11 @@ final class CaptureModel: ObservableObject {
         }
     }
 
+    func runOCRSelection() {
+        guard let sel = selection, hasSelection else { return }
+        runOCR(over: sel)
+    }
+
     func copyText() {
         guard let text = extractedText else { return }
         let pasteboard = NSPasteboard.general
@@ -185,22 +211,21 @@ struct ResultView: View {
                 Spacer()
                 Button("Copy Image") { model.copyImage() }
                 Button("Save PNG…") { model.savePNG() }
-                Button("Get Text") { model.runOCR() }
-                    .disabled(model.isOCRRunning || model.extractedText != nil)
+                if model.hasSelection {
+                    Button("Get Selection Text") { model.runOCRSelection() }
+                        .disabled(model.isOCRRunning)
+                        .help("Recognize text inside the selected region")
+                }
+                Button("Get All Text") { model.runOCR() }
+                    .disabled(model.isOCRRunning)
+                    .help("Recognize all text in the screenshot")
                 Button("Close") { onClose() }
             }
             .padding(.horizontal, 12)
             .padding(.top, 10)
 
             if model.mode == .screenshot {
-                GeometryReader { geo in
-                    let imageWidth = CGFloat(model.image.width)
-                    Image(nsImage: NSImage(cgImage: model.image, size: .zero))
-                        .resizable()
-                        // Downscale with smoothing (AA); upscale keeps pixels crisp.
-                        .interpolation(imageWidth >= geo.size.width ? .high : .none)
-                        .aspectRatio(contentMode: .fit)
-                }
+                ScreenshotPane(model: model)
                     .border(Color.secondary.opacity(0.4))
                     .padding(.horizontal, 12)
             } else {
@@ -241,3 +266,83 @@ struct ResultView: View {
         .frame(minWidth: 480, minHeight: 380)
     }
 }
+
+struct ScreenshotPane: View {
+    @ObservedObject var model: CaptureModel
+
+    private var imageSize: CGSize {
+        CGSize(width: model.image.width, height: model.image.height)
+    }
+
+    private func geometry(for geo: GeometryProxy) -> (scale: CGFloat, drawSize: CGSize, origin: CGPoint) {
+        let size = imageSize
+        let scale = min(geo.size.width / size.width, geo.size.height / size.height)
+        let drawSize = CGSize(width: size.width * scale, height: size.height * scale)
+        let origin = CGPoint(
+            x: (geo.size.width - drawSize.width) / 2,
+            y: (geo.size.height - drawSize.height) / 2
+        )
+        return (scale, drawSize, origin)
+    }
+
+    private func toImagePoint(_ viewPoint: CGPoint, scale: CGFloat, origin: CGPoint) -> CGPoint {
+        CGPoint(
+            x: (viewPoint.x - origin.x) / scale,
+            y: (viewPoint.y - origin.y) / scale
+        )
+    }
+
+    private func clampSelection(_ rect: CGRect) -> CGRect {
+        rect.intersection(CGRect(origin: .zero, size: imageSize))
+    }
+
+    var body: some View {
+        GeometryReader { geo in
+            let (scale, drawSize, origin) = geometry(for: geo)
+
+            ZStack {
+                Image(nsImage: NSImage(cgImage: model.image, size: .zero))
+                    .resizable()
+                    .interpolation(imageSize.width >= geo.size.width ? .high : .none)
+                    .aspectRatio(contentMode: .fit)
+                    .frame(width: drawSize.width, height: drawSize.height)
+                    .position(x: origin.x + drawSize.width / 2, y: origin.y + drawSize.height / 2)
+
+                if let sel = model.selection {
+                    let viewRect = CGRect(
+                        x: origin.x + sel.minX * scale,
+                        y: origin.y + sel.minY * scale,
+                        width: sel.width * scale,
+                        height: sel.height * scale
+                    )
+                    Rectangle()
+                        .fill(Color.accentColor.opacity(0.15))
+                        .border(Color.accentColor, width: 1.5)
+                        .frame(width: viewRect.width, height: viewRect.height)
+                        .position(x: viewRect.midX, y: viewRect.midY)
+                        .allowsHitTesting(false)
+                }
+            }
+            .contentShape(Rectangle())
+            .gesture(
+                DragGesture(minimumDistance: 0)
+                    .onChanged { value in
+                        let start = toImagePoint(value.startLocation, scale: scale, origin: origin)
+                        let current = toImagePoint(value.location, scale: scale, origin: origin)
+                        let rect = CGRect(
+                            x: min(start.x, current.x),
+                            y: min(start.y, current.y),
+                            width: abs(current.x - start.x),
+                            height: abs(current.y - start.y)
+                        )
+                        model.selection = clampSelection(rect)
+                    }
+                    .onEnded { _ in
+                        if let s = model.selection, (s.width < 2 || s.height < 2) {
+                            model.selection = nil
+                        }
+                    }
+            )
+        }
+    }
+}

build-app.sh

@@ -108,9 +108,9 @@ cat > "$APP/Contents/Info.plist" <<'PLIST'
     <key>CFBundleIconFile</key>
     <string>Icon</string>
     <key>CFBundleShortVersionString</key>
-    <string>1.1.4</string>
+    <string>1.2.0</string>
     <key>CFBundleVersion</key>
-    <string>14</string>
+    <string>20</string>
     <key>LSUIElement</key>
     <true/>
     <key>NSHighResolutionCapable</key>