Notch: Toleranz für zitternde Hände, „Panel öffnen" fliegt raus

Warum meine Proben grün waren und deine Hand nicht: jedes einzelne
Abtastbild außerhalb der Auslösefläche hat das Aufziehen sofort
abgebrochen. Ein Zeiger, den eine Hand an den oberen Rand führt, steht
dort aber nicht still — er wandert um ein paar Punkte. Damit fing die
Entprellzeit von 220 ms dauernd von vorn an und kam nie ans Ziel.
`CGWarpMouseCursorPosition` setzt den Zeiger auf einen Punkt und hält ihn
absolut still; deshalb war jede automatisierte Probe 19 von 19 grün.

Kurzes Herausrutschen bricht jetzt nicht mehr ab: die Entprellzeit läuft
weiter, parallel läuft die Abbruchfrist von 300 ms. Kommt der Zeiger
zurück, wird die Frist gestoppt — die Entprellzeit setzt bewusst nicht neu
an, sonst dauerte es bei jedem Grenzübertritt wieder von vorn.

Das allein hätte einen neuen Fehler gebracht, und ein vorhandener Test hat
ihn gefunden: beim beiläufigen Streifen der Notch wäre die Entprellzeit
abgelaufen, während der Zeiger längst weg war — das Panel wäre für ein
Zehntel aufgeblitzt. Die Maschine merkt sich deshalb, wo der Zeiger steht,
und öffnet nur, wenn er da ist. Ist die Entprellzeit abgelaufen, während er
draußen war, geht es beim Zurückkommen ohne weiteres Warten auf.

Die Auslösefläche reicht außerdem 14 statt 4 Punkte unter die Notch. Vier
Punkte sind keine Fläche, die eine Hand trifft.

„Panel öffnen" ist aus dem Menü verschwunden. Ein Menüeintrag für etwas,
das beim Berühren der Notch von selbst passiert, beschreibt einen Umweg um
die eigentliche Bedienung herum. Als Notausgang bleibt es erreichbar, nur
ohne eigene Zeile: Linksklick auf das Symbol fährt das Panel aus,
Rechtsklick zeigt Einstellungen und Beenden.

Dazu Protokollierung jedes Zustandswechsels und jeder Unterdrückung. Ohne
diese Spur ist ein Panel, das sich „manchmal nicht öffnet", nicht zu
untersuchen.

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

Onyx/OnyxApp.swift

@@ -233,27 +233,45 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
 
     // MARK: - Menüleiste
 
