Handle hidden-titlebar Bonsplit chrome overlap

Sources/Bonsplit/Internal/Views/BonsplitHostingView.swift

@@ -0,0 +1,53 @@
+import AppKit
+import SwiftUI
+
+final class BonsplitHostingView<Content: View>: NSHostingView<Content> {
+    private let zeroSafeAreaLayoutGuide = NSLayoutGuide()
+
+    override var safeAreaInsets: NSEdgeInsets { NSEdgeInsetsZero }
+    override var safeAreaRect: NSRect { bounds }
+    override var safeAreaLayoutGuide: NSLayoutGuide { zeroSafeAreaLayoutGuide }
+    override var mouseDownCanMoveWindow: Bool { false }
+    override var intrinsicContentSize: NSSize {
+        NSSize(width: NSView.noIntrinsicMetric, height: NSView.noIntrinsicMetric)
+    }
+
+    required init(rootView: Content) {
+        super.init(rootView: rootView)
+        addLayoutGuide(zeroSafeAreaLayoutGuide)
+        NSLayoutConstraint.activate([
+            zeroSafeAreaLayoutGuide.leadingAnchor.constraint(equalTo: leadingAnchor),
+            zeroSafeAreaLayoutGuide.trailingAnchor.constraint(equalTo: trailingAnchor),
+            zeroSafeAreaLayoutGuide.topAnchor.constraint(equalTo: topAnchor),
+            zeroSafeAreaLayoutGuide.bottomAnchor.constraint(equalTo: bottomAnchor),
+        ])
+    }
+
+    @available(*, unavailable)
+    required init?(coder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+}
+
+final class BonsplitHostingController<Content: View>: NSViewController {
+    private let hostingView: BonsplitHostingView<Content>
+
+    var rootView: Content {
+        get { hostingView.rootView }
+        set { hostingView.rootView = newValue }
+    }
+
+    init(rootView: Content) {
+        hostingView = BonsplitHostingView(rootView: rootView)
+        super.init(nibName: nil, bundle: nil)
+    }
+
+    @available(*, unavailable)
+    required init?(coder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+
+    override func loadView() {
+        view = hostingView
+    }
+}

Sources/Bonsplit/Internal/Views/PaneContainerView.swift

@@ -2,6 +2,142 @@ import SwiftUI
 import UniformTypeIdentifiers
 import AppKit
 
+private final class TabBarInteractionContainerView: NSView {
+    private var eventMonitor: Any?
+    private weak var monitoredWindow: NSWindow?
+    private var previousWindowMovableState: Bool?
+
+    override var mouseDownCanMoveWindow: Bool { false }
+    override func isAccessibilityElement() -> Bool { true }
+    override func accessibilityRole() -> NSAccessibility.Role? { .group }
+
+    deinit {
+        removeEventMonitor()
+        restoreWindowDraggingIfNeeded()
+    }
+
+    override func viewDidMoveToWindow() {
+        super.viewDidMoveToWindow()
+
+        if window !== monitoredWindow {
+            removeEventMonitor()
+            monitoredWindow = window
+            installEventMonitor()
+        }
+
+        if window == nil {
+            restoreWindowDraggingIfNeeded()
+        }
+    }
+
+    private func installEventMonitor() {
+        guard eventMonitor == nil else { return }
+        eventMonitor = NSEvent.addLocalMonitorForEvents(matching: [.leftMouseDown, .leftMouseDragged, .leftMouseUp]) { [weak self] event in
+            self?.handleLocalMouseEvent(event) ?? event
+        }
+    }
+
+    private func removeEventMonitor() {
+        guard let eventMonitor else { return }
+        NSEvent.removeMonitor(eventMonitor)
+        self.eventMonitor = nil
+    }
+
+    private func handleLocalMouseEvent(_ event: NSEvent) -> NSEvent? {
+        guard let window = monitoredWindow else {
+            return event
+        }
+
+        if event.window !== window {
+            if event.type == .leftMouseUp {
+                restoreWindowDraggingIfNeeded()
+            }
+            return event
+        }
+
+        let point = convert(event.locationInWindow, from: nil)
+        switch event.type {
+        case .leftMouseDown:
+            if bounds.contains(point), !hitTestRoutesToWindowDragRegion(at: point) {
+                suppressWindowDraggingIfNeeded(window: window)
+            }
+        case .leftMouseDragged:
+            if previousWindowMovableState == nil, bounds.contains(point), !hitTestRoutesToWindowDragRegion(at: point) {
+                suppressWindowDraggingIfNeeded(window: window)
+            }
+        case .leftMouseUp:
+            restoreWindowDraggingIfNeeded()
+        default:
+            break
+        }
+
+        return event
+    }
+
+    private func hitTestRoutesToWindowDragRegion(at point: NSPoint) -> Bool {
+        guard let hitView = super.hitTest(point) else { return false }
+        var current: NSView? = hitView
+        while let view = current {
+            if view is TabBarWindowDragRegionView {
+                return true
+            }
+            current = view.superview
+        }
+        return false
+    }
+
+    private func suppressWindowDraggingIfNeeded(window: NSWindow) {
+        guard previousWindowMovableState == nil else { return }
+        previousWindowMovableState = window.isMovable
+        if window.isMovable {
+            window.isMovable = false
+        }
+    }
+
+    private func restoreWindowDraggingIfNeeded() {
+        guard let previousWindowMovableState else { return }
+        monitoredWindow?.isMovable = previousWindowMovableState
+        self.previousWindowMovableState = nil
+    }
+}
+
+private struct TabBarHostingWrapper<Content: View>: NSViewRepresentable {
+    let content: Content
+
+    func makeCoordinator() -> Coordinator {
+        Coordinator()
+    }
+
+    func makeNSView(context: Context) -> NSView {
+        let containerView = TabBarInteractionContainerView()
+        containerView.setAccessibilityElement(true)
+        containerView.setAccessibilityIdentifier("paneTabBar")
+
+        let hostingView = BonsplitHostingView(rootView: content)
+        hostingView.translatesAutoresizingMaskIntoConstraints = false
+        hostingView.setAccessibilityElement(false)
+        containerView.addSubview(hostingView)
+
+        NSLayoutConstraint.activate([
+            hostingView.topAnchor.constraint(equalTo: containerView.topAnchor),
+            hostingView.leadingAnchor.constraint(equalTo: containerView.leadingAnchor),
+            hostingView.trailingAnchor.constraint(equalTo: containerView.trailingAnchor),
+            hostingView.bottomAnchor.constraint(equalTo: containerView.bottomAnchor),
+        ])
+
+        context.coordinator.hostingView = hostingView
+        return containerView
+    }
+
+    func updateNSView(_ nsView: NSView, context: Context) {
+        context.coordinator.hostingView?.rootView = content
+    }
+
+    final class Coordinator {
+        var hostingView: BonsplitHostingView<Content>?
+    }
+}
+
 /// Drop zone positions for creating splits
 public enum DropZone: Equatable {
     case center
@@ -174,10 +310,12 @@ struct PaneContainerView<Content: View, EmptyContent: View>: View {
     var body: some View {
         VStack(spacing: 0) {
             // Tab bar
-            TabBarView(
-                pane: pane,
-                isFocused: isFocused,
-                showSplitButtons: showSplitButtons
+            TabBarHostingWrapper(
+                content: TabBarView(
+                    pane: pane,
+                    isFocused: isFocused,
+                    showSplitButtons: showSplitButtons
+                )
             )
 
             // Content area with drop zones

Sources/Bonsplit/Internal/Views/SplitContainerView.swift

@@ -355,14 +355,8 @@ struct SplitContainerView<Content: View, EmptyContent: View>: NSViewRepresentabl
 
     // MARK: - Helpers
 
-    private func makeHostingController(for node: SplitNode) -> NSHostingController<AnyView> {
-        let hostingController = NSHostingController(rootView: AnyView(makeView(for: node)))
-        if #available(macOS 13.0, *) {
-            // NSSplitView owns pane geometry. Keep NSHostingController from publishing
-            // intrinsic-size constraints that force a minimum pane width.
-            hostingController.sizingOptions = []
-        }
-
+    private func makeHostingController(for node: SplitNode) -> BonsplitHostingController<AnyView> {
+        let hostingController = BonsplitHostingController(rootView: AnyView(makeView(for: node)))
         let hostedView = hostingController.view
         // NSSplitView lays out arranged subviews by setting frames. Leaving Auto Layout
         // enabled on these NSHostingViews can allow them to compress to 0 during
@@ -378,7 +372,7 @@ struct SplitContainerView<Content: View, EmptyContent: View>: NSViewRepresentabl
         return hostingController
     }
 
-    private func installHostingController(_ hostingController: NSHostingController<AnyView>, into container: NSView) {
+    private func installHostingController(_ hostingController: BonsplitHostingController<AnyView>, into container: NSView) {
         let hostedView = hostingController.view
         hostedView.frame = container.bounds
         hostedView.autoresizingMask = [.width, .height]
@@ -391,7 +385,7 @@ struct SplitContainerView<Content: View, EmptyContent: View>: NSViewRepresentabl
         in container: NSView,
         node: SplitNode,
         nodeTypeChanged: Bool,
-        controller: inout NSHostingController<AnyView>?
+        controller: inout BonsplitHostingController<AnyView>?
     ) {
         // Historically we recreated the NSHostingController when the child node type changed
         // (pane <-> split) to force a full detach/reattach of native AppKit subviews.
@@ -468,8 +462,8 @@ struct SplitContainerView<Content: View, EmptyContent: View>: NSViewRepresentabl
         var firstNodeType: SplitNode.NodeType
         var secondNodeType: SplitNode.NodeType
         /// Retain hosting controllers so SwiftUI content stays alive
-        var firstHostingController: NSHostingController<AnyView>?
-        var secondHostingController: NSHostingController<AnyView>?
+        var firstHostingController: BonsplitHostingController<AnyView>?
+        var secondHostingController: BonsplitHostingController<AnyView>?
 
         init(
             splitState: SplitState,

Sources/Bonsplit/Internal/Views/SplitNodeView.swift

@@ -45,7 +45,9 @@ struct SplitNodeView<Content: View, EmptyContent: View>: View {
 }
 
 /// Container NSView for a pane inside SinglePaneWrapper.
-class PaneDragContainerView: NSView {}
+class PaneDragContainerView: NSView {
+    override var mouseDownCanMoveWindow: Bool { false }
+}
 
 /// Wrapper that uses NSHostingController for proper AppKit layout constraints
 struct SinglePaneWrapper<Content: View, EmptyContent: View>: NSViewRepresentable {
@@ -66,7 +68,7 @@ struct SinglePaneWrapper<Content: View, EmptyContent: View>: NSViewRepresentable
             showSplitButtons: showSplitButtons,
             contentViewLifecycle: contentViewLifecycle
         )
-        let hostingController = NSHostingController(rootView: paneView)
+        let hostingController = BonsplitHostingController(rootView: paneView)
         hostingController.view.translatesAutoresizingMaskIntoConstraints = false
 
         let containerView = PaneDragContainerView()
@@ -110,6 +112,6 @@ struct SinglePaneWrapper<Content: View, EmptyContent: View>: NSViewRepresentable
     }
 
     class Coordinator {
-        var hostingController: NSHostingController<PaneContainerView<Content, EmptyContent>>?
+        var hostingController: BonsplitHostingController<PaneContainerView<Content, EmptyContent>>?
     }
 }