chore(release): bump version to 0.12.0

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
docs: README und Dokumentation auf den aktuellen Stand
2026-10-08 09:31:45 +02:00 · 2026-10-08 09:21:42 +02:00 · 2026-10-08 09:21:42 +02:00 · 2026-10-08 08:50:54 +02:00
19 changed files with 876 additions and 554 deletions
@@ -1393,7 +1393,7 @@ dependencies = [

 [[package]]
 name = "ink-notes"
-version = "0.10.0"
+version = "0.12.0"
 dependencies = [
 "ab_glyph",
 "arboard",
@@ -1,8 +1,8 @@
 [package]
 name = "ink-notes"
-version = "0.10.0"
+version = "0.12.0"
 edition = "2021"
-description = "Latenzoptimierte Vektor-Notizbuch- und Inking-Anwendung für Linux"
+description = "Notizbuch-App für Stift, Touch und Maus unter Linux"
 repository = "https://gitea.pansi.eu/harald/ink-notes"
 license = "MIT"
 readme = "README.md"
@@ -1,286 +1,217 @@
-# 🖋️ ink-notes
+# ink-notes

-Eine latenzoptimierte, hardwarebeschleunigte Inking- und Notizbuch-Anwendung für Linux, entwickelt in **Rust** mit **wgpu** und **winit**.
+Eine Notizbuch-App für Linux zum Schreiben mit Stift, Finger oder Maus – geschrieben in **Rust** mit **wgpu**, **winit** und **egui**.

-`ink-notes` kombiniert minimale Eingabelatenz beim Zeichnen mit Stift, Touchpad oder Maus mit einem flüssigen stufenlosen Viewport, automatischer Geometrie- und Formerkennung, Objekttransformationen, Multi-Dokumenten-Verwaltung und Vektor-PDF-Export.
+ink-notes speichert Handschrift als Vektoren, erkennt auf Wunsch Formen, kann PDFs zum Beschriften importieren, Bilder und Textfelder einfügen und alles wieder als PDF, PNG oder SVG exportieren. Gespeichert wird automatisch im Hintergrund.
+
+Getestet wird vor allem unter Zorin OS 18 / Ubuntu 24.04 (Wayland und X11).

 ---

-## ✨ Features im Überblick
+## Funktionen

-### ⚡ Latenzoptimierte Inking-Pipeline
- **Hardware-Rendering:** Direct-to-Screen-Rendering mit `wgpu` (Vulkan / X11 / Wayland) unter Nutzung von `PresentMode::Mailbox` für minimale Eingabeverzögerung.
- **Zwei-Stufen-Modell:**
-  1. *Live-Phase:* Eingehende Stylus-Samples werden in Echtzeit durch einen 1€-Filter (One-Euro-Filter) entprellt und inkrementell als GPU-Meshes dargestellt.
-  2. *Commit-Phase (Post-Stroke Finalisierung):* Akausale Ecken-Erkennung (Corner Preservation bei Knicken > 65°), gewichtetes 3-Punkt-Druckfenster, Ramer-Douglas-Peucker (RDP) Dezimierung und saubere runde Endkappen.
- **Centripetal Catmull-Rom Splines:** Weiche C1-stetige Kurveninterpolation ohne Überschwinger oder Schleifen.
- **Werkzeuge:**
-  - **Stift (Pen):** Feine, variable Strichstärken (0.3 mm bis 1.2 mm) mit Notiz-Farben (Schwarz, Blau, Rot, Grün, Grau).
-  - **Textmarker (Highlighter):** Breite, halbtransparente Striche (4.0 mm bis 8.0 mm) mit Multiplikations-Blending.
-  - **Radierer (Eraser):** Segment- und abstandsbasierte Löschung einzelner Striche auf dem DIN-A4-Canvas.
-  - **Text (`T`):** Ins Blatt tippen und mit der Tastatur schreiben – für Überschriften, Code-Schnipsel oder kopierten Text. Normale Schrift oder Code-Schrift (feste Zeichenbreite, Tab rückt ein), 8 bis 36 pt, Farben der Stiftpalette; Zeilen werden am rechten Rand des Textfelds umbrochen. Vorhandenen Text antippen zum Ändern, `Esc` beendet. Textfelder lassen sich wie Bilder verschieben, drehen und skalieren; im PDF-Export ist der Text echt (durchsuchbar und kopierbar). Aus anderen Programmen kopierter Text wird mit `Strg + V` zum Textfeld.
+### Schreiben und Zeichnen
+- **Stift** mit Druckstärke, vier Strichstärken (0,3–1,2 mm) und fünf Farben; **Textmarker** (halbtransparent, 4–8 mm) in vier Farben.
+- **Glättung in zwei Stufen:** Während des Schreibens glättet ein 1€-Filter das Zittern, die Linie erscheint sofort. Beim Absetzen wird der Strich nachbearbeitet: Ecken (Knicke über 65°) bleiben erhalten, der Druckverlauf wird geglättet, überflüssige Punkte entfallen, die Enden werden rund.
+- **Druckkurve** im ☰-Menü an den eigenen Stift anpassen (weicher/härter, Schwelle gegen Grundrauschen).
+- **Radierer** in drei Modi: ganze Striche, nur den überstrichenen Teil (Teilstrich) oder nur Textmarker. Stiftrückseite und Seitentaste des Stifts radieren ebenfalls.
+- **Virtuelles Lineal** (`L`): verschieben, am Griff drehen (rastet bei 15° ein); Striche entlang einer Kante werden gerade.

-### 🔍 Stufenloser Zoom & Pan (Kamera)
- **Viewport-Transformation:** 2D-Projektionsmatrix im WGSL-Vertex-Shader.
- **Durchgehendes Scrollen:** Seiten hängen untereinander und werden mit Mausrad, Finger oder Touchpad fließend gescrollt; wer im unteren Fünftel der letzten Seite schreibt, bekommt automatisch eine neue Seite angehängt. Abschaltbar im ☰-Menü unter „Ansicht“ (dann Seite für Seite blättern).
- **Cursor-zentrierter Zoom:** Stufenloses Zoomen von **25 % bis 1000 %** (importierte PDF-Seiten werden beim Hineinzoomen schärfer nachgerendert) zentriert auf die Cursor-Position via `Strg + Mausrad` (ohne durchgehende Ansicht: Mausrad), Trackpad-Pinch oder Tastenkürzel (`Strg +` / `Strg -` / `Strg 0`).
- **Pan:** Verschieben des Canvas per mittlerer Maustaste, `Leertaste + Drag` oder Trackpad-Pan.
- **Inverse Koordinatentransformation:** Präzise Umrechnung von Bildschirm- in DIN-A4-Dokumentkoordinaten (`screen_to_page`).
+### Formerkennung
+- **Formen-Werkzeug** (`S`/`F`) oder **Halten** am Strichende (über 400 ms stillhalten): Die Skizze wird durch eine saubere Form ersetzt.
+- Erkannt werden Linien, Pfeile, Kreise, Ellipsen, Rechtecke, Dreiecke, Rauten, Vielecke, Koordinatensysteme und Oktaeder (Skizze als 3D-Körper).
+- Die Erkennung arbeitet rein geometrisch (Bogenlänge, Douglas-Peucker, Kreis-Fit), ohne Machine Learning. Nicht alles wird erkannt – was nicht passt, bleibt Handschrift.

-### 📐 Geometrie- & Objekterkennung (Shape Recognition)
- **Erkannte Primitiven:**
-  - **Geraden (Line):** Sehnen- zu Pfadlängenverhältnis > 0.92.
-  - **Rechtecke (Rectangle):** 4 orthogonale Ecken via Douglas-Peucker-Polygonzug (RDP).
-  - **Kreise & Ellipsen (Circle/Ellipse):** Geschlossene Pfade mit minimaler Varianz via Least-Squares Circle Fit.
-  - **Koordinatensysteme (Axes):** Zwei orthogonale Achsen (80°–100° gesnappt auf exakt 90°) mit Richtungspfeilen.
-  - **Dreiecke, Rhomben / Rauten & Oktaeder:** Regelmäßige Polygone mit Eckpunkt-Analyse.
- **Interaktionsmodelle:**
-  - **Draw-and-Hold:** Verweilt der Stift am Ende eines Strichs für > 400 ms regungslos (< 3 px), snappt die Skizze sofort automatisch in eine perfekte Vektorform ein.
-  - **Formen-Werkzeug (Shape Mode):** Direkte Erkennung und Ersetzung beim Loslassen.
+### Auswählen und Bearbeiten
+- **Auswahlwerkzeug** (`V`): antippen oder Rahmen aufziehen, dann verschieben, an den Ecken skalieren, am Griff drehen oder mit `R` um 90° drehen. Funktioniert mit Maus, Finger und Stift.
+- Auswahl über die Palette **umfärben**, **kopieren/einfügen** (`Strg + C/V`), **löschen** (`Entf`).
+- `Strg + C` legt die Auswahl zusätzlich als Bild in die Zwischenablage, z. B. für Chat oder Mail.
+- **Rückgängig/Wiederholen** (`Strg + Z/Y`) für alle Änderungen, je Seite.

-### 🖐️ Objektauswahl & Transformation (Lasso / Select)
- **Lasso & Klick-Auswahl:** Schnelles Markieren einzelner Striche oder Gruppen per Rahmen (`V`).
- **Echtzeit-Verschieben:** Freies Verschieben ausgewählter Objekte über die Seite.
- **Stufenlose Skalierung:** Größenänderung über interaktive Eck-Griffe.
- **Drehung:** Stufenlose Rotation um das Objektzentrum über den oberen Dreh-Griff oder exakte 90°-Schritte mit Taste `R`.
- **Multicolor-Umfärbung:** Ausgewählte Objekte direkt über die Farbpalette umfärben.
- **Clipboard & Editieren:** Kopieren (`Strg + C`), Einfügen (`Strg + V`) und Löschen (`Entf` / `Backspace`).
- **Undo / Redo:** Vollständige Transaktionshistorie (`Strg + Z` / `Strg + Y`) für alle Aktionen inklusive Transformationen.
+### Text, Bilder und PDFs
+- **Text-Werkzeug** (`T`): ins Blatt tippen und schreiben – normale oder Code-Schrift (feste Zeichenbreite, Tab rückt ein), 8–36 pt, Zeilenumbruch am Feldrand. Vorhandenen Text antippen zum Ändern, `Esc` beendet. Textfelder lassen sich wie Bilder verschieben, drehen und skalieren. In anderen Programmen kopierter Text wird mit `Strg + V` zum Textfeld.
+- **Bilder** (PNG, JPEG, GIF, WebP, BMP) über `Strg + I`, aus der Zwischenablage oder per Ziehen ins Fenster einfügen.
+- **PDF importieren** (☰-Menü): Jede PDF-Seite wird eine Notizbuchseite mit der PDF-Seite als Hintergrund. Hochformat-Seiten werden DIN A4, Querformat-Seiten (z. B. Folien) bekommen eine Querformat-Seite ohne leeren Streifen darunter. Beim Hineinzoomen werden PDF-Seiten schärfer nachgerendert.

-### 📚 Multi-Dokumenten- & Notizbuch-Verwaltung
- **Dateisystem-Architektur:** Jedes Dokument wird in einem separaten Verzeichnis unter `~/.local/share/ink-notes/notebooks/<id>/` mit `manifest.json` und Einzelseiten (`page_<id>.json`) gespeichert.
- **Dokumenten-Manager:** Toolbar-Modal zum Anlegen, Wechseln, Umbenennen und Löschen von Notizbüchern.
- **Verlustfreier Wechsel:** Beim Dokumentenwechsel sichert ein synchroner Disk-Flush alle anstehenden Änderungen garantiert ab.
+### Seiten und Ansicht
+- **Hintergründe:** blanko, kariert (5 mm), liniert (7,5 mm), Punktraster (5 mm). Die **Farbe von Karos, Linien und Punkten** ist wählbar (hell, mittel, kräftig, blau, grün) und gilt auch im Export.
+- **Papierfarbe** der Anzeige: weiß, creme, dunkelgrau, schwarz; auf dunklem Papier werden dunkle Stiftfarben auf Wunsch aufgehellt. Gespeichert und exportiert wird immer auf weißem Papier.
+- **Durchgehendes Scrollen:** Seiten hängen untereinander; wer im unteren Fünftel der letzten Seite schreibt, bekommt automatisch eine neue Seite. Abschaltbar (dann Seite für Seite blättern).
+- **Zoom** von 25 % bis 1000 % (`Strg + Mausrad`, zwei Finger, `Strg + +/-/0`), Verschieben mit mittlerer Maustaste, `Leertaste + Ziehen` oder einem Finger.
+- **Seiten** anhängen oder direkt nach der aktuellen Seite einfügen, **Seitentitel** vergeben; die Seitenübersicht zeigt Vorschaubilder oder ein Inhaltsverzeichnis. Seitentitel werden im PDF zu Lesezeichen.
+- **Werkzeugleiste** links oder rechts andocken (für Links- und Rechtshänder).

-### 📄 Seiten & Hintergründe
- **Virtuelles DIN-A4-Raster:** 2100 × 2970 Koordinateneinheiten (10 Einheiten = 1 mm).
- **Seitenformat aus dem PDF:** Beim PDF-Import bleiben Hochformat-Seiten DIN A4; Querformat-Seiten wie PowerPoint-Folien bekommen eine Querformat-Seite (297 mm breit, Höhe nach Seitenverhältnis) ohne leeren Streifen darunter. Eingefügte Seiten übernehmen das Format der aktuellen Seite.
- **Hintergrundmuster:** Blanko, Kariert (5 mm), Liniert (7.5 mm), Punktraster (5 mm).
- **Seitenverwaltung:** Vor- und Zurückblättern, neue Seiten anhängen oder direkt nach der aktuellen Seite einfügen (☰-Menü oder Seitenauswahl, z. B. zwischen zwei PDF-Folien), Seitensprung-Menü.
+### Notizbücher und Speichern
+- Mehrere **Notizbücher** anlegen, umbenennen, wechseln und löschen (gelöschte landen zunächst im Papierkorb und lassen sich wiederherstellen).
+- **Automatisches Speichern** im Hintergrund: 1,5 Sekunden nach der letzten Änderung, bei ununterbrochenem Schreiben spätestens alle 10 Sekunden. Zeichnen wird dabei nicht unterbrochen.
+- Jede Datei wird erst vollständig in eine temporäre Datei geschrieben und dann ersetzt – ein Absturz beim Speichern hinterlässt keine halbe Datei.
+- **Beim Schließen** (Fenster oder `Strg + Q`) und beim Wechsel des Notizbuchs wird alles Ausstehende geschrieben, bevor es weitergeht. Schlägt das fehl, bleibt die App offen und bietet Wiederholen oder eine Notfall-Sicherung an.
+- `Strg + S` speichert sofort. Der Punkt am ☰-Knopf zeigt den Stand: grün = gespeichert, orange = Änderungen warten, gelb = speichert gerade, rot = Fehler.

-### 💾 Autosave & Persistenz
- **Asynchroner Autosave-Controller:** Sichert Änderungen im Hintergrund nach 1.5 s Ruhezeit (Debounce), ohne das Zeichnen zu blockieren.
- **Atomares Schreiben:** Temp-Dateien mit atomarem Rename (`manifest.json.tmp` -> `manifest.json`) schützen vor Datenkorruption bei Abstürzen.
- **Dediziertes Speichern (`Strg + S`):** Sofortiger, synchroner Disk-Flush mit visueller Toast-Rückmeldung.
- **Sicherer Shutdown:** `Strg + Q` oder Schließen des Fensters führt vor Programmende einen vollständigen synchronen Flush aus.
+### Export
+- **PDF** (`Strg + E`) nach `~/Documents/<Titel>.pdf`: Striche und Formen als Vektoren, Textfelder als echter, durchsuchbarer Text, importierte PDF-Seiten als Vektor-Unterlage, Seitentitel als Lesezeichen.
+- **Einzelne Seite** als PNG (mit oder ohne Hintergrund) oder SVG über das ☰-Menü.

-### 🖨️ Vektor-PDF-Export
- Exportiert das Dokument via `printpdf` nach `~/Documents/<Titel>.pdf` (mit automatischer Kollisionsvermeidung `_1`, `_2`).
- Striche und geometrische Formen werden als skalierbare Vektoren ausgegeben. Kürzel: `Strg + E`.
+### Eingabegeräte
+- Stifte über das Tablet-Protokoll von Wayland bzw. X11 (Druck, Stiftrückseite, Seitentaste).
+- Solange der Stift aufliegt oder in der Nähe ist, werden Berührungen mit der Hand ignoriert.
+- Finger: standardmäßig scrollen und zoomen; Zeichnen mit dem Finger lässt sich im ☰-Menü einschalten.
+
+### Updates
+- Die App prüft auf neue Versionen auf Gitea und installiert sie auf Wunsch. Installiert wird nur, wenn die Minisign-Signatur und die SHA-256-Prüfsumme stimmen (Details unten).

 ---

-## 📦 Release, Packaging & Updater
+## Installation

- **Natives .deb-Paket**: Optimiert für Zorin OS 18 (Ubuntu 24.04 LTS Basis) mit vollständiger XDG Desktop-Integration (`.desktop`, Hicolor-Icons SVG & PNG, AppStream Metainfo, Debian Copyright & Changelog).
- **Portables .AppImage**: Eigenständiges x86_64 Bundle.
- **In-App Updater (`src/updater.rs`)**: Automatischer Prüflauf gegen Gitea Releases, SemVer-Filterung, Minisign-Signaturprüfung, SHA-256-Prüfung und atomarer In-Place Austausch.
-
-### 1. Release-Pakete bauen
+Pakete gibt es unter [Releases](https://gitea.pansi.eu/harald/ink-notes/releases) als `.deb` und `.AppImage` (x86_64). `<version>` steht für die Versionsnummer, z. B. `0.11.0`.

 ```bash
-# Baut .deb, .AppImage und berechnet SHA256SUMS.txt in target/
-./scripts/build-release.sh
+# Debian-Paket (Zorin OS 18 / Ubuntu 24.04)
+sudo apt install ./ink-notes_<version>_amd64.deb
+
+# oder AppImage
+chmod +x ink-notes_<version>_x86_64.AppImage
+./ink-notes_<version>_x86_64.AppImage
 ```

-Ergebnis in `target/`:
- `ink-notes_0.1.0_amd64.deb`
- `ink-notes_0.1.0_x86_64.AppImage`
- `SHA256SUMS.txt`
- `SHA256SUMS.txt.minisig` (nur mit gesetztem `MINISIGN_SECRET_KEY`, siehe unten)
+Hinweise:
+- Benötigt `glibc >= 2.39` (Ubuntu 24.04, Zorin OS 18) und einen Grafiktreiber mit Vulkan oder OpenGL.
+- Meldet das AppImage einen Fehler zu `libfuse.so.2`, entweder `sudo apt install libfuse2t64` installieren oder mit `--appimage-extract-and-run` starten.
+
+---
+
+## Tastenkürzel
+
+| Aktion | Taste / Geste |
+| :--- | :--- |
+| Zeichnen | Stiftspitze, linke Maustaste (Finger, wenn eingeschaltet) |
+| Radieren | `E` umschalten, rechte Maustaste, Stiftrückseite oder Seitentaste |
+| Stift in Schwarz / Blau / Rot | `B` / `U` / `R` |
+| Formen-Werkzeug | `S` oder `F` |
+| Auswahlwerkzeug | `V` |
+| Text-Werkzeug | `T`, dann ins Blatt klicken; `Esc` beendet die Eingabe |
+| Lineal ein/aus | `L` |
+| Hintergrund wechseln | `G` |
+| Auswahl um 90° drehen | `R` (bei Auswahl) |
+| Kopieren / Einfügen | `Strg + C` / `Strg + V` |
+| Auswahl löschen | `Entf` oder `Rücktaste` |
+| Rückgängig / Wiederholen | `Strg + Z` / `Strg + Y` oder `Strg + Umschalt + Z` |
+| Bild einfügen | `Strg + I` |
+| Scrollen | Mausrad (`Umschalt` = waagerecht), ein Finger |
+| Zoomen | `Strg + Mausrad`, zwei Finger, `Strg + +` / `Strg + -` |
+| Zoom zurücksetzen | `Strg + 0` |
+| Verschieben | mittlere Maustaste oder `Leertaste + Ziehen` |
+| Nächste / vorherige Seite | `Bild ab` oder `N` / `Bild auf` |
+| Erste / letzte Seite | `Pos 1` / `Ende` |
+| Jetzt speichern | `Strg + S` |
+| PDF exportieren | `Strg + E` |
+| Menüs schließen, Auswahl aufheben | `Esc` |
+| Beenden (speichert vorher) | `Strg + Q` oder Fenster schließen |
+
+---
+
+## Entwicklung
+
+### Voraussetzungen
+- Rust 1.92 oder neuer (`rustup update stable`)
+- Vulkan- oder OpenGL-Treiber (z. B. `mesa-vulkan-drivers`)
+- X11-/Wayland-Bibliotheken: `libx11-dev`, `libxcursor-dev`, `libxrandr-dev`, `libxi-dev`, `libxkbcommon-dev`
+
+### Bauen, starten, testen
+
+```bash
+git clone https://gitea.pansi.eu/harald/ink-notes.git
+cd ink-notes
+cargo run --release          # oder ./run.sh
+cargo test                   # Unit- und Integrationstests
+```
+
+Die CI prüft zusätzlich `cargo fmt --check` und `cargo clippy --all-targets -- -D warnings`.
+
+### Projektstruktur
+
+```text
+src/
+├── main.rs         # Event-Loop (winit), Eingaben von Maus, Touch und Stift, Ablaufsteuerung
+├── lib.rs          # Bibliotheks-Exporte (für Tests)
+├── canvas.rs       # wgpu-Rendering: Papier, Muster, Bilder, Tinte, Nachbarseiten
+├── shader.wgsl     # Vertex- und Fragment-Shader
+├── viewport.rs     # Kamera (Zoom, Verschieben), Seitenstapel der durchgehenden Ansicht
+├── filter.rs       # 1€-Filter gegen Zittern
+├── spline.rs       # Catmull-Rom-Splines, Ecken-Erhaltung, Dreiecksstreifen
+├── geometry.rs     # Formerkennung (Douglas-Peucker, Kreis-Fit, …)
+├── selection.rs    # Auswahl, Griffe, Verschieben/Drehen/Skalieren
+├── ruler.rs        # Virtuelles Lineal
+├── text.rs         # Textfelder: Satz, Zeilenumbruch, Rasterung
+├── background.rs   # Papierfarben, Musterfarben, Karo/Linien/Punkte
+├── image_layer.rs  # Texturen für Bilder, PDF-Seiten und Text
+├── assets.rs       # Bilder und PDFs im Notizbuchordner
+├── pdf_doc.rs      # PDF lesen und rendern (hayro)
+├── pdf_merge.rs    # Importierte PDF-Seiten beim Export unterlegen
+├── document.rs     # Datenmodell: Notizbuch, Seiten, Striche, Seitengrößen
+├── history.rs      # Rückgängig/Wiederholen
+├── storage.rs      # Laden/Speichern (atomar), Notizbücher, Papierkorb
+├── autosave.rs     # Speichern im Hintergrund
+├── export.rs       # PDF-Export (printpdf)
+├── page_export.rs  # Seite als PNG/SVG, Auswahl als Bild
+├── file_picker.rs  # Eingebaute Dateiauswahl
+├── settings.rs     # Einstellungen (~/.config/ink-notes/ui.json)
+├── platform.rs     # Wayland/X11-Erkennung
+├── updater.rs      # Updates von Gitea (Signatur- und Prüfsummenprüfung)
+└── ui.rs           # Oberfläche (egui): Werkzeugleiste, Menüs, Dialoge
+```
+
+Mehr dazu in [`docs/ARCHITECTURE.md`](docs/ARCHITECTURE.md), das Speicherformat steht in [`docs/FILE_FORMAT.md`](docs/FILE_FORMAT.md).
+
+---
+
+## Releases bauen und veröffentlichen
+
+```bash
+./scripts/build-release.sh          # .deb, .AppImage und SHA256SUMS.txt in target/
+```
+
+Veröffentlicht wird über Gitea Actions ([`.gitea/workflows/release.yaml`](.gitea/workflows/release.yaml)), sobald ein Tag `vX.Y.Z` gepusht wird: Tests, Pakete bauen, signieren, Release anlegen. Manuell geht es mit `GITEA_TOKEN=… ./scripts/publish-gitea-release.sh`.

 ### Release-Signatur einrichten (einmalig)

-In-App-Updates werden nur mit gültiger Minisign-Signatur installiert. Signiert wird mit [rsign2](https://crates.io/crates/rsign2), einer Minisign-kompatiblen Implementierung (`cargo install rsign2 --locked`). Einmalig ein Schlüsselpaar erzeugen (ohne Passwort, da es nur als CI-Secret verwendet wird):
+Updates werden in der App nur mit gültiger Minisign-Signatur installiert. Signiert wird mit [rsign2](https://crates.io/crates/rsign2) (`cargo install rsign2 --locked`). Schlüsselpaar ohne Passwort erzeugen (es wird nur als CI-Secret verwendet):

 ```bash
 rsign generate -W -p ink-notes.pub -s ink-notes.key
 ```

-> **Wichtig:** Schlüssel und Signierwerkzeug müssen zusammenpassen. `rsign generate -W` verschlüsselt den Schlüssel mit einem leeren Passwort; das `minisign`-CLI (z. B. Ubuntu-Paket 0.11) kann ihn ohne Terminal nicht laden. `build-release.sh` und die CI signieren deshalb mit `rsign`.
+1. Die zweite Zeile von `ink-notes.pub` (beginnt mit `RW`) in `src/updater.rs` als `UPDATE_SIGNING_PUBLIC_KEY` eintragen.
+2. Den Inhalt von `ink-notes.key` in Gitea unter *Repository → Einstellungen → Actions → Secrets* als `MINISIGN_SECRET_KEY` hinterlegen.
+3. `ink-notes.key` offline aufbewahren. Geht er verloren, können bestehende Installationen keine Updates mehr prüfen.

-1. Die zweite Zeile aus `ink-notes.pub` (beginnt mit `RW`) in `src/updater.rs` als `UPDATE_SIGNING_PUBLIC_KEY` eintragen und committen.
-2. Den kompletten Inhalt von `ink-notes.key` in Gitea unter *Repository → Einstellungen → Actions → Secrets* als `MINISIGN_SECRET_KEY` anlegen.
-3. `ink-notes.key` sicher offline aufbewahren und vom Rechner löschen. Geht der Schlüssel verloren, können bestehende Installationen keine Updates mehr prüfen.
+`rsign generate -W` verschlüsselt den Schlüssel mit leerem Passwort; das `minisign`-Programm (z. B. Ubuntu-Paket 0.11) kann ihn ohne Terminal nicht lesen, deshalb signieren Skript und CI mit `rsign`. In der CI ist die Signatur Pflicht (`INK_NOTES_REQUIRE_SIGNATURE=1`), und das Skript prüft, dass der geheime Schlüssel zum eingebauten öffentlichen passt.

-Lokal signiert `build-release.sh` nur, wenn `MINISIGN_SECRET_KEY` gesetzt und `rsign` installiert ist. In der CI ist die Signatur Pflicht (`INK_NOTES_REQUIRE_SIGNATURE=1`), und das Skript prüft, dass der geheime Schlüssel zum eingebauten öffentlichen Schlüssel passt.
+### CI-Runner (act_runner)

-### 2. Installation auf Zorin OS 18 / Ubuntu 24.04
+Der Workflow läuft auf dem Label `ubuntu-latest`. Im `config.yaml` des Runners muss es zugeordnet sein, z. B.:

-```bash
-# Natives Debian-Paket installieren
-sudo dpkg -i target/ink-notes_0.1.0_amd64.deb
-
-# Oder portables AppImage starten
-chmod +x target/ink-notes_0.1.0_x86_64.AppImage
-./target/ink-notes_0.1.0_x86_64.AppImage
-```
-
-#### Hinweise zu AppImage, glibc & FUSE:
- **glibc-Mindestversion:** `ink-notes` benötigt `glibc >= 2.39` (Standard unter Ubuntu 24.04 LTS und Zorin OS 18).
- **Host-Grafikstack:** Das AppImage bündelt die Anwendungslogik, nutzt für maximale Performance und Hardwarebeschleunigung jedoch den Treiber- und Grafikstack des Host-Systems (Vulkan ICD-Treiber, Wayland bzw. X11).
- **FUSE 2 / FUSE 3 Kompatibilität:** Ubuntu 24.04-basierte Distributionen nutzen standardmäßig FUSE 3 (`fuse3`). Sollte das AppImage beim Start einen Fehler bezüglich `libfuse.so.2` ausgeben, kann entweder das Kompatibilitätspaket installiert werden:
-  ```bash
-  sudo apt install libfuse2t64
-  ```
-  oder das AppImage direkt ohne FUSE entpackt und ausgeführt werden:
-  ```bash
-  ./ink-notes_0.1.0_x86_64.AppImage --appimage-extract-and-run
-  ```
-
-### 3. Release auf Gitea veröffentlichen
-
-Das Skript arbeitet vollkommen idempotent und aktualisiert bei wiederholter Ausführung Release-Notizen und Assets:
-
-```bash
-export GITEA_TOKEN="<DEIN_GITEA_TOKEN>"
-./scripts/publish-gitea-release.sh
-```
-
---
-
-## 🛡️ Updater-Sicherheit
-
-Der In-App-Updater (`src/updater.rs`) folgt strengen Sicherheitsrichtlinien:
-
-1. **Minisign-Signatur (Pflicht):**
-   - Jedes Release enthält `SHA256SUMS.txt.minisig`, eine Minisign-Signatur der Prüfsummendatei.
-   - Der Updater lädt `SHA256SUMS.txt` und die Signatur **vor** dem Paket und prüft sie gegen den in die App eingebauten öffentlichen Schlüssel (`UPDATE_SIGNING_PUBLIC_KEY` in `src/updater.rs`, Crate `minisign-verify`).
-   - Fehlt die Signatur, ist sie ungültig oder ist kein Schlüssel eingebaut, wird das Update abgelehnt. Ein kompromittierter Release-Server kann so keine manipulierten Pakete ausliefern.
-2. **SHA-256-Integritätsprüfung:**
-   - Der SHA-256-Hash des heruntergeladenen Pakets wird mit dem Eintrag in der signierten `SHA256SUMS.txt` verglichen (`sha2`).
-   - Weicht die Prüfsumme ab oder fehlt ein Eintrag, wird die Datei sofort gelöscht und der Installationsvorgang mit Fehlermeldung abgebrochen.
-3. **Redirect-Schutz & HTTPS:**
-   - Jede Anfrage erzwingt HTTPS – auch Download-Links aus der Release-API und jedes Weiterleitungsziel.
-   - Bei HTTP-Redirects werden sensible Autorisierungs-Header (`Authorization: token ...`) verworfen, sobald die Weiterleitung auf eine andere Origin oder ein externes CDN verweist.
-4. **Isolierter Download-Pfad & Path-Traversal-Schutz:**
-   - Downloads werden in einem isolierten Benutzerverzeichnis abgelegt (`$XDG_CACHE_HOME/ink-notes/updates` bzw. `~/.cache/ink-notes/updates`, Berechtigung `0700`).
-   - Asset-Namen werden sanitisiert: Pfadtrenner (`/`, `\`), Pfadüberquerungen (`..`), Steuerzeichen und leere Dateinamen werden strikt abgewiesen.
-5. **Atomarer AppImage-Tausch:**
-   - Kein direktes Überschreiben laufender Programmdateien per `fs::copy` (verhindert den Linux-Kernel-Fehler *"Text file busy"*).
-   - Die neue Datei wird temporär im selben Verzeichnis angelegt (`<name>.new.<pid>`), mit Ausführungsrechten (`0755`) versehen, das bestehende AppImage als `<name>.bak` gesichert (dessen Fehler nicht ignoriert werden) und anschließend per atomarem `fs::rename` ausgetauscht.
-
---
-
-## ⚙️ CI-Runner einrichten (Gitea Actions / act_runner)
-
-Der Veröffentlichungs-Workflow liegt unter [`.gitea/workflows/release.yaml`](.gitea/workflows/release.yaml).
-
-### Runner-Label konfigurieren
-Der Workflow nutzt standardmäßig das Runner-Label:
-```yaml
-runs-on: ubuntu-latest
-```
-
-In der Konfigurationsdatei Ihres Gitea `act_runner` (`config.yaml`) muss dieses Label auf ein passendes Container-Image oder den Host gemappt sein:
 ```yaml
 runner:
  labels:
    - "ubuntu-latest:docker://catthehacker/ubuntu:act-latest"
-    # oder für native Host-Ausführung:
-    # - "ubuntu-latest:host"
 ```

-### Diagnose & Fehlerbehebung
-Bleibt ein Release-Job auf **"Waiting to run"** hängen:
-1. **Runner online?** Prüfen Sie in Gitea unter *Einstellungen -> Aktionen -> Runner*, ob der `act_runner` aktiv und mit einem grünen Punkt als *Online* markiert ist.
-2. **Label-Übereinstimmung:** Stimmen die im Runner registrierten Labels exakt mit dem `runs-on`-Feld in `.gitea/workflows/release.yaml` überein?
-3. **Rechte:** Der Workflow prüft `if [ "$(id -u)" -ne 0 ]` und setzt `sudo` nur ein, wenn der Runner nicht als `root` läuft. Das verhindert Fehler sowohl in unprivilegierten Host-Umgebungen als auch in Root-Containern.
+Bleibt ein Job auf „Waiting to run“ stehen: Ist der Runner online (*Einstellungen → Aktionen → Runner*) und stimmt das Label mit `runs-on` überein? `sudo` verwendet der Workflow nur, wenn der Runner nicht als `root` läuft.

 ---

-## 🚀 Schnellstart (Entwicklung)
+## Sicherheit der Updates

-### Voraussetzungen
- **Rust & Cargo:** Version 1.75 oder neuer (`rustup update stable`)
- **System-Bibliotheken (Linux):**
-  - Vulkan-Treiber (z. B. `mesa-vulkan-drivers` oder proprietäre Treiber)
-  - X11 / Wayland Bibliotheken (`libx11-dev`, `libxcursor-dev`, `libxrandr-dev`, `libxi-dev`, `libxkbcommon-dev`)
-
-### Bauen & Ausführen
-
-```bash
-# Repository klonen
-git clone https://gitea.pansi.eu/harald/ink-notes.git
-cd ink-notes
-
-# Kompilieren und starten via Starter-Skript
-./run.sh
-```
-
-Alternativ direkt mit Cargo:
-
-```bash
-cargo run --release
-```
+1. **Signatur:** Jedes Release enthält `SHA256SUMS.txt.minisig`. Die App lädt `SHA256SUMS.txt` und die Signatur vor dem Paket und prüft sie gegen den eingebauten öffentlichen Schlüssel (`minisign-verify`). Ohne gültige Signatur wird nicht installiert.
+2. **Prüfsumme:** Der SHA-256-Wert des heruntergeladenen Pakets muss zum Eintrag in der signierten Liste passen, sonst wird die Datei gelöscht.
+3. **Nur HTTPS:** Auch Download-Links und Weiterleitungen müssen HTTPS sein. Bei Weiterleitungen auf einen anderen Server wird der `Authorization`-Header nicht mitgeschickt.
+4. **Eigener Download-Ordner:** `~/.cache/ink-notes/updates` (Rechte `0700`); Dateinamen mit Pfadtrennern, `..` oder Steuerzeichen werden abgelehnt.
+5. **AppImage-Austausch:** Die neue Datei wird neben der alten angelegt, die alte als `.bak` gesichert und dann per `rename` ersetzt – die laufende Datei wird nie überschrieben.

 ---

-## ⌨️ Tastatur- & Maus-Shortcuts
+## Lizenz

-| Aktion | Tastenkürzel / Mausgeste |
-| :--- | :--- |
-| **Zeichnen** | Linke Maustaste / Stiftspitze |
-| **Canvas verschieben (Pan)** | Mittlere Maustaste **oder** `Leertaste + Drag` |
-| **Scrollen (durchgehende Ansicht)** | Mausrad (`Umschalt` = waagerecht) / ein Finger |
-| **Zoom zentriert auf Cursor** | `Strg + Mausrad` / Touchpad-Pinch (Einzelseiten-Ansicht: Mausrad) |
-| **Zoom zurücksetzen (100 %)** | `Strg + 0` |
-| **Zoom In / Out** | `Strg + +` / `Strg + -` |
-| **Auswahlwerkzeug (Lasso)** | `V` |
-| **Text-Werkzeug** | `T`, dann ins Blatt klicken; `Esc` beendet die Eingabe |
-| **Auswahl um 90° drehen** | `R` |
-| **Kopieren & Einfügen** | `Strg + C` / `Strg + V` |
-| **Auswahl löschen** | `Entf` oder `Backspace` |
-| **Undo / Redo** | `Strg + Z` / `Strg + Y` (oder `Strg + Shift + Z`) |
-| **Nächste Seite** | `Bild ab (PageDown)` oder `N` |
-| **Vorherige Seite** | `Bild auf (PageUp)` |
-| **Erste / Letzte Seite** | `Pos 1 (Home)` / `Ende (End)` |
-| **Jetzt speichern (Disk Flush)** | `Strg + S` |
-| **Vektor-PDF-Export** | `Strg + E` |
-| **Dialoge / Menüs schließen** | `Esc` |
-| **Beenden (mit Disk-Flush)** | `Strg + Q` (oder Fenster schließen) |
-
---
-
-## 🏗️ Projekt- und Modul-Architektur
-
-```text
-src/
-├── main.rs         # Event-Loop (winit), Input-Routing, App-Orchestrierung
-├── lib.rs          # Bibliotheks-Exporte für Tests und Komponenten
-├── canvas.rs       # wgpu Render-Pipeline, GPU-Buffer, Zeichenzustand
-├── viewport.rs     # Kamera-Pan, Zoom, 2D-Transformationsmatrizen
-├── shader.wgsl     # WGSL Vertex- & Fragment-Shader für Inking-Meshes
-├── filter.rs       # One-Euro-Filter gegen Eingabe-Jitter
-├── spline.rs       # Catmull-Rom, Corner Preservation & Dreiecksstreifen
-├── geometry.rs     # RDP-Algorithmus, Least-Squares Circle Fit, Shape Recognition
-├── selection.rs    # Lasso-Auswahl, Bounding-Box, Griffe, Rotation & Skalierung
-├── background.rs   # Tessellierung für Kariert, Liniert, Punktraster
-├── document.rs     # Notizbuch-Datenmodell, Seiten, DIN-A4-Koordinatensystem
-├── history.rs      # Undo/Redo-Transaktionsstapel (Add, Erase, Transform)
-├── storage.rs      # Atomares Laden/Speichern von Manifest & Seiten, Multi-Notebooks
-├── autosave.rs     # Debounced Hintergrund-Autosave mit MPSC-Kanal
-├── updater.rs      # In-App Gitea Updater (SemVer, HTTPS, SHA256-Integrität, Self-Update)
-├── export.rs       # Skalierbarer Vektor-PDF-Export via printpdf
-└── ui.rs           # Floating Glassmorphism-Toolbar, Dokumenten- & Update-Manager (egui)
-```
-
-Ausführliche Details zur Architektur und mathematischen Modellen findest du unter [`docs/ARCHITECTURE.md`](docs/ARCHITECTURE.md).
-
---
-
-## 🧪 Tests ausführen
-
-Die gesamte Inking-Pipeline, Geometrieerkennung, Speicherlogik und der Updater sind mit umfassenden Unit-Tests abgesichert:
-
-```bash
-cargo test
-```
-
-Alle Unit-Tests prüfen Berechnungen, Hit-Testing, Undo/Redo, Persistenz, Updater-Sicherheit und Versionsvergleiche konsistent ab.
-
---
-
-## 📄 Lizenz
-
-Dieses Projekt ist unter der [MIT-Lizenz](LICENSE) lizenziert (Copyright © 2026 Harald Pansi).
+[MIT](LICENSE), Copyright © 2026 Harald Pansi.
@@ -1,153 +1,190 @@
-# Architektur & Technische Dokumentation von ink-notes
+# Architektur von ink-notes

-Dieses Dokument beschreibt die interne Architektur, mathematische Modelle und Rendering-Pipelines von `ink-notes`.
+Dieses Dokument beschreibt, wie ink-notes intern aufgebaut ist: Eingabe und Strichverarbeitung, Rendering, Seiten und Ansicht, Formerkennung, Speichern und Export. Das Speicherformat steht in [`FILE_FORMAT.md`](FILE_FORMAT.md).

 ---

-## 1. Die Inking-Pipeline
+## 1. Überblick
+
+ink-notes ist ein einzelnes Programm mit einem Event-Loop (`winit`) im Haupt-Thread. Dazu kommen drei Hintergrund-Threads:
+
+| Thread | Aufgabe |
+| :--- | :--- |
+| Haupt-Thread | Eingaben, Datenmodell, Rendering (`wgpu`), Oberfläche (`egui`) |
+| Autosave | Seiten und Manifest auf die Festplatte schreiben (`autosave.rs`) |
+| PDF-Rendering | Importierte PDF-Seiten zu Texturen rendern (`pdf_doc.rs`, `hayro`) |
+| Export | PDF/PNG/SVG-Export, damit die Oberfläche nicht hängt (`main.rs`) |
+
+Stifteingaben kommen über `octotablet` (Tablet-Protokoll von Wayland bzw. X11), Maus und Touch über `winit`. Die Oberfläche (Werkzeugleiste, Menüs, Dialoge, Textbearbeitung) ist mit `egui` gebaut und wird im selben Render-Durchgang über das Blatt gezeichnet.
+
+---
+
+## 2. Vom Stift zum Strich

 ```
-[Hardware Stylus / Touch / Maus]
-              │
-              ▼
-       [winit Event-Loop]
-              │ (tx, ty, pressure, timestamp)
-              ▼
-   [Viewport Invertierung]  (screen_to_page: Umrechnung in DIN-A4-Einheiten)
-              │
-              ▼
-       [1€-Filter]          (Jitter-Beseitigung bei langsamen Bewegungen)
-              │
-              ▼
- [Centripetal Catmull-Rom]  (C1-stetige Spline-Interpolation, alpha = 0.5)
-              │
-              ▼
-   [Mesh-Tessellierung]     (Drucksensitive Dreiecksstreifen via Normalen)
-              │
-              ▼
-       [wgpu GPU-Buffer]    (Vertex- & Index-Buffer im VRAM)
+[Stift / Touch / Maus]
+          │  Bildschirmposition, Druck, Zeit
+          ▼
+[Bildschirm → Seitenkoordinaten]   (viewport.rs)
+          │
+          ▼
+[Druckkurve]                        (settings.rs, vom Nutzer einstellbar)
+          │
+          ▼
+[1€-Filter]                         (filter.rs)
+          │
+          ▼
+[Catmull-Rom-Spline + Dreiecksstreifen]   (spline.rs) → Live-Puffer auf der GPU
+          │  Stift abgehoben
+          ▼
+[Nachbearbeitung]                   (spline.rs: finalize_stroke)
+          │
+          ▼
+[Strich auf der Seite + Undo-Eintrag]   (document.rs, history.rs)
 ```

-### 1.1. 1€-Filter (One-Euro-Filter)
-Stift- und Touch-Eingaben unterliegen bei niedrigen Geschwindigkeiten oft Mikrozittern (Jitter). Standard-Tiefpassfilter verursachen jedoch bei schnellen Schwüngen eine störende Verzögerung (Latenz).
+### 2.1 1€-Filter
+Langsame Bewegungen zittern, schnelle sollen nicht nachhinken. Der 1€-Filter (`filter.rs`) passt seine Grenzfrequenz an die Geschwindigkeit an:

-Der 1€-Filter (`filter.rs`) löst dieses Dilemma mit einer adaptiven Grenzfrequenz $f_c$:
 $$f_c = f_{c,\min} + \beta \cdot |\dot{x}|$$
- Bei geringer Geschwindigkeit ($|\dot{x}| \approx 0$) dominiert $f_{c,\min}$, wodurch Zittern maximal geglättet wird.
- Bei schnellen Zügen wächst $\beta \cdot |\dot{x}|$ an, wodurch der Filter durchlässig wird und Latenz eliminiert.

-### 1.2. Centripetal Catmull-Rom Splines
-Um Ecken zu vermeiden und eine organische Schriftführung zu erzielen, werden Abtastpunkte mit einem zentripetalen Catmull-Rom-Spline (`spline.rs`) interpoliert ($\alpha = 0.5$):
-$$t_{i+1} = t_i + ||P_{i+1} - P_i||^\alpha$$
-Diese Parametrisierung garantiert:
- Keine Selbstüberschneidungen bei scharfen Wendungen.
- Keine unerwünschten Cusp-Schleifen.
- Perfekte $C^1$-Stetigkeit an den Stützstellen.
+Bei langsamer Bewegung glättet er stark, bei schneller kaum.

-### 1.3. Drucksensitive Dreiecksstreifen (Tessellierung)
-Aus den interpolierten Spline-Punkten mit Radius $r_i = f(\text{pressure}_i)$ wird ein Triangle-Strip erzeugt:
-1. Richtungsvektor $T_i = P_{i+1} - P_i$.
-2. Senkrechter Normalenvektor $N_i = (-T_{i,y}, T_{i,x}) / ||T_i||$.
-3. An inneren Stützstellen werden Normalen benachbarter Segmente gemittelt (Winkelhalbierende).
-4. Eckpunkte des Dreiecksstreifens:
-   $$V_{i,\text{left}} = P_i + N_i \cdot r_i, \quad V_{i,\text{right}} = P_i - N_i \cdot r_i$$
+### 2.2 Zentripetaler Catmull-Rom-Spline
+Die gefilterten Punkte werden mit einem zentripetalen Catmull-Rom-Spline ($\alpha = 0{,}5$) interpoliert:

-### 1.4. Zwei-Stufen-Modell (Live-Glättung vs. akausale Post-Stroke-Finalisierung)
-Um minimale Latenz beim Zeichnen mit maximaler Präzision und Ecken-Erhaltung zu verbinden, arbeitet `ink-notes` mit einem strikten Zwei-Stufen-Modell:
+$$t_{i+1} = t_i + \lVert P_{i+1} - P_i \rVert^{\alpha}$$

-1. **Live-Phase (Kausal, Zero-Latency):**
-   - Eingehende Punkte durchlaufen in Echtzeit den 1€-Filter (`filter.rs`).
-   - `spline.rs` tesselliert inkrementell temporäre Triangle-Strips für die unverzögerte Bildschirmdarstellung im GPU-Live-Buffer.
-2. **Commit-Phase (Akausal, `finalize_stroke`):**
-   - Beim Absetzen des Stifts wird der gesamte Strich akausal analysiert:
-     - **Druckglättung:** Glättung des Druckverlaufs $p$ über ein gewichtetes 3-Punkt-Fenster $[0.25, 0.5, 0.25]$ zur Ausblendung von Digitalisierer-Stufen.
-     - **RDP-Dezimierung:** Ausdünnung kollinearer Zwischenpunkte mit Ramer-Douglas-Peucker ($\epsilon \approx 0.075\text{ mm} = 0.75\text{ Einheiten}$).
-     - **Ecken-Erkennung (Corner Preservation):** Bei Richtungsänderungen $> 65^\circ$ wird die $C^1$-Spline-Kontinuität zu $C^0$ aufgebrochen, sodass Ecken (z. B. 90°-L-Knicke oder Zickzack-Linien) gestochen scharf bleiben und nicht rundgeschliffen werden.
-     - **Runde Kappen & Miter-Joins:** Generierung sauberer runder Kappen an Start und Ende des Triangle-Strips.
-   - Der temporäre Live-Buffer wird vollständig entleert und der bereinigte `Stroke` in den persistenten Puffer der Seite überführt.
+Diese Parametrisierung erzeugt bei engen Kurven keine Schlaufen oder Spitzen und ist an den Stützstellen $C^1$-stetig.
+
+### 2.3 Dreiecksstreifen
+Aus den Spline-Punkten mit Radius $r_i$ (aus Druck und Strichstärke) entsteht ein Dreiecksstreifen:
+
+$$V_{i,\text{links}} = P_i + N_i \cdot r_i, \qquad V_{i,\text{rechts}} = P_i - N_i \cdot r_i$$
+
+$N_i$ ist die Normale der Laufrichtung; an inneren Punkten wird über benachbarte Segmente gemittelt.
+
+### 2.4 Zwei Stufen
+1. **Während des Schreibens:** Filter und Spline arbeiten nur mit bisherigen Punkten; der Strich wird sofort in einen eigenen Live-Puffer geschrieben.
+2. **Beim Absetzen** wird der ganze Strich noch einmal bearbeitet (`finalize_stroke`):
+   - Druckverlauf mit dem Fenster $[0{,}25;\ 0{,}5;\ 0{,}25]$ glätten,
+   - Punkte mit Ramer-Douglas-Peucker ausdünnen ($\varepsilon = 0{,}75$ Einheiten $= 0{,}075$ mm),
+   - an Knicken über 65° den Spline auftrennen, damit Ecken nicht abgerundet werden,
+   - runde Endkappen anfügen.
+
+   Danach wird der Live-Puffer geleert und der Strich in die Seite übernommen.
+
+### 2.5 Lineal
+Beginnt ein Strich nahe einer Linealkante (`ruler.rs`), werden alle seine Punkte auf diese Kante projiziert, bis der Stift abgehoben wird.

 ---

-## 2. Rendering & Kamera-Pipeline (`wgpu`)
+## 3. Koordinaten, Seiten und Ansicht

-### 2.1. Virtuelles Koordinatensystem
-Die Anwendung rechnet intern in virtuellen DIN-A4-Koordinaten:
- Breite: **2100 Einheiten** (210 mm)
- Höhe: **2970 Einheiten** (297 mm)
- 1 mm entspricht exakt **10 Einheiten**.
+### 3.1 Seitenkoordinaten
+Gerechnet wird in Seiteneinheiten: **10 Einheiten = 1 mm**. Eine DIN-A4-Seite ist 2100 × 2970 Einheiten groß. Jede Seite hat ihre eigene Größe (`Page::size`): Standard ist A4 hoch; beim PDF-Import bekommen Querformat-Seiten 2970 Einheiten Breite und eine Höhe nach Seitenverhältnis (`document::pdf_page_size`). Neue Seiten übernehmen die Größe der aktuellen.

-### 2.2. Viewport & Projektionsmatrix (`viewport.rs`)
-Der Vertex-Shader transformiert DIN-A4-Koordinaten über eine Orthogonal-Projektion kombiniert mit Pan und Zoom in Normalized Device Coordinates (NDC, $[-1, 1]$):
+### 3.2 Maßstab und Kamera
+- `PageViewport` (`document.rs`) passt einen Rahmen, in den alle Seiten des Notizbuchs passen (`Notebook::fit_box`), ins Fenster ein. Daraus ergibt sich ein Maßstab (Bildschirmpixel je Einheit), der für alle Seiten gilt. Die aktuelle Seite liegt waagerecht zentriert und oben im Rahmen. Den Platz der Werkzeugleiste rechnet der Viewport heraus.
+- `ViewportState` (`viewport.rs`) ergänzt Zoom (25 % bis 1000 %) und Verschiebung (Pan). Beim Zoomen bleibt der Punkt unter dem Mauszeiger stehen:

-```wgsl
-struct CameraUniform {
-    transform: mat4x4<f32>,
-};
-```
-
-Die Projektionsmatrix $M$ wird berechnet aus:
-1. Skalierung des DIN-A4-Papiers auf den Viewport unter Berücksichtigung des Seitenverhältnisses.
-2. Anwenden des Zoom-Faktors $z \in [0.25, 5.0]$.
-3. Translation durch den Pan-Offset $(p_x, p_y)$.
-
-### 2.3. Cursor-zentrierter Zoom
-Beim Zoomen mit dem Mausrad wird der neue Pan-Offset so korrigiert, dass der Punkt unter dem Cursor fixiert bleibt:
 $$\vec{p}_{\text{neu}} = \vec{c} - (\vec{c} - \vec{p}_{\text{alt}}) \cdot \frac{z_{\text{neu}}}{z_{\text{alt}}}$$

-### 2.4. Render-Passes
-In jedem Frame werden zwei Hauptpässe durchlaufen:
-1. **Pass 1 (Canvas):**
-   - Hintergrund-Quad und Linien/Gitter (Instanced oder Batch Vertex-Buffer).
-   - Gespeicherte Striche und Geometrie-Meshes.
-   - Aktiver Live-Strich (Ephemeral Buffer).
-   - Auswahl-Overlay & Transformationsgriffe.
-2. **Pass 2 (egui UI):**
-   - Floating Glassmorphism-Toolbar.
-   - Farb- und Werkzeug-Popovers.
-   - Modal-Dokumentenmanager.
+- Im Shader wird jeder Punkt mit `transform_scale` und `transform_offset` (aus `CameraUniforms`) direkt in Gerätekoordinaten umgerechnet.
+
+### 3.3 Durchgehende Ansicht
+Alle Koordinaten beziehen sich auf die **aktuelle Seite**. `PageStack` (`viewport.rs`) legt die übrigen Seiten mit 8 mm Abstand darunter bzw. darüber, waagerecht zur aktuellen Seite zentriert. Jede sichtbare Nachbarseite wird mit einer eigenen Kamera gezeichnet, die um die Lage der Seite verschoben ist (höchstens 12 Nachbarseiten).
+
+Nach dem Scrollen wird die Seite in der Fenstermitte zur aktuellen Seite; die Kamera wird dabei so verschoben, dass sich das Bild nicht bewegt. Während eines Strichs, einer Auswahl, beim Ziehen des Lineals oder beim Schreiben von Text wird nicht gewechselt. Wer auf einer sichtbaren Nachbarseite zu zeichnen beginnt, wechselt zuerst auf diese Seite.

 ---

-## 3. Geometrieerkennung & Shape-Fitting (`geometry.rs`)
+## 4. Rendering

-Die Erkennung erfolgt rein analytisch und deterministisch ohne schwere ML-Frameworks:
+Ein Frame besteht aus einem Render-Durchgang auf die Fensterfläche (`canvas.rs`):

-### 3.1. Ramer-Douglas-Peucker (RDP)
-Reduziert den Rohpfad auf signifikante Eckpunkte mit konfigurierbarem Toleranzabstand $\epsilon$.
+1. Für jede sichtbare Nachbarseite: Papier und Muster, Bilder/PDF-Seite/Text, Tinte.
+2. Für die aktuelle Seite: Papier, Muster (Karo, Linien, Punkte), Bildebene, gespeicherte Striche, Live-Strich.
+3. Die `egui`-Oberfläche: Werkzeugleiste, Menüs, Auswahlrahmen und Griffe, Lineal, Textbearbeitung.

-### 3.2. Erkennungsregeln:
- **Gerade:** Verhältnis von Sehnenlänge ($||P_{\text{end}} - P_{\text{start}}||$) zur Pfad-Bogenlänge $> 0.92$.
- **Rechteck:** RDP liefert 4 dominante Ecken; Kantenwinkel liegen zwischen $75^\circ$ und $105^\circ$.
- **Kreis / Ellipse:** Pfad ist geschlossen ($||P_{\text{start}} - P_{\text{end}}|| < 0.1 \times \text{Umfang}$); Standardabweichung der Radien vom Mittelpunkt ist minimal ($< 0.12 \times \bar{r}$).
- **Koordinatensystem:** Zwei orthogonale Schenkel mit Schnittpunkt nahe dem Start/Ende; Winkel $80^\circ$ bis $100^\circ$ wird exakt auf $90^\circ$ eingerastet; positive Achsenenden erhalten Pfeilspitzen.
- **Dreiecke / Rhomben / Oktaeder:** Spezifische Eckpunkt- und Symmetrieanalysen der RDP-Kontur.
+### 4.1 Bildebene
+`image_layer.rs` zeichnet texturierte Vierecke unter der Tinte: importierte PDF-Seiten, eingefügte Bilder und Textfelder. Texturen werden beim ersten Bedarf geladen, bekommen Mipmaps und werden freigegeben, wenn mehr als 384 MB belegt sind.
+- **PDF-Seiten** rendert ein Hintergrund-Thread mit `hayro` (längste Kante 2560 Pixel, beim starken Hineinzoomen 5120 Pixel). Bis die schärfere Fassung fertig ist, bleibt die vorhandene sichtbar.
+- **Textfelder** werden mit `ab_glyph` gerastert, in einer Auflösung, die dem Zoom folgt (in Vierteln einer Zweierpotenz, höchstens 8 Pixel je Einheit). Der Texturschlüssel enthält einen Hash von Inhalt, Schrift und Farbe; jede Änderung erzeugt eine neue Textur.

-### 3.3. Draw-and-Hold Erkennung
-Hält der Anwender den Stift am Ende eines Strichs für $> 400\text{ ms}$ innerhalb eines Radius von $< 3\text{ px}$ ruhig, wird die Form im fliegenden Wechsel als Vektorform visualisiert und beim Abheben des Stifts fixiert.
+### 4.2 Papier- und Musterfarben
+Papierfarbe (`PaperTheme`) und Musterfarbe (`PatternColor`) stehen in `background.rs`. Alle Farben sind linear; die Fensterfläche ist sRGB, die Umrechnung übernimmt die GPU. Auf dunklem Papier kann der Shader dunkle Tinte aufhellen (`ink_params` in `CameraUniforms`), gespeichert werden immer die Originalfarben.

 ---

-## 4. Persistenz & Autosave-Architektur (`storage.rs`, `autosave.rs`)
+## 5. Objekte auf der Seite
+
+Alles auf einer Seite ist ein `Stroke` (`document.rs`):
+- **Tinte:** Abtastpunkte, Werkzeug (Stift, Textmarker, Form), Breite, Farbe; die Dreiecke werden beim Laden aus den Punkten neu berechnet.
+- **Formen:** zusätzlich eine `RecognizedShape` (siehe Abschnitt 6).
+- **Bilder und Textfelder:** vier Eckpunkte (oben links, oben rechts, unten rechts, unten links) plus Verweis auf die Bilddatei bzw. ein `TextBox`. Weil die Ecken normale Punkte sind, wirken Verschieben, Drehen und Skalieren der Auswahl ohne Sonderfälle.
+
+### 5.1 Textfelder
+`text.rs` setzt den Text selbst: Zeilenumbruch an Leerzeichen (zu lange Wörter zeichenweise), Unterschneidung, Tabulator = 4 Leerzeichen. Bildschirm-Textur, PDF-Export und Bearbeitung verwenden dieselben Schriften (Ubuntu Light und Hack aus den eingebauten `egui`-Schriften) und denselben Umbruch. Bearbeitet wird in einem `egui`-Textfeld an der Stelle des Felds; danach wird die Höhe des Felds an den Text angepasst, Lage, Drehung und Skalierung bleiben.
+
+### 5.2 Rückgängig
+Jede Seite hat einen eigenen Verlauf (`history.rs`): Hinzufügen, Entfernen, Ersetzen und Ändern von Strichen. Verschieben/Drehen/Skalieren einer Auswahl, ein Radierzug mit dem Teilstrich-Radierer und eine Textbearbeitung sind jeweils ein Schritt.
+
+---
+
+## 6. Formerkennung
+
+`geometry.rs` erkennt Formen rein geometrisch, ohne Machine Learning. Geschlossene Formen (Kreis, Ellipse, Dreieck, Rechteck, Raute) treten gegeneinander an; gewählt wird die, deren Umriss am besten zu den Punkten passt. Danach folgen Vielecke, Pfeile, Koordinatensysteme und Linien. Übernommen wird eine Form nur, wenn der Strich im Mittel höchstens 4 % seiner Diagonale von ihr abweicht – sonst bleibt er Handschrift.
+
+- **Linie:** Verhältnis von Abstand Anfang–Ende zur Strichlänge über 0,92.
+- **Kreis, Ellipse:** Kreis- bzw. Ellipsen-Fit über die Punkte.
+- **Rechteck, Dreieck, Raute, Vieleck, Pfeil:** Analyse der mit Douglas-Peucker vereinfachten Kontur (Eckenzahl, Winkel, Seitenverhältnisse).
+- **Koordinatensystem:** zwei etwa rechtwinklige Achsen; der Winkel wird auf 90° gesetzt.
+- **Oktaeder:** Skizze einer Doppelpyramide als 3D-Kantenmodell; nur, wenn kein einfacher Umriss passt.
+
+**Halten am Strichende:** Bleibt der Stift über 400 ms innerhalb von 3 Pixeln ruhig, wird die erkannte Form schon vor dem Absetzen angezeigt und beim Absetzen übernommen. Mit dem Formen-Werkzeug wird jeder Strich beim Absetzen geprüft.
+
+---
+
+## 7. Speichern

 ```
-[UI / Inking Event]
-       │
-       ▼
- [mark_page_dirty]
-       │
-       ▼
-[AutosaveController] ──(1.5s Debounce)──► [Hintergrund-Thread (MPSC)]
-                                                   │
-                                                   ▼
-                                         [Temp-Datei *.tmp schreiben]
-                                                   │
-                                                   ▼
-                                         [Atomares std::fs::rename]
-                                                   │
-                                                   ▼
-                                         [manifest.json / page_<id>.json]
+[Änderung]
+    │  mark_page_dirty / mark_manifest_dirty
+    ▼
+[AutosaveController]  ── 1,5 s nach der letzten Änderung, spätestens nach 10 s ──►  [Autosave-Thread]
+                                                                                        │
+                                                                                        ▼
+                                                                 [temporäre Datei schreiben + fsync]
+                                                                                        │
+                                                                                        ▼
+                                                                 [rename über die alte Datei, Ordner-fsync]
 ```

- **Keine UI-Blockierung:** Disk-I/O erfolgt vollständig in einem dedizierten Worker-Thread.
- **Atomarität:** Daten werden stets zuerst in `.json.tmp` geschrieben und via `fs::rename` atomar ersetzt.
- **Verlustfreier Notizbuchwechsel:** Bei `switch_notebook_dir` wird synchron `flush()` aufgerufen, um alle ungespeicherten Daten des aktuellen Dokuments sicherzustellen, bevor der Pfad gewechselt wird.
+- Der Haupt-Thread schreibt nie selbst; er übergibt fertige Seitendaten an den Autosave-Thread.
+- Schlägt ein Schreibvorgang fehl, wird die Seite mit wachsendem Abstand (1 s bis 30 s) erneut versucht; der Status wird rot.
+- `flush()` schreibt alles Ausstehende und wartet darauf. Es läuft bei `Strg + S`, beim Wechsel des Notizbuchs und beim Beenden. Schlägt es beim Beenden fehl, bleibt die App offen und bietet Wiederholen oder einen Notfall-Export der ungespeicherten Seiten an (`~/.local/share/ink-notes/recovery/`).
+- Seiten werden erst beim Anzeigen geladen (Lazy Loading); Titel, Hintergrund und Größe stehen im Manifest, damit Seitenübersicht und durchgehende Ansicht sie vorher kennen.
+- Ein zweites Fenster mit demselben Notizbuch öffnet es schreibgeschützt (Sperrdatei).
+
+---
+
+## 8. Export
+
+`export.rs` erzeugt das PDF mit `printpdf`. Jede Seite bekommt ihre eigene Größe und diese Ebenen:
+
+1. **Background:** Karo, Linien oder Punkte in der gewählten Musterfarbe (immer auf weißem Papier).
+2. **PDF** (nur im Notfall): importierte PDF-Seite als Bild, falls sie sich nicht als Vektor übernehmen lässt.
+3. **Images:** eingefügte Bilder (höchstens 300 dpi).
+4. **Text:** Textfelder als echter Text mit eingebetteter Schrift (durchsuchbar, kopierbar). Jedes Feld liegt in einem eigenen Koordinatensystem, das eine Transformationsmatrix auf seine Ecken abbildet.
+5. **Ink:** Striche als gefüllte Polygone, Formen als Pfade.
+
+Importierte PDF-Seiten werden anschließend als Form-XObject unter die Seite gelegt (`pdf_merge.rs`), bleiben also Vektorgrafik. Seitentitel werden zu Lesezeichen.
+
+PNG und SVG einer Seite (`page_export.rs`) entstehen aus diesem PDF: `hayro` rastert es bzw. wandelt es in SVG um. So sehen alle Exporte gleich aus.
+
+---
+
+## 9. Updates
+
+`updater.rs` fragt die Gitea-Releases ab, vergleicht die Version (SemVer) und lädt auf Wunsch das passende Paket. Vor der Installation prüft er die Minisign-Signatur von `SHA256SUMS.txt` gegen den eingebauten Schlüssel und danach die SHA-256-Prüfsumme des Pakets. Ein AppImage wird per `rename` ersetzt; ein `.deb`-Paket wird mit `xdg-open` an die Softwareinstallation des Systems übergeben. Details im README unter „Sicherheit der Updates“.
@@ -1,137 +1,173 @@
-# Dateiformat & Speicherstruktur von ink-notes
+# Dateiformat von ink-notes

-Dieses Dokument beschreibt die Speicherstruktur, die JSON-Dateiformate und die Versionshistorie, mit denen `ink-notes` Dokumente auf dem Dateisystem ablegt.
+Dieses Dokument beschreibt, wo und wie ink-notes Notizbücher speichert, und die Versionen des Dateiformats. Aktuell ist **Version 8**.

 ---

-## 1. Verzeichnisstruktur
-
-Notizbücher werden standardmäßig unter dem XDG-Datenpfad gespeichert:
+## 1. Ordner

 ```text
-~/.local/share/ink-notes/
-└── notebooks/
-    ├── <notebook_id_1>/
-    │   ├── manifest.json
-    │   ├── manifest.json.v0.bak (optional, Migrations-Backup)
-    │   ├── page_1.json
-    │   ├── page_1.json.corrupt-1775460000 (optional, Quarantäne bei Parsefehlern)
-    │   ├── page_2.json
-    │   └── ...
-    └── <notebook_id_2>/
-        ├── manifest.json
-        └── page_1.json
+~/.local/share/ink-notes/              ($XDG_DATA_HOME/ink-notes)
+├── notebooks/
+│   ├── <notizbuch-id>/
+│   │   ├── manifest.json              Metadaten und Seitenreihenfolge
+│   │   ├── manifest.json.bak          Kopie des vorherigen Manifests
+│   │   ├── page_1.json                eine Datei je Seite
+│   │   ├── page_2.json
+│   │   ├── page_7.json.corrupt-<ts>   beiseitegelegte beschädigte Seite (falls vorgekommen)
+│   │   ├── assets/                    eingefügte Bilder und importierte PDFs
+│   │   │   ├── <sha256>.png
+│   │   │   └── <sha256>.pdf
+│   │   └── .lock                      Sperrdatei, solange das Notizbuch geöffnet ist
+│   └── .trash/                        gelöschte Notizbücher (<id>_<zeitstempel>)
+└── recovery/                          Notfall-Sicherungen ungespeicherter Seiten
+
+~/.config/ink-notes/ui.json            ($XDG_CONFIG_HOME) Einstellungen der Oberfläche
 ```

+- **Notizbuch-IDs** werden aus dem Titel und dem Zeitpunkt gebildet (z. B. `mathematik_1775460000`); das erste Notizbuch heißt `default`.
+- **Assets** sind nach dem SHA-256-Hash ihres Inhalts benannt; dasselbe Bild wird nur einmal gespeichert. Bilder werden als PNG oder (unverändert) JPEG abgelegt, PDFs unverändert.
+- Alle Dateien werden mit Rechten `0600`, Ordner mit `0700` angelegt.
+
 ---

-## 2. Dokumenten-Manifest (`manifest.json`)
-
-Das Manifest enthält Metadaten über das gesamte Dokument sowie die Reihenfolge und IDs aller Seiten:
+## 2. Manifest (`manifest.json`)

 ```json
 {
-  "format_version": 2,
-  "id": "notebook-a1b2c3d4",
-  "title": "Mathematik Vorlesung",
+  "format_version": 8,
+  "id": "vorlesung_1775460000",
+  "title": "Vorlesung",
+  "created_at": 1775460000,
+  "modified_at": 1775463600,
+  "current_page_index": 0,
  "pages": [
-    {
-      "id": 1,
-      "background": "Grid5mm"
-    },
-    {
-      "id": 2,
-      "background": "DotGrid"
-    }
+    { "id": 1, "background": "Blank", "title": "Einführung", "size": [2970.0, 1671.0] },
+    { "id": 2, "background": "Grid5mm" }
  ],
  "page_ids": [1, 2],
-  "current_page_index": 0,
-  "next_page_id": 3,
  "next_stroke_id": 42,
-  "created_at": 1775460000,
-  "modified_at": 1775463600
+  "next_page_id": 3
 }
 ```

-### Felder:
- `format_version`: Format-Versionsnummer (aktuell `2`, bei unversionierten Legacy-Dateien implizit `0`).
- `id`: Eindeutige ID des Notizbuchs (z. B. UUID oder `"default"`).
- `title`: Vom Nutzer vergebener Anzeigename des Notizbuchs.
- `pages`: Geordnete Liste von Seitenmetadaten (`id`, optional `background`).
- `page_ids`: Abwärtskompatible Liste der Seiten-IDs.
- `current_page_index`: Index der zuletzt aktiven Seite für Session-Restore.
- `next_page_id`: Inkrementierender ID-Zähler für neue Seiten.
- `next_stroke_id`: Globaler ID-Zähler für neue Striche.
- `created_at` / `modified_at`: UNIX-Zeitstempel in Sekunden.
+| Feld | Bedeutung |
+| :--- | :--- |
+| `format_version` | Formatversion (siehe Abschnitt 5) |
+| `id`, `title` | ID (= Ordnername) und Anzeigename |
+| `created_at`, `modified_at` | UNIX-Zeit in Sekunden |
+| `current_page_index` | zuletzt geöffnete Seite |
+| `pages` | Seiten in ihrer Reihenfolge: `id`, `background`, optional `title` und `size` (siehe unten) – damit Seitenübersicht und Ansicht sie kennen, ohne jede Seite zu laden |
+| `page_ids` | dieselbe Reihenfolge als reine ID-Liste (für ältere Versionen) |
+| `next_stroke_id`, `next_page_id` | nächste freie IDs |

 ---

-## 3. Seitendatei (`page_<id>.json`)
+## 3. Seite (`page_<id>.json`)

-Jede Seite wird in einer eigenen Datei gespeichert, um Lazy-Loading und schnelles inkrementelles Speichern zu ermöglichen.
-Die Speicherung erfolgt ab Version 2 als kompaktes JSON (`serde_json::to_vec`), wodurch gegenüber Pretty-Printed JSON über 50 % Speicherplatz eingespart wird.
+Jede Seite liegt in einer eigenen Datei (kompaktes JSON, hier zur Lesbarkeit umbrochen):

 ```json
-{"format_version":2,"id":1,"background":"Grid5mm","strokes":[{"id":1,"color":[0.12,0.12,0.14,1.0],"samples":[{"x":350.2,"y":420.5,"p":0.65,"t":12.345},{"x":352.1,"y":425.8,"p":0.70,"t":12.355}],"shape":null,"tool":"pen","width":5.0,"finalized":true},{"id":2,"color":[0.15,0.35,0.85,1.0],"samples":[],"shape":{"Rectangle":{"top_left":{"x":500.0,"y":600.0},"width":300.0,"height":200.0}},"tool":"shape","width":20.0,"finalized":true}]}
+{
+  "format_version": 8,
+  "id": 1,
+  "background": "Blank",
+  "title": "Einführung",
+  "size": [2970.0, 1671.0],
+  "pdf_background": { "asset": "<sha256>.pdf", "page": 0, "width_pt": 960.0, "height_pt": 540.0 },
+  "strokes": [ … ]
+}
 ```

-### Felder:
- `format_version`: Format-Versionsnummer (`2`).
- `id`: Eindeutige ID der Seite.
- `background`: Papiermuster (`Blank`, `Grid5mm`, `Lined`, `DotGrid`).
- `strokes`: Liste der auf der Seite gezeichneten Striche und Vektorformen.
-  - `id`: Eindeutige ID des Strichs.
-  - `color`: RGBA-Farbwerte im Bereich `[0.0, 1.0]`.
-  - `samples`: Rohabtastpunkte entlang des Pfads (`x`, `y` in DIN-A4-Einheiten, `p` Druckwert in `[0.0, 1.0]`, `t` Zeitstempel in Sekunden).
-  - `shape`: Optionales Enum für geometrische Vektorformen:
-    - `Line { start, end }`
-    - `Rectangle { top_left, width, height }`
-    - `Circle { center, radius }`
-    - `Axes { origin, x_end, y_end, has_arrows }`
-    - `Triangle { p1, p2, p3 }`
-    - `Rhombus { center, width, height }`
-    - `Octahedron { center, radius }`
-  - `tool`: Zeichenwerkzeug (`"pen"`, `"highlighter"`, `"shape"`).
-  - `width`: Strichbreite in internen DIN-A4-Einheiten (10 Einheiten = 1 mm; z. B. `5.0` für 0.5 mm Stift, `60.0` für 6.0 mm Marker).
-  - `finalized`: Boolesches Flag für Striche, die das Zwei-Stufen-Inking (Eckenerkennung, Glättung, runde Endkappen) durchlaufen haben.
+| Feld | Bedeutung |
+| :--- | :--- |
+| `background` | Muster: `Blank`, `Grid5mm`, `Lined`, `DotGrid` |
+| `title` | Seitentitel (optional) |
+| `size` | Seitengröße `[breite, höhe]` in Seiteneinheiten (10 = 1 mm); fehlt bei DIN A4 hoch (`[2100, 2970]`) |
+| `pdf_background` | importierte PDF-Seite als Hintergrund (optional): Datei, Seitennummer ab 0, Größe in Punkt |
+| `strokes` | alle Objekte der Seite, von unten nach oben |
+
+### 3.1 Objekte (`strokes`)
+
+Jedes Objekt hat eine `id`, eine `color` (RGBA, linear, Werte 0–1) und `samples`: Punkte mit `x`, `y` (Seiteneinheiten), `p` (Druck 0–1) und `t` (Zeit in Sekunden). Die Dreiecke für die Anzeige werden beim Laden aus den Punkten berechnet und nicht gespeichert.
+
+**Tinte**
+
+```json
+{ "id": 7, "color": [0.12, 0.12, 0.14, 1.0],
+  "samples": [{ "x": 350.2, "y": 420.5, "p": 0.65, "t": 12.345 }, …],
+  "tool": "pen", "width": 5.0, "finalized": true }
+```
+
+- `tool`: `pen`, `highlighter` oder `shape`
+- `width`: Strichbreite in Seiteneinheiten (5.0 = 0,5 mm)
+- `finalized`: Der Strich wurde nach dem Absetzen nachbearbeitet (Glättung, Ecken, Endkappen)
+
+**Formen** haben zusätzlich `shape`, z. B.:
+
+```json
+"shape": { "Rectangle": { "corners": [[500, 600], [800, 600], [800, 800], [500, 800]] } }
+```
+
+Mögliche Formen: `Line { start, end }`, `Arrow { start, end, double }`, `Circle { center, radius }`, `Ellipse { center, radius_x, radius_y, rotation }`, `Rectangle { corners }`, `Triangle { corners }`, `Rhombus { corners }`, `Polygon { vertices }`, `CoordinateSystem { origin, x_axis_end, y_axis_end, with_arrows }`, `Octahedron { … }`. Punkte sind `[x, y]`.
+
+**Bilder** haben `image` (Dateiname in `assets/`); die vier `samples` sind die Ecken oben links, oben rechts, unten rechts, unten links:
+
+```json
+{ "id": 9, "color": [1, 1, 1, 1], "samples": [ …4 Ecken… ], "width": 0.0, "image": "<sha256>.png" }
+```
+
+**Textfelder** haben `text`; die vier `samples` sind wie bei Bildern die Ecken des Felds:
+
+```json
+"text": { "content": "Überschrift\nzweite Zeile", "size": 42.3, "font": "Sans", "wrap_width": 1500.0 }
+```
+
+- `size`: Schriftgröße (Em) in Seiteneinheiten (12 pt ≈ 42,3)
+- `font`: `Sans` (Ubuntu Light) oder `Mono` (Hack)
+- `wrap_width`: Umbruchbreite in Seiteneinheiten; die Ecken bilden das Feld dieser Breite (und der Höhe des gesetzten Texts) ab, Drehung und Skalierung stecken in den Ecken

 ---

-## 4. Datensicherheit & Migration
+## 4. Sicherheit beim Speichern

-### Atomares Schreiben & Verzeichnis-Sync
-1. Daten werden in `<ziel>.tmp.<pid>.<nanos>` serialisiert und per `fsync` auf das Speichermedium geschrieben (Dateirechte `0600` auf Unix).
-2. Mittels `std::fs::rename("<ziel>.tmp", "<ziel>")` wird die Zieldatei auf POSIX-Systemen atomar ersetzt.
-3. Nach dem Rename wird das übergeordnete Verzeichnis synchronisiert (`sync_all()`), um Persistenz bei Stromausfall zu garantieren. Verzeichnisse erhalten Berechtigung `0700`.
+### Atomares Schreiben
+1. Der Inhalt wird in `<datei>.tmp.<pid>.<nanosekunden>` geschrieben und mit `fsync` auf den Datenträger gebracht.
+2. `rename` ersetzt die alte Datei in einem Schritt.
+3. Danach wird auch der Ordner mit `fsync` gesichert.

-### Quarantäne bei Parsefehlern
-Wird eine Seitendatei beim Laden als fehlerhaft erkannt (z. B. unvollständiges oder korruptes JSON), wird sie nicht stillschweigend gelöscht oder überschrieben, sondern nach `page_<id>.json.corrupt-<unix_ts>` verschoben. Die Ersatzseite wird als schreibgeschützt markiert.
+Ein Absturz während des Speicherns hinterlässt deshalb entweder die alte oder die neue Datei, nie eine halbe.

-### Migrations-Backups & Rolling Backups
-Beim ersten Speichern einer Datei im Legacy-Format (Version 0) wird vor dem Überschreiben ein Backup `*.v0.bak` angelegt (z. B. `manifest.json.v0.bak`, `page_1.json.v0.bak`).
-Zusätzlich existiert ein Rolling-Backup `manifest.json.bak`, auf das bei beschädigtem Manifest automatisch zurückgegriffen wird.
+### Beschädigte Dateien
+- Lässt sich eine Seite nicht lesen, wird sie nach `page_<id>.json.corrupt-<zeitstempel>` verschoben (nicht gelöscht) und die Seite schreibgeschützt angezeigt.
+- Ist `manifest.json` beschädigt oder fehlt, wird `manifest.json.bak` verwendet.
+
+### Neuere Versionen
+Dateien mit einer höheren `format_version` als der unterstützten werden nicht geöffnet – so kann eine ältere App-Version keine Inhalte verlieren, die sie nicht kennt.
+
+### Migration
+Beim ersten Speichern einer unversionierten Datei (Version 0) wird vorher eine Kopie `*.v0.bak` angelegt.

 ---

-## 5. Versionshistorie
+## 5. Versionen

-| Version | Status | Beschreibung |
-|---|---|---|
-| **0** | Legacy | Unversioniertes Format. `format_version` fehlt in JSON. Implizit als Version 0 interpretiert. |
-| **1** | Überholt | Einführung von `format_version: u32` in `manifest.json` und `page_<id>.json`. Seiten-Hintergrund im Manifest gecached (`pages: Vec<PageMeta>`). Strenges Versionsmatching (neuere Versionen werden abgelehnt). Automatische Migration mit `*.v0.bak`. |
-| **2** | **Aktuell** | Stroke-Treue: Ergänzung von `tool`, `width` und `finalized` in `StrokeData` für exakte Rekonstruktion aller Vertizes und Splines. Umstellung auf kompaktes JSON (`serde_json::to_vec`, ca. 54% Platzerparnis). |
+| Version | App | Änderung |
+| :--- | :--- | :--- |
+| 0 | – | ohne `format_version` |
+| 1 | – | `format_version`, Hintergründe im Manifest |
+| 2 | – | `tool`, `width`, `finalized` an Strichen; kompaktes JSON |
+| 3 | 0.3.7 | Formen `Ellipse` und `Arrow` |
+| 4 | 0.5 | Bilder (`image`, Ordner `assets/`) |
+| 5 | 0.6.1 | importierte PDF-Seiten (`pdf_background`) |
+| 6 | 0.7 | Seitentitel (`title` in Seite und Manifest) |
+| 7 | 0.10 | Textfelder (`text`) |
+| 8 | 0.11 | Seitengröße je Seite (`size` in Seite und Manifest) |
+
+Jede neue Version ändert nur Ergänzungen; ältere Dateien werden ohne Umwandlung gelesen und beim nächsten Speichern mit der aktuellen Versionsnummer geschrieben.

 ---

-## 6. Analyse & Bewertung: Binärformat (z. B. `postcard`)
+## 6. Warum JSON

-Eine Umstellung auf ein Binärformat wie `postcard` wurde evaluiert:
- **Vorteile**:
-  - Weitere 20–30 % Reduktion der Dateigröße gegenüber kompaktem JSON.
-  - Minimal schnellere Serialisierung auf leistungsschwachen Systemen.
- **Nachteile**:
-  - Verlust der Text-Transparenz (JSON lässt sich direkt inspizieren, mit `git`/Tools diffen und bei Korruption manuell reparieren).
-  - Snapshotting und JSON-Verarbeitung liegen im Benchmark bereits bei **0,02 ms (1k Samples)** bis **0,70 ms (50k Samples)** – also weit unter dem Zielwert von 1 ms.
-  - Kompaktes JSON spart bereits über 53 % Dateigröße ein.
- **Entscheidung**:
-  Kompaktes JSON bietet aktuell das optimale Verhältnis aus Ausfallsicherheit, Benutzerfreundlichkeit, Performance und Portabilität. Ein Binärformat wie `postcard` bleibt als Option für spätere Riesen-Notizbücher (> 500 Seiten) denkbar, wird aktuell jedoch nicht eingeführt.
+Ein Binärformat (z. B. `postcard`) würde Dateien um weitere 20–30 % verkleinern. JSON bleibt trotzdem, weil es sich ansehen, vergleichen und im Notfall von Hand reparieren lässt und das Speichern einer Seite auch bei vielen Strichen deutlich unter einer Millisekunde dauert.
@@ -2,13 +2,13 @@
 Version=1.0
 Name=ink-notes
 GenericName=Notizbuch- & Inking-App
-Comment=Latenzoptimierte Vektor-Notizen mit Stylus, Stift & Geometrie-Erkennung
+Comment=Handschriftliche Notizen mit Stift, Touch und Maus; PDFs beschriften
 Exec=ink-notes %F
 Icon=eu.pansi.ink-notes
 Terminal=false
 Type=Application
 Categories=Office;Graphics;Utility;
-Keywords=Note;Notiz;Pen;Stift;Ink;Inking;Stylus;Drawing;Zeichnen;PDF;Vector;
+Keywords=Note;Notiz;Pen;Stift;Ink;Inking;Stylus;Drawing;Zeichnen;PDF;Vector;Text;Annotation;
 StartupWMClass=ink-notes
 MimeType=application/x-inknotes;
 Actions=NewWindow;
@@ -4,20 +4,22 @@
  <metadata_license>CC0-1.0</metadata_license>
  <project_license>MIT</project_license>
  <name>ink-notes</name>
-  <summary>Latenzoptimierte Vektor-Notizbuch- und Inking-App für Linux</summary>
+  <summary>Notizbuch-App für Stift, Touch und Maus</summary>
  <description>
    <p>
-      ink-notes ist eine hardwarebeschleunigte, hochperformante Notizbuch- und Inking-Anwendung für Linux,
-      geschrieben in Rust mit wgpu. Sie bietet minimale Eingabelatenz mit Stylus, Touchpad oder Maus.
+      ink-notes ist eine Notizbuch-App für Linux, geschrieben in Rust mit wgpu. Handschrift wird als
+      Vektoren gespeichert; geschrieben wird mit Stift, Finger, Touchpad oder Maus.
    </p>
-    <p>Hauptmerkmale:</p>
+    <p>Funktionen:</p>
    <ul>
-      <li>Zwei-Stufen-Inking-Modell: Echtzeit-Glättung mit 1€-Filter und akausale Ecken-Erhaltung</li>
-      <li>Automatische Geometrie- und Formerkennung (Geraden, Rechtecke, Kreise, Koordinatensysteme, Polygone)</li>
-      <li>Stufenloser Viewport mit cursor-zentriertem Zoom (25% bis 500%) und Panning</li>
-      <li>Objektauswahl, Lasso, Skalieren, stufenloses Drehen und Multicolor-Umfärbung</li>
-      <li>Multi-Dokumenten- und Notizbuch-Verwaltung mit atomarem Autosave</li>
-      <li>Vektor-PDF-Export für Druck und Weitergabe</li>
+      <li>Stift und Textmarker mit Druckstärke, Glättung beim Schreiben und Ecken-Erhaltung</li>
+      <li>Radierer für ganze Striche, Teilstriche oder nur Textmarker; virtuelles Lineal</li>
+      <li>Formerkennung (Linien, Pfeile, Kreise, Ellipsen, Rechtecke, Dreiecke, Rauten, Koordinatensysteme)</li>
+      <li>Auswählen, Verschieben, Drehen, Skalieren und Umfärben; Rückgängig für alle Änderungen</li>
+      <li>Textfelder, Bilder und PDF-Import zum Beschriften (Querformat-Folien bekommen Querformat-Seiten)</li>
+      <li>Durchgehendes Scrollen, Zoom von 25 bis 1000 Prozent, Papier- und Musterfarben</li>
+      <li>Mehrere Notizbücher, automatisches Speichern im Hintergrund</li>
+      <li>Export als PDF (mit durchsuchbarem Text), PNG oder SVG</li>
    </ul>
  </description>
  <launchable type="desktop-id">eu.pansi.ink-notes.desktop</launchable>
@@ -2,13 +2,13 @@
 Version=1.0
 Name=ink-notes
 GenericName=Notizbuch- & Inking-App
-Comment=Latenzoptimierte Vektor-Notizen mit Stylus, Stift & Geometrie-Erkennung
+Comment=Handschriftliche Notizen mit Stift, Touch und Maus; PDFs beschriften
 Exec=ink-notes %F
 Icon=eu.pansi.ink-notes
 Terminal=false
 Type=Application
 Categories=Office;Graphics;Utility;
-Keywords=Note;Notiz;Pen;Stift;Ink;Inking;Stylus;Drawing;Zeichnen;PDF;Vector;
+Keywords=Note;Notiz;Pen;Stift;Ink;Inking;Stylus;Drawing;Zeichnen;PDF;Vector;Text;Annotation;
 StartupWMClass=ink-notes
 MimeType=application/x-inknotes;
 Actions=NewWindow;
@@ -4,20 +4,22 @@
  <metadata_license>CC0-1.0</metadata_license>
  <project_license>MIT</project_license>
  <name>ink-notes</name>
-  <summary>Latenzoptimierte Vektor-Notizbuch- und Inking-App für Linux</summary>
+  <summary>Notizbuch-App für Stift, Touch und Maus</summary>
  <description>
    <p>
-      ink-notes ist eine hardwarebeschleunigte, hochperformante Notizbuch- und Inking-Anwendung für Linux,
-      geschrieben in Rust mit wgpu. Sie bietet minimale Eingabelatenz mit Stylus, Touchpad oder Maus.
+      ink-notes ist eine Notizbuch-App für Linux, geschrieben in Rust mit wgpu. Handschrift wird als
+      Vektoren gespeichert; geschrieben wird mit Stift, Finger, Touchpad oder Maus.
    </p>
-    <p>Hauptmerkmale:</p>
+    <p>Funktionen:</p>
    <ul>
-      <li>Zwei-Stufen-Inking-Modell: Echtzeit-Glättung mit 1€-Filter und akausale Ecken-Erhaltung</li>
-      <li>Automatische Geometrie- und Formerkennung (Geraden, Rechtecke, Kreise, Koordinatensysteme, Polygone)</li>
-      <li>Stufenloser Viewport mit cursor-zentriertem Zoom (25% bis 500%) und Panning</li>
-      <li>Objektauswahl, Lasso, Skalieren, stufenloses Drehen und Multicolor-Umfärbung</li>
-      <li>Multi-Dokumenten- und Notizbuch-Verwaltung mit atomarem Autosave</li>
-      <li>Vektor-PDF-Export für Druck und Weitergabe</li>
+      <li>Stift und Textmarker mit Druckstärke, Glättung beim Schreiben und Ecken-Erhaltung</li>
+      <li>Radierer für ganze Striche, Teilstriche oder nur Textmarker; virtuelles Lineal</li>
+      <li>Formerkennung (Linien, Pfeile, Kreise, Ellipsen, Rechtecke, Dreiecke, Rauten, Koordinatensysteme)</li>
+      <li>Auswählen, Verschieben, Drehen, Skalieren und Umfärben; Rückgängig für alle Änderungen</li>
+      <li>Textfelder, Bilder und PDF-Import zum Beschriften (Querformat-Folien bekommen Querformat-Seiten)</li>
+      <li>Durchgehendes Scrollen, Zoom von 25 bis 1000 Prozent, Papier- und Musterfarben</li>
+      <li>Mehrere Notizbücher, automatisches Speichern im Hintergrund</li>
+      <li>Export als PDF (mit durchsuchbarem Text), PNG oder SVG</li>
    </ul>
  </description>
  <launchable type="desktop-id">eu.pansi.ink-notes.desktop</launchable>
@@ -1,8 +1,10 @@
 ## ink-notes {{TAG_NAME}}

-Latenzoptimierte Vektor-Notizbuch- und Inking-Anwendung für Linux (Zorin OS 18 / Ubuntu 24.04).
+Notizbuch-App für Stift, Touch und Maus unter Linux (getestet mit Zorin OS 18 / Ubuntu 24.04).

 ### Highlights:
+- **Musterfarbe**: Karos, Linien und Punkte in hell, mittel, kräftig, blau oder grün (☰-Menü, gilt auch im Export); Punkte des Punktrasters am Bildschirm so groß wie im Export (0,4 mm). README und Dokumentation überarbeitet
+- **Beta-Feedback**: Querformat-PDFs (z. B. PowerPoint-Folien) bekommen Querformat-Seiten ohne leeren Streifen (Dateiformat-Version 8); neue Seiten direkt nach der aktuellen einfügen; Auswahlwerkzeug funktioniert mit dem Stift; Zoom bis 1000 % mit schärfer nachgerenderten PDF-Seiten
 - **Text-Werkzeug**: Mit T ins Blatt tippen und schreiben – normale oder Code-Schrift, 8–36 pt, Zeilenumbruch am Feldrand; Textfelder verschieben, drehen und skalieren wie Bilder; im PDF echter, durchsuchbarer Text; kopierter Text wird mit Strg+V zum Textfeld (Dateiformat-Version 7)
 - **Durchgehendes Scrollen**: Seiten untereinander mit Mausrad, Finger oder Touchpad scrollen (Strg+Mausrad zoomt); Schreiben im unteren Fünftel der letzten Seite hängt automatisch eine neue an; abschaltbar unter ☰ → Ansicht
 - **Virtuelles Lineal**: Ein- und ausblenden mit L oder über die Werkzeugleiste; verschieben, am Griff drehen (rastet bei 15° ein); Striche entlang einer Kante werden exakt gerade – mit Stift, Textmarker und Formwerkzeug
@@ -13,7 +15,7 @@ Latenzoptimierte Vektor-Notizbuch- und Inking-Anwendung für Linux (Zorin OS 18
 - **Bilder einfügen**: Screenshots per Strg+V, Bilddateien über die eingebaute Dateiauswahl (Strg+I) oder per Drag & Drop; verschieben, drehen, skalieren und darauf schreiben – auch im PDF-Export (Dateiformat-Version 4: ältere Versionen öffnen solche Notizbücher nicht)
 - **Dunkelmodus & Papierfarben**: Weiß, Creme, Dunkelgrau oder Schwarz; auf dunklem Papier werden dunkle Stiftfarben automatisch aufgehellt (nur Anzeige – Dateien und PDF-Export bleiben unverändert)
 - **Nur Textmarker radieren**: Markierungen korrigieren, ohne die Handschrift darunter zu löschen – auch mit Stiftrückseite und Seitentaste
- **Einstellbare Druckkurve**: Kennlinie weich bis hart und Mindestdruck mit Live-Vorschau, passend für jeden Digitizer
+- **Einstellbare Druckkurve**: Kennlinie weich bis hart und Mindestdruck mit Vorschau, zum Anpassen an den eigenen Stift
 - **Neue Formen**: Ellipsen sowie in einem Zug gezeichnete Pfeile und Doppelpfeile werden erkannt (Dateiformat-Version 3: ältere Versionen öffnen solche Notizbücher nicht)
 - **Stabiler Start**: Kein Absturz mehr, wenn die Grafikkarte nicht nutzbar ist (z. B. fehlende Rechte auf /dev/dri); Software-Renderer als Ausweichlösung und verständliche Fehlermeldung
 - **WSL (WSLg)**: Läuft unter WSL automatisch über X11 statt Wayland, da WSLg die Wayland-Verbindung abbricht; übersteuerbar mit `INK_NOTES_DISPLAY=x11|wayland`
@@ -21,21 +23,21 @@ Latenzoptimierte Vektor-Notizbuch- und Inking-Anwendung für Linux (Zorin OS 18
 - **Neue Werkzeugleiste**: Schmale senkrechte Leiste mit Symbol-Knöpfen, links oder rechts andockbar; selten genutzte Funktionen im ☰-Menü, das Blatt wird daneben zentriert
 - **Einheitliche Dialoge**: Deckende Fenster ohne doppelte Titel, Seitenauswahl mit Vorschaubildern, größere Bedienelemente in allen Popovern
 - **UI per Stift und Touch bedienbar**: Werkzeugleiste, Popover und Dialoge reagieren jetzt auch auf Stift und Finger, auch bei Display-Skalierung
- **Aktive Stylus-Unterstützung (Lazarite / MPP / AES)**: Natives Wayland-Tablet-Protokoll mit präziser Druck- und Neigungserfassung
- **Touchscreen Multi-Touch**: Stufenloses 2-Finger Pinch-to-Zoom und Panning mit umschaltbarem Finger-Zeichenmodus
- **Zwei-Stufen-Inking-Modell**: Kausale Echtzeit-Glättung via 1€-Filter & akausale Ecken-Erhaltung (Corner Preservation)
+- **Aktive Stylus-Unterstützung (Lazarite / MPP / AES)**: Stifteingabe über das Tablet-Protokoll von Wayland bzw. X11, mit Druckstärke
+- **Touchscreen Multi-Touch**: Zoomen mit zwei Fingern, Verschieben mit einem; Zeichnen mit dem Finger zuschaltbar
+- **Zwei-Stufen-Inking-Modell**: Glättung während des Schreibens (1€-Filter), beim Absetzen Nachbearbeitung mit Ecken-Erhaltung
 - **Geometrie- und Formerkennung**: Geraden, Pfeile & Doppelpfeile, Rechtecke, Kreise, Ellipsen, Dreiecke, Rauten, Vielecke & Koordinatensysteme mit spitzen Pfeilspitzen (Draw-and-Hold); Freiformen bleiben unverändert
- **Multi-Dokumenten-Manager**: Unbegrenzte Notizbücher mit atomarem Autosave, Papierkorb und fortlaufenden Backups
- **Datensicherheit**: Versioniertes Dateiformat mit Migration, Quarantäne beschädigter Seiten, Schutz vor Doppelöffnung und Crash-getestetem Speichern
- **In-App Updater**: Automatische Versionsprüfung und sichere Atomar-Aktualisierung via Gitea Releases – mit Pflicht-Signaturprüfung (Minisign) und durchgängigem HTTPS
- **Vektor-PDF-Export**: Verlustfreie Ausgabe für Druck und Weitergabe
+- **Mehrere Notizbücher**: Anlegen, umbenennen, löschen (mit Papierkorb); automatisches Speichern im Hintergrund
+- **Datensicherheit**: Versioniertes Dateiformat mit Migration, beschädigte Seiten werden beiseitegelegt statt überschrieben, Schutz vor gleichzeitigem Öffnen, atomares Speichern
+- **In-App Updater**: Prüft auf neue Versionen auf Gitea und installiert sie auf Wunsch – nur mit gültiger Minisign-Signatur und über HTTPS
+- **PDF-Export**: Striche und Formen als Vektoren, für Druck und Weitergabe

 ### Installation:
 - **Zorin OS / Ubuntu / Debian (.deb)**:
  ```bash
  sudo dpkg -i ink-notes_{{VERSION}}_amd64.deb
  ```
- **Portables AppImage (Alle Linux-Distributionen)**:
+- **AppImage (andere Distributionen mit glibc ≥ 2.39)**:
  ```bash
  chmod +x ink-notes_{{VERSION}}_x86_64.AppImage
  ./ink-notes_{{VERSION}}_x86_64.AppImage
@@ -104,9 +104,7 @@ cat <<EOF > "${CHANGELOG_TMP}"
 ink-notes (${VERSION}-1) stable; urgency=medium

  * Release v${VERSION}.
-  * Low-latency vector inking with two-stage pipeline.
-  * Shape recognition and infinite canvas with zoom/pan.
-  * Multi-notebook management and PDF export.
+  * See the release notes on https://gitea.pansi.eu/harald/ink-notes/releases

 -- Harald <harald@pansi.eu>  $(date -R)
 EOF
@@ -130,10 +128,10 @@ Depends: libc6 (>= 2.38), libgcc-s1, libvulkan1, mesa-vulkan-drivers | vulkan-ic
 Section: utils
 Priority: optional
 Homepage: https://gitea.pansi.eu/harald/ink-notes
-Description: Latenzoptimierte Vektor-Notizbuch- und Inking-App für Linux
- ink-notes kombiniert minimale Stylus-Latenz mit GPU-Hardwarebeschleunigung (wgpu),
- stufenlosem Viewport, Geometrie- und Formerkennung, Objekt-Transformationen,
- Multi-Dokumenten-Verwaltung und Vektor-PDF-Export.
+Description: Notizbuch-App für Stift, Touch und Maus
+ ink-notes speichert Handschrift als Vektoren, erkennt auf Wunsch Formen und
+ kann PDFs zum Beschriften importieren sowie Bilder und Textfelder einfügen.
+ Mehrere Notizbücher, automatisches Speichern und Export als PDF, PNG oder SVG.
 EOF
 chmod 644 "${STAGING_DIR}/DEBIAN/control"

@@ -5,10 +5,63 @@ use serde::{Deserialize, Serialize};
 use crate::canvas::InkVertex;
 use crate::document::PageBackground;

+/// Farbe von Karos, Linien und Punkten (wird gespeichert und gilt auch für den Export).
+/// `Light` ist die zurückhaltende Standardfarbe des jeweiligen Papiers.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum PatternColor {
+    #[default]
+    Light,
+    Medium,
+    Strong,
+    Blue,
+    Green,
+}
+
+impl PatternColor {
+    pub const ALL: [PatternColor; 5] = [
+        PatternColor::Light,
+        PatternColor::Medium,
+        PatternColor::Strong,
+        PatternColor::Blue,
+        PatternColor::Green,
+    ];
+
+    pub fn label(self) -> &'static str {
+        match self {
+            PatternColor::Light => "Hell",
+            PatternColor::Medium => "Mittel",
+            PatternColor::Strong => "Kräftig",
+            PatternColor::Blue => "Blau",
+            PatternColor::Green => "Grün",
+        }
+    }
+
+    /// Linearer Farbwert des Musters auf dem Papier `paper` (für den Export: weißes Papier).
+    pub fn color(self, paper: PaperTheme) -> [f32; 4] {
+        let light = paper.pattern_color();
+        let dark = paper.is_dark();
+        let scaled = |f: f32| [light[0] * f, light[1] * f, light[2] * f, 1.0];
+        match (self, dark) {
+            (PatternColor::Light, _) => light,
+            // Helles Papier: kräftiger = dunkler
+            (PatternColor::Medium, false) => scaled(0.62),
+            (PatternColor::Strong, false) => scaled(0.28),
+            // Dunkles Papier: kräftiger = heller
+            (PatternColor::Medium, true) => [0.16, 0.16, 0.17, 1.0],
+            (PatternColor::Strong, true) => [0.32, 0.32, 0.34, 1.0],
+            (PatternColor::Blue, false) => [0.35, 0.55, 0.95, 1.0],
+            (PatternColor::Blue, true) => [0.06, 0.14, 0.42, 1.0],
+            (PatternColor::Green, false) => [0.32, 0.72, 0.38, 1.0],
+            (PatternColor::Green, true) => [0.05, 0.22, 0.09, 1.0],
+        }
+    }
+}
+
 /// Linienstärke für Gitter- und Schreiblinien in Seiteneinheiten (1.5 = 0.15 mm).
 pub const LINE_THICKNESS: f32 = 1.5;
-/// Punktgröße für das Punktraster in Seiteneinheiten (2.5 = 0.25 mm).
-pub const DOT_SIZE: f32 = 2.5;
+/// Punktgröße für das Punktraster in Seiteneinheiten (4 = 0,4 mm, wie im PDF-Export).
+pub const DOT_SIZE: f32 = 4.0;

 /// Rasterabstand 5 mm (50 Einheiten).
 pub const GRID_5MM_SPACING: f32 = 50.0;
@@ -229,6 +282,31 @@ mod tests {

    use crate::document::{A4_SIZE, PAGE_HEIGHT, PAGE_WIDTH};

+    #[test]
+    fn test_pattern_colors_get_more_visible() {
+        // Luminanz (linear) als Abstand zum Papier
+        let lum = |c: [f32; 4]| 0.2126 * c[0] + 0.7152 * c[1] + 0.0722 * c[2];
+        for paper in PaperTheme::ALL {
+            let p = lum(paper.paper_color());
+            let contrast = |c: PatternColor| (lum(c.color(paper)) - p).abs();
+            assert_eq!(PatternColor::Light.color(paper), paper.pattern_color());
+            assert!(
+                contrast(PatternColor::Medium) > contrast(PatternColor::Light),
+                "{paper:?}"
+            );
+            assert!(
+                contrast(PatternColor::Strong) > contrast(PatternColor::Medium),
+                "{paper:?}"
+            );
+            for c in [PatternColor::Blue, PatternColor::Green] {
+                assert!(
+                    contrast(c) > contrast(PatternColor::Light),
+                    "{c:?} auf {paper:?}"
+                );
+            }
+        }
+    }
+
    #[test]
    fn test_paper_quad_generation() {
        let quad = generate_paper_quad(PaperTheme::White.paper_color(), A4_SIZE);
@@ -1,7 +1,7 @@
 //! GPU-Canvas-Renderpipeline mit wgpu und Low-Latency-Verwaltung.
 //!
 //! Features:
-//! - Zero-Latency-Pufferung via `PresentMode::Mailbox` (Fallback: `Fifo`) und `desired_maximum_frame_latency: 1`.
+//! - Geringe Bildverzögerung durch `PresentMode::Mailbox` (Fallback: `Fifo`) und `desired_maximum_frame_latency: 1`.
 //! - Strikte Pipeline-Trennung: DIN-A4-Hintergrund, permanente Striche und temporäre Live-Geometrie.
 //! - NDC-Transformation der 2D-Vektor-Meshes über Vertex-Shader-Uniforms.
 //! - Alpha-Blending (`wgpu::BlendState::ALPHA_BLENDING`).
@@ -12,7 +12,7 @@ use std::sync::Arc;
 use winit::dpi::PhysicalSize;
 use winit::window::Window;

-use crate::background::{generate_background_mesh, generate_paper_quad, PaperTheme};
+use crate::background::{generate_background_mesh, generate_paper_quad, PaperTheme, PatternColor};
 use crate::document::{Page, PageBackground, PageViewport, Stroke, StylusSample};
 use crate::filter::OneEuroFilter;
 use crate::spline::{self, ControlPoint, SplineConfig};
@@ -122,18 +122,20 @@ struct NeighborFingerprint {
    background: PageBackground,
    size: [u32; 2],
    paper_theme: PaperTheme,
+    pattern: PatternColor,
    vertex_count: usize,
    stroke_count: usize,
    last_stroke_id: Option<u64>,
 }

 impl NeighborFingerprint {
-    fn of(page: &Page, paper_theme: PaperTheme) -> Self {
+    fn of(page: &Page, paper_theme: PaperTheme, pattern: PatternColor) -> Self {
        Self {
            page_id: page.id,
            background: page.background,
            size: page.size.to_array().map(f32::to_bits),
            paper_theme,
+            pattern,
            vertex_count: page.vertex_cache.len(),
            stroke_count: page.strokes.len(),
            last_stroke_id: page.strokes.last().map(|s| s.id),
@@ -190,6 +192,8 @@ pub struct CanvasState {
    pub paper_theme: PaperTheme,
    /// Dunkle Tinte auf dunklem Papier aufhellen
    pub adapt_ink: bool,
+    /// Farbe von Karos, Linien und Punkten
+    pattern: PatternColor,
    /// Größe der aktuellen Seite und Rahmen, in den alle Seiten des Notizbuchs passen
    page_size: glam::Vec2,
    fit_box: glam::Vec2,
@@ -299,7 +303,7 @@ impl CanvasState {
            )
            .await?;

-        // 4. Zero-Latency-Pufferung (Mailbox, sonst Fifo) & Frame-Latency 1
+        // 4. Geringe Bildverzögerung (Mailbox, sonst Fifo) & Frame-Latency 1
        let surface_format = surface_caps
            .formats
            .iter()
@@ -509,6 +513,7 @@ impl CanvasState {
            current_background,
            paper_theme,
            adapt_ink: false,
+            pattern: PatternColor::default(),
            page_size: crate::document::A4_SIZE,
            fit_box: crate::document::A4_SIZE,
            text_specs: HashMap::new(),
@@ -785,6 +790,14 @@ impl CanvasState {
        self.update_uniforms();
    }

+    /// Setzt die Farbe von Karos, Linien und Punkten.
+    pub fn set_pattern_color(&mut self, pattern: PatternColor) {
+        if self.pattern != pattern {
+            self.pattern = pattern;
+            self.upload_background_mesh();
+        }
+    }
+
    /// Setzt den Seitenhintergrund und aktualisiert bei Bedarf den Vertex-Puffer.
    pub fn set_background(&mut self, background: PageBackground) {
        if self.current_background == background {
@@ -798,7 +811,7 @@ impl CanvasState {
    fn upload_background_mesh(&mut self) {
        let mesh = generate_background_mesh(
            self.current_background,
-            self.paper_theme.pattern_color(),
+            self.pattern.color(self.paper_theme),
            self.page_size,
        );
        self.background_vertex_count = mesh.len() as u32;
@@ -874,7 +887,7 @@ impl CanvasState {
        let mut old = std::mem::take(&mut self.neighbors);
        let mut image_groups = Vec::with_capacity(pages.len());
        for &(offset, page) in pages {
-            let fingerprint = NeighborFingerprint::of(page, self.paper_theme);
+            let fingerprint = NeighborFingerprint::of(page, self.paper_theme, self.pattern);
            let mut neighbor = match old.iter().position(|n| n.fingerprint == fingerprint) {
                Some(i) => old.swap_remove(i),
                None => self.upload_neighbor(page, fingerprint),
@@ -924,7 +937,7 @@ impl CanvasState {
        let mut background = generate_paper_quad(self.paper_theme.paper_color(), page.size);
        background.extend(generate_background_mesh(
            page.background,
-            self.paper_theme.pattern_color(),
+            self.pattern.color(self.paper_theme),
            page.size,
        ));
        NeighborPage {
@@ -20,7 +20,7 @@ use printpdf::path::{PaintMode, WindingOrder};
 use printpdf::{Color, Line, Mm, PdfDocument, PdfDocumentReference, Point, Polygon, Rgb};

 use crate::assets::AssetStore;
-use crate::background::{GRID_5MM_SPACING, LINED_SPACING};
+use crate::background::{PatternColor, DOT_SIZE, GRID_5MM_SPACING, LINED_SPACING};
 use crate::document::{
    Notebook, Page, PageBackground, Stroke, A4_HEIGHT_MM, A4_WIDTH_MM, PAGE_HEIGHT, PAGE_WIDTH,
 };
@@ -155,14 +155,16 @@ fn end_page_layer(layer: &printpdf::PdfLayerReference) {
 }

 /// Erzeugt ein PDF-Dokument aus einem Notizbuch und speichert es als Datei.
-/// `assets`: Bilder des Notizbuchs (ohne werden Bilder als graue Fläche ausgegeben).
+/// `assets`: Bilder des Notizbuchs (ohne werden Bilder als graue Fläche ausgegeben);
+/// `pattern`: Farbe von Karos, Linien und Punkten.
 pub fn export_notebook_to_pdf<P: AsRef<Path>>(
    notebook: &Notebook,
    path: P,
    strategy: ExportStrategy,
    assets: Option<&AssetStore>,
+    pattern: PatternColor,
 ) -> Result<(), Box<dyn Error>> {
-    let bytes = export_notebook_to_bytes(notebook, strategy, assets)?;
+    let bytes = export_notebook_to_bytes(notebook, strategy, assets, pattern)?;
    let file = File::create(path)?;
    let mut writer = BufWriter::new(file);
    std::io::Write::write_all(&mut writer, &bytes)?;
@@ -175,8 +177,9 @@ pub fn export_notebook_to_bytes(
    notebook: &Notebook,
    strategy: ExportStrategy,
    assets: Option<&AssetStore>,
+    pattern: PatternColor,
 ) -> Result<Vec<u8>, Box<dyn Error>> {
-    let doc = generate_pdf_document(notebook, strategy, assets)?;
+    let doc = generate_pdf_document(notebook, strategy, assets, pattern)?;
    let bytes = fix_text_encoding(doc.save_to_bytes()?, notebook)?;

    // Importierte PDF-Seiten als Vektorgrafik unterlegen
@@ -202,7 +205,7 @@ pub fn export_notebook_to_bytes(
        );
        raster.insert(underlay.target_page);
    }
-    let doc = generate_pdf_document_with(notebook, strategy, assets, &raster)?;
+    let doc = generate_pdf_document_with(notebook, strategy, assets, pattern, &raster)?;
    let bytes = fix_text_encoding(doc.save_to_bytes()?, notebook)?;
    let remaining: Vec<_> = underlays
        .into_iter()
@@ -289,11 +292,13 @@ pub fn generate_pdf_document(
    notebook: &Notebook,
    strategy: ExportStrategy,
    assets: Option<&AssetStore>,
+    pattern: PatternColor,
 ) -> Result<PdfDocumentReference, Box<dyn Error>> {
    generate_pdf_document_with(
        notebook,
        strategy,
        assets,
+        pattern,
        &std::collections::HashSet::new(),
    )
 }
@@ -304,6 +309,7 @@ fn generate_pdf_document_with(
    notebook: &Notebook,
    strategy: ExportStrategy,
    assets: Option<&AssetStore>,
+    pattern: PatternColor,
    raster_pdf_pages: &std::collections::HashSet<usize>,
 ) -> Result<PdfDocumentReference, Box<dyn Error>> {
    if notebook.pages.is_empty() {
@@ -338,7 +344,7 @@ fn generate_pdf_document_with(
            doc.add_bookmark(title.clone(), page_idx);
        }
        let page_ref = doc.get_page(page_idx);
-        render_background_layer(&page_ref.get_layer(layer_bg), page);
+        render_background_layer(&page_ref.get_layer(layer_bg), page, pattern);
        let layer = |name: &str, render: &dyn Fn(&printpdf::PdfLayerReference)| {
            let layer = page_ref.add_layer(name);
            begin_page_layer(&layer, page);
@@ -361,10 +367,16 @@ fn generate_pdf_document_with(
 }

 /// Rendert das Vektorraster auf Layer 1 ("Background").
-fn render_background_layer(layer: &printpdf::PdfLayerReference, page: &Page) {
+fn render_background_layer(
+    layer: &printpdf::PdfLayerReference,
+    page: &Page,
+    pattern: PatternColor,
+) {
    let background = page.background;
    let (Mm(page_width_mm), Mm(page_height_mm)) = pdf_page_mm(page);
-    let grid_color = Color::Rgb(Rgb::new(0.88, 0.88, 0.88, None));
+    // Exportiert wird immer auf weißem Papier
+    let [r, g, b, _] = pattern.color(crate::background::PaperTheme::White);
+    let grid_color = Color::Rgb(Rgb::new(r, g, b, None));
    layer.set_outline_color(grid_color.clone());
    layer.set_outline_thickness(0.4); // Feine 0.15 mm Haarlinie (ca. 0.4 pt)
    layer.set_fill_color(grid_color);
@@ -425,7 +437,7 @@ fn render_background_layer(layer: &printpdf::PdfLayerReference, page: &Page) {

        PageBackground::DotGrid => {
            let spacing_mm = GRID_5MM_SPACING / 10.0; // 5.0 mm
-            let half_dot = 0.2; // 0.4 mm Kantenlänge
+            let half_dot = DOT_SIZE / 20.0; // Kantenlänge in mm wie am Bildschirm

            let mut y = spacing_mm;
            while y < page_height_mm {
@@ -1259,8 +1271,13 @@ mod tests {
        let temp_dir = std::env::temp_dir();
        let pdf_path = temp_dir.join("ink_notes_test_export.pdf");

-        let export_res =
-            export_notebook_to_pdf(&notebook, &pdf_path, ExportStrategy::FilledPolygon, None);
+        let export_res = export_notebook_to_pdf(
+            &notebook,
+            &pdf_path,
+            ExportStrategy::FilledPolygon,
+            None,
+            PatternColor::default(),
+        );
        assert!(
            export_res.is_ok(),
            "PDF-Export zu Datei muss erfolgreich sein"
@@ -1286,7 +1303,12 @@ mod tests {
        );

        // 3. Export als Bytes testen (Strategie B: BezierCurve)
-        let bytes_res = export_notebook_to_bytes(&notebook, ExportStrategy::BezierCurve, None);
+        let bytes_res = export_notebook_to_bytes(
+            &notebook,
+            ExportStrategy::BezierCurve,
+            None,
+            PatternColor::default(),
+        );
        assert!(bytes_res.is_ok());
        let bytes = bytes_res.unwrap();
        assert!(bytes.len() > 1024);
@@ -1409,7 +1431,12 @@ mod tests {
        );
        page.add_stroke(octahedron_stroke);

-        let bytes_res = export_notebook_to_bytes(&notebook, ExportStrategy::FilledPolygon, None);
+        let bytes_res = export_notebook_to_bytes(
+            &notebook,
+            ExportStrategy::FilledPolygon,
+            None,
+            PatternColor::default(),
+        );
        assert!(bytes_res.is_ok(), "Shape export must succeed");
        let bytes = bytes_res.unwrap();
        assert!(bytes.len() > 1024);
@@ -1478,9 +1505,13 @@ mod tests {
            ));
        }

-        let bytes =
-            export_notebook_to_bytes(&notebook, ExportStrategy::FilledPolygon, Some(&assets))
-                .expect("Export mit Bildern");
+        let bytes = export_notebook_to_bytes(
+            &notebook,
+            ExportStrategy::FilledPolygon,
+            Some(&assets),
+            PatternColor::default(),
+        )
+        .expect("Export mit Bildern");
        let contains = |needle: &[u8]| bytes.windows(needle.len()).any(|w| w == needle);
        assert!(
            contains(b"/DCTDecode"),
@@ -1504,7 +1535,13 @@ mod tests {
        assert_eq!(image_objects, 3);

        // Ohne Asset-Ordner: Export klappt trotzdem (graue Flächen)
-        assert!(export_notebook_to_bytes(&notebook, ExportStrategy::FilledPolygon, None).is_ok());
+        assert!(export_notebook_to_bytes(
+            &notebook,
+            ExportStrategy::FilledPolygon,
+            None,
+            PatternColor::default()
+        )
+        .is_ok());
    }

    #[test]
@@ -1516,9 +1553,13 @@ mod tests {
        crate::storage::load_all_pages(&dir, &mut notebook).unwrap();
        let assets = AssetStore::new(&dir);

-        let bytes =
-            export_notebook_to_bytes(&notebook, ExportStrategy::FilledPolygon, Some(&assets))
-                .unwrap();
+        let bytes = export_notebook_to_bytes(
+            &notebook,
+            ExportStrategy::FilledPolygon,
+            Some(&assets),
+            PatternColor::default(),
+        )
+        .unwrap();
        let doc = printpdf::lopdf::Document::load_mem(&bytes).unwrap();
        assert_eq!(doc.get_pages().len(), 2);
        for page_id in doc.get_pages().into_values() {
@@ -1563,7 +1604,13 @@ mod tests {
        assert!(!red_at(&exported, 5, 5));

        // Ohne Zugriff auf das PDF: Export klappt trotzdem (graue Ersatzfläche)
-        assert!(export_notebook_to_bytes(&notebook, ExportStrategy::FilledPolygon, None).is_ok());
+        assert!(export_notebook_to_bytes(
+            &notebook,
+            ExportStrategy::FilledPolygon,
+            None,
+            PatternColor::default()
+        )
+        .is_ok());
    }

    #[test]
@@ -1574,8 +1621,13 @@ mod tests {
        let ids: Vec<u64> = notebook.pages.iter().map(|p| p.id).collect();
        notebook.set_page_title(ids[0], "Einleitung");
        notebook.set_page_title(ids[2], "Übung 2 – Integrale");
-        let bytes =
-            export_notebook_to_bytes(&notebook, ExportStrategy::FilledPolygon, None).unwrap();
+        let bytes = export_notebook_to_bytes(
+            &notebook,
+            ExportStrategy::FilledPolygon,
+            None,
+            PatternColor::default(),
+        )
+        .unwrap();
        let doc = printpdf::lopdf::Document::load_mem(&bytes).unwrap();
        let catalog = doc.catalog().unwrap();
        assert!(catalog.has(b"Outlines"), "Lesezeichen fehlen");
@@ -18,6 +18,7 @@ use winit::{
 use glam::Vec2;
 use ink_notes::assets::{AssetStore, ImportedImage};
 use ink_notes::autosave::{AutosaveController, AutosaveStatus};
+use ink_notes::background::PatternColor;
 use ink_notes::canvas::CanvasState;
 use ink_notes::document::{Notebook, PageBackground};
 use ink_notes::export::{self, export_notebook_to_pdf, ExportStrategy};
@@ -85,6 +86,7 @@ fn start_pdf_export(
    notebook: &Notebook,
    storage_dir: &Path,
    title: &str,
+    pattern: PatternColor,
    result_tx: Sender<Result<PathBuf, String>>,
    window: Arc<Window>,
 ) {
@@ -106,6 +108,7 @@ fn start_pdf_export(
                    &export_path,
                    ExportStrategy::FilledPolygon,
                    Some(&assets),
+                    pattern,
                )
                .map_err(|err| err.to_string())
            });
@@ -746,6 +749,7 @@ fn start_page_export(
    notebook: &Notebook,
    storage_dir: &Path,
    title: &str,
+    pattern: PatternColor,
    result_tx: Sender<Result<PathBuf, String>>,
    window: Arc<Window>,
 ) {
@@ -762,11 +766,15 @@ fn start_page_export(
    std::thread::spawn(move || {
        let assets = AssetStore::new(&storage_dir);
        let bytes = match kind {
-            ui::PageExportKind::Png => page_png(&page, Some(&assets), ImageBackground::Paper),
-            ui::PageExportKind::PngTransparent => {
-                page_png(&page, Some(&assets), ImageBackground::Transparent)
+            ui::PageExportKind::Png => {
+                page_png(&page, Some(&assets), ImageBackground::Paper, pattern)
+            }
+            ui::PageExportKind::PngTransparent => {
+                page_png(&page, Some(&assets), ImageBackground::Transparent, pattern)
+            }
+            ui::PageExportKind::Svg => {
+                page_svg(&page, Some(&assets), pattern).map(String::into_bytes)
            }
-            ui::PageExportKind::Svg => page_svg(&page, Some(&assets)).map(String::into_bytes),
        };
        let result = bytes
            .map_err(|e| e.to_string())
@@ -1047,6 +1055,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
    ui_state.sidebar_side = ui_settings.sidebar_side;
    ui_state.paper_theme = ui_settings.paper_theme;
    ui_state.adapt_ink_colors = ui_settings.adapt_ink_colors;
+    ui_state.pattern_color = ui_settings.pattern_color;
    ui_state.pressure_curve = ui_settings.pressure_curve;
    ui_state.continuous_scroll = ui_settings.continuous_scroll;
    ui_state.current_notebook_id = manifest.id.clone();
@@ -1084,6 +1093,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {

    // Initiale Seite und Werkzeugeinstellungen mit Canvas synchronisieren
    canvas.set_paper_theme(ui_state.paper_theme, ui_state.adapt_ink_colors);
+    canvas.set_pattern_color(ui_state.pattern_color);
    canvas.sync_page(notebook.current_page_mut());
    canvas.set_stroke_color(ui_state.pen_color);
    canvas.set_stroke_width_mm(ui_state.pen_stroke_width_mm);
@@ -1825,7 +1835,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {

                            // PDF-Export: Strg + E
                            Key::Character(c) if c.eq_ignore_ascii_case("e") && ctrl => {
-                                start_pdf_export(&notebook, &storage_dir, &manifest.title, export_tx.clone(), window.clone());
+                                start_pdf_export(&notebook, &storage_dir, &manifest.title, ui_state.pattern_color, export_tx.clone(), window.clone());
                                ui_state.set_export_message("PDF-Export läuft…");
                                window.request_redraw();
                            }
@@ -2782,7 +2792,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                    window.request_redraw();
                                }
                                UiAction::ExportPage(kind) => {
-                                    start_page_export(kind, &notebook, &storage_dir, &manifest.title, export_tx.clone(), window.clone());
+                                    start_page_export(kind, &notebook, &storage_dir, &manifest.title, ui_state.pattern_color, export_tx.clone(), window.clone());
                                    ui_state.set_export_message("Seite wird exportiert …".to_string());
                                    window.request_redraw();
                                }
@@ -2848,7 +2858,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                    window.request_redraw();
                                }
                                UiAction::ExportPdf => {
-                                    start_pdf_export(&notebook, &storage_dir, &manifest.title, export_tx.clone(), window.clone());
+                                    start_pdf_export(&notebook, &storage_dir, &manifest.title, ui_state.pattern_color, export_tx.clone(), window.clone());
                                    ui_state.set_export_message("PDF-Export läuft…");
                                    window.request_redraw();
                                }
@@ -3184,6 +3194,12 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                    save_ui_settings(&ui_settings, ui_settings_path.as_deref(), &mut ui_state);
                                    window.request_redraw();
                                }
+                                UiAction::SetPatternColor(pattern) => {
+                                    canvas.set_pattern_color(pattern);
+                                    ui_settings.pattern_color = pattern;
+                                    save_ui_settings(&ui_settings, ui_settings_path.as_deref(), &mut ui_state);
+                                    window.request_redraw();
+                                }
                                UiAction::SetContinuousScroll(on) => {
                                    ui_settings.continuous_scroll = on;
                                    save_ui_settings(&ui_settings, ui_settings_path.as_deref(), &mut ui_state);
@@ -12,6 +12,7 @@ use hayro::vello_cpu::color::palette::css::{TRANSPARENT, WHITE};
 use hayro::{PixmapSettings, RenderCache, RenderSettings};

 use crate::assets::{AssetStore, RgbaImage};
+use crate::background::PatternColor;
 use crate::document::{Aabb, Notebook, Page, PageBackground, A4_WIDTH_MM, PAGE_WIDTH};
 use crate::export::{export_notebook_to_bytes, ExportStrategy};

@@ -30,9 +31,13 @@ pub enum ImageBackground {
 }

 /// Erzeugt ein einseitiges PDF aus `page`.
-fn single_page_pdf(page: &Page, assets: Option<&AssetStore>) -> Result<Vec<u8>, Box<dyn Error>> {
+fn single_page_pdf(
+    page: &Page,
+    assets: Option<&AssetStore>,
+    pattern: PatternColor,
+) -> Result<Vec<u8>, Box<dyn Error>> {
    let notebook = Notebook::from_pages(vec![page.clone()], 0, 1, page.id + 1);
-    export_notebook_to_bytes(&notebook, ExportStrategy::FilledPolygon, assets)
+    export_notebook_to_bytes(&notebook, ExportStrategy::FilledPolygon, assets, pattern)
 }

 /// Seite ohne Raster und PDF-Hintergrund (für transparenten Export und Auswahlen).
@@ -91,11 +96,14 @@ pub fn page_png(
    page: &Page,
    assets: Option<&AssetStore>,
    background: ImageBackground,
+    pattern: PatternColor,
 ) -> Result<Vec<u8>, Box<dyn Error>> {
    let image = match background {
-        ImageBackground::Paper => rasterize(single_page_pdf(page, assets)?, PAGE_PNG_DPI, false)?,
+        ImageBackground::Paper => {
+            rasterize(single_page_pdf(page, assets, pattern)?, PAGE_PNG_DPI, false)?
+        }
        ImageBackground::Transparent => rasterize(
-            single_page_pdf(&content_only(page), assets)?,
+            single_page_pdf(&content_only(page), assets, pattern)?,
            PAGE_PNG_DPI,
            true,
        )?,
@@ -104,9 +112,13 @@ pub fn page_png(
 }

 /// Seite als SVG (Vektor; Schriften importierter PDFs werden zu Pfaden).
-pub fn page_svg(page: &Page, assets: Option<&AssetStore>) -> Result<String, Box<dyn Error>> {
-    let pdf =
-        Pdf::new(single_page_pdf(page, assets)?).map_err(|e| format!("PDF nicht lesbar: {e:?}"))?;
+pub fn page_svg(
+    page: &Page,
+    assets: Option<&AssetStore>,
+    pattern: PatternColor,
+) -> Result<String, Box<dyn Error>> {
+    let pdf = Pdf::new(single_page_pdf(page, assets, pattern)?)
+        .map_err(|e| format!("PDF nicht lesbar: {e:?}"))?;
    let pdf_page = pdf.pages().first().ok_or("PDF ohne Seite")?;
    Ok(hayro_svg::convert(
        pdf_page,
@@ -133,7 +145,11 @@ pub fn selection_image(
    let max_width = selected.strokes.iter().map(|s| s.width).fold(0.0, f32::max);
    let bounds: Aabb = bounds.expanded(max_width / 2.0 + 4.0);

-    let full = rasterize(single_page_pdf(&selected, assets)?, SELECTION_PNG_DPI, true)?;
+    let full = rasterize(
+        single_page_pdf(&selected, assets, PatternColor::default())?,
+        SELECTION_PNG_DPI,
+        true,
+    )?;
    // Seiteneinheiten → Pixel
    let px_per_unit = SELECTION_PNG_DPI / 25.4 * A4_WIDTH_MM / PAGE_WIDTH;
    let x0 = ((bounds.min.x * px_per_unit).floor().max(0.0) as u32).min(full.width);
@@ -190,12 +206,22 @@ mod tests {
    #[test]
    fn test_page_png_paper_and_transparent() {
        let page = page_with_line();
-        let paper = decode(&page_png(&page, None, ImageBackground::Paper).unwrap());
+        let paper = decode(
+            &page_png(&page, None, ImageBackground::Paper, PatternColor::default()).unwrap(),
+        );
        // A4 mit 200 dpi
        assert_eq!(paper.width(), (A4_WIDTH_MM / 25.4 * PAGE_PNG_DPI) as u32);
        assert_eq!(paper.get_pixel(5, 5).0[3], 255, "Papier ist deckend");

-        let clear = decode(&page_png(&page, None, ImageBackground::Transparent).unwrap());
+        let clear = decode(
+            &page_png(
+                &page,
+                None,
+                ImageBackground::Transparent,
+                PatternColor::default(),
+            )
+            .unwrap(),
+        );
        assert_eq!(clear.get_pixel(5, 5).0[3], 0, "Hintergrund ist transparent");
        // Die Linie ist rot und deckend
        let px_per_unit = clear.width() as f32 / PAGE_WIDTH;
@@ -207,9 +233,22 @@ mod tests {
        assert!(clear.height() as f32 / clear.width() as f32 - PAGE_HEIGHT / PAGE_WIDTH < 0.01);
    }

+    #[test]
+    fn test_export_uses_pattern_color() {
+        // Kariertes Blatt: das kräftige Muster ist im Export dunkler als das helle
+        let page = Page::new(1, PageBackground::Grid5mm);
+        let darkest = |pattern| {
+            let png = decode(&page_png(&page, None, ImageBackground::Paper, pattern).unwrap());
+            png.pixels().map(|p| p.0[1]).min().unwrap()
+        };
+        let light = darkest(PatternColor::Light);
+        let strong = darkest(PatternColor::Strong);
+        assert!(strong + 60 < light, "hell {light}, kräftig {strong}");
+    }
+
    #[test]
    fn test_page_svg_contains_ink() {
-        let svg = page_svg(&page_with_line(), None).unwrap();
+        let svg = page_svg(&page_with_line(), None, PatternColor::default()).unwrap();
        assert!(svg.starts_with("<svg") || svg.contains("<svg"));
        assert!(svg.contains("<path"));
        assert!(svg.trim_end().ends_with("</svg>"));
@@ -253,7 +292,15 @@ mod tests {
    #[test]
    fn test_exported_text_matches_screen_rendering() {
        let (page, text) = page_with_text();
-        let png = decode(&page_png(&page, None, ImageBackground::Transparent).unwrap());
+        let png = decode(
+            &page_png(
+                &page,
+                None,
+                ImageBackground::Transparent,
+                PatternColor::default(),
+            )
+            .unwrap(),
+        );
        let px_per_unit = png.width() as f32 / PAGE_WIDTH;
        let exported = ink_bounds(png.width(), png.as_raw());

@@ -278,12 +325,28 @@ mod tests {
    #[test]
    fn test_exported_text_follows_rotation() {
        let (mut page, _) = page_with_text();
-        let png = decode(&page_png(&page, None, ImageBackground::Transparent).unwrap());
+        let png = decode(
+            &page_png(
+                &page,
+                None,
+                ImageBackground::Transparent,
+                PatternColor::default(),
+            )
+            .unwrap(),
+        );
        let straight = ink_bounds(png.width(), png.as_raw());

        let center = page.strokes[0].aabb.min;
        page.strokes[0].rotate(center, std::f32::consts::FRAC_PI_2);
-        let png = decode(&page_png(&page, None, ImageBackground::Transparent).unwrap());
+        let png = decode(
+            &page_png(
+                &page,
+                None,
+                ImageBackground::Transparent,
+                PatternColor::default(),
+            )
+            .unwrap(),
+        );
        let rotated = ink_bounds(png.width(), png.as_raw());
        // 90° im Uhrzeigersinn: Breite und Höhe tauschen, Text liegt links vom Drehpunkt
        let (w, h) = (straight.2 - straight.0, straight.3 - straight.1);
@@ -302,7 +365,15 @@ mod tests {
        let mut page = page_with_line();
        page.size = glam::Vec2::new(2970.0, 1671.0);
        page.strokes[0].translate(glam::Vec2::new(1900.0, 500.0)); // x 2400–2800, y 1500
-        let png = decode(&page_png(&page, None, ImageBackground::Transparent).unwrap());
+        let png = decode(
+            &page_png(
+                &page,
+                None,
+                ImageBackground::Transparent,
+                PatternColor::default(),
+            )
+            .unwrap(),
+        );
        let ratio = png.width() as f32 / png.height() as f32;
        assert!((ratio - 2970.0 / 1671.0).abs() < 0.01, "{ratio}");
        let px_per_unit = png.width() as f32 / 2970.0;
@@ -312,7 +383,7 @@ mod tests {
        };
        assert!(at(2600.0, 1500.0)[3] > 200, "Strich liegt unten rechts");
        assert!(at(2600.0, 1300.0)[3] == 0);
-        let svg = page_svg(&page, None).unwrap();
+        let svg = page_svg(&page, None, PatternColor::default()).unwrap();
        assert!(svg.contains("<path"));
    }

@@ -6,7 +6,7 @@ use std::path::{Path, PathBuf};

 use serde::{Deserialize, Serialize};

-use crate::background::PaperTheme;
+use crate::background::{PaperTheme, PatternColor};
 use crate::storage::{self, StorageError};

 /// Fensterseite, an der die Werkzeugleiste angedockt ist.
@@ -82,6 +82,8 @@ pub struct UiSettings {
    pub paper_theme: PaperTheme,
    /// Dunkle Stiftfarben auf dunklem Papier aufhellen
    pub adapt_ink_colors: bool,
+    /// Farbe von Karos, Linien und Punkten (Anzeige und Export)
+    pub pattern_color: PatternColor,
    /// Druckkennlinie des Stifts
    pub pressure_curve: PressureCurve,
    /// Seiten durchgehend untereinander anzeigen (sonst einzeln blättern)
@@ -94,6 +96,7 @@ impl Default for UiSettings {
            sidebar_side: SidebarSide::default(),
            paper_theme: PaperTheme::default(),
            adapt_ink_colors: true,
+            pattern_color: PatternColor::default(),
            pressure_curve: PressureCurve::default(),
            continuous_scroll: true,
        }
@@ -148,6 +151,7 @@ mod tests {
            sidebar_side: SidebarSide::Right,
            paper_theme: PaperTheme::Black,
            adapt_ink_colors: false,
+            pattern_color: PatternColor::Strong,
            pressure_curve: PressureCurve {
                exponent: 1.8,
                threshold: 0.1,
@@ -178,6 +182,7 @@ mod tests {
        assert!(settings.adapt_ink_colors);
        assert_eq!(settings.pressure_curve, PressureCurve::default());
        assert!(settings.continuous_scroll);
+        assert_eq!(settings.pattern_color, PatternColor::Light);

        // Unsinnige Werte aus einer von Hand bearbeiteten Datei werden begrenzt
        std::fs::write(
@@ -2338,12 +2338,24 @@ mod tests {
        let (mut loaded, _) = load_notebook(&dir).unwrap();
        assert!(!loaded.pages[1].is_loaded);
        // Ohne Nachladen verweigert der Export, statt leere Seiten zu erzeugen
-        assert!(crate::export::generate_pdf_document(&loaded, Default::default(), None).is_err());
+        assert!(crate::export::generate_pdf_document(
+            &loaded,
+            Default::default(),
+            None,
+            Default::default()
+        )
+        .is_err());

        load_all_pages(&dir, &mut loaded).unwrap();
        assert_eq!(loaded.pages[1].strokes.len(), 1);
        assert_eq!(loaded.pages[1].background, PageBackground::Lined);
-        assert!(crate::export::generate_pdf_document(&loaded, Default::default(), None).is_ok());
+        assert!(crate::export::generate_pdf_document(
+            &loaded,
+            Default::default(),
+            None,
+            Default::default()
+        )
+        .is_ok());
    }

    #[test]
@@ -12,7 +12,7 @@
 use std::time::Instant;

 use crate::autosave::AutosaveStatus;
-use crate::background::{adapt_ink_color, PaperTheme};
+use crate::background::{adapt_ink_color, PaperTheme, PatternColor};
 use crate::document::{
    EraserMode, Notebook, Page, PageBackground, StrokeTool, PAGE_HEIGHT, PAGE_WIDTH,
 };
@@ -198,6 +198,8 @@ pub enum UiAction {
    SavePressureCurve(PressureCurve),
    /// Seiten durchgehend untereinander statt einzeln anzeigen (wird gespeichert)
    SetContinuousScroll(bool),
+    /// Farbe von Karos, Linien und Punkten (wird gespeichert, gilt auch für den Export)
+    SetPatternColor(PatternColor),
    /// Bilddatei auf der aktuellen Seite einfügen
    InsertImageFile(std::path::PathBuf),
    /// PDF als neues Notizbuch importieren
@@ -266,6 +268,8 @@ pub struct UiState {
    pub paper_theme: PaperTheme,
    /// Dunkle Tinte auf dunklem Papier aufhellen
    pub adapt_ink_colors: bool,
+    /// Farbe von Karos, Linien und Punkten
+    pub pattern_color: PatternColor,
    /// Seiten hängen untereinander und werden durchgehend gescrollt
    pub continuous_scroll: bool,
    /// Text-Werkzeug: Farbe, Schriftgröße (Punkt) und Schriftart neuer Textfelder
@@ -335,6 +339,7 @@ impl Default for UiState {
            eraser_mode: EraserMode::All,
            paper_theme: PaperTheme::White,
            adapt_ink_colors: true,
+            pattern_color: PatternColor::Light,
            continuous_scroll: true,
            text_color: PEN_COLOR_PRESETS[0].0,
            text_size_pt: crate::text::DEFAULT_TEXT_SIZE_PT,
@@ -1283,6 +1288,49 @@ fn paper_theme_button(ui: &mut egui::Ui, theme: PaperTheme, selected: bool) -> e
    response
 }

+/// Knopf für eine Musterfarbe: Vorschau (kleines Karo auf der aktuellen Papierfarbe) und
+/// Bezeichnung.
+fn pattern_color_button(
+    ui: &mut egui::Ui,
+    pattern: PatternColor,
+    paper: PaperTheme,
+    selected: bool,
+) -> egui::Response {
+    let response = ui.add_sized(
+        [82.0, 28.0],
+        egui::SelectableLabel::new(selected, format!("      {}", pattern.label())),
+    );
+    let swatch = egui::Rect::from_center_size(
+        egui::pos2(response.rect.min.x + 15.0, response.rect.center().y),
+        egui::vec2(16.0, 16.0),
+    );
+    let painter = ui.painter();
+    painter.rect_filled(
+        swatch,
+        egui::Rounding::same(3.0),
+        linear_color32(paper.paper_color()),
+    );
+    let line = egui::Stroke::new(1.5_f32, linear_color32(pattern.color(paper)));
+    for t in [0.33, 0.67] {
+        let x = swatch.min.x + swatch.width() * t;
+        let y = swatch.min.y + swatch.height() * t;
+        painter.line_segment(
+            [egui::pos2(x, swatch.min.y), egui::pos2(x, swatch.max.y)],
+            line,
+        );
+        painter.line_segment(
+            [egui::pos2(swatch.min.x, y), egui::pos2(swatch.max.x, y)],
+            line,
+        );
+    }
+    painter.rect_stroke(
+        swatch,
+        egui::Rounding::same(3.0),
+        egui::Stroke::new(1.0_f32, egui::Color32::from_gray(120)),
+    );
+    response.on_hover_text("Gilt für alle Seiten, auch beim Export")
+}
+
 /// Schieberegler für die Druckkurve mit Vorschau der Kennlinie. Änderungen gelten sofort
 /// (`state.pressure_curve`); zurückgegeben wird die Kurve, sobald sie gespeichert werden soll
 /// (Regler losgelassen oder per Tastatur geändert).
@@ -2664,6 +2712,25 @@ pub fn render_ui(
                                });
                            }

+                            section(ui, "KAROS, LINIEN UND PUNKTE");
+                            ui.horizontal_wrapped(|ui| {
+                                ui.spacing_mut().item_spacing = egui::vec2(6.0, 6.0);
+                                for pattern in PatternColor::ALL {
+                                    if pattern_color_button(
+                                        ui,
+                                        pattern,
+                                        state.paper_theme,
+                                        state.pattern_color == pattern,
+                                    )
+                                    .clicked()
+                                        && state.pattern_color != pattern
+                                    {
+                                        state.pattern_color = pattern;
+                                        actions.push(UiAction::SetPatternColor(pattern));
+                                    }
+                                }
+                            });
+
                            section(ui, "ANSICHT");
                            if ui
                                .checkbox(&mut state.continuous_scroll, "Seiten durchgehend scrollen")
Author	SHA1	Message	Date
haraldandClaude Opus 5.5	ffab2cea7a	chore(release): bump version to 0.12.0 Build & Publish Release / Build Packages & Publish to Gitea (push) Successful in 7m23s Details Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-08 09:31:45 +02:00
haraldandClaude Opus 5.5	614dd140a1	docs: README und Dokumentation auf den aktuellen Stand README, ARCHITECTURE.md und FILE_FORMAT.md beschreiben jetzt alle Funktionen bis v0.11 (Text, Bilder, PDF-Import, Seitenformate, Lineal, durchgehendes Scrollen, Musterfarben, Dateiformat-Version 8). Werbliche Formulierungen durch überprüfbare Angaben ersetzt, auch in Paket- beschreibung, Desktop-Datei, AppStream-Metadaten und Release-Notizen. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-08 09:21:42 +02:00
haraldandClaude Opus 5.5	0a6b5e78ef	feat: Farbe von Karos, Linien und Punkten wählbar Im ☰-Menü unter „Karos, Linien und Punkte“: hell (bisher), mittel, kräftig, blau oder grün – passend zur gewählten Papierfarbe. Die Wahl wird gespeichert und gilt auch für PDF-, PNG- und SVG-Export (Issue #6). Punkte des Punktrasters sind am Bildschirm jetzt 0,4 mm groß wie im Export (bisher 0,25 mm, beim Herauszoomen kaum sichtbar). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-08 09:21:42 +02:00
haraldandClaude Opus 5.5	901c91d10c	chore(release): bump version to 0.11.0 Build & Publish Release / Build Packages & Publish to Gitea (push) Successful in 6m13s Details Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-08 08:50:54 +02:00