Skip to content

Fastest and only macOS Dictation app with on-device STT and custom trained AI enhancement model. Windows, iOS testflight! Android, Linux waitlist open! A local Wispr Flow alternative. Follow https://x.com/fluidvoiceapp for more

Add mouse shortcut support for primary dictation

George Pickett66f5440c3a98
diff --git a/Fluid.xcodeproj/project.pbxproj b/Fluid.xcodeproj/project.pbxproj
index 30da8f2d..8ca13476 100644
--- a/Fluid.xcodeproj/project.pbxproj
+++ b/Fluid.xcodeproj/project.pbxproj
@@ -12,6 +12,7 @@
7C3236542EAAD608007E4CB6 /* MCP in Frameworks */ = {isa = PBXBuildFile; productRef = 7C3236532EAAD608007E4CB6 /* MCP */; };
7C3697892ED70F9C005874CE /* DynamicNotchKit in Frameworks */ = {isa = PBXBuildFile; productRef = 7C3697882ED70F9C005874CE /* DynamicNotchKit */; };
7C5AF14B2F15041600DE21B0 /* MediaRemoteAdapter in Frameworks */ = {isa = PBXBuildFile; productRef = 7C5AF14A2F15041600DE21B0 /* MediaRemoteAdapter */; };
+ 7C91B0012F42AA0100C0DEF0 /* HotkeyShortcutTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 7C91B0022F42AA0100C0DEF0 /* HotkeyShortcutTests.swift */; };
7CDB0A2D2F3C4D5600FB7CAD /* DictationE2ETests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 7CDB0A292F3C4D5600FB7CAD /* DictationE2ETests.swift */; };
7CDB0A2E2F3C4D5600FB7CAD /* AudioFixtureLoader.swift in Sources */ = {isa = PBXBuildFile; fileRef = 7CDB0A2A2F3C4D5600FB7CAD /* AudioFixtureLoader.swift */; };
7CDB0A2F2F3C4D5600FB7CAD /* dictation_fixture.wav in Resources */ = {isa = PBXBuildFile; fileRef = 7CDB0A2B2F3C4D5600FB7CAD /* dictation_fixture.wav */; };
@@ -32,6 +33,7 @@
/* Begin PBXFileReference section */
7C078D8F2E3B339200FB7CAC /* FluidVoice Debug.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = "FluidVoice Debug.app"; sourceTree = BUILT_PRODUCTS_DIR; };
7CDB0A202F3C4D5600FB7CAD /* FluidDictationIntegrationTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = FluidDictationIntegrationTests.xctest; sourceTree = BUILT_PRODUCTS_DIR; };
+ 7C91B0022F42AA0100C0DEF0 /* HotkeyShortcutTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = HotkeyShortcutTests.swift; sourceTree = "<group>"; };
7CDB0A292F3C4D5600FB7CAD /* DictationE2ETests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = DictationE2ETests.swift; sourceTree = "<group>"; };
7CDB0A2A2F3C4D5600FB7CAD /* AudioFixtureLoader.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AudioFixtureLoader.swift; sourceTree = "<group>"; };
7CDB0A2B2F3C4D5600FB7CAD /* dictation_fixture.wav */ = {isa = PBXFileReference; lastKnownFileType = audio.wav; path = dictation_fixture.wav; sourceTree = "<group>"; };
@@ -103,6 +105,7 @@
7CDB0A262F3C4D5600FB7CAD /* Helpers */,
7CDB0A272F3C4D5600FB7CAD /* Resources */,
7CDB0A292F3C4D5600FB7CAD /* DictationE2ETests.swift */,
+ 7C91B0022F42AA0100C0DEF0 /* HotkeyShortcutTests.swift */,
);
path = FluidDictationIntegrationTests;
sourceTree = "<group>";
@@ -258,6 +261,7 @@
files = (
7CDB0A2E2F3C4D5600FB7CAD /* AudioFixtureLoader.swift in Sources */,
7CDB0A2D2F3C4D5600FB7CAD /* DictationE2ETests.swift in Sources */,
+ 7C91B0012F42AA0100C0DEF0 /* HotkeyShortcutTests.swift in Sources */,
);
runOnlyForDeploymentPostprocessing = 0;
};
diff --git a/Sources/Fluid/ContentView.swift b/Sources/Fluid/ContentView.swift
index 92a6a3ef..b431df33 100644
--- a/Sources/Fluid/ContentView.swift
+++ b/Sources/Fluid/ContentView.swift
@@ -102,6 +102,10 @@ enum ShortcutRecordingTarget: Hashable {
if case let .dictationPrompt(key) = self { return key }
return nil
}
+
+ var allowsMouseShortcut: Bool {
+ self == .primaryDictation
+ }
}
// MARK: - Minimal FluidAudio ASR Service (finalized text, macOS)
@@ -637,7 +641,7 @@ struct ContentView: View {
}
private func installShortcutCaptureMonitor() {
- NSEvent.addLocalMonitorForEvents(matching: [.keyDown, .flagsChanged]) { event in
+ NSEvent.addLocalMonitorForEvents(matching: [.keyDown, .flagsChanged, .leftMouseDown, .rightMouseDown, .otherMouseDown]) { event in
self.handleShortcutCaptureEvent(event)
}
}
@@ -651,6 +655,8 @@ struct ContentView: View {
return self.handleShortcutKeyDownEvent(event, modifiers: eventModifiers, isRecordingAnyShortcut: isRecordingAnyShortcut, recordingTarget: recordingTarget)
} else if event.type == .flagsChanged {
return self.handleShortcutFlagsChangedEvent(event, modifiers: eventModifiers, isRecordingAnyShortcut: isRecordingAnyShortcut, recordingTarget: recordingTarget)
+ } else if event.type == .leftMouseDown || event.type == .rightMouseDown || event.type == .otherMouseDown {
+ return self.handleShortcutMouseDownEvent(event, modifiers: eventModifiers, isRecordingAnyShortcut: isRecordingAnyShortcut, recordingTarget: recordingTarget)
}
return event
@@ -701,6 +707,39 @@ struct ContentView: View {
return nil
}
+ private func handleShortcutMouseDownEvent(
+ _ event: NSEvent,
+ modifiers eventModifiers: NSEvent.ModifierFlags,
+ isRecordingAnyShortcut: Bool,
+ recordingTarget: ShortcutRecordingTarget?
+ ) -> NSEvent? {
+ guard isRecordingAnyShortcut else {
+ self.shortcutRecordingMessage = nil
+ self.resetPendingShortcutState()
+ return event
+ }
+
+ let newShortcut = HotkeyShortcut(mouseButton: event.buttonNumber, modifierFlags: self.pendingModifierFlags.union(eventModifiers))
+ DebugLogger.shared.debug("NSEvent monitor: Recording new mouse shortcut: \(newShortcut.displayString)", source: "ContentView")
+
+ if let recordingTarget,
+ let conflictMessage = self.shortcutConflictMessage(for: newShortcut, target: recordingTarget)
+ {
+ self.shortcutRecordingMessage = conflictMessage
+ self.resetPendingShortcutState()
+ DebugLogger.shared.debug("NSEvent monitor: Mouse shortcut conflict while recording: \(conflictMessage)", source: "ContentView")
+ return nil
+ }
+
+ self.shortcutRecordingMessage = nil
+ if let recordingTarget {
+ self.assignRecordedShortcut(newShortcut, to: recordingTarget)
+ }
+ self.resetPendingShortcutState()
+ DebugLogger.shared.debug("NSEvent monitor: Finished recording mouse shortcut", source: "ContentView")
+ return nil
+ }
+
private func handleShortcutFlagsChangedEvent(
_ event: NSEvent,
modifiers eventModifiers: NSEvent.ModifierFlags,
@@ -883,6 +922,16 @@ struct ContentView: View {
}
private func shortcutConflictMessage(for shortcut: HotkeyShortcut, target: ShortcutRecordingTarget) -> String? {
+ if shortcut.isMouseShortcut {
+ guard target.allowsMouseShortcut else {
+ return "Mouse clicks can only be assigned to Primary Dictation Shortcut"
+ }
+
+ if shortcut.isUnmodifiedLeftOrRightClick, let mouseButton = shortcut.mouseButton {
+ return "\(HotkeyShortcut.mouseButtonToString(mouseButton)) needs a modifier key"
+ }
+ }
+
let configuredShortcuts: [(ShortcutRecordingTarget, HotkeyShortcut)] = [
(.primaryDictation, self.hotkeyShortcut),
(.secondaryDictation, self.promptModeHotkeyShortcut),
diff --git a/Sources/Fluid/Models/HotkeyShortcut.swift b/Sources/Fluid/Models/HotkeyShortcut.swift
index 7fd17be7..9ba689cb 100644
--- a/Sources/Fluid/Models/HotkeyShortcut.swift
+++ b/Sources/Fluid/Models/HotkeyShortcut.swift
@@ -3,24 +3,32 @@ import Carbon
import Foundation
struct HotkeyShortcut: Codable, Equatable {
+ enum ShortcutKind: String, Codable {
+ case keyboard
+ case mouse
+ }
+
+ private(set) var kind: ShortcutKind
var keyCode: UInt16
var modifierFlags: NSEvent.ModifierFlags
var modifierKeyCodes: [UInt16]
- enum CodingKeys: String, CodingKey { case keyCode, modifierFlagsRawValue, modifierKeyCodes }
+ private(set) var mouseButton: Int?
+ enum CodingKeys: String, CodingKey { case kind, keyCode, modifierFlagsRawValue, modifierKeyCodes, mouseButton }
var displayString: String {
+ if self.isMouseShortcut, let mouseButton {
+ var parts = Self.modifierDisplayParts(for: self.relevantModifierFlags)
+ parts.append(Self.mouseButtonToString(mouseButton))
+ return parts.joined(separator: " + ")
+ }
+
let modifierKeyCodes = self.normalizedModifierKeyCodes
let modifierParts = modifierKeyCodes.compactMap(Self.keyCodeToString)
if !modifierParts.isEmpty {
return modifierParts.joined(separator: " + ")
}
- var parts: [String] = []
- if self.modifierFlags.contains(.function) { parts.append("🌐") }
- if self.modifierFlags.contains(.command) { parts.append("⌘") }
- if self.modifierFlags.contains(.option) { parts.append("⌥") }
- if self.modifierFlags.contains(.control) { parts.append("⌃") }
- if self.modifierFlags.contains(.shift) { parts.append("⇧") }
+ var parts = Self.modifierDisplayParts(for: self.modifierFlags)
parts.append(Self.keyCodeToString(self.keyCode) ?? "?")
if self.modifierFlags.isEmpty {
@@ -54,7 +62,26 @@ struct HotkeyShortcut: Codable, Equatable {
}
}
- // US QWERTY names used when TIS layout data is unavailable (e.g. emoji/CJK input sources).
+ static func mouseButtonToString(_ button: Int) -> String {
+ switch button {
+ case 0: return "Left Click"
+ case 1: return "Right Click"
+ case 2: return "Middle Click"
+ default: return "Mouse \(button + 1)"
+ }
+ }
+
+ private static func modifierDisplayParts(for flags: NSEvent.ModifierFlags) -> [String] {
+ var parts: [String] = []
+ if flags.contains(.function) { parts.append("🌐") }
+ if flags.contains(.command) { parts.append("⌘") }
+ if flags.contains(.option) { parts.append("⌥") }
+ if flags.contains(.control) { parts.append("⌃") }
+ if flags.contains(.shift) { parts.append("⇧") }
+ return parts
+ }
+
+ /// US QWERTY names used when TIS layout data is unavailable (e.g. emoji/CJK input sources).
private static let qwertyFallback: [UInt16: String] = [
0: "A", 1: "S", 2: "D", 3: "F", 4: "H", 5: "G", 6: "Z", 7: "X",
8: "C", 9: "V", 10: "§", 11: "B", 12: "Q", 13: "W", 14: "E", 15: "R",
@@ -101,6 +128,8 @@ struct HotkeyShortcut: Codable, Equatable {
}
init(keyCode: UInt16, modifierFlags: NSEvent.ModifierFlags, modifierKeyCodes: [UInt16] = []) {
+ self.kind = .keyboard
+ self.mouseButton = nil
let normalizedModifierKeyCodes = Self.normalizedModifierKeyCodes(from: modifierKeyCodes)
if !normalizedModifierKeyCodes.isEmpty {
self.modifierKeyCodes = normalizedModifierKeyCodes
@@ -122,6 +151,14 @@ struct HotkeyShortcut: Codable, Equatable {
self.modifierKeyCodes = []
}
}
+
+ init(mouseButton: Int, modifierFlags: NSEvent.ModifierFlags) {
+ self.kind = .mouse
+ self.keyCode = 0
+ self.modifierFlags = modifierFlags.intersection(Self.relevantModifierMask)
+ self.modifierKeyCodes = []
+ self.mouseButton = mouseButton
+ }
}
extension HotkeyShortcut {
@@ -160,7 +197,7 @@ extension HotkeyShortcut {
}
static func normalizedModifierKeyCodes(from modifierKeyCodes: [UInt16]) -> [UInt16] {
- let normalized = Array(Set(modifierKeyCodes)).compactMap { keyCode -> (UInt16, Int)? in
+ Array(Set(modifierKeyCodes)).compactMap { keyCode -> (UInt16, Int)? in
guard let priority = Self.modifierSortPriority(forKeyCode: keyCode) else { return nil }
return (keyCode, priority)
}
@@ -168,15 +205,23 @@ extension HotkeyShortcut {
lhs.1 < rhs.1
}
.map(\.0)
-
- return normalized
}
var relevantModifierFlags: NSEvent.ModifierFlags {
self.modifierFlags.intersection(Self.relevantModifierMask)
}
+ var isMouseShortcut: Bool {
+ self.kind == .mouse && self.mouseButton != nil
+ }
+
+ var isUnmodifiedLeftOrRightClick: Bool {
+ guard self.isMouseShortcut, let mouseButton else { return false }
+ return (mouseButton == 0 || mouseButton == 1) && self.relevantModifierFlags.isEmpty
+ }
+
var normalizedModifierKeyCodes: [UInt16] {
+ guard !self.isMouseShortcut else { return [] }
let normalized = Self.normalizedModifierKeyCodes(from: self.modifierKeyCodes)
if !normalized.isEmpty { return normalized }
@@ -188,7 +233,8 @@ extension HotkeyShortcut {
}
var modifierTriggerFlag: NSEvent.ModifierFlags? {
- Self.modifierFlag(forKeyCode: self.keyCode)
+ guard !self.isMouseShortcut else { return nil }
+ return Self.modifierFlag(forKeyCode: self.keyCode)
}
/// True when two modifier-only shortcuts would overlap — either identical
@@ -215,10 +261,23 @@ extension HotkeyShortcut {
}
func matches(keyCode: UInt16, modifiers: NSEvent.ModifierFlags) -> Bool {
- keyCode == self.keyCode && modifiers.intersection(Self.relevantModifierMask) == self.relevantModifierFlags
+ guard !self.isMouseShortcut else { return false }
+ return keyCode == self.keyCode && modifiers.intersection(Self.relevantModifierMask) == self.relevantModifierFlags
+ }
+
+ func matchesMouse(button: Int, modifiers: NSEvent.ModifierFlags) -> Bool {
+ guard self.isMouseShortcut, let mouseButton else { return false }
+ guard !self.isUnmodifiedLeftOrRightClick else { return false }
+ return mouseButton == button && modifiers.intersection(Self.relevantModifierMask) == self.relevantModifierFlags
}
static func == (lhs: HotkeyShortcut, rhs: HotkeyShortcut) -> Bool {
+ if lhs.isMouseShortcut || rhs.isMouseShortcut {
+ return lhs.kind == rhs.kind &&
+ lhs.mouseButton == rhs.mouseButton &&
+ lhs.relevantModifierFlags == rhs.relevantModifierFlags
+ }
+
let lhsModifierKeyCodes = lhs.normalizedModifierKeyCodes
let rhsModifierKeyCodes = rhs.normalizedModifierKeyCodes
if !lhsModifierKeyCodes.isEmpty, !rhsModifierKeyCodes.isEmpty {
@@ -230,18 +289,39 @@ extension HotkeyShortcut {
init(from decoder: Decoder) throws {
let c = try decoder.container(keyedBy: CodingKeys.self)
- let keyCode = try c.decode(UInt16.self, forKey: .keyCode)
- let raw = try c.decode(UInt.self, forKey: .modifierFlagsRawValue)
- let modifierKeyCodes = try c.decodeIfPresent([UInt16].self, forKey: .modifierKeyCodes) ?? []
- self.init(keyCode: keyCode, modifierFlags: NSEvent.ModifierFlags(rawValue: raw), modifierKeyCodes: modifierKeyCodes)
+ let kind = try c.decodeIfPresent(ShortcutKind.self, forKey: .kind) ?? .keyboard
+ let raw = try c.decodeIfPresent(UInt.self, forKey: .modifierFlagsRawValue) ?? 0
+
+ switch kind {
+ case .keyboard:
+ let keyCode = try c.decode(UInt16.self, forKey: .keyCode)
+ let modifierKeyCodes = try c.decodeIfPresent([UInt16].self, forKey: .modifierKeyCodes) ?? []
+ self.init(keyCode: keyCode, modifierFlags: NSEvent.ModifierFlags(rawValue: raw), modifierKeyCodes: modifierKeyCodes)
+ case .mouse:
+ let mouseButton = try c.decode(Int.self, forKey: .mouseButton)
+ self.init(mouseButton: mouseButton, modifierFlags: NSEvent.ModifierFlags(rawValue: raw))
+ }
}
func encode(to encoder: Encoder) throws {
var c = encoder.container(keyedBy: CodingKeys.self)
- try c.encode(self.keyCode, forKey: .keyCode)
+ try c.encode(self.kind, forKey: .kind)
try c.encode(self.modifierFlags.rawValue, forKey: .modifierFlagsRawValue)
- if !self.normalizedModifierKeyCodes.isEmpty {
- try c.encode(self.normalizedModifierKeyCodes, forKey: .modifierKeyCodes)
+ switch self.kind {
+ case .keyboard:
+ try c.encode(self.keyCode, forKey: .keyCode)
+ if !self.normalizedModifierKeyCodes.isEmpty {
+ try c.encode(self.normalizedModifierKeyCodes, forKey: .modifierKeyCodes)
+ }
+ case .mouse:
+ guard let mouseButton = self.mouseButton else {
+ let context = EncodingError.Context(
+ codingPath: c.codingPath + [CodingKeys.mouseButton],
+ debugDescription: "Mouse shortcut is missing a mouse button"
+ )
+ throw EncodingError.invalidValue(self, context)
+ }
+ try c.encode(mouseButton, forKey: .mouseButton)
}
}
}
diff --git a/Sources/Fluid/Services/GlobalHotkeyManager.swift b/Sources/Fluid/Services/GlobalHotkeyManager.swift
index 3befca62..8c12e648 100644
--- a/Sources/Fluid/Services/GlobalHotkeyManager.swift
+++ b/Sources/Fluid/Services/GlobalHotkeyManager.swift
@@ -28,6 +28,7 @@ private final nonisolated class HotkeyState: @unchecked Sendable {
var automaticPressStartTimes: [HotkeyHoldModeType: Date] = [:]
var automaticPressWasTargetActive: [HotkeyHoldModeType: Bool] = [:]
var automaticPressStartedTypes: Set<HotkeyHoldModeType> = []
+ var activePrimaryMouseButton: Int?
func withLock<T>(_ block: () -> T) -> T {
self.lock.lock()
@@ -112,6 +113,11 @@ final class GlobalHotkeyManager: NSObject {
set { self.state.withLock { self.state.isPromptAssignmentKeyPressed = newValue } }
}
+ private nonisolated var activePrimaryMouseButton: Int? {
+ get { self.state.withLock { self.state.activePrimaryMouseButton } }
+ set { self.state.withLock { self.state.activePrimaryMouseButton = newValue } }
+ }
+
private nonisolated var pressedModifierKeyCodes: Set<UInt16> {
get { self.state.withLock { self.state.pressedModifierKeyCodes } }
set { self.state.withLock { self.state.pressedModifierKeyCodes = newValue } }
@@ -441,6 +447,12 @@ final class GlobalHotkeyManager: NSObject {
let eventMask = (1 << CGEventType.keyDown.rawValue)
| (1 << CGEventType.keyUp.rawValue)
| (1 << CGEventType.flagsChanged.rawValue)
+ | (1 << CGEventType.leftMouseDown.rawValue)
+ | (1 << CGEventType.leftMouseUp.rawValue)
+ | (1 << CGEventType.rightMouseDown.rawValue)
+ | (1 << CGEventType.rightMouseUp.rawValue)
+ | (1 << CGEventType.otherMouseDown.rawValue)
+ | (1 << CGEventType.otherMouseUp.rawValue)
self.eventTap = CGEvent.tapCreate(
tap: .cgSessionEventTap,
@@ -493,7 +505,21 @@ final class GlobalHotkeyManager: NSObject {
self.runLoopSource = nil
}
- // swiftlint:disable cyclomatic_complexity function_body_length
+ private func markOtherInputDuringModifierOnly() {
+ guard self.modifierOnlyKeyDown else { return }
+ self.otherKeyPressedDuringModifier = true
+ if let pending = self.pendingHoldModeStart {
+ pending.cancel()
+ self.pendingHoldModeStart = nil
+ self.pendingHoldModeType = nil
+ DebugLogger.shared.info("Another input pressed - cancelled pending hold mode start", source: "GlobalHotkeyManager")
+ }
+ }
+
+ private func mouseButton(from event: CGEvent) -> Int {
+ Int(event.getIntegerValueField(.mouseEventButtonNumber))
+ }
+
private func handleKeyEvent(proxy: CGEventTapProxy, type: CGEventType, event: CGEvent) -> Unmanaged<CGEvent>? {
if let tapRecoveryResult = self.handleTapDisableEvent(type: type, event: event) {
return tapRecoveryResult
@@ -516,17 +542,7 @@ final class GlobalHotkeyManager: NSObject {
switch type {
case .keyDown:
- // If a modifier-only shortcut key is being held and this is a different key, mark it
- if self.modifierOnlyKeyDown {
- self.otherKeyPressedDuringModifier = true
- // Cancel any pending hold mode start (user is doing a key combo, not just modifier)
- if let pending = self.pendingHoldModeStart {
- pending.cancel()
- self.pendingHoldModeStart = nil
- self.pendingHoldModeType = nil
- DebugLogger.shared.info("Another key pressed - cancelled pending hold mode start", source: "GlobalHotkeyManager")
- }
- }
+ self.markOtherInputDuringModifierOnly()
// Observe post-transcription edits (do not consume the event).
Task {
@@ -710,81 +726,7 @@ final class GlobalHotkeyManager: NSObject {
// Then check transcription hotkey
if self.matchesShortcut(keyCode: keyCode, modifiers: eventModifiers) {
- switch self.hotkeyMode {
- case .hold:
- if !self.isKeyPressed {
- self.cancelPendingReleaseStop(for: .transcription)
- self.clearHoldModeStartTriggered(for: .transcription)
- self.isKeyPressed = true
- if self.asrService.isRunning {
- let isSameMode = self.isDictateRecordingProvider?() ?? false
- DebugLogger.shared.debug(
- "GlobalHotkeyManager: dictation hold-press path",
- source: "GlobalHotkeyManager"
- )
- DebugLogger.shared.info(
- "Hotkey route | pressed=dictate | active=\(isSameMode ? "dictate" : "other") | asrRunning=true | action=\(isSameMode ? "stop" : "switch")",
- source: "GlobalHotkeyManager"
- )
- if !isSameMode {
- self.triggerDictationMode()
- }
- } else {
- DebugLogger.shared.info(
- "Hotkey route | pressed=dictate | active=none | asrRunning=false | action=start",
- source: "GlobalHotkeyManager"
- )
- self.startRecordingIfNeeded()
- }
- self.markHoldModeStartTriggered(for: .transcription)
- }
- case .automatic:
- if !self.isKeyPressed {
- self.isKeyPressed = true
- let isSameMode = self.asrService.isRunning && (self.isDictateRecordingProvider?() ?? false)
- self.beginAutomaticPress(for: .transcription, wasTargetActive: isSameMode)
- if self.asrService.isRunning {
- DebugLogger.shared.info(
- "Hotkey route | pressed=dictate | active=\(isSameMode ? "dictate" : "other") | asrRunning=true | action=\(isSameMode ? "release-stop" : "switch")",
- source: "GlobalHotkeyManager"
- )
- if !isSameMode {
- self.triggerDictationMode()
- self.markAutomaticPressStarted(for: .transcription)
- }
- } else {
- DebugLogger.shared.info(
- "Hotkey route | pressed=dictate | active=none | asrRunning=false | action=start",
- source: "GlobalHotkeyManager"
- )
- self.triggerDictationMode()
- self.markAutomaticPressStarted(for: .transcription)
- }
- }
- case .toggle:
- if self.asrService.isRunning {
- let isSameMode = self.isDictateRecordingProvider?() ?? false
- DebugLogger.shared.debug(
- "GlobalHotkeyManager: dictation tap path while already running",
- source: "GlobalHotkeyManager"
- )
- DebugLogger.shared.info(
- "Hotkey route | pressed=dictate | active=\(isSameMode ? "dictate" : "other") | asrRunning=true | action=\(isSameMode ? "stop" : "switch")",
- source: "GlobalHotkeyManager"
- )
- if isSameMode {
- self.stopRecordingIfNeeded()
- } else {
- self.triggerDictationMode()
- }
- } else {
- DebugLogger.shared.info(
- "Hotkey route | pressed=dictate | active=none | asrRunning=false | action=start",
- source: "GlobalHotkeyManager"
- )
- self.triggerDictationMode()
- }
- }
+ self.handlePrimaryDictationTriggerDown()
return nil
}
@@ -851,21 +793,27 @@ final class GlobalHotkeyManager: NSObject {
// Transcription key up
// Note: Only check keyCode, not modifiers - user may release modifier before/with main key
- if self.isKeyPressed, keyCode == self.shortcut.keyCode {
- switch self.hotkeyMode {
- case .hold:
- self.isKeyPressed = false
- _ = self.finishHoldModeStartTriggered(for: .transcription)
- self.stopRecordingAfterRelease(for: .transcription, label: "Transcription")
- case .automatic:
- self.isKeyPressed = false
- self.handleAutomaticKeyRelease(for: .transcription, label: "Transcription")
- case .toggle:
- break
- }
+ if self.isKeyPressed, !self.shortcut.isMouseShortcut, keyCode == self.shortcut.keyCode {
+ self.handlePrimaryDictationTriggerUp()
return nil
}
+ case .leftMouseDown, .rightMouseDown, .otherMouseDown:
+ self.markOtherInputDuringModifierOnly()
+ let mouseButton = self.mouseButton(from: event)
+ if self.shortcut.matchesMouse(button: mouseButton, modifiers: eventModifiers) {
+ self.activePrimaryMouseButton = mouseButton
+ self.handlePrimaryDictationTriggerDown()
+ return nil
+ }
+
+ case .leftMouseUp, .rightMouseUp, .otherMouseUp:
+ let mouseButton = self.mouseButton(from: event)
+ guard self.activePrimaryMouseButton == mouseButton else { break }
+ self.activePrimaryMouseButton = nil
+ self.handlePrimaryDictationTriggerUp()
+ return nil
+
case .flagsChanged:
if HotkeyShortcut.modifierFlag(forKeyCode: keyCode) != nil {
self.pressedModifierKeyCodes = self.synchronizedPressedModifierKeyCodes(
@@ -985,7 +933,6 @@ final class GlobalHotkeyManager: NSObject {
}
return Unmanaged.passUnretained(event)
- // swiftlint:enable cyclomatic_complexity function_body_length
}
private func handleTapDisableEvent(type: CGEventType, event: CGEvent) -> Unmanaged<CGEvent>? {
@@ -1092,6 +1039,98 @@ final class GlobalHotkeyManager: NSObject {
}
}
+ private func handlePrimaryDictationTriggerDown() {
+ switch self.hotkeyMode {
+ case .hold:
+ if !self.isKeyPressed {
+ self.cancelPendingReleaseStop(for: .transcription)
+ self.clearHoldModeStartTriggered(for: .transcription)
+ self.isKeyPressed = true
+ if self.asrService.isRunning {
+ let isSameMode = self.isDictateRecordingProvider?() ?? false
+ DebugLogger.shared.debug(
+ "GlobalHotkeyManager: dictation hold-press path",
+ source: "GlobalHotkeyManager"
+ )
+ DebugLogger.shared.info(
+ "Hotkey route | pressed=dictate | active=\(isSameMode ? "dictate" : "other") | asrRunning=true | action=\(isSameMode ? "stop" : "switch")",
+ source: "GlobalHotkeyManager"
+ )
+ if !isSameMode {
+ self.triggerDictationMode()
+ }
+ } else {
+ DebugLogger.shared.info(
+ "Hotkey route | pressed=dictate | active=none | asrRunning=false | action=start",
+ source: "GlobalHotkeyManager"
+ )
+ self.startRecordingIfNeeded()
+ }
+ self.markHoldModeStartTriggered(for: .transcription)
+ }
+ case .automatic:
+ if !self.isKeyPressed {
+ self.isKeyPressed = true
+ let isSameMode = self.asrService.isRunning && (self.isDictateRecordingProvider?() ?? false)
+ self.beginAutomaticPress(for: .transcription, wasTargetActive: isSameMode)
+ if self.asrService.isRunning {
+ DebugLogger.shared.info(
+ "Hotkey route | pressed=dictate | active=\(isSameMode ? "dictate" : "other") | asrRunning=true | action=\(isSameMode ? "release-stop" : "switch")",
+ source: "GlobalHotkeyManager"
+ )
+ if !isSameMode {
+ self.triggerDictationMode()
+ self.markAutomaticPressStarted(for: .transcription)
+ }
+ } else {
+ DebugLogger.shared.info(
+ "Hotkey route | pressed=dictate | active=none | asrRunning=false | action=start",
+ source: "GlobalHotkeyManager"
+ )
+ self.triggerDictationMode()
+ self.markAutomaticPressStarted(for: .transcription)
+ }
+ }
+ case .toggle:
+ if self.asrService.isRunning {
+ let isSameMode = self.isDictateRecordingProvider?() ?? false
+ DebugLogger.shared.debug(
+ "GlobalHotkeyManager: dictation tap path while already running",
+ source: "GlobalHotkeyManager"
+ )
+ DebugLogger.shared.info(
+ "Hotkey route | pressed=dictate | active=\(isSameMode ? "dictate" : "other") | asrRunning=true | action=\(isSameMode ? "stop" : "switch")",
+ source: "GlobalHotkeyManager"
+ )
+ if isSameMode {
+ self.stopRecordingIfNeeded()
+ } else {
+ self.triggerDictationMode()
+ }
+ } else {
+ DebugLogger.shared.info(
+ "Hotkey route | pressed=dictate | active=none | asrRunning=false | action=start",
+ source: "GlobalHotkeyManager"
+ )
+ self.triggerDictationMode()
+ }
+ }
+ }
+
+ private func handlePrimaryDictationTriggerUp() {
+ switch self.hotkeyMode {
+ case .hold:
+ self.isKeyPressed = false
+ _ = self.finishHoldModeStartTriggered(for: .transcription)
+ self.stopRecordingAfterRelease(for: .transcription, label: "Transcription")
+ case .automatic:
+ self.isKeyPressed = false
+ self.handleAutomaticKeyRelease(for: .transcription, label: "Transcription")
+ case .toggle:
+ break
+ }
+ }
+
private func isRecordingTargetActive(for type: HotkeyHoldModeType) -> Bool {
switch type {
case .transcription:
@@ -1269,6 +1308,7 @@ final class GlobalHotkeyManager: NSObject {
self.isCommandModeKeyPressed = false
self.isRewriteKeyPressed = false
self.isPromptAssignmentKeyPressed = false
+ self.activePrimaryMouseButton = nil
if shouldStopActiveHold {
switch reason {
@@ -1595,6 +1635,7 @@ final class GlobalHotkeyManager: NSObject {
self.isCommandModeKeyPressed = false
self.isRewriteKeyPressed = false
self.isPromptAssignmentKeyPressed = false
+ self.activePrimaryMouseButton = nil
if shouldStopActivePress {
self.stopRecordingIfNeeded()
@@ -1694,27 +1735,19 @@ final class GlobalHotkeyManager: NSObject {
}
private func matchesShortcut(keyCode: UInt16, modifiers: NSEvent.ModifierFlags) -> Bool {
- let relevantModifiers: NSEvent.ModifierFlags = modifiers.intersection([.function, .command, .option, .control, .shift])
- let shortcutModifiers = self.shortcut.modifierFlags.intersection([.function, .command, .option, .control, .shift])
- return keyCode == self.shortcut.keyCode && relevantModifiers == shortcutModifiers
+ self.shortcut.matches(keyCode: keyCode, modifiers: modifiers)
}
private func matchesPromptModeShortcut(keyCode: UInt16, modifiers: NSEvent.ModifierFlags) -> Bool {
- let relevantModifiers: NSEvent.ModifierFlags = modifiers.intersection([.function, .command, .option, .control, .shift])
- let shortcutModifiers = self.promptModeShortcut.modifierFlags.intersection([.function, .command, .option, .control, .shift])
- return keyCode == self.promptModeShortcut.keyCode && relevantModifiers == shortcutModifiers
+ self.promptModeShortcut.matches(keyCode: keyCode, modifiers: modifiers)
}
private func matchesCommandModeShortcut(keyCode: UInt16, modifiers: NSEvent.ModifierFlags) -> Bool {
- let relevantModifiers: NSEvent.ModifierFlags = modifiers.intersection([.function, .command, .option, .control, .shift])
- let shortcutModifiers = self.commandModeShortcut.modifierFlags.intersection([.function, .command, .option, .control, .shift])
- return keyCode == self.commandModeShortcut.keyCode && relevantModifiers == shortcutModifiers
+ self.commandModeShortcut.matches(keyCode: keyCode, modifiers: modifiers)
}
private func matchesRewriteModeShortcut(keyCode: UInt16, modifiers: NSEvent.ModifierFlags) -> Bool {
- let relevantModifiers: NSEvent.ModifierFlags = modifiers.intersection([.function, .command, .option, .control, .shift])
- let shortcutModifiers = self.rewriteModeShortcut.modifierFlags.intersection([.function, .command, .option, .control, .shift])
- return keyCode == self.rewriteModeShortcut.keyCode && relevantModifiers == shortcutModifiers
+ self.rewriteModeShortcut.matches(keyCode: keyCode, modifiers: modifiers)
}
func isEventTapEnabled() -> Bool {
diff --git a/Sources/Fluid/UI/SettingsView.swift b/Sources/Fluid/UI/SettingsView.swift
index 323a8a86..bf33e76d 100644
--- a/Sources/Fluid/UI/SettingsView.swift
+++ b/Sources/Fluid/UI/SettingsView.swift
@@ -653,11 +653,11 @@ struct SettingsView: View {
// MARK: - Shortcuts Section
VStack(alignment: .leading, spacing: 8) {
- Text("Keyboard Shortcuts")
+ Text("Shortcuts")
.font(.subheadline.weight(.medium))
.foregroundStyle(.secondary)
- Text("Changes usually apply immediately. If a new shortcut does not respond, restart FluidVoice.")
+ Text("Primary dictation can use keys or an allowed mouse button. Changes usually apply immediately.")
.font(.caption)
.foregroundStyle(.tertiary)
@@ -666,7 +666,7 @@ struct SettingsView: View {
icon: "mic.fill",
iconColor: .secondary,
title: "Primary Dictation Shortcut",
- description: "Defaults to raw transcription, but can use Off, Default, or any custom prompt."
+ description: "Use a keyboard shortcut, side mouse button, or modified mouse click."
),
shortcut: self.hotkeyShortcut,
isRecording: self.isRecording(.primaryDictation),
diff --git a/Tests/FluidDictationIntegrationTests/HotkeyShortcutTests.swift b/Tests/FluidDictationIntegrationTests/HotkeyShortcutTests.swift
new file mode 100644
index 00000000..2cac7053
--- /dev/null
+++ b/Tests/FluidDictationIntegrationTests/HotkeyShortcutTests.swift
@@ -0,0 +1,71 @@
+import AppKit
+@testable import FluidVoice_Debug
+import Foundation
+import XCTest
+
+final class HotkeyShortcutTests: XCTestCase {
+ func testLegacyKeyboardShortcutPayloadDefaultsToKeyboardKind() throws {
+ let json = #"{"keyCode":61,"modifierFlagsRawValue":0}"#
+ let data = try XCTUnwrap(json.data(using: .utf8))
+
+ let shortcut = try JSONDecoder().decode(HotkeyShortcut.self, from: data)
+
+ XCTAssertEqual(shortcut.kind, .keyboard)
+ XCTAssertFalse(shortcut.isMouseShortcut)
+ XCTAssertEqual(shortcut.keyCode, 61)
+ XCTAssertTrue(shortcut.matches(keyCode: 61, modifiers: NSEvent.ModifierFlags()))
+ }
+
+ func testKeyboardPayloadIgnoresStrayMouseButtonField() throws {
+ let json = #"{"kind":"keyboard","keyCode":0,"modifierFlagsRawValue":0,"mouseButton":3}"#
+ let data = try XCTUnwrap(json.data(using: .utf8))
+
+ let shortcut = try JSONDecoder().decode(HotkeyShortcut.self, from: data)
+
+ XCTAssertFalse(shortcut.isMouseShortcut)
+ XCTAssertEqual(shortcut.displayString, "A")
+ XCTAssertFalse(shortcut.matchesMouse(button: 3, modifiers: NSEvent.ModifierFlags()))
+ }
+
+ func testMouseShortcutRoundTripsAndMatchesOnlyMouseEvents() throws {
+ let shortcut = HotkeyShortcut(mouseButton: 3, modifierFlags: [.option])
+
+ let data = try JSONEncoder().encode(shortcut)
+ let decoded = try JSONDecoder().decode(HotkeyShortcut.self, from: data)
+
+ XCTAssertEqual(decoded.kind, .mouse)
+ XCTAssertTrue(decoded.isMouseShortcut)
+ XCTAssertEqual(decoded.mouseButton, 3)
+ XCTAssertTrue(decoded.matchesMouse(button: 3, modifiers: [.option]))
+ XCTAssertFalse(decoded.matchesMouse(button: 3, modifiers: NSEvent.ModifierFlags()))
+ XCTAssertFalse(decoded.matches(keyCode: 0, modifiers: [.option]))
+ }
+
+ func testUnmodifiedLeftAndRightClicksDoNotMatchMouseEvents() {
+ let leftClick = HotkeyShortcut(mouseButton: 0, modifierFlags: NSEvent.ModifierFlags())
+ let rightClick = HotkeyShortcut(mouseButton: 1, modifierFlags: NSEvent.ModifierFlags())
+ let sideButton = HotkeyShortcut(mouseButton: 3, modifierFlags: NSEvent.ModifierFlags())
+ let modifiedLeftClick = HotkeyShortcut(mouseButton: 0, modifierFlags: [.control])
+
+ XCTAssertTrue(leftClick.isUnmodifiedLeftOrRightClick)
+ XCTAssertTrue(rightClick.isUnmodifiedLeftOrRightClick)
+ XCTAssertFalse(leftClick.matchesMouse(button: 0, modifiers: NSEvent.ModifierFlags()))
+ XCTAssertFalse(rightClick.matchesMouse(button: 1, modifiers: NSEvent.ModifierFlags()))
+ XCTAssertTrue(sideButton.matchesMouse(button: 3, modifiers: NSEvent.ModifierFlags()))
+ XCTAssertTrue(modifiedLeftClick.matchesMouse(button: 0, modifiers: [.control]))
+ }
+
+ func testMouseShortcutDisplayIncludesModifiers() {
+ let shortcut = HotkeyShortcut(mouseButton: 0, modifierFlags: [.control, .shift])
+
+ XCTAssertEqual(shortcut.displayString, "⌃ + ⇧ + Left Click")
+ }
+
+ func testMouseShortcutDoesNotEqualKeyboardShortcutWithPlaceholderKeyCode() {
+ let mouseShortcut = HotkeyShortcut(mouseButton: 3, modifierFlags: NSEvent.ModifierFlags())
+ let keyboardShortcut = HotkeyShortcut(keyCode: 0, modifierFlags: NSEvent.ModifierFlags())
+
+ XCTAssertEqual(mouseShortcut.displayString, "Mouse 4")
+ XCTAssertNotEqual(mouseShortcut, keyboardShortcut)
+ }
+}