Panel wächst aus der Notch, statt einzublenden

Die Fläche wird nicht eingeblendet — sie beginnt exakt in der Notch-Silhouette
und wächst von dort nach unten und zur Seite, deckungsgleich mit der schwarzen
Hardware darüber. Eingeblendetes Panel wirkt wie Glas; Onyx soll sich wie ein
fester Körper anfühlen, der herausfährt.

Der Inhalt hat eine eigene Kurve: beim Öffnen um 90 ms verzögert, damit die
Fläche vorweg läuft und kein Text sich mitdehnt; beim Schließen sofort weg,
damit beim Einfahren nichts gestaucht wird. Die Eckenrundung wandert mit
(10 → 26), sonst sieht die kleine Form aufgeblasen aus.

Drei Fallstricke, die im Code stehen:

Der Fensterschatten folgt dem Fensterrahmen, nicht der gezeichneten Form. Das
Fenster hat immer volle Panelgröße, damit die Animation Platz hat — der
Systemschatten läge also die ganze Zeit um eine unsichtbare Fläche. Deshalb
hasShadow = false und Schatten aus SwiftUI.

Ausgefahren wird erst im nächsten Runloop-Durchlauf. Im selben Durchlauf wie
orderFrontRegardless sieht SwiftUI keinen Zustandswechsel, sondern nur den
Endzustand, und das Panel wäre schlagartig da.

NotchHostingView nimmt Klicks nur dort an, wo etwas zu sehen ist. Sonst
verschluckt das volle Fenster während des Aus- und Einfahrens Klicks in seiner
leeren Fläche.

Packages/OnyxKit/Sources/OnyxNotch/NotchScreenController.swift

@@ -3,28 +3,42 @@ import AppKit
 /// Führt für genau einen Bildschirm Geometrie, Zustandsmaschine und Fenster zusammen.
 ///
 /// Die Entscheidungen trifft `NotchStateMachine`; diese Klasse übersetzt sie nur
-/// in Timer und Fensteraufrufe. Deshalb steht hier auch kein `if phase == …`.
+/// in Timer, Fensteraufrufe und Animationszustände. Deshalb steht hier auch kein
+/// `if phase == …`.
 @MainActor
 public final class NotchScreenController {
 
     public private(set) var geometry: NotchGeometry
     public let displayID: CGDirectDisplayID
+    public let presentation: NotchPresentation
 
     private var machine = NotchStateMachine()
     private let panel: NotchPanel
     private var armTimer: DispatchWorkItem?
     private var closeTimer: DispatchWorkItem?
+    /// Entfernt das Fenster erst, wenn das Einfahren zu Ende ist.
+    private var teardownTimer: DispatchWorkItem?
 
     /// Größe des ausgefahrenen Panels. Ab Phase 2 liefert das die Layout-Engine.
-    public var expandedSize = CGSize(width: 640, height: 320) {
-        didSet { if machine.isVisible { layoutPanel() } }
+    public var expandedSize: CGSize {
+        didSet {
+            guard expandedSize != oldValue else { return }
+            presentation.expandedSize = expandedSize
+            layoutPanel()
+        }
     }
 
-    public init(metrics: ScreenMetrics, virtualSize: CGSize, content: NSView) {
+    public init(metrics: ScreenMetrics,
+                virtualSize: CGSize,
+                expandedSize: CGSize = CGSize(width: 640, height: 320),
+                makeContent: (NotchPresentation) -> NSView) {
         self.displayID = metrics.displayID
         self.geometry = NotchGeometry.resolve(metrics, virtualSize: virtualSize)
+        self.expandedSize = expandedSize
+        self.presentation = NotchPresentation(collapsedSize: geometry.rect.size,
+                                              expandedSize: expandedSize)
         self.panel = NotchPanel(contentRect: .zero)
-        panel.contentView = content
+        panel.contentView = makeContent(presentation)
         layoutPanel()
     }
 
@@ -35,8 +49,12 @@ public final class NotchScreenController {
 
     /// Zeigerposition in globalen Bildschirmkoordinaten.
     public func pointerMoved(to point: CGPoint) {
+        // Nur die tatsächlich sichtbare Fläche zählt. Das Fenster ist immer so
+        // groß wie das ausgefahrene Panel, damit die Animation Platz hat —
+        // würde man `panel.frame` nehmen, hielte ein Zeiger in der noch leeren
+        // Fläche das Panel offen.
         let inside = geometry.triggerRect.contains(point)
-            || (machine.isVisible && panel.frame.contains(point))
+            || (presentation.isExpanded && panel.frame.contains(point))
         apply(machine.handle(inside ? .pointerEntered : .pointerExited))
     }
 
@@ -47,12 +65,14 @@ public final class NotchScreenController {
     /// Nach einem Wechsel von Auflösung, Anordnung oder Skalierung.
     public func update(metrics: ScreenMetrics, virtualSize: CGSize) {
         geometry = NotchGeometry.resolve(metrics, virtualSize: virtualSize)
+        presentation.collapsedSize = geometry.rect.size
         layoutPanel()
     }
 
     public func tearDown() {
         armTimer?.cancel()
         closeTimer?.cancel()
+        teardownTimer?.cancel()
         panel.orderOut(nil)
     }
 
@@ -84,15 +104,41 @@ public final class NotchScreenController {
                 closeTimer = nil
 
             case .show:
-                layoutPanel()
-                panel.orderFrontRegardless()
+                show()
 
             case .hide:
-                panel.orderOut(nil)
+                hide()
             }
         }
     }
 
+    private func show() {
+        // Ein noch laufendes Einfahren abbrechen: wer sofort zurückkehrt, soll
+        // das Panel wieder aufgehen sehen und nicht dabei zusehen, wie es
+        // mittendrin verschwindet.
+        teardownTimer?.cancel()
+        teardownTimer = nil
+
+        layoutPanel()
+        panel.orderFrontRegardless()
+
+        // Erst im nächsten Durchlauf ausfahren. Im selben Durchlauf wie
+        // `orderFrontRegardless` sieht SwiftUI keinen Zustandswechsel, sondern
+        // nur den Endzustand — das Panel wäre schlagartig da.
+        DispatchQueue.main.async { [weak self] in
+            self?.presentation.isExpanded = true
+        }
+    }
+
+    private func hide() {
+        presentation.isExpanded = false
+        teardownTimer?.cancel()
+        teardownTimer = schedule(after: NotchPresentation.collapseDuration) { [weak self] in
+            guard let self, !presentation.isExpanded else { return }
+            panel.orderOut(nil)
+        }
+    }
+
     private func schedule(after delay: TimeInterval, _ body: @escaping @MainActor () -> Void)
     -> DispatchWorkItem {
         let item = DispatchWorkItem { MainActor.assumeIsolated { body() } }
@@ -100,7 +146,10 @@ public final class NotchScreenController {
         return item
     }
 
+    /// Das Fenster hat immer die Größe des ausgefahrenen Panels — die Animation
+    /// findet im Inhalt statt, nicht am Fenster. Fensterrahmen zu animieren
+    /// überlässt die Interpolation dem Fensterserver und ruckelt sichtbar.
     private func layoutPanel() {
-        panel.setFrame(geometry.panelRect(for: expandedSize), display: machine.isVisible)
+        panel.setFrame(geometry.panelRect(for: expandedSize), display: presentation.isExpanded)
     }
 }