Something went wrong. Try again.
An auto tiler for macOS
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257import Foundationimport ParcelConfigimport ParcelCoreimport ParcelPlatform
@MainActorfinal class AppSetupShortcuts { enum Operation: String, Sendable { case register, unregister }
enum Issue: Error, LocalizedError { case invalidShortcut(setupID: UUID, shortcut: String, cause: KeyChordParseError) case duplicateSetupID(UUID) case duplicateShortcut(chord: KeyChord, setupIDs: [UUID]) case reservedShortcut(chord: KeyChord, setupID: UUID) case registeredShortcut(chord: KeyChord, setupID: UUID) case operation(hotKey: HotKey, operation: Operation, cause: any Error) case unconfirmed(hotKey: HotKey, operation: Operation) case interrupted(cause: any Error)
var errorDescription: String? { switch self { case .invalidShortcut(_, let shortcut, let cause): AppText.detail("Invalid setup shortcut: %@.", "\(shortcut) — \(cause.localizedDescription)").message case .duplicateSetupID(let id): AppText.detail("Setup shortcut identity is duplicated: %@.", id.uuidString).message case .duplicateShortcut(let chord, _): AppText.detail("Multiple setups use the same shortcut: %@.", chord.description).message case .reservedShortcut(let chord, _): AppText.detail("Setup shortcut is reserved by configuration: %@.", chord.description).message case .registeredShortcut(let chord, _): AppText.detail("Setup shortcut is already registered elsewhere: %@.", chord.description).message case .operation(let hotKey, let operation, let cause): AppText.detail( operation == .register ? "Setup shortcut could not be registered: %@." : "Setup shortcut could not be unregistered: %@.", "\(hotKey) — \(cause.localizedDescription)" ).message case .interrupted(let cause): AppText.detail("Setup shortcut reload was interrupted: %@.", cause.localizedDescription).message case .unconfirmed(let hotKey, let operation): AppText.detail( operation == .register ? "Setup shortcut registration was not confirmed: %@." : "Setup shortcut removal was not confirmed: %@.", hotKey.description ).message } } }
struct Failure: Error, LocalizedError { let issues: [Issue] let rollbackIssues: [Issue]
var errorDescription: String? { let details = issues.map(\.localizedDescription).joined(separator: "\n") guard !rollbackIssues.isEmpty else { return details } return details + "\n" + AppText.detail( "Setup shortcut rollback was incomplete: %@.", rollbackIssues.map(\.localizedDescription).joined(separator: "\n") ).message } }
private struct Binding { let setupID: UUID let chord: KeyChord var hotKey: HotKey { HotKey(keyCode: chord.keyCode, modifiers: HotKey.Modifiers(rawValue: UInt32(chord.modifiers.rawValue))) } }
private let register: @MainActor (HotKey) throws -> Void private let unregister: @MainActor (HotKey) throws -> Void private let isRegistered: @MainActor (HotKey) -> Bool private let isReserved: @MainActor (HotKey) -> Bool private var owned: Set<HotKey> = [] private(set) var actions: [HotKey: UUID] = [:]
init( register: @escaping @MainActor (HotKey) throws -> Void, unregister: @escaping @MainActor (HotKey) throws -> Void, isRegistered: @escaping @MainActor (HotKey) -> Bool, isReserved: @escaping @MainActor (HotKey) -> Bool = { _ in false } ) { self.register = register self.unregister = unregister self.isRegistered = isRegistered self.isReserved = isReserved }
@discardableResult func reload(setups: [SavedSetup], shortcutsEnabled: Bool, reserved: Set<HotKey>) throws -> [HotKey: UUID] { guard shortcutsEnabled else { try clear() return actions } try Task.checkCancellation() reconcile() try removeReservedRegistrations() let bindings = try desiredBindings(setups: setups, reserved: reserved) let desired = Dictionary(uniqueKeysWithValues: bindings.map { ($0.hotKey, $0.setupID) }) let previous = actions let previousOwned = owned var issues: [Issue] = [] do { for key in sorted(Set(desired.keys).subtracting(owned)) { try Task.checkCancellation() if let issue = perform(.register, key: key) { issues.append(issue) } } if issues.isEmpty { for key in sorted(owned.subtracting(desired.keys)) { try Task.checkCancellation() if let issue = perform(.unregister, key: key) { issues.append(issue) } } } } catch { let rollbackIssues = restore(previousOwned) actions = previous.filter { owned.contains($0.key) && isRegistered($0.key) } if rollbackIssues.isEmpty { throw error } throw Failure( issues: issues + [.interrupted(cause: error)], rollbackIssues: rollbackIssues) } if !issues.isEmpty { let rollbackIssues = restore(previousOwned) actions = previous.filter { owned.contains($0.key) && isRegistered($0.key) } throw Failure(issues: issues, rollbackIssues: rollbackIssues) } actions = desired return actions }
func action(for press: HotKeyPress) -> UUID? { guard !press.isRepeat, !press.isReverse, !isReserved(press.hotKey), owned.contains(press.hotKey), isRegistered(press.hotKey) else { return nil } return actions[press.hotKey] }
func clear() throws { actions.removeAll() reconcile() var issues: [Issue] = [] for key in sorted(owned) { try Task.checkCancellation() if let issue = perform(.unregister, key: key) { issues.append(issue) } } if !issues.isEmpty { throw Failure(issues: issues, rollbackIssues: []) } }
private func desiredBindings(setups: [SavedSetup], reserved: Set<HotKey>) throws -> [Binding] { var issues: [Issue] = [] var seenIDs: Set<UUID> = [] var duplicateIDs: Set<UUID> = [] var bindings: [Binding] = [] for setup in setups { if !seenIDs.insert(setup.id).inserted, duplicateIDs.insert(setup.id).inserted { issues.append(.duplicateSetupID(setup.id)) } guard let shortcut = setup.shortcut else { continue } do { let binding = Binding(setupID: setup.id, chord: try KeyChord(parsing: shortcut)) if !isReserved(binding.hotKey) { bindings.append(binding) } } catch { issues.append(.invalidShortcut(setupID: setup.id, shortcut: shortcut, cause: error)) } } let grouped = Dictionary(grouping: bindings, by: \.hotKey) for key in sorted(Set(grouped.keys)) { guard let group = grouped[key], let first = group.first else { preconditionFailure("A grouped setup shortcut must contain a binding") } if group.count > 1 { issues.append(.duplicateShortcut(chord: first.chord, setupIDs: group.map(\.setupID))) } for binding in group { if reserved.contains(key) { issues.append(.reservedShortcut(chord: binding.chord, setupID: binding.setupID)) } if !owned.contains(key), isRegistered(key) { issues.append(.registeredShortcut(chord: binding.chord, setupID: binding.setupID)) } } } if !issues.isEmpty { throw Failure(issues: issues, rollbackIssues: []) } return bindings }
private func removeReservedRegistrations() throws { let keys = owned.filter(isReserved) for key in keys { actions.removeValue(forKey: key) } var issues: [Issue] = [] for key in sorted(keys) { if let issue = perform(.unregister, key: key) { issues.append(issue) } } // A reservation must not be restored by a later transactional reload failure. if !issues.isEmpty { throw Failure(issues: issues, rollbackIssues: []) } }
private func reconcile() { owned = owned.filter(isRegistered) actions = actions.filter { owned.contains($0.key) } }
private func perform(_ operation: Operation, key: HotKey) -> Issue? { do { switch operation { case .register: // Some native failures can remove registrations between reloads. guard !isRegistered(key) else { return .operation(hotKey: key, operation: operation, cause: InputError.duplicateHotKey(key)) } try register(key) if isRegistered(key) { owned.insert(key) } else { return .unconfirmed(hotKey: key, operation: operation) } case .unregister: try unregister(key) if !isRegistered(key) { owned.remove(key) } else { return .unconfirmed(hotKey: key, operation: operation) } } return nil } catch { // Keep ownership accurate even if a backend throws after changing its registration. if isRegistered(key) { owned.insert(key) } else { owned.remove(key) } return .operation(hotKey: key, operation: operation, cause: error) } }
private func restore(_ previousOwned: Set<HotKey>) -> [Issue] { var issues: [Issue] = [] for key in sorted(owned.subtracting(previousOwned)) { if let issue = perform(.unregister, key: key) { issues.append(issue) } } for key in sorted(previousOwned.subtracting(owned)) { if let issue = perform(.register, key: key) { issues.append(issue) } } return issues }
private func sorted(_ keys: Set<HotKey>) -> [HotKey] { keys.sorted { if $0.keyCode != $1.keyCode { return $0.keyCode < $1.keyCode } return $0.modifiers.rawValue < $1.modifiers.rawValue } }}