@lattices/cli 0.4.2 → 0.4.6

package/app/Sources/Core/Overlays/OverlayPanelShell.swift

@@ -0,0 +1,241 @@
+import AppKit
+import SwiftUI
+
+final class OverlayPanel: NSPanel {
+    var activatesOnMouseDown = false
+    var onKeyDown: ((NSEvent) -> Void)?
+    var onFlagsChanged: ((NSEvent) -> Void)?
+
+    override var canBecomeKey: Bool { true }
+    override var canBecomeMain: Bool { true }
+
+    override func sendEvent(_ event: NSEvent) {
+        if activatesOnMouseDown,
+           event.type == .leftMouseDown || event.type == .rightMouseDown {
+            if !NSApp.isActive {
+                NSApp.activate(ignoringOtherApps: true)
+            }
+            if !isKeyWindow {
+                makeKey()
+            }
+        }
+        super.sendEvent(event)
+    }
+
+    override func keyDown(with event: NSEvent) {
+        if let onKeyDown {
+            onKeyDown(event)
+        } else {
+            super.keyDown(with: event)
+        }
+    }
+
+    override func flagsChanged(with event: NSEvent) {
+        if let onFlagsChanged {
+            onFlagsChanged(event)
+        } else {
+            super.flagsChanged(with: event)
+        }
+    }
+}
+
+private final class OverlayHostingView<Content: View>: NSHostingView<Content> {
+    override func acceptsFirstMouse(for event: NSEvent?) -> Bool { true }
+    override var focusRingType: NSFocusRingType { get { .none } set {} }
+}
+
+struct OverlayPanelShell {
+    enum Background {
+        case clear
+        case solid(NSColor)
+        case material(NSVisualEffectView.Material)
+    }
+
+    enum Placement {
+        case centered(yOffsetRatio: CGFloat = 0)
+        case mouseScreenCentered(yOffsetRatio: CGFloat = 0)
+        case topCenter(margin: CGFloat = 40)
+    }
+
+    struct Config {
+        var size: NSSize
+        var styleMask: NSWindow.StyleMask = [.nonactivatingPanel]
+        var title: String = ""
+        var titleVisible: NSWindow.TitleVisibility = .hidden
+        var titlebarAppearsTransparent = false
+        var background: Background = .clear
+        var cornerRadius: CGFloat? = nil
+        var level: NSWindow.Level = .floating
+        var hasShadow = true
+        var hidesOnDeactivate = false
+        var isReleasedWhenClosed = false
+        var isMovableByWindowBackground = false
+        var collectionBehavior: NSWindow.CollectionBehavior = [.canJoinAllSpaces, .fullScreenAuxiliary]
+        var minSize: NSSize? = nil
+        var maxSize: NSSize? = nil
+        var activatesOnMouseDown = false
+        var onKeyDown: ((NSEvent) -> Void)? = nil
+        var onFlagsChanged: ((NSEvent) -> Void)? = nil
+        var appearance: NSAppearance? = NSAppearance(named: .darkAqua)
+    }
+
+    static func makePanel<Content: View>(config: Config, rootView: Content) -> OverlayPanel {
+        let hosting = OverlayHostingView(rootView: rootView)
+        hosting.translatesAutoresizingMaskIntoConstraints = false
+
+        let panel = OverlayPanel(
+            contentRect: NSRect(origin: .zero, size: config.size),
+            styleMask: config.styleMask,
+            backing: .buffered,
+            defer: false
+        )
+        panel.title = config.title
+        panel.titleVisibility = config.titleVisible
+        panel.titlebarAppearsTransparent = config.titlebarAppearsTransparent
+        panel.isOpaque = false
+        panel.backgroundColor = backgroundColor(for: config.background)
+        panel.level = config.level
+        panel.hasShadow = config.hasShadow
+        panel.hidesOnDeactivate = config.hidesOnDeactivate
+        panel.isReleasedWhenClosed = config.isReleasedWhenClosed
+        panel.isMovableByWindowBackground = config.isMovableByWindowBackground
+        panel.collectionBehavior = config.collectionBehavior
+        panel.activatesOnMouseDown = config.activatesOnMouseDown
+        panel.onKeyDown = config.onKeyDown
+        panel.onFlagsChanged = config.onFlagsChanged
+        if let minSize = config.minSize {
+            panel.minSize = minSize
+        }
+        if let maxSize = config.maxSize {
+            panel.maxSize = maxSize
+        }
+        if let appearance = config.appearance {
+            panel.appearance = appearance
+        }
+
+        install(hosting: hosting, on: panel, background: config.background, cornerRadius: config.cornerRadius)
+        return panel
+    }
+
+    static func position(_ window: NSWindow, placement: Placement) {
+        let screen: NSScreen
+        switch placement {
+        case .mouseScreenCentered, .topCenter:
+            screen = mouseScreen()
+        case .centered:
+            screen = NSScreen.main ?? mouseScreen()
+        }
+
+        let visibleFrame = screen.visibleFrame
+        let size = window.frame.size
+        let origin: NSPoint
+
+        switch placement {
+        case .centered(let yOffsetRatio), .mouseScreenCentered(let yOffsetRatio):
+            origin = NSPoint(
+                x: visibleFrame.midX - size.width / 2,
+                y: visibleFrame.midY - size.height / 2 + (visibleFrame.height * yOffsetRatio)
+            )
+        case .topCenter(let margin):
+            origin = NSPoint(
+                x: visibleFrame.midX - size.width / 2,
+                y: visibleFrame.maxY - size.height - margin
+            )
+        }
+
+        window.setFrameOrigin(origin)
+    }
+
+    static func present(
+        _ panel: NSPanel,
+        activate: Bool = true,
+        makeKey: Bool = true,
+        orderFrontRegardless: Bool = false
+    ) {
+        if orderFrontRegardless {
+            panel.orderFrontRegardless()
+        } else if makeKey {
+            panel.makeKeyAndOrderFront(nil)
+        } else {
+            panel.orderFront(nil)
+        }
+
+        if makeKey {
+            panel.makeKey()
+        }
+
+        if activate {
+            NSApp.activate(ignoringOtherApps: true)
+        }
+    }
+
+    private static func install(
+        hosting: NSView,
+        on panel: NSPanel,
+        background: Background,
+        cornerRadius: CGFloat?
+    ) {
+        switch background {
+        case .material(let material):
+            let effectView = NSVisualEffectView()
+            effectView.blendingMode = .behindWindow
+            effectView.material = material
+            effectView.state = .active
+            effectView.wantsLayer = true
+            if let cornerRadius {
+                effectView.maskImage = maskImage(cornerRadius: cornerRadius)
+            }
+            panel.contentView = effectView
+            pin(hosting: hosting, to: effectView)
+        case .clear, .solid:
+            panel.contentView = hosting
+        }
+    }
+
+    private static func pin(hosting: NSView, to container: NSView) {
+        container.addSubview(hosting)
+        NSLayoutConstraint.activate([
+            hosting.leadingAnchor.constraint(equalTo: container.leadingAnchor),
+            hosting.trailingAnchor.constraint(equalTo: container.trailingAnchor),
+            hosting.topAnchor.constraint(equalTo: container.topAnchor),
+            hosting.bottomAnchor.constraint(equalTo: container.bottomAnchor),
+        ])
+    }
+
+    private static func mouseScreen() -> NSScreen {
+        let mouseLocation = NSEvent.mouseLocation
+        return NSScreen.screens.first(where: { $0.frame.contains(mouseLocation) })
+            ?? NSScreen.main
+            ?? NSScreen.screens.first!
+    }
+
+    private static func backgroundColor(for background: Background) -> NSColor {
+        switch background {
+        case .clear, .material:
+            return .clear
+        case .solid(let color):
+            return color
+        }
+    }
+
+    private static func maskImage(cornerRadius: CGFloat) -> NSImage {
+        let edgeLength = 2.0 * cornerRadius + 1.0
+        let maskImage = NSImage(
+            size: NSSize(width: edgeLength, height: edgeLength),
+            flipped: false
+        ) { rect in
+            let path = NSBezierPath(roundedRect: rect, xRadius: cornerRadius, yRadius: cornerRadius)
+            NSColor.black.set()
+            path.fill()
+            return true
+        }
+        maskImage.capInsets = NSEdgeInsets(
+            top: cornerRadius,
+            left: cornerRadius,
+            bottom: cornerRadius,
+            right: cornerRadius
+        )
+        maskImage.resizingMode = .stretch
+        return maskImage
+    }
+}

