Fix flipped drawing when copying/saving annotated images

The strokes were stored in top-left image coordinates but drawn into an
AppKit CGContext with a bottom-left origin, so exports came out mirrored
and offset. Flip Y in the context before stroking so annotations land
where they were drawn.

💘 Generated with Crush

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

Sources/Kapture/CaptureController.swift

@@ -118,15 +118,18 @@ final class ScreenCapture {
 
     @available(macOS 14.0, *)
     private func crop(_ image: CGImage, to cgRect: CGRect, display: SCDisplay) -> CGImage? {
-        // cgRect is already in SCDisplay space (Y flipped relative to AppKit).
+        // cgRect is in SCDisplay space (bottom-left origin, Y flipped vs AppKit).
-        // Derive the pixel scale from the image we actually got, relative to
+        // The captured image has a TOP-LEFT origin. So within the display,
-        // the display's point frame.
+        // we must flip Y: pixelY = displayHeight - (cgY - displayMinY) - cgHeight.
         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 localMinX = cgRect.minX - display.frame.minX
+        let localMaxY = cgRect.maxY - display.frame.minY
+        let flippedY = display.frame.height - localMaxY
         let pxRect = CGRect(
-            x: (cgRect.minX - display.frame.minX) * scaleX,
+            x: localMinX * scaleX,
-            y: (cgRect.minY - display.frame.minY) * scaleY,
+            y: flippedY * scaleY,
             width: cgRect.width * scaleX,
             height: cgRect.height * scaleY
         )
@@ -134,15 +137,11 @@ final class ScreenCapture {
         // display's frame (e.g. secondary monitor coordinate quirks).
         let safeRect = pxRect.intersection(CGRect(x: 0, y: 0, width: CGFloat(image.width), height: CGFloat(image.height)))
         guard safeRect.width >= 1, safeRect.height >= 1 else { return nil }
-        guard let cropCtx = CGContext(
+        // Use a pixel-exact subimage crop instead of redrawing through a
-            data: nil, width: Int(safeRect.width), height: Int(safeRect.height),
+        // CGContext, which resamples and loses quality on retina captures.
-            bitsPerComponent: 8, bytesPerRow: 0,
+        let rounded = safeRect.integral
-            space: CGColorSpaceCreateDeviceRGB(),
+        guard rounded.width >= 1, rounded.height >= 1 else { return nil }
-            bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue
+        return image.cropping(to: rounded)
-        ) else { return nil }
-        cropCtx.interpolationQuality = .high
-        cropCtx.draw(image, in: CGRect(x: -safeRect.minX, y: -safeRect.minY, width: CGFloat(image.width), height: CGFloat(image.height)))
-        return cropCtx.makeImage()
     }
 
     @available(macOS 14.0, *)

Sources/Kapture/ResultWindow.swift

@@ -90,6 +90,22 @@ final class CaptureModel: ObservableObject {
     @Published var statusMessage: String?
     /// Drag selection rect in IMAGE point space (nil = none)
     @Published var selection: CGRect?
+    /// Freehand drawing strokes in IMAGE point space
+    @Published var strokes: [Stroke] = []
+    /// Redo stack of removed strokes
+    @Published var redoStack: [Stroke] = []
+    /// Whether the pen is active (drag draws instead of selecting)
+    @Published var isDrawing = false
+    /// Current drawing color
+    @Published var drawColor: NSColor = .systemRed
+    /// Stroke thickness in points (image space)
+    @Published var strokeWidth: CGFloat = 3.0
+
+    struct Stroke {
+        let points: [CGPoint]
+        let width: CGFloat
+        let color: NSColor
+    }
 
     enum CaptureMode {
         case screenshot
@@ -101,6 +117,67 @@ final class CaptureModel: ObservableObject {
     }
 
     var hasSelection: Bool { selection != nil && selection!.width >= 2 && selection!.height >= 2 }
+    var canUndo: Bool { !strokes.isEmpty }
+    var canRedo: Bool { !redoStack.isEmpty }
+
+    func undoStroke() {
+        guard let last = strokes.popLast() else { return }
+        redoStack.append(last)
+    }
+
+    func redoStroke() {
+        guard let last = redoStack.popLast() else { return }
+        strokes.append(last)
+    }
+
+    func clearAnnotations() {
+        strokes = []
+        redoStack = []
+    }
+
+    /// Image with drawn strokes flattened in, for copy/save/export.
+    var annotatedImage: CGImage {
+        guard !strokes.isEmpty else { return image }
+        let size = NSSize(width: image.width, height: image.height)
+        guard let rep = NSBitmapImageRep(
+            bitmapDataPlanes: nil, pixelsWide: Int(size.width), pixelsHigh: Int(size.height),
+            bitsPerSample: 8, samplesPerPixel: 4, hasAlpha: true, isPlanar: false,
+            colorSpaceName: .deviceRGB, bytesPerRow: 0, bitsPerPixel: 0
+        ) else { return image }
+        NSGraphicsContext.saveGraphicsState()
+        NSGraphicsContext.current = NSGraphicsContext(bitmapImageRep: rep)
+        let ctx = NSGraphicsContext.current!.cgContext
+        // CGImage draws with a flipped Y in NSGraphicsContext
+        ctx.draw(image, in: NSRect(origin: .zero, size: size))
+        // Strokes are stored in TOP-LEFT image coordinates (from the SwiftUI
+        // canvas), but the CGContext uses a BOTTOM-LEFT origin. Flip Y so the
+        // strokes land where they were drawn.
+        ctx.saveGState()
+        ctx.translateBy(x: 0, y: size.height)
+        ctx.scaleBy(x: 1, y: -1)
+        ctx.setLineCap(.round)
+        ctx.setLineJoin(.round)
+        for stroke in strokes {
+            guard stroke.points.count > 1 else { continue }
+            stroke.color.setStroke()
+            ctx.setLineWidth(stroke.width)
+            ctx.beginPath()
+            ctx.move(to: stroke.points[0])
+            for point in stroke.points.dropFirst() {
+                ctx.addLine(to: point)
+            }
+            ctx.strokePath()
+        }
+        ctx.restoreGState()
+        NSGraphicsContext.restoreGraphicsState()
+        return rep.cgImage ?? image
+    }
+
+    func addStroke(_ points: [CGPoint]) {
+        guard points.count > 1 else { return }
+        strokes.append(Stroke(points: points, width: strokeWidth, color: drawColor))
+        redoStack = []
+    }
 
     var displayText: String {
         if isOCRRunning {
@@ -164,7 +241,7 @@ final class CaptureModel: ObservableObject {
     func copyImage() {
         let pasteboard = NSPasteboard.general
         pasteboard.clearContents()
-        pasteboard.writeObjects([NSImage(cgImage: image, size: .zero)])
+        pasteboard.writeObjects([NSImage(cgImage: annotatedImage, size: .zero)])
         statusMessage = "Image copied to clipboard."
     }
 
@@ -177,7 +254,7 @@ final class CaptureModel: ObservableObject {
             statusMessage = "Could not create PNG file."
             return
         }
-        CGImageDestinationAddImage(dest, image, nil)
+        CGImageDestinationAddImage(dest, annotatedImage, nil)
         if CGImageDestinationFinalize(dest) {
             statusMessage = "Saved PNG."
         } else {
@@ -231,6 +308,16 @@ struct ResultView: View {
 
                 Divider().frame(height: 18)
 
+                Button {
+                    model.isDrawing.toggle()
+                    if model.isDrawing { model.selection = nil }
+                } label: {
+                    Label("Draw", systemImage: model.isDrawing ? "pencil.tip.crop.circle.fill" : "pencil.tip.crop.circle")
+                }
+                .buttonStyle(.bordered)
+                .foregroundStyle(model.isDrawing ? .primary : .secondary)
+                .help("Toggle drawing on the screenshot")
+
                 Button {
                     model.copyImage()
                 } label: {
@@ -261,6 +348,76 @@ struct ResultView: View {
 
             Divider()
 
+            // Draw toolbar (only when drawing)
+            if model.isDrawing {
+                HStack(spacing: 14) {
+                    Label("Draw", systemImage: "pencil.tip")
+                        .font(.caption)
+                        .foregroundStyle(.secondary)
+
+                    Divider().frame(height: 18)
+
+                    HStack(spacing: 6) {
+                        Image(systemName: "circle.fill").font(.system(size: 4))
+                        Image(systemName: "circle.fill").font(.system(size: 7))
+                        Image(systemName: "circle.fill").font(.system(size: 10))
+                    }
+                    .foregroundStyle(.secondary)
+                    Slider(value: $model.strokeWidth, in: 1...12, step: 0.5)
+                        .frame(width: 120)
+                        .help("Stroke thickness")
+
+                    Divider().frame(height: 18)
+
+                    ColorPicker("", selection: Binding(
+                        get: { Color(nsColor: model.drawColor) },
+                        set: { model.drawColor = NSColor($0) }
+                    ), supportsOpacity: false)
+                    .labelsHidden()
+                    .frame(width: 28)
+                    .help("Drawing color")
+
+                    Spacer()
+
+                    Button {
+                        model.undoStroke()
+                    } label: {
+                        Label("Undo", systemImage: "arrow.uturn.backward")
+                    }
+                    .buttonStyle(.bordered)
+                    .controlSize(.small)
+                    .disabled(!model.canUndo)
+                    .keyboardShortcut("z", modifiers: .command)
+                    .help("Undo last stroke (⌘Z)")
+
+                    Button {
+                        model.redoStroke()
+                    } label: {
+                        Label("Redo", systemImage: "arrow.uturn.forward")
+                    }
+                    .buttonStyle(.bordered)
+                    .controlSize(.small)
+                    .disabled(!model.canRedo)
+                    .keyboardShortcut("z", modifiers: [.command, .shift])
+                    .help("Redo stroke (⌘⇧Z)")
+
+                    Button {
+                        model.clearAnnotations()
+                    } label: {
+                        Label("Clear", systemImage: "eraser")
+                    }
+                    .buttonStyle(.bordered)
+                    .controlSize(.small)
+                    .disabled(model.strokes.isEmpty)
+                    .help("Remove all drawn annotations")
+                }
+                .padding(.horizontal, 14)
+                .padding(.vertical, 8)
+                .background(.bar)
+
+                Divider()
+            }
+
             // Content
             if model.mode == .screenshot {
                 ScreenshotPane(model: model)
@@ -340,6 +497,8 @@ struct ScreenshotPane: View {
         rect.intersection(CGRect(origin: .zero, size: imageSize))
     }
 
+    @State private var currentStroke: [CGPoint] = []
+
     var body: some View {
         GeometryReader { geo in
             let (scale, drawSize, origin) = geometry(for: geo)
@@ -352,7 +511,36 @@ struct ScreenshotPane: View {
                     .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 {
+                // Completed strokes
+                Canvas { context, _ in
+                    for stroke in model.strokes {
+                        guard stroke.points.count > 1 else { continue }
+                        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() {
+                            path.addLine(to: CGPoint(x: origin.x + point.x * scale, y: origin.y + point.y * scale))
+                        }
+                        context.stroke(path, with: .color(Color(nsColor: stroke.color)), lineWidth: stroke.width)
+                    }
+                }
+                .allowsHitTesting(false)
+
+                // In-progress stroke
+                if !currentStroke.isEmpty {
+                    Canvas { context, _ in
+                        var path = Path()
+                        if currentStroke.count > 1 {
+                            path.move(to: CGPoint(x: origin.x + currentStroke[0].x * scale, y: origin.y + currentStroke[0].y * scale))
+                            for point in currentStroke.dropFirst() {
+                                path.addLine(to: CGPoint(x: origin.x + point.x * scale, y: origin.y + point.y * scale))
+                            }
+                        }
+                        context.stroke(path, with: .color(Color(nsColor: model.drawColor)), lineWidth: model.strokeWidth)
+                    }
+                    .allowsHitTesting(false)
+                }
+
+                if !model.isDrawing, let sel = model.selection {
                     let viewRect = CGRect(
                         x: origin.x + sel.minX * scale,
                         y: origin.y + sel.minY * scale,
@@ -371,19 +559,34 @@ struct ScreenshotPane: View {
             .gesture(
                 DragGesture(minimumDistance: 0)
                     .onChanged { value in
-                        let start = toImagePoint(value.startLocation, scale: scale, origin: origin)
+                        if model.isDrawing {
-                        let current = toImagePoint(value.location, scale: scale, origin: origin)
+                            let p = toImagePoint(value.location, scale: scale, origin: origin)
-                        let rect = CGRect(
+                            let imgRect = CGRect(origin: .zero, size: imageSize)
-                            x: min(start.x, current.x),
+                            if imgRect.contains(p) {
-                            y: min(start.y, current.y),
+                                currentStroke.append(p)
-                            width: abs(current.x - start.x),
+                            }
-                            height: abs(current.y - start.y)
+                        } else {
-                        )
+                            let start = toImagePoint(value.startLocation, scale: scale, origin: origin)
-                        model.selection = clampSelection(rect)
+                            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) {
+                        if model.isDrawing {
-                            model.selection = nil
+                            if currentStroke.count > 1 {
+                                model.addStroke(currentStroke)
+                            }
+                            currentStroke = []
+                        } else {
+                            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.2.1</string>
+    <string>1.4.3</string>
     <key>CFBundleVersion</key>
-    <string>21</string>
+    <string>43</string>
     <key>LSUIElement</key>
     <true/>
     <key>NSHighResolutionCapable</key>