@lattices/cli 0.4.5 → 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}

@@ -1388,7 +1388,9 @@ final class ScreenMapController: ObservableObject {
     @Published var editor: ScreenMapEditorState? {
         didSet { bindEditor() }
     }
-    @Published var selectedWindowIds: Set<UInt32> = []
+    @Published var selectedWindowIds: Set<UInt32> = [] {
+        didSet { syncSharedSelection() }
+    }
     @Published var windowSets: [ScreenMapWindowSet] = []
     @Published var activeWindowSetID: UUID? = nil
     @Published var flashMessage: String? = nil
@@ -1484,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 })

package/app/Sources/{VoiceCommandWindow.swift → Core/Overlays/Voice/VoiceCommandWindow.swift}

@@ -2,55 +2,12 @@ import AppKit
 import Combine
 import SwiftUI
 
-// MARK: - Panel subclass (handles keyDown when focused)
-
-final class VoicePanel: NSPanel {
-    var onKeyDown: ((NSEvent) -> Void)?
-    var onFlagsChanged: ((NSEvent) -> Void)?
-
-    override var canBecomeKey: Bool { true }
-    override var canBecomeMain: Bool { true }
-
-    override func sendEvent(_ event: NSEvent) {
-        if 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 handler = onKeyDown {
-            handler(event)
-        } else {
-            super.keyDown(with: event)
-        }
-    }
-
-    override func flagsChanged(with event: NSEvent) {
-        if let handler = onFlagsChanged {
-            handler(event)
-        } else {
-            super.flagsChanged(with: event)
-        }
-    }
-}
-
-private final class VoiceHostingView<Content: View>: NSHostingView<Content> {
-    override func acceptsFirstMouse(for event: NSEvent?) -> Bool { true }
-    override var focusRingType: NSFocusRingType { get { .none } set {} }
-}
-
 // MARK: - Window Controller
 
 final class VoiceCommandWindow {
     static let shared = VoiceCommandWindow()
 
-    private(set) var panel: VoicePanel?
+    private(set) var panel: OverlayPanel?
     private var keyMonitor: Any?
     private var state: VoiceCommandState?
 
@@ -66,7 +23,7 @@ final class VoiceCommandWindow {
 
     func show() {
         // If panel exists but is hidden, just re-show it
-        if let p = panel, let s = state {
+        if let p = panel, state != nil {
             p.alphaValue = 0
             p.orderFrontRegardless()
             NSAnimationContext.runAnimationGroup { ctx in
@@ -87,42 +44,32 @@ final class VoiceCommandWindow {
         .preferredColorScheme(.dark)
 
         let mouseLocation = NSEvent.mouseLocation
-        let screen = NSScreen.screens.first(where: { $0.frame.contains(mouseLocation) }) ?? NSScreen.main ?? NSScreen.screens.first!
+        let screen = NSScreen.screens.first(where: { $0.frame.contains(mouseLocation) })
+            ?? NSScreen.main
+            ?? NSScreen.screens.first!
         let visible = screen.visibleFrame
-
         let panelWidth: CGFloat = min(900, visible.width - 80)
         let panelHeight: CGFloat = min(560, visible.height - 80)
 
-        let p = VoicePanel(
-            contentRect: NSRect(x: 0, y: 0, width: panelWidth, height: panelHeight),
-            styleMask: [.titled, .nonactivatingPanel],
-            backing: .buffered,
-            defer: false
+        let p = OverlayPanelShell.makePanel(
+            config: .init(
+                size: NSSize(width: panelWidth, height: panelHeight),
+                styleMask: [.titled, .nonactivatingPanel],
+                titleVisible: .hidden,
+                titlebarAppearsTransparent: true,
+                background: .clear,
+                hidesOnDeactivate: false,
+                isMovableByWindowBackground: true,
+                activatesOnMouseDown: true,
+                onKeyDown: { [weak self] event in self?.handleKey(event) },
+                onFlagsChanged: { [weak self] event in self?.handleFlags(event) }
+            ),
+            rootView: view
         )
-        p.onKeyDown = { [weak self] event in self?.handleKey(event) }
-        p.onFlagsChanged = { [weak self] event in self?.handleFlags(event) }
-        p.titlebarAppearsTransparent = true
-        p.titleVisibility = .hidden
-        p.isOpaque = false
-        p.backgroundColor = .clear
-        p.level = .floating
-        p.hasShadow = true
-        p.hidesOnDeactivate = false
-        p.isReleasedWhenClosed = false
-        p.isMovableByWindowBackground = true
-        let hosting = VoiceHostingView(rootView: view)
-        hosting.translatesAutoresizingMaskIntoConstraints = false
-        p.contentView = hosting
-
-        // Position: top-center of screen
-        let x = visible.midX - panelWidth / 2
-        let y = visible.maxY - panelHeight - 40
-        p.setFrameOrigin(NSPoint(x: x, y: y))
+        OverlayPanelShell.position(p, placement: .topCenter(margin: 40))
 
         p.alphaValue = 0
-        p.orderFrontRegardless()
-        p.makeKey()
-        NSApp.activate(ignoringOtherApps: true)
+        OverlayPanelShell.present(p, activate: true, makeKey: true, orderFrontRegardless: true)
 
         NSAnimationContext.runAnimationGroup { ctx in
             ctx.duration = 0.15
@@ -560,6 +507,7 @@ final class VoiceCommandState: ObservableObject {
 
 struct VoiceCommandView: View {
     @ObservedObject var state: VoiceCommandState
+    @ObservedObject private var activeSelection = WindowSelectionStore.shared
     let onDismiss: () -> Void
 
     private let docsURL = "https://lattices.dev/docs/voice"
@@ -884,6 +832,30 @@ struct VoiceCommandView: View {
             VStack(alignment: .leading, spacing: 14) {
                     // Zero-height spacer forces VStack to fill ScrollView width
                     Color.clear.frame(maxWidth: .infinity, maxHeight: 0)
+                    if activeSelection.isActive {
+                        commandSection("selection") {
+                            VStack(alignment: .leading, spacing: 6) {
+                                HStack(spacing: 6) {
+                                    Text("\(activeSelection.count) window\(activeSelection.count == 1 ? "" : "s")")
+                                        .font(Typo.geistMonoBold(11))
+                                        .foregroundColor(Palette.running)
+                                    if let source = activeSelection.sourceLabel {
+                                        Text(source)
+                                            .font(Typo.geistMono(10))
+                                            .foregroundColor(Palette.textMuted)
+                                    }
+                                }
+                                Text(activeSelection.summary(maxItems: 4))
+                                    .font(Typo.geistMono(11))
+                                    .foregroundColor(Palette.textDim)
+                                    .lineLimit(3)
+                                Text("Try: grid that in the bottom half")
+                                    .font(Typo.geistMono(10))
+                                    .foregroundColor(Palette.textMuted)
+                            }
+                        }
+                    }
+
                     // Partial transcript (while listening)
                     if state.phase == .listening, !state.partialText.isEmpty {
                         commandSection("hearing...") {