Diagramme rechnen mit der vollen Länge, eigene Symbole für CPU und GPU

Frisch gestartet hat der Verlauf fünf Messwerte statt sechzig. Gerechnet
wurde aber „Breite geteilt durch Anzahl" — also war jeder Balken ein
Fünftel breit, und mit jedem weiteren wurden sie schmaler. Das Diagramm sah
nach einem Ausschlag aus und bedeutete nichts.

Jetzt kommt die Schrittweite aus der vollen Länge. Fehlende Werte bleiben
als freie Fläche links stehen; der Verlauf wächst nach links weg, wie bei
jedem Zeitdiagramm.

Das steckte an **drei** Stellen, alle mit derselben Rechnung: dem
Balkendiagramm im Netzwerk-Popover, der Sparkline in den Kacheln und der
Linie in den Menüleisten-Modulen. Die gemeinsame Rechnung liegt jetzt in
`GraphLayout` und ist geprüft, statt dreimal danebenzugehen.

Nebenbei: die Fläche unter der Sparkline begann am linken Rand statt am
ersten Messwert — ein Keil über die ganze Breite, wo noch nichts gemessen
war.

CPU und GPU bekommen eigene Symbole aus chip.svg und graphic-card.svg. SF
Symbols hat für beides nur denselben Chip, und „cpu" neben „cpu.fill" ist
kein Unterschied, den man in der Menüleiste erkennt.

Die Beschriftung unter den Ringen klebte am Rand und sah aus, als gehörte
sie noch hinein — sechs Punkte Abstand statt zwei. Und die Popover für CPU
und GPU tragen jetzt einen Titel: bei drei gleich aussehenden Ringen sieht
man sonst nicht, vor welchem man steht.

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

Packages/OnyxKit/Sources/OnyxMenuBar/GraphLayout.swift

@@ -0,0 +1,41 @@
+import CoreGraphics
+
+/// Wo die Punkte eines Verlaufsdiagramms liegen.
+///
+/// Die Schrittweite kommt aus der **vollen** Länge des Verlaufs, nicht aus der
+/// Anzahl der bisher vorhandenen Werte. Frisch gestartet hat der Verlauf zwei
+/// Messwerte statt sechzig — wurde daraus gerechnet, spannte sich der Weg
+/// zwischen ihnen über die ganze Breite. Das sah nach viel Bewegung aus und
+/// bedeutete nichts.
+public enum GraphLayout {
+
+    /// - Parameters:
+    ///   - count: wie viele Werte vorliegen.
+    ///   - capacity: wie viele der Verlauf fasst.
+    public static func positions(count: Int, capacity: Int, in rect: CGRect) -> [CGFloat] {
+        // Eine Linie braucht zwei Punkte. Einen zu zeichnen ergäbe einen Strich
+        // am Rand, der wie ein Messwert aussieht.
+        guard count >= 2, capacity >= 2 else { return [] }
+
+        let shown = min(count, capacity)
+        let step = rect.width / CGFloat(capacity - 1)
+        // Neue Werte rechts: der Verlauf wächst nach links weg.
+        let start = rect.maxX - CGFloat(shown - 1) * step
+        return (0..<shown).map { start + CGFloat($0) * step }
+    }
+
+    /// Die Breite eines Balkens.
+    ///
+    /// Aus der **vollen** Länge gerechnet, nicht aus den vorhandenen Werten:
+    /// sonst ist bei fünf Messwerten jeder Balken ein Fünftel breit, und mit
+    /// jedem weiteren werden sie schmaler. Fehlende Werte bleiben stattdessen
+    /// als freie Fläche links stehen.
+    public static func barWidth(capacity: Int, totalWidth: CGFloat,
+                                spacing: CGFloat) -> CGFloat {
+        guard capacity > 0 else { return totalWidth }
+        let gaps = spacing * CGFloat(capacity - 1)
+        // Sichtbar bleiben, auch wenn es eng wird — sonst verschwindet der
+        // Verlauf bei schmalem Fenster ganz.
+        return max((totalWidth - gaps) / CGFloat(capacity), 0.5)
+    }
+}