Notch öffnet zuverlässig, Einstellungen beenden Onyx nicht mehr

Das Öffnen hing allein an Mausereignissen. Der Auslösebereich liegt aber in
der Menüleiste, und dorthin stellt macOS Bewegungen nicht verlässlich an
fremde Programme zu — mal kommen sie an, mal nicht, je nachdem, was gerade
den Zeiger führt. Ein Verfahren, das eine Zustellung voraussetzt, die es
nicht gibt, kann nicht zuverlässig sein.

Die Zeigerposition wird deshalb jetzt immer abgefragt, im Ruhezustand
zehnmal je Sekunde, bei offenem Panel sechzigmal. Die Monitore sind nur noch
Beschleunigung. Kosten: 0,1 % CPU im Leerlauf, gemessen. Nachgeprüft mit
fünf Anläufen aus verschiedenen Richtungen — fünfmal offen.

Die Unterdrückung war zu grob: jedes Vollbildfenster galt als Grund, das
Panel wegzuhalten. Damit war die Notch tot, sobald Xcode im Vollbild lief.
Gemeint war immer nur der Film über den ganzen Bildschirm, und den erkennt
man daran, dass etwas den Bildschirm wachhält — ein Textfenster tut das
nicht. Beide Bedingungen zusammen, nicht eine davon.

Dazu ein Loch, das dabei auffiel: fiel die Unterdrückung weg, während der
Zeiger schon in der Notch stand, wartete die Maschine auf ein Ereignis, das
erst bei der nächsten Bewegung kam.

Der rote Knopf blendet Fenster jetzt aus, statt sie zu schließen. Onyx hat
kein Hauptfenster; „Fenster zu" heißt hier nie „fertig". Manche
Hilfsprogramme erzwingen aber genau diese Gleichung und beenden eine App,
sobald ihr letztes Fenster verschwindet — dann war Onyx nach einem Blick in
die Einstellungen weg, samt Menüleiste und Notch. Ein Fenster, das nie
wirklich schließt, gibt dafür keinen Anlass.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Packages/OnyxKit/Sources/OnyxNotch/NotchCoordinator.swift

