Fix Space Lane tile visuals

Ariver

2026-06-10 71acd11e8d5349672da8b1b6bb254e9a25ff4e51

 C1.source/Sources/Aligner/QuickSwitchRootView.swift

@@ -283,7 +283,7 @@
        static let columnMaxWidth: CGFloat = 292
        static let contentHorizontalPadding: CGFloat = 0
        static let columnHorizontalPadding: CGFloat = 0
        static let columnVerticalPadding: CGFloat = 12
        static let columnVerticalPadding: CGFloat = 0
        static let columnHeaderTextInset: CGFloat = 12
        static let headerHeight: CGFloat = 34
        static let cardHeight: CGFloat = 138
@@ -304,11 +304,11 @@
    }

    private enum SpaceLaneMetrics {
        static let horizontalPadding: CGFloat = 12
        static let groupGap: CGFloat = 30
        static let groupHorizontalPadding: CGFloat = 12
        static let groupVerticalPadding: CGFloat = 10
        static let segmentGap: CGFloat = 10
        static let horizontalPadding: CGFloat = 0
        static let groupGap: CGFloat = 36
        static let groupHorizontalPadding: CGFloat = 24
        static let groupVerticalPadding: CGFloat = 6
        static let segmentGap: CGFloat = 12
        static let segmentMinWidth: CGFloat = 96
        static let segmentMaxWidth: CGFloat = 150
    }
@@ -669,6 +669,8 @@
            "glassBorderWidth": Double(glassLayer.borderWidth),
            "glassShadowOpacity": Double(glassLayer.shadowOpacity),
            "spaceLaneFrame": dictionary(from: laneLayer.frame),
            "spaceLaneBackgroundColor": colorDictionary(from: laneLayer.backgroundColor),
            "spaceLaneCornerRadius": Double(laneLayer.cornerRadius),
            "spaceLaneContentWidth": Double(spaceLaneContentWidth),
            "spaceLaneVisibleWidth": Double(laneLayer.bounds.width),
            "spaceLaneMaxScrollOffset": Double(spaceLaneMaxScrollOffset),
@@ -1576,8 +1578,8 @@
        glassLayer.shadowOpacity = 0
        rootLayer.addSublayer(glassLayer)

        laneLayer.backgroundColor = NSColor.controlBackgroundColor.withAlphaComponent(0.68).cgColor
        laneLayer.cornerRadius = 16
        laneLayer.backgroundColor = NSColor.clear.cgColor
        laneLayer.cornerRadius = 0
        laneLayer.masksToBounds = true
        glassLayer.addSublayer(laneLayer)
        laneLayer.addSublayer(spaceLaneContentLayer)
