wehub-resource-sync
641 lines
20 KiB
Swift
641 lines
20 KiB
Swift
import AppKit
|
|
import ApplicationServices
|
|
import Carbon.HIToolbox
|
|
import Foundation
|
|
import MacToolsPluginKit
|
|
|
|
enum WindowSwitcherConstants {
|
|
static let pluginID = "window-switcher"
|
|
static let shortcutDefinitionID = "switcher"
|
|
static let shortcutActionID = "switch"
|
|
static let accessibilityPermissionID = "accessibility"
|
|
}
|
|
|
|
enum WindowSwitcherMode: String, Codable, CaseIterable, Identifiable {
|
|
case keyWindow
|
|
case directCycle
|
|
|
|
var id: String { rawValue }
|
|
}
|
|
|
|
enum WindowSwitcherSortMode: String, Codable, CaseIterable, Identifiable {
|
|
case recentUse
|
|
case fixed
|
|
|
|
var id: String { rawValue }
|
|
}
|
|
|
|
struct WindowSwitcherConfiguration: Codable, Equatable {
|
|
var isEnabled: Bool
|
|
var mode: WindowSwitcherMode
|
|
var sortMode: WindowSwitcherSortMode
|
|
|
|
init(
|
|
isEnabled: Bool,
|
|
mode: WindowSwitcherMode,
|
|
sortMode: WindowSwitcherSortMode
|
|
) {
|
|
self.isEnabled = isEnabled
|
|
self.mode = mode
|
|
self.sortMode = sortMode
|
|
}
|
|
|
|
init(from decoder: Decoder) throws {
|
|
let container = try decoder.container(keyedBy: CodingKeys.self)
|
|
self.isEnabled = try container.decodeIfPresent(Bool.self, forKey: .isEnabled) ?? true
|
|
self.mode = try container.decodeIfPresent(WindowSwitcherMode.self, forKey: .mode) ?? .keyWindow
|
|
self.sortMode = try container.decodeIfPresent(WindowSwitcherSortMode.self, forKey: .sortMode) ?? .recentUse
|
|
}
|
|
|
|
static let `default` = WindowSwitcherConfiguration(
|
|
isEnabled: true,
|
|
mode: .keyWindow,
|
|
sortMode: .recentUse
|
|
)
|
|
|
|
private enum CodingKeys: String, CodingKey {
|
|
case isEnabled
|
|
case mode
|
|
case sortMode
|
|
}
|
|
}
|
|
|
|
struct WindowSwitcherShortcutBindingState: Codable, Equatable {
|
|
static let currentVersion = 1
|
|
|
|
var version: Int
|
|
var manual: [String: String]
|
|
var automatic: [String: String]
|
|
|
|
init(
|
|
version: Int = currentVersion,
|
|
manual: [String: String] = [:],
|
|
automatic: [String: String] = [:]
|
|
) {
|
|
self.version = version
|
|
self.manual = manual
|
|
self.automatic = automatic
|
|
}
|
|
}
|
|
|
|
enum WindowSwitcherShortcutCustomizationResult {
|
|
case updated([WindowSwitcherAppEntry])
|
|
case conflict
|
|
case unavailable
|
|
}
|
|
|
|
@MainActor
|
|
final class WindowSwitcherStore: ObservableObject {
|
|
private enum Keys {
|
|
static let configuration = "configuration"
|
|
static let shortcutBindings = "shortcut-bindings"
|
|
static let obsoleteShortcutAssignments = "shortcut-assignments"
|
|
}
|
|
|
|
@Published private(set) var configuration: WindowSwitcherConfiguration
|
|
@Published private(set) var shortcutBindings: WindowSwitcherShortcutBindingState
|
|
|
|
private let storage: PluginStorage
|
|
private let encoder = JSONEncoder()
|
|
private let decoder = JSONDecoder()
|
|
|
|
init(storage: PluginStorage) {
|
|
self.storage = storage
|
|
if let data = storage.data(forKey: Keys.configuration),
|
|
let loaded = try? decoder.decode(WindowSwitcherConfiguration.self, from: data) {
|
|
self.configuration = loaded
|
|
} else {
|
|
self.configuration = .default
|
|
}
|
|
|
|
if let data = storage.data(forKey: Keys.shortcutBindings),
|
|
let loaded = try? decoder.decode(WindowSwitcherShortcutBindingState.self, from: data) {
|
|
self.shortcutBindings = loaded
|
|
} else {
|
|
self.shortcutBindings = WindowSwitcherShortcutBindingState()
|
|
}
|
|
storage.removeObject(forKey: Keys.obsoleteShortcutAssignments)
|
|
}
|
|
|
|
func setMode(_ mode: WindowSwitcherMode) {
|
|
guard configuration.mode != mode else {
|
|
return
|
|
}
|
|
|
|
configuration.mode = mode
|
|
persist()
|
|
}
|
|
|
|
func setSortMode(_ sortMode: WindowSwitcherSortMode) {
|
|
guard configuration.sortMode != sortMode else {
|
|
return
|
|
}
|
|
|
|
configuration.sortMode = sortMode
|
|
persist()
|
|
}
|
|
|
|
func setEnabled(_ isEnabled: Bool) {
|
|
guard configuration.isEnabled != isEnabled else {
|
|
return
|
|
}
|
|
|
|
configuration.isEnabled = isEnabled
|
|
persist()
|
|
}
|
|
|
|
private func persist() {
|
|
guard let data = try? encoder.encode(configuration) else {
|
|
return
|
|
}
|
|
|
|
storage.set(data, forKey: Keys.configuration)
|
|
}
|
|
|
|
func assignShortcuts(to entries: [WindowSwitcherAppEntry]) -> [WindowSwitcherAppEntry] {
|
|
let result = WindowSwitcherShortcutAssignment.assignShortcuts(
|
|
to: entries,
|
|
bindingState: shortcutBindings
|
|
)
|
|
|
|
if result.bindingState != shortcutBindings {
|
|
shortcutBindings = result.bindingState
|
|
persistShortcutBindings()
|
|
}
|
|
|
|
return result.entries
|
|
}
|
|
|
|
func setManualShortcut(
|
|
_ rawToken: String?,
|
|
for entryID: String,
|
|
in entries: [WindowSwitcherAppEntry]
|
|
) -> WindowSwitcherShortcutCustomizationResult {
|
|
let identities = WindowSwitcherShortcutAssignment.identities(for: entries)
|
|
guard let targetIndex = entries.firstIndex(where: { $0.id == entryID }),
|
|
identities.indices.contains(targetIndex)
|
|
else {
|
|
return .unavailable
|
|
}
|
|
|
|
let targetIdentity = identities[targetIndex]
|
|
let current = WindowSwitcherShortcutAssignment.assignShortcuts(
|
|
to: entries,
|
|
bindingState: shortcutBindings
|
|
)
|
|
var updatedState = current.bindingState
|
|
|
|
if let rawToken {
|
|
guard let token = WindowSwitcherShortcutAssignment.normalizedManualToken(rawToken) else {
|
|
return .unavailable
|
|
}
|
|
|
|
guard !hasShortcutConflict(
|
|
token,
|
|
targetIdentity: targetIdentity,
|
|
identities: identities,
|
|
current: current
|
|
) else {
|
|
return .conflict
|
|
}
|
|
|
|
updatedState.manual[targetIdentity] = token
|
|
} else {
|
|
updatedState.manual.removeValue(forKey: targetIdentity)
|
|
}
|
|
|
|
let updated = WindowSwitcherShortcutAssignment.assignShortcuts(
|
|
to: entries,
|
|
bindingState: updatedState
|
|
)
|
|
if updated.bindingState != shortcutBindings {
|
|
shortcutBindings = updated.bindingState
|
|
persistShortcutBindings()
|
|
}
|
|
return .updated(updated.entries)
|
|
}
|
|
|
|
func hasShortcutConflict(
|
|
_ rawToken: String,
|
|
for entryID: String,
|
|
in entries: [WindowSwitcherAppEntry]
|
|
) -> Bool {
|
|
guard let token = WindowSwitcherShortcutAssignment.normalizedManualToken(rawToken) else {
|
|
return true
|
|
}
|
|
|
|
let identities = WindowSwitcherShortcutAssignment.identities(for: entries)
|
|
guard let targetIndex = entries.firstIndex(where: { $0.id == entryID }),
|
|
identities.indices.contains(targetIndex)
|
|
else {
|
|
return true
|
|
}
|
|
|
|
let current = WindowSwitcherShortcutAssignment.assignShortcuts(
|
|
to: entries,
|
|
bindingState: shortcutBindings
|
|
)
|
|
return hasShortcutConflict(
|
|
token,
|
|
targetIdentity: identities[targetIndex],
|
|
identities: identities,
|
|
current: current
|
|
)
|
|
}
|
|
|
|
private func hasShortcutConflict(
|
|
_ token: String,
|
|
targetIdentity: String,
|
|
identities: [String],
|
|
current: WindowSwitcherShortcutAssignment.Result
|
|
) -> Bool {
|
|
let conflictsWithSavedManualBinding = current.bindingState.manual.contains {
|
|
identity, assignedToken in
|
|
identity != targetIdentity
|
|
&& WindowSwitcherShortcutAssignment.normalizedManualToken(assignedToken) == token
|
|
}
|
|
let conflictsWithRunningEntry = current.entries.enumerated().contains { index, entry in
|
|
identities[index] != targetIdentity && entry.shortcutToken == token
|
|
}
|
|
return conflictsWithSavedManualBinding || conflictsWithRunningEntry
|
|
}
|
|
|
|
private func persistShortcutBindings() {
|
|
guard let data = try? encoder.encode(shortcutBindings) else {
|
|
return
|
|
}
|
|
|
|
storage.set(data, forKey: Keys.shortcutBindings)
|
|
}
|
|
}
|
|
|
|
struct WindowSwitcherAppEntry: Identifiable {
|
|
let id: String
|
|
let processIdentifier: pid_t
|
|
let bundleIdentifier: String?
|
|
let appName: String
|
|
let windowTitle: String?
|
|
let icon: NSImage?
|
|
let windowElement: AXUIElement?
|
|
let isMinimized: Bool
|
|
var shortcutToken: String?
|
|
|
|
var displayName: String {
|
|
guard let title = cleanWindowTitle else {
|
|
return appName
|
|
}
|
|
|
|
return title
|
|
}
|
|
|
|
var displaySubtitle: String? {
|
|
guard let title = cleanWindowTitle,
|
|
title.caseInsensitiveCompare(appName) != .orderedSame
|
|
else {
|
|
return nil
|
|
}
|
|
|
|
return appName
|
|
}
|
|
|
|
var shortcutDisplay: String? {
|
|
shortcutToken.flatMap(WindowSwitcherSelectionShortcut.init(storageValue:))?.displayValue
|
|
}
|
|
|
|
var isWindowEntry: Bool {
|
|
windowElement != nil
|
|
}
|
|
|
|
var appIdentifier: String {
|
|
if let bundleIdentifier, !bundleIdentifier.isEmpty {
|
|
return "bundle:\(bundleIdentifier)"
|
|
}
|
|
|
|
return "pid:\(processIdentifier)"
|
|
}
|
|
|
|
private var cleanWindowTitle: String? {
|
|
guard let title = windowTitle?.trimmingCharacters(in: .whitespacesAndNewlines),
|
|
!title.isEmpty
|
|
else {
|
|
return nil
|
|
}
|
|
|
|
return title
|
|
}
|
|
}
|
|
|
|
struct WindowSwitcherSelectionShortcut: Equatable {
|
|
private static let commandPrefix = "cmd+"
|
|
|
|
let key: String
|
|
let usesCommand: Bool
|
|
|
|
init?(key: String, usesCommand: Bool) {
|
|
let normalizedKey = key.lowercased()
|
|
guard Self.isAllowedKey(normalizedKey) else {
|
|
return nil
|
|
}
|
|
|
|
self.key = normalizedKey
|
|
self.usesCommand = usesCommand
|
|
}
|
|
|
|
init?(storageValue: String) {
|
|
let normalized = storageValue.lowercased()
|
|
let usesCommand = normalized.hasPrefix(Self.commandPrefix)
|
|
let key = usesCommand
|
|
? String(normalized.dropFirst(Self.commandPrefix.count))
|
|
: normalized
|
|
self.init(key: key, usesCommand: usesCommand)
|
|
}
|
|
|
|
var storageValue: String {
|
|
usesCommand ? Self.commandPrefix + key : key
|
|
}
|
|
|
|
var displayValue: String {
|
|
(usesCommand ? "⌘" : "") + key.uppercased()
|
|
}
|
|
|
|
private static func isAllowedKey(_ key: String) -> Bool {
|
|
guard key.unicodeScalars.count == 1,
|
|
let scalar = key.unicodeScalars.first
|
|
else {
|
|
return false
|
|
}
|
|
|
|
return (scalar.value >= 97 && scalar.value <= 122)
|
|
|| (scalar.value >= 48 && scalar.value <= 57)
|
|
}
|
|
}
|
|
|
|
extension WindowSwitcherAppEntry: Equatable {
|
|
static func == (lhs: WindowSwitcherAppEntry, rhs: WindowSwitcherAppEntry) -> Bool {
|
|
lhs.id == rhs.id
|
|
&& lhs.displayName == rhs.displayName
|
|
&& lhs.displaySubtitle == rhs.displaySubtitle
|
|
&& lhs.shortcutToken == rhs.shortcutToken
|
|
}
|
|
}
|
|
|
|
enum WindowSwitcherShortcutAssignment {
|
|
struct Result {
|
|
let entries: [WindowSwitcherAppEntry]
|
|
let bindingState: WindowSwitcherShortcutBindingState
|
|
}
|
|
|
|
private struct Target {
|
|
let index: Int
|
|
let identity: String
|
|
let preferredToken: String?
|
|
}
|
|
|
|
static let letterKeyOrder: [String] = [
|
|
"f", "j", "d", "k", "s", "l", "a", "g", "h",
|
|
"e", "i", "r", "u", "w", "o", "q", "p",
|
|
"c", "m", "v", "n", "x", "b", "z", "t", "y",
|
|
]
|
|
static let digitKeyOrder: [String] = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "0"]
|
|
static let maximumShortcutCount = (letterKeyOrder.count + digitKeyOrder.count) * 2
|
|
|
|
static func assignShortcuts(to entries: [WindowSwitcherAppEntry]) -> [WindowSwitcherAppEntry] {
|
|
assignShortcuts(to: entries, bindingState: WindowSwitcherShortcutBindingState()).entries
|
|
}
|
|
|
|
static func assignShortcuts(
|
|
to entries: [WindowSwitcherAppEntry],
|
|
bindingState: WindowSwitcherShortcutBindingState
|
|
) -> Result {
|
|
guard !entries.isEmpty else {
|
|
return Result(entries: [], bindingState: bindingState)
|
|
}
|
|
|
|
let targets = assignmentTargets(for: entries)
|
|
let reservedManualTokens = Set(bindingState.manual.values.compactMap(normalizedManualToken))
|
|
let availableTokens = shortcutTokens(count: maximumShortcutCount)
|
|
var assignedTokens = Array<String?>(repeating: nil, count: entries.count)
|
|
var activeManualTokens = Set<String>()
|
|
var usedTokens = reservedManualTokens
|
|
|
|
for target in targets {
|
|
guard let token = bindingState.manual[target.identity].flatMap(normalizedManualToken),
|
|
activeManualTokens.insert(token).inserted
|
|
else {
|
|
continue
|
|
}
|
|
|
|
assignedTokens[target.index] = token
|
|
}
|
|
|
|
for target in targets where assignedTokens[target.index] == nil {
|
|
guard let token = bindingState.automatic[target.identity].flatMap(normalizedShortcutToken),
|
|
!usedTokens.contains(token)
|
|
else {
|
|
continue
|
|
}
|
|
|
|
assignedTokens[target.index] = token
|
|
usedTokens.insert(token)
|
|
}
|
|
|
|
for target in targets where assignedTokens[target.index] == nil {
|
|
guard let token = target.preferredToken,
|
|
!usedTokens.contains(token)
|
|
else {
|
|
continue
|
|
}
|
|
|
|
assignedTokens[target.index] = token
|
|
usedTokens.insert(token)
|
|
}
|
|
|
|
for target in targets where assignedTokens[target.index] == nil {
|
|
guard let token = availableTokens.first(where: { !usedTokens.contains($0) }) else {
|
|
continue
|
|
}
|
|
|
|
assignedTokens[target.index] = token
|
|
usedTokens.insert(token)
|
|
}
|
|
|
|
let assignedEntries = entries.enumerated().map { index, entry in
|
|
var copy = entry
|
|
copy.shortcutToken = assignedTokens[index]
|
|
return copy
|
|
}
|
|
let updatedState = updatedBindingState(
|
|
from: bindingState,
|
|
targets: targets,
|
|
assignedTokens: assignedTokens
|
|
)
|
|
return Result(entries: assignedEntries, bindingState: updatedState)
|
|
}
|
|
|
|
static func shortcutTokens(count: Int) -> [String] {
|
|
guard count > 0 else {
|
|
return []
|
|
}
|
|
|
|
let plainTokens = letterKeyOrder + digitKeyOrder
|
|
let commandTokens = plainTokens.map { "cmd+\($0)" }
|
|
return Array((plainTokens + commandTokens).prefix(count))
|
|
}
|
|
|
|
static func identities(for entries: [WindowSwitcherAppEntry]) -> [String] {
|
|
assignmentTargets(for: entries).map(\.identity)
|
|
}
|
|
|
|
static func normalizedManualToken(_ token: String) -> String? {
|
|
WindowSwitcherSelectionShortcut(storageValue: token)?.storageValue
|
|
}
|
|
|
|
private static func assignmentTargets(for entries: [WindowSwitcherAppEntry]) -> [Target] {
|
|
var appOccurrences: [String: Int] = [:]
|
|
|
|
return entries.enumerated().map { index, entry in
|
|
let appIdentifier = entry.appIdentifier
|
|
let occurrence = appOccurrences[appIdentifier, default: 0]
|
|
appOccurrences[appIdentifier] = occurrence + 1
|
|
return Target(
|
|
index: index,
|
|
identity: occurrence == 0
|
|
? appIdentifier
|
|
: "\(appIdentifier)#window:\(occurrence + 1)",
|
|
preferredToken: occurrence == 0 ? preferredSingleKeyToken(for: entry) : nil
|
|
)
|
|
}
|
|
}
|
|
|
|
private static func updatedBindingState(
|
|
from bindingState: WindowSwitcherShortcutBindingState,
|
|
targets: [Target],
|
|
assignedTokens: [String?]
|
|
) -> WindowSwitcherShortcutBindingState {
|
|
var state = bindingState
|
|
state.version = WindowSwitcherShortcutBindingState.currentVersion
|
|
let validManualBindings = state.manual.compactMapValues(normalizedManualToken)
|
|
state.manual = validManualBindings
|
|
let manualIdentities = Set(validManualBindings.keys)
|
|
let manualTokens = Set(validManualBindings.values)
|
|
var activeTokens = Set<String>()
|
|
var activeIdentities = Set<String>()
|
|
|
|
for target in targets {
|
|
guard let token = assignedTokens[target.index]
|
|
else {
|
|
continue
|
|
}
|
|
|
|
activeTokens.insert(token)
|
|
guard !manualIdentities.contains(target.identity) else {
|
|
continue
|
|
}
|
|
|
|
state.automatic[target.identity] = token
|
|
activeIdentities.insert(target.identity)
|
|
}
|
|
|
|
for (identity, rawToken) in state.automatic {
|
|
guard let token = normalizedShortcutToken(rawToken) else {
|
|
state.automatic.removeValue(forKey: identity)
|
|
continue
|
|
}
|
|
|
|
let conflictsWithManual = !manualIdentities.contains(identity) && manualTokens.contains(token)
|
|
let conflictsWithActive = !activeIdentities.contains(identity)
|
|
&& !manualIdentities.contains(identity)
|
|
&& activeTokens.contains(token)
|
|
if conflictsWithManual || conflictsWithActive {
|
|
state.automatic.removeValue(forKey: identity)
|
|
}
|
|
}
|
|
|
|
guard state.automatic.count > 256 else {
|
|
return state
|
|
}
|
|
|
|
let retainedIdentities = activeIdentities.union(manualIdentities)
|
|
let retained = state.automatic.filter { retainedIdentities.contains($0.key) }
|
|
let inactive = state.automatic
|
|
.filter { !retainedIdentities.contains($0.key) }
|
|
.sorted { $0.key < $1.key }
|
|
.prefix(max(0, 256 - retained.count))
|
|
state.automatic = inactive.reduce(into: retained) { result, item in
|
|
result[item.key] = item.value
|
|
}
|
|
return state
|
|
}
|
|
|
|
private static func preferredSingleKeyToken(for entry: WindowSwitcherAppEntry) -> String? {
|
|
let candidates = [
|
|
entry.appName,
|
|
entry.bundleIdentifier?.split(separator: ".").last.map(String.init),
|
|
entry.bundleIdentifier,
|
|
].compactMap { $0 }
|
|
|
|
for candidate in candidates {
|
|
if let token = firstASCIIKey(in: candidate) {
|
|
return token
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
private static func firstASCIIKey(in text: String) -> String? {
|
|
for scalar in text.lowercased().unicodeScalars {
|
|
guard scalar.value >= 97, scalar.value <= 122 else {
|
|
continue
|
|
}
|
|
|
|
return String(Character(scalar))
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
private static func normalizedShortcutToken(_ token: String) -> String? {
|
|
WindowSwitcherSelectionShortcut(storageValue: token)?.storageValue
|
|
}
|
|
}
|
|
|
|
enum WindowSwitcherShortcutBindingStore {
|
|
static let defaultBinding = ShortcutBinding(
|
|
keyCode: UInt16(kVK_Tab),
|
|
modifiers: .command
|
|
)
|
|
|
|
private static let defaultsKey = "shortcut.customization.\(itemID)"
|
|
|
|
static var itemID: String {
|
|
"\(WindowSwitcherConstants.pluginID).shortcut.\(WindowSwitcherConstants.shortcutDefinitionID)"
|
|
}
|
|
|
|
static func resolvedBinding(userDefaults: UserDefaults = .standard) -> ShortcutBinding? {
|
|
guard let data = userDefaults.data(forKey: defaultsKey) else {
|
|
return defaultBinding
|
|
}
|
|
|
|
do {
|
|
let customization = try JSONDecoder().decode(ShortcutCustomization.self, from: data)
|
|
return ShortcutStoreResolve.resolve(customization: customization, defaultBinding: defaultBinding)
|
|
} catch {
|
|
return defaultBinding
|
|
}
|
|
}
|
|
}
|
|
|
|
private enum ShortcutStoreResolve {
|
|
static func resolve(customization: ShortcutCustomization, defaultBinding: ShortcutBinding?) -> ShortcutBinding? {
|
|
switch customization {
|
|
case .inheritDefault:
|
|
return defaultBinding
|
|
case let .custom(binding):
|
|
return binding
|
|
case .cleared:
|
|
return nil
|
|
}
|
|
}
|
|
}
|