Flash menu-bar icon background on successful conversion

Author: gluck-59

Sources/AppDelegate.swift

@@ -20,6 +20,9 @@ class AppDelegate: NSObject, NSApplicationDelegate {
         )
 
         textSwitcher = TextSwitcher()
+        textSwitcher.onConversionSucceeded = { [weak self] in
+            self?.flashStatusIcon()
+        }
         hotkeyManager = HotkeyManager { [weak self] in
             self?.textSwitcher.switchSelectedText()
         }
@@ -104,6 +107,159 @@ class AppDelegate: NSObject, NSApplicationDelegate {
         return "Горячая клавиша: \(HotkeyDisplayHelper.format(keyCode: keyCode, modifiers: modifiers))"
     }
 
+    // MARK: - Status icon flash
+
+    /// How long the flash image stays on the status button before the
+    /// original template icon is restored.
+    private static let flashDuration: TimeInterval = 0.3
+
+    /// Flash background color: RGB 255, 150, 0.
+    private static let flashBackgroundColor = NSColor(
+        deviceRed: 1.0, green: 150.0 / 255.0, blue: 0.0, alpha: 1.0
+    )
+
+    /// Corner radius (points) of the rounded-square flash fill.
+    private static let flashCornerRadius: CGFloat = 4
+
+    /// Inset (points) between the rounded fill and the icon's edge.
+    private static let flashInset: CGFloat = 1
+
+    /// Restore work currently scheduled, cancelled when a newer flash
+    /// supersedes it so rapid successive hotkeys never restore early.
+    private var flashRestoreWork: DispatchWorkItem?
+    /// The template icon the flash temporarily replaced.
+    private var flashBaseImage: NSImage?
+
+    /// Briefly swap the status-button icon for an orange-background version
+    /// after a successful conversion, then restore the template icon. Runs on
+    /// the main thread (the conversion flow completes there).
+    private func flashStatusIcon() {
+        guard let button = statusItem?.button, let base = button.image else { return }
+        flashRestoreWork?.cancel()
+        flashBaseImage = base
+
+        // Defer the swap to the next main-runloop turn so the 300 ms hold
+        // starts only after the synchronous conversion flow returns and the
+        // button actually repaints.
+        DispatchQueue.main.async { [weak self] in
+            guard let self,
+                  let flash = Self.makeFlashImage(
+                      base: base,
+                      size: NSSize(width: 18, height: 18),
+                      background: Self.flashBackgroundColor,
+                      cornerRadius: Self.flashCornerRadius,
+                      inset: Self.flashInset
+                  )
+            else { return }
+            button.image = flash
+            button.image?.isTemplate = false
+
+            let work = DispatchWorkItem { [weak self] in
+                guard let self, let button = self.statusItem?.button else { return }
+                if let base = self.flashBaseImage {
+                    button.image = base
+                    button.image?.isTemplate = true
+                }
+                self.flashRestoreWork = nil
+            }
+            self.flashRestoreWork = work
+            DispatchQueue.main.asyncAfter(
+                deadline: .now() + Self.flashDuration,
+                execute: work
+            )
+        }
+    }
+
+    /// Composite a rounded orange square behind a white copy of the template
+    /// glyph. The result is non-template so it renders identically in both
+    /// light and dark menu bars. Rendered at 2x pixel scale for retina.
+    static func makeFlashImage(
+        base: NSImage,
+        size: NSSize,
+        background: NSColor,
+        cornerRadius: CGFloat,
+        inset: CGFloat
+    ) -> NSImage? {
+        guard size.width > 0, size.height > 0 else { return nil }
+        let pixelsWide = Int(size.width * 2)
+        let pixelsHigh = Int(size.height * 2)
+        guard let rep = NSBitmapImageRep(
+            bitmapDataPlanes: nil,
+            pixelsWide: pixelsWide,
+            pixelsHigh: pixelsHigh,
+            bitsPerSample: 8,
+            samplesPerPixel: 4,
+            hasAlpha: true,
+            isPlanar: false,
+            colorSpaceName: .deviceRGB,
+            bytesPerRow: 0,
+            bitsPerPixel: 0
+        ) else { return nil }
+        rep.size = size
+
+        NSGraphicsContext.saveGraphicsState()
+        guard let context = NSGraphicsContext(bitmapImageRep: rep) else {
+            NSGraphicsContext.restoreGraphicsState()
+            return nil
+        }
+        NSGraphicsContext.current = context
+
+        let rect = NSRect(origin: .zero, size: size)
+        let fillRect = rect.insetBy(dx: inset, dy: inset)
+
+        // Tint the glyph white on a transparent canvas first, so the white
+        // never bleeds into the orange fill (sourceAtop over the opaque
+        // background would whiten the whole square).
+        let glyph = Self.whiteGlyph(from: base, in: fillRect)
+
+        let rounded = NSBezierPath(
+            roundedRect: fillRect,
+            xRadius: cornerRadius,
+            yRadius: cornerRadius
+        )
+        background.setFill()
+        rounded.fill()
+
+        glyph.draw(in: fillRect)
+
+        NSGraphicsContext.restoreGraphicsState()
+
+        let image = NSImage(size: size)
+        image.addRepresentation(rep)
+        image.isTemplate = false
+        return image
+    }
+
+    /// Render `base` as a white glyph on a transparent canvas sized to `rect`.
+    private static func whiteGlyph(from base: NSImage, in rect: NSRect) -> NSImage {
+        let pixelsWide = Int(rect.width * 2)
+        let pixelsHigh = Int(rect.height * 2)
+        let rep = NSBitmapImageRep(
+            bitmapDataPlanes: nil,
+            pixelsWide: pixelsWide,
+            pixelsHigh: pixelsHigh,
+            bitsPerSample: 8,
+            samplesPerPixel: 4,
+            hasAlpha: true,
+            isPlanar: false,
+            colorSpaceName: .deviceRGB,
+            bytesPerRow: 0,
+            bitsPerPixel: 0
+        )!
+        rep.size = rect.size
+
+        NSGraphicsContext.saveGraphicsState()
+        NSGraphicsContext.current = NSGraphicsContext(bitmapImageRep: rep)
+        base.draw(in: NSRect(origin: .zero, size: rect.size))
+        NSColor.white.set()
+        NSRect(origin: .zero, size: rect.size).fill(using: .sourceAtop)
+        NSGraphicsContext.restoreGraphicsState()
+
+        let image = NSImage(size: rect.size)
+        image.addRepresentation(rep)
+        return image
+    }
+
     // MARK: - Helpers
 
     private func activateApp() {

Sources/TextSwitcher.swift

@@ -3,6 +3,10 @@ import Carbon
 
 class TextSwitcher {
 
+    /// Invoked on the main thread after every successfully typed conversion;
+    /// failure paths never reach it, so their feedback is unchanged.
+    var onConversionSucceeded: (() -> Void)?
+
     // MARK: - Tunables
 
     /// Maximum time to wait for the focused app to fill the pasteboard after
@@ -380,7 +384,12 @@ class TextSwitcher {
             Self.injectUnicode(converted)
         }
         Self.diag("injection done")
+        finishConversion(targetLayout: targetLayout)
+    }
 
+    /// Post-injection success tail: report success + optional layout switch.
+    private func finishConversion(targetLayout: LayoutInfo?) {
+        onConversionSucceeded?()
         if UserDefaults.standard.switchLayoutAfterConversion, let targetLayout {
             InputSourceSwitcher.switchTo(target: targetLayout)
         }

Tests/StatusIconFlashTests.swift

@@ -0,0 +1,102 @@
+import XCTest
+import AppKit
+
+final class StatusIconFlashTests: XCTestCase {
+
+    /// A minimal template glyph shaped like the real menu-bar icon: a
+    /// horizontal black band in the middle of a 32×32 transparent canvas.
+    private func makeTemplateBase() -> NSImage {
+        let image = NSImage(size: NSSize(width: 32, height: 32))
+        image.isTemplate = true
+        image.lockFocus()
+        NSColor.black.setFill()
+        NSRect(x: 4, y: 12, width: 24, height: 8).fill()
+        image.unlockFocus()
+        return image
+    }
+
+    private func makeFlash(size: NSSize = NSSize(width: 18, height: 18)) -> NSImage? {
+        AppDelegate.makeFlashImage(
+            base: makeTemplateBase(),
+            size: size,
+            background: NSColor(
+                deviceRed: 1.0, green: 150.0 / 255.0, blue: 0.0, alpha: 1.0
+            ),
+            cornerRadius: 4,
+            inset: 1
+        )
+    }
+
+    /// Sample a color at a point in points (the rep is rendered at 2x).
+    private func pixel(_ image: NSImage, point: CGPoint) -> NSColor? {
+        guard let rep = image.representations.first as? NSBitmapImageRep else { return nil }
+        let x = Int(point.x * 2)
+        let y = Int(point.y * 2)
+        guard x >= 0, x < rep.pixelsWide, y >= 0, y < rep.pixelsHigh else { return nil }
+        return rep.colorAt(x: x, y: y)?.usingColorSpace(.deviceRGB)
+    }
+
+    private func isClose(_ value: CGFloat, to expected: CGFloat, tolerance: CGFloat = 0.05) -> Bool {
+        abs(value - expected) <= tolerance
+    }
+
+    // MARK: - Basic properties
+
+    func testMakeFlash_ReturnsNonNilForValidInput() {
+        XCTAssertNotNil(makeFlash())
+    }
+
+    func testMakeFlash_HasRequestedPointSize() {
+        let image = makeFlash()
+        XCTAssertEqual(image?.size.width, 18)
+        XCTAssertEqual(image?.size.height, 18)
+    }
+
+    func testMakeFlash_IsNotATemplate() {
+        XCTAssertEqual(makeFlash()?.isTemplate, false)
+    }
+
+    func testMakeFlash_ReturnsNilForZeroSize() {
+        XCTAssertNil(makeFlash(size: .zero))
+    }
+
+    func testMakeFlash_ReturnsNilForNegativeSize() {
+        XCTAssertNil(makeFlash(size: NSSize(width: -18, height: 18)))
+    }
+
+    // MARK: - Pixel colors
+
+    func testMakeFlash_FillIsOrange() {
+        guard let image = makeFlash() else { return XCTFail("flash image nil") }
+        // Top-center: inside the rounded fill (inset 1, starts at y=1) but
+        // above the glyph band (which starts near y=7).
+        guard let color = pixel(image, point: CGPoint(x: 9, y: 2.5)) else {
+            return XCTFail("no pixel data")
+        }
+        XCTAssertTrue(isClose(color.redComponent, to: 1.0), "red was \(color.redComponent)")
+        XCTAssertTrue(isClose(color.greenComponent, to: 150.0 / 255.0), "green was \(color.greenComponent)")
+        XCTAssertTrue(isClose(color.blueComponent, to: 0.0), "blue was \(color.blueComponent)")
+        XCTAssertTrue(isClose(color.alphaComponent, to: 1.0), "alpha was \(color.alphaComponent)")
+    }
+
+    func testMakeFlash_GlyphIsWhite() {
+        guard let image = makeFlash() else { return XCTFail("flash image nil") }
+        // Center: inside the glyph band (y 7...11).
+        guard let color = pixel(image, point: CGPoint(x: 9, y: 9)) else {
+            return XCTFail("no pixel data")
+        }
+        XCTAssertTrue(isClose(color.redComponent, to: 1.0), "red was \(color.redComponent)")
+        XCTAssertTrue(isClose(color.greenComponent, to: 1.0), "green was \(color.greenComponent)")
+        XCTAssertTrue(isClose(color.blueComponent, to: 1.0), "blue was \(color.blueComponent)")
+        XCTAssertTrue(isClose(color.alphaComponent, to: 1.0), "alpha was \(color.alphaComponent)")
+    }
+
+    func testMakeFlash_RoundedCornersAreTransparent() {
+        guard let image = makeFlash() else { return XCTFail("flash image nil") }
+        // The rounded corner cuts the 1×1 image corner away from the fill.
+        guard let color = pixel(image, point: CGPoint(x: 1, y: 1)) else {
+            return XCTFail("no pixel data")
+        }
+        XCTAssertTrue(color.alphaComponent < 0.05, "alpha was \(color.alphaComponent)")
+    }
+}