@@ -1822,23 +1824,25 @@
        for display in currentViewModel?.displays ?? [] {
            let groupContainer = CALayer()
            groupContainer.name = display.displayLabel
            groupContainer.cornerRadius = 16
            groupContainer.cornerRadius = 14
            groupContainer.masksToBounds = false
            groupContainer.borderWidth = 1
            groupContainer.borderColor = NSColor.separatorColor.withAlphaComponent(0.26).cgColor
            groupContainer.backgroundColor = NSColor.windowBackgroundColor.withAlphaComponent(0.28).cgColor
            groupContainer.borderWidth = 0
            groupContainer.borderColor = NSColor.clear.cgColor
            groupContainer.backgroundColor = NSColor.windowBackgroundColor.cgColor
            groupContainer.shadowColor = NSColor.black.cgColor
            groupContainer.shadowOpacity = 0
            groupContainer.shadowRadius = 0
            groupContainer.shadowOffset = .zero

            let segments = display.spaces.map { space in
                let container = CALayer()
                let container = CAGradientLayer()
                container.name = space.label
                container.cornerRadius = 10
                container.borderWidth = 1
                container.borderColor = NSColor.separatorColor.withAlphaComponent(0.34).cgColor
                container.backgroundColor = spaceColor(for: space).cgColor
                container.backgroundColor = NSColor.clear.cgColor
                container.startPoint = CGPoint(x: 0.5, y: 1.0)
                container.endPoint = CGPoint(x: 0.5, y: 0.0)
                container.shadowColor = NSColor.black.cgColor

                let labelLayer = makeTextLayer(
@@ -2033,7 +2037,8 @@
    private func layoutSpaceLaneSegments() {
        guard !spaceLaneDisplayGroups.isEmpty, !spaceLaneSegments.isEmpty else { return }

        let groupHeight = max(1, laneLayer.bounds.height - 16)
        let groupOuterVerticalInset: CGFloat = 6
        let groupHeight = max(1, laneLayer.bounds.height - groupOuterVerticalInset * 2)
        let segmentHeight = max(1, groupHeight - SpaceLaneMetrics.groupVerticalPadding * 2)
        let groupGapWidth = CGFloat(max(0, spaceLaneDisplayGroups.count - 1)) * SpaceLaneMetrics.groupGap
        let segmentGapWidth = spaceLaneDisplayGroups.reduce(CGFloat(0)) { total, group in
@@ -2076,7 +2081,7 @@
            let groupWidth = groupWidths[index]
            group.containerLayer.frame = CGRect(
                x: x,
                y: 8,
                y: groupOuterVerticalInset,
                width: groupWidth,
                height: groupHeight
            )
@@ -2114,29 +2119,14 @@
                || segment.space.id == windowHoverAssociatedSpaceID
        }
        let hasCurrentSegment = group.display.spaces.contains { $0.isCurrent }
        let hasWindows = group.display.spaces.contains { $0.windowCount > 0 }
        let background = hasActiveSegment
            ? accentTintedWindowBackground(fraction: 0.035, alpha: 0.62)
            : NSColor.windowBackgroundColor.withAlphaComponent(hasWindows ? 0.44 : 0.30)

        group.containerLayer.backgroundColor = background.cgColor
        group.containerLayer.borderColor = (hasActiveSegment
            ? spaceLaneOccupiedColor.withAlphaComponent(0.36)
            : hasCurrentSegment
                ? NSColor.labelColor.withAlphaComponent(0.22)
                : NSColor.separatorColor.withAlphaComponent(0.24)
        ).cgColor
        group.containerLayer.borderWidth = 1
        group.containerLayer.shadowOpacity = hasActiveSegment ? 0.12 : 0
        group.containerLayer.shadowRadius = hasActiveSegment ? 14 : 0
        group.containerLayer.shadowOffset = CGSize(width: 0, height: -3)
        group.containerLayer.backgroundColor = NSColor.windowBackgroundColor.cgColor
        group.containerLayer.borderColor = NSColor.clear.cgColor
        group.containerLayer.borderWidth = 0
        group.containerLayer.shadowOpacity = 0
        group.containerLayer.shadowRadius = 0
        group.containerLayer.shadowOffset = .zero
        group.containerLayer.zPosition = hasActiveSegment ? 8 : hasCurrentSegment ? 4 : 0
        group.containerLayer.shadowPath = CGPath(
            roundedRect: group.containerLayer.bounds,
            cornerWidth: group.containerLayer.cornerRadius,
            cornerHeight: group.containerLayer.cornerRadius,
            transform: nil
        )
        group.containerLayer.shadowPath = nil
    }

    private func applySpaceLaneVisualState(_ segment: SpaceLaneSegmentLayers) {
@@ -2160,12 +2150,24 @@
                    ? NSColor.labelColor.withAlphaComponent(0.34)
                : NSColor.separatorColor.withAlphaComponent(0.34)
        ).cgColor
        segment.containerLayer.backgroundColor = (isActive
            ? accentTintedWindowBackground(fraction: 0.10, alpha: 0.94)
            : isAssociated
                ? accentTintedWindowBackground(fraction: 0.07, alpha: 0.90)
                : spaceColor(for: segment.space)
        ).cgColor
        if isActive {
            applySpaceLaneSolidFill(
                to: segment.containerLayer,
                color: accentTintedWindowBackground(fraction: 0.10, alpha: 0.94)
            )
        } else if isAssociated {
            applySpaceLaneSolidFill(
                to: segment.containerLayer,
                color: accentTintedWindowBackground(fraction: 0.07, alpha: 0.90)
            )
        } else if hasWindows {
            applySpaceLaneGradientFill(
                to: segment.containerLayer,
                colors: spaceLaneIdleOccupiedGradientColors()
            )
        } else {
            applySpaceLaneSolidFill(to: segment.containerLayer, color: .clear)
        }
        segment.containerLayer.shadowOpacity = isActive ? 0.26 : isAssociated ? 0.18 : isCurrent ? 0.14 : 0
        segment.containerLayer.shadowRadius = isActive ? 24 : isAssociated ? 18 : isCurrent ? 12 : 0
        segment.containerLayer.shadowOffset = CGSize(
@@ -3452,20 +3454,43 @@
        return states.joined(separator: " / ")
    }

    private func spaceColor(for space: QuickSwitchSpaceViewModel) -> NSColor {
        if space.windowCount > 0 {
            return NSColor.controlBackgroundColor.withAlphaComponent(0.36)
        }

        return NSColor.labelColor.withAlphaComponent(space.isCurrent ? 0.07 : 0.05)
    }

    private var spaceLaneOccupiedColor: NSColor {
        if effectiveAppearance.bestMatch(from: [.darkAqua, .aqua]) == .darkAqua {
            return NSColor(calibratedRed: 10 / 255, green: 132 / 255, blue: 1, alpha: 1)
        }

        return NSColor(calibratedRed: 0, green: 122 / 255, blue: 1, alpha: 1)
    }

    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)
            let surface = NSColor.windowBackgroundColor.withAlphaComponent(1)
            return [blue, surface]
        }

        return [
            NSColor(calibratedRed: 232 / 255, green: 246 / 255, blue: 1, alpha: 1),
            NSColor.white
        ]
    }

    private func applySpaceLaneGradientFill(to layer: CALayer, colors: [NSColor]) {
        if let gradientLayer = layer as? CAGradientLayer {
            gradientLayer.colors = colors.map(\.cgColor)
            gradientLayer.locations = [0, 1]
            gradientLayer.startPoint = CGPoint(x: 0.5, y: 1.0)
            gradientLayer.endPoint = CGPoint(x: 0.5, y: 0.0)
        }
        layer.backgroundColor = NSColor.clear.cgColor
    }

    private func applySpaceLaneSolidFill(to layer: CALayer, color: NSColor) {
        if let gradientLayer = layer as? CAGradientLayer {
            gradientLayer.colors = nil
            gradientLayer.locations = nil
        }
        layer.backgroundColor = color.cgColor
    }

    private func makeFullscreenMarkerLayer(for space: QuickSwitchSpaceViewModel) -> CALayer? {
@@ -3687,11 +3712,18 @@
    }

    private func fullscreenMarkerFrame(in segmentBounds: CGRect) -> CGRect {
        CGRect(
        let topReserved: CGFloat = 32
        let bottomReserved: CGFloat = 16
        let availableHeight = max(20, segmentBounds.height - topReserved - bottomReserved)
        let markerHeight = min(30, max(20, availableHeight))
        let markerCenterY = bottomReserved + availableHeight * 0.5
        let markerY = max(8, min(segmentBounds.height - topReserved - markerHeight, markerCenterY - markerHeight * 0.5))

        return CGRect(
            x: 10,
            y: 12,
            y: markerY,
            width: max(1, segmentBounds.width - 20),
            height: max(1, segmentBounds.height - 64)
            height: markerHeight
        )
    }

@@ -3778,6 +3810,13 @@
            let visibleFrame = column.containerLayer.frame.offsetBy(dx: waterfallContentLayer.frame.minX, dy: 0)
            let appGroupIndex = column.column.appGroupIndex
            let isHovered = appGroupIndex == effectiveHoveredAppGroupIndex
            let firstCardFrame = column.cards.first?.containerLayer.frame
            let headerToFirstCardGap = firstCardFrame.map {
                column.headerLayer.frame.minY - $0.maxY
            }
            let topToFirstCardGap = firstCardFrame.map {
                column.containerLayer.bounds.height - $0.maxY
            }

            return [
                "appGroupIndex": appGroupIndex,
@@ -3791,6 +3830,9 @@
                "spaceFocusDirection": spaceFocusDirection(for: appGroupIndex),
                "frame": dictionary(from: column.containerLayer.frame),
                "visibleFrame": dictionary(from: visibleFrame),
                "headerFrame": dictionary(from: column.headerLayer.frame),
                "headerToFirstCardGap": headerToFirstCardGap.map(Double.init) ?? NSNull(),
                "topToFirstCardGap": topToFirstCardGap.map(Double.init) ?? NSNull(),
                "appNameFrame": dictionary(from: column.appNameLayer.frame),
                "appNameAlignment": column.appNameLayer.alignmentMode.rawValue,
                "appNameColor": colorDictionary(from: column.appNameLayer.foregroundColor),
@@ -4031,6 +4073,8 @@
                "shadowOpacity": Double(group.containerLayer.shadowOpacity),
                "shadowRadius": Double(group.containerLayer.shadowRadius),
                "groupGap": Double(SpaceLaneMetrics.groupGap),
                "groupHorizontalPadding": Double(SpaceLaneMetrics.groupHorizontalPadding),
                "groupVerticalPadding": Double(SpaceLaneMetrics.groupVerticalPadding),
                "segmentGap": Double(SpaceLaneMetrics.segmentGap)
            ] as [String: Any]
        }
