wehub-resource-sync
433 lines
15 KiB
Swift
433 lines
15 KiB
Swift
import AppKit
|
|
import SwiftUI
|
|
|
|
public enum PluginShortcutRecordingResult: Equatable {
|
|
case accepted
|
|
case rejected(String)
|
|
|
|
public static func from(errorMessage: String?) -> PluginShortcutRecordingResult {
|
|
if let errorMessage {
|
|
return .rejected(errorMessage)
|
|
}
|
|
|
|
return .accepted
|
|
}
|
|
}
|
|
|
|
@MainActor
|
|
private final class PluginShortcutRecorderDisplayState: ObservableObject {
|
|
@Published var previewText = PluginKitLocalization.shortcutRecorderPreviewPlaceholder
|
|
@Published private(set) var showEscHint = false
|
|
@Published private(set) var conflictMessage: String?
|
|
@Published private(set) var shakeOffset: CGFloat = 0
|
|
@Published private(set) var isShaking = false
|
|
|
|
func triggerShake(conflict: String? = nil) {
|
|
withAnimation(.spring(response: 0.3, dampingFraction: 0.75)) {
|
|
showEscHint = true
|
|
if let conflict {
|
|
conflictMessage = conflict
|
|
}
|
|
}
|
|
|
|
isShaking = true
|
|
let steps: [(CGFloat, Double)] = [
|
|
(10, 0.00), (-8, 0.06), (7, 0.12), (-5, 0.18), (3, 0.24), (0, 0.30)
|
|
]
|
|
|
|
for (offset, delay) in steps {
|
|
DispatchQueue.main.asyncAfter(deadline: .now() + delay) { [weak self] in
|
|
withAnimation(.linear(duration: 0.05)) {
|
|
self?.shakeOffset = offset
|
|
}
|
|
}
|
|
}
|
|
|
|
DispatchQueue.main.asyncAfter(deadline: .now() + 0.38) { [weak self] in
|
|
self?.isShaking = false
|
|
}
|
|
}
|
|
}
|
|
|
|
public struct PluginShortcutRecorderField: View {
|
|
public let displayText: String
|
|
public let placeholder: String
|
|
public let isRecording: Bool
|
|
public let minWidth: CGFloat
|
|
|
|
private var normalizedText: String {
|
|
if displayText.isEmpty || displayText == "None" {
|
|
return placeholder
|
|
}
|
|
|
|
return displayText
|
|
}
|
|
|
|
private var isPlaceholderVisible: Bool {
|
|
normalizedText == placeholder
|
|
}
|
|
|
|
public init(
|
|
displayText: String,
|
|
placeholder: String = PluginKitLocalization.defaultShortcutPlaceholder,
|
|
isRecording: Bool,
|
|
minWidth: CGFloat = 90
|
|
) {
|
|
self.displayText = displayText
|
|
self.placeholder = placeholder
|
|
self.isRecording = isRecording
|
|
self.minWidth = minWidth
|
|
}
|
|
|
|
public var body: some View {
|
|
Text(normalizedText)
|
|
.font(PluginSettingsTheme.Typography.monospacedValue)
|
|
.foregroundStyle(isPlaceholderVisible ? AnyShapeStyle(.tertiary) : AnyShapeStyle(.primary))
|
|
.lineLimit(1)
|
|
.minimumScaleFactor(0.8)
|
|
.padding(.horizontal, PluginSettingsTheme.Spacing.sectionHeaderContent)
|
|
.padding(.vertical, PluginSettingsTheme.Spacing.controlCluster - 3)
|
|
.frame(minWidth: minWidth, alignment: .center)
|
|
.background(
|
|
RoundedRectangle(cornerRadius: PluginSettingsTheme.Radius.field, style: .continuous)
|
|
.fill(PluginSettingsTheme.Palette.fieldBackground)
|
|
)
|
|
.overlay(
|
|
RoundedRectangle(cornerRadius: PluginSettingsTheme.Radius.field, style: .continuous)
|
|
.strokeBorder(
|
|
isRecording ? Color.accentColor : PluginSettingsTheme.Palette.cardBorder,
|
|
lineWidth: isRecording ? 1.5 : PluginSettingsTheme.Stroke.standard
|
|
)
|
|
)
|
|
}
|
|
}
|
|
|
|
public struct PluginShortcutRecorder: View {
|
|
public let title: String
|
|
public let displayText: String
|
|
public let placeholder: String
|
|
public let minWidth: CGFloat
|
|
public let onRecord: (ShortcutBinding) -> PluginShortcutRecordingResult
|
|
public let onBeginRecording: (() -> Void)?
|
|
public let onEndRecording: (() -> Void)?
|
|
|
|
@State private var isPresented = false
|
|
|
|
public init(
|
|
title: String,
|
|
displayText: String,
|
|
placeholder: String = PluginKitLocalization.defaultShortcutPlaceholder,
|
|
minWidth: CGFloat = 90,
|
|
onRecord: @escaping (ShortcutBinding) -> PluginShortcutRecordingResult,
|
|
onBeginRecording: (() -> Void)? = nil,
|
|
onEndRecording: (() -> Void)? = nil
|
|
) {
|
|
self.title = title
|
|
self.displayText = displayText
|
|
self.placeholder = placeholder
|
|
self.minWidth = minWidth
|
|
self.onRecord = onRecord
|
|
self.onBeginRecording = onBeginRecording
|
|
self.onEndRecording = onEndRecording
|
|
}
|
|
|
|
public var body: some View {
|
|
Button {
|
|
isPresented = true
|
|
} label: {
|
|
PluginShortcutRecorderField(
|
|
displayText: displayText,
|
|
placeholder: placeholder,
|
|
isRecording: isPresented,
|
|
minWidth: minWidth
|
|
)
|
|
}
|
|
.buttonStyle(.plain)
|
|
.help(PluginKitLocalization.shortcutRecorderHelp(title: title))
|
|
.accessibilityLabel(Text(title))
|
|
.background {
|
|
GeometryReader { proxy in
|
|
PluginShortcutRecorderPopoverAnchor(
|
|
isPresented: $isPresented,
|
|
onRecord: onRecord,
|
|
onBeginRecording: onBeginRecording,
|
|
onEndRecording: onEndRecording
|
|
)
|
|
.frame(width: max(proxy.size.width, 1), height: max(proxy.size.height, 1))
|
|
.allowsHitTesting(false)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private struct PluginShortcutRecorderPopoverView: View {
|
|
@ObservedObject var displayState: PluginShortcutRecorderDisplayState
|
|
|
|
var body: some View {
|
|
VStack(spacing: 0) {
|
|
Text(displayState.previewText)
|
|
.font(PluginSettingsTheme.Typography.secondaryLabel)
|
|
.foregroundStyle(Color.accentColor)
|
|
.lineLimit(1)
|
|
.padding(.horizontal, PluginSettingsTheme.Spacing.rowContentControl)
|
|
.padding(.vertical, PluginSettingsTheme.Spacing.controlCluster)
|
|
.frame(minWidth: 130, alignment: .center)
|
|
.background(
|
|
RoundedRectangle(cornerRadius: PluginSettingsTheme.Radius.field, style: .continuous)
|
|
.fill(
|
|
displayState.isShaking
|
|
? Color.red.opacity(0.18)
|
|
: PluginSettingsTheme.Palette.recordingBackground
|
|
)
|
|
)
|
|
.offset(x: displayState.shakeOffset)
|
|
|
|
if displayState.conflictMessage != nil || displayState.showEscHint {
|
|
Group {
|
|
if let message = displayState.conflictMessage {
|
|
Text(message)
|
|
.foregroundStyle(.red)
|
|
} else {
|
|
Text(PluginKitLocalization.shortcutRecorderEscHint)
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
}
|
|
.font(PluginSettingsTheme.Typography.statusBadge)
|
|
.padding(.top, PluginSettingsTheme.Spacing.controlCluster)
|
|
.transition(.asymmetric(
|
|
insertion: .opacity.combined(with: .offset(y: -6)),
|
|
removal: .opacity
|
|
))
|
|
}
|
|
}
|
|
.padding(.horizontal, PluginSettingsTheme.Spacing.rowHorizontal)
|
|
.padding(.vertical, PluginSettingsTheme.Spacing.rowContentControl)
|
|
.frame(minWidth: 160)
|
|
}
|
|
}
|
|
|
|
private struct PluginShortcutRecorderPopoverAnchor: NSViewRepresentable {
|
|
@Binding var isPresented: Bool
|
|
let onRecord: (ShortcutBinding) -> PluginShortcutRecordingResult
|
|
var onBeginRecording: (() -> Void)?
|
|
var onEndRecording: (() -> Void)?
|
|
|
|
func makeCoordinator() -> Coordinator {
|
|
Coordinator()
|
|
}
|
|
|
|
func makeNSView(context: Context) -> NSView {
|
|
NSView(frame: .zero)
|
|
}
|
|
|
|
func updateNSView(_ nsView: NSView, context: Context) {
|
|
context.coordinator.update(
|
|
isPresented: isPresented,
|
|
sourceView: nsView,
|
|
onRecord: onRecord,
|
|
onDismiss: { isPresented = false },
|
|
onBeginRecording: onBeginRecording,
|
|
onEndRecording: onEndRecording
|
|
)
|
|
}
|
|
|
|
static func dismantleNSView(_ nsView: NSView, coordinator: Coordinator) {
|
|
coordinator.close()
|
|
}
|
|
|
|
@MainActor
|
|
final class Coordinator: NSObject, NSPopoverDelegate {
|
|
private var popover: NSPopover?
|
|
private var displayState: PluginShortcutRecorderDisplayState?
|
|
private var keyMonitor: Any?
|
|
private var committed = false
|
|
private var wantsPresentation = false
|
|
private var presentationRetryScheduled = false
|
|
private var onRecord: ((ShortcutBinding) -> PluginShortcutRecordingResult)?
|
|
private var onDismiss: (() -> Void)?
|
|
private var onBeginRecording: (() -> Void)?
|
|
private var onEndRecording: (() -> Void)?
|
|
|
|
func update(
|
|
isPresented: Bool,
|
|
sourceView: NSView,
|
|
onRecord: @escaping (ShortcutBinding) -> PluginShortcutRecordingResult,
|
|
onDismiss: @escaping () -> Void,
|
|
onBeginRecording: (() -> Void)?,
|
|
onEndRecording: (() -> Void)?
|
|
) {
|
|
wantsPresentation = isPresented
|
|
self.onRecord = onRecord
|
|
self.onDismiss = onDismiss
|
|
self.onBeginRecording = onBeginRecording
|
|
self.onEndRecording = onEndRecording
|
|
|
|
if isPresented {
|
|
requestPresentation(from: sourceView)
|
|
} else if popover != nil {
|
|
close()
|
|
}
|
|
}
|
|
|
|
func close() {
|
|
wantsPresentation = false
|
|
|
|
guard let popover else {
|
|
cleanup()
|
|
return
|
|
}
|
|
|
|
let dismiss = onDismiss
|
|
let endRecording = onEndRecording
|
|
let wasRecording = displayState != nil
|
|
|
|
popover.delegate = nil
|
|
self.popover = nil
|
|
popover.close()
|
|
cleanup()
|
|
dismiss?()
|
|
if wasRecording {
|
|
endRecording?()
|
|
}
|
|
}
|
|
|
|
func popoverShouldClose(_ popover: NSPopover) -> Bool {
|
|
guard !committed else { return true }
|
|
displayState?.triggerShake()
|
|
return false
|
|
}
|
|
|
|
private func requestPresentation(from sourceView: NSView) {
|
|
guard wantsPresentation, popover == nil else {
|
|
return
|
|
}
|
|
|
|
guard sourceView.window != nil, sourceView.bounds.width > 0, sourceView.bounds.height > 0 else {
|
|
schedulePresentationRetry(from: sourceView)
|
|
return
|
|
}
|
|
|
|
present(from: sourceView)
|
|
}
|
|
|
|
private func schedulePresentationRetry(from sourceView: NSView) {
|
|
guard !presentationRetryScheduled else {
|
|
return
|
|
}
|
|
|
|
presentationRetryScheduled = true
|
|
DispatchQueue.main.async { [weak self, weak sourceView] in
|
|
guard let self else { return }
|
|
self.presentationRetryScheduled = false
|
|
guard let sourceView else { return }
|
|
self.requestPresentation(from: sourceView)
|
|
}
|
|
}
|
|
|
|
private func present(from sourceView: NSView) {
|
|
committed = false
|
|
let state = PluginShortcutRecorderDisplayState()
|
|
displayState = state
|
|
|
|
onBeginRecording?()
|
|
|
|
let content = PluginShortcutRecorderPopoverView(displayState: state)
|
|
let controller = NSHostingController(rootView: content)
|
|
controller.view.layoutSubtreeIfNeeded()
|
|
|
|
let popover = NSPopover()
|
|
popover.contentViewController = controller
|
|
popover.contentSize = controller.view.fittingSize
|
|
popover.behavior = .transient
|
|
popover.animates = true
|
|
popover.delegate = self
|
|
self.popover = popover
|
|
|
|
keyMonitor = NSEvent.addLocalMonitorForEvents(
|
|
matching: NSEvent.EventTypeMask.keyDown
|
|
.union(.flagsChanged)
|
|
.union(.leftMouseDown)
|
|
.union(.rightMouseDown)
|
|
.union(.otherMouseDown)
|
|
.union(.leftMouseUp)
|
|
.union(.rightMouseUp)
|
|
.union(.otherMouseUp)
|
|
.union(.scrollWheel)
|
|
.union(.mouseEntered)
|
|
.union(.mouseExited)
|
|
.union(.mouseMoved)
|
|
) { [weak self] event in
|
|
guard let self else { return event }
|
|
return self.handleEvent(event)
|
|
}
|
|
|
|
let anchorBounds = sourceView.bounds
|
|
popover.show(relativeTo: anchorBounds, of: sourceView, preferredEdge: .maxY)
|
|
}
|
|
|
|
private func handleEvent(_ event: NSEvent) -> NSEvent? {
|
|
switch event.type {
|
|
case .flagsChanged:
|
|
handleFlagsChanged(event)
|
|
return event
|
|
case .keyDown:
|
|
return handleKey(event)
|
|
case .leftMouseDown, .rightMouseDown, .otherMouseDown,
|
|
.leftMouseUp, .rightMouseUp, .otherMouseUp,
|
|
.scrollWheel, .mouseEntered, .mouseExited, .mouseMoved:
|
|
return nil
|
|
default:
|
|
return event
|
|
}
|
|
}
|
|
|
|
private func handleFlagsChanged(_ event: NSEvent) {
|
|
guard popover?.isShown == true else { return }
|
|
let modifiers = ShortcutModifiers.from(event.modifierFlags)
|
|
|
|
displayState?.previewText = modifiers.isEmpty
|
|
? PluginKitLocalization.shortcutRecorderPreviewPlaceholder
|
|
: modifiers.symbolString.map { String($0) }.joined(separator: " + ")
|
|
}
|
|
|
|
private func handleKey(_ event: NSEvent) -> NSEvent? {
|
|
guard popover?.isShown == true else { return event }
|
|
|
|
let modifiers = ShortcutModifiers.from(event.modifierFlags)
|
|
|
|
if event.keyCode == ShortcutKeyCode.escape, modifiers.isEmpty {
|
|
close()
|
|
return nil
|
|
}
|
|
|
|
let binding = ShortcutBinding(keyCode: event.keyCode, modifiers: modifiers)
|
|
guard binding.isValid else { return nil }
|
|
|
|
switch onRecord?(binding) ?? .accepted {
|
|
case .accepted:
|
|
committed = true
|
|
close()
|
|
case let .rejected(message):
|
|
displayState?.triggerShake(conflict: message)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
private func cleanup() {
|
|
if let monitor = keyMonitor {
|
|
NSEvent.removeMonitor(monitor)
|
|
}
|
|
|
|
keyMonitor = nil
|
|
displayState = nil
|
|
committed = false
|
|
presentationRetryScheduled = false
|
|
onRecord = nil
|
|
onDismiss = nil
|
|
onBeginRecording = nil
|
|
onEndRecording = nil
|
|
}
|
|
}
|
|
}
|