import SwiftUI
import AppKit
import UniformTypeIdentifiers
// MARK: - Notification for manual re-index
extension Notification.Name {
static let tagLauncherEditModeChanged = Notification.Name("TagLauncherEditModeChanged")
static let tagLauncherAppNoteEditingChanged = Notification.Name("TagLauncherAppNoteEditingChanged")
static let tagLauncherDataDidChange = Notification.Name("TagLauncherDataDidChange")
static let tagLauncherOpenPreferencesRequested = Notification.Name("TagLauncherOpenPreferencesRequested")
static let tagLauncherOverlayDidShow = Notification.Name("TagLauncherOverlayDidShow")
static let tagLauncherOverlayDidHide = Notification.Name("TagLauncherOverlayDidHide")
static let tagLauncherModalInteractionChanged = Notification.Name("TagLauncherModalInteractionChanged")
}
// MARK: - Edit Phase
enum EditPhase {
case none
case editingTags
case editingApps
}
enum EditTagOperation {
case add
case remove
}
// MARK: - Native NSTextField (avoids SwiftUI TextField event issues)
/// Custom container that wraps NSTextField so that hitTest returns the container
/// and mouseDown can reliably make the text field first responder.
final class TextFieldContainer: NSView {
let textField: NSTextField
init(field: NSTextField) {
self.textField = field
super.init(frame: NSRect(x: 0, y: 0, width: 160, height: 24))
addSubview(field)
field.frame = bounds
field.autoresizingMask = [.width, .height]
}
required init?(coder: NSCoder) { fatalError() }
override func layout() {
super.layout()
textField.frame = bounds
}
override func hitTest(_ point: NSPoint) -> NSView? {
if bounds.contains(point) { return self }
return nil
}
override func mouseDown(with event: NSEvent) {
if let w = window { w.makeFirstResponder(textField) }
textField.mouseDown(with: event)
}
}
struct MacTextField: NSViewRepresentable {
typealias NSViewType = TextFieldContainer
@Binding var text: String
let placeholder: String
var onSubmit: (() -> Void)?
func makeNSView(context: Context) -> TextFieldContainer {
let field = NSTextField()
field.placeholderString = placeholder
field.isBordered = true
field.isBezeled = true
field.drawsBackground = true
field.isEditable = true
field.isSelectable = true
field.font = NSFont.systemFont(ofSize: 13)
field.focusRingType = .default
field.delegate = context.coordinator
context.coordinator.field = field
context.coordinator.onSubmit = onSubmit
return TextFieldContainer(field: field)
}
func updateNSView(_ container: TextFieldContainer, context: Context) {
if container.textField.stringValue != text {
container.textField.stringValue = text
}
}
func makeCoordinator() -> Coordinator {
Coordinator(text: $text)
}
final class Coordinator: NSObject, NSTextFieldDelegate {
var text: Binding
var onSubmit: (() -> Void)?
weak var field: NSTextField?
init(text: Binding) {
self.text = text
}
func controlTextDidChange(_ obj: Notification) {
guard let field = obj.object as? NSTextField else { return }
text.wrappedValue = field.stringValue
}
func control(_ control: NSControl, textView: NSTextView, doCommandBy commandSelector: Selector) -> Bool {
if commandSelector == #selector(NSResponder.insertNewline(_:)) {
onSubmit?()
return true
}
return false
}
}
}
// MARK: - Native Floating Icon Button
final class FloatingIconButtonView: NSView {
private let imageView = NSImageView()
var action: (() -> Void)?
override init(frame frameRect: NSRect) {
super.init(frame: frameRect)
addSubview(imageView)
imageView.imageScaling = .scaleProportionallyDown
imageView.contentTintColor = .secondaryLabelColor
}
required init?(coder: NSCoder) { fatalError() }
override func layout() {
super.layout()
let size: CGFloat = 16
imageView.frame = NSRect(
x: (bounds.width - size) / 2,
y: (bounds.height - size) / 2,
width: size,
height: size
)
}
override func hitTest(_ point: NSPoint) -> NSView? {
bounds.contains(point) ? self : nil
}
override func mouseDown(with event: NSEvent) {
action?()
}
func setSystemImage(_ systemImage: String) {
let config = NSImage.SymbolConfiguration(pointSize: 16, weight: .medium)
imageView.image = NSImage(
systemSymbolName: systemImage,
accessibilityDescription: nil
)?.withSymbolConfiguration(config)
}
}
private struct NativeFloatingIconButton: NSViewRepresentable {
let systemImage: String
let action: () -> Void
func makeCoordinator() -> Coordinator {
Coordinator(action: action)
}
func makeNSView(context: Context) -> FloatingIconButtonView {
let view = FloatingIconButtonView(frame: NSRect(x: 0, y: 0, width: 36, height: 36))
configure(view, context: context)
return view
}
func updateNSView(_ view: FloatingIconButtonView, context: Context) {
context.coordinator.action = action
configure(view, context: context)
}
private func configure(_ view: FloatingIconButtonView, context: Context) {
view.setSystemImage(systemImage)
view.action = {
context.coordinator.action()
}
}
final class Coordinator {
var action: () -> Void
init(action: @escaping () -> Void) {
self.action = action
}
}
}
// MARK: - Tag Pill (for top navigation bar)
struct TagPill: View {
let name: String
let colorIndex: Int
var dragModeActive: Bool = false
var isDragging: Bool = false
var dragResetToken: Int = 0
let action: () -> Void
private var bgColor: Color {
Color(nsColor: TagColor.nsColor(for: colorIndex))
}
private var textColor: Color {
if colorIndex == 0 || colorIndex == 5 {
return .primary
}
return .white
}
var body: some View {
Text(name)
.font(.system(size: 13, weight: .medium))
.foregroundStyle(textColor)
.padding(.horizontal, 12)
.padding(.vertical, 6)
.background(RoundedRectangle(cornerRadius: 7).fill(bgColor))
.shadow(color: .black.opacity(isDragging ? 0.34 : 0.2), radius: isDragging ? 8 : 3, y: isDragging ? 4 : 1)
.scaleEffect(isDragging ? 1.05 : 1.0)
.opacity(dragModeActive ? (isDragging ? 1.0 : 0.62) : 1.0)
.animation(.easeOut(duration: 0.08), value: isDragging)
.animation(.easeOut(duration: 0.08), value: dragModeActive)
.id("\(name)|reset-\(dragResetToken)")
.contentShape(RoundedRectangle(cornerRadius: 7))
.onTapGesture {
action()
}
}
}
// MARK: - Side Tag Pill
struct SideTagPill: View {
let name: String
let colorIndex: Int
var dragModeActive: Bool = false
var isDragging: Bool = false
var dragResetToken: Int = 0
let action: () -> Void
private var bgColor: Color {
Color(nsColor: TagColor.nsColor(for: colorIndex))
}
private var textColor: Color {
colorIndex == 0 || colorIndex == 5 ? .primary : .white
}
var body: some View {
Text(name)
.font(.system(size: 13, weight: .medium))
.foregroundStyle(textColor)
.padding(.horizontal, 10).padding(.vertical, 5)
.frame(maxWidth: .infinity, alignment: .leading)
.background(RoundedRectangle(cornerRadius: 6).fill(bgColor))
.shadow(color: .black.opacity(isDragging ? 0.34 : 0.2), radius: isDragging ? 8 : 3, y: isDragging ? 4 : 1)
.scaleEffect(isDragging ? 1.03 : 1.0)
.opacity(dragModeActive ? (isDragging ? 1.0 : 0.62) : 1.0)
.animation(.easeOut(duration: 0.08), value: isDragging)
.animation(.easeOut(duration: 0.08), value: dragModeActive)
.id("\(name)|reset-\(dragResetToken)")
.contentShape(RoundedRectangle(cornerRadius: 6))
.onTapGesture {
action()
}
}
}
// MARK: - Color Swatch (for tag color picker)
struct ColorSwatch: View {
let index: Int
let isSelected: Bool
let action: () -> Void
var body: some View {
Button(action: action) {
Circle()
.fill(Color(nsColor: TagColor.nsColor(for: index)))
.frame(width: 18, height: 18)
.overlay(
Circle()
.stroke(isSelected ? Color.white : Color.clear, lineWidth: 2)
.padding(2)
)
.shadow(color: .black.opacity(0.15), radius: 2, y: 1)
}
.buttonStyle(.plain)
}
}
// MARK: - Full-Screen Overlay
private struct AppBubbleContext {
let app: AppInfo
let frame: CGRect
}
private struct AppBubbleMetrics {
let centerX: CGFloat
let centerY: CGFloat
let arrowX: CGFloat
let arrowOffset: CGFloat
}
private struct EditActionFeedback: Identifiable {
let id = UUID()
let title: String
let message: String
}
private struct PendingUncategorizedDrop: Identifiable {
let id = UUID()
let app: AppInfo
let assignedTags: [String]
}
private enum SmartStartNoticeMode {
case autoApplied
case suggestionOnly
case manuallyApplied
}
private struct SmartStartNotice: Identifiable {
let id = UUID()
let mode: SmartStartNoticeMode
let title: String
let message: String
let summary: SmartStartSummary
}
struct ContentView: View {
let hideOverlay: () -> Void
private let initialQuickSearchSource: String?
@State private var allApps: [AppInfo] = []
@State private var tagColors: [String: Int] = [:]
@State private var scrollProxy: ScrollViewProxy? = nil
// Edit mode
@State private var editPhase: EditPhase = .none
@State private var selectedAppPaths: Set = []
@State private var selectedTagNames: Set = []
@State private var removableTagNames: Set = []
@State private var editTagOperation: EditTagOperation = .add
@State private var editActionFeedback: EditActionFeedback? = nil
@State private var draggedTagNames: [String] = [] // live drag order
@State private var dragItem: String? = nil // currently dragged tag
@State private var tagReorderFrames: [String: CGRect] = [:]
@State private var tagNavDragModeActive = false
@State private var tagNavDragItem: String? = nil
@State private var tagNavDragResetToken = 0
@State private var tagNavReorderFrames: [String: CGRect] = [:]
@State private var tagNavReorderDidMove = false
@State private var hoveredContainer: String? = nil // colored container lift
// Fixed interaction for "Colorless Container": hover fills persistently; click clears.
@State private var filledColorlessContainer: String? = nil
@State private var appDragModeActive = false
@State private var dropWarningToast: String? = nil
@State private var smartStartNotice: SmartStartNotice? = nil
@State private var pendingSmartStartDraft: SmartCategorizationDraft? = nil
@State private var dropRefreshVisible = false
@State private var dropRefreshStartedAt: Date? = nil
@State private var refreshInProgress = false
@State private var refreshAgainAfterCurrent = false
@State private var refreshAgainForceLayout = false
@State private var hoveredAppItemID: String? = nil
@State private var hoveredBubble: AppBubbleContext? = nil
@State private var editingBubble: AppBubbleContext? = nil
@State private var pendingUncategorizedDrop: PendingUncategorizedDrop? = nil
@State private var appDragResetToken = 0
@State private var bubbleDraftNote = ""
@FocusState private var bubbleNoteFocused: Bool
// Quick Search
@State private var quickSearchVisible = false
@State private var quickSearchQuery = ""
@State private var quickSearchDocuments: [QuickSearchDocument] = []
@State private var quickSearchResults: [QuickSearchResult] = []
@State private var quickSearchSelectedID: URL? = nil
@State private var quickSearchManualSelection = false
@State private var quickSearchFocusToken = 0
@State private var quickSearchCloseHidesOverlay = false
@State private var quickSearchErrorMessage: String? = nil
@State private var initialQuickSearchConsumed = false
init(hideOverlay: @escaping () -> Void, initialQuickSearchSource: String? = nil) {
self.hideOverlay = hideOverlay
self.initialQuickSearchSource = initialQuickSearchSource
let startsInQuickSearch = initialQuickSearchSource != nil
_quickSearchVisible = State(initialValue: startsInQuickSearch)
_quickSearchCloseHidesOverlay = State(initialValue: initialQuickSearchSource == QuickSearchOpenSource.globalHidden)
_quickSearchFocusToken = State(initialValue: startsInQuickSearch ? 1 : 0)
}
// Configurable defaults
@AppStorage("defaultGroupName") private var defaultGroupName = "Other"
@AppStorage("tagFontSize") private var tagFontSize: Double = AppDefaults.tagFontSize
@AppStorage("iconSize") private var iconSize: Double = AppDefaults.iconSize
@AppStorage("tagPosition") private var tagPosition = AppDefaults.tagPosition
@State private var notchHeight: CGFloat = 0
@AppStorage("displayMode") private var displayMode = AppDefaults.displayMode
@AppStorage("hideAppNames") private var hideAppNames = AppDefaults.hideAppNames
private let editSidebarWidth: CGFloat = 188
private let editSidebarHorizontalInset: CGFloat = 12
private let floatingControlsTrailingInset: CGFloat = 20
private let floatingControlsReservedWidth: CGFloat = 120
private var appBubbleDisabled: Bool {
appDragModeActive || pendingUncategorizedDrop != nil
}
private let rightSidebarFloatingClearance: CGFloat = 44
private var isSideLayout: Bool {
tagPosition == "left" || tagPosition == "right"
}
private var floatingControlsTopInset: CGFloat {
notchHeight > 0 ? notchHeight + 10 : 20
}
private var isColorlessContainerMode: Bool {
displayMode == "container" || displayMode == "gridContainer"
}
private var isColoredContainerMode: Bool {
displayMode == "coloredContainer" || displayMode == "coloredGridContainer"
}
private var quickSearchOnlyMode: Bool {
quickSearchVisible && quickSearchCloseHidesOverlay
}
var body: some View {
ZStack {
if !quickSearchOnlyMode {
VisualEffectView(material: .hudWindow, blendingMode: .behindWindow)
.ignoresSafeArea()
.allowsHitTesting(false)
}
if !quickSearchOnlyMode {
if notchHeight > 0 {
VStack {
Rectangle().fill(.black)
.frame(height: notchHeight)
.ignoresSafeArea(edges: .top)
Spacer()
}
.allowsHitTesting(false)
}
switch editPhase {
case .none:
normalContent
case .editingTags:
editTagsView
case .editingApps:
editAppsView
}
uncommonAppBubbleOverlay
smartStartNoticeOverlay
editActionFeedbackOverlay
uncategorizedDropConfirmOverlay
}
quickSearchOverlay
if !quickSearchOnlyMode, let message = dropWarningToast {
Text(message)
.font(.system(size: 16, weight: .semibold))
.foregroundStyle(.primary)
.padding(.horizontal, 22)
.padding(.vertical, 12)
.background(
RoundedRectangle(cornerRadius: 10)
.fill(.ultraThickMaterial)
.shadow(color: .black.opacity(0.22), radius: 18, y: 10)
)
.transition(.scale(scale: 0.96).combined(with: .opacity))
.allowsHitTesting(false)
}
if !quickSearchOnlyMode && dropRefreshVisible {
Color.black.opacity(0.08)
.ignoresSafeArea()
.transition(.opacity)
.allowsHitTesting(false)
ProgressView()
.progressViewStyle(.circular)
.controlSize(.large)
.scaleEffect(1.15)
.padding(24)
.background(
RoundedRectangle(cornerRadius: 12)
.fill(.ultraThickMaterial)
.shadow(color: .black.opacity(0.26), radius: 24, y: 12)
)
.transition(.scale(scale: 0.92).combined(with: .opacity))
.allowsHitTesting(false)
}
}
.onAppear {
refreshNotchHeight()
refreshApps()
if let initialQuickSearchSource, !initialQuickSearchConsumed {
initialQuickSearchConsumed = true
quickSearchCloseHidesOverlay = initialQuickSearchSource == QuickSearchOpenSource.globalHidden
quickSearchVisible = true
quickSearchFocusToken &+= 1
NotificationCenter.default.post(
name: .tagLauncherQuickSearchVisibilityChanged,
object: nil,
userInfo: ["active": true]
)
}
}
.onReceive(NotificationCenter.default.publisher(for: .tagLauncherOverlayDidShow)) { _ in
resetTransientDragState()
refreshNotchHeight()
refreshApps()
}
.onReceive(NotificationCenter.default.publisher(for: .tagLauncherOverlayDidHide)) { _ in
resetTransientDragState()
closeQuickSearch(notify: true, hideOverlayIfNeeded: false)
}
.onReceive(NotificationCenter.default.publisher(for: .tagLauncherQuickSearchRequested)) { notification in
let source = notification.userInfo?["source"] as? String ?? QuickSearchOpenSource.mainOverlay
openQuickSearch(source: source)
}
.onReceive(NotificationCenter.default.publisher(for: .tagLauncherQuickSearchDismissRequested)) { _ in
closeQuickSearch()
}
.onReceive(NotificationCenter.default.publisher(for: NSApplication.didBecomeActiveNotification)) { _ in
guard allApps.isEmpty, !refreshInProgress else { return }
refreshApps()
}
.onReceive(NotificationCenter.default.publisher(for: .tagLauncherDataDidChange)) { _ in
refreshApps(forceLayoutRefresh: true)
}
.onReceive(NotificationCenter.default.publisher(for: .appLanguageDidChange)) { _ in
let appsSnapshot = allApps
DispatchQueue.global(qos: .userInitiated).async {
_ = SmartStartService.relocalizeDefaultNotesForCurrentLanguage(apps: appsSnapshot)
DispatchQueue.main.async {
refreshApps(forceLayoutRefresh: true)
}
}
}
.onChange(of: editPhase) { _, newPhase in
let active = newPhase != .none
dismissAppBubble()
NotificationCenter.default.post(
name: .tagLauncherEditModeChanged,
object: nil,
userInfo: ["active": active]
)
}
.onChange(of: bubbleNoteFocused) { _, focused in
if editingBubble != nil && !focused {
commitBubbleNote()
}
}
.onChange(of: quickSearchQuery) { _, _ in
quickSearchErrorMessage = nil
refreshQuickSearchResults()
}
.onChange(of: pendingUncategorizedDrop != nil) { _, active in
NotificationCenter.default.post(
name: .tagLauncherModalInteractionChanged,
object: nil,
userInfo: ["active": active]
)
}
.onDisappear {
NotificationCenter.default.post(
name: .tagLauncherModalInteractionChanged,
object: nil,
userInfo: ["active": false]
)
}
}
/// Set edit phase with synchronous notification BEFORE state change.
func setEditPhase(_ phase: EditPhase) {
if phase != .none {
NotificationCenter.default.post(name: .tagLauncherEditModeChanged, object: nil, userInfo: ["active": true])
NSApp.activate(ignoringOtherApps: true)
// Always sync tag list from database when entering edit mode
let store = TagDatabase.load()
tagColors = store.tags.mapValues { $0.color }
draggedTagNames = TagEditor.orderedTagNames()
}
editPhase = phase
if phase == .none {
TagDatabase.flushPendingCategorySchemeBackupBatch()
DispatchQueue.main.async {
NotificationCenter.default.post(name: .tagLauncherEditModeChanged, object: nil, userInfo: ["active": false])
}
}
}
// MARK: - Quick Search
private var quickSearchOverlay: some View {
GeometryReader { proxy in
if quickSearchVisible {
Color.black.opacity(0.001)
.frame(width: proxy.size.width, height: proxy.size.height)
.ignoresSafeArea()
.contentShape(Rectangle())
.onTapGesture {
closeQuickSearch()
}
.zIndex(899)
QuickSearchOverlayView(
query: $quickSearchQuery,
results: quickSearchResults,
selectedID: quickSearchSelectedID,
focusToken: quickSearchFocusToken,
isLoading: quickSearchDocuments.isEmpty && refreshInProgress,
maxVisibleRows: quickSearchMaxVisibleRows(in: proxy.size),
errorMessage: quickSearchErrorMessage,
onCommand: handleQuickSearchCommand,
onHover: selectQuickSearchResult,
onLaunch: launchQuickSearchResult
)
.position(
x: proxy.size.width / 2,
y: quickSearchPanelCenterY(in: proxy.size)
)
.transition(.scale(scale: 0.98).combined(with: .opacity))
.zIndex(900)
}
}
.ignoresSafeArea()
.animation(.easeOut(duration: 0.12), value: quickSearchVisible)
}
private func quickSearchPanelCenterY(in size: CGSize) -> CGFloat {
let visibleRows = max(1, min(quickSearchResults.isEmpty ? 1 : quickSearchResults.count, quickSearchMaxVisibleRows(in: size)))
let estimatedPanelHeight = CGFloat(visibleRows) * 76 + 122
return quickSearchPanelTopY(in: size) + estimatedPanelHeight / 2
}
private func quickSearchPanelTopY(in size: CGSize) -> CGFloat {
max(notchHeight + 54, min(112, size.height * 0.12))
}
private func quickSearchMaxVisibleRows(in size: CGSize) -> Int {
let bottomClearance: CGFloat = 84
let chromeHeight: CGFloat = 122
let rowHeightWithSpacing: CGFloat = 76
let availableHeight = max(0, size.height - quickSearchPanelTopY(in: size) - bottomClearance - chromeHeight)
return max(1, min(8, Int(floor(availableHeight / rowHeightWithSpacing))))
}
private func openQuickSearch(source: String) {
guard canOpenQuickSearch else { return }
dismissAppBubble()
quickSearchCloseHidesOverlay = source == QuickSearchOpenSource.globalHidden
quickSearchVisible = true
quickSearchQuery = ""
quickSearchManualSelection = false
quickSearchErrorMessage = nil
quickSearchFocusToken &+= 1
refreshQuickSearchResults()
NotificationCenter.default.post(
name: .tagLauncherQuickSearchVisibilityChanged,
object: nil,
userInfo: ["active": true]
)
}
private var canOpenQuickSearch: Bool {
editPhase == .none
&& pendingUncategorizedDrop == nil
&& smartStartNotice == nil
&& !dropRefreshVisible
&& !quickSearchVisible
}
private func closeQuickSearch(notify: Bool = true, hideOverlayIfNeeded: Bool = true) {
let shouldHideOverlay = quickSearchVisible && quickSearchCloseHidesOverlay && hideOverlayIfNeeded
guard quickSearchVisible else { return }
quickSearchVisible = false
quickSearchQuery = ""
quickSearchResults = []
quickSearchSelectedID = nil
quickSearchManualSelection = false
quickSearchErrorMessage = nil
quickSearchCloseHidesOverlay = false
if notify {
NotificationCenter.default.post(
name: .tagLauncherQuickSearchVisibilityChanged,
object: nil,
userInfo: ["active": false]
)
}
if shouldHideOverlay {
hideOverlay()
}
}
private func refreshQuickSearchResults() {
let previousSelection = quickSearchSelectedID
quickSearchResults = QuickSearchEngine.search(quickSearchQuery, documents: quickSearchDocuments)
if quickSearchResults.isEmpty {
quickSearchSelectedID = nil
quickSearchManualSelection = false
return
}
if quickSearchManualSelection,
let previousSelection,
quickSearchResults.contains(where: { $0.id == previousSelection }) {
quickSearchSelectedID = previousSelection
} else {
quickSearchSelectedID = quickSearchResults.first?.id
quickSearchManualSelection = false
}
}
private func handleQuickSearchCommand(_ command: QuickSearchCommand) {
switch command {
case .moveUp:
moveQuickSearchSelection(by: -1)
case .moveDown:
moveQuickSearchSelection(by: 1)
case .submit:
guard let selected = selectedQuickSearchResult else { return }
launchQuickSearchResult(selected)
case .dismiss:
closeQuickSearch()
}
}
private var selectedQuickSearchResult: QuickSearchResult? {
guard let quickSearchSelectedID else { return nil }
return quickSearchResults.first { $0.id == quickSearchSelectedID }
}
private func moveQuickSearchSelection(by delta: Int) {
guard !quickSearchResults.isEmpty else { return }
let currentIndex = quickSearchSelectedID.flatMap { id in
quickSearchResults.firstIndex { $0.id == id }
} ?? 0
let nextIndex = min(max(currentIndex + delta, 0), quickSearchResults.count - 1)
quickSearchSelectedID = quickSearchResults[nextIndex].id
quickSearchManualSelection = true
}
private func selectQuickSearchResult(_ result: QuickSearchResult) {
quickSearchSelectedID = result.id
quickSearchManualSelection = true
}
private func launchQuickSearchResult(_ result: QuickSearchResult) {
quickSearchErrorMessage = nil
launchApp(
result.app,
closeQuickSearchOnSuccess: true,
closeOverlayOnSuccess: true,
onFailure: {
quickSearchErrorMessage = tr("quickSearch.launchFailed")
quickSearchFocusToken &+= 1
NSAccessibility.post(
element: NSApp.mainWindow as Any,
notification: .announcementRequested,
userInfo: [.announcement: tr("quickSearch.launchFailed")]
)
}
)
}
// MARK: - Normal Content
private var normalContent: some View {
ZStack(alignment: .topTrailing) {
if isSideLayout {
sideLayout
} else {
topLayout
}
floatingActionButtons
.padding(.top, floatingControlsTopInset)
.padding(.trailing, floatingControlsTrailingInset)
.zIndex(2)
}
}
private var floatingActionButtons: some View {
HStack(spacing: 8) {
floatingOverlayButton(systemImage: "pencil.line") {
setEditPhase(.editingApps)
}
.keyboardShortcut("e", modifiers: .control)
.help(tr("edit.title"))
floatingOverlayButton(systemImage: "gearshape") {
NotificationCenter.default.post(name: .tagLauncherOpenPreferencesRequested, object: nil)
}
.help(tr("menu.preferences"))
}
}
private func floatingOverlayButton(
systemImage: String,
action: @escaping () -> Void
) -> some View {
NativeFloatingIconButton(systemImage: systemImage, action: action)
.frame(width: 36, height: 36)
.background(Circle().fill(.ultraThinMaterial))
}
// MARK: - Top / Side Layouts
private var topLayout: some View {
VStack(spacing: 0) {
Spacer().frame(height: notchHeight > 0 ? notchHeight + 14 : 28)
if !tagLabels.isEmpty { tagBar.padding(.bottom, 8) }
Divider().opacity(0.3)
appGridContent
}
}
private var sideLayout: some View {
VStack(spacing: 0) {
Spacer().frame(height: notchHeight > 0 ? notchHeight + 14 : 28)
Divider().opacity(0.3)
HStack(spacing: 0) {
if tagPosition == "left" { tagSidebar; sideDivider }
appGridContent
if tagPosition == "right" { sideDivider; rightTagSidebar }
}
}
}
private var tagBar: some View {
ScrollView(.horizontal, showsIndicators: false) {
HStack(spacing: 8) {
ForEach(tagLabels) { tag in
TagPill(name: tag.name, colorIndex: tag.colorIndex,
dragModeActive: tagNavDragModeActive && canReorderTag(tag.name),
isDragging: tagNavDragItem == tag.name,
dragResetToken: tagNavDragResetToken,
action: {
activateTagNavigation(tag.id)
})
.background(tagNavFrameReader(for: tag.name))
.zIndex(tagNavDragItem == tag.name ? 1 : 0)
.highPriorityGesture(tagNavReorderGesture(for: tag.name))
.onHover { hovering in
if hovering {
fillColorlessContainer(tag.id)
scrollTo(tag.id)
}
}
}
}
.padding(.leading, 24)
.padding(.trailing, tagPosition == "top" ? floatingControlsReservedWidth : 24)
.coordinateSpace(name: "tagNavReorder")
.onPreferenceChange(TagNavReorderFramePreferenceKey.self) { frames in
tagNavReorderFrames = frames
}
}
}
private var tagSidebar: some View {
tagSidebarList
.frame(width: 135)
}
private var rightTagSidebar: some View {
tagSidebarList
.padding(.top, rightSidebarFloatingClearance)
.frame(width: 135)
}
private var tagSidebarList: some View {
ScrollView(.vertical, showsIndicators: false) {
VStack(spacing: 6) {
ForEach(tagLabels) { tag in
SideTagPill(name: tag.name, colorIndex: tag.colorIndex,
dragModeActive: tagNavDragModeActive && canReorderTag(tag.name),
isDragging: tagNavDragItem == tag.name,
dragResetToken: tagNavDragResetToken,
action: {
activateTagNavigation(tag.id)
})
.background(tagNavFrameReader(for: tag.name))
.zIndex(tagNavDragItem == tag.name ? 1 : 0)
.highPriorityGesture(tagNavReorderGesture(for: tag.name))
.onHover { hovering in
if hovering {
fillColorlessContainer(tag.id)
scrollTo(tag.id)
}
}
}
}
.padding(12)
.coordinateSpace(name: "tagNavReorder")
.onPreferenceChange(TagNavReorderFramePreferenceKey.self) { frames in
tagNavReorderFrames = frames
}
}
}
private var sideDivider: some View {
Rectangle().fill(.secondary.opacity(0.12)).frame(width: 1)
}
private var appGridContent: some View {
Group {
if allApps.isEmpty {
Spacer()
ProgressView().scaleEffect(0.8)
Spacer()
} else if displayMode == "gridContainer" || displayMode == "coloredGridContainer" {
gridContainerGrid
} else if displayMode == "container" || displayMode == "coloredContainer" {
containerGrid
} else {
flatGrid
}
}
}
private var uncommonAppBubbleOverlay: some View {
GeometryReader { proxy in
if let context = editingBubble ?? hoveredBubble {
let rootFrame = proxy.frame(in: .global)
let editing = editingBubble != nil
let width = min(editing ? 440 : 520, max(260, proxy.size.width - 48))
let placement = bubblePlacement(for: context.frame, rootFrame: rootFrame)
let metrics = bubbleMetrics(
for: context,
rootFrame: rootFrame,
rootSize: proxy.size,
width: width,
placement: placement,
isEditing: editing
)
AppNameBubble(
appName: context.app.name,
note: currentNote(for: context.app),
isEditing: editing,
placement: placement,
arrowOffset: metrics.arrowOffset,
draftNote: $bubbleDraftNote,
noteFocused: $bubbleNoteFocused,
onCommit: commitBubbleNote,
onCancel: dismissAppBubble
)
.frame(width: width)
.fixedSize(horizontal: false, vertical: true)
.position(x: metrics.centerX, y: metrics.centerY)
.transition(.opacity)
.zIndex(500)
}
}
.ignoresSafeArea()
.allowsHitTesting(editingBubble != nil)
}
private var smartStartNoticeOverlay: some View {
GeometryReader { proxy in
if let notice = smartStartNotice {
let panelWidth = min(560, max(320, proxy.size.width - 64))
ZStack {
Color.black.opacity(0.10)
.ignoresSafeArea()
VStack(spacing: 18) {
Image(systemName: notice.mode == .suggestionOnly ? "sparkles" : "checkmark.seal.fill")
.font(.system(size: 30, weight: .semibold))
.foregroundStyle(Color.accentColor)
.frame(width: 58, height: 58)
.background(
Circle()
.fill(Color.accentColor.opacity(0.12))
)
VStack(spacing: 8) {
Text(notice.title)
.font(.system(size: 21, weight: .semibold))
.foregroundStyle(.primary)
.multilineTextAlignment(.center)
Text(notice.message)
.font(.system(size: 15, weight: .regular))
.foregroundStyle(.secondary)
.multilineTextAlignment(.center)
.lineLimit(4)
.fixedSize(horizontal: false, vertical: true)
}
HStack(spacing: 12) {
switch notice.mode {
case .suggestionOnly:
Button(tr("smartstart.later")) {
dismissSmartStartNotice()
}
.buttonStyle(.bordered)
.controlSize(.large)
Button(tr("smartstart.apply")) {
applySmartStartSuggestion()
}
.buttonStyle(.borderedProminent)
.controlSize(.large)
case .autoApplied, .manuallyApplied:
if notice.summary.backupPath != nil {
Button(tr("smartstart.undo")) {
undoSmartStart()
}
.buttonStyle(.bordered)
.controlSize(.large)
}
Button(tr("smartstart.ok")) {
dismissSmartStartNotice()
}
.buttonStyle(.borderedProminent)
.controlSize(.large)
}
}
}
.padding(.horizontal, 30)
.padding(.vertical, 26)
.frame(width: panelWidth)
.background(
RoundedRectangle(cornerRadius: 16)
.fill(.ultraThickMaterial)
.shadow(color: .black.opacity(0.26), radius: 28, y: 16)
)
.overlay(
RoundedRectangle(cornerRadius: 16)
.stroke(.white.opacity(0.16), lineWidth: 1)
)
}
.frame(width: proxy.size.width, height: proxy.size.height)
.transition(.scale(scale: 0.96).combined(with: .opacity))
.zIndex(650)
}
}
.ignoresSafeArea()
.allowsHitTesting(smartStartNotice != nil)
}
private var flatGrid: some View {
ScrollViewReader { proxy in
ScrollView {
LazyVStack(alignment: .leading, spacing: 24) {
ForEach(groups) { group in
TagGroupView(
group: group,
onSelectApp: { app in openApp(app) },
tagFontSize: tagFontSize,
iconSize: iconSize,
showNames: !hideAppNames,
dragModeActive: appDragModeActive,
onDragModeChange: { setAppDragMode($0) },
onBubbleHover: handleBubbleHover,
onEditNote: beginEditingBubbleNote,
bubbleDisabled: appBubbleDisabled,
dragResetToken: appDragResetToken,
hoveredAppItemID: $hoveredAppItemID,
onDropApp: { path, source, copy in
dropApp(path: path, sourceTag: source, targetTag: group.name, copy: copy)
}
).id(group.id)
}
}.padding(20)
}
.id(displayMode) // force rebuild on mode switch
.onAppear { scrollProxy = proxy }
}
}
private var containerGrid: some View {
GeometryReader { geo in
let outerPad: CGFloat = 20
let gap: CGFloat = 16
let available = geo.size.width - outerPad * 2
let colW: CGFloat = 280
let colCount = max(1, Int((available + gap) / (colW + gap)))
let actualColW = (available - gap * CGFloat(colCount - 1)) / CGFloat(colCount)
let columns = distributeToColumns(groups: groups, colCount: colCount, colWidth: actualColW)
ScrollViewReader { proxy in
ScrollView {
HStack(alignment: .top, spacing: gap) {
ForEach(0.. [[TagGroup]] {
var cols = Array(repeating: [TagGroup](), count: colCount)
var h = Array(repeating: CGFloat(0), count: colCount)
for g in groups {
let est = estimatedCardHeight(g, width: colWidth)
let ci = h.firstIndex(of: h.min()!)!
cols[ci].append(g)
h[ci] += est + 16
}
return cols
}
private func estimatedCardHeight(_ group: TagGroup, width: CGFloat) -> CGFloat {
let inner = width - 32
let itemW = AppGridItem.stableWidth(iconSize: iconSize) + 6
let perRow = max(1, Int(inner / itemW))
let rows = (group.apps.count + perRow - 1) / perRow
return 32
+ CGFloat(rows) * AppGridItem.stableHeight(iconSize: iconSize)
+ CGFloat(max(0, rows - 1)) * 2
}
private func masonryCard(_ group: TagGroup, width: CGFloat) -> some View {
let isColored = displayMode == "coloredContainer"
let isColorless = isColorlessContainerMode
let isColorlessFilled = isColorless && filledColorlessContainer == group.name
let isHovered = hoveredContainer == group.name
let isColorlessActive = isColorless && (isColorlessFilled || isHovered)
let tagColor = Color(nsColor: TagColor.nsColor(for: tagColors[group.name] ?? 0))
return VStack(alignment: .leading, spacing: 6) {
HStack(spacing: 0) {
Rectangle().fill(.secondary.opacity(0.25)).frame(height: 1)
.layoutPriority(0)
Text(group.name)
.font(.system(size: tagFontSize, weight: .semibold))
.foregroundStyle(.secondary)
.lineLimit(1)
.truncationMode(.middle)
.padding(.horizontal, 10)
.layoutPriority(1)
Rectangle().fill(.secondary.opacity(0.25)).frame(height: 1)
.layoutPriority(0)
}
let itemSize = AppGridItem.stableWidth(iconSize: iconSize)
LazyVGrid(
columns: [GridItem(.adaptive(minimum: itemSize, maximum: itemSize + 36), spacing: 6)],
spacing: 2
) {
ForEach(group.apps) { app in
AppGridItem(
app: app,
iconSize: iconSize,
showName: !hideAppNames,
sourceTag: group.name,
dragModeActive: appDragModeActive,
onDragModeChange: { setAppDragMode($0) },
onBubbleHover: handleBubbleHover,
onEditNote: beginEditingBubbleNote,
bubbleDisabled: appBubbleDisabled,
itemID: "\(group.name)|\(app.path.path)",
dragResetToken: appDragResetToken,
hoveredAppItemID: $hoveredAppItemID,
onSelect: { openApp(app) }
)
}
}
}
.frame(maxWidth: width)
.padding(16)
.background(
RoundedRectangle(cornerRadius: 14)
.fill((isColored || isColorlessActive) ? tagColor.opacity(0.30) : Color.clear)
.background(
RoundedRectangle(cornerRadius: 14)
.fill(.ultraThinMaterial)
)
)
.overlay(
RoundedRectangle(cornerRadius: 14)
.stroke(Color.primary.opacity(0.08), lineWidth: 1)
)
.overlay {
AppDropTargetView(targetTag: group.name) { path, source, copy in
dropApp(path: path, sourceTag: source, targetTag: group.name, copy: copy)
}
.allowsHitTesting(false)
}
.shadow(color: .black.opacity((isColored && isHovered) || isColorlessActive ? 0.22 : 0),
radius: (isColored && isHovered) || isColorlessActive ? 8 : 0,
y: (isColored && isHovered) || isColorlessActive ? 3 : 0)
.zIndex(isHovered ? 50 : 0)
.animation(.easeOut(duration: 0.045), value: isHovered)
.animation(.easeOut(duration: 0.08), value: isColorlessFilled)
.onHover { hovering in
if isColored || isColorless {
hoveredContainer = hovering ? group.name : nil
}
}
.contentShape(RoundedRectangle(cornerRadius: 14))
.onTapGesture {
if isColorless {
toggleColorlessFill(group.name)
}
}
.onDrop(of: [UTType.plainText], isTargeted: nil) { providers in
handleAppDrop(providers, targetTag: group.name)
}
}
private var gridContainerGrid: some View {
GeometryReader { geo in
let outerPad: CGFloat = 20
let gap: CGFloat = 16
let available = geo.size.width - outerPad * 2
let preferredCount = preferredGridContainersPerRow(availableWidth: available)
let rows = gridContainerRows(groups: groups, trackCount: preferredCount, availableWidth: available, gap: gap)
ScrollViewReader { proxy in
ScrollView {
VStack(alignment: .leading, spacing: gap) {
ForEach(Array(rows.indices), id: \.self) { rowIndex in
let row = rows[rowIndex]
HStack(alignment: .top, spacing: gap) {
ForEach(Array(row.items.indices), id: \.self) { itemIndex in
let item = row.items[itemIndex]
gridContainerCard(item.group, width: item.width, fixedRows: row.fixedRows)
.id(item.group.id)
}
}
}
}
.padding(outerPad)
.frame(maxWidth: .infinity, alignment: .topLeading)
}
.id(displayMode)
.onAppear { scrollProxy = proxy }
}
}
}
private func preferredGridContainersPerRow(availableWidth: CGFloat) -> Int {
let minCardWidth = max(260, AppGridItem.stableWidth(iconSize: iconSize) * 3 + 64)
if availableWidth >= minCardWidth * 3 + 32 { return 3 }
if availableWidth >= minCardWidth * 2 + 16 { return 2 }
return 1
}
private struct GridContainerLayoutItem {
let group: TagGroup
let width: CGFloat
}
private struct GridContainerLayoutRow {
let items: [GridContainerLayoutItem]
let fixedRows: Int
}
private struct GridContainerCandidate {
let spans: [Int]
let rows: Int
let cost: CGFloat
}
private func gridContainerRows(groups: [TagGroup], trackCount: Int, availableWidth: CGFloat, gap: CGFloat) -> [GridContainerLayoutRow] {
let trackCount = max(1, trackCount)
let trackWidth = (availableWidth - gap * CGFloat(trackCount - 1)) / CGFloat(trackCount)
let patterns = gridContainerSpanPatterns(trackCount: trackCount)
let n = groups.count
guard n > 0 else { return [] }
var bestCost = Array(repeating: CGFloat.greatestFiniteMagnitude, count: n + 1)
var bestPattern = Array(repeating: [Int](), count: n)
bestCost[n] = 0
for index in stride(from: n - 1, through: 0, by: -1) {
for pattern in patterns where index + pattern.count <= n {
let candidate = gridContainerCandidate(
groups: groups,
startIndex: index,
spans: pattern,
trackWidth: trackWidth,
availableWidth: availableWidth,
gap: gap
)
let totalCost = candidate.cost + bestCost[index + pattern.count]
if totalCost < bestCost[index] {
bestCost[index] = totalCost
bestPattern[index] = candidate.spans
}
}
}
var rows: [GridContainerLayoutRow] = []
var index = 0
while index < n {
let spans = bestPattern[index].isEmpty ? [trackCount] : bestPattern[index]
let widths = spans.map { gridContainerWidth(trackWidth: trackWidth, span: $0, gap: gap) }
let fixedRows = widths.indices.map {
iconRows(appCount: groups[index + $0].apps.count, width: widths[$0])
}.max() ?? 1
let items = widths.indices.map {
GridContainerLayoutItem(group: groups[index + $0], width: widths[$0])
}
rows.append(GridContainerLayoutRow(items: items, fixedRows: fixedRows))
index += spans.count
}
return rows
}
private func gridContainerSpanPatterns(trackCount: Int) -> [[Int]] {
switch trackCount {
case 3:
return [[1, 1, 1], [1, 2], [2, 1], [3]]
case 2:
return [[1, 1], [2]]
default:
return [[1]]
}
}
private func gridContainerCandidate(
groups: [TagGroup],
startIndex: Int,
spans: [Int],
trackWidth: CGFloat,
availableWidth: CGFloat,
gap: CGFloat
) -> GridContainerCandidate {
let widths = spans.map { gridContainerWidth(trackWidth: trackWidth, span: $0, gap: gap) }
let rowCounts = widths.indices.map {
iconRows(appCount: groups[startIndex + $0].apps.count, width: widths[$0])
}
let fixedRows = rowCounts.max() ?? 1
let rowArea = CGFloat(fixedRows) * iconCellHeight() * availableWidth
let paddingCost = CGFloat(spans.count) * 0.001
return GridContainerCandidate(spans: spans, rows: fixedRows, cost: rowArea + paddingCost)
}
private func gridContainerWidth(trackWidth: CGFloat, span: Int, gap: CGFloat) -> CGFloat {
let span = max(1, span)
return trackWidth * CGFloat(span) + gap * CGFloat(span - 1)
}
private func iconColumns(width: CGFloat) -> Int {
let inner = width - 32
let itemW = AppGridItem.stableWidth(iconSize: iconSize) + 6
return max(1, Int((inner + 6) / itemW))
}
private func iconRows(appCount: Int, width: CGFloat) -> Int {
let cols = iconColumns(width: width)
return max(1, (appCount + cols - 1) / cols)
}
private func gridContainerCard(_ group: TagGroup, width: CGFloat, fixedRows: Int) -> some View {
let isColored = displayMode == "coloredGridContainer"
let isColorlessGrid = displayMode == "gridContainer"
let isColorless = isColorlessContainerMode
let isColorlessFilled = isColorless && filledColorlessContainer == group.name
let isHovered = hoveredContainer == group.name
let isColorlessGridActive = isColorlessGrid && (isColorlessFilled || isHovered)
let cols = iconColumns(width: width)
let contentWidth = max(1, width - 32)
let cellWidth = max(1, (contentWidth - 6 * CGFloat(cols - 1)) / CGFloat(cols))
let cellHeight = iconCellHeight()
let gridHeight = CGFloat(fixedRows) * cellHeight + CGFloat(max(0, fixedRows - 1)) * 2
let rows = appRows(group.apps, columns: cols, fixedRows: fixedRows)
let tagColor = Color(nsColor: TagColor.nsColor(for: tagColors[group.name] ?? 0))
return VStack(alignment: .leading, spacing: 6) {
HStack(spacing: 0) {
Rectangle().fill(.secondary.opacity(0.25)).frame(height: 1)
.layoutPriority(0)
Text(group.name)
.font(.system(size: tagFontSize, weight: .semibold))
.foregroundStyle(.secondary)
.lineLimit(1)
.truncationMode(.middle)
.padding(.horizontal, 10)
.layoutPriority(1)
Rectangle().fill(.secondary.opacity(0.25)).frame(height: 1)
.layoutPriority(0)
}
VStack(alignment: .leading, spacing: 2) {
ForEach(rows.indices, id: \.self) { rowIndex in
HStack(alignment: .top, spacing: 6) {
ForEach(rows[rowIndex]) { app in
AppGridItem(
app: app,
iconSize: iconSize,
showName: !hideAppNames,
sourceTag: group.name,
dragModeActive: appDragModeActive,
onDragModeChange: { setAppDragMode($0) },
onBubbleHover: handleBubbleHover,
onEditNote: beginEditingBubbleNote,
bubbleDisabled: appBubbleDisabled,
itemID: "\(group.name)|\(app.path.path)",
dragResetToken: appDragResetToken,
hoveredAppItemID: $hoveredAppItemID,
onSelect: { openApp(app) }
)
.frame(width: cellWidth)
.frame(height: cellHeight)
}
let emptyCells = max(0, cols - rows[rowIndex].count)
ForEach(0.. CGFloat {
AppGridItem.stableHeight(iconSize: iconSize)
}
private func appRows(_ apps: [AppInfo], columns: Int, fixedRows: Int) -> [[AppInfo]] {
let columns = max(1, columns)
let rowCount = max(1, fixedRows)
return (0.. 0 ? notchHeight + 10 : 20)
.padding(.bottom, 12)
Divider().opacity(0.3)
TagEditorView(
tagColors: $tagColors,
excludedTagNames: ["Mac自带", defaultGroupName],
onRefresh: { refreshApps() }
)
}
}
// MARK: - Edit Apps View
private var editAppsView: some View {
VStack(spacing: 0) {
EditAppsHeaderView(
operation: editTagOperation,
hintText: editModeHintText,
confirmTitle: editConfirmTitle,
isConfirmDisabled: selectedAppPaths.isEmpty || pendingOperationTagNames.isEmpty,
notchHeight: notchHeight,
onExit: {
cancelEditApps()
setEditPhase(.none)
},
onSelectOperation: setEditTagOperation,
onConfirm: confirmAssign
)
Divider().opacity(0.3)
HStack(spacing: 0) {
VStack(alignment: .leading, spacing: 4) {
EditAppsSidebarIntroView(
width: editSidebarWidth,
horizontalInset: editSidebarHorizontalInset
)
ScrollView(.vertical, showsIndicators: false) {
VStack(spacing: 4) {
ForEach(sortedTagNames, id: \.self) { tagName in
selectableTagItem(tagName)
.opacity(dragItem == tagName ? 0.72 : 1.0)
.scaleEffect(dragItem == tagName ? 1.03 : 1.0)
.background(
GeometryReader { proxy in
Color.clear.preference(
key: TagReorderFramePreferenceKey.self,
value: [tagName: proxy.frame(in: .named("tagReorderList"))]
)
}
)
.zIndex(dragItem == tagName ? 1 : 0)
.highPriorityGesture(tagReorderGesture(for: tagName))
}
}
.padding(12)
.coordinateSpace(name: "tagReorderList")
.onPreferenceChange(TagReorderFramePreferenceKey.self) { frames in
tagReorderFrames = frames
}
}
.frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .topLeading)
}
.frame(width: editSidebarWidth, alignment: .topLeading)
Rectangle().fill(.secondary.opacity(0.12)).frame(width: 1)
if allApps.isEmpty {
Spacer(); ProgressView().scaleEffect(0.8); Spacer()
} else {
editAppsGrid
}
}
}
}
private var editAppsGrid: some View {
ScrollView {
LazyVStack(alignment: .leading, spacing: 24) {
ForEach(editGroups) { group in
editFlatGroup(group)
}
}
.padding(20)
}
.frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .topLeading)
}
private func editFlatGroup(_ group: TagGroup) -> some View {
VStack(alignment: .leading, spacing: 0) {
HStack(spacing: 0) {
Rectangle().fill(.secondary.opacity(0.25)).frame(height: 1)
Text(group.name)
.font(.system(size: tagFontSize, weight: .semibold))
.foregroundStyle(.secondary)
.padding(.horizontal, 10)
Rectangle().fill(.secondary.opacity(0.25)).frame(height: 1)
}
.padding(.bottom, 6)
LazyVGrid(
columns: [
GridItem(
.adaptive(
minimum: AppGridItem.stableWidth(iconSize: iconSize),
maximum: AppGridItem.stableWidth(iconSize: iconSize) + 36
),
spacing: 6
)
],
spacing: 2
) {
ForEach(group.apps) { app in editableAppItem(app) }
}
.frame(minHeight: group.apps.isEmpty ? max(52, iconSize + 12) : 0)
}
}
private func selectableTagItem(_ tagName: String) -> some View {
let isSelected = selectedTagNames.contains(tagName)
let isRemovableCandidate = removableTagNames.contains(tagName)
let isUncommon = tagName == TagDatabase.uncommonTagKey
let colorIndex = isUncommon ? 0 : (tagColors[tagName] ?? 0)
return EditSelectableTagItem(
tagName: tagName,
displayName: displayTagName(tagName),
colorIndex: colorIndex,
operation: editTagOperation,
isSelected: isSelected,
isRemovableCandidate: isRemovableCandidate
) {
if isSelected {
selectedTagNames.remove(tagName)
} else {
selectedTagNames.insert(tagName)
}
}
}
private func tagReorderGesture(for tagName: String) -> some Gesture {
DragGesture(minimumDistance: 4, coordinateSpace: .named("tagReorderList"))
.onChanged { value in
guard canReorderTag(tagName) else { return }
if dragItem == nil {
dragItem = tagName
}
guard dragItem == tagName else { return }
reorderDraggedTag(at: value.location)
}
.onEnded { _ in
guard canReorderTag(tagName) else { return }
dragItem = nil
TagEditor.reorderTags(draggedTagNames)
}
}
private func reorderDraggedTag(at location: CGPoint) {
guard let fromName = dragItem,
let targetName = tagReorderFrames.first(where: { $0.value.contains(location) })?.key,
fromName != targetName,
let fromIndex = draggedTagNames.firstIndex(of: fromName),
let toIndex = draggedTagNames.firstIndex(of: targetName)
else { return }
withAnimation(.easeInOut(duration: 0.14)) {
let destination = toIndex > fromIndex ? toIndex + 1 : toIndex
draggedTagNames.move(fromOffsets: IndexSet(integer: fromIndex), toOffset: destination)
}
}
private func confirmAssign() {
let selectedApps = allApps.filter { selectedAppPaths.contains($0.path) }
let tags = pendingOperationTagNames
guard !selectedApps.isEmpty, !tags.isEmpty else { return }
let paths = selectedApps.map { $0.path.path }
let feedback = buildEditActionFeedback(for: selectedApps, tags: tags)
switch editTagOperation {
case .add:
TagEditor.appendTags(tags, to: paths)
case .remove:
TagEditor.removeTags(tags, from: paths)
}
selectedAppPaths = []
selectedTagNames = []
removableTagNames = []
refreshApps()
showEditActionFeedback(feedback)
}
private func cancelEditApps() {
selectedAppPaths = []
selectedTagNames = []
removableTagNames = []
editTagOperation = .add
}
private func editableAppItem(_ app: AppInfo) -> some View {
let isSelected = selectedAppPaths.contains(app.path)
return EditableAppSelectionItem(
app: app,
iconSize: iconSize,
isSelected: isSelected
) {
toggleEditableAppSelection(app)
}
}
private func toggleEditableAppSelection(_ app: AppInfo) {
if selectedAppPaths.contains(app.path) {
selectedAppPaths.remove(app.path)
} else {
selectedAppPaths.insert(app.path)
}
syncSelectedTagsFromSelectedApps()
}
private func syncSelectedTagsFromSelectedApps() {
guard !selectedAppPaths.isEmpty else {
selectedTagNames = []
removableTagNames = []
return
}
guard editTagOperation == .remove else {
removableTagNames = []
return
}
let selectedApps = allApps.filter { selectedAppPaths.contains($0.path) }
let autoSelectedTags = selectedApps.reduce(into: Set()) { result, app in
result.formUnion(app.tags)
if app.isUncommon {
result.insert(TagDatabase.uncommonTagKey)
}
}
removableTagNames = autoSelectedTags
selectedTagNames = autoSelectedTags
}
private var editConfirmTitle: String {
switch editTagOperation {
case .add:
return tr("edit.confirmAdd")
case .remove:
return tr("edit.confirmRemove")
}
}
private func setEditTagOperation(_ mode: EditTagOperation) {
guard editTagOperation != mode else { return }
editTagOperation = mode
if mode == .add {
selectedTagNames = []
removableTagNames = []
} else {
syncSelectedTagsFromSelectedApps()
}
}
private var pendingOperationTagNames: [String] {
switch editTagOperation {
case .add:
return sortedTagNames.filter { selectedTagNames.contains($0) }
case .remove:
return sortedTagNames.filter { removableTagNames.contains($0) && !selectedTagNames.contains($0) }
}
}
private var editModeHintText: String {
editTagOperation == .remove ? tr("edit.removeHint") : tr("edit.modeHint")
}
private var editActionFeedbackOverlay: some View {
GeometryReader { proxy in
if let feedback = editActionFeedback {
ZStack {
Color.black.opacity(0.08)
.ignoresSafeArea()
EditActionFeedbackBubble(
title: feedback.title,
message: feedback.message,
onClose: dismissEditActionFeedback
)
.frame(width: min(760, max(360, proxy.size.width - 120)))
.position(x: proxy.size.width / 2, y: proxy.size.height / 2)
.transition(.scale(scale: 0.94).combined(with: .opacity))
}
.zIndex(700)
}
}
.ignoresSafeArea()
.allowsHitTesting(editActionFeedback != nil)
}
private var uncategorizedDropConfirmOverlay: some View {
GeometryReader { proxy in
if let pendingDrop = pendingUncategorizedDrop {
ZStack {
Color.black.opacity(0.14)
.ignoresSafeArea()
UncategorizedDropConfirmBubble(
title: tr("drop.uncategorizedConfirmTitle"),
message: uncategorizedConfirmMessage(for: pendingDrop),
cancelTitle: tr("tag.cancel"),
confirmTitle: tr("edit.confirm"),
onCancel: dismissUncategorizedDropConfirm,
onConfirm: confirmPendingUncategorizedDrop
)
.frame(width: min(540, max(340, proxy.size.width - 120)))
.position(x: proxy.size.width / 2, y: proxy.size.height / 2)
.transition(.scale(scale: 0.94).combined(with: .opacity))
}
.zIndex(710)
}
}
.ignoresSafeArea()
.allowsHitTesting(pendingUncategorizedDrop != nil)
}
private func buildEditActionFeedback(for selectedApps: [AppInfo], tags: [String]) -> EditActionFeedback {
let appNames = selectedApps.map(\.name)
.joined(separator: localizedListSeparator)
switch editTagOperation {
case .add:
let actualAddCount = selectedApps.reduce(into: 0) { count, app in
count += tags.reduce(into: 0) { subtotal, tagName in
if !appHasTag(app, tagName: tagName) {
subtotal += 1
}
}
}
return EditActionFeedback(
title: tr("edit.confirmAdd"),
message: formattedFeedbackMessage(
forKey: "edit.feedbackAddFormat",
replacements: [
"%appCount%": "\(selectedApps.count)",
"%appNames%": appNames,
"%tagCount%": "\(actualAddCount)"
]
)
)
case .remove:
let actualRemovedTagNames = tags.filter { tagName in
selectedApps.contains(where: { appHasTag($0, tagName: tagName) })
}
let actualRemoveCount = selectedApps.reduce(into: 0) { count, app in
count += tags.reduce(into: 0) { subtotal, tagName in
if appHasTag(app, tagName: tagName) {
subtotal += 1
}
}
}
return EditActionFeedback(
title: tr("edit.confirmRemove"),
message: formattedFeedbackMessage(
forKey: "edit.feedbackRemoveFormat",
replacements: [
"%appCount%": "\(selectedApps.count)",
"%appNames%": appNames,
"%tagCount%": "\(actualRemoveCount)",
"%tagNames%": actualRemovedTagNames
.map(displayTagName)
.joined(separator: localizedListSeparator)
]
)
)
}
}
private func appHasTag(_ app: AppInfo, tagName: String) -> Bool {
if tagName == TagDatabase.uncommonTagKey {
return app.isUncommon
}
return app.tags.contains(tagName)
}
private func formattedFeedbackMessage(forKey key: String, replacements: [String: String]) -> String {
replacements.reduce(tr(key)) { partial, replacement in
partial.replacingOccurrences(of: replacement.key, with: replacement.value)
}
}
private func showEditActionFeedback(_ feedback: EditActionFeedback) {
let feedbackID = feedback.id
withAnimation(.spring(response: 0.24, dampingFraction: 0.82)) {
editActionFeedback = feedback
}
DispatchQueue.main.asyncAfter(deadline: .now() + 2.6) {
guard editActionFeedback?.id == feedbackID else { return }
dismissEditActionFeedback()
}
}
private func dismissEditActionFeedback() {
withAnimation(.easeOut(duration: 0.18)) {
editActionFeedback = nil
}
}
private func showSmartStartNotice(
mode: SmartStartNoticeMode,
summary: SmartStartSummary
) {
let titleKey: String
let messageKey: String
switch mode {
case .autoApplied:
titleKey = "smartstart.auto.title"
messageKey = "smartstart.auto.messageFormat"
case .suggestionOnly:
titleKey = "smartstart.suggestion.title"
messageKey = "smartstart.suggestion.messageFormat"
case .manuallyApplied:
titleKey = "smartstart.applied.title"
messageKey = "smartstart.applied.messageFormat"
}
let notice = SmartStartNotice(
mode: mode,
title: tr(titleKey),
message: formattedFeedbackMessage(
forKey: messageKey,
replacements: [
"%appCount%": "\(summary.matchedAppCount)",
"%tagCount%": "\(summary.assignedTagCount)",
"%createdTagCount%": "\(summary.createdTagCount)"
]
),
summary: summary
)
withAnimation(.spring(response: 0.28, dampingFraction: 0.86)) {
smartStartNotice = notice
}
}
private func handleSmartStartRunResult(_ result: SmartStartRunResult) {
switch result.mode {
case .none:
return
case .autoApplied:
pendingSmartStartDraft = nil
if let summary = result.summary {
showSmartStartNotice(mode: .autoApplied, summary: summary)
}
case .suggestionOnly:
pendingSmartStartDraft = result.draft
if let summary = result.summary {
showSmartStartNotice(mode: .suggestionOnly, summary: summary)
}
}
}
private func applySmartStartSuggestion() {
guard let draft = pendingSmartStartDraft else {
dismissSmartStartNotice()
return
}
let scannedApps = allApps
DispatchQueue.global(qos: .userInitiated).async {
let result = SmartStartService.applySuggestion(draft)
let store = result.store
let apps = TagEditor.annotate(apps: scannedApps, store: store)
let colors = store.tags.mapValues { $0.color }
let order = TagEditor.orderedTagNames()
DispatchQueue.main.async {
pendingSmartStartDraft = nil
allApps = apps
tagColors = colors
draggedTagNames = order
if let summary = result.summary {
showSmartStartNotice(mode: .manuallyApplied, summary: summary)
} else {
dismissSmartStartNotice()
}
}
}
}
private func undoSmartStart() {
guard let backupPath = smartStartNotice?.summary.backupPath else {
dismissSmartStartNotice()
return
}
DispatchQueue.global(qos: .userInitiated).async {
let restored = SmartStartService.restoreBackup(at: backupPath)
DispatchQueue.main.async {
pendingSmartStartDraft = nil
dismissSmartStartNotice()
if restored {
refreshApps(forceLayoutRefresh: true)
}
}
}
}
private func dismissSmartStartNotice() {
withAnimation(.easeOut(duration: 0.18)) {
smartStartNotice = nil
}
}
private var localizedListSeparator: String {
switch L10n.currentCode {
case "zh-Hans", "zh-Hant", "ja":
return "、"
case "ar", "ar-Najdi":
return "، "
default:
return ", "
}
}
// MARK: - Computed
private var sortedTagNames: [String] {
let filtered = tagColors.keys.filter { $0 != "Mac自带" && $0 != defaultGroupName }
// Use user-defined order, fall back to alpha
let ordered = draggedTagNames.filter { filtered.contains($0) }
let remaining = filtered.filter { !ordered.contains($0) }.sorted()
return ordered + remaining + [TagDatabase.uncommonTagKey]
}
private func displayTagName(_ tagName: String) -> String {
tagName == TagDatabase.uncommonTagKey ? tr("group.uncommon") : tagName
}
private var tagLabels: [TagLabel] {
groups.map { TagLabel(name: $0.name, colorIndex: tagColors[$0.name] ?? 0) }
}
private var groups: [TagGroup] {
let order = draggedTagNames.isEmpty
? TagEditor.orderedTagNames()
: draggedTagNames
let raw = AppIndexer.group(apps: allApps, defaultGroupName: defaultGroupName, tagOrder: order)
// Translate stable keys for display
return raw.map { group in
if group.name == defaultGroupName {
return TagGroup(name: tr("group.uncategorized"), apps: group.apps)
}
if group.name == "Mac自带" {
return TagGroup(name: tr("group.appleBuiltIn"), apps: group.apps)
}
return group
}
}
private var editGroups: [TagGroup] {
groups + [
TagGroup(
name: tr("group.uncommon"),
apps: allApps.filter(\.isUncommon).sorted {
$0.name.localizedStandardCompare($1.name) == .orderedAscending
}
)
]
}
// MARK: - Actions
private func refreshNotchHeight() {
let mousePoint = NSEvent.mouseLocation
let activeScreen = NSScreen.screens.first(where: {
NSMouseInRect(mousePoint, $0.frame, false)
}) ?? NSScreen.main
notchHeight = activeScreen?.safeAreaInsets.top ?? 0
}
private func handleBubbleHover(app: AppInfo, frame: CGRect, event: AppBubbleHoverEvent) {
guard !appBubbleDisabled else {
clearAppBubbleState()
return
}
guard editingBubble == nil else { return }
switch event {
case .entered(let canShowBubble):
if canShowBubble {
hoveredBubble = AppBubbleContext(app: app, frame: frame)
} else {
hoveredBubble = nil
}
case .exited:
guard hoveredBubble?.app.path == app.path else { return }
hoveredBubble = nil
}
}
private func beginEditingBubbleNote(app: AppInfo, frame: CGRect) {
guard !appBubbleDisabled else {
clearAppBubbleState()
return
}
bubbleDraftNote = currentNote(for: app)
hoveredBubble = nil
editingBubble = AppBubbleContext(app: app, frame: frame)
notifyAppNoteEditing(active: true)
DispatchQueue.main.async {
bubbleNoteFocused = true
}
}
private func commitBubbleNote() {
guard let context = editingBubble else { return }
let limited = String(bubbleDraftNote.prefix(TagDatabase.maxAppNoteLength))
.trimmingCharacters(in: .whitespacesAndNewlines)
TagEditor.setAppNote(limited, for: context.app.path.path)
bubbleDraftNote = limited
editingBubble = nil
bubbleNoteFocused = false
notifyAppNoteEditing(active: false)
refreshApps()
}
private func dismissAppBubble() {
hoveredBubble = nil
if editingBubble != nil {
notifyAppNoteEditing(active: false)
}
editingBubble = nil
bubbleNoteFocused = false
}
private func clearAppBubbleState() {
hoveredAppItemID = nil
hoveredBubble = nil
if editingBubble != nil {
notifyAppNoteEditing(active: false)
}
editingBubble = nil
bubbleNoteFocused = false
}
private func notifyAppNoteEditing(active: Bool) {
NotificationCenter.default.post(
name: .tagLauncherAppNoteEditingChanged,
object: nil,
userInfo: ["active": active]
)
}
private func currentNote(for app: AppInfo) -> String {
if let latest = allApps.first(where: { $0.path == app.path })?.note {
return latest
}
return app.note ?? ""
}
private func bubblePlacement(for frame: CGRect, rootFrame: CGRect) -> BubblePlacement {
frame.minY < 170 ? .below : .above
}
private func bubbleMetrics(
for context: AppBubbleContext,
rootFrame: CGRect,
rootSize: CGSize,
width: CGFloat,
placement: BubblePlacement,
isEditing: Bool
) -> AppBubbleMetrics {
let appCenterX = context.frame.midX
let halfWidth = width / 2
let centerX = min(max(appCenterX, halfWidth + 24), max(halfWidth + 24, rootSize.width - halfWidth - 24))
let estimatedHeight = estimatedBubbleHeight(for: context.app, width: width, isEditing: isEditing)
let gap: CGFloat = 16
let topY: CGFloat
if placement == .below {
topY = context.frame.maxY + gap
} else {
topY = context.frame.minY - estimatedHeight - gap
}
let clampedTopY = min(max(topY, 14), max(14, rootSize.height - estimatedHeight - 14))
let arrowX = min(max(appCenterX, centerX - halfWidth + 28), centerX + halfWidth - 28)
return AppBubbleMetrics(
centerX: centerX,
centerY: clampedTopY + estimatedHeight / 2,
arrowX: arrowX,
arrowOffset: arrowX - centerX
)
}
private func estimatedBubbleHeight(for app: AppInfo, width: CGFloat, isEditing: Bool) -> CGFloat {
if isEditing {
return 120
}
let note = currentNote(for: app).trimmingCharacters(in: .whitespacesAndNewlines)
guard !note.isEmpty else { return 68 }
let contentWidth = max(160, width - 48)
let approxCharsPerLine = max(16, Int(contentWidth / 14))
let lines = min(4, max(1, Int(ceil(Double(note.count) / Double(approxCharsPerLine)))))
return 70 + CGFloat(lines) * 20
}
func scrollTo(_ id: String) {
withAnimation(.easeInOut(duration: 0.25)) { scrollProxy?.scrollTo(id, anchor: .top) }
}
private func activateTagNavigation(_ id: String) {
cancelTagNavReorderVisualState()
if isColorlessContainerMode {
toggleColorlessFill(id)
}
scrollTo(id)
}
private func fillColorlessContainer(_ id: String) {
guard isColorlessContainerMode else { return }
guard filledColorlessContainer != id else { return }
filledColorlessContainer = id
}
private func toggleColorlessFill(_ id: String) {
guard isColorlessContainerMode else { return }
filledColorlessContainer = (filledColorlessContainer == id) ? nil : id
}
private func canReorderTag(_ name: String) -> Bool {
tagColors[name] != nil && name != "Mac自带" && name != defaultGroupName
}
private func tagNavFrameReader(for tagName: String) -> some View {
GeometryReader { proxy in
Color.clear.preference(
key: TagNavReorderFramePreferenceKey.self,
value: canReorderTag(tagName)
? [tagName: proxy.frame(in: .named("tagNavReorder"))]
: [:]
)
}
}
private func tagNavReorderGesture(for tagName: String) -> some Gesture {
LongPressGesture(minimumDuration: 0.35)
.sequenced(before: DragGesture(minimumDistance: 0, coordinateSpace: .named("tagNavReorder")))
.onChanged { value in
guard canReorderTag(tagName) else { return }
switch value {
case .second(true, let drag?):
if tagNavDragItem == nil {
beginTagNavReorder(tagName)
}
reorderTagNavItem(at: drag.location)
default:
break
}
}
.onEnded { value in
guard canReorderTag(tagName) else { return }
if case .second(true, let drag?) = value {
reorderTagNavItem(at: drag.location)
}
endTagNavReorder()
}
}
private func beginTagNavReorder(_ tagName: String) {
guard canReorderTag(tagName) else { return }
if tagNavDragItem == nil {
tagNavDragItem = tagName
tagNavReorderDidMove = false
}
tagNavDragModeActive = true
}
private func endTagNavReorder() {
if tagNavDragModeActive && tagNavReorderDidMove {
TagEditor.reorderTags(draggedTagNames)
}
tagNavDragModeActive = false
tagNavDragItem = nil
tagNavReorderDidMove = false
tagNavDragResetToken &+= 1
}
private func cancelTagNavReorderVisualState() {
guard tagNavDragModeActive || tagNavDragItem != nil else { return }
tagNavDragModeActive = false
tagNavDragItem = nil
tagNavReorderDidMove = false
tagNavDragResetToken &+= 1
}
private func reorderTagNavItem(at location: CGPoint) {
guard let fromName = tagNavDragItem,
let targetName = tagNavReorderFrames.first(where: { $0.value.contains(location) })?.key,
fromName != targetName,
let fromIndex = draggedTagNames.firstIndex(of: fromName),
let toIndex = draggedTagNames.firstIndex(of: targetName)
else { return }
tagNavReorderDidMove = true
withAnimation(.spring(response: 0.22, dampingFraction: 0.82)) {
let destination = toIndex > fromIndex ? toIndex + 1 : toIndex
draggedTagNames.move(fromOffsets: IndexSet(integer: fromIndex), toOffset: destination)
}
}
private func handleAppDrop(_ providers: [NSItemProvider], targetTag: String) -> Bool {
guard let provider = providers.first(where: { $0.hasItemConformingToTypeIdentifier(UTType.plainText.identifier) }) else {
return false
}
provider.loadItem(forTypeIdentifier: UTType.plainText.identifier, options: nil) { item, _ in
let text: String?
if let data = item as? Data {
text = String(data: data, encoding: .utf8)
} else if let string = item as? String {
text = string
} else if let string = item as? NSString {
text = string as String
} else {
text = nil
}
guard let text else { return }
let parts = text.components(separatedBy: "\n")
guard let path = parts.first, !path.isEmpty else { return }
let source = parts.dropFirst().first ?? ""
let copy = NSEvent.modifierFlags.contains(.option)
DispatchQueue.main.async {
dropApp(path: path, sourceTag: source, targetTag: targetTag, copy: copy)
}
}
return true
}
private func dropApp(path: String, sourceTag: String, targetTag: String, copy: Bool) {
resetTransientDragState(keepingPendingUncategorizedDrop: true)
if isUncategorizedDropTarget(targetTag) {
confirmAndMoveAppToUncategorized(path: path)
return
}
guard !isAppleBuiltInDropTarget(targetTag) else {
showDropWarning()
return
}
guard tagColors[targetTag] != nil else { return }
guard sourceTag != targetTag || copy else { return }
TagEditor.moveApp(
path: path,
from: sourceTag,
to: targetTag,
color: tagColors[targetTag] ?? 0,
copy: copy
)
showDropRefresh()
refreshApps(forceLayoutRefresh: true)
}
private func confirmAndMoveAppToUncategorized(path: String) {
guard let app = allApps.first(where: { $0.path.path == path }) else { return }
let assignedTags = assignedRegularDisplayTags(for: app)
guard !assignedTags.isEmpty else { return }
clearAppBubbleState()
withAnimation(.spring(response: 0.24, dampingFraction: 0.84)) {
pendingUncategorizedDrop = PendingUncategorizedDrop(app: app, assignedTags: assignedTags)
}
}
private func assignedRegularDisplayTags(for app: AppInfo) -> [String] {
var result: [String] = []
for tag in app.tags {
let name = displayTagName(tag)
if !result.contains(name) {
result.append(name)
}
}
return result
}
private func uncategorizedConfirmMessage(for pendingDrop: PendingUncategorizedDrop) -> String {
formattedFeedbackMessage(
forKey: "drop.uncategorizedConfirmMessage",
replacements: [
"%appName%": pendingDrop.app.name,
"%tagCount%": "\(pendingDrop.assignedTags.count)",
"%tagNames%": pendingDrop.assignedTags.joined(separator: localizedListSeparator)
]
)
}
private func dismissUncategorizedDropConfirm() {
resetTransientDragState(keepingPendingUncategorizedDrop: true)
withAnimation(.easeOut(duration: 0.18)) {
pendingUncategorizedDrop = nil
}
}
private func confirmPendingUncategorizedDrop() {
guard let pendingDrop = pendingUncategorizedDrop else { return }
let path = pendingDrop.app.path.path
let tags = pendingDrop.app.tags
resetTransientDragState(keepingPendingUncategorizedDrop: true)
withAnimation(.easeOut(duration: 0.16)) {
pendingUncategorizedDrop = nil
}
TagEditor.removeTags(tags, from: [path])
showDropRefresh()
refreshApps(forceLayoutRefresh: true)
}
private func isUncategorizedDropTarget(_ targetTag: String) -> Bool {
let defaultNames = [
defaultGroupName,
tr("group.uncategorized")
]
return defaultNames.contains(targetTag)
}
private func isAppleBuiltInDropTarget(_ targetTag: String) -> Bool {
let defaultNames = [
"Mac自带",
tr("group.appleBuiltIn")
]
return defaultNames.contains(targetTag)
}
private func showDropWarning() {
withAnimation(.spring(response: 0.24, dampingFraction: 0.82)) {
dropWarningToast = tr("drop.systemDefaultWarning")
}
DispatchQueue.main.asyncAfter(deadline: .now() + 1.6) {
withAnimation(.easeOut(duration: 0.18)) {
dropWarningToast = nil
}
}
}
private func showDropRefresh() {
dropRefreshStartedAt = Date()
withAnimation(.spring(response: 0.22, dampingFraction: 0.82)) {
dropRefreshVisible = true
}
}
private func finishDropRefreshAfterMinimumDuration() {
let minimumDuration: TimeInterval = 0.85
let elapsed = dropRefreshStartedAt.map { Date().timeIntervalSince($0) } ?? minimumDuration
let delay = max(0, minimumDuration - elapsed)
DispatchQueue.main.asyncAfter(deadline: .now() + delay) {
withAnimation(.easeOut(duration: 0.18)) {
dropRefreshVisible = false
}
dropRefreshStartedAt = nil
}
}
private func setAppDragMode(_ active: Bool) {
if active {
endTagNavReorder()
clearAppBubbleState()
}
appDragModeActive = active
if active {
DispatchQueue.main.asyncAfter(deadline: .now() + 8) {
if appDragModeActive {
appDragModeActive = false
}
}
}
}
private func resetTransientDragState(keepingPendingUncategorizedDrop: Bool = false) {
AppDragCoordinator.shared.cancelDrag()
appDragModeActive = false
appDragResetToken &+= 1
tagNavDragModeActive = false
tagNavDragItem = nil
tagNavReorderDidMove = false
tagNavDragResetToken &+= 1
dragItem = nil
hoveredAppItemID = nil
hoveredContainer = nil
clearAppBubbleState()
if !keepingPendingUncategorizedDrop {
pendingUncategorizedDrop = nil
}
}
func refreshApps(forceLayoutRefresh: Bool = false) {
guard !refreshInProgress else {
if forceLayoutRefresh {
refreshAgainAfterCurrent = true
refreshAgainForceLayout = true
}
return
}
refreshInProgress = true
DispatchQueue.global(qos: .userInitiated).async {
let scannedApps = AppIndexer.scan()
let reconciledStore = TagEditor.reconcileScannedApps(scannedApps)
let smartStartResult = SmartStartService.runIfNeeded(
apps: scannedApps,
store: reconciledStore
)
let store = smartStartResult.store
let apps = TagEditor.annotate(apps: scannedApps, store: store)
let quickSearchDocs = QuickSearchEngine.makeDocuments(apps: apps, store: store)
let colors = store.tags.mapValues { $0.color }
let order = TagEditor.orderedTagNames()
DispatchQueue.main.async {
allApps = apps
quickSearchDocuments = quickSearchDocs
tagColors = colors
draggedTagNames = order
if quickSearchVisible {
refreshQuickSearchResults()
}
handleSmartStartRunResult(smartStartResult)
if forceLayoutRefresh {
finishDropRefreshAfterMinimumDuration()
}
refreshInProgress = false
if refreshAgainAfterCurrent {
let shouldForceLayout = refreshAgainForceLayout
refreshAgainAfterCurrent = false
refreshAgainForceLayout = false
refreshApps(forceLayoutRefresh: shouldForceLayout)
}
}
}
}
private func launchApp(
_ app: AppInfo,
closeQuickSearchOnSuccess: Bool = false,
closeOverlayOnSuccess: Bool = true,
onFailure: (() -> Void)? = nil
) {
appDragModeActive = false
endTagNavReorder()
let configuration = NSWorkspace.OpenConfiguration()
NSWorkspace.shared.openApplication(at: app.path, configuration: configuration) { _, error in
DispatchQueue.main.async {
guard error == nil else {
onFailure?()
return
}
DispatchQueue.global(qos: .utility).async {
TagEditor.recordLauncherOpen(for: app.path.path)
}
if closeQuickSearchOnSuccess {
closeQuickSearch(hideOverlayIfNeeded: false)
}
if closeOverlayOnSuccess {
hideOverlay()
}
}
}
}
func openApp(_ app: AppInfo) {
launchApp(app)
}
}
// MARK: - Tag Label
private struct TagReorderFramePreferenceKey: PreferenceKey {
static var defaultValue: [String: CGRect] = [:]
static func reduce(value: inout [String: CGRect], nextValue: () -> [String: CGRect]) {
value.merge(nextValue(), uniquingKeysWith: { _, new in new })
}
}
private struct TagNavReorderFramePreferenceKey: PreferenceKey {
static var defaultValue: [String: CGRect] = [:]
static func reduce(value: inout [String: CGRect], nextValue: () -> [String: CGRect]) {
value.merge(nextValue(), uniquingKeysWith: { _, new in new })
}
}
private struct TagLabel: Identifiable {
var id: String { name }
let name: String
let colorIndex: Int
}
// MARK: - NSVisualEffectView bridge
struct VisualEffectView: NSViewRepresentable {
let material: NSVisualEffectView.Material
let blendingMode: NSVisualEffectView.BlendingMode
func makeNSView(context: Context) -> NSVisualEffectView {
let view = NSVisualEffectView()
view.material = material
view.blendingMode = blendingMode
view.state = .active
return view
}
func updateNSView(_ nsView: NSVisualEffectView, context: Context) {
nsView.material = material
nsView.blendingMode = blendingMode
}
}