package/app/Sources/{ScreenMapState.swift → Core/Overlays/ScreenMap/ScreenMapState.swift}

@@ -1,4 +1,5 @@
 import AppKit
+import Combine
 import Foundation
 import SwiftUI
 
@@ -251,7 +252,8 @@ final class ScreenMapEditorState: ObservableObject {
     static let minZoom: CGFloat = 0.3
     static let maxZoom: CGFloat = 5.0
 
-    var effectiveScale: CGFloat { scale * zoomLevel }
+    /// `scale` is the synced effective canvas scale (fit scale × zoom).
+    var effectiveScale: CGFloat { scale }
 
     func resetZoomPan() {
         zoomLevel = 1.0
@@ -330,6 +332,12 @@ final class ScreenMapEditorState: ObservableObject {
         effectiveLayers.count
     }
 
+    /// Total windows in the current display scope before any layer filter is applied.
+    var scopedWindowCount: Int {
+        guard let dIdx = focusedDisplayIndex else { return windows.count }
+        return windows.filter { $0.displayIndex == dIdx }.count
+    }
+
     /// Window count for a layer, scoped to the focused display
     func effectiveWindowCount(for layer: Int) -> Int {
         guard let dIdx = focusedDisplayIndex else {
@@ -338,6 +346,27 @@ final class ScreenMapEditorState: ObservableObject {
         return windows.filter { $0.layer == layer && $0.displayIndex == dIdx }.count
     }
 
+    /// Windows currently rendered in the main canvas.
+    var renderedCanvasWindows: [ScreenMapWindowEntry] {
+        focusedDisplayIndex != nil ? focusedVisibleWindows : visibleWindows
+    }
+
+    var namedEffectiveLayers: [Int] {
+        effectiveLayers.filter { layerNames[$0] != nil }
+    }
+
+    var unnamedEffectiveLayers: [Int] {
+        effectiveLayers.filter { layerNames[$0] == nil }
+    }
+
+    func layerTreeWindows(for layer: Int) -> [ScreenMapWindowEntry] {
+        var scoped = windows.filter { $0.layer == layer }
+        if let dIdx = focusedDisplayIndex {
+            scoped = scoped.filter { $0.displayIndex == dIdx }
+        }
+        return scoped.sorted { $0.zIndex < $1.zIndex }
+    }
+
     /// Visible window count per display index
     func visibleWindowCount(for displayIndex: Int) -> Int {
         visibleWindows.filter { $0.displayIndex == displayIndex }.count
@@ -510,6 +539,12 @@ final class ScreenMapEditorState: ObservableObject {
         return regions
     }
 
+    func displayRegion(for displayIndex: Int) -> ScreenMapCanvasRegion? {
+        canvasExplorerRegions.first {
+            $0.kind == .display && $0.displayIndex == displayIndex
+        }
+    }
+
     private func regionRect(for windows: [ScreenMapWindowEntry], fallback: CGRect, padding: CGFloat) -> CGRect {
         guard !windows.isEmpty else { return fallback.insetBy(dx: -padding, dy: -padding) }
 
@@ -1350,8 +1385,12 @@ final class ScreenMapActionLog {
 // MARK: - Screen Map Controller
 
 final class ScreenMapController: ObservableObject {
-    @Published var editor: ScreenMapEditorState?
-    @Published var selectedWindowIds: Set<UInt32> = []
+    @Published var editor: ScreenMapEditorState? {
+        didSet { bindEditor() }
+    }
+    @Published var selectedWindowIds: Set<UInt32> = [] {
+        didSet { syncSharedSelection() }
+    }
     @Published var windowSets: [ScreenMapWindowSet] = []
     @Published var activeWindowSetID: UUID? = nil
     @Published var flashMessage: String? = nil
@@ -1364,6 +1403,7 @@ final class ScreenMapController: ObservableObject {
         case left, right, none
     }
     @Published var displayTransition: DisplayTransitionDirection = .none
+    private var editorObserver: AnyCancellable?
 
     var previewWindow: NSWindow? = nil
     private var previewGlobalMonitor: Any? = nil
@@ -1371,6 +1411,52 @@ final class ScreenMapController: ObservableObject {
 
     var onDismiss: (() -> Void)?
 
+    enum DisplayFocusDirection {
+        case previous
+        case next
+    }
+
+    private func bindEditor() {
+        editorObserver = editor?.objectWillChange.sink { [weak self] _ in
+            self?.objectWillChange.send()
+        }
+    }
+
+    private func finalizeDisplayFocusChange(flashLabel: Bool) {
+        guard let ed = editor else { return }
+        focusViewportPreset(ed.activeViewportPreset ?? .main, flashView: false)
+        if flashLabel {
+            flash(ed.focusedDisplay?.label ?? "All displays")
+        }
+        objectWillChange.send()
+    }
+
+    func setDisplayFocus(_ index: Int?, flashLabel: Bool = false) {
+        guard let ed = editor else { return }
+        ed.focusDisplay(index)
+        finalizeDisplayFocusChange(flashLabel: flashLabel)
+    }
+
+    func stepDisplayFocus(_ direction: DisplayFocusDirection, flashLabel: Bool = true) {
+        guard let ed = editor, ed.displays.count > 1 else { return }
+        switch direction {
+        case .previous:
+            ed.cyclePreviousDisplay()
+        case .next:
+            ed.cycleNextDisplay()
+        }
+        finalizeDisplayFocusChange(flashLabel: flashLabel)
+    }
+
+    func adjustZoom(by delta: CGFloat) {
+        guard let ed = editor else { return }
+        let newZoom = max(ScreenMapEditorState.minZoom, min(ScreenMapEditorState.maxZoom, ed.zoomLevel + delta))
+        guard newZoom != ed.zoomLevel else { return }
+        ed.activeViewportPreset = nil
+        ed.zoomLevel = newZoom
+        objectWillChange.send()
+    }
+
     // MARK: - Selection
 
     func isSelected(_ id: UInt32) -> Bool { selectedWindowIds.contains(id) }
@@ -1400,6 +1486,28 @@ final class ScreenMapController: ObservableObject {
         activeWindowSetID = nil
     }
 
+    private func syncSharedSelection() {
+        guard !selectedWindowIds.isEmpty else {
+            WindowSelectionStore.shared.clear(source: "screen-map")
+            return
+        }
+
+        guard let editor else { return }
+        let summaries = editor.windows
+            .filter { selectedWindowIds.contains($0.id) }
+            .map {
+                SelectedWindowSummary(
+                    wid: $0.id,
+                    app: $0.app,
+                    title: $0.title,
+                    latticesSession: $0.latticesSession
+                )
+            }
+
+        guard !summaries.isEmpty else { return }
+        WindowSelectionStore.shared.setSelection(summaries, source: "screen-map")
+    }
+
     func selectNextWindow() {
         guard let ed = editor else { return }
         let wins = ed.focusedVisibleWindows.sorted(by: { $0.zIndex < $1.zIndex })
@@ -1616,7 +1724,7 @@ final class ScreenMapController: ObservableObject {
             guard CGRectMakeWithDictionaryRepresentation(boundsDict, &rect) else { continue }
             guard rect.width >= 100 && rect.height >= 50 else { continue }
             let app = info[kCGWindowOwnerName as String] as? String ?? ""
-            if app == "Lattices" || app == "lattices" || app == "Lattices" { continue }
+            if app == "Lattices" || app == "lattices" || app == "AutoFill" { continue }
             let pid = info[kCGWindowOwnerPID as String] as? Int32 ?? 0
             let title = info[kCGWindowName as String] as? String ?? ""
             let dIdx = displayIndex(for: rect)
@@ -2052,23 +2160,11 @@ final class ScreenMapController: ObservableObject {
         // MARK: Right hand — Navigation
 
         case 4: // h → previous display
-            if let ed = editor, ed.displays.count > 1 {
-                ed.cyclePreviousDisplay()
-                focusViewportPreset(ed.activeViewportPreset ?? .main, flashView: false)
-                let label = ed.focusedDisplay?.label ?? "All displays"
-                flash(label)
-                objectWillChange.send()
-            }
+            stepDisplayFocus(.previous)
             return true
 
         case 37: // l → next display
-            if let ed = editor, ed.displays.count > 1 {
-                ed.cycleNextDisplay()
-                focusViewportPreset(ed.activeViewportPreset ?? .main, flashView: false)
-                let label = ed.focusedDisplay?.label ?? "All displays"
-                flash(label)
-                objectWillChange.send()
-            }
+            stepDisplayFocus(.next)
             return true
 
         case 38: // j → next layer
@@ -2213,23 +2309,11 @@ final class ScreenMapController: ObservableObject {
             return true
 
         case 123: // ← previous display (secondary)
-            if let ed = editor, ed.displays.count > 1 {
-                ed.cyclePreviousDisplay()
-                focusViewportPreset(ed.activeViewportPreset ?? .main, flashView: false)
-                let label = ed.focusedDisplay?.label ?? "All displays"
-                flash(label)
-                objectWillChange.send()
-            }
+            stepDisplayFocus(.previous)
             return true
 
         case 124: // → next display (secondary)
-            if let ed = editor, ed.displays.count > 1 {
-                ed.cycleNextDisplay()
-                focusViewportPreset(ed.activeViewportPreset ?? .main, flashView: false)
-                let label = ed.focusedDisplay?.label ?? "All displays"
-                flash(label)
-                objectWillChange.send()
-            }
+            stepDisplayFocus(.next)
             return true
 
         case 44: // / → open window search