-    /// Das feste Onyx-Element: Panel öffnen, Einstellungen, Beenden. Es ist auch
+    /// Das feste Onyx-Element.
-    /// das Sicherheitsnetz, falls die Notch einmal nicht reagiert.
+    ///
+    /// **Kein „Panel öffnen" im Menü.** Das Panel öffnet sich, wenn man die
+    /// Notch berührt — ein Menüeintrag dafür beschreibt einen Umweg um die
+    /// eigentliche Bedienung herum und wirft die Frage auf, wozu es die Notch
+    /// dann gibt. Als Notausgang bleibt es trotzdem erreichbar, nur ohne
+    /// eigene Zeile: **Linksklick auf das Symbol fährt das Panel aus,
+    /// Rechtsklick zeigt das Menü.**
     private func installOnyxStatusItem() {
         let item = NSStatusBar.system.statusItem(withLength: NSStatusItem.squareLength)
         item.autosaveName = "onyx.menubar.main"
         item.button?.image = Self.menuBarIcon()
-
+        item.button?.target = self
-        let menu = NSMenu()
+        item.button?.action = #selector(onyxItemClicked)
-        menu.addItem(withTitle: String(localized: "menu.openPanel"),
+        item.button?.sendAction(on: [.leftMouseUp, .rightMouseUp])
-                     action: #selector(togglePanel), keyEquivalent: "").target = self
-        menu.addItem(.separator())
-        menu.addItem(withTitle: String(localized: "menu.settings"),
-                     action: #selector(openSettings), keyEquivalent: ",").target = self
-        menu.addItem(.separator())
-        menu.addItem(withTitle: String(localized: "menu.quit"),
-                     action: #selector(quit), keyEquivalent: "q").target = self
-        item.menu = menu
 
         onyxItem = item
     }
 
+    /// Links: Panel. Rechts: Menü.
+    @objc private func onyxItemClicked() {
+        guard let item = onyxItem, let button = item.button else { return }
+        if NSApp.currentEvent?.type == .rightMouseUp {
+            let menu = NSMenu()
+            menu.addItem(withTitle: String(localized: "menu.settings"),
+                         action: #selector(openSettings), keyEquivalent: ",").target = self
+            menu.addItem(.separator())
+            menu.addItem(withTitle: String(localized: "menu.quit"),
+                         action: #selector(quit), keyEquivalent: "q").target = self
+            // Das Menü nur für diesen Klick anhängen und danach wieder lösen —
+            // bleibt es hängen, verschluckt es den Linksklick.
+            item.menu = menu
+            button.performClick(nil)
+            item.menu = nil
+        } else {
+            togglePanel()
+        }
+    }
+
     /// Das Glyph aus dem App-Icon, auf Menüleistengröße gebracht.
     ///
     /// Nicht das vollständige App-Icon: das bringt die abgerundete Kachel samt

Packages/OnyxKit/Sources/OnyxNotch/NotchCoordinator.swift

@@ -1,4 +1,7 @@
 import AppKit
+import OSLog
+
+private let log = Logger(subsystem: "com.scarriffleservices.onyx", category: "Notch")
 
 /// Hält für jeden in Frage kommenden Bildschirm einen Controller und versorgt
 /// alle mit der Zeigerposition.
@@ -84,6 +87,7 @@ public final class NotchCoordinator {
     private func rebuild() {
         let wanted = policy.screens(from: NSScreen.screens.map(\.onyxMetrics))
         let wantedIDs = Set(wanted.map(\.displayID))
+        log.notice("Bildschirme neu aufgebaut: \(wantedIDs.count, privacy: .public) von \(NSScreen.screens.count, privacy: .public) verwendet")
 
         for (id, controller) in controllers where !wantedIDs.contains(id) {
             controller.tearDown()
@@ -186,6 +190,7 @@ public final class NotchCoordinator {
         RunLoop.main.add(timer, forMode: .common)
         pointerPollTimer = timer
         pollInterval = interval
+        log.notice("Zeigerabfrage: \(Int(1 / interval), privacy: .public) Hz, \(self.controllers.count, privacy: .public) Bildschirm(e)")
     }
 
     /// Im Ruhezustand genügt ein Zehntel: dazu kommt ohnehin die Entprellzeit

Packages/OnyxKit/Sources/OnyxNotch/NotchGeometry.swift

@@ -74,7 +74,10 @@ public struct NotchGeometry: Equatable, Sendable {
     /// muss man die Notch pixelgenau treffen, und die unteren Bildpunkte der
     /// Notch selbst nimmt die Menüleiste bereits für sich in Anspruch.
     public static let triggerInsetX: CGFloat = 16
-    public static let triggerInsetY: CGFloat = 4
+    /// Nach unten deutlich großzügiger als nach oben: von oben kommt niemand,
+    /// dort ist der Bildschirmrand. Vier Punkte waren zu wenig — eine Hand
+    /// hält den Zeiger nicht auf vier Punkte genau.
+    public static let triggerInsetY: CGFloat = 14
 
     public init(kind: Kind, rect: CGRect, screenFrame: CGRect) {
         self.kind = kind

Packages/OnyxKit/Sources/OnyxNotch/NotchScreenController.swift

@@ -1,4 +1,7 @@
 import AppKit
+import OSLog
+
+private let log = Logger(subsystem: "com.scarriffleservices.onyx", category: "Notch")
 
 /// Führt für genau einen Bildschirm Geometrie, Zustandsmaschine und Fenster zusammen.
 ///
@@ -75,7 +78,11 @@ public final class NotchScreenController {
 
     public func click() { send(.click) }
     public func escape() { send(.escape) }
-    public func setSuppressed(_ suppressed: Bool) { send(.suppressed(suppressed)) }
+    public func setSuppressed(_ suppressed: Bool) {
+        guard suppressed != machine.isSuppressed else { return }
+        log.notice("Notch \(self.displayID, privacy: .public): Unterdrückung \(suppressed ? "an" : "aus", privacy: .public)")
+        send(.suppressed(suppressed))
+    }
 
     /// Nach einem Wechsel von Auflösung, Anordnung oder Skalierung.
     public func update(metrics: ScreenMetrics, virtualSize: CGSize) {
@@ -103,7 +110,16 @@ public final class NotchScreenController {
     /// Zustand dort bereits geändert, ein Vergleich käme also immer negativ zurück.
     private func send(_ input: NotchInput) {
         let wasVisible = machine.isVisible
+        let before = machine.phase
         apply(machine.handle(input))
+        // Jeden Zustandswechsel protokollieren — außer den beiden, die
+        // sekündlich hunderte Male kommen. Ohne diese Spur ist ein Panel, das
+        // sich „manchmal nicht öffnet", nicht zu untersuchen: hinterher weiß
+        // niemand mehr, ob der Zeiger erkannt wurde, ob die Maschine
+        // umgeschaltet hat oder ob die Unterdrückung dazwischenkam.
+        if machine.phase != before {
+            log.notice("Notch \(self.displayID, privacy: .public): \(String(describing: before), privacy: .public) → \(String(describing: self.machine.phase), privacy: .public) durch \(String(describing: input), privacy: .public)")
+        }
         if machine.isVisible != wasVisible { onVisibilityChanged?(machine.isVisible) }
     }
 

Packages/OnyxKit/Sources/OnyxNotch/NotchStateMachine.swift

@@ -59,6 +59,16 @@ public struct NotchStateMachine: Equatable, Sendable {
     public private(set) var phase: NotchPhase = .idle
     public private(set) var isSuppressed: Bool = false
 
+    /// Wo der Zeiger zuletzt war. Die Maschine braucht das, um beim Ablauf der
+    /// Entprellzeit zu entscheiden — ohne diese Angabe würde ein beiläufiges
+    /// Streifen der Notch das Panel kurz aufblitzen lassen: betreten,
+    /// verlassen, Entprellzeit läuft trotzdem ab, Panel auf, Frist abgelaufen,
+    /// Panel zu.
+    private var isPointerInside = false
+    /// Ob die Entprellzeit schon abgelaufen ist, während der Zeiger draußen war.
+    /// Kommt er zurück, wird ohne weiteres Warten geöffnet.
+    private var debounceElapsed = false
+
     public init() {}
 
     /// Sichtbar, egal aus welchem Grund.
@@ -88,19 +98,54 @@ public struct NotchStateMachine: Equatable, Sendable {
 
         guard !isSuppressed else { return [] }
 
+        switch input {
+        case .pointerEntered: isPointerInside = true
+        case .pointerExited: isPointerInside = false
+        default: break
+        }
+
         switch (phase, input) {
 
         // Öffnen
         case (.idle, .pointerEntered):
             phase = .arming
+            debounceElapsed = false
             return [.startArmTimer(Self.armDelay)]
 
         case (.arming, .armTimerFired):
+            // Nur öffnen, wenn der Zeiger auch da ist. Sonst weitermerken,
+            // dass die Entprellzeit vorbei ist — kommt er zurück, geht es
+            // sofort auf; bleibt er weg, beendet die Abbruchfrist die Sache.
+            guard isPointerInside else {
+                debounceElapsed = true
+                return []
+            }
             phase = .open
             return [.show]
 
+        // Kurz herausrutschen bricht nicht ab.
+        //
+        // Ein Zeiger, den eine Hand an den oberen Rand führt, steht dort nicht
+        // still. Jedes Abtastbild außerhalb sofort als Abbruch zu werten hieß:
+        // bei zitternder Hand fing die Entprellzeit dauernd von vorn an und kam
+        // nie ans Ziel — das Panel öffnete „manchmal einfach nicht".
+        //
+        // Der Aufziehzeitgeber läuft weiter; parallel läuft die Frist, nach der
+        // wirklich abgebrochen wird.
         case (.arming, .pointerExited):
+            return [.startCloseTimer(Self.closeDelay)]
+
+        case (.arming, .pointerEntered):
+            // Zurück in der Zone: nur die Abbruchfrist stoppen. Die Entprellzeit
+            // **nicht** neu ansetzen, sonst dauert es bei jedem Grenzübertritt
+            // wieder von vorn.
+            guard debounceElapsed else { return [.cancelCloseTimer] }
+            phase = .open
+            return [.cancelCloseTimer, .show]
+
+        case (.arming, .closeTimerFired):
             phase = .idle
+            debounceElapsed = false
             return [.cancelArmTimer]
 
         // Schließen

Packages/OnyxKit/Tests/OnyxNotchTests/NotchStateMachineTests.swift

@@ -32,9 +32,13 @@ struct NotchStateMachineTests {
 
     @Test("Zeiger verlässt die Notch vor Ablauf → kein Öffnen")
     func leavingDuringArmingCancels() {
+        // Die Absicht ist unverändert: wer die Notch nur streift, bekommt kein
+        // Panel. Der Weg dorthin führt seit der Toleranz für zitternde Hände
+        // über die Abbruchfrist statt über einen sofortigen Abbruch.
         var machine = NotchStateMachine()
         _ = machine.handle(.pointerEntered)
-        let effects = machine.handle(.pointerExited)
+        _ = machine.handle(.pointerExited)
+        let effects = machine.handle(.closeTimerFired)
 
         #expect(machine.phase == .idle)
         #expect(effects == [.cancelArmTimer])
@@ -191,12 +195,14 @@ struct NotchStateMachineTests {
 
     @Test("Zweimal betreten ohne zwischenzeitliches Verlassen startet keinen zweiten Timer")
     func repeatedEnterIsIdempotent() {
+        // Worauf es ankommt: die Entprellzeit setzt nicht neu an. Dass dabei
+        // eine ohnehin nicht laufende Abbruchfrist gestoppt wird, ist folgenlos.
         var machine = NotchStateMachine()
         _ = machine.handle(.pointerEntered)
         let effects = machine.handle(.pointerEntered)
 
         #expect(machine.phase == .arming)
-        #expect(effects.isEmpty)
+        #expect(!effects.contains(.startArmTimer(NotchStateMachine.armDelay)))
     }
 
     @Test("Verlassen im Ruhezustand tut nichts")
@@ -208,15 +214,32 @@ struct NotchStateMachineTests {
         #expect(effects.isEmpty)
     }
 
-    @Test("Verspäteter Timer nach dem Schließen öffnet nicht mehr")
+    @Test("Entprellzeit läuft ab, während der Zeiger draußen ist → kein Öffnen")
-    func staleArmTimerDoesNotOpen() {
+    func armTimerWhileOutsideDoesNotOpen() {
+        // Der Fall, der ohne Zeigerkenntnis das Panel aufblitzen ließe: die
+        // Notch beiläufig streifen. Entprellzeit läuft ab, obwohl der Zeiger
+        // längst weg ist — geöffnet wird trotzdem nicht.
         var machine = NotchStateMachine()
         _ = machine.handle(.pointerEntered)
-        _ = machine.handle(.pointerExited)      // Timer wurde abbestellt …
+        _ = machine.handle(.pointerExited)
-        let effects = machine.handle(.armTimerFired)  // … feuert aber trotzdem noch
+        let effects = machine.handle(.armTimerFired)
 
-        #expect(machine.phase == .idle)
+        #expect(!effects.contains(.show))
-        #expect(effects.isEmpty)
+        #expect(machine.phase != .open)
+    }
+
+    @Test("Kommt der Zeiger nach abgelaufener Entprellzeit zurück, geht es sofort auf")
+    func returnAfterDebounceOpensAtOnce() {
+        // Sonst müsste eine zitternde Hand die volle Entprellzeit noch einmal
+        // durchstehen, obwohl sie längst gewartet hat.
+        var machine = NotchStateMachine()
+        _ = machine.handle(.pointerEntered)
+        _ = machine.handle(.pointerExited)
+        _ = machine.handle(.armTimerFired)
+        let effects = machine.handle(.pointerEntered)
+
+        #expect(machine.phase == .open)
+        #expect(effects.contains(.show))
     }
 
     @Test("Verspäteter Schließtimer schließt kein wieder geöffnetes Panel")
@@ -248,3 +271,68 @@ struct NotchStateMachineTests {
         #expect(NotchStateMachine.closeDelay == 0.30)
     }
 }
+
+// Nachgetragen, nachdem sich das Panel „manchmal nicht öffnete". Ein Zeiger,
+// der von Hand an den oberen Rand geführt wird, steht dort nicht still — er
+// wandert um ein paar Punkte. Jedes Abtastbild außerhalb hat das Aufziehen
+// sofort abgebrochen, und beim nächsten fing es von vorn an. Bei 220 ms
+// Entprellzeit kam es so nie ans Ziel.
+//
+// Automatisierte Proben haben das nie gezeigt: `CGWarpMouseCursorPosition`
+// setzt den Zeiger auf einen Punkt und hält ihn absolut still.
+
+@Suite("Toleranz beim Aufziehen")
+struct NotchArmingToleranceTests {
+
+    @Test("Kurz herausrutschen bricht das Aufziehen nicht ab")
+    func briefExitKeepsArming() {
+        var machine = NotchStateMachine()
+        machine.handle(.pointerEntered)
+        #expect(machine.phase == .arming)
+
+        machine.handle(.pointerExited)
+        // Immer noch am Aufziehen — es läuft nur eine Frist.
+        #expect(machine.phase == .arming)
+    }
+
+    @Test("Kommt der Zeiger zurück, läuft es weiter")
+    func returningResumes() {
+        var machine = NotchStateMachine()
+        machine.handle(.pointerEntered)
+        machine.handle(.pointerExited)
+        machine.handle(.pointerEntered)
+        machine.handle(.armTimerFired)
+        #expect(machine.phase == .open)
+    }
+
+    @Test("Bleibt er draußen, wird abgebrochen")
+    func lastingExitCancels() {
+        var machine = NotchStateMachine()
+        machine.handle(.pointerEntered)
+        machine.handle(.pointerExited)
+        machine.handle(.closeTimerFired)
+        #expect(machine.phase == .idle)
+    }
+
+    @Test("Beim Abbrechen wird auch der Aufziehzeitgeber gestoppt")
+    func cancelStopsArmTimer() {
+        // Sonst fährt das Panel aus, nachdem der Zeiger längst weg ist.
+        var machine = NotchStateMachine()
+        machine.handle(.pointerEntered)
+        machine.handle(.pointerExited)
+        let effects = machine.handle(.closeTimerFired)
+        #expect(effects.contains(.cancelArmTimer))
+    }
+
+    @Test("Das Aufziehen setzt beim Herausrutschen nicht neu an")
+    func exitDoesNotRestartArmTimer() {
+        // Sonst dauert es bei zitternder Hand endlos, weil die Entprellzeit
+        // bei jedem Grenzübertritt von vorn beginnt.
+        var machine = NotchStateMachine()
+        machine.handle(.pointerEntered)
+        machine.handle(.pointerExited)
+        let effects = machine.handle(.pointerEntered)
+        #expect(!effects.contains(.startArmTimer(NotchStateMachine.armDelay)))
+        #expect(effects.contains(.cancelCloseTimer))
+    }
+}