From 343237725f65445bab306e3fe4cdbd10949d4d4b Mon Sep 17 00:00:00 2001
From: Ariver <shanghai3168@gmail.com>
Date: Sat, 13 Jun 2026 18:47:36 +0800
Subject: [PATCH] Fix Finder tab page activation
---
C1.source/Sources/Aligner/QuickSwitchRootView.swift | 1259 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++---
1 files changed, 1,192 insertions(+), 67 deletions(-)
diff --git a/C1.source/Sources/Aligner/QuickSwitchRootView.swift b/C1.source/Sources/Aligner/QuickSwitchRootView.swift
index 0d3590c..c04faf7 100644
--- a/C1.source/Sources/Aligner/QuickSwitchRootView.swift
+++ b/C1.source/Sources/Aligner/QuickSwitchRootView.swift
@@ -24,6 +24,9 @@
private lazy var closeConfirmationLayers = makeCloseConfirmationLayers()
private let closeFeedbackLayer = CALayer()
private let closeFeedbackTextLayer = CATextLayer()
+ private let settingsButtonLayer = CALayer()
+ private let settingsButtonIconLayer = CALayer()
+ private let settingsButtonFallbackTextLayer = CATextLayer()
private let appIconProvider: any AppIconProviderProtocol = WorkspaceAppIconProvider()
private let skeletonThumbnailProvider = NativeSkeletonThumbnailProvider(size: NSSize(width: 160, height: 96))
private var screenshotSourcesByWindowID: [UInt32: ScreenshotResolutionSource] = [:]
@@ -49,15 +52,19 @@
private var closeConfirmationRequired = true
private var closeFeedback: CloseFeedback?
private var closeFeedbackHideTask: Task<Void, Never>?
+ private var isSettingsButtonHovered = false
private var hoverTarget: HoverTarget = .none
private var hoverTargetSource: HoverTargetSource = .event
private var hoveredSpaceLaneID: UInt64?
private var focusedSpaceID: UInt64?
private var debugHoveredAppGroupIndex: Int?
private var waterfallColumns: [WaterfallColumnLayers] = []
+ private var waterfallViewMode: QuickSwitchWaterfallViewMode = .verticalColumns
private var waterfallContentWidth: CGFloat = 0
private var waterfallScrollOffset: CGFloat = 0
private var waterfallColumnScrollOffsets: [Int: CGFloat] = [:]
+ private var horizontalMasonryContentHeight: CGFloat = 0
+ private var horizontalMasonryScrollOffset: CGFloat = 0
private var currentSelection: QuickSwitchSelection?
private var columnSelectionHistory: [Int: Int] = [:]
private var keyboardCommandsApplied: [String] = []
@@ -78,8 +85,17 @@
private var keyboardResponseLatencyMilliseconds: [Double] = []
private var mouseResponseLatencyMilliseconds: [Double] = []
private var hoverResponseLatencyMilliseconds: [Double] = []
+ private var lastProjectionTransitionMovedLayerCount = 0
+ private var lastProjectionTransitionFadeInLayerCount = 0
+ private var lastProjectionTransitionFadeOutLayerCount = 0
+ private var lastProjectionTransitionDurationMilliseconds: Double = 0
+ private var suppressEventInput = false
+ private var suppressEventBackgroundClicks = false
var onEscape: (() -> Void)?
var onCommitSelection: ((QuickSwitchSelection, QuickSwitchCommitSource) -> Void)?
+ var onSpaceLaneClick: ((UInt64, Int) -> Void)?
+ var onBackgroundClick: (() -> Bool)?
+ var onOpenSettings: (() -> Void)?
var onRequestClose: ((QuickSwitchCloseRequest) -> Void)?
var onCloseConfirmationDisabled: (() -> Void)?
@@ -210,6 +226,7 @@
let labelLayer: CATextLayer
let countLayer: CATextLayer
let appLayer: CATextLayer
+ let splitAppLayers: [CATextLayer]
let windowBlocks: [CALayer]
let fullscreenMarkerLayer: CALayer?
}
@@ -258,6 +275,22 @@
let closeButton: CloseButtonLayers
}
+ private struct ProjectionLayerSnapshot {
+ let layer: CALayer
+ let frame: CGRect
+ }
+
+ private struct ProjectionColumnSnapshot {
+ let layer: CALayer
+ let frame: CGRect
+ let cardsByWindowID: [UInt32: ProjectionLayerSnapshot]
+ }
+
+ private struct ProjectionTransitionSnapshot {
+ let appShelfItemsByAppGroupIndex: [Int: ProjectionLayerSnapshot]
+ let waterfallColumnsByAppGroupIndex: [Int: ProjectionColumnSnapshot]
+ }
+
private enum AppShelfMetrics {
static let normalIconSize: CGFloat = 56
static let hoverIconSize: CGFloat = 68
@@ -290,6 +323,16 @@
static let cardGap: CGFloat = 12
static let revealPadding: CGFloat = 24
static let horizontalRevealPadding: CGFloat = 0
+ }
+
+ private enum HorizontalMasonryMetrics {
+ static let horizontalPadding: CGFloat = 12
+ static let verticalPadding: CGFloat = 0
+ static let horizontalGap: CGFloat = 16
+ static let verticalGap: CGFloat = WaterfallMetrics.cardGap
+ static let cardMinWidth: CGFloat = 220
+ static let cardMaxWidth: CGFloat = 320
+ static let cardHeight: CGFloat = WaterfallMetrics.cardHeight
}
private enum WaterfallHorizontalIntent {
@@ -358,6 +401,13 @@
}
override func keyDown(with event: NSEvent) {
+ if suppressEventInput {
+ DevelopmentDiagnostics.log("quickSwitch.view.keyDown.ignoredForDebugSequence", [
+ "keyCode": event.keyCode
+ ])
+ return
+ }
+
switch event.keyCode {
case TriggerKeyCode.escape where Self.shouldDismissOnEscape(event):
onEscape?()
@@ -400,6 +450,15 @@
}
if shouldScrollWaterfall(for: event) {
+ if isHorizontalMasonryMode {
+ let currentOffset = horizontalMasonryScrollOffset
+ horizontalMasonryScrollOffset = clampedHorizontalMasonryOffset(
+ currentOffset - event.scrollingDeltaY
+ )
+ needsLayout = true
+ return
+ }
+
if abs(event.scrollingDeltaX) >= abs(event.scrollingDeltaY), waterfallAlignmentScrollable {
waterfallScrollOffset = clampedWaterfallAlignmentOffset(waterfallScrollOffset - event.scrollingDeltaX)
needsLayout = true
@@ -426,6 +485,17 @@
override func mouseMoved(with event: NSEvent) {
guard debugHoveredAppGroupIndex == nil else { return }
+ let settingsHovered = settingsButtonContains(windowLocation: event.locationInWindow)
+ if isSettingsButtonHovered != settingsHovered {
+ isSettingsButtonHovered = settingsHovered
+ needsLayout = true
+ }
+ if settingsHovered {
+ hoveredCloseTarget = nil
+ setHoverTarget(.none)
+ return
+ }
+
let closeTarget = closeButtonTarget(at: event.locationInWindow)
if hoveredCloseTarget != closeTarget {
hoveredCloseTarget = closeTarget
@@ -436,12 +506,27 @@
override func mouseExited(with event: NSEvent) {
guard debugHoveredAppGroupIndex == nil else { return }
+ isSettingsButtonHovered = false
hoveredCloseTarget = nil
setHoverTarget(.none)
}
override func mouseDown(with event: NSEvent) {
+ if suppressEventInput {
+ DevelopmentDiagnostics.log("quickSwitch.view.mouseDown.ignoredForDebugSequence", [
+ "x": event.locationInWindow.x,
+ "y": event.locationInWindow.y,
+ "bounds": NSStringFromRect(bounds)
+ ])
+ return
+ }
+
if handleCloseConfirmationMouseDown(at: event.locationInWindow) {
+ return
+ }
+
+ if settingsButtonContains(windowLocation: event.locationInWindow) {
+ clickSettingsButton(source: "mouse")
return
}
@@ -456,7 +541,7 @@
}
if let segment = spaceLaneSegment(at: event.locationInWindow) {
- clickSpaceLaneSegment(segment)
+ clickSpaceLaneSegment(segment, clickCount: max(1, event.clickCount))
return
}
@@ -470,6 +555,9 @@
"y": event.locationInWindow.y,
"bounds": NSStringFromRect(bounds)
])
+ if !suppressEventBackgroundClicks, onBackgroundClick?() == true {
+ return
+ }
super.mouseDown(with: event)
}
@@ -513,6 +601,15 @@
}
}
+ func setSuppressEventBackgroundClicks(_ suppressed: Bool) {
+ suppressEventBackgroundClicks = suppressed
+ }
+
+ func setSuppressEventInput(_ suppressed: Bool) {
+ suppressEventInput = suppressed
+ suppressEventBackgroundClicks = suppressed
+ }
+
func beginPerformanceFirstFrameMeasurement() {
firstFrameMeasurementStart = CACurrentMediaTime()
}
@@ -543,6 +640,17 @@
closeConfirmationLayers.containerLayer.isHidden = true
closeConfirmationArrowEdge = nil
}
+ needsLayout = true
+ }
+
+ func setWaterfallViewMode(_ mode: QuickSwitchWaterfallViewMode) {
+ guard waterfallViewMode != mode else { return }
+
+ waterfallViewMode = mode
+ waterfallScrollOffset = 0
+ waterfallColumnScrollOffsets = [:]
+ horizontalMasonryScrollOffset = 0
+ horizontalMasonryContentHeight = 0
needsLayout = true
}
@@ -608,35 +716,77 @@
}
}
+ func effectiveSelectionForProjection() -> QuickSwitchSelection? {
+ effectiveSelection
+ }
+
func apply(viewModel: QuickSwitchViewModel?) {
+ apply(viewModel: viewModel, preservingInteractionState: false, animatedProjection: false)
+ }
+
+ func applyProjected(viewModel: QuickSwitchViewModel?) {
+ apply(viewModel: viewModel, preservingInteractionState: true, animatedProjection: true)
+ }
+
+ private func apply(
+ viewModel: QuickSwitchViewModel?,
+ preservingInteractionState: Bool,
+ animatedProjection: Bool
+ ) {
+ let transitionSnapshot = animatedProjection ? captureProjectionTransitionSnapshot() : nil
+ if !animatedProjection {
+ resetProjectionTransitionReport()
+ }
currentViewModel = viewModel
- screenshotSourcesByWindowID = [:]
- screenshotSkippedReasonsByWindowID = [:]
- currentSelection = viewModel?.initialSelection
- columnSelectionHistory = [:]
- keyboardCommandsApplied = []
- lastKeyboardCommand = nil
- tabIgnoredCount = 0
- lastCommittedSelection = nil
- lastCommitSource = nil
- mouseCommandsApplied = []
- lastMouseCommand = nil
- lastClickedAppGroupIndex = nil
- lastAppShelfClickChangedSelection = nil
- lastClickedWindowID = nil
- lastSpaceFocusedAppGroupIndex = nil
- lastSpaceLaneClickSpaceID = nil
- lastAppShelfScrollSyncedAppGroupIndex = nil
- focusedSpaceID = nil
- hoveredCloseTarget = nil
- pendingCloseTarget = nil
- pendingCloseRequest = nil
- pendingCloseOptOut = false
- closeConfirmationLayers.containerLayer.isHidden = true
- closeConfirmationArrowEdge = nil
- clearCloseFeedback()
- setHoverTarget(.none)
- hoveredAppGroupIndex = debugHoveredAppGroupIndex
+
+ if preservingInteractionState {
+ currentSelection = validSelection(currentSelection, in: viewModel) ?? viewModel?.initialSelection
+ columnSelectionHistory = columnSelectionHistory.filter { appGroupIndex, _ in
+ viewModel?.waterfallColumns.contains { $0.appGroupIndex == appGroupIndex } == true
+ }
+ if let currentSelection {
+ columnSelectionHistory[currentSelection.appGroupIndex] = currentSelection.windowIndex
+ }
+ hoveredCloseTarget = nil
+ pendingCloseTarget = nil
+ pendingCloseRequest = nil
+ pendingCloseOptOut = false
+ closeConfirmationLayers.containerLayer.isHidden = true
+ closeConfirmationArrowEdge = nil
+ } else {
+ screenshotSourcesByWindowID = [:]
+ screenshotSkippedReasonsByWindowID = [:]
+ currentSelection = viewModel?.initialSelection
+ columnSelectionHistory = [:]
+ keyboardCommandsApplied = []
+ lastKeyboardCommand = nil
+ tabIgnoredCount = 0
+ lastCommittedSelection = nil
+ lastCommitSource = nil
+ mouseCommandsApplied = []
+ lastMouseCommand = nil
+ lastClickedAppGroupIndex = nil
+ lastAppShelfClickChangedSelection = nil
+ lastClickedWindowID = nil
+ lastSpaceFocusedAppGroupIndex = nil
+ lastSpaceLaneClickSpaceID = nil
+ lastAppShelfScrollSyncedAppGroupIndex = nil
+ waterfallScrollOffset = 0
+ waterfallColumnScrollOffsets = [:]
+ horizontalMasonryScrollOffset = 0
+ horizontalMasonryContentHeight = 0
+ focusedSpaceID = nil
+ hoveredCloseTarget = nil
+ pendingCloseTarget = nil
+ pendingCloseRequest = nil
+ pendingCloseOptOut = false
+ closeConfirmationLayers.containerLayer.isHidden = true
+ closeConfirmationArrowEdge = nil
+ clearCloseFeedback()
+ setHoverTarget(.none)
+ hoveredAppGroupIndex = debugHoveredAppGroupIndex
+ }
+
if let currentSelection {
columnSelectionHistory[currentSelection.appGroupIndex] = currentSelection.windowIndex
}
@@ -646,6 +796,250 @@
needsLayout = true
ensureCurrentSelectionVisible(horizontalIntent: .alignWithAppShelf(animated: false))
needsLayout = true
+ if animatedProjection, let transitionSnapshot {
+ layoutSubtreeIfNeeded()
+ applyProjectionTransitionAnimations(from: transitionSnapshot)
+ }
+ }
+
+ private func validSelection(
+ _ selection: QuickSwitchSelection?,
+ in viewModel: QuickSwitchViewModel?
+ ) -> QuickSwitchSelection? {
+ guard let selection, let viewModel else { return nil }
+
+ for column in viewModel.waterfallColumns {
+ if let card = column.windows.first(where: { $0.window.id == selection.windowID }) {
+ return QuickSwitchSelection(
+ appGroupIndex: card.appGroupIndex,
+ windowIndex: card.windowIndex,
+ windowID: card.window.id
+ )
+ }
+ }
+
+ return nil
+ }
+
+ private func captureProjectionTransitionSnapshot() -> ProjectionTransitionSnapshot {
+ ProjectionTransitionSnapshot(
+ appShelfItemsByAppGroupIndex: Dictionary(
+ uniqueKeysWithValues: appShelfItems.map { item in
+ (
+ item.item.appGroupIndex,
+ ProjectionLayerSnapshot(
+ layer: item.containerLayer,
+ frame: item.containerLayer.frame
+ )
+ )
+ }
+ ),
+ waterfallColumnsByAppGroupIndex: Dictionary(
+ uniqueKeysWithValues: waterfallColumns.map { column in
+ (
+ column.column.appGroupIndex,
+ ProjectionColumnSnapshot(
+ layer: column.containerLayer,
+ frame: column.containerLayer.frame,
+ cardsByWindowID: Dictionary(
+ uniqueKeysWithValues: column.cards.map { card in
+ (
+ card.item.window.id,
+ ProjectionLayerSnapshot(
+ layer: card.containerLayer,
+ frame: card.containerLayer.frame
+ )
+ )
+ }
+ )
+ )
+ )
+ }
+ )
+ )
+ }
+
+ private func applyProjectionTransitionAnimations(from snapshot: ProjectionTransitionSnapshot) {
+ let reduceMotion = NSWorkspace.shared.accessibilityDisplayShouldReduceMotion
+ let duration: CFTimeInterval = reduceMotion ? 0.12 : 0.21
+ let timing = CAMediaTimingFunction(name: reduceMotion ? .linear : .easeOut)
+ var movedLayerCount = 0
+ var fadeInLayerCount = 0
+ var fadeOutLayerCount = 0
+
+ for item in appShelfItems {
+ guard let oldSnapshot = snapshot.appShelfItemsByAppGroupIndex[item.item.appGroupIndex] else {
+ if addFadeInAnimation(to: item.containerLayer, duration: duration, timing: timing) {
+ fadeInLayerCount += 1
+ }
+ continue
+ }
+ if addPositionAnimation(to: item.containerLayer, from: oldSnapshot.frame, duration: duration, timing: timing) {
+ movedLayerCount += 1
+ }
+ }
+
+ let visibleAppGroupIndexes = Set(appShelfItems.map(\.item.appGroupIndex))
+ for (appGroupIndex, oldSnapshot) in snapshot.appShelfItemsByAppGroupIndex
+ where !visibleAppGroupIndexes.contains(appGroupIndex) {
+ if addFadeOutSnapshot(
+ oldSnapshot,
+ to: appShelfContentLayer,
+ frame: oldSnapshot.frame,
+ duration: duration,
+ timing: timing
+ ) {
+ fadeOutLayerCount += 1
+ }
+ }
+
+ for column in waterfallColumns {
+ guard let oldSnapshot = snapshot.waterfallColumnsByAppGroupIndex[column.column.appGroupIndex] else {
+ if addFadeInAnimation(to: column.containerLayer, duration: duration, timing: timing) {
+ fadeInLayerCount += 1
+ }
+ continue
+ }
+ if addPositionAnimation(to: column.containerLayer, from: oldSnapshot.frame, duration: duration, timing: timing) {
+ movedLayerCount += 1
+ }
+
+ for card in column.cards {
+ guard let oldCardSnapshot = oldSnapshot.cardsByWindowID[card.item.window.id] else {
+ if addFadeInAnimation(to: card.containerLayer, duration: duration, timing: timing) {
+ fadeInLayerCount += 1
+ }
+ continue
+ }
+ if addPositionAnimation(to: card.containerLayer, from: oldCardSnapshot.frame, duration: duration, timing: timing) {
+ movedLayerCount += 1
+ }
+ }
+ }
+
+ let visibleColumnsByAppGroupIndex = Dictionary(
+ uniqueKeysWithValues: waterfallColumns.map { ($0.column.appGroupIndex, $0) }
+ )
+ for (appGroupIndex, oldSnapshot) in snapshot.waterfallColumnsByAppGroupIndex {
+ guard let visibleColumn = visibleColumnsByAppGroupIndex[appGroupIndex] else {
+ if addFadeOutSnapshot(
+ ProjectionLayerSnapshot(layer: oldSnapshot.layer, frame: oldSnapshot.frame),
+ to: waterfallContentLayer,
+ frame: oldSnapshot.frame,
+ duration: duration,
+ timing: timing
+ ) {
+ fadeOutLayerCount += 1
+ }
+ continue
+ }
+
+ let visibleWindowIDs = Set(visibleColumn.cards.map(\.item.window.id))
+ for (windowID, oldCardSnapshot) in oldSnapshot.cardsByWindowID
+ where !visibleWindowIDs.contains(windowID) {
+ let absoluteFrame = oldCardSnapshot.frame.offsetBy(
+ dx: oldSnapshot.frame.minX,
+ dy: oldSnapshot.frame.minY
+ )
+ if addFadeOutSnapshot(
+ oldCardSnapshot,
+ to: waterfallContentLayer,
+ frame: absoluteFrame,
+ duration: duration,
+ timing: timing
+ ) {
+ fadeOutLayerCount += 1
+ }
+ }
+ }
+
+ lastProjectionTransitionMovedLayerCount = movedLayerCount
+ lastProjectionTransitionFadeInLayerCount = fadeInLayerCount
+ lastProjectionTransitionFadeOutLayerCount = fadeOutLayerCount
+ lastProjectionTransitionDurationMilliseconds = duration * 1_000
+ }
+
+ private func resetProjectionTransitionReport() {
+ lastProjectionTransitionMovedLayerCount = 0
+ lastProjectionTransitionFadeInLayerCount = 0
+ lastProjectionTransitionFadeOutLayerCount = 0
+ lastProjectionTransitionDurationMilliseconds = 0
+ }
+
+ @discardableResult
+ private func addPositionAnimation(
+ to layer: CALayer,
+ from oldFrame: CGRect,
+ duration: CFTimeInterval,
+ timing: CAMediaTimingFunction
+ ) -> Bool {
+ let oldPosition = CGPoint(x: oldFrame.midX, y: oldFrame.midY)
+ let newPosition = layer.position
+ guard abs(oldPosition.x - newPosition.x) > 0.5 || abs(oldPosition.y - newPosition.y) > 0.5 else {
+ return false
+ }
+
+ let animation = CABasicAnimation(keyPath: "position")
+ animation.fromValue = oldPosition
+ animation.toValue = newPosition
+ animation.duration = duration
+ animation.timingFunction = timing
+ animation.isRemovedOnCompletion = true
+ layer.add(animation, forKey: "quickSwitchProjectionPosition")
+ return true
+ }
+
+ @discardableResult
+ private func addFadeInAnimation(
+ to layer: CALayer,
+ duration: CFTimeInterval,
+ timing: CAMediaTimingFunction
+ ) -> Bool {
+ let animation = CABasicAnimation(keyPath: "opacity")
+ animation.fromValue = 0
+ animation.toValue = layer.opacity
+ animation.duration = duration
+ animation.timingFunction = timing
+ animation.isRemovedOnCompletion = true
+ layer.add(animation, forKey: "quickSwitchProjectionFadeIn")
+ return true
+ }
+
+ @discardableResult
+ private func addFadeOutSnapshot(
+ _ snapshot: ProjectionLayerSnapshot,
+ to parentLayer: CALayer,
+ frame: CGRect,
+ duration: CFTimeInterval,
+ timing: CAMediaTimingFunction
+ ) -> Bool {
+ let layer = snapshot.layer
+ layer.removeAllAnimations()
+ layer.removeFromSuperlayer()
+ CATransaction.begin()
+ CATransaction.setDisableActions(true)
+ layer.frame = frame
+ layer.opacity = max(layer.opacity, 0.01)
+ layer.zPosition = max(layer.zPosition, 240)
+ parentLayer.addSublayer(layer)
+ CATransaction.commit()
+
+ let animation = CABasicAnimation(keyPath: "opacity")
+ animation.fromValue = layer.opacity
+ animation.toValue = 0
+ animation.duration = duration
+ animation.timingFunction = timing
+ animation.isRemovedOnCompletion = true
+ CATransaction.begin()
+ CATransaction.setDisableActions(true)
+ layer.opacity = 0
+ CATransaction.commit()
+ layer.add(animation, forKey: "quickSwitchProjectionFadeOut")
+
+ DispatchQueue.main.asyncAfter(deadline: .now() + duration + 0.05) { [weak layer] in
+ layer?.removeFromSuperlayer()
+ }
+ return true
}
func reportDictionary() -> [String: Any] {
@@ -685,6 +1079,11 @@
"spaceLaneHoveredSpaceID": hoveredSpaceLaneID ?? NSNull(),
"spaceLaneFocusedSpaceID": focusedSpaceID ?? NSNull(),
"activeSpaceFocusID": activeSpaceFocusID ?? NSNull(),
+ "spaceFilterLockedSpaceID": currentViewModel?.lockedSpaceID ?? NSNull(),
+ "spaceFilterActive": currentViewModel?.lockedSpaceID != nil,
+ "settingsButtonVisible": !settingsButtonLayer.isHidden,
+ "settingsButtonHovered": isSettingsButtonHovered,
+ "settingsButtonFrame": dictionary(from: settingsButtonLayer.frame),
"spaceFocusAppGroupIndexes": spaceFocusedAppGroupIndexes(),
"appHoverAssociatedSpaceIDs": appHoverAssociatedSpaceIDs.sorted(),
"appHoverAssociatedSpaceLabels": appHoverAssociatedSpaceLabels,
@@ -716,10 +1115,15 @@
"appShelfMinIconSize": Double(AppShelfMetrics.minIconSize),
"appShelfItems": appShelfItemReports(),
"waterfallFrame": dictionary(from: waterfallLayer.frame),
+ "waterfallViewMode": waterfallViewMode.rawValue,
"waterfallContentWidth": Double(waterfallContentWidth),
"waterfallVisibleWidth": Double(waterfallLayer.bounds.width),
"waterfallScrollOffset": Double(waterfallScrollOffset),
"waterfallMaxScrollOffset": Double(waterfallMaxScrollOffset),
+ "horizontalMasonryContentHeight": Double(horizontalMasonryContentHeight),
+ "horizontalMasonryScrollOffset": Double(horizontalMasonryScrollOffset),
+ "horizontalMasonryMaxScrollOffset": Double(horizontalMasonryMaxScrollOffset),
+ "horizontalMasonryScrollable": horizontalMasonryMaxScrollOffset > 0,
"waterfallAlignmentMinScrollOffset": Double(waterfallAlignmentScrollRange.lowerBound),
"waterfallAlignmentMaxScrollOffset": Double(waterfallAlignmentScrollRange.upperBound),
"waterfallScrollable": waterfallMaxScrollOffset > 0,
@@ -732,6 +1136,10 @@
"waterfallAlignmentTolerance": Double(WaterfallAlignmentMetrics.tolerance),
"waterfallAlignmentAnimationDurationMilliseconds": Double(WaterfallAlignmentMetrics.animationDuration * 1_000),
"waterfallAlignmentAnimationTimingName": "easeOut",
+ "projectionTransitionMovedLayerCount": lastProjectionTransitionMovedLayerCount,
+ "projectionTransitionFadeInLayerCount": lastProjectionTransitionFadeInLayerCount,
+ "projectionTransitionFadeOutLayerCount": lastProjectionTransitionFadeOutLayerCount,
+ "projectionTransitionDurationMilliseconds": lastProjectionTransitionDurationMilliseconds,
"reduceMotionEffective": NSWorkspace.shared.accessibilityDisplayShouldReduceMotion,
"selectedAppGroupIndex": effectiveSelection?.appGroupIndex ?? NSNull(),
"selectedWindowIndex": effectiveSelection?.windowIndex ?? NSNull(),
@@ -827,8 +1235,13 @@
recordKeyboardCommand("enter")
commitCurrentSelection()
case "tab":
- tabIgnoredCount += 1
- recordKeyboardCommand("tabIgnored")
+ if isHorizontalMasonryMode {
+ recordKeyboardCommand("tab")
+ moveSelection(.right)
+ } else {
+ tabIgnoredCount += 1
+ recordKeyboardCommand("tabIgnored")
+ }
default:
recordKeyboardCommand("unknown:\(command)")
}
@@ -898,8 +1311,24 @@
}
recordMouseCommand("click-space:\(spaceID)")
if let segment = spaceLaneSegment(spaceID: spaceID) {
- clickSpaceLaneSegment(segment)
+ clickSpaceLaneSegment(segment, clickCount: 1)
}
+ case "double-click-space" where parts.count == 2:
+ guard let spaceID = UInt64(parts[1]) else {
+ recordMouseCommand("invalid:\(command)")
+ return
+ }
+ recordMouseCommand("double-click-space:\(spaceID)")
+ if let segment = spaceLaneSegment(spaceID: spaceID) {
+ clickSpaceLaneSegment(segment, clickCount: 1)
+ clickSpaceLaneSegment(segment, clickCount: 2)
+ }
+ case "click-background":
+ recordMouseCommand("click-background")
+ _ = onBackgroundClick?()
+ case "click-settings":
+ recordMouseCommand("click-settings")
+ clickSettingsButton(source: "debug")
case "hover-card" where parts.count == 3:
guard let appGroupIndex = Int(parts[1]), let windowIndex = Int(parts[2]) else {
recordMouseCommand("invalid:\(command)")
@@ -916,6 +1345,15 @@
}
recordMouseCommand("click-card:\(appGroupIndex):\(windowIndex)")
if let card = waterfallCard(appGroupIndex: appGroupIndex, windowIndex: windowIndex) {
+ clickWindowCard(card)
+ }
+ case "click-card-id" where parts.count == 2:
+ guard let windowID = UInt32(parts[1]) else {
+ recordMouseCommand("invalid:\(command)")
+ return
+ }
+ recordMouseCommand("click-card-id:\(windowID)")
+ if let card = waterfallCard(windowID: windowID) {
clickWindowCard(card)
}
case "hover-card-close" where parts.count == 3:
@@ -1015,22 +1453,15 @@
focusSpace(segment.space.id, persistent: false, source: source)
}
- private func clickSpaceLaneSegment(_ segment: SpaceLaneSegmentLayers) {
+ private func clickSpaceLaneSegment(_ segment: SpaceLaneSegmentLayers, clickCount: Int = 1) {
DevelopmentDiagnostics.log("quickSwitch.view.clickSpaceLane", [
"spaceID": segment.space.id,
- "label": segment.space.label
+ "label": segment.space.label,
+ "clickCount": clickCount
])
lastSpaceLaneClickSpaceID = segment.space.id
-
- guard let firstCard = firstWaterfallCard(inSpaceID: segment.space.id) else {
- DevelopmentDiagnostics.log("quickSwitch.view.clickSpaceLane.emptySpaceUnsupported", [
- "spaceID": segment.space.id,
- "label": segment.space.label
- ])
- return
- }
-
- commitWindowCard(firstCard, trigger: "spaceLane")
+ onSpaceLaneClick?(segment.space.id, clickCount)
+ lastSpaceLaneClickSpaceID = segment.space.id
}
private func focusSpace(_ spaceID: UInt64, persistent: Bool, source: HoverTargetSource = .event) {
@@ -1228,6 +1659,11 @@
}
private func moveSelection(_ direction: QuickSwitchKeyboardDirection) {
+ if isHorizontalMasonryMode {
+ moveHorizontalMasonrySelection(direction)
+ return
+ }
+
guard let currentViewModel,
let snapshot = snapshotForFocus(from: currentViewModel),
let current = currentSelection ?? currentViewModel.initialSelection,
@@ -1257,6 +1693,113 @@
"windowID": next.windowID
])
needsLayout = true
+ }
+
+ private func moveHorizontalMasonrySelection(_ direction: QuickSwitchKeyboardDirection) {
+ guard let current = currentSelection ?? currentViewModel?.initialSelection,
+ let next = nextHorizontalMasonrySelection(from: current, direction: direction)
+ else {
+ DevelopmentDiagnostics.log("quickSwitch.view.moveHorizontalMasonrySelection.blocked", [
+ "direction": String(describing: direction),
+ "hasSelection": (currentSelection ?? currentViewModel?.initialSelection) != nil
+ ])
+ return
+ }
+
+ columnSelectionHistory[current.appGroupIndex] = current.windowIndex
+ currentSelection = next
+ columnSelectionHistory[next.appGroupIndex] = next.windowIndex
+ ensureCurrentSelectionVisible(horizontalIntent: .alignWithAppShelf(animated: true))
+ DevelopmentDiagnostics.log("quickSwitch.view.moveHorizontalMasonrySelection", [
+ "direction": String(describing: direction),
+ "appGroupIndex": next.appGroupIndex,
+ "windowIndex": next.windowIndex,
+ "windowID": next.windowID
+ ])
+ needsLayout = true
+ }
+
+ private func nextHorizontalMasonrySelection(
+ from current: QuickSwitchSelection,
+ direction: QuickSwitchKeyboardDirection
+ ) -> QuickSwitchSelection? {
+ layoutSubtreeIfNeeded()
+
+ let cards = horizontalMasonryCardsInPlacementOrder()
+ guard let currentIndex = cards.firstIndex(where: { $0.item.window.id == current.windowID }) else {
+ return cards.first.map(selectionForCard)
+ }
+
+ switch direction {
+ case .right:
+ return selectionForCard(cards[(currentIndex + 1) % cards.count])
+ case .left:
+ return selectionForCard(cards[(currentIndex - 1 + cards.count) % cards.count])
+ case .up:
+ return nearestHorizontalMasonrySelection(from: cards[currentIndex], direction: .up)
+ ?? selectionForCard(cards.first ?? cards[currentIndex])
+ case .down:
+ return nearestHorizontalMasonrySelection(from: cards[currentIndex], direction: .down)
+ ?? selectionForCard(cards.last ?? cards[currentIndex])
+ }
+ }
+
+ private func nearestHorizontalMasonrySelection(
+ from currentCard: WaterfallCardLayers,
+ direction: QuickSwitchKeyboardDirection
+ ) -> QuickSwitchSelection? {
+ let currentFrame = currentCard.containerLayer.frame
+ let candidates = horizontalMasonryCardsInPlacementOrder().filter { card in
+ guard card.item.window.id != currentCard.item.window.id else { return false }
+ switch direction {
+ case .up:
+ return card.containerLayer.frame.minY >= currentFrame.maxY - 0.5
+ case .down:
+ return card.containerLayer.frame.maxY <= currentFrame.minY + 0.5
+ case .left, .right:
+ return false
+ }
+ }
+
+ let best = candidates.min { lhs, rhs in
+ let lhsFrame = lhs.containerLayer.frame
+ let rhsFrame = rhs.containerLayer.frame
+ let lhsPrimaryDistance = direction == .up
+ ? lhsFrame.minY - currentFrame.maxY
+ : currentFrame.minY - lhsFrame.maxY
+ let rhsPrimaryDistance = direction == .up
+ ? rhsFrame.minY - currentFrame.maxY
+ : currentFrame.minY - rhsFrame.maxY
+ if abs(lhsPrimaryDistance - rhsPrimaryDistance) > 0.5 {
+ return lhsPrimaryDistance < rhsPrimaryDistance
+ }
+
+ let lhsHorizontalDistance = abs(lhsFrame.midX - currentFrame.midX)
+ let rhsHorizontalDistance = abs(rhsFrame.midX - currentFrame.midX)
+ if abs(lhsHorizontalDistance - rhsHorizontalDistance) > 0.5 {
+ return lhsHorizontalDistance < rhsHorizontalDistance
+ }
+
+ return lhs.item.globalIndex < rhs.item.globalIndex
+ }
+
+ return best.map(selectionForCard)
+ }
+
+ private func horizontalMasonryCardsInPlacementOrder() -> [WaterfallCardLayers] {
+ waterfallColumns
+ .sorted { $0.column.appGroupIndex < $1.column.appGroupIndex }
+ .flatMap { column in
+ column.cards.sorted { $0.item.windowIndex < $1.item.windowIndex }
+ }
+ }
+
+ private func selectionForCard(_ card: WaterfallCardLayers) -> QuickSwitchSelection {
+ QuickSwitchSelection(
+ appGroupIndex: card.item.appGroupIndex,
+ windowIndex: card.item.windowIndex,
+ windowID: card.item.window.id
+ )
}
private func commitCurrentSelection() {
@@ -1316,9 +1859,24 @@
_ selection: QuickSwitchSelection,
horizontalIntent: WaterfallHorizontalIntent = .reveal
) {
+ if isHorizontalMasonryMode {
+ switch horizontalIntent {
+ case .reveal:
+ ensureHorizontalMasonrySelectionVisible(selection, animated: false)
+ case .alignWithAppShelf(let animated):
+ ensureHorizontalMasonrySelectionVisible(selection, animated: animated)
+ }
+ return
+ }
+
guard
let column = waterfallColumns.first(where: { $0.column.appGroupIndex == selection.appGroupIndex })
else {
+ return
+ }
+
+ if waterfallShouldKeepFilteredColumnsCentered {
+ ensureWaterfallCardVisibleVertically(selection)
return
}
@@ -1332,6 +1890,11 @@
}
private func ensureWaterfallCardVisibleVertically(_ selection: QuickSwitchSelection) {
+ guard !isHorizontalMasonryMode else {
+ ensureHorizontalMasonrySelectionVisible(selection, animated: false)
+ return
+ }
+
let visibleHeight = max(
1,
waterfallLayer.bounds.height
@@ -1359,6 +1922,11 @@
}
private func alignWaterfallColumnWithAppShelfIcon(appGroupIndex: Int, animated: Bool) {
+ if isHorizontalMasonryMode {
+ ensureHorizontalMasonryAppVisible(appGroupIndex, animated: animated)
+ return
+ }
+
guard
let item = appShelfItems.first(where: { $0.item.appGroupIndex == appGroupIndex }),
let column = waterfallColumns.first(where: { $0.column.appGroupIndex == appGroupIndex })
@@ -1385,6 +1953,11 @@
}
private func ensureWaterfallColumnVisible(_ appGroupIndex: Int) {
+ if isHorizontalMasonryMode {
+ ensureHorizontalMasonryAppVisible(appGroupIndex, animated: false)
+ return
+ }
+
guard let column = waterfallColumns.first(where: { $0.column.appGroupIndex == appGroupIndex }) else {
return
}
@@ -1393,6 +1966,11 @@
}
private func ensureWaterfallColumnVisible(_ column: WaterfallColumnLayers) {
+ if isHorizontalMasonryMode {
+ ensureHorizontalMasonryAppVisible(column.column.appGroupIndex, animated: false)
+ return
+ }
+
waterfallScrollOffset = clampedWaterfallOffset(
scrollOffset(
makingVisible: column.containerLayer.frame,
@@ -1405,6 +1983,14 @@
}
private var waterfallAlignmentScrollRange: ClosedRange<CGFloat> {
+ if isHorizontalMasonryMode {
+ return 0...0
+ }
+
+ if waterfallShouldKeepFilteredColumnsCentered {
+ return 0...0
+ }
+
var minimumOffset: CGFloat = 0
var maximumOffset = waterfallMaxScrollOffset
@@ -1429,6 +2015,10 @@
private func clampedWaterfallAlignmentOffset(_ offset: CGFloat) -> CGFloat {
let range = waterfallAlignmentScrollRange
return min(max(range.lowerBound, offset), range.upperBound)
+ }
+
+ private var waterfallShouldKeepFilteredColumnsCentered: Bool {
+ currentViewModel?.lockedSpaceID != nil && waterfallMaxScrollOffset <= 0.5
}
private func setWaterfallScrollOffset(_ offset: CGFloat, animated: Bool) {
@@ -1463,6 +2053,80 @@
animation.timingFunction = CAMediaTimingFunction(name: WaterfallAlignmentMetrics.animationTimingName)
animation.isRemovedOnCompletion = true
waterfallContentLayer.add(animation, forKey: "waterfallColumnAlignment")
+ }
+
+ private func ensureHorizontalMasonrySelectionVisible(
+ _ selection: QuickSwitchSelection,
+ animated: Bool
+ ) {
+ guard let card = waterfallCard(
+ appGroupIndex: selection.appGroupIndex,
+ windowIndex: selection.windowIndex
+ ) else {
+ return
+ }
+
+ let visibleFrame = card.containerLayer.frame.offsetBy(
+ dx: 0,
+ dy: waterfallContentLayer.frame.minY
+ )
+ let visibleHeight = waterfallLayer.bounds.height
+ let padding = WaterfallMetrics.revealPadding
+ var nextOffset = horizontalMasonryScrollOffset
+
+ if visibleFrame.maxY > visibleHeight - padding {
+ nextOffset -= visibleFrame.maxY - (visibleHeight - padding)
+ } else if visibleFrame.minY < padding {
+ nextOffset += padding - visibleFrame.minY
+ }
+
+ setHorizontalMasonryScrollOffset(nextOffset, animated: animated)
+ }
+
+ private func ensureHorizontalMasonryAppVisible(_ appGroupIndex: Int, animated: Bool) {
+ guard let firstCard = waterfallColumns
+ .first(where: { $0.column.appGroupIndex == appGroupIndex })?
+ .cards
+ .sorted(by: { $0.item.windowIndex < $1.item.windowIndex })
+ .first
+ else {
+ return
+ }
+
+ let cardTopDistance = horizontalMasonryContentHeight - firstCard.containerLayer.frame.maxY
+ setHorizontalMasonryScrollOffset(
+ cardTopDistance - WaterfallMetrics.revealPadding,
+ animated: animated
+ )
+ }
+
+ private func setHorizontalMasonryScrollOffset(_ offset: CGFloat, animated: Bool) {
+ let nextOffset = clampedHorizontalMasonryOffset(offset)
+ let previousPositionY = waterfallContentLayer.presentation()?.position.y
+ ?? waterfallContentLayer.position.y
+
+ horizontalMasonryScrollOffset = nextOffset
+ CATransaction.begin()
+ CATransaction.setDisableActions(true)
+ waterfallContentLayer.frame = horizontalMasonryContentFrame()
+ CATransaction.commit()
+
+ let nextPositionY = waterfallContentLayer.position.y
+ guard animated,
+ !NSWorkspace.shared.accessibilityDisplayShouldReduceMotion,
+ abs(previousPositionY - nextPositionY) > 0.5
+ else {
+ waterfallContentLayer.removeAnimation(forKey: "horizontalMasonryAlignment")
+ return
+ }
+
+ let animation = CABasicAnimation(keyPath: "position.y")
+ animation.fromValue = previousPositionY
+ animation.toValue = nextPositionY
+ animation.duration = WaterfallAlignmentMetrics.animationDuration
+ animation.timingFunction = CAMediaTimingFunction(name: WaterfallAlignmentMetrics.animationTimingName)
+ animation.isRemovedOnCompletion = true
+ waterfallContentLayer.add(animation, forKey: "horizontalMasonryAlignment")
}
private func scrollOffset(
@@ -1616,6 +2280,26 @@
closeFeedbackTextLayer.truncationMode = .end
closeFeedbackLayer.addSublayer(closeFeedbackTextLayer)
glassLayer.addSublayer(closeFeedbackLayer)
+
+ settingsButtonLayer.cornerRadius = 10
+ settingsButtonLayer.masksToBounds = false
+ settingsButtonLayer.borderWidth = 1
+ settingsButtonLayer.shadowColor = NSColor.black.cgColor
+ settingsButtonLayer.shadowOffset = CGSize(width: 0, height: -2)
+ settingsButtonLayer.zPosition = 170
+ settingsButtonIconLayer.contentsGravity = .resizeAspect
+ settingsButtonIconLayer.contentsScale = backingScaleFactor
+ settingsButtonIconLayer.contents = settingsIconImage()
+ settingsButtonFallbackTextLayer.contentsScale = backingScaleFactor
+ settingsButtonFallbackTextLayer.string = "⚙"
+ settingsButtonFallbackTextLayer.font = NSFont.systemFont(ofSize: 18, weight: .regular)
+ settingsButtonFallbackTextLayer.fontSize = 18
+ settingsButtonFallbackTextLayer.alignmentMode = .center
+ settingsButtonFallbackTextLayer.foregroundColor = NSColor.secondaryLabelColor.cgColor
+ settingsButtonFallbackTextLayer.isHidden = settingsButtonIconLayer.contents != nil
+ settingsButtonLayer.addSublayer(settingsButtonIconLayer)
+ settingsButtonLayer.addSublayer(settingsButtonFallbackTextLayer)
+ glassLayer.addSublayer(settingsButtonLayer)
}
private func rebuildAppShelfItems() {
@@ -1866,6 +2550,15 @@
color: space.type == .fullscreen ? .labelColor : .secondaryLabelColor,
alignment: space.type == .fullscreen ? .center : .left
)
+ let splitAppLayers = splitViewAppNames(for: space).map { name in
+ makeTextLayer(
+ string: name,
+ fontSize: 12,
+ weight: .medium,
+ color: .labelColor,
+ alignment: .center
+ )
+ }
let windowBlocks = space.type == .fullscreen
? []
: makeWindowBlocks(count: min(space.windowCount, 5), space: space)
@@ -1876,6 +2569,9 @@
container.addSublayer(appLayer)
if let fullscreenMarkerLayer {
container.addSublayer(fullscreenMarkerLayer)
+ }
+ for splitAppLayer in splitAppLayers {
+ container.addSublayer(splitAppLayer)
}
for block in windowBlocks {
container.addSublayer(block)
@@ -1888,6 +2584,7 @@
labelLayer: labelLayer,
countLayer: countLayer,
appLayer: appLayer,
+ splitAppLayers: splitAppLayers,
windowBlocks: windowBlocks,
fullscreenMarkerLayer: fullscreenMarkerLayer
)
@@ -1953,8 +2650,40 @@
layoutWaterfallColumns()
layoutCloseConfirmation()
layoutCloseFeedback()
+ layoutSettingsButton()
CATransaction.commit()
+ }
+
+ private func layoutSettingsButton() {
+ let size: CGFloat = 34
+ let topMargin = topSafeAreaInset + RootLayoutMetrics.topContentMargin
+ let x = max(
+ RootLayoutMetrics.horizontalMargin,
+ glassLayer.bounds.width - RootLayoutMetrics.horizontalMargin - size
+ )
+ let y = max(
+ RootLayoutMetrics.bottomMargin,
+ glassLayer.bounds.height - topMargin - size
+ )
+ settingsButtonLayer.frame = CGRect(x: x, y: y, width: size, height: size)
+ settingsButtonLayer.backgroundColor = NSColor.windowBackgroundColor
+ .withAlphaComponent(isSettingsButtonHovered ? 0.78 : 0.54)
+ .cgColor
+ settingsButtonLayer.borderColor = NSColor.separatorColor
+ .withAlphaComponent(isSettingsButtonHovered ? 0.42 : 0.26)
+ .cgColor
+ settingsButtonLayer.shadowOpacity = isSettingsButtonHovered ? 0.14 : 0.08
+ settingsButtonLayer.shadowRadius = isSettingsButtonHovered ? 9 : 6
+ settingsButtonIconLayer.contentsScale = backingScaleFactor
+ settingsButtonFallbackTextLayer.contentsScale = backingScaleFactor
+ let iconInset: CGFloat = 8
+ settingsButtonIconLayer.frame = settingsButtonLayer.bounds.insetBy(dx: iconInset, dy: iconInset)
+ settingsButtonFallbackTextLayer.frame = settingsButtonLayer.bounds.insetBy(dx: 0, dy: 6)
+ settingsButtonFallbackTextLayer.foregroundColor = (isSettingsButtonHovered
+ ? NSColor.labelColor
+ : NSColor.secondaryLabelColor
+ ).cgColor
}
private var topSafeAreaInset: CGFloat {
@@ -2118,6 +2847,7 @@
segment.space.id == activeSpaceFocusID
|| appHoverAssociatedSpaceIDs.contains(segment.space.id)
|| segment.space.id == windowHoverAssociatedSpaceID
+ || segment.space.id == currentViewModel?.lockedSpaceID
}
let hasCurrentSegment = group.display.spaces.contains { $0.isCurrent }
group.containerLayer.backgroundColor = NSColor.windowBackgroundColor.cgColor
@@ -2133,16 +2863,19 @@
private func applySpaceLaneVisualState(_ segment: SpaceLaneSegmentLayers) {
let isHovered = segment.space.id == activeSpaceFocusID
let isFocused = segment.space.id == activeSpaceFocusID
+ let isLocked = segment.space.id == currentViewModel?.lockedSpaceID
let isCurrent = segment.space.isCurrent
let hasWindows = segment.space.windowCount > 0
let isAppAssociated = appHoverAssociatedSpaceIDs.contains(segment.space.id)
let isWindowAssociated = segment.space.id == windowHoverAssociatedSpaceID
- let isActive = isHovered || isFocused
+ let isActive = isHovered || isFocused || isLocked
let isAssociated = (isAppAssociated || isWindowAssociated) && !isActive
segment.containerLayer.borderWidth = (hasWindows || isCurrent || isActive || isAssociated) ? 1.5 : 1
- segment.containerLayer.borderColor = (isActive
- ? spaceLaneOccupiedColor.withAlphaComponent(0.62)
+ segment.containerLayer.borderColor = (isLocked
+ ? NSColor.white.withAlphaComponent(0.86)
+ : isActive
+ ? spaceLaneOccupiedColor.withAlphaComponent(isLocked ? 0.92 : 0.62)
: isAssociated
? spaceLaneOccupiedColor.withAlphaComponent(0.50)
: hasWindows
@@ -2151,7 +2884,12 @@
? NSColor.labelColor.withAlphaComponent(0.34)
: NSColor.separatorColor.withAlphaComponent(0.34)
).cgColor
- if !hasWindows {
+ if isLocked {
+ applySpaceLaneSolidFill(
+ to: segment.containerLayer,
+ color: spaceLaneLockedFillColor
+ )
+ } else if !hasWindows {
applySpaceLaneSolidFill(to: segment.containerLayer, color: .clear)
} else if isActive {
applySpaceLaneSolidFill(
@@ -2169,21 +2907,24 @@
colors: spaceLaneIdleOccupiedGradientColors()
)
}
- segment.containerLayer.shadowOpacity = hasWindows
- ? (isActive ? 0.26 : isAssociated ? 0.18 : isCurrent ? 0.14 : 0)
+ segment.containerLayer.shadowColor = isLocked
+ ? NSColor.white.withAlphaComponent(0.98).cgColor
+ : NSColor.black.cgColor
+ segment.containerLayer.shadowOpacity = (hasWindows || isLocked)
+ ? (isLocked ? 0.72 : isActive ? 0.26 : isAssociated ? 0.18 : isCurrent ? 0.14 : 0)
: 0
- segment.containerLayer.shadowRadius = hasWindows
- ? (isActive ? 24 : isAssociated ? 18 : isCurrent ? 12 : 0)
+ segment.containerLayer.shadowRadius = (hasWindows || isLocked)
+ ? (isLocked ? 30 : isActive ? 24 : isAssociated ? 18 : isCurrent ? 12 : 0)
: 0
segment.containerLayer.shadowOffset = CGSize(
width: 0,
- height: hasWindows ? (isActive ? -6 : isAssociated ? -4 : isCurrent ? -2.5 : 0) : 0
+ height: (hasWindows || isLocked) ? (isLocked ? 0 : isActive ? -6 : isAssociated ? -4 : isCurrent ? -2.5 : 0) : 0
)
- segment.containerLayer.zPosition = isActive ? 30 : isAssociated ? 18 : isCurrent ? 10 : 0
+ segment.containerLayer.zPosition = isLocked ? 42 : isActive ? 30 : isAssociated ? 18 : isCurrent ? 10 : 0
segment.containerLayer.transform = (isActive || isAssociated)
? CATransform3DMakeScale(isActive ? 1.03 : 1.015, isActive ? 1.03 : 1.015, 1)
: CATransform3DIdentity
- segment.containerLayer.shadowPath = hasWindows
+ segment.containerLayer.shadowPath = (hasWindows || isLocked)
? CGPath(
roundedRect: segment.containerLayer.bounds,
cornerWidth: segment.containerLayer.cornerRadius,
@@ -2191,6 +2932,37 @@
transform: nil
)
: nil
+
+ applySpaceLaneContentVisualState(segment, isLocked: isLocked)
+ }
+
+ private func applySpaceLaneContentVisualState(_ segment: SpaceLaneSegmentLayers, isLocked: Bool) {
+ let primaryTextColor: NSColor = isLocked ? .white : .labelColor
+ let secondaryTextColor: NSColor = isLocked
+ ? .white
+ : .secondaryLabelColor
+
+ segment.labelLayer.foregroundColor = primaryTextColor.cgColor
+ segment.countLayer.foregroundColor = (isLocked ? NSColor.white : .secondaryLabelColor).cgColor
+ segment.appLayer.foregroundColor = (segment.space.type == .fullscreen
+ ? primaryTextColor
+ : secondaryTextColor
+ ).cgColor
+ for splitAppLayer in segment.splitAppLayers {
+ splitAppLayer.foregroundColor = primaryTextColor.cgColor
+ }
+
+ for block in segment.windowBlocks {
+ block.backgroundColor = (isLocked
+ ? NSColor.white
+ : spaceLaneOccupiedColor.withAlphaComponent(segment.space.isCurrent ? 0.72 : 0.58)
+ ).cgColor
+ }
+
+ (segment.fullscreenMarkerLayer as? CAShapeLayer)?.strokeColor = (isLocked
+ ? NSColor.white
+ : NSColor.secondaryLabelColor.withAlphaComponent(segment.space.isCurrent ? 0.42 : 0.28)
+ ).cgColor
}
private func shouldScrollSpaceLane(for event: NSEvent) -> Bool {
@@ -2263,6 +3035,26 @@
spaceLaneSegments.first { $0.space.id == spaceID }
}
+ private func settingsButtonContains(windowLocation: CGPoint) -> Bool {
+ let locationInView = convert(windowLocation, from: nil)
+ let locationInGlass = CGPoint(
+ x: locationInView.x - glassLayer.frame.minX,
+ y: locationInView.y - glassLayer.frame.minY
+ )
+ return settingsButtonLayer.frame.contains(locationInGlass)
+ }
+
+ private func clickSettingsButton(source: String) {
+ DevelopmentDiagnostics.log("quickSwitch.view.clickSettings", [
+ "source": source
+ ])
+ lastMouseCommand = "click-settings"
+ if !mouseCommandsApplied.contains("click-settings") {
+ mouseCommandsApplied.append("click-settings")
+ }
+ onOpenSettings?()
+ }
+
private func appShelfItem(at windowLocation: CGPoint) -> AppShelfItemLayers? {
let locationInView = convert(windowLocation, from: nil)
let locationInShelfContent = CGPoint(
@@ -2302,23 +3094,61 @@
.first(where: { $0.item.windowIndex == windowIndex })
}
+ private func waterfallCard(windowID: UInt32) -> WaterfallCardLayers? {
+ waterfallColumns
+ .lazy
+ .flatMap(\.cards)
+ .first(where: { $0.item.window.id == windowID })
+ }
+
private func layoutSpaceLaneSegmentContents(_ segment: SpaceLaneSegmentLayers) {
let bounds = segment.containerLayer.bounds
+ let splitAppNames = splitViewAppNames(for: segment.space)
+ let isSplitView = splitAppNames.count >= 2
segment.labelLayer.frame = CGRect(x: 10, y: bounds.height - 29, width: max(1, bounds.width - 48), height: 20)
segment.countLayer.frame = CGRect(x: bounds.width - 34, y: bounds.height - 29, width: 24, height: 20)
+ segment.countLayer.string = isSplitView ? "" : "\(segment.space.windowCount)"
+ segment.countLayer.isHidden = isSplitView
if segment.space.type == .fullscreen {
let markerFrame = fullscreenMarkerFrame(in: bounds)
- segment.appLayer.frame = CGRect(
- x: 8,
- y: markerFrame.midY - 8.5,
- width: max(1, bounds.width - 16),
- height: 17
- )
+ segment.appLayer.isHidden = isSplitView
+ if isSplitView {
+ let labelY = markerFrame.midY - 8.5
+ let halfWidth = markerFrame.width / 2
+ for (index, splitAppLayer) in segment.splitAppLayers.enumerated() {
+ let x = markerFrame.minX + CGFloat(index) * halfWidth
+ splitAppLayer.isHidden = false
+ splitAppLayer.frame = CGRect(
+ x: x + 4,
+ y: labelY,
+ width: max(1, halfWidth - 8),
+ height: 17
+ )
+ }
+ } else {
+ segment.appLayer.frame = CGRect(
+ x: 8,
+ y: markerFrame.midY - 8.5,
+ width: max(1, bounds.width - 16),
+ height: 17
+ )
+ for splitAppLayer in segment.splitAppLayers {
+ splitAppLayer.isHidden = true
+ }
+ }
} else {
+ segment.appLayer.isHidden = false
segment.appLayer.frame = CGRect(x: 10, y: 9, width: max(1, bounds.width - 20), height: 17)
+ for splitAppLayer in segment.splitAppLayers {
+ splitAppLayer.isHidden = true
+ }
}
if let fullscreenMarkerLayer = segment.fullscreenMarkerLayer {
- layoutFullscreenMarkerLayer(fullscreenMarkerLayer, in: bounds)
+ layoutFullscreenMarkerLayer(
+ fullscreenMarkerLayer,
+ in: bounds,
+ isSplitView: isSplitView
+ )
}
let blockGap: CGFloat = 5
@@ -2576,6 +3406,10 @@
return "none"
}
+ guard !isHorizontalMasonryMode else {
+ return "visible"
+ }
+
let visibleMinX = waterfallScrollOffset
let visibleMaxX = waterfallScrollOffset + waterfallLayer.bounds.width
if column.containerLayer.frame.maxX < visibleMinX + WaterfallMetrics.gap {
@@ -2658,17 +3492,24 @@
}
private func layoutWaterfallColumns() {
+ if isHorizontalMasonryMode {
+ layoutHorizontalMasonryWaterfall()
+ return
+ }
+
guard !waterfallColumns.isEmpty else {
waterfallContentWidth = waterfallLayer.bounds.width
waterfallScrollOffset = 0
+ horizontalMasonryContentHeight = waterfallLayer.bounds.height
+ horizontalMasonryScrollOffset = 0
waterfallContentLayer.frame = waterfallLayer.bounds
return
}
let columnWidth = waterfallColumnWidth()
- let totalWidth = WaterfallMetrics.contentHorizontalPadding * 2
- + CGFloat(waterfallColumns.count) * columnWidth
+ let columnsWidth = CGFloat(waterfallColumns.count) * columnWidth
+ CGFloat(max(0, waterfallColumns.count - 1)) * WaterfallMetrics.gap
+ let totalWidth = WaterfallMetrics.contentHorizontalPadding * 2 + columnsWidth
waterfallContentWidth = max(waterfallLayer.bounds.width, totalWidth)
waterfallScrollOffset = clampedWaterfallAlignmentOffset(waterfallScrollOffset)
waterfallContentLayer.frame = CGRect(
@@ -2678,7 +3519,7 @@
height: waterfallLayer.bounds.height
)
- var x = WaterfallMetrics.contentHorizontalPadding
+ var x = waterfallColumnStartX(columnsWidth: columnsWidth)
for column in waterfallColumns {
column.containerLayer.frame = CGRect(
x: x,
@@ -2691,7 +3532,174 @@
}
}
+ private func layoutHorizontalMasonryWaterfall() {
+ guard !waterfallColumns.isEmpty else {
+ waterfallContentWidth = waterfallLayer.bounds.width
+ waterfallScrollOffset = 0
+ horizontalMasonryContentHeight = waterfallLayer.bounds.height
+ horizontalMasonryScrollOffset = 0
+ waterfallContentLayer.frame = waterfallLayer.bounds
+ return
+ }
+
+ let layout = horizontalMasonryLayout()
+ waterfallContentWidth = waterfallLayer.bounds.width
+ waterfallScrollOffset = 0
+ horizontalMasonryContentHeight = layout.contentHeight
+ horizontalMasonryScrollOffset = clampedHorizontalMasonryOffset(horizontalMasonryScrollOffset)
+ waterfallContentLayer.frame = horizontalMasonryContentFrame()
+
+ for column in waterfallColumns {
+ column.containerLayer.frame = CGRect(
+ x: 0,
+ y: 0,
+ width: waterfallContentWidth,
+ height: horizontalMasonryContentHeight
+ )
+ column.containerLayer.masksToBounds = false
+ column.containerLayer.backgroundColor = NSColor.clear.cgColor
+ column.containerLayer.borderColor = NSColor.clear.cgColor
+ column.containerLayer.borderWidth = 0
+ column.containerLayer.shadowOpacity = 0
+ column.containerLayer.shadowRadius = 0
+ column.containerLayer.shadowOffset = .zero
+ column.headerLayer.isHidden = true
+ column.appNameLayer.isHidden = true
+ column.countLayer.isHidden = true
+
+ for card in column.cards {
+ if let frame = layout.cardFramesByWindowID[card.item.window.id] {
+ card.containerLayer.frame = frame
+ } else {
+ card.containerLayer.frame = .zero
+ }
+ layoutWaterfallCard(card)
+ }
+ }
+ }
+
+ private struct HorizontalMasonryLayout {
+ let contentHeight: CGFloat
+ let cardFramesByWindowID: [UInt32: CGRect]
+ }
+
+ private func horizontalMasonryLayout() -> HorizontalMasonryLayout {
+ let cards = horizontalMasonryCardsInPlacementOrder()
+ guard !cards.isEmpty else {
+ return HorizontalMasonryLayout(
+ contentHeight: waterfallLayer.bounds.height,
+ cardFramesByWindowID: [:]
+ )
+ }
+
+ let viewportWidth = max(1, waterfallLayer.bounds.width)
+ let availableWidth = max(
+ HorizontalMasonryMetrics.cardMinWidth,
+ viewportWidth - HorizontalMasonryMetrics.horizontalPadding * 2
+ )
+ let maximumLaneCount = max(
+ 1,
+ Int(
+ floor(
+ (availableWidth + HorizontalMasonryMetrics.horizontalGap)
+ / (HorizontalMasonryMetrics.cardMinWidth + HorizontalMasonryMetrics.horizontalGap)
+ )
+ )
+ )
+ let laneCount = min(maximumLaneCount, max(1, cards.count))
+ let fittingWidth = (
+ availableWidth - CGFloat(max(0, laneCount - 1)) * HorizontalMasonryMetrics.horizontalGap
+ ) / CGFloat(laneCount)
+ let cardWidth = floor(
+ min(
+ HorizontalMasonryMetrics.cardMaxWidth,
+ max(HorizontalMasonryMetrics.cardMinWidth, fittingWidth)
+ )
+ )
+ let usedWidth = CGFloat(laneCount) * cardWidth
+ + CGFloat(max(0, laneCount - 1)) * HorizontalMasonryMetrics.horizontalGap
+ let startX = max(
+ HorizontalMasonryMetrics.horizontalPadding,
+ (viewportWidth - usedWidth) / 2
+ )
+
+ var laneHeights = Array(repeating: CGFloat(0), count: laneCount)
+ var plannedFrames: [(windowID: UInt32, x: CGFloat, top: CGFloat, width: CGFloat, height: CGFloat)] = []
+
+ for card in cards {
+ let laneIndex = laneHeights.enumerated().min { lhs, rhs in
+ if abs(lhs.element - rhs.element) > 0.5 {
+ return lhs.element < rhs.element
+ }
+ return lhs.offset < rhs.offset
+ }?.offset ?? 0
+ let cardHeight = HorizontalMasonryMetrics.cardHeight
+ let x = startX + CGFloat(laneIndex) * (cardWidth + HorizontalMasonryMetrics.horizontalGap)
+ let top = HorizontalMasonryMetrics.verticalPadding + laneHeights[laneIndex]
+ plannedFrames.append((
+ windowID: card.item.window.id,
+ x: x,
+ top: top,
+ width: cardWidth,
+ height: cardHeight
+ ))
+ laneHeights[laneIndex] += cardHeight + HorizontalMasonryMetrics.verticalGap
+ }
+
+ let tallestLane = laneHeights.max().map {
+ max(0, $0 - HorizontalMasonryMetrics.verticalGap)
+ } ?? 0
+ let contentHeight = max(
+ waterfallLayer.bounds.height,
+ HorizontalMasonryMetrics.verticalPadding * 2 + tallestLane
+ )
+ let frames = Dictionary(
+ uniqueKeysWithValues: plannedFrames.map { planned in
+ (
+ planned.windowID,
+ CGRect(
+ x: planned.x,
+ y: contentHeight - planned.top - planned.height,
+ width: planned.width,
+ height: planned.height
+ )
+ )
+ }
+ )
+
+ return HorizontalMasonryLayout(contentHeight: contentHeight, cardFramesByWindowID: frames)
+ }
+
+ private func horizontalMasonryContentFrame() -> CGRect {
+ let contentHeight = max(waterfallLayer.bounds.height, horizontalMasonryContentHeight)
+ return CGRect(
+ x: 0,
+ y: waterfallLayer.bounds.height - contentHeight + horizontalMasonryScrollOffset,
+ width: waterfallLayer.bounds.width,
+ height: contentHeight
+ )
+ }
+
+ private func waterfallColumnStartX(columnsWidth: CGFloat) -> CGFloat {
+ guard currentViewModel?.lockedSpaceID != nil else {
+ return WaterfallMetrics.contentHorizontalPadding
+ }
+
+ let centeredStart = (waterfallContentWidth - columnsWidth) / 2
+ return max(WaterfallMetrics.contentHorizontalPadding, centeredStart)
+ }
+
private func layoutWaterfallColumn(_ column: WaterfallColumnLayers) {
+ column.containerLayer.cornerRadius = 14
+ column.containerLayer.masksToBounds = true
+ column.containerLayer.backgroundColor = NSColor.controlBackgroundColor.withAlphaComponent(0.56).cgColor
+ column.containerLayer.shadowOpacity = 0
+ column.containerLayer.shadowRadius = 0
+ column.containerLayer.shadowOffset = .zero
+ column.headerLayer.isHidden = false
+ column.appNameLayer.isHidden = false
+ column.countLayer.isHidden = false
+
let bounds = column.containerLayer.bounds
let isSpaceFocused = spaceFocusWindowCount(for: column.column.appGroupIndex) > 0
let isHovered = column.column.appGroupIndex == effectiveHoveredAppGroupIndex
@@ -3412,15 +4420,30 @@
)
}
+ private var isHorizontalMasonryMode: Bool {
+ waterfallViewMode == .horizontalMasonry
+ }
+
private var waterfallMaxScrollOffset: CGFloat {
- max(0, waterfallContentWidth - waterfallLayer.bounds.width)
+ guard !isHorizontalMasonryMode else { return 0 }
+ return max(0, waterfallContentWidth - waterfallLayer.bounds.width)
}
private func clampedWaterfallOffset(_ offset: CGFloat) -> CGFloat {
min(max(0, offset), waterfallMaxScrollOffset)
}
+ private var horizontalMasonryMaxScrollOffset: CGFloat {
+ max(0, horizontalMasonryContentHeight - waterfallLayer.bounds.height)
+ }
+
+ private func clampedHorizontalMasonryOffset(_ offset: CGFloat) -> CGFloat {
+ min(max(0, offset), horizontalMasonryMaxScrollOffset)
+ }
+
private func waterfallMaxVerticalScrollOffset(for appGroupIndex: Int) -> CGFloat {
+ guard !isHorizontalMasonryMode else { return 0 }
+
guard
let column = waterfallColumns.first(where: { $0.column.appGroupIndex == appGroupIndex })
else {
@@ -3469,6 +4492,14 @@
return NSColor(calibratedRed: 0, green: 122 / 255, blue: 1, alpha: 1)
}
+ private var spaceLaneLockedFillColor: NSColor {
+ if effectiveAppearance.bestMatch(from: [.darkAqua, .aqua]) == .darkAqua {
+ return NSColor(calibratedRed: 58 / 255, green: 148 / 255, blue: 1, alpha: 0.86)
+ }
+
+ return NSColor(calibratedRed: 90 / 255, green: 171 / 255, blue: 1, alpha: 0.82)
+ }
+
private func spaceLaneIdleOccupiedGradientColors() -> [NSColor] {
if effectiveAppearance.bestMatch(from: [.darkAqua, .aqua]) == .darkAqua {
let blue = NSColor(calibratedRed: 36 / 255, green: 54 / 255, blue: 72 / 255, alpha: 1)
@@ -3510,6 +4541,21 @@
shapeLayer.lineCap = .round
shapeLayer.lineJoin = .round
return shapeLayer
+ }
+
+ private func settingsIconImage() -> CGImage? {
+ let names = [
+ NSImage.Name("NSPreferencesGeneral"),
+ NSImage.Name("NSAdvanced")
+ ]
+ for name in names {
+ guard let image = NSImage(named: name) else { continue }
+ var rect = CGRect(origin: .zero, size: image.size)
+ if let cgImage = image.cgImage(forProposedRect: &rect, context: nil, hints: nil) {
+ return cgImage
+ }
+ }
+ return nil
}
private func makeTextLayer(
@@ -3689,13 +4735,38 @@
return identifiers.joined(separator: " ")
}
- private func layoutFullscreenMarkerLayer(_ layer: CALayer, in segmentBounds: CGRect) {
+ private func splitViewAppNames(for space: QuickSwitchSpaceViewModel) -> [String] {
+ guard space.type == .fullscreen else { return [] }
+
+ let names = space.splitViewAppNames
+ .prefix(2)
+ .map { $0.trimmingCharacters(in: .whitespacesAndNewlines) }
+ .filter { !$0.isEmpty }
+
+ guard names.count >= 2 else { return [] }
+ return names
+ }
+
+ private func layoutFullscreenMarkerLayer(
+ _ layer: CALayer,
+ in segmentBounds: CGRect,
+ isSplitView: Bool = false
+ ) {
let markerFrame = fullscreenMarkerFrame(in: segmentBounds)
layer.frame = markerFrame
guard let shapeLayer = layer as? CAShapeLayer else { return }
let bounds = shapeLayer.bounds
+ if isSplitView {
+ let path = CGMutablePath()
+ path.move(to: CGPoint(x: bounds.midX, y: bounds.minY))
+ path.addLine(to: CGPoint(x: bounds.midX, y: bounds.maxY))
+ shapeLayer.path = path
+ shapeLayer.lineCap = .butt
+ return
+ }
+
let cornerLength = min(12, max(7, min(bounds.width, bounds.height) * 0.28))
let path = CGMutablePath()
@@ -3716,6 +4787,7 @@
path.addLine(to: CGPoint(x: 0, y: bounds.maxY - cornerLength))
shapeLayer.path = path
+ shapeLayer.lineCap = .round
}
private func fullscreenMarkerFrame(in segmentBounds: CGRect) -> CGRect {
@@ -4104,6 +5176,8 @@
let fullscreenMarkerCenterRatio = fullscreenMarkerFrame.map {
Double($0.midY / max(1, segment.containerLayer.bounds.height))
}
+ let splitAppNames = splitViewAppNames(for: space)
+ let splitAppLabelFrames = segment.splitAppLayers.map { dictionary(from: $0.frame) }
return [
"displayUUID": display.displayUUID,
"displayLabel": display.displayLabel,
@@ -4112,19 +5186,44 @@
"type": spaceTypeName(space.type),
"visualStates": visualStates(for: space),
"fullscreenMarkerVisible": segment.fullscreenMarkerLayer != nil,
- "fullscreenMarkerKind": segment.fullscreenMarkerLayer == nil ? "none" : "cornerBracket",
+ "fullscreenMarkerKind": fullscreenMarkerKind(
+ markerLayer: segment.fullscreenMarkerLayer,
+ splitAppNames: splitAppNames
+ ),
+ "fullscreenMarkerPathStyle": fullscreenMarkerPathStyle(
+ markerLayer: segment.fullscreenMarkerLayer,
+ splitAppNames: splitAppNames
+ ),
"fullscreenMarkerFrame": fullscreenMarkerFrame.map { dictionary(from: $0) } ?? NSNull(),
"fullscreenMarkerCenterRatio": fullscreenMarkerCenterRatio ?? NSNull(),
+ "splitViewAppNames": splitAppNames,
+ "splitViewLabelFrames": splitAppLabelFrames,
+ "splitViewLabelColors": segment.splitAppLayers.map {
+ colorDictionary(from: $0.foregroundColor)
+ },
"windowBlockCount": segment.windowBlocks.count,
"windowBlockColors": segment.windowBlocks.map { colorDictionary(from: $0.backgroundColor) },
"windowBlockFrames": segment.windowBlocks.map { dictionary(from: $0.frame) },
+ "labelColor": colorDictionary(from: segment.labelLayer.foregroundColor),
+ "countText": string(from: segment.countLayer.string),
+ "countVisible": !segment.countLayer.isHidden && segment.countLayer.opacity > 0,
+ "countColor": colorDictionary(from: segment.countLayer.foregroundColor),
+ "appColor": colorDictionary(from: segment.appLayer.foregroundColor),
+ "fullscreenMarkerStrokeColor": colorDictionary(
+ from: (segment.fullscreenMarkerLayer as? CAShapeLayer)?.strokeColor
+ ),
"backgroundKind": spaceLaneFillKind(for: segment.containerLayer),
"backgroundColor": colorDictionary(from: segment.containerLayer.backgroundColor),
"gradientColors": gradientColorDictionaries(from: segment.containerLayer),
"borderColor": colorDictionary(from: segment.containerLayer.borderColor),
"borderWidth": Double(segment.containerLayer.borderWidth),
+ "shadowColor": colorDictionary(from: segment.containerLayer.shadowColor),
"shadowOpacity": Double(segment.containerLayer.shadowOpacity),
"shadowRadius": Double(segment.containerLayer.shadowRadius),
+ "shadowOffset": [
+ "width": Double(segment.containerLayer.shadowOffset.width),
+ "height": Double(segment.containerLayer.shadowOffset.height)
+ ],
"appFrame": dictionary(from: segment.appLayer.frame),
"frame": dictionary(from: segment.containerLayer.frame),
"visibleFrame": dictionary(from: visibleFrame),
@@ -4147,6 +5246,16 @@
}
}
+ private func fullscreenMarkerKind(markerLayer: CALayer?, splitAppNames: [String]) -> String {
+ guard markerLayer != nil else { return "none" }
+ return splitAppNames.count >= 2 ? "splitViewPair" : "cornerBracket"
+ }
+
+ private func fullscreenMarkerPathStyle(markerLayer: CALayer?, splitAppNames: [String]) -> String {
+ guard markerLayer != nil else { return "none" }
+ return splitAppNames.count >= 2 ? "centerDividerOnly" : "cornerBracket"
+ }
+
private func visualStates(for space: QuickSwitchSpaceViewModel) -> [String] {
var states: [String] = []
if space.isCurrent {
@@ -4164,8 +5273,14 @@
if space.id == activeSpaceFocusID {
states.append("focused")
}
+ if space.id == currentViewModel?.lockedSpaceID {
+ states.append("locked")
+ }
if space.type == .fullscreen {
states.append("fullscreen")
+ }
+ if splitViewAppNames(for: space).count >= 2 {
+ states.append("splitView")
}
return states
}
@@ -4192,6 +5307,16 @@
]
}
+ private func string(from textLayerValue: Any?) -> String {
+ if let string = textLayerValue as? String {
+ return string
+ }
+ if let attributedString = textLayerValue as? NSAttributedString {
+ return attributedString.string
+ }
+ return ""
+ }
+
private func colorDictionary(from color: CGColor?) -> [String: Double] {
guard let color,
let nsColor = NSColor(cgColor: color)?.usingColorSpace(.deviceRGB)
--
Gitblit v1.9.3