Phase 1: Notch-Shell, Design-System, Menüleisten-Infrastruktur
Zustandsmaschine und Geometrie sind testgetrieben entstanden und tragen 40 Tests — sie sind frei von AppKit, damit jeder Übergang ohne Fenster und ohne Warten prüfbar ist. Zeit kommt nur als Ereignis herein. Zwei Entscheidungen, die im Code begründet sind: Der Zeiger wird über einen globalen Ereignismonitor verfolgt, nicht über ein unsichtbares Fenster auf der Notch. Ein solches Fenster müsste Mausereignisse annehmen, um sie zu bemerken, und würde damit Menüleiste und Fensterknöpfe darunter unbenutzbar machen. "Nur internes Display" fällt auf ein externes zurück, wenn kein eingebautes da ist. Am Dock mit geschlossenem Deckel hieße die Einstellung wörtlich genommen, dass Onyx unerreichbar wird. Design: NSVisualEffectView mit eigenem Tint statt Liquid Glass — Onyx ist Stein, kein Glas. Alle Farben und Maße liegen als Tokens in OnyxDesign. Menüleiste: jedes Modul bekommt ein eigenes NSStatusItem. Elemente, denen macOS mangels Platz keine Breite gibt, werden erkannt und gemeldet, statt still zu verschwinden. App-Target über XcodeGen, damit die Projektdefinition im Diff lesbar bleibt. Nicht sandboxed, mit App-Group-Entitlement — baut, startet, signiert mit PP34X97WS3.
This commit is contained in:
Guido Schmit
@@ -0,0 +1 @@
|
||||
// OnyxMenuBarTests
|
||||
@@ -0,0 +1,67 @@
|
||||
import Testing
|
||||
import CoreGraphics
|
||||
@testable import OnyxNotch
|
||||
|
||||
@Suite("Anzeigen-Auswahl")
|
||||
struct DisplayPolicyTests {
|
||||
|
||||
static let builtIn = ScreenMetrics(
|
||||
frame: CGRect(x: 0, y: 0, width: 1800, height: 1169),
|
||||
safeAreaTop: 38,
|
||||
auxiliaryTopLeft: CGRect(x: 0, y: 1131, width: 790, height: 38),
|
||||
auxiliaryTopRight: CGRect(x: 1010, y: 1131, width: 790, height: 38),
|
||||
isBuiltIn: true,
|
||||
displayID: 1
|
||||
)
|
||||
|
||||
static let external = ScreenMetrics(
|
||||
frame: CGRect(x: 1800, y: 0, width: 2560, height: 1440),
|
||||
safeAreaTop: 0, auxiliaryTopLeft: nil, auxiliaryTopRight: nil,
|
||||
isBuiltIn: false, displayID: 2
|
||||
)
|
||||
|
||||
static let secondExternal = ScreenMetrics(
|
||||
frame: CGRect(x: -2560, y: 0, width: 2560, height: 1440),
|
||||
safeAreaTop: 0, auxiliaryTopLeft: nil, auxiliaryTopRight: nil,
|
||||
isBuiltIn: false, displayID: 3
|
||||
)
|
||||
|
||||
@Test("Nur intern: externe Displays bekommen kein Panel")
|
||||
func builtInOnlySkipsExternal() {
|
||||
let chosen = DisplayPolicy.builtInOnly.screens(from: [Self.builtIn, Self.external])
|
||||
#expect(chosen.map(\.displayID) == [1])
|
||||
}
|
||||
|
||||
@Test("Alle Displays: jedes bekommt eins")
|
||||
func allDisplaysCoversEverything() {
|
||||
let chosen = DisplayPolicy.allDisplays
|
||||
.screens(from: [Self.builtIn, Self.external, Self.secondExternal])
|
||||
#expect(Set(chosen.map(\.displayID)) == [1, 2, 3])
|
||||
}
|
||||
|
||||
@Test("Nur intern und der Deckel ist zu: Onyx wäre unerreichbar, also fällt es auf extern zurück")
|
||||
func builtInOnlyFallsBackWhenLidClosed() {
|
||||
// Deckel zu am Dock: das eingebaute Display verschwindet aus der Liste.
|
||||
// Ohne Rückfall hätte man gar keinen Zugang mehr zur App.
|
||||
let chosen = DisplayPolicy.builtInOnly.screens(from: [Self.external])
|
||||
#expect(chosen.map(\.displayID) == [2])
|
||||
}
|
||||
|
||||
@Test("Rückfall wählt genau ein Display, nicht alle")
|
||||
func fallbackPicksOnlyOne() {
|
||||
let chosen = DisplayPolicy.builtInOnly.screens(from: [Self.external, Self.secondExternal])
|
||||
#expect(chosen.count == 1)
|
||||
}
|
||||
|
||||
@Test("Ohne Displays kein Panel — und kein Absturz")
|
||||
func noScreensIsSafe() {
|
||||
#expect(DisplayPolicy.builtInOnly.screens(from: []).isEmpty)
|
||||
#expect(DisplayPolicy.allDisplays.screens(from: []).isEmpty)
|
||||
}
|
||||
|
||||
@Test("Mehrere eingebaute Displays gibt es nicht, aber der Code darf daran nicht scheitern")
|
||||
func handlesImplausibleInput() {
|
||||
let chosen = DisplayPolicy.builtInOnly.screens(from: [Self.builtIn, Self.builtIn])
|
||||
#expect(chosen.count == 2)
|
||||
}
|
||||
}
|
||||
142
Packages/OnyxKit/Tests/OnyxNotchTests/NotchGeometryTests.swift
Normal file
142
Packages/OnyxKit/Tests/OnyxNotchTests/NotchGeometryTests.swift
Normal file
@@ -0,0 +1,142 @@
|
||||
import Testing
|
||||
import CoreGraphics
|
||||
@testable import OnyxNotch
|
||||
|
||||
// Bildschirmkoordinaten auf macOS haben ihren Ursprung unten links, y wächst nach
|
||||
// oben. Die Notch sitzt also bei y = frame.maxY − höhe, nicht bei y = 0.
|
||||
|
||||
@Suite("Notch-Geometrie")
|
||||
struct NotchGeometryTests {
|
||||
|
||||
/// Gemessen auf dem Zielgerät (MacBook Pro Mac17,9, M5 Pro) am 10.08.2026.
|
||||
/// Dient als Referenzfall — wenn dieser Test bricht, hat Apple die
|
||||
/// Notch-Metrik geändert und nicht wir.
|
||||
static let builtIn = ScreenMetrics(
|
||||
frame: CGRect(x: 0, y: 0, width: 1800, height: 1169),
|
||||
safeAreaTop: 38,
|
||||
auxiliaryTopLeft: CGRect(x: 0, y: 1131, width: 790, height: 38),
|
||||
auxiliaryTopRight: CGRect(x: 1010, y: 1131, width: 790, height: 38)
|
||||
)
|
||||
|
||||
/// Typischer externer Monitor, rechts neben dem eingebauten angeordnet.
|
||||
static let external = ScreenMetrics(
|
||||
frame: CGRect(x: 1800, y: 0, width: 2560, height: 1440),
|
||||
safeAreaTop: 0,
|
||||
auxiliaryTopLeft: nil,
|
||||
auxiliaryTopRight: nil
|
||||
)
|
||||
|
||||
static let virtualSize = CGSize(width: 220, height: 32)
|
||||
|
||||
// MARK: - Erkennung
|
||||
|
||||
@Test("Eingebautes Display: echte Notch aus den Hilfsflächen berechnet")
|
||||
func physicalNotchFromRealDevice() {
|
||||
let g = NotchGeometry.resolve(Self.builtIn, virtualSize: Self.virtualSize)
|
||||
|
||||
#expect(g.kind == .physical)
|
||||
#expect(g.rect == CGRect(x: 790, y: 1131, width: 220, height: 38))
|
||||
}
|
||||
|
||||
@Test("Externes Display ohne Notch: virtueller Ersatz, oben mittig")
|
||||
func virtualNotchOnExternal() {
|
||||
let g = NotchGeometry.resolve(Self.external, virtualSize: Self.virtualSize)
|
||||
|
||||
#expect(g.kind == .virtual)
|
||||
// Mittig: 1800 + (2560 − 220)/2 = 2970
|
||||
#expect(g.rect == CGRect(x: 2970, y: 1408, width: 220, height: 32))
|
||||
}
|
||||
|
||||
@Test("safeAreaTop ohne Hilfsflächen gilt nicht als Notch")
|
||||
func safeAreaWithoutAuxIsVirtual() {
|
||||
// Kommt bei manchen Spiegelungs- und Fernanzeige-Konfigurationen vor:
|
||||
// ein Inset ist gesetzt, aber es gibt keine Notch, um die man herumlegen
|
||||
// könnte. Ein Panel an dieser Stelle säße im Nichts.
|
||||
let odd = ScreenMetrics(
|
||||
frame: CGRect(x: 0, y: 0, width: 1800, height: 1169),
|
||||
safeAreaTop: 38,
|
||||
auxiliaryTopLeft: nil,
|
||||
auxiliaryTopRight: nil
|
||||
)
|
||||
#expect(NotchGeometry.resolve(odd, virtualSize: Self.virtualSize).kind == .virtual)
|
||||
}
|
||||
|
||||
@Test("Notch-Mitte liegt auf der Bildschirmmitte")
|
||||
func notchIsCentred() {
|
||||
let g = NotchGeometry.resolve(Self.builtIn, virtualSize: Self.virtualSize)
|
||||
#expect(g.rect.midX == Self.builtIn.frame.midX)
|
||||
}
|
||||
|
||||
// MARK: - Auslösefläche
|
||||
|
||||
@Test("Auslösefläche ist breiter und tiefer als die Notch")
|
||||
func triggerIsLargerThanNotch() {
|
||||
let g = NotchGeometry.resolve(Self.builtIn, virtualSize: Self.virtualSize)
|
||||
let t = g.triggerRect
|
||||
|
||||
#expect(t.width > g.rect.width)
|
||||
#expect(t.height > g.rect.height)
|
||||
#expect(t.midX == g.rect.midX)
|
||||
}
|
||||
|
||||
@Test("Auslösefläche ragt nie über den oberen Bildschirmrand hinaus")
|
||||
func triggerStaysOnScreen() {
|
||||
let g = NotchGeometry.resolve(Self.builtIn, virtualSize: Self.virtualSize)
|
||||
#expect(g.triggerRect.maxY <= Self.builtIn.frame.maxY)
|
||||
#expect(g.triggerRect.minX >= Self.builtIn.frame.minX)
|
||||
#expect(g.triggerRect.maxX <= Self.builtIn.frame.maxX)
|
||||
}
|
||||
|
||||
@Test("Auslösefläche eines schmalen Bildschirms bleibt innerhalb")
|
||||
func triggerClampsOnNarrowScreen() {
|
||||
let narrow = ScreenMetrics(
|
||||
frame: CGRect(x: 0, y: 0, width: 240, height: 400),
|
||||
safeAreaTop: 0, auxiliaryTopLeft: nil, auxiliaryTopRight: nil
|
||||
)
|
||||
let g = NotchGeometry.resolve(narrow, virtualSize: Self.virtualSize)
|
||||
|
||||
#expect(g.triggerRect.minX >= 0)
|
||||
#expect(g.triggerRect.maxX <= 240)
|
||||
}
|
||||
|
||||
// MARK: - Panelfläche
|
||||
|
||||
@Test("Panel hängt unter der Notch und ist auf sie zentriert")
|
||||
func panelHangsBelowNotch() {
|
||||
let g = NotchGeometry.resolve(Self.builtIn, virtualSize: Self.virtualSize)
|
||||
let panel = g.panelRect(for: CGSize(width: 640, height: 320))
|
||||
|
||||
#expect(panel.midX == g.rect.midX)
|
||||
// Oberkante bündig mit dem Bildschirmrand — das Panel wächst aus der
|
||||
// Notch heraus, es schwebt nicht darunter.
|
||||
#expect(panel.maxY == Self.builtIn.frame.maxY)
|
||||
#expect(panel.height == 320)
|
||||
}
|
||||
|
||||
@Test("Panel breiter als der Bildschirm wird eingepasst statt abgeschnitten")
|
||||
func panelClampsToScreen() {
|
||||
let g = NotchGeometry.resolve(Self.builtIn, virtualSize: Self.virtualSize)
|
||||
let panel = g.panelRect(for: CGSize(width: 5000, height: 320))
|
||||
|
||||
#expect(panel.minX >= Self.builtIn.frame.minX)
|
||||
#expect(panel.maxX <= Self.builtIn.frame.maxX)
|
||||
}
|
||||
|
||||
@Test("Panel auf dem externen Display liegt in dessen Koordinaten, nicht bei null")
|
||||
func panelUsesScreenOrigin() {
|
||||
let g = NotchGeometry.resolve(Self.external, virtualSize: Self.virtualSize)
|
||||
let panel = g.panelRect(for: CGSize(width: 640, height: 320))
|
||||
|
||||
#expect(panel.minX >= 1800)
|
||||
#expect(panel.maxY == 1440)
|
||||
}
|
||||
|
||||
@Test("Zu hohes Panel wird auf die Bildschirmhöhe begrenzt")
|
||||
func panelClampsHeight() {
|
||||
let g = NotchGeometry.resolve(Self.builtIn, virtualSize: Self.virtualSize)
|
||||
let panel = g.panelRect(for: CGSize(width: 640, height: 99_999))
|
||||
|
||||
#expect(panel.height <= Self.builtIn.frame.height)
|
||||
#expect(panel.minY >= Self.builtIn.frame.minY)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,250 @@
|
||||
import Testing
|
||||
@testable import OnyxNotch
|
||||
|
||||
// Die Zustandsmaschine ist die Spezifikation des Panelverhaltens. Sie ist bewusst
|
||||
// frei von AppKit: keine Fenster, keine Timer, keine Uhr. Zeit kommt ausschließlich
|
||||
// als Eingabe herein (`.armTimerFired` / `.closeTimerFired`), damit jeder Übergang
|
||||
// ohne Warten prüfbar ist.
|
||||
|
||||
@Suite("Notch-Zustandsmaschine")
|
||||
struct NotchStateMachineTests {
|
||||
|
||||
// MARK: - Öffnen
|
||||
|
||||
@Test("Zeiger betritt die Notch → Entprellung startet, Panel bleibt zu")
|
||||
func pointerEntersStartsArming() {
|
||||
var machine = NotchStateMachine()
|
||||
let effects = machine.handle(.pointerEntered)
|
||||
|
||||
#expect(machine.phase == .arming)
|
||||
#expect(effects == [.startArmTimer(NotchStateMachine.armDelay)])
|
||||
}
|
||||
|
||||
@Test("Entprellzeit abgelaufen → Panel öffnet")
|
||||
func armTimerOpens() {
|
||||
var machine = NotchStateMachine()
|
||||
_ = machine.handle(.pointerEntered)
|
||||
let effects = machine.handle(.armTimerFired)
|
||||
|
||||
#expect(machine.phase == .open)
|
||||
#expect(effects == [.show])
|
||||
}
|
||||
|
||||
@Test("Zeiger verlässt die Notch vor Ablauf → kein Öffnen")
|
||||
func leavingDuringArmingCancels() {
|
||||
var machine = NotchStateMachine()
|
||||
_ = machine.handle(.pointerEntered)
|
||||
let effects = machine.handle(.pointerExited)
|
||||
|
||||
#expect(machine.phase == .idle)
|
||||
#expect(effects == [.cancelArmTimer])
|
||||
}
|
||||
|
||||
// MARK: - Schließen
|
||||
|
||||
@Test("Zeiger verlässt geöffnetes Panel → Nachlauffrist, noch kein Schließen")
|
||||
func leavingOpenStartsGrace() {
|
||||
var machine = NotchStateMachine()
|
||||
machine.forcePhase(.open)
|
||||
let effects = machine.handle(.pointerExited)
|
||||
|
||||
#expect(machine.phase == .closing)
|
||||
#expect(effects == [.startCloseTimer(NotchStateMachine.closeDelay)])
|
||||
}
|
||||
|
||||
@Test("Rückkehr innerhalb der Nachlauffrist → Panel bleibt offen")
|
||||
func returningDuringGraceKeepsOpen() {
|
||||
var machine = NotchStateMachine()
|
||||
machine.forcePhase(.open)
|
||||
_ = machine.handle(.pointerExited)
|
||||
let effects = machine.handle(.pointerEntered)
|
||||
|
||||
#expect(machine.phase == .open)
|
||||
#expect(effects == [.cancelCloseTimer])
|
||||
}
|
||||
|
||||
@Test("Nachlauffrist abgelaufen → Panel schließt")
|
||||
func graceExpiryCloses() {
|
||||
var machine = NotchStateMachine()
|
||||
machine.forcePhase(.open)
|
||||
_ = machine.handle(.pointerExited)
|
||||
let effects = machine.handle(.closeTimerFired)
|
||||
|
||||
#expect(machine.phase == .idle)
|
||||
#expect(effects == [.hide])
|
||||
}
|
||||
|
||||
// MARK: - Fixieren
|
||||
|
||||
@Test("Klick fixiert das offene Panel")
|
||||
func clickPins() {
|
||||
var machine = NotchStateMachine()
|
||||
machine.forcePhase(.open)
|
||||
let effects = machine.handle(.click)
|
||||
|
||||
#expect(machine.phase == .pinned)
|
||||
#expect(effects == [.cancelCloseTimer])
|
||||
}
|
||||
|
||||
@Test("Fixiertes Panel bleibt offen, wenn der Zeiger weggeht — das ist der Zweck")
|
||||
func pinnedIgnoresPointerExit() {
|
||||
var machine = NotchStateMachine()
|
||||
machine.forcePhase(.pinned)
|
||||
let effects = machine.handle(.pointerExited)
|
||||
|
||||
#expect(machine.phase == .pinned)
|
||||
#expect(effects.isEmpty)
|
||||
}
|
||||
|
||||
@Test("Zweiter Klick löst die Fixierung, Panel bleibt offen solange der Zeiger drin ist")
|
||||
func secondClickUnpins() {
|
||||
var machine = NotchStateMachine()
|
||||
machine.forcePhase(.pinned)
|
||||
let effects = machine.handle(.click)
|
||||
|
||||
#expect(machine.phase == .open)
|
||||
#expect(effects.isEmpty)
|
||||
}
|
||||
|
||||
@Test("esc löst die Fixierung und schließt")
|
||||
func escapeClosesPinned() {
|
||||
var machine = NotchStateMachine()
|
||||
machine.forcePhase(.pinned)
|
||||
let effects = machine.handle(.escape)
|
||||
|
||||
#expect(machine.phase == .idle)
|
||||
#expect(effects == [.hide])
|
||||
}
|
||||
|
||||
@Test("esc schließt auch ein nur geöffnetes Panel")
|
||||
func escapeClosesOpen() {
|
||||
var machine = NotchStateMachine()
|
||||
machine.forcePhase(.open)
|
||||
let effects = machine.handle(.escape)
|
||||
|
||||
#expect(machine.phase == .idle)
|
||||
#expect(effects == [.hide])
|
||||
}
|
||||
|
||||
@Test("esc im Ruhezustand tut nichts")
|
||||
func escapeIdleIsNoop() {
|
||||
var machine = NotchStateMachine()
|
||||
let effects = machine.handle(.escape)
|
||||
|
||||
#expect(machine.phase == .idle)
|
||||
#expect(effects.isEmpty)
|
||||
}
|
||||
|
||||
// MARK: - Unterdrückung (Vollbildvideo, „Nicht stören")
|
||||
|
||||
@Test("Unterdrückung schließt ein offenes Panel und räumt die Timer ab")
|
||||
func suppressionClosesOpen() {
|
||||
var machine = NotchStateMachine()
|
||||
machine.forcePhase(.open)
|
||||
let effects = machine.handle(.suppressed(true))
|
||||
|
||||
#expect(machine.phase == .idle)
|
||||
#expect(effects == [.cancelArmTimer, .cancelCloseTimer, .hide])
|
||||
}
|
||||
|
||||
@Test("Unterdrückung löst auch die Fixierung — sonst klebt das Panel im Vollbild")
|
||||
func suppressionBeatsPinning() {
|
||||
var machine = NotchStateMachine()
|
||||
machine.forcePhase(.pinned)
|
||||
_ = machine.handle(.suppressed(true))
|
||||
|
||||
#expect(machine.phase == .idle)
|
||||
}
|
||||
|
||||
@Test("Während der Unterdrückung öffnet Hovern nicht")
|
||||
func suppressedIgnoresHover() {
|
||||
var machine = NotchStateMachine()
|
||||
_ = machine.handle(.suppressed(true))
|
||||
let effects = machine.handle(.pointerEntered)
|
||||
|
||||
#expect(machine.phase == .idle)
|
||||
#expect(effects.isEmpty)
|
||||
}
|
||||
|
||||
@Test("Nach dem Ende der Unterdrückung öffnet Hovern wieder")
|
||||
func unsuppressingRestoresHover() {
|
||||
var machine = NotchStateMachine()
|
||||
_ = machine.handle(.suppressed(true))
|
||||
_ = machine.handle(.pointerEntered)
|
||||
_ = machine.handle(.suppressed(false))
|
||||
_ = machine.handle(.pointerEntered)
|
||||
|
||||
#expect(machine.phase == .arming)
|
||||
}
|
||||
|
||||
@Test("Ende der Unterdrückung öffnet nicht von selbst, auch wenn der Zeiger dort steht")
|
||||
func unsuppressingDoesNotAutoOpen() {
|
||||
var machine = NotchStateMachine()
|
||||
_ = machine.handle(.suppressed(true))
|
||||
let effects = machine.handle(.suppressed(false))
|
||||
|
||||
#expect(machine.phase == .idle)
|
||||
#expect(effects.isEmpty)
|
||||
}
|
||||
|
||||
// MARK: - Robustheit gegen doppelte Ereignisse
|
||||
|
||||
@Test("Zweimal betreten ohne zwischenzeitliches Verlassen startet keinen zweiten Timer")
|
||||
func repeatedEnterIsIdempotent() {
|
||||
var machine = NotchStateMachine()
|
||||
_ = machine.handle(.pointerEntered)
|
||||
let effects = machine.handle(.pointerEntered)
|
||||
|
||||
#expect(machine.phase == .arming)
|
||||
#expect(effects.isEmpty)
|
||||
}
|
||||
|
||||
@Test("Verlassen im Ruhezustand tut nichts")
|
||||
func exitWhileIdleIsNoop() {
|
||||
var machine = NotchStateMachine()
|
||||
let effects = machine.handle(.pointerExited)
|
||||
|
||||
#expect(machine.phase == .idle)
|
||||
#expect(effects.isEmpty)
|
||||
}
|
||||
|
||||
@Test("Verspäteter Timer nach dem Schließen öffnet nicht mehr")
|
||||
func staleArmTimerDoesNotOpen() {
|
||||
var machine = NotchStateMachine()
|
||||
_ = machine.handle(.pointerEntered)
|
||||
_ = machine.handle(.pointerExited) // Timer wurde abbestellt …
|
||||
let effects = machine.handle(.armTimerFired) // … feuert aber trotzdem noch
|
||||
|
||||
#expect(machine.phase == .idle)
|
||||
#expect(effects.isEmpty)
|
||||
}
|
||||
|
||||
@Test("Verspäteter Schließtimer schließt kein wieder geöffnetes Panel")
|
||||
func staleCloseTimerDoesNotHide() {
|
||||
var machine = NotchStateMachine()
|
||||
machine.forcePhase(.open)
|
||||
_ = machine.handle(.pointerExited)
|
||||
_ = machine.handle(.pointerEntered) // zurück, Timer abbestellt …
|
||||
let effects = machine.handle(.closeTimerFired) // … feuert trotzdem
|
||||
|
||||
#expect(machine.phase == .open)
|
||||
#expect(effects.isEmpty)
|
||||
}
|
||||
|
||||
@Test("Klick im Ruhezustand öffnet nicht — sonst öffnet jeder Klick oben am Rand")
|
||||
func clickWhileIdleIsNoop() {
|
||||
var machine = NotchStateMachine()
|
||||
let effects = machine.handle(.click)
|
||||
|
||||
#expect(machine.phase == .idle)
|
||||
#expect(effects.isEmpty)
|
||||
}
|
||||
|
||||
// MARK: - Zeitkonstanten
|
||||
|
||||
@Test("Entprellung und Nachlauf entsprechen dem Plan")
|
||||
func timingConstants() {
|
||||
#expect(NotchStateMachine.armDelay == 0.22)
|
||||
#expect(NotchStateMachine.closeDelay == 0.30)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1 @@
|
||||
// OnyxWidgetKitTests
|
||||
Reference in New Issue
Block a user