116 lines
4.3 KiB
Swift
116 lines
4.3 KiB
Swift
import Carbon.HIToolbox
|
|
import Foundation
|
|
|
|
/// Carbon's C event handler cannot capture Swift closures, so live handlers are kept in one
|
|
/// process-wide table keyed by the numeric EventHotKeyID Carbon hands back on fire. Safe
|
|
/// because InstallEventHandler on GetApplicationEventTarget() always delivers on the main
|
|
/// thread, and every access here happens either from a @MainActor HotkeyCenter method or from
|
|
/// the C callback below, which this process only ever invokes on the main run loop.
|
|
private final class HotkeyDispatchTable: @unchecked Sendable {
|
|
static let shared = HotkeyDispatchTable()
|
|
private var handlers: [UInt32: @MainActor () -> Void] = [:]
|
|
private init() {}
|
|
func set(_ numericID: UInt32, _ handler: @escaping @MainActor () -> Void) {
|
|
handlers[numericID] = handler
|
|
}
|
|
func remove(_ numericID: UInt32) { handlers.removeValue(forKey: numericID) }
|
|
func fire(_ numericID: UInt32) { MainActor.assumeIsolated { handlers[numericID]?() } }
|
|
}
|
|
|
|
private func shotdeckCarbonHotkeyHandler(
|
|
_ nextHandler: EventHandlerCallRef?, _ event: EventRef?, _ userData: UnsafeMutableRawPointer?
|
|
) -> OSStatus {
|
|
guard let event else { return OSStatus(eventNotHandledErr) }
|
|
var hotKeyID = EventHotKeyID()
|
|
let status = GetEventParameter(event, EventParamName(kEventParamDirectObject),
|
|
EventParamType(typeEventHotKeyID), nil, MemoryLayout<EventHotKeyID>.size, nil, &hotKeyID)
|
|
guard status == noErr else { return status }
|
|
HotkeyDispatchTable.shared.fire(hotKeyID.id)
|
|
return noErr
|
|
}
|
|
|
|
/// Four-character creator code used for every `EventHotKeyID` this process registers.
|
|
private let shotdeckHotKeySignature: OSType = 0x53484F54 // "SHOT"
|
|
|
|
@MainActor
|
|
public final class HotkeyCenter {
|
|
private var bindings: [String: (ref: EventHotKeyRef, numericID: UInt32)] = [:]
|
|
private var nextNumericID: UInt32 = 1
|
|
|
|
private static var didInstallGlobalCarbonHandler = false
|
|
private static var carbonHandlerRef: EventHandlerRef?
|
|
|
|
public init() { HotkeyCenter.installGlobalCarbonHandlerIfNeeded() }
|
|
|
|
/// Registers a hotkey. `id` is a caller-chosen stable identifier. Re-registering the same
|
|
/// `id` first unregisters its previous binding, then attempts the new one (idempotent).
|
|
/// Returns false when Carbon's `RegisterEventHotKey` reports a non-`noErr` status — the
|
|
/// most common cause is the same keyCode+modifiers combination already being claimed
|
|
/// system-wide by this or another process.
|
|
@discardableResult
|
|
public func register(
|
|
id: String,
|
|
keyCode: UInt32,
|
|
modifiers: UInt32,
|
|
handler: @escaping @MainActor () -> Void
|
|
) -> Bool {
|
|
unregister(id: id)
|
|
|
|
let hotKeyID = EventHotKeyID(signature: shotdeckHotKeySignature, id: nextNumericID)
|
|
var ref: EventHotKeyRef?
|
|
let status = RegisterEventHotKey(
|
|
keyCode,
|
|
modifiers,
|
|
hotKeyID,
|
|
GetApplicationEventTarget(),
|
|
0,
|
|
&ref
|
|
)
|
|
guard status == noErr, let ref else {
|
|
return false
|
|
}
|
|
bindings[id] = (ref: ref, numericID: nextNumericID)
|
|
HotkeyDispatchTable.shared.set(nextNumericID, handler)
|
|
nextNumericID += 1
|
|
return true
|
|
}
|
|
|
|
public func unregister(id: String) {
|
|
guard let binding = bindings.removeValue(forKey: id) else { return }
|
|
_ = UnregisterEventHotKey(binding.ref)
|
|
HotkeyDispatchTable.shared.remove(binding.numericID)
|
|
}
|
|
|
|
public func unregisterAll() {
|
|
let ids = Array(bindings.keys)
|
|
for id in ids {
|
|
unregister(id: id)
|
|
}
|
|
}
|
|
|
|
/// Installs the process-wide Carbon hot-key pressed handler exactly once.
|
|
private static func installGlobalCarbonHandlerIfNeeded() {
|
|
guard !didInstallGlobalCarbonHandler else { return }
|
|
didInstallGlobalCarbonHandler = true
|
|
|
|
var handlerRef: EventHandlerRef?
|
|
var eventTypes = [
|
|
EventTypeSpec(
|
|
eventClass: OSType(kEventClassKeyboard),
|
|
eventKind: OSType(kEventHotKeyPressed)
|
|
)
|
|
]
|
|
let status = InstallEventHandler(
|
|
GetApplicationEventTarget(),
|
|
shotdeckCarbonHotkeyHandler,
|
|
1,
|
|
&eventTypes,
|
|
nil,
|
|
&handlerRef
|
|
)
|
|
if status == noErr {
|
|
carbonHandlerRef = handlerRef
|
|
}
|
|
}
|
|
}
|