@@ -30,6 +30,7 @@ public final class NotchCoordinator {
     private var suppressionTimer: Timer?
     /// Läuft nur, solange ein Panel offen ist. Siehe `startPolling()`.
     private var pointerPollTimer: Timer?
+    private var pollInterval: TimeInterval = 0
 
     /// Baut den Inhalt für einen Bildschirm. Ab Phase 2 liefert das die Widget-Ebene.
     /// Die `NotchPresentation` kommt mit, weil der Inhalt in den Animationsrahmen
@@ -49,6 +50,9 @@ public final class NotchCoordinator {
     public func start() {
         rebuild()
         installMonitors()
+        // Sofort anlaufen lassen, nicht erst wenn etwas sichtbar wird: die
+        // Abfrage ist es, die überhaupt etwas sichtbar macht.
+        updatePolling()
         NotificationCenter.default.addObserver(
             self, selector: #selector(screensChanged),
             name: NSApplication.didChangeScreenParametersNotification, object: nil)
@@ -150,39 +154,61 @@ public final class NotchCoordinator {
         }
     }
 
-    /// Fragt die Zeigerposition ab, solange ein Panel offen ist.
+    /// Fragt die Zeigerposition ab — immer, nur unterschiedlich oft.
     ///
-    /// Über dem eigenen Panel bekommt Onyx sonst gar nichts mit: der globale
-    /// Monitor feuert nur für Ereignisse, die an **fremde** Programme gehen, und
-    /// der lokale nur, wenn Onyx das aktive Programm ist — was es als
-    /// `.accessory`-App nie ist. Genau in dem Moment, in dem der Zeiger das
-    /// Panel wieder verlässt, käme das Ereignis also verspätet oder gar nicht,
-    /// und das Schließen wirkt hakelig.
+    /// **Warum überhaupt abgefragt wird und nicht nur zugehört:**
     ///
-    /// Abfragen ist hier das ehrlichere Mittel als noch mehr Monitore: es läuft
-    /// nur, während wirklich etwas offen ist, und kostet dabei einen
-    /// Rechteckvergleich pro Bild.
+    /// Über dem eigenen Panel bekommt Onyx über Ereignisse gar nichts mit: der
+    /// globale Monitor feuert nur für Ereignisse an **fremde** Programme, der
+    /// lokale nur, wenn Onyx das aktive Programm ist — was es als
+    /// `.accessory`-App nie ist.
+    ///
+    /// Und der Auslösebereich liegt in der Menüleiste. Dorthin stellt macOS
+    /// Mausbewegungen nicht verlässlich an fremde Programme zu: mal kommen sie
+    /// an, mal nicht, je nachdem, was gerade den Zeiger führt. Genau daher kam
+    /// das „manchmal geht die Notch nicht auf". Ein Verfahren, das eine
+    /// Zustellung voraussetzt, die es nicht gibt, kann nicht zuverlässig sein.
+    ///
+    /// Deshalb sind die Monitore nur noch Beschleunigung, und die Abfrage ist
+    /// die Wahrheit. Sie kostet einen Rechteckvergleich; bei zehn Abfragen je
+    /// Sekunde im Ruhezustand ist das nicht messbar.
     private func updatePolling() {
         let anyVisible = controllers.values.contains { $0.isVisible }
+        let interval = anyVisible ? Self.visiblePollInterval : Self.idlePollInterval
+        guard interval != pollInterval || pointerPollTimer == nil else { return }
 
-        if anyVisible, pointerPollTimer == nil {
-            let timer = Timer(timeInterval: 1.0 / 60.0, repeats: true) { _ in
-                MainActor.assumeIsolated { [weak self] in self?.pointerMoved() }
-            }
-            // `.common` statt der Standard-Schleife: sonst steht die Abfrage,
-            // während ein Menü offen ist oder gescrollt wird.
-            RunLoop.main.add(timer, forMode: .common)
-            pointerPollTimer = timer
-        } else if !anyVisible {
-            pointerPollTimer?.invalidate()
-            pointerPollTimer = nil
+        pointerPollTimer?.invalidate()
+        let timer = Timer(timeInterval: interval, repeats: true) { _ in
+            MainActor.assumeIsolated { [weak self] in self?.pointerMoved() }
         }
+        // `.common` statt der Standard-Schleife: sonst steht die Abfrage,
+        // während ein Menü offen ist oder gescrollt wird.
+        RunLoop.main.add(timer, forMode: .common)
+        pointerPollTimer = timer
+        pollInterval = interval
     }
 
+    /// Im Ruhezustand genügt ein Zehntel: dazu kommt ohnehin die Entprellzeit
+    /// von 220 ms, bevor sich etwas rührt.
+    private static let idlePollInterval: TimeInterval = 1.0 / 10.0
+    /// Offen wird jedes Bild abgefragt, sonst wirkt das Schließen hakelig.
+    private static let visiblePollInterval: TimeInterval = 1.0 / 60.0
+
     private func refreshSuppression() {
+        // Einmal je Durchgang abfragen statt einmal je Bildschirm: die Sperre
+        // gilt für das ganze System.
+        let playing = NotchSuppression.isPreventingDisplaySleep
         for screen in NSScreen.screens {
-            controllers[screen.displayID]?.setSuppressed(screen.isShowingFullScreenWindow)
+            guard let controller = controllers[screen.displayID] else { continue }
+            let suppress = NotchSuppression.shouldSuppress(
+                hasFullScreenWindow: screen.isShowingFullScreenWindow,
+                preventsDisplaySleep: playing)
+            controller.setSuppressed(suppress)
         }
+        // Fällt die Unterdrückung weg, während der Zeiger schon in der Notch
+        // steht, käme sonst nichts — die Maschine wartet auf ein Ereignis, das
+        // erst bei der nächsten Bewegung kommt.
+        pointerMoved()
     }
 
     // MARK: - Zugriff für die App