@@ -4049,6 +4093,10 @@
                    dx: (group?.containerLayer.frame.minX ?? 0) + spaceLaneContentLayer.frame.minX,
                    dy: group?.containerLayer.frame.minY ?? 0
                )
                let fullscreenMarkerFrame = segment.fullscreenMarkerLayer?.frame
                let fullscreenMarkerCenterRatio = fullscreenMarkerFrame.map {
                    Double($0.midY / max(1, segment.containerLayer.bounds.height))
                }
                return [
                    "displayUUID": display.displayUUID,
                    "displayLabel": display.displayLabel,
@@ -4058,11 +4106,14 @@
                    "visualStates": visualStates(for: space),
                    "fullscreenMarkerVisible": segment.fullscreenMarkerLayer != nil,
                    "fullscreenMarkerKind": segment.fullscreenMarkerLayer == nil ? "none" : "cornerBracket",
                    "fullscreenMarkerFrame": segment.fullscreenMarkerLayer.map { dictionary(from: $0.frame) } ?? NSNull(),
                    "fullscreenMarkerFrame": fullscreenMarkerFrame.map { dictionary(from: $0) } ?? NSNull(),
                    "fullscreenMarkerCenterRatio": fullscreenMarkerCenterRatio ?? NSNull(),
                    "windowBlockCount": segment.windowBlocks.count,
                    "windowBlockColors": segment.windowBlocks.map { colorDictionary(from: $0.backgroundColor) },
                    "windowBlockFrames": segment.windowBlocks.map { dictionary(from: $0.frame) },
                    "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),
                    "shadowOpacity": Double(segment.containerLayer.shadowOpacity),
@@ -4153,4 +4204,23 @@
            "alpha": Double(nsColor.alphaComponent)
        ]
    }

    private func gradientColorDictionaries(from layer: CALayer) -> [[String: Double]] {
        guard let gradientLayer = layer as? CAGradientLayer else { return [] }
        return (gradientLayer.colors ?? []).map { color in
            let cgColor = color as! CGColor
            return colorDictionary(from: cgColor)
        }
    }

    private func spaceLaneFillKind(for layer: CALayer) -> String {
        if !gradientColorDictionaries(from: layer).isEmpty {
            return "gradient"
        }
        let background = colorDictionary(from: layer.backgroundColor)
        if background["alpha", default: 0] <= 0.01 {
            return "clear"
        }
        return "solid"
    }
}