From 1a7643b2e7e8f9712533e5a68536ee3b23b0804b Mon Sep 17 00:00:00 2001
From: Ariver <ar@MacBook-Air.local>
Date: Mon, 11 May 2026 11:51:02 +0800
Subject: [PATCH] Implement CALayer drag preview for 5.2.0
---
Apptag/ContentView.swift | 766 ++++++++++++++++++++++++++++++++++++++++++++++++++++------
1 files changed, 680 insertions(+), 86 deletions(-)
diff --git a/Apptag/ContentView.swift b/Apptag/ContentView.swift
index c399bac..b8833eb 100644
--- a/Apptag/ContentView.swift
+++ b/Apptag/ContentView.swift
@@ -1,11 +1,11 @@
import SwiftUI
import AppKit
+import UniformTypeIdentifiers
// MARK: - Notification for manual re-index
extension Notification.Name {
- static let apptagReindex = Notification.Name("ApptagReindex")
- static let apptagEditModeChanged = Notification.Name("ApptagEditModeChanged")
+ static let tagLauncherEditModeChanged = Notification.Name("TagLauncherEditModeChanged")
}
// MARK: - Edit Phase
@@ -203,6 +203,12 @@
@State private var selectedTagNames: Set<String> = []
@State private var successToast: String? = nil
@State private var draggedTagNames: [String] = [] // live drag order
+ @State private var dragItem: String? = nil // currently dragged tag
+ @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
// Configurable defaults
@AppStorage("defaultGroupName") private var defaultGroupName = "Other"
@@ -210,9 +216,19 @@
@AppStorage("iconSize") private var iconSize: Double = 56
@AppStorage("tagPosition") private var tagPosition = "left"
@State private var notchHeight: CGFloat = 0
+ @AppStorage("displayMode") private var displayMode = "flat"
+ @AppStorage("hideAppNames") private var hideAppNames = false
private var isSideLayout: Bool {
tagPosition == "left" || tagPosition == "right"
+ }
+
+ private var isColorlessContainerMode: Bool {
+ displayMode == "container" || displayMode == "gridContainer"
+ }
+
+ private var isColoredContainerMode: Bool {
+ displayMode == "coloredContainer" || displayMode == "coloredGridContainer"
}
var body: some View {
@@ -239,6 +255,21 @@
case .editingApps:
editAppsView
}
+
+ if 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)
+ }
}
.onAppear {
let mousePoint = NSEvent.mouseLocation
@@ -251,13 +282,10 @@
.onReceive(NotificationCenter.default.publisher(for: NSApplication.didBecomeActiveNotification)) { _ in
refreshApps()
}
- .onReceive(NotificationCenter.default.publisher(for: .apptagReindex)) { _ in
- refreshApps()
- }
.onChange(of: editPhase) { _, newPhase in
let active = newPhase != .none
NotificationCenter.default.post(
- name: .apptagEditModeChanged,
+ name: .tagLauncherEditModeChanged,
object: nil,
userInfo: ["active": active]
)
@@ -267,17 +295,17 @@
/// Set edit phase with synchronous notification BEFORE state change.
func setEditPhase(_ phase: EditPhase) {
if phase != .none {
- NotificationCenter.default.post(name: .apptagEditModeChanged, object: nil, userInfo: ["active": true])
+ NotificationCenter.default.post(name: .tagLauncherEditModeChanged, object: nil, userInfo: ["active": true])
NSApp.activate(ignoringOtherApps: true)
- // Sync drag order from database when entering edit mode
- if draggedTagNames.isEmpty {
- draggedTagNames = TagEditor.orderedTagNames()
- }
+ // 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 {
DispatchQueue.main.async {
- NotificationCenter.default.post(name: .apptagEditModeChanged, object: nil, userInfo: ["active": false])
+ NotificationCenter.default.post(name: .tagLauncherEditModeChanged, object: nil, userInfo: ["active": false])
}
}
}
@@ -336,7 +364,18 @@
HStack(spacing: 8) {
ForEach(tagLabels) { tag in
TagPill(name: tag.name, colorIndex: tag.colorIndex,
- action: { scrollTo(tag.id) })
+ action: {
+ if isColorlessContainerMode {
+ toggleColorlessFill(tag.id)
+ }
+ scrollTo(tag.id)
+ })
+ .onHover { hovering in
+ if hovering {
+ fillColorlessContainer(tag.id)
+ scrollTo(tag.id)
+ }
+ }
}
}.padding(.horizontal, 24)
}
@@ -347,7 +386,18 @@
VStack(spacing: 6) {
ForEach(tagLabels) { tag in
SideTagPill(name: tag.name, colorIndex: tag.colorIndex,
- action: { scrollTo(tag.id) })
+ action: {
+ if isColorlessContainerMode {
+ toggleColorlessFill(tag.id)
+ }
+ scrollTo(tag.id)
+ })
+ .onHover { hovering in
+ if hovering {
+ fillColorlessContainer(tag.id)
+ scrollTo(tag.id)
+ }
+ }
}
}.padding(12)
}.frame(width: 135)
@@ -363,22 +413,434 @@
Spacer()
ProgressView().scaleEffect(0.8)
Spacer()
+ } else if displayMode == "gridContainer" || displayMode == "coloredGridContainer" {
+ gridContainerGrid
+ } else if displayMode == "container" || displayMode == "coloredContainer" {
+ containerGrid
} else {
- 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
- ).id(group.id)
+ flatGrid
+ }
+ }
+ }
+
+ 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) },
+ onDropApp: { path, source, copy in
+ dropApp(path: path, sourceTag: source, targetTag: group.name, copy: copy)
}
- }.padding(20)
- }.onAppear { scrollProxy = proxy }
+ ).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..<colCount, id: \.self) { ci in
+ LazyVStack(spacing: gap) {
+ ForEach(columns[ci]) { group in
+ masonryCard(group, width: actualColW)
+ .id(group.id)
+ }
+ }
+ }
+ }
+ .padding(outerPad)
+ }
+ .id(displayMode) // force rebuild on mode switch
+ .onAppear { scrollProxy = proxy }
+ }
+ }
+ }
+
+ /// Distribute groups to the shortest column.
+ private func distributeToColumns(groups: [TagGroup], colCount: Int, colWidth: CGFloat) -> [[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 = iconSize + 28 + 6
+ let perRow = max(1, Int(inner / itemW))
+ let rows = (group.apps.count + perRow - 1) / perRow
+ return 32 + CGFloat(rows) * (iconSize + 30)
+ }
+
+ 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 = iconSize + 28
+ 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) },
+ 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 ? 18 : 0,
+ y: (isColored && isHovered) || isColorlessActive ? 10 : 0)
+ .scaleEffect(isColored && isHovered ? 1.015 : 1.0)
+ .animation(.spring(response: 0.25, dampingFraction: 0.82), value: isHovered)
+ .animation(.spring(response: 0.25, dampingFraction: 0.82), 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, iconSize * 3 + 88)
+ 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 = iconSize + 34
+ 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) },
+ onSelect: { openApp(app) }
+ )
+ .frame(width: cellWidth)
+ .frame(height: cellHeight)
+ }
+
+ let emptyCells = max(0, cols - rows[rowIndex].count)
+ ForEach(0..<emptyCells, id: \.self) { _ in
+ Color.clear
+ .frame(width: cellWidth, height: cellHeight)
+ }
+ }
+ .frame(height: cellHeight)
+ }
+ }
+ .frame(height: gridHeight, alignment: .topLeading)
+ }
+ .frame(width: contentWidth)
+ .padding(16)
+ .background(
+ RoundedRectangle(cornerRadius: 14)
+ .fill((isColored || isColorlessGridActive) ? 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) || isColorlessGridActive ? 0.22 : 0),
+ radius: (isColored && isHovered) || isColorlessGridActive ? 18 : 0,
+ y: (isColored && isHovered) || isColorlessGridActive ? 10 : 0)
+ .scaleEffect(isColored && isHovered ? 1.015 : 1.0)
+ .animation(.spring(response: 0.25, dampingFraction: 0.82), value: isHovered)
+ .animation(.spring(response: 0.25, dampingFraction: 0.82), value: isColorlessFilled)
+ .onHover { hovering in
+ if isColored || isColorlessGrid {
+ hoveredContainer = hovering ? group.name : nil
+ } else if hovering {
+ fillColorlessContainer(group.name)
+ }
+ }
+ .contentShape(RoundedRectangle(cornerRadius: 14))
+ .onTapGesture {
+ if isColorlessGrid {
+ toggleColorlessFill(group.name)
+ }
+ }
+ .onDrop(of: [UTType.plainText], isTargeted: nil) { providers in
+ handleAppDrop(providers, targetTag: group.name)
+ }
+ }
+
+ private func iconCellHeight() -> CGFloat {
+ iconSize + (hideAppNames ? 16 : 42)
+ }
+
+ private func appRows(_ apps: [AppInfo], columns: Int, fixedRows: Int) -> [[AppInfo]] {
+ let columns = max(1, columns)
+ let rowCount = max(1, fixedRows)
+ return (0..<rowCount).map { rowIndex in
+ let start = rowIndex * columns
+ guard start < apps.count else { return [] }
+ let end = min(start + columns, apps.count)
+ return Array(apps[start..<end])
}
}
@@ -390,12 +852,12 @@
Button {
setEditPhase(.none)
} label: {
- Label("Exit editing", systemImage: "rectangle.portrait.and.arrow.right")
+ Label(tr("edit.exit"), systemImage: "rectangle.portrait.and.arrow.right")
.font(.system(size: 12))
}
.buttonStyle(.bordered)
Spacer()
- Text("Edit Tags").font(.headline)
+ Text(tr("edit.tags")).font(.headline)
Spacer()
}
.padding(.horizontal, 24)
@@ -418,14 +880,14 @@
VStack(spacing: 0) {
HStack {
Button { cancelEditApps(); setEditPhase(.none) } label: {
- Label("Exit editing", systemImage: "rectangle.portrait.and.arrow.right")
+ Label(tr("edit.exit"), systemImage: "rectangle.portrait.and.arrow.right")
.font(.system(size: 12))
}
.buttonStyle(.bordered)
Spacer()
- Text("Edit App Categories").font(.headline)
+ Text(tr("edit.title")).font(.headline)
Spacer()
- Button("Confirm") { confirmAssign() }
+ Button(tr("edit.confirm")) { confirmAssign() }
.buttonStyle(.borderedProminent)
.disabled(selectedAppPaths.isEmpty || selectedTagNames.isEmpty)
}
@@ -437,47 +899,40 @@
HStack(spacing: 0) {
VStack(alignment: .leading, spacing: 4) {
- Text("Select tags:").font(.caption).foregroundStyle(.secondary).padding(.bottom, 4)
- List {
- ForEach(sortedTagNames, id: \.self) { tagName in
- selectableTagItem(tagName)
- }
- .onMove { from, to in
- var names = sortedTagNames
- names.move(fromOffsets: from, toOffset: to)
- // Persist the new order
- let fullOrder = TagEditor.orderedTagNames()
- let otherTags = fullOrder.filter { !names.contains($0) }
- draggedTagNames = names + otherTags
- TagEditor.reorderTags(draggedTagNames)
- }
- }
- .listStyle(.plain)
- .scrollContentBackground(.hidden)
- .frame(width: 170)
+ Text(tr("edit.selectTags")).font(.caption).foregroundStyle(.secondary).padding(.bottom, 4)
+ Text(tr("edit.dragHint")).font(.caption2).foregroundStyle(.tertiary).padding(.bottom, 2)
+ ScrollView(.vertical, showsIndicators: false) {
+ VStack(spacing: 4) {
+ ForEach(sortedTagNames, id: \.self) { tagName in
+ selectableTagItem(tagName)
+ .onDrag {
+ dragItem = tagName
+ return NSItemProvider(object: tagName as NSString)
+ }
+ .onDrop(of: [.text], isTargeted: nil) { providers, _ in
+ guard let fromName = dragItem,
+ var names = draggedTagNames as [String]?,
+ let fromIdx = names.firstIndex(of: fromName),
+ let toIdx = names.firstIndex(of: tagName),
+ fromIdx != toIdx
+ else { return false }
+ let toOffset = toIdx > fromIdx ? toIdx + 1 : toIdx
+ names.move(fromOffsets: [fromIdx], toOffset: toOffset)
+ draggedTagNames = names
+ TagEditor.reorderTags(names)
+ dragItem = nil
+ return true
+ }
+ }
+ }.padding(12)
+ }.frame(width: 155)
}
Rectangle().fill(.secondary.opacity(0.12)).frame(width: 1)
if allApps.isEmpty {
Spacer(); ProgressView().scaleEffect(0.8); Spacer()
} else {
- ScrollView {
- LazyVStack(alignment: .leading, spacing: 24) {
- ForEach(groups) { group in
- VStack(alignment: .leading, spacing: 6) {
- 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)
- }
- LazyVGrid(columns: [GridItem(.adaptive(minimum: iconSize + 28, maximum: iconSize + 64), spacing: 6)], spacing: 2) {
- ForEach(group.apps) { app in editableAppItem(app) }
- }
- }
- }
- }.padding(20)
- }
+ editAppsGrid
}
}
@@ -495,24 +950,55 @@
}
}
+ private var editAppsGrid: some View {
+ ScrollView {
+ LazyVStack(alignment: .leading, spacing: 24) {
+ ForEach(groups) { group in
+ editFlatGroup(group)
+ }
+ }
+ .padding(20)
+ }
+ }
+
+ 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: iconSize + 28, maximum: iconSize + 64), spacing: 6)],
+ spacing: 2
+ ) {
+ ForEach(group.apps) { app in editableAppItem(app) }
+ }
+ }
+ }
+
private func selectableTagItem(_ tagName: String) -> some View {
let isSelected = selectedTagNames.contains(tagName)
- return Button {
- if isSelected { selectedTagNames.remove(tagName) } else { selectedTagNames.insert(tagName) }
- } label: {
- HStack(spacing: 6) {
- Circle()
- .fill(isSelected ? Color.accentColor : Color.secondary.opacity(0.3))
- .frame(width: 16, height: 16)
- .overlay(isSelected ? Image(systemName: "checkmark").font(.system(size: 8, weight: .bold)).foregroundStyle(.white) : nil)
- Text(tagName).font(.system(size: 13, weight: .medium)).foregroundStyle(.primary)
- }
- .padding(.horizontal, 10).padding(.vertical, 5)
- .frame(maxWidth: .infinity, alignment: .leading)
- .background(RoundedRectangle(cornerRadius: 6)
- .fill(Color(nsColor: TagColor.nsColor(for: tagColors[tagName] ?? 0).withAlphaComponent(0.3))))
+ return HStack(spacing: 6) {
+ Circle()
+ .fill(isSelected ? Color.accentColor : Color.secondary.opacity(0.3))
+ .frame(width: 16, height: 16)
+ .overlay(isSelected ? Image(systemName: "checkmark").font(.system(size: 8, weight: .bold)).foregroundStyle(.white) : nil)
+ Text(tagName).font(.system(size: 13, weight: .medium)).foregroundStyle(.primary)
}
- .buttonStyle(.plain)
+ .padding(.horizontal, 10).padding(.vertical, 5)
+ .frame(maxWidth: .infinity, alignment: .leading)
+ .background(RoundedRectangle(cornerRadius: 6)
+ .fill(Color(nsColor: TagColor.nsColor(for: tagColors[tagName] ?? 0).withAlphaComponent(0.3))))
+ .contentShape(RoundedRectangle(cornerRadius: 6))
+ .onTapGesture {
+ if isSelected { selectedTagNames.remove(tagName) } else { selectedTagNames.insert(tagName) }
+ }
}
private func confirmAssign() {
@@ -523,7 +1009,7 @@
}
selectedAppPaths = []; selectedTagNames = []
refreshApps()
- withAnimation { successToast = "分类成功" }
+ withAnimation { successToast = tr("edit.success") }
}
private func cancelEditApps() {
@@ -573,7 +1059,17 @@
let order = draggedTagNames.isEmpty
? TagEditor.orderedTagNames()
: draggedTagNames
- return AppIndexer.group(apps: allApps, defaultGroupName: defaultGroupName, tagOrder: order)
+ 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
+ }
}
// MARK: - Actions
@@ -582,11 +1078,97 @@
withAnimation(.easeInOut(duration: 0.25)) { scrollProxy?.scrollTo(id, anchor: .top) }
}
+ private func fillColorlessContainer(_ id: String) {
+ guard isColorlessContainerMode else { return }
+ filledColorlessContainer = id
+ }
+
+ private func toggleColorlessFill(_ id: String) {
+ guard isColorlessContainerMode else { return }
+ filledColorlessContainer = (filledColorlessContainer == id) ? nil : id
+ }
+
+ 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) {
+ appDragModeActive = false
+ guard !isSystemDefaultDropTarget(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
+ )
+ refreshApps()
+ }
+
+ private func isSystemDefaultDropTarget(_ targetTag: String) -> Bool {
+ let defaultNames = [
+ defaultGroupName,
+ tr("group.uncategorized"),
+ "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 setAppDragMode(_ active: Bool) {
+ appDragModeActive = active
+ if active {
+ DispatchQueue.main.asyncAfter(deadline: .now() + 8) {
+ if appDragModeActive {
+ appDragModeActive = false
+ }
+ }
+ }
+ }
+
func refreshApps() {
DispatchQueue.global(qos: .userInitiated).async {
var apps = AppIndexer.scan()
- // Ensure migration ran at least once
- let store = TagDatabase.migrateFromFinderIfNeeded(apps: apps)
+ let store = TagDatabase.load()
apps = TagEditor.annotate(apps: apps)
let colors = store.tags.mapValues { $0.color }
let order = TagEditor.orderedTagNames()
@@ -599,8 +1181,20 @@
}
func openApp(_ app: AppInfo) {
+ appDragModeActive = false
hideOverlay()
- NSWorkspace.shared.open(app.path)
+ if let bundleIdentifier = app.bundleIdentifier {
+ NSWorkspace.shared.launchApplication(
+ withBundleIdentifier: bundleIdentifier,
+ options: [],
+ additionalEventParamDescriptor: nil,
+ launchIdentifier: nil
+ )
+ return
+ }
+
+ let configuration = NSWorkspace.OpenConfiguration()
+ NSWorkspace.shared.openApplication(at: app.path, configuration: configuration)
}
}
--
Gitblit v1.9.3