ggbond268--mactools
wehub-resource-sync
844 行
28 KiB
Swift
844 行
28 KiB
Swift
import AppKit
|
|
import SwiftUI
|
|
|
|
private enum WindowSwitcherOverlayPresentation {
|
|
case direct
|
|
case keyWindow
|
|
}
|
|
|
|
enum WindowSwitcherOverlayMetrics {
|
|
static let cornerRadius: CGFloat = 22
|
|
static let iconSize: CGFloat = 60
|
|
static let iconLayoutSize: CGFloat = 80
|
|
static let iconHighlightPadding: CGFloat = 2
|
|
static let iconHighlightSize = iconSize + iconHighlightPadding * 2
|
|
static let iconHighlightCornerRadius: CGFloat = 14
|
|
static let quitButtonSize: CGFloat = 18
|
|
static let quitButtonGap: CGFloat = 1
|
|
static let horizontalSpacing: CGFloat = 14
|
|
static let verticalSpacing: CGFloat = 12
|
|
static let panelHorizontalPadding: CGFloat = 20
|
|
static let panelVerticalPadding: CGFloat = 18
|
|
static let directTopSpacing: CGFloat = 14
|
|
static let shortcutHeight: CGFloat = 22
|
|
static let shortcutContentSpacing: CGFloat = 7
|
|
static let iconLabelSpacing: CGFloat = 6
|
|
static let labelAreaHeight: CGFloat = 27
|
|
static let tileContentHeight = iconLayoutSize + iconLabelSpacing + labelAreaHeight
|
|
static let directTileWidth: CGFloat = 106
|
|
static let keyWindowTileWidth: CGFloat = 112
|
|
static let directTileHeight = directTopSpacing + tileContentHeight
|
|
static let keyWindowTileHeight = shortcutHeight + shortcutContentSpacing + tileContentHeight
|
|
|
|
static func quitButtonCenter(tileWidth: CGFloat, contentTopOffset: CGFloat) -> CGPoint {
|
|
let highlightTopInset = (iconLayoutSize - iconHighlightSize) / 2
|
|
let cornerCenter = CGPoint(
|
|
x: tileWidth / 2 + iconHighlightSize / 2 - iconHighlightCornerRadius,
|
|
y: contentTopOffset + highlightTopInset + iconHighlightCornerRadius
|
|
)
|
|
let diagonalOffset = (
|
|
iconHighlightCornerRadius + quitButtonSize / 2 + quitButtonGap
|
|
) / sqrt(2)
|
|
return CGPoint(
|
|
x: cornerCenter.x + diagonalOffset,
|
|
y: cornerCenter.y - diagonalOffset
|
|
)
|
|
}
|
|
|
|
static func roundedMaskImage(
|
|
cornerRadius: CGFloat = WindowSwitcherOverlayMetrics.cornerRadius
|
|
) -> NSImage {
|
|
let edge = cornerRadius * 2 + 1
|
|
let image = NSImage(size: NSSize(width: edge, height: edge), flipped: false) { rect in
|
|
NSColor.black.setFill()
|
|
NSBezierPath(
|
|
roundedRect: rect,
|
|
xRadius: cornerRadius,
|
|
yRadius: cornerRadius
|
|
).fill()
|
|
return true
|
|
}
|
|
image.capInsets = NSEdgeInsets(
|
|
top: cornerRadius,
|
|
left: cornerRadius,
|
|
bottom: cornerRadius,
|
|
right: cornerRadius
|
|
)
|
|
image.resizingMode = .stretch
|
|
return image
|
|
}
|
|
}
|
|
|
|
@MainActor
|
|
private final class WindowSwitcherOverlayModel: ObservableObject {
|
|
@Published var entries: [WindowSwitcherAppEntry] = []
|
|
@Published var selectedID: String?
|
|
@Published var recordingEntryID: String?
|
|
@Published var recordingCandidate: String?
|
|
@Published var recordingHasConflict: Bool = false
|
|
@Published var presentation: WindowSwitcherOverlayPresentation = .keyWindow
|
|
@Published var columnCount: Int = 1
|
|
@Published var shortcutText: String = ""
|
|
}
|
|
|
|
@MainActor
|
|
final class WindowSwitcherOverlayController: NSObject, NSWindowDelegate {
|
|
var onSelect: ((WindowSwitcherAppEntry) -> Void)?
|
|
var onQuit: ((WindowSwitcherAppEntry) -> Void)?
|
|
var onShortcutChange: ((WindowSwitcherAppEntry, String?) -> WindowSwitcherShortcutCustomizationResult)?
|
|
var onCancel: (() -> Void)?
|
|
|
|
private final class KeyablePanel: NSPanel {
|
|
override var canBecomeKey: Bool { true }
|
|
override var canBecomeMain: Bool { true }
|
|
}
|
|
|
|
private let model = WindowSwitcherOverlayModel()
|
|
private var panel: KeyablePanel?
|
|
private var keyMonitor: Any?
|
|
private var clickMonitor: Any?
|
|
private var hostingView: NSView?
|
|
private var isClosing = false
|
|
|
|
var isVisible: Bool {
|
|
panel?.isVisible ?? false
|
|
}
|
|
|
|
func showDirect(
|
|
entries: [WindowSwitcherAppEntry],
|
|
selectedID: String?,
|
|
shortcutText: String
|
|
) {
|
|
show(
|
|
entries: entries,
|
|
selectedID: selectedID,
|
|
presentation: .direct,
|
|
shortcutText: shortcutText
|
|
)
|
|
}
|
|
|
|
func showKeyWindow(
|
|
entries: [WindowSwitcherAppEntry],
|
|
shortcutText: String
|
|
) {
|
|
show(
|
|
entries: entries,
|
|
selectedID: nil,
|
|
presentation: .keyWindow,
|
|
shortcutText: shortcutText
|
|
)
|
|
}
|
|
|
|
func updateDirectSelection(selectedID: String?) {
|
|
model.selectedID = selectedID
|
|
}
|
|
|
|
func updateEntries(entries: [WindowSwitcherAppEntry], selectedID: String?) {
|
|
model.entries = entries
|
|
model.selectedID = selectedID
|
|
if let recordingEntryID = model.recordingEntryID,
|
|
!entries.contains(where: { $0.id == recordingEntryID }) {
|
|
cancelShortcutRecording()
|
|
}
|
|
model.columnCount = columnCount(
|
|
for: entries.count,
|
|
presentation: model.presentation,
|
|
screen: targetScreen()
|
|
)
|
|
|
|
if entries.isEmpty {
|
|
hide()
|
|
} else if let panel {
|
|
resize(panel)
|
|
center(panel, on: targetScreen())
|
|
}
|
|
}
|
|
|
|
func hide() {
|
|
model.recordingEntryID = nil
|
|
model.recordingCandidate = nil
|
|
model.recordingHasConflict = false
|
|
removeKeyMonitor()
|
|
removeClickMonitor()
|
|
isClosing = true
|
|
panel?.orderOut(nil)
|
|
isClosing = false
|
|
}
|
|
|
|
private func show(
|
|
entries: [WindowSwitcherAppEntry],
|
|
selectedID: String?,
|
|
presentation: WindowSwitcherOverlayPresentation,
|
|
shortcutText: String
|
|
) {
|
|
let screen = targetScreen()
|
|
model.entries = entries
|
|
model.selectedID = selectedID
|
|
model.recordingEntryID = nil
|
|
model.recordingCandidate = nil
|
|
model.recordingHasConflict = false
|
|
model.presentation = presentation
|
|
model.shortcutText = shortcutText
|
|
model.columnCount = columnCount(for: entries.count, presentation: presentation, screen: screen)
|
|
|
|
let panel = panel ?? makePanel()
|
|
self.panel = panel
|
|
resize(panel)
|
|
center(panel, on: screen)
|
|
|
|
switch presentation {
|
|
case .direct:
|
|
removeKeyMonitor()
|
|
removeClickMonitor()
|
|
panel.orderFrontRegardless()
|
|
case .keyWindow:
|
|
installKeyMonitor()
|
|
installClickMonitor()
|
|
NSApp.activate(ignoringOtherApps: true)
|
|
panel.makeKeyAndOrderFront(nil)
|
|
}
|
|
}
|
|
|
|
private func makePanel() -> KeyablePanel {
|
|
let panel = KeyablePanel(
|
|
contentRect: NSRect(x: 0, y: 0, width: 640, height: 220),
|
|
styleMask: [.borderless, .nonactivatingPanel],
|
|
backing: .buffered,
|
|
defer: false
|
|
)
|
|
panel.level = .popUpMenu
|
|
panel.backgroundColor = .clear
|
|
panel.isOpaque = false
|
|
panel.hasShadow = true
|
|
panel.isMovableByWindowBackground = false
|
|
panel.collectionBehavior = [.canJoinAllSpaces, .fullScreenAuxiliary, .stationary, .ignoresCycle]
|
|
panel.hidesOnDeactivate = false
|
|
panel.isReleasedWhenClosed = false
|
|
panel.animationBehavior = .none
|
|
panel.delegate = self
|
|
|
|
let hostingView = NSHostingView(
|
|
rootView: WindowSwitcherOverlayView(model: model) { [weak self] entry in
|
|
self?.select(entry)
|
|
} onQuit: { [weak self] entry in
|
|
self?.quit(entry)
|
|
} onRecordShortcut: { [weak self] entry in
|
|
self?.beginShortcutRecording(entry)
|
|
} onCancelShortcutRecording: { [weak self] in
|
|
self?.cancelShortcutRecording()
|
|
}
|
|
)
|
|
hostingView.wantsLayer = true
|
|
hostingView.layer?.cornerRadius = WindowSwitcherOverlayMetrics.cornerRadius
|
|
hostingView.layer?.cornerCurve = .continuous
|
|
hostingView.layer?.masksToBounds = true
|
|
|
|
self.hostingView = hostingView
|
|
panel.contentView = makeGlassContentView(hostingView: hostingView)
|
|
return panel
|
|
}
|
|
|
|
private func makeGlassContentView(hostingView: NSView) -> NSView {
|
|
if #available(macOS 26.0, *) {
|
|
let glassView = NSGlassEffectView()
|
|
glassView.style = .regular
|
|
glassView.cornerRadius = WindowSwitcherOverlayMetrics.cornerRadius
|
|
glassView.contentView = hostingView
|
|
glassView.wantsLayer = true
|
|
glassView.layer?.cornerRadius = WindowSwitcherOverlayMetrics.cornerRadius
|
|
glassView.layer?.cornerCurve = .continuous
|
|
glassView.layer?.masksToBounds = true
|
|
return glassView
|
|
}
|
|
|
|
let effectView = NSVisualEffectView()
|
|
effectView.material = .hudWindow
|
|
effectView.blendingMode = .behindWindow
|
|
effectView.state = .active
|
|
effectView.maskImage = WindowSwitcherOverlayMetrics.roundedMaskImage()
|
|
effectView.wantsLayer = true
|
|
effectView.layer?.cornerRadius = WindowSwitcherOverlayMetrics.cornerRadius
|
|
effectView.layer?.cornerCurve = .continuous
|
|
effectView.layer?.masksToBounds = true
|
|
|
|
hostingView.translatesAutoresizingMaskIntoConstraints = false
|
|
effectView.addSubview(hostingView)
|
|
NSLayoutConstraint.activate([
|
|
hostingView.leadingAnchor.constraint(equalTo: effectView.leadingAnchor),
|
|
hostingView.trailingAnchor.constraint(equalTo: effectView.trailingAnchor),
|
|
hostingView.topAnchor.constraint(equalTo: effectView.topAnchor),
|
|
hostingView.bottomAnchor.constraint(equalTo: effectView.bottomAnchor),
|
|
])
|
|
return effectView
|
|
}
|
|
|
|
private func resize(_ panel: NSPanel) {
|
|
guard let hostingView else {
|
|
return
|
|
}
|
|
|
|
hostingView.layoutSubtreeIfNeeded()
|
|
panel.setContentSize(hostingView.fittingSize)
|
|
panel.invalidateShadow()
|
|
}
|
|
|
|
private func center(_ panel: NSPanel, on screen: NSScreen?) {
|
|
guard let frame = screen?.visibleFrame ?? NSScreen.main?.visibleFrame else {
|
|
return
|
|
}
|
|
|
|
let size = panel.frame.size
|
|
let origin = NSPoint(
|
|
x: frame.midX - size.width / 2,
|
|
y: frame.midY - size.height / 2
|
|
)
|
|
panel.setFrameOrigin(origin)
|
|
}
|
|
|
|
private func targetScreen() -> NSScreen? {
|
|
let mouseLocation = NSEvent.mouseLocation
|
|
return NSScreen.screens.first { NSMouseInRect(mouseLocation, $0.frame, false) }
|
|
?? NSScreen.main
|
|
}
|
|
|
|
private func columnCount(
|
|
for entryCount: Int,
|
|
presentation: WindowSwitcherOverlayPresentation,
|
|
screen: NSScreen?
|
|
) -> Int {
|
|
guard entryCount > 0 else {
|
|
return 1
|
|
}
|
|
|
|
let frame = screen?.visibleFrame ?? NSScreen.main?.visibleFrame ?? NSRect(x: 0, y: 0, width: 900, height: 700)
|
|
let tileWidth = presentation == .direct
|
|
? WindowSwitcherOverlayMetrics.directTileWidth
|
|
: WindowSwitcherOverlayMetrics.keyWindowTileWidth
|
|
let horizontalPadding = WindowSwitcherOverlayMetrics.panelHorizontalPadding * 2
|
|
let spacing = WindowSwitcherOverlayMetrics.horizontalSpacing
|
|
let maxWidth = min(frame.width - 96, presentation == .direct ? 980 : 1040)
|
|
let capacity = Int((maxWidth - horizontalPadding + spacing) / (tileWidth + spacing))
|
|
return max(1, min(entryCount, capacity))
|
|
}
|
|
|
|
private func installKeyMonitor() {
|
|
removeKeyMonitor()
|
|
keyMonitor = NSEvent.addLocalMonitorForEvents(matching: .keyDown) { [weak self] event in
|
|
guard let self else {
|
|
return event
|
|
}
|
|
|
|
return self.handleKeyDown(event) ? nil : event
|
|
}
|
|
}
|
|
|
|
private func removeKeyMonitor() {
|
|
if let keyMonitor {
|
|
NSEvent.removeMonitor(keyMonitor)
|
|
}
|
|
keyMonitor = nil
|
|
}
|
|
|
|
private func installClickMonitor() {
|
|
removeClickMonitor()
|
|
clickMonitor = NSEvent.addGlobalMonitorForEvents(
|
|
matching: [.leftMouseDown, .rightMouseDown, .otherMouseDown]
|
|
) { [weak self] _ in
|
|
Task { @MainActor [weak self] in
|
|
self?.cancel()
|
|
}
|
|
}
|
|
}
|
|
|
|
private func removeClickMonitor() {
|
|
if let clickMonitor {
|
|
NSEvent.removeMonitor(clickMonitor)
|
|
}
|
|
clickMonitor = nil
|
|
}
|
|
|
|
private func handleKeyDown(_ event: NSEvent) -> Bool {
|
|
guard model.presentation == .keyWindow else {
|
|
return false
|
|
}
|
|
|
|
if model.recordingEntryID != nil {
|
|
return handleRecordingKeyDown(event)
|
|
}
|
|
|
|
if event.keyCode == 53 {
|
|
cancel()
|
|
return true
|
|
}
|
|
|
|
guard let shortcut = selectionShortcut(from: event) else {
|
|
return false
|
|
}
|
|
|
|
resolveShortcutToken(shortcut.storageValue)
|
|
return true
|
|
}
|
|
|
|
private func handleRecordingKeyDown(_ event: NSEvent) -> Bool {
|
|
if event.keyCode == 53 {
|
|
cancelShortcutRecording()
|
|
return true
|
|
}
|
|
|
|
if event.keyCode == 51 || event.keyCode == 117 {
|
|
commitRecordedShortcut(nil)
|
|
return true
|
|
}
|
|
|
|
guard let shortcut = selectionShortcut(from: event) else {
|
|
NSSound.beep()
|
|
return true
|
|
}
|
|
|
|
commitRecordedShortcut(shortcut.storageValue)
|
|
return true
|
|
}
|
|
|
|
private func selectionShortcut(from event: NSEvent) -> WindowSwitcherSelectionShortcut? {
|
|
guard event.modifierFlags.intersection([.control, .option]).isEmpty,
|
|
let chars = event.charactersIgnoringModifiers?.lowercased(),
|
|
let character = chars.first
|
|
else {
|
|
return nil
|
|
}
|
|
|
|
return WindowSwitcherSelectionShortcut(
|
|
key: String(character),
|
|
usesCommand: event.modifierFlags.contains(.command)
|
|
)
|
|
}
|
|
|
|
private func resolveShortcutToken(_ token: String) {
|
|
guard let entry = model.entries.first(where: { $0.shortcutToken == token }) else {
|
|
NSSound.beep()
|
|
return
|
|
}
|
|
|
|
select(entry)
|
|
}
|
|
|
|
private func select(_ entry: WindowSwitcherAppEntry) {
|
|
cancelShortcutRecording()
|
|
hide()
|
|
onSelect?(entry)
|
|
}
|
|
|
|
private func beginShortcutRecording(_ entry: WindowSwitcherAppEntry) {
|
|
guard model.presentation == .keyWindow else {
|
|
return
|
|
}
|
|
|
|
cancelShortcutRecording()
|
|
model.recordingEntryID = entry.id
|
|
model.recordingCandidate = nil
|
|
model.recordingHasConflict = false
|
|
}
|
|
|
|
private func commitRecordedShortcut(_ token: String?) {
|
|
guard let entryID = model.recordingEntryID,
|
|
let entry = model.entries.first(where: { $0.id == entryID }),
|
|
let onShortcutChange
|
|
else {
|
|
cancelShortcutRecording()
|
|
return
|
|
}
|
|
|
|
model.recordingCandidate = token
|
|
switch onShortcutChange(entry, token) {
|
|
case let .updated(entries):
|
|
model.entries = entries
|
|
cancelShortcutRecording()
|
|
case .conflict:
|
|
model.recordingHasConflict = true
|
|
NSSound.beep()
|
|
case .unavailable:
|
|
cancelShortcutRecording()
|
|
NSSound.beep()
|
|
}
|
|
}
|
|
|
|
private func cancelShortcutRecording() {
|
|
model.recordingEntryID = nil
|
|
model.recordingCandidate = nil
|
|
model.recordingHasConflict = false
|
|
}
|
|
|
|
private func quit(_ entry: WindowSwitcherAppEntry) {
|
|
cancelShortcutRecording()
|
|
onQuit?(entry)
|
|
}
|
|
|
|
private func cancel() {
|
|
cancelShortcutRecording()
|
|
hide()
|
|
onCancel?()
|
|
}
|
|
|
|
func windowDidResignKey(_ notification: Notification) {
|
|
guard !isClosing, model.presentation == .keyWindow else {
|
|
return
|
|
}
|
|
|
|
cancel()
|
|
}
|
|
}
|
|
|
|
@MainActor
|
|
private struct WindowSwitcherOverlayView: View {
|
|
@ObservedObject var model: WindowSwitcherOverlayModel
|
|
let onSelect: (WindowSwitcherAppEntry) -> Void
|
|
let onQuit: (WindowSwitcherAppEntry) -> Void
|
|
let onRecordShortcut: (WindowSwitcherAppEntry) -> Void
|
|
let onCancelShortcutRecording: () -> Void
|
|
|
|
private var tileWidth: CGFloat {
|
|
model.presentation == .direct
|
|
? WindowSwitcherOverlayMetrics.directTileWidth
|
|
: WindowSwitcherOverlayMetrics.keyWindowTileWidth
|
|
}
|
|
|
|
private var tileHeight: CGFloat {
|
|
model.presentation == .direct
|
|
? WindowSwitcherOverlayMetrics.directTileHeight
|
|
: WindowSwitcherOverlayMetrics.keyWindowTileHeight
|
|
}
|
|
|
|
private var spacing: CGFloat {
|
|
WindowSwitcherOverlayMetrics.horizontalSpacing
|
|
}
|
|
|
|
private var contentWidth: CGFloat {
|
|
let columns = max(1, model.columnCount)
|
|
let gridWidth = CGFloat(columns) * tileWidth + CGFloat(max(0, columns - 1)) * spacing
|
|
return max(220, gridWidth)
|
|
}
|
|
|
|
var body: some View {
|
|
VStack(spacing: WindowSwitcherOverlayMetrics.verticalSpacing) {
|
|
if model.entries.isEmpty {
|
|
emptyState
|
|
} else {
|
|
appGrid
|
|
}
|
|
}
|
|
.frame(width: contentWidth)
|
|
.padding(.horizontal, WindowSwitcherOverlayMetrics.panelHorizontalPadding)
|
|
.padding(.vertical, WindowSwitcherOverlayMetrics.panelVerticalPadding)
|
|
.background {
|
|
Color.clear
|
|
.contentShape(Rectangle())
|
|
.onTapGesture {
|
|
guard model.recordingEntryID != nil else {
|
|
return
|
|
}
|
|
onCancelShortcutRecording()
|
|
}
|
|
}
|
|
.fixedSize()
|
|
}
|
|
|
|
private var appGrid: some View {
|
|
LazyVGrid(
|
|
columns: Array(
|
|
repeating: GridItem(.fixed(tileWidth), spacing: spacing),
|
|
count: max(1, model.columnCount)
|
|
),
|
|
spacing: WindowSwitcherOverlayMetrics.verticalSpacing
|
|
) {
|
|
ForEach(model.entries) { entry in
|
|
WindowSwitcherAppTile(
|
|
entry: entry,
|
|
isSelected: entry.id == model.selectedID,
|
|
isRecording: entry.id == model.recordingEntryID,
|
|
recordingCandidate: entry.id == model.recordingEntryID
|
|
? model.recordingCandidate
|
|
: nil,
|
|
recordingHasConflict: entry.id == model.recordingEntryID
|
|
&& model.recordingHasConflict,
|
|
showsShortcut: model.presentation == .keyWindow,
|
|
tileWidth: tileWidth,
|
|
tileHeight: tileHeight,
|
|
onSelect: { onSelect(entry) },
|
|
onQuit: { onQuit(entry) },
|
|
onRecordShortcut: { onRecordShortcut(entry) }
|
|
)
|
|
}
|
|
}
|
|
}
|
|
|
|
private var emptyState: some View {
|
|
VStack(spacing: 8) {
|
|
Image(systemName: "app.dashed")
|
|
.font(.system(size: 28, weight: .medium))
|
|
.foregroundStyle(.secondary)
|
|
Text("没有可切换的窗口")
|
|
.font(.system(size: 13, weight: .medium))
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
.frame(height: 110)
|
|
.frame(maxWidth: .infinity)
|
|
}
|
|
|
|
}
|
|
|
|
private struct WindowSwitcherAppTile: View {
|
|
let entry: WindowSwitcherAppEntry
|
|
let isSelected: Bool
|
|
let isRecording: Bool
|
|
let recordingCandidate: String?
|
|
let recordingHasConflict: Bool
|
|
let showsShortcut: Bool
|
|
let tileWidth: CGFloat
|
|
let tileHeight: CGFloat
|
|
let onSelect: () -> Void
|
|
let onQuit: () -> Void
|
|
let onRecordShortcut: () -> Void
|
|
|
|
@Environment(\.colorScheme) private var colorScheme
|
|
@State private var isIconHovered = false
|
|
@State private var isQuitHovered = false
|
|
@State private var isShortcutHovered = false
|
|
|
|
var body: some View {
|
|
ZStack(alignment: .topLeading) {
|
|
VStack(spacing: showsShortcut ? WindowSwitcherOverlayMetrics.shortcutContentSpacing : 0) {
|
|
if showsShortcut {
|
|
Button(action: onRecordShortcut) {
|
|
shortcutBadge
|
|
.frame(height: WindowSwitcherOverlayMetrics.shortcutHeight)
|
|
}
|
|
.buttonStyle(.plain)
|
|
.onHover { isShortcutHovered = $0 }
|
|
.help("修改 \(entry.appName)快捷键")
|
|
} else {
|
|
Color.clear
|
|
.frame(height: WindowSwitcherOverlayMetrics.directTopSpacing)
|
|
}
|
|
|
|
Button(action: onSelect) {
|
|
tileContent
|
|
}
|
|
.buttonStyle(.plain)
|
|
}
|
|
.frame(width: tileWidth, height: tileHeight, alignment: .top)
|
|
|
|
quitButton
|
|
.position(quitButtonCenter)
|
|
}
|
|
.frame(width: tileWidth, height: tileHeight)
|
|
}
|
|
|
|
private var shortcutBadge: some View {
|
|
Group {
|
|
if isRecording, recordingCandidate == nil {
|
|
Image(systemName: "keyboard")
|
|
.font(.system(size: 10, weight: .semibold))
|
|
} else {
|
|
Text(recordingDisplay ?? entry.shortcutDisplay ?? "")
|
|
.font(.system(size: 11, weight: .bold, design: .monospaced))
|
|
.lineLimit(1)
|
|
}
|
|
}
|
|
.foregroundStyle(shortcutForegroundColor)
|
|
.frame(minWidth: 22)
|
|
.padding(.horizontal, 7)
|
|
.padding(.vertical, 3)
|
|
.background(
|
|
Capsule(style: .continuous)
|
|
.fill(shortcutBackgroundColor)
|
|
)
|
|
.contentShape(Capsule(style: .continuous))
|
|
.animation(.easeOut(duration: 0.12), value: isRecording)
|
|
.animation(.easeOut(duration: 0.12), value: recordingHasConflict)
|
|
.animation(.easeOut(duration: 0.12), value: isShortcutHovered)
|
|
}
|
|
|
|
private var shortcutForegroundColor: Color {
|
|
if recordingHasConflict {
|
|
return Color(nsColor: .systemRed)
|
|
}
|
|
if isRecording {
|
|
return Color.accentColor
|
|
}
|
|
return .secondary
|
|
}
|
|
|
|
private var shortcutBackgroundColor: Color {
|
|
if recordingHasConflict {
|
|
return Color(nsColor: .systemRed).opacity(0.16)
|
|
}
|
|
if isRecording {
|
|
return Color.accentColor.opacity(0.16)
|
|
}
|
|
if isShortcutHovered {
|
|
return Color.primary.opacity(0.12)
|
|
}
|
|
return Color.primary.opacity(0.07)
|
|
}
|
|
|
|
private var recordingDisplay: String? {
|
|
guard isRecording, let recordingCandidate else {
|
|
return nil
|
|
}
|
|
|
|
return WindowSwitcherSelectionShortcut(storageValue: recordingCandidate)?.displayValue
|
|
}
|
|
|
|
private var quitButton: some View {
|
|
Button(action: onQuit) {
|
|
Image(systemName: "xmark")
|
|
.font(.system(size: 8, weight: .bold))
|
|
.foregroundStyle(quitForegroundColor)
|
|
.frame(
|
|
width: WindowSwitcherOverlayMetrics.quitButtonSize,
|
|
height: WindowSwitcherOverlayMetrics.quitButtonSize
|
|
)
|
|
.background(
|
|
Circle()
|
|
.fill(quitBackgroundColor)
|
|
)
|
|
.contentShape(Circle())
|
|
}
|
|
.buttonStyle(.plain)
|
|
.opacity(showsQuitButton ? 1 : 0)
|
|
.allowsHitTesting(showsQuitButton)
|
|
.onHover { isQuitHovered = $0 }
|
|
.help("退出 \(entry.appName)")
|
|
.animation(.easeOut(duration: 0.12), value: showsQuitButton)
|
|
.animation(.easeOut(duration: 0.12), value: isQuitHovered)
|
|
}
|
|
|
|
private var tileContent: some View {
|
|
VStack(spacing: WindowSwitcherOverlayMetrics.iconLabelSpacing) {
|
|
highlightedIcon
|
|
|
|
VStack(spacing: 1) {
|
|
Text(entry.displayName)
|
|
.font(.system(size: 11, weight: .medium))
|
|
.lineLimit(1)
|
|
.truncationMode(.tail)
|
|
.foregroundStyle(.primary)
|
|
.frame(height: 14)
|
|
|
|
if let subtitle = entry.displaySubtitle {
|
|
Text(subtitle)
|
|
.font(.system(size: 10, weight: .regular))
|
|
.lineLimit(1)
|
|
.truncationMode(.tail)
|
|
.foregroundStyle(.secondary)
|
|
.frame(height: 12)
|
|
} else {
|
|
Color.clear
|
|
.frame(height: 12)
|
|
}
|
|
}
|
|
.frame(
|
|
width: tileWidth - 12,
|
|
height: WindowSwitcherOverlayMetrics.labelAreaHeight,
|
|
alignment: .top
|
|
)
|
|
}
|
|
.frame(width: tileWidth, height: highlightedContentHeight, alignment: .top)
|
|
.help(accessibilityTitle)
|
|
}
|
|
|
|
private var highlightedIcon: some View {
|
|
ZStack {
|
|
RoundedRectangle(
|
|
cornerRadius: WindowSwitcherOverlayMetrics.iconHighlightCornerRadius,
|
|
style: .continuous
|
|
)
|
|
.fill(iconBackgroundColor)
|
|
|
|
iconView
|
|
}
|
|
.frame(
|
|
width: WindowSwitcherOverlayMetrics.iconHighlightSize,
|
|
height: WindowSwitcherOverlayMetrics.iconHighlightSize
|
|
)
|
|
.frame(
|
|
width: WindowSwitcherOverlayMetrics.iconLayoutSize,
|
|
height: WindowSwitcherOverlayMetrics.iconLayoutSize
|
|
)
|
|
.contentShape(Rectangle())
|
|
.onHover { isIconHovered = $0 }
|
|
.animation(.easeOut(duration: 0.12), value: isIconHovered)
|
|
.animation(.easeOut(duration: 0.12), value: isSelected)
|
|
}
|
|
|
|
private var iconBackgroundColor: Color {
|
|
if isSelected {
|
|
return Color.accentColor.opacity(0.16)
|
|
}
|
|
if showsShortcut && (isIconHovered || isQuitHovered) {
|
|
return Color.black.opacity(colorScheme == .dark ? 0.16 : 0.08)
|
|
}
|
|
return .clear
|
|
}
|
|
|
|
@ViewBuilder
|
|
private var iconView: some View {
|
|
if let icon = entry.icon {
|
|
Image(nsImage: icon)
|
|
.resizable()
|
|
.interpolation(.high)
|
|
.scaledToFit()
|
|
.frame(
|
|
width: WindowSwitcherOverlayMetrics.iconSize,
|
|
height: WindowSwitcherOverlayMetrics.iconSize
|
|
)
|
|
} else {
|
|
Image(systemName: "app.fill")
|
|
.font(.system(size: 52))
|
|
.foregroundStyle(.secondary)
|
|
.frame(
|
|
width: WindowSwitcherOverlayMetrics.iconSize,
|
|
height: WindowSwitcherOverlayMetrics.iconSize
|
|
)
|
|
}
|
|
}
|
|
|
|
private var highlightedContentTopOffset: CGFloat {
|
|
showsShortcut
|
|
? WindowSwitcherOverlayMetrics.shortcutHeight
|
|
+ WindowSwitcherOverlayMetrics.shortcutContentSpacing
|
|
: WindowSwitcherOverlayMetrics.directTopSpacing
|
|
}
|
|
|
|
private var quitButtonCenter: CGPoint {
|
|
WindowSwitcherOverlayMetrics.quitButtonCenter(
|
|
tileWidth: tileWidth,
|
|
contentTopOffset: highlightedContentTopOffset
|
|
)
|
|
}
|
|
|
|
private var highlightedContentHeight: CGFloat {
|
|
WindowSwitcherOverlayMetrics.tileContentHeight
|
|
}
|
|
|
|
private var showsQuitButton: Bool {
|
|
isIconHovered || isQuitHovered
|
|
}
|
|
|
|
private var quitForegroundColor: Color {
|
|
isQuitHovered ? Color(nsColor: .systemRed) : .secondary
|
|
}
|
|
|
|
private var quitBackgroundColor: Color {
|
|
isQuitHovered ? Color(nsColor: .systemRed).opacity(0.16) : Color.primary.opacity(0.08)
|
|
}
|
|
|
|
private var accessibilityTitle: String {
|
|
if let subtitle = entry.displaySubtitle {
|
|
return "\(entry.displayName)，\(subtitle)"
|
|
}
|
|
|
|
return entry.displayName
|
|
}
|
|
}
|