feat: Tasten am Stift belegen (Issue #23 )

- Im ☰-Menü unter Eingabe → „Tasten am Stift“: je Taste Radieren (Standard), Auswählen, Textmarker, Stift oder Nichts; gilt, solange die Taste gedrückt ist - Tasten werden beim ersten Drücken gelernt und in ui.json gemerkt; die gerade gedrückte leuchtet im Menü grün - Mit einer Werkzeug-Taste geschriebene Striche benutzen dieses Werkzeug, danach ist wieder das gewählte Werkzeug aktiv Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
chore(release): bump version to 0.19.0
2026-10-08 19:05:09 +02:00 · 2026-10-08 18:47:28 +02:00 · 2026-10-08 18:46:51 +02:00 · 2026-10-08 17:42:38 +02:00 · 2026-10-08 17:41:05 +02:00 · 2026-10-08 17:10:14 +02:00
32 changed files with 5500 additions and 1682 deletions
@@ -1393,7 +1393,7 @@ dependencies = [
 [[package]]
 name = "ink-notes"
-version = "0.10.0"
+version = "0.19.0"
 dependencies = [
 "ab_glyph",
 "arboard",
@@ -1,8 +1,8 @@
 [package]
 name = "ink-notes"
-version = "0.10.0"
+version = "0.19.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,285 +1,230 @@
-# 🖋️ ink-notes
+<p align="center">
  <img src="assets/ink-notes-banner.svg" alt="ink-notes Banner" width="100%">
 </p>
-Eine latenzoptimierte, hardwarebeschleunigte Inking- und Notizbuch-Anwendung für Linux, entwickelt in **Rust** mit **wgpu** und **winit**.
+<p align="center">
-
+  <strong>Eine moderne Notizbuch-App für Linux zum Schreiben mit Stift, Touch und Maus</strong><br>
-`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.
+  Geschrieben in <strong>Rust</strong> mit <strong>wgpu</strong>, <strong>winit</strong> und <strong>egui</strong>.
 </p>
 ---
-## ✨ Features im Überblick
+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.
-### ⚡ Latenzoptimierte Inking-Pipeline
+Getestet wird vor allem unter Zorin OS 18 / Ubuntu 24.04 (Wayland und X11).
 - **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.
 ### 🔍 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 500 %** 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`).
 ### 📐 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.
 ### 🖐️ 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.
 ### 📚 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 & Hintergründe
 - **Virtuelles DIN-A4-Raster:** 2100 × 2970 Koordinateneinheiten (10 Einheiten = 1 mm).
 - **Hintergrundmuster:** Blanko, Kariert (5 mm), Liniert (7.5 mm), Punktraster (5 mm).
 - **Seitenverwaltung:** Vor- und Zurückblättern, neue Seiten anfügen, Seitensprung-Menü.
 ### 💾 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.
 ### 🖨️ 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`.
 ---
-## 📦 Release, Packaging & Updater
+## Funktionen
- **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).
+### Schreiben und Zeichnen
- **Portables .AppImage**: Eigenständiges x86_64 Bundle.
+- **Vier Stifte** in der Werkzeugleiste, jeder mit eigener Farbe und Stärke (0,15–5 mm, mit Druckstärke). Ändert man Farbe oder Stärke, merkt sich der gewählte Stift das – auch über einen Neustart hinweg. **Textmarker** (halbtransparent, 4–8 mm) in vier Farben; innerhalb eines Strichs wird er nicht dunkler, erst ein neuer Strich deckt stärker.
- **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.
+- **Eigene Farben:** Jede Farbe in der Werkzeugleiste (Stifte, Textmarker, Text) lässt sich anpassen – gewählte Farbe erneut antippen, eine Vorgabe oder mit 🎨 einen freien Farbton wählen. Die Leiste merkt sich die Farben. Am Bildschirm erscheinen sie genauso wie im PDF- und Bildexport.
 - **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).
 - **Tasten am Stift** im ☰-Menü belegen: Radieren (Standard), Auswählen, Textmarker, Stift oder nichts – gilt, solange die Taste gedrückt ist. Jede Taste erscheint dort nach dem ersten Drücken.
 - **Radierer** in drei Modi: ganze Striche, nur den überstrichenen Teil (Teilstrich) oder nur Textmarker. Die Stiftrückseite radiert ebenfalls.
 - **Virtuelles Lineal** (`L`): verschieben, am Griff drehen (rastet bei 15° ein); Striche entlang einer Kante werden gerade.
-### 1. Release-Pakete bauen
+### 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.
 ### 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.
 ### 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.
 - **Einfügen per Finger:** Lange (½ s) mit dem Finger aufs Blatt drücken öffnet ein Menü „Einfügen“ – Screenshot, kopierter Text oder kopierte Objekte landen genau an dieser Stelle.
 - **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.
 ### 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 lückenlos untereinander, eine dunkle Linie markiert die Grenze; wer im unteren Fünftel der letzten Seite schreibt, bekommt automatisch eine neue Seite. Abschaltbar (dann Seite für Seite blättern, mit Pfeilen in der Werkzeugleiste).
 - **Seiten einfügen und löschen:** ➕ in der Werkzeugleiste fügt nach der aktuellen Seite eine leere Seite ein. Löschen im ☰-Menü (mit Rückfrage); die zuletzt gelöschte Seite lässt sich dort wiederherstellen, solange die App läuft.
 - **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).
 ### Notizbücher und Speichern
 - Mehrere **Notizbücher** anlegen, umbenennen, wechseln und löschen (gelöschte landen zunächst im Papierkorb und lassen sich wiederherstellen).
 - **Ordner** für Notizbücher, beliebig verschachtelt (z. B. 3. Semester › Mathe): anlegen, umbenennen, löschen (der Inhalt rückt eine Ebene nach oben) und Notizbücher wie Ordner (samt Inhalt) mit 📂 verschieben. Neue Notizbücher landen im gerade geöffneten Ordner.
 - **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.
 ### 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ü.
 ### 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).
 ---
 ## Installation
 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/
+# Debian-Paket (Zorin OS 18 / Ubuntu 24.04)
-./scripts/build-release.sh
+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/`:
+Hinweise:
- `ink-notes_0.1.0_amd64.deb`
+- Benötigt `glibc >= 2.39` (Ubuntu 24.04, Zorin OS 18) und einen Grafiktreiber mit Vulkan oder OpenGL.
- `ink-notes_0.1.0_x86_64.AppImage`
+- Meldet das AppImage einen Fehler zu `libfuse.so.2`, entweder `sudo apt install libfuse2t64` installieren oder mit `--appimage-extract-and-run` starten.
- `SHA256SUMS.txt`
+
- `SHA256SUMS.txt.minisig` (nur mit gesetztem `MINISIGN_SECRET_KEY`, siehe unten)
+---
 ## 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
 ├── library.rs      # Ordner der Notizbücher (library.json)
 ├── 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.
+`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.
 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.
-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 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.
 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.
 ---
-## 🚀 Schnellstart (Entwicklung)
+## Sicherheit der Updates
-### Voraussetzungen
+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.
- **Rust & Cargo:** Version 1.75 oder neuer (`rustup update stable`)
+2. **Prüfsumme:** Der SHA-256-Wert des heruntergeladenen Pakets muss zum Eintrag in der signierten Liste passen, sonst wird die Datei gelöscht.
- **System-Bibliotheken (Linux):**
+3. **Nur HTTPS:** Auch Download-Links und Weiterleitungen müssen HTTPS sein. Bei Weiterleitungen auf einen anderen Server wird der `Authorization`-Header nicht mitgeschickt.
-  - Vulkan-Treiber (z. B. `mesa-vulkan-drivers` oder proprietäre Treiber)
+4. **Eigener Download-Ordner:** `~/.cache/ink-notes/updates` (Rechte `0700`); Dateinamen mit Pfadtrennern, `..` oder Steuerzeichen werden abgelehnt.
-  - X11 / Wayland Bibliotheken (`libx11-dev`, `libxcursor-dev`, `libxrandr-dev`, `libxi-dev`, `libxkbcommon-dev`)
+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.
 ### 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
 ```
 ---
-## ⌨️ Tastatur- & Maus-Shortcuts
+## Lizenz
-| Aktion | Tastenkürzel / Mausgeste |
+[MIT](LICENSE), Copyright © 2026 Harald Pansi.
 | :--- | :--- |
 | **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).
@@ -0,0 +1,178 @@
 <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1200 360" width="1200" height="360">
  <defs>
    <!-- Haupt-Hintergrund-Verlauf -->
    <linearGradient id="bannerBg" x1="0%" y1="0%" x2="100%" y2="100%">
      <stop offset="0%" stop-color="#0f1420"/>
      <stop offset="40%" stop-color="#141a29"/>
      <stop offset="100%" stop-color="#090b12"/>
    </linearGradient>
    <!-- Subtiles Ambient Glow -->
    <radialGradient id="ambientGlow" cx="15%" cy="50%" r="45%">
      <stop offset="0%" stop-color="#3b82f6" stop-opacity="0.22"/>
      <stop offset="70%" stop-color="#1d4ed8" stop-opacity="0.05"/>
      <stop offset="100%" stop-color="#1d4ed8" stop-opacity="0"/>
    </radialGradient>
    <radialGradient id="ambientGlowRight" cx="85%" cy="30%" r="40%">
      <stop offset="0%" stop-color="#38bdf8" stop-opacity="0.10"/>
      <stop offset="100%" stop-color="#38bdf8" stop-opacity="0"/>
    </radialGradient>
    <!-- Icon Hintergrund-Verlauf -->
    <linearGradient id="bgGrad" x1="0%" y1="0%" x2="100%" y2="100%">
      <stop offset="0%" stop-color="#1e2638"/>
      <stop offset="50%" stop-color="#141824"/>
      <stop offset="100%" stop-color="#0c0e17"/>
    </linearGradient>
    <!-- Stiftkörper-Verlauf -->
    <linearGradient id="penBody" x1="0%" y1="0%" x2="100%" y2="100%">
      <stop offset="0%" stop-color="#3b82f6"/>
      <stop offset="100%" stop-color="#1d4ed8"/>
    </linearGradient>
    <!-- Goldene Feder-Spitze -->
    <linearGradient id="nibGrad" x1="0%" y1="0%" x2="100%" y2="100%">
      <stop offset="0%" stop-color="#fbbf24"/>
      <stop offset="50%" stop-color="#f59e0b"/>
      <stop offset="100%" stop-color="#d97706"/>
    </linearGradient>
    <!-- Tintenspur-Verlauf -->
    <linearGradient id="inkGrad" x1="0%" y1="0%" x2="100%" y2="100%">
      <stop offset="0%" stop-color="#60a5fa" stop-opacity="0.95"/>
      <stop offset="50%" stop-color="#3b82f6" stop-opacity="0.85"/>
      <stop offset="100%" stop-color="#2563eb" stop-opacity="0.4"/>
    </linearGradient>
    <!-- Text Ink Gradient -->
    <linearGradient id="textInkGrad" x1="0%" y1="0%" x2="100%" y2="0%">
      <stop offset="0%" stop-color="#60a5fa"/>
      <stop offset="100%" stop-color="#38bdf8"/>
    </linearGradient>
    <!-- Leucht-Effekt -->
    <filter id="glow" x="-20%" y="-20%" width="140%" height="140%">
      <feGaussianBlur stdDeviation="8" result="blur" />
      <feComposite in="SourceGraphic" in2="blur" operator="over" />
    </filter>
    <filter id="iconShadow" x="-10%" y="-10%" width="120%" height="130%">
      <feDropShadow dx="0" dy="12" stdDeviation="16" flood-color="#000000" flood-opacity="0.6"/>
    </filter>
    <!-- Gitter-Muster für Hintergrund -->
    <pattern id="gridPattern" width="30" height="30" patternUnits="userSpaceOnUse">
      <path d="M 30 0 L 0 0 0 30" fill="none" stroke="#94a3b8" stroke-width="0.8" opacity="0.07"/>
    </pattern>
  </defs>
  <!-- Banner-Rahmen & Hintergrund -->
  <rect width="1200" height="360" rx="20" fill="url(#bannerBg)" stroke="#27324b" stroke-width="2"/>
  <!-- Hintergrund-Gitter (Notizbuch-Raster) -->
  <rect width="1200" height="360" rx="20" fill="url(#gridPattern)"/>
  <!-- Subtile Glows -->
  <rect width="1200" height="360" rx="20" fill="url(#ambientGlow)"/>
  <rect width="1200" height="360" rx="20" fill="url(#ambientGlowRight)"/>
  <!-- ==================== LINKER BEREICH: APP-ICON ==================== -->
  <g transform="translate(65, 55) scale(0.488)" filter="url(#iconShadow)">
    <!-- App-Icon Hintergrund (Squircle) -->
    <rect x="24" y="24" width="464" height="464" rx="104" ry="104" fill="url(#bgGrad)" stroke="#384260" stroke-width="4"/>
    <!-- DIN-A4 Dokumenten-Gitter im Icon -->
    <g opacity="0.14" stroke="#94a3b8" stroke-width="2">
      <line x1="80" y1="160" x2="432" y2="160" />
      <line x1="80" y1="220" x2="432" y2="220" />
      <line x1="80" y1="280" x2="432" y2="280" />
      <line x1="80" y1="340" x2="432" y2="340" />
      <line x1="80" y1="400" x2="432" y2="400" />
      <line x1="140" y1="100" x2="140" y2="430" />
      <line x1="200" y1="100" x2="200" y2="430" />
      <line x1="260" y1="100" x2="260" y2="430" />
      <line x1="320" y1="100" x2="320" y2="430" />
      <line x1="380" y1="100" x2="380" y2="430" />
    </g>
    <!-- Tintenspur -->
    <path d="M 110 390 C 180 430, 260 380, 240 310 C 220 240, 280 190, 340 220" 
          fill="none" stroke="url(#inkGrad)" stroke-width="26" stroke-linecap="round" filter="url(#glow)"/>
    <path d="M 110 390 C 180 430, 260 380, 240 310 C 220 240, 280 190, 340 220" 
          fill="none" stroke="#93c5fd" stroke-width="12" stroke-linecap="round"/>
    <!-- Stylus / Füllfederhalter -->
    <g transform="translate(240, 110) rotate(45)">
      <rect x="-24" y="-140" width="48" height="150" rx="8" fill="url(#penBody)" stroke="#60a5fa" stroke-width="3"/>
      <rect x="-22" y="10" width="44" height="26" rx="4" fill="#1e293b" stroke="#cbd5e1" stroke-width="2"/>
      <rect x="-25" y="6" width="50" height="6" fill="#f8fafc"/>
      <path d="M -20 36 L 20 36 L 12 85 L 0 115 L -12 85 Z" fill="url(#nibGrad)" stroke="#fef08a" stroke-width="2"/>
      <line x1="0" y1="46" x2="0" y2="108" stroke="#78350f" stroke-width="3" stroke-linecap="round"/>
      <circle cx="0" cy="65" r="4" fill="#78350f"/>
    </g>
    <!-- Glanzpunkt -->
    <circle cx="110" cy="390" r="14" fill="#60a5fa" filter="url(#glow)"/>
    <circle cx="110" cy="390" r="8" fill="#ffffff"/>
  </g>
  <!-- ==================== RECHTER BEREICH: TYPOGRAFIE & BADGES ==================== -->
  <g transform="translate(360, 0)">
    <!-- Version & Platform Pill -->
    <g transform="translate(0, 68)">
      <rect width="254" height="30" rx="15" fill="#1e293b" stroke="#334155" stroke-width="1.2"/>
      <circle cx="16" cy="15" r="4" fill="#22c55e"/>
      <text x="28" y="20" font-family="-apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Ubuntu, sans-serif" font-size="13" font-weight="600" fill="#cbd5e1" letter-spacing="0.5">
        v0.14.0 • LINUX • RUST &amp; WGPU
      </text>
    </g>
    <!-- Haupttitel: ink-notes -->
    <text x="0" y="162" font-family="-apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Ubuntu, sans-serif" font-weight="800" font-size="64" letter-spacing="-1">
      <tspan fill="url(#textInkGrad)">ink</tspan><tspan fill="#f8fafc">-notes</tspan>
    </text>
    <!-- Subtitle / Tagline -->
    <text x="0" y="206" font-family="-apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Ubuntu, sans-serif" font-weight="400" font-size="22" fill="#94a3b8">
      Notizbuch- &amp; PDF-Annotations-App für Stift, Touch und Maus
    </text>
    <!-- Feature Pills / Highlights -->
    <g transform="translate(0, 248)">
      <!-- Pill 1: Niedrige Latenz -->
      <g transform="translate(0, 0)">
        <rect width="186" height="36" rx="10" fill="#182236" stroke="#253554" stroke-width="1"/>
        <text x="14" y="23" font-family="-apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Ubuntu, sans-serif" font-size="13.5" font-weight="500" fill="#93c5fd">
          ⚡ Schnelles wgpu-Inking
        </text>
      </g>
      <!-- Pill 2: Stylus mit Druck -->
      <g transform="translate(198, 0)">
        <rect width="190" height="36" rx="10" fill="#182236" stroke="#253554" stroke-width="1"/>
        <text x="14" y="23" font-family="-apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Ubuntu, sans-serif" font-size="13.5" font-weight="500" fill="#93c5fd">
          🖊️ Druck &amp; Palm Rejection
        </text>
      </g>
      <!-- Pill 3: Formerkennung -->
      <g transform="translate(400, 0)">
        <rect width="182" height="36" rx="10" fill="#182236" stroke="#253554" stroke-width="1"/>
        <text x="14" y="23" font-family="-apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Ubuntu, sans-serif" font-size="13.5" font-weight="500" fill="#93c5fd">
          📐 Formenerkennung &amp; Lineal
        </text>
      </g>
      <!-- Pill 4: 100% lokal -->
      <g transform="translate(594, 0)">
        <rect width="176" height="36" rx="10" fill="#182236" stroke="#253554" stroke-width="1"/>
        <text x="14" y="23" font-family="-apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Ubuntu, sans-serif" font-size="13.5" font-weight="500" fill="#93c5fd">
          🔒 100% lokal &amp; atomar
        </text>
      </g>
    </g>
  </g>
 </svg>
@@ -1,153 +1,192 @@
-# 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]
+[Stift / Touch / Maus]
-              │
+          │  Bildschirmposition, Druck, Zeit
-              ▼
+          ▼
-       [winit Event-Loop]
+[Bildschirm → Seitenkoordinaten]   (viewport.rs)
-              │ (tx, ty, pressure, timestamp)
+          │
-              ▼
+          ▼
-   [Viewport Invertierung]  (screen_to_page: Umrechnung in DIN-A4-Einheiten)
+[Druckkurve]                        (settings.rs, vom Nutzer einstellbar)
-              │
+          │
-              ▼
+          ▼
-       [1€-Filter]          (Jitter-Beseitigung bei langsamen Bewegungen)
+[1€-Filter]                         (filter.rs)
-              │
+          │
-              ▼
+          ▼
- [Centripetal Catmull-Rom]  (C1-stetige Spline-Interpolation, alpha = 0.5)
+[Catmull-Rom-Spline + Dreiecksstreifen]   (spline.rs) → Live-Puffer auf der GPU
-              │
+          │  Stift abgehoben
-              ▼
+          ▼
-   [Mesh-Tessellierung]     (Drucksensitive Dreiecksstreifen via Normalen)
+[Nachbearbeitung]                   (spline.rs: finalize_stroke)
-              │
+          │
-              ▼
+          ▼
-       [wgpu GPU-Buffer]    (Vertex- & Index-Buffer im VRAM)
+[Strich auf der Seite + Undo-Eintrag]   (document.rs, history.rs)
 ```
-### 1.1. 1€-Filter (One-Euro-Filter)
+### 2.1 1€-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).
+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
+Bei langsamer Bewegung glättet er stark, bei schneller kaum.
 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.
-### 1.3. Drucksensitive Dreiecksstreifen (Tessellierung)
+### 2.2 Zentripetaler Catmull-Rom-Spline
-Aus den interpolierten Spline-Punkten mit Radius $r_i = f(\text{pressure}_i)$ wird ein Triangle-Strip erzeugt:
+Die gefilterten Punkte werden mit einem zentripetalen Catmull-Rom-Spline ($\alpha = 0{,}5$) interpoliert:
 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$$
-### 1.4. Zwei-Stufen-Modell (Live-Glättung vs. akausale Post-Stroke-Finalisierung)
+$$t_{i+1} = t_i + \lVert P_{i+1} - P_i \rVert^{\alpha}$$
 Um minimale Latenz beim Zeichnen mit maximaler Präzision und Ecken-Erhaltung zu verbinden, arbeitet `ink-notes` mit einem strikten Zwei-Stufen-Modell:
-1. **Live-Phase (Kausal, Zero-Latency):**
+Diese Parametrisierung erzeugt bei engen Kurven keine Schlaufen oder Spitzen und ist an den Stützstellen $C^1$-stetig.
-   - 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.3 Dreiecksstreifen
-2. **Commit-Phase (Akausal, `finalize_stroke`):**
+Aus den Spline-Punkten mit Radius $r_i$ (aus Druck und Strichstärke) entsteht ein Dreiecksstreifen:
-   - 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.
+$$V_{i,\text{links}} = P_i + N_i \cdot r_i, \qquad V_{i,\text{rechts}} = P_i - N_i \cdot r_i$$
-     - **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.
+$N_i$ ist die Normale der Laufrichtung; an inneren Punkten wird über benachbarte Segmente gemittelt.
-     - **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.
+### 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
+### 3.1 Seitenkoordinaten
-Die Anwendung rechnet intern in virtuellen DIN-A4-Koordinaten:
+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.
 - Breite: **2100 Einheiten** (210 mm)
 - Höhe: **2970 Einheiten** (297 mm)
 - 1 mm entspricht exakt **10 Einheiten**.
-### 2.2. Viewport & Projektionsmatrix (`viewport.rs`)
+### 3.2 Maßstab und Kamera
-Der Vertex-Shader transformiert DIN-A4-Koordinaten über eine Orthogonal-Projektion kombiniert mit Pan und Zoom in Normalized Device Coordinates (NDC, $[-1, 1]$):
+- `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
+- Im Shader wird jeder Punkt mit `transform_scale` und `transform_offset` (aus `CameraUniforms`) direkt in Gerätekoordinaten umgerechnet.
-In jedem Frame werden zwei Hauptpässe durchlaufen:
+
-1. **Pass 1 (Canvas):**
+### 3.3 Durchgehende Ansicht
-   - Hintergrund-Quad und Linien/Gitter (Instanced oder Batch Vertex-Buffer).
+Alle Koordinaten beziehen sich auf die **aktuelle Seite**. `PageStack` (`viewport.rs`) legt die übrigen Seiten lückenlos darunter bzw. darüber (die Grenze zeichnet die Oberfläche als dunkle Linie), 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).
-   - Gespeicherte Striche und Geometrie-Meshes.
+
-   - Aktiver Live-Strich (Ephemeral Buffer).
+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.
   - Auswahl-Overlay & Transformationsgriffe.
 2. **Pass 2 (egui UI):**
   - Floating Glassmorphism-Toolbar.
   - Farb- und Werkzeug-Popovers.
   - Modal-Dokumentenmanager.
 ---
-## 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)
+1. Für jede sichtbare Nachbarseite: Papier und Muster, Bilder/PDF-Seite/Text, Tinte.
-Reduziert den Rohpfad auf signifikante Eckpunkte mit konfigurierbarem Toleranzabstand $\epsilon$.
+2. Für die aktuelle Seite: Papier, Muster (Karo, Linien, Punkte), Bildebene, gespeicherte Striche, Live-Strich.
 3. Die `egui`-Oberfläche: Werkzeugleiste, Menüs, Seitengrenzen, Auswahlrahmen und Griffe, Lineal, Textbearbeitung.
-### 3.2. Erkennungsregeln:
+Jeder Strich ist ein eigener Draw-Call mit eigener Nummer im Stencil-Puffer: Ein Pixel, das der Strich schon gefärbt hat, wird kein zweites Mal gefärbt. So bleibt halbtransparente Tinte (Textmarker) gleichmäßig, auch wo sich der Strich selbst überlappt (Anfangskappe, Kehren, langsames Hin- und Herfahren); erst ein neuer Strich deckt stärker. Nach 255 Strichen setzt ein bildschirmfüllendes Dreieck den Stencil-Puffer zurück.
 - **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.
-### 3.3. Draw-and-Hold Erkennung
+### 4.1 Bildebene
-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.
+`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.
 ### 4.2 Papier- und Musterfarben
 Papierfarbe (`PaperTheme`) und Musterfarbe (`PatternColor`) stehen in `background.rs`; sie sind linear angegeben und werden im Shader nach sRGB umgerechnet. Tintenfarben (Striche, Text) sind sRGB-Werte – dieselben Zahlen landen im PDF und in den Farbpunkten der Oberfläche. Gezeichnet wird ohne sRGB-Umrechnung der GPU (`render_format`), Texturen sind `Rgba8Unorm`: So wird halbtransparente Tinte wie im PDF in sRGB gemischt und sieht am Bildschirm genauso aus wie im Export. 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]
+[Änderung]
-       │
+    │  mark_page_dirty / mark_manifest_dirty
-       ▼
+    ▼
- [mark_page_dirty]
+[AutosaveController]  ── 1,5 s nach der letzten Änderung, spätestens nach 10 s ──►  [Autosave-Thread]
-       │
+                                                                                        │
-       ▼
+                                                                                        ▼
-[AutosaveController] ──(1.5s Debounce)──► [Hintergrund-Thread (MPSC)]
+                                                                 [temporäre Datei schreiben + fsync]
-                                                   │
+                                                                                        │
-                                                   ▼
+                                                                                        ▼
-                                         [Temp-Datei *.tmp schreiben]
+                                                                 [rename über die alte Datei, Ordner-fsync]
                                                   │
                                                   ▼
                                         [Atomares std::fs::rename]
                                                   │
                                                   ▼
                                         [manifest.json / page_<id>.json]
 ```
- **Keine UI-Blockierung:** Disk-I/O erfolgt vollständig in einem dedizierten Worker-Thread.
+- Der Haupt-Thread schreibt nie selbst; er übergibt fertige Seitendaten an den Autosave-Thread.
- **Atomarität:** Daten werden stets zuerst in `.json.tmp` geschrieben und via `fs::rename` atomar ersetzt.
+- Schlägt ein Schreibvorgang fehl, wird die Seite mit wachsendem Abstand (1 s bis 30 s) erneut versucht; der Status wird rot.
- **Verlustfreier Notizbuchwechsel:** Bei `switch_notebook_dir` wird synchron `flush()` aufgerufen, um alle ungespeicherten Daten des aktuellen Dokuments sicherzustellen, bevor der Pfad gewechselt wird.
+- `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. Halbtransparente Striche (Textmarker) bekommen einen Grafikzustand mit Deckkraft (`ca`/`CA`); printpdf kann solche Zustände nicht anlegen, deshalb trägt `add_alpha_states` sie nach dem Speichern mit `lopdf` in die Seitenressourcen ein. Jeder Strich ist ein einziger Pfad und deckt sich daher nicht selbst doppelt.
 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,192 @@
-# 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
+## 1. Ordner
 Notizbücher werden standardmäßig unter dem XDG-Datenpfad gespeichert:
 ```text
-~/.local/share/ink-notes/
+~/.local/share/ink-notes/              ($XDG_DATA_HOME/ink-notes)
-└── notebooks/
+├── notebooks/
-    ├── <notebook_id_1>/
+│   ├── library.json                   Ordner der Notizbücher (siehe unten)
-    │   ├── manifest.json
+│   ├── <notizbuch-id>/
-    │   ├── manifest.json.v0.bak (optional, Migrations-Backup)
+│   │   ├── manifest.json              Metadaten und Seitenreihenfolge
-    │   ├── page_1.json
+│   │   ├── manifest.json.bak          Kopie des vorherigen Manifests
-    │   ├── page_1.json.corrupt-1775460000 (optional, Quarantäne bei Parsefehlern)
+│   │   ├── page_1.json                eine Datei je Seite
-    │   ├── page_2.json
+│   │   ├── page_2.json
-    │   └── ...
+│   │   ├── page_7.json.corrupt-<ts>   beiseitegelegte beschädigte Seite (falls vorgekommen)
-    └── <notebook_id_2>/
+│   │   ├── assets/                    eingefügte Bilder und importierte PDFs
-        ├── manifest.json
+│   │   │   ├── <sha256>.png
-        └── page_1.json
+│   │   │   └── <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`)
+### Ordner (`library.json`)
-
+Ordner wie „3. Semester › Mathe“ sind rein logisch: Die Notizbücher bleiben in ihren Verzeichnissen, `library.json` hält nur fest, welcher Ordner welches Notizbuch enthält. Umbenennen, Verschieben (samt Inhalt) und Löschen von Ordnern ändern deshalb nie eine Notizbuch-Datei.
 Das Manifest enthält Metadaten über das gesamte Dokument sowie die Reihenfolge und IDs aller Seiten:
 ```json
 {
-  "format_version": 2,
+  "folders": ["3. Semester", "3. Semester/Mathe", "4. Semester"],
-  "id": "notebook-a1b2c3d4",
+  "notebooks": { "analysis_1775460000": "3. Semester/Mathe" }
  "title": "Mathematik Vorlesung",
  "pages": [
    {
      "id": 1,
      "background": "Grid5mm"
    },
    {
      "id": 2,
      "background": "DotGrid"
    }
  ],
  "page_ids": [1, 2],
  "current_page_index": 0,
  "next_page_id": 3,
  "next_stroke_id": 42,
  "created_at": 1775460000,
  "modified_at": 1775463600
 }
 ```
-### Felder:
+- Ordner sind Pfade mit `/` als Trenner; Namen enthalten selbst kein `/` und höchstens 80 Zeichen.
- `format_version`: Format-Versionsnummer (aktuell `2`, bei unversionierten Legacy-Dateien implizit `0`).
+- Notizbücher ohne Eintrag liegen auf der obersten Ebene.
- `id`: Eindeutige ID des Notizbuchs (z. B. UUID oder `"default"`).
+- Wird ein Ordner gelöscht, rücken seine Notizbücher und Unterordner eine Ebene nach oben.
- `title`: Vom Nutzer vergebener Anzeigename des Notizbuchs.
+- Fehlt die Datei oder ist sie unlesbar, liegen alle Notizbücher auf der obersten Ebene; fehlende übergeordnete Ordner werden beim Laden ergänzt.
 - `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.
 ---
-## 3. Seitendatei (`page_<id>.json`)
+## 2. Manifest (`manifest.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.
 ```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": "vorlesung_1775460000",
  "title": "Vorlesung",
  "created_at": 1775460000,
  "modified_at": 1775463600,
  "current_page_index": 0,
  "pages": [
    { "id": 1, "background": "Blank", "title": "Einführung", "size": [2970.0, 1671.0] },
    { "id": 2, "background": "Grid5mm" }
  ],
  "page_ids": [1, 2],
  "next_stroke_id": 42,
  "next_page_id": 3
 }
 ```
-### Felder:
+| Feld | Bedeutung |
- `format_version`: Format-Versionsnummer (`2`).
+| :--- | :--- |
- `id`: Eindeutige ID der Seite.
+| `format_version` | Formatversion (siehe Abschnitt 5) |
- `background`: Papiermuster (`Blank`, `Grid5mm`, `Lined`, `DotGrid`).
+| `id`, `title` | ID (= Ordnername) und Anzeigename |
- `strokes`: Liste der auf der Seite gezeichneten Striche und Vektorformen.
+| `created_at`, `modified_at` | UNIX-Zeit in Sekunden |
-  - `id`: Eindeutige ID des Strichs.
+| `current_page_index` | zuletzt geöffnete Seite |
-  - `color`: RGBA-Farbwerte im Bereich `[0.0, 1.0]`.
+| `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 |
-  - `samples`: Rohabtastpunkte entlang des Pfads (`x`, `y` in DIN-A4-Einheiten, `p` Druckwert in `[0.0, 1.0]`, `t` Zeitstempel in Sekunden).
+| `page_ids` | dieselbe Reihenfolge als reine ID-Liste (für ältere Versionen) |
-  - `shape`: Optionales Enum für geometrische Vektorformen:
+| `next_stroke_id`, `next_page_id` | nächste freie IDs |
    - `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.
 ---
-## 4. Datensicherheit & Migration
+## 3. Seite (`page_<id>.json`)
-### Atomares Schreiben & Verzeichnis-Sync
+Jede Seite liegt in einer eigenen Datei (kompaktes JSON, hier zur Lesbarkeit umbrochen):
 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`.
-### Quarantäne bei Parsefehlern
+```json
-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.
+{
  "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": [ … ]
 }
 ```
-### Migrations-Backups & Rolling Backups
+| Feld | Bedeutung |
-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.
+| `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
 ---
-## 5. Versionshistorie
+## 4. Sicherheit beim Speichern
-| Version | Status | Beschreibung |
+### Atomares Schreiben
-|---|---|---|
+1. Der Inhalt wird in `<datei>.tmp.<pid>.<nanosekunden>` geschrieben und mit `fsync` auf den Datenträger gebracht.
-| **0** | Legacy | Unversioniertes Format. `format_version` fehlt in JSON. Implizit als Version 0 interpretiert. |
+2. `rename` ersetzt die alte Datei in einem Schritt.
-| **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`. |
+3. Danach wird auch der Ordner mit `fsync` gesichert.
-| **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). |
+
 Ein Absturz während des Speicherns hinterlässt deshalb entweder die alte oder die neue Datei, nie eine halbe.
 ### 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.
 ### Gelöschte Seiten
 Eine gelöschte Seite verschwindet aus `manifest.json`; ihre Datei `page_<id>.json` bleibt im Ordner liegen. Seitenkennungen werden nie wiederverwendet (`next_page_id`), die Datei kann also mit keiner neuen Seite kollidieren. Wird die Seite in derselben Sitzung wiederhergestellt, schreibt die App sie neu.
 ### 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.
 ---
-## 6. Analyse & Bewertung: Binärformat (z. B. `postcard`)
+## 5. Versionen
-Eine Umstellung auf ein Binärformat wie `postcard` wurde evaluiert:
+| Version | App | Änderung |
- **Vorteile**:
+| :--- | :--- | :--- |
-  - Weitere 20–30 % Reduktion der Dateigröße gegenüber kompaktem JSON.
+| 0 | – | ohne `format_version` |
-  - Minimal schnellere Serialisierung auf leistungsschwachen Systemen.
+| 1 | – | `format_version`, Hintergründe im Manifest |
- **Nachteile**:
+| 2 | – | `tool`, `width`, `finalized` an Strichen; kompaktes JSON |
-  - Verlust der Text-Transparenz (JSON lässt sich direkt inspizieren, mit `git`/Tools diffen und bei Korruption manuell reparieren).
+| 3 | 0.3.7 | Formen `Ellipse` und `Arrow` |
-  - 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.
+| 4 | 0.5 | Bilder (`image`, Ordner `assets/`) |
-  - Kompaktes JSON spart bereits über 53 % Dateigröße ein.
+| 5 | 0.6.1 | importierte PDF-Seiten (`pdf_background`) |
- **Entscheidung**:
+| 6 | 0.7 | Seitentitel (`title` in Seite und Manifest) |
-  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.
+| 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. Warum JSON
 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,
+      ink-notes ist eine Notizbuch-App für Linux, geschrieben in Rust mit wgpu. Handschrift wird als
-      geschrieben in Rust mit wgpu. Sie bietet minimale Eingabelatenz mit Stylus, Touchpad oder Maus.
+      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>Stift und Textmarker mit Druckstärke, Glättung beim Schreiben und Ecken-Erhaltung</li>
-      <li>Automatische Geometrie- und Formerkennung (Geraden, Rechtecke, Kreise, Koordinatensysteme, Polygone)</li>
+      <li>Radierer für ganze Striche, Teilstriche oder nur Textmarker; virtuelles Lineal</li>
-      <li>Stufenloser Viewport mit cursor-zentriertem Zoom (25% bis 500%) und Panning</li>
+      <li>Formerkennung (Linien, Pfeile, Kreise, Ellipsen, Rechtecke, Dreiecke, Rauten, Koordinatensysteme)</li>
-      <li>Objektauswahl, Lasso, Skalieren, stufenloses Drehen und Multicolor-Umfärbung</li>
+      <li>Auswählen, Verschieben, Drehen, Skalieren und Umfärben; Rückgängig für alle Änderungen</li>
-      <li>Multi-Dokumenten- und Notizbuch-Verwaltung mit atomarem Autosave</li>
+      <li>Textfelder, Bilder und PDF-Import zum Beschriften (Querformat-Folien bekommen Querformat-Seiten)</li>
-      <li>Vektor-PDF-Export für Druck und Weitergabe</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,
+      ink-notes ist eine Notizbuch-App für Linux, geschrieben in Rust mit wgpu. Handschrift wird als
-      geschrieben in Rust mit wgpu. Sie bietet minimale Eingabelatenz mit Stylus, Touchpad oder Maus.
+      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>Stift und Textmarker mit Druckstärke, Glättung beim Schreiben und Ecken-Erhaltung</li>
-      <li>Automatische Geometrie- und Formerkennung (Geraden, Rechtecke, Kreise, Koordinatensysteme, Polygone)</li>
+      <li>Radierer für ganze Striche, Teilstriche oder nur Textmarker; virtuelles Lineal</li>
-      <li>Stufenloser Viewport mit cursor-zentriertem Zoom (25% bis 500%) und Panning</li>
+      <li>Formerkennung (Linien, Pfeile, Kreise, Ellipsen, Rechtecke, Dreiecke, Rauten, Koordinatensysteme)</li>
-      <li>Objektauswahl, Lasso, Skalieren, stufenloses Drehen und Multicolor-Umfärbung</li>
+      <li>Auswählen, Verschieben, Drehen, Skalieren und Umfärben; Rückgängig für alle Änderungen</li>
-      <li>Multi-Dokumenten- und Notizbuch-Verwaltung mit atomarem Autosave</li>
+      <li>Textfelder, Bilder und PDF-Import zum Beschriften (Querformat-Folien bekommen Querformat-Seiten)</li>
-      <li>Vektor-PDF-Export für Druck und Weitergabe</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,17 @@
 ## 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:
 - **Ordner verschieben**: Ordner lassen sich jetzt wie Notizbücher mit 📂 samt Inhalt in andere Ordner oder auf die oberste Ebene verschieben
 - **Ordner für Notizbücher**: Beliebig verschachtelte Ordner (z. B. 3. Semester › Mathe) im Dokumenten-Manager anlegen, umbenennen und löschen, Notizbücher mit 📂 verschieben; neue Notizbücher landen im geöffneten Ordner. Die Notizbuch-Dateien bleiben unverändert (Zuordnung in library.json)
 - **Einfügen per Finger**: Lange (½ s) mit dem Finger aufs Blatt drücken öffnet ein Menü „Einfügen“ – Screenshot, kopierter Text oder kopierte Objekte landen genau an dieser Stelle (wie in Rnote)
 - **Eigene Farben**: Jede Farbe der Werkzeugleiste (Stifte, Textmarker, Text) lässt sich anpassen – erneut antippen, Vorgabe oder mit 🎨 frei wählen; die Leiste merkt sich die Farben. Farben am Bildschirm wie im PDF-/Bildexport (Schwarz ist schwarz, Textmarker mischt wie im PDF); Karos und Linien im PDF so hell wie am Bildschirm
 - **Beta-Feedback II**: Vier Stifte mit eigener Farbe und Stärke, die sich Änderungen merken; Textmarker wird innerhalb eines Strichs nicht dunkler und ist jetzt auch im PDF-/PNG-/SVG-Export durchsichtig; Seiten lückenlos untereinander mit Trennlinie; neue Seite per ➕ in der Werkzeugleiste; Seite löschen im ☰-Menü (wiederherstellbar); Koordinatensystem ohne Loch am Ursprung
 - **Fehlerbehebungen**: Umbenennen und Löschen in der Notizbuchverwaltung reagieren wieder; Karos, Linien und Punkte werden pro Pixel berechnet und liegen in jedem Zoom gleichmäßig (mindestens ein Pixel breit, kantengeglättet)
 - **Strichqualität**: Kleine Schleifen wie in „o“, „a“ oder „e“ bleiben rund (der fertige Strich entsteht aus den ungefilterten Stiftpunkten); Strichkanten werden kantengeglättet (4× Multisampling), runde Strichenden sind feiner unterteilt
 - **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 +22,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 +30,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
+- **Aktive Stylus-Unterstützung (Lazarite / MPP / AES)**: Stifteingabe über das Tablet-Protokoll von Wayland bzw. X11, mit Druckstärke
- **Touchscreen Multi-Touch**: Stufenloses 2-Finger Pinch-to-Zoom und Panning mit umschaltbarem Finger-Zeichenmodus
+- **Touchscreen Multi-Touch**: Zoomen mit zwei Fingern, Verschieben mit einem; Zeichnen mit dem Finger zuschaltbar
- **Zwei-Stufen-Inking-Modell**: Kausale Echtzeit-Glättung via 1€-Filter & akausale Ecken-Erhaltung (Corner Preservation)
+- **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
+- **Mehrere Notizbücher**: Anlegen, umbenennen, löschen (mit Papierkorb); automatisches Speichern im Hintergrund
- **Datensicherheit**: Versioniertes Dateiformat mit Migration, Quarantäne beschädigter Seiten, Schutz vor Doppelöffnung und Crash-getestetem Speichern
+- **Datensicherheit**: Versioniertes Dateiformat mit Migration, beschädigte Seiten werden beiseitegelegt statt überschrieben, Schutz vor gleichzeitigem Öffnen, atomares Speichern
- **In-App Updater**: Automatische Versionsprüfung und sichere Atomar-Aktualisierung via Gitea Releases – mit Pflicht-Signaturprüfung (Minisign) und durchgängigem HTTPS
+- **In-App Updater**: Prüft auf neue Versionen auf Gitea und installiert sie auf Wunsch – nur mit gültiger Minisign-Signatur und über HTTPS
- **Vektor-PDF-Export**: Verlustfreie Ausgabe für Druck und Weitergabe
+- **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.
+  * See the release notes on https://gitea.pansi.eu/harald/ink-notes/releases
  * Shape recognition and infinite canvas with zoom/pan.
  * Multi-notebook management and PDF export.
 -- 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
+Description: Notizbuch-App für Stift, Touch und Maus
- ink-notes kombiniert minimale Stylus-Latenz mit GPU-Hardwarebeschleunigung (wgpu),
+ ink-notes speichert Handschrift als Vektoren, erkennt auf Wunsch Formen und
- stufenlosem Viewport, Geometrie- und Formerkennung, Objekt-Transformationen,
+ kann PDFs zum Beschriften importieren sowie Bilder und Textfelder einfügen.
- Multi-Dokumenten-Verwaltung und Vektor-PDF-Export.
+ Mehrere Notizbücher, automatisches Speichern und Export als PDF, PNG oder SVG.
 EOF
 chmod 644 "${STAGING_DIR}/DEBIAN/control"
@@ -3,12 +3,65 @@
 use serde::{Deserialize, Serialize};
 use crate::canvas::InkVertex;
-use crate::document::{PageBackground, PAGE_HEIGHT, PAGE_WIDTH};
+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).
+/// Punktgröße für das Punktraster in Seiteneinheiten (4 = 0,4 mm, wie im PDF-Export).
-pub const DOT_SIZE: f32 = 2.5;
+pub const DOT_SIZE: f32 = 4.0;
 /// Rasterabstand 5 mm (50 Einheiten).
 pub const GRID_5MM_SPACING: f32 = 50.0;
@@ -18,7 +71,8 @@ pub const LINED_SPACING: f32 = 75.0;
 /// Papierfarbe der Anzeige. Betrifft nur die Darstellung am Bildschirm; gespeicherte
 /// Strichfarben und der PDF-Export bleiben unverändert (weißes Papier).
 ///
-/// Alle Farben sind linear (die Oberfläche ist sRGB, die Umrechnung macht die GPU).
+/// Papier- und Musterfarben sind linear (der Shader rechnet sie in sRGB um); Tintenfarben
 /// dagegen sind sRGB-Werte wie im Export.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
 #[serde(rename_all = "lowercase")]
 pub enum PaperTheme {
@@ -85,7 +139,24 @@ impl PaperTheme {
            PaperTheme::DarkGray => (0.004, 0.004, 0.005),
            PaperTheme::Black => (0.03, 0.03, 0.035),
        };
-        wgpu::Color { r, g, b, a: 1.0 }
+        // Linear angegeben; gezeichnet wird ohne sRGB-Umrechnung
        let srgb = |c: f64| f64::from(linear_to_srgb(c as f32));
        wgpu::Color {
            r: srgb(r),
            g: srgb(g),
            b: srgb(b),
            a: 1.0,
        }
    }
 }
 /// Linearer Farbanteil (Papier, Muster) als sRGB-Wert (Tinte, Export).
 pub fn linear_to_srgb(c: f32) -> f32 {
    let c = c.clamp(0.0, 1.0);
    if c <= 0.003_130_8 {
        c * 12.92
    } else {
        1.055 * c.powf(1.0 / 2.4) - 0.055
    }
 }
@@ -99,165 +170,152 @@ pub fn adapt_ink_color(color: [f32; 4]) -> [f32; 4] {
    [color[0] + lift, color[1] + lift, color[2] + lift, color[3]]
 }
-/// Erzeugt die 6 Vertizes (2 Dreiecke) für das DIN-A4-Papierblatt.
+/// Erzeugt die 6 Vertizes (2 Dreiecke) für ein Blatt der Größe `size`.
-pub fn generate_paper_quad(color: [f32; 4]) -> Vec<InkVertex> {
+pub fn generate_paper_quad(color: [f32; 4], size: glam::Vec2) -> Vec<InkVertex> {
    let (page_width, page_height) = (size.x, size.y);
    vec![
        InkVertex::new(0.0, 0.0, color),
-        InkVertex::new(PAGE_WIDTH, 0.0, color),
+        InkVertex::new(page_width, 0.0, color),
-        InkVertex::new(0.0, PAGE_HEIGHT, color),
+        InkVertex::new(0.0, page_height, color),
-        InkVertex::new(0.0, PAGE_HEIGHT, color),
+        InkVertex::new(0.0, page_height, color),
-        InkVertex::new(PAGE_WIDTH, 0.0, color),
+        InkVertex::new(page_width, 0.0, color),
-        InkVertex::new(PAGE_WIDTH, PAGE_HEIGHT, color),
+        InkVertex::new(page_width, page_height, color),
    ]
 }
-/// Fügt ein Quad (2 Dreiecke) zur Vertexliste hinzu.
+/// Oberer und unterer Rand ohne Linien bei liniertem Papier (15 mm).
-#[inline]
+pub const LINED_MARGIN: f32 = 150.0;
-fn push_quad(
+
-    vertices: &mut Vec<InkVertex>,
+/// Ecke des Musterrechtecks: Das Muster selbst berechnet der Fragment-Shader (`fs_pattern`)
-    color: [f32; 4],
+/// für jedes Bildschirmpixel. So liegen Linien und Punkte in jedem Zoom exakt gleichmäßig,
-    x_min: f32,
+/// sind mindestens ein Pixel breit und kantengeglättet – vorher gerasterte Haarlinien
-    y_min: f32,
+/// fielen je nach Lage auf das Pixelraster und wirkten unregelmäßig.
-    x_max: f32,
+#[repr(C)]
-    y_max: f32,
+#[derive(Copy, Clone, Debug, PartialEq, bytemuck::Pod, bytemuck::Zeroable)]
-) {
+pub struct PatternVertex {
-    vertices.push(InkVertex::new(x_min, y_min, color));
+    /// Seitenkoordinate
-    vertices.push(InkVertex::new(x_max, y_min, color));
+    pub position: [f32; 2],
-    vertices.push(InkVertex::new(x_min, y_max, color));
+    pub color: [f32; 4],
-    vertices.push(InkVertex::new(x_min, y_max, color));
+    /// Art (1 = Karo, 2 = Linien, 3 = Punkte), Abstand, Linienstärke, Punktgröße
-    vertices.push(InkVertex::new(x_max, y_min, color));
+    pub params: [f32; 4],
-    vertices.push(InkVertex::new(x_max, y_max, color));
+    /// Seitenbreite, Seitenhöhe, Rand oben/unten bei Linien, ungenutzt
    pub bounds: [f32; 4],
 }
-/// Generiert das statische Vektor-Mesh für den gewählten Seitenhintergrund in `color`.
+impl PatternVertex {
-pub fn generate_background_mesh(background: PageBackground, color: [f32; 4]) -> Vec<InkVertex> {
+    const ATTRIBUTES: [wgpu::VertexAttribute; 4] = wgpu::vertex_attr_array![
-    match background {
+        0 => Float32x2,
-        PageBackground::Blank => Vec::new(),
+        1 => Float32x4,
-        PageBackground::Grid5mm => {
+        2 => Float32x4,
-            let mut vertices = Vec::with_capacity(1200);
+        3 => Float32x4
-            let half_t = LINE_THICKNESS / 2.0;
+    ];
-            // Vertikale Linien alle 5 mm
+    pub fn desc() -> wgpu::VertexBufferLayout<'static> {
-            let mut x = GRID_5MM_SPACING;
+        wgpu::VertexBufferLayout {
-            while x < PAGE_WIDTH {
+            array_stride: std::mem::size_of::<PatternVertex>() as wgpu::BufferAddress,
-                push_quad(
+            step_mode: wgpu::VertexStepMode::Vertex,
-                    &mut vertices,
+            attributes: &Self::ATTRIBUTES,
                    color,
                    x - half_t,
                    0.0,
                    x + half_t,
                    PAGE_HEIGHT,
                );
                x += GRID_5MM_SPACING;
            }
            // Horizontale Linien alle 5 mm
            let mut y = GRID_5MM_SPACING;
            while y < PAGE_HEIGHT {
                push_quad(
                    &mut vertices,
                    color,
                    0.0,
                    y - half_t,
                    PAGE_WIDTH,
                    y + half_t,
                );
                y += GRID_5MM_SPACING;
            }
            vertices
        }
        PageBackground::Lined => {
            let mut vertices = Vec::with_capacity(600);
            let half_t = LINE_THICKNESS / 2.0;
            // Oberer und unterer Randabstand (z. B. 15 mm)
            let margin_top = 150.0;
            let margin_bottom = 150.0;
            let mut y = margin_top;
            while y <= PAGE_HEIGHT - margin_bottom {
                push_quad(
                    &mut vertices,
                    color,
                    0.0,
                    y - half_t,
                    PAGE_WIDTH,
                    y + half_t,
                );
                y += LINED_SPACING;
            }
            vertices
        }
        PageBackground::DotGrid => {
            let mut vertices = Vec::with_capacity(15000);
            let half_d = DOT_SIZE / 2.0;
            let mut y = GRID_5MM_SPACING;
            while y < PAGE_HEIGHT {
                let mut x = GRID_5MM_SPACING;
                while x < PAGE_WIDTH {
                    push_quad(
                        &mut vertices,
                        color,
                        x - half_d,
                        y - half_d,
                        x + half_d,
                        y + half_d,
                    );
                    x += GRID_5MM_SPACING;
                }
                y += GRID_5MM_SPACING;
            }
            vertices
        }
    }
 }
 /// Rechteck über das ganze Blatt der Größe `size`, auf dem der Shader das Muster
 /// `background` in `color` zeichnet; leer bei blankem Papier.
 pub fn generate_pattern_quad(
    background: PageBackground,
    color: [f32; 4],
    size: glam::Vec2,
 ) -> Vec<PatternVertex> {
    let params = match background {
        PageBackground::Blank => return Vec::new(),
        PageBackground::Grid5mm => [1.0, GRID_5MM_SPACING, LINE_THICKNESS, DOT_SIZE],
        PageBackground::Lined => [2.0, LINED_SPACING, LINE_THICKNESS, DOT_SIZE],
        PageBackground::DotGrid => [3.0, GRID_5MM_SPACING, LINE_THICKNESS, DOT_SIZE],
    };
    let bounds = [size.x, size.y, LINED_MARGIN, 0.0];
    let corner = |x: f32, y: f32| PatternVertex {
        position: [x, y],
        color,
        params,
        bounds,
    };
    vec![
        corner(0.0, 0.0),
        corner(size.x, 0.0),
        corner(0.0, size.y),
        corner(0.0, size.y),
        corner(size.x, 0.0),
        corner(size.x, size.y),
    ]
 }
 #[cfg(test)]
 mod tests {
    use super::*;
    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());
+        let quad = generate_paper_quad(PaperTheme::White.paper_color(), A4_SIZE);
        assert_eq!(quad.len(), 6);
        assert_eq!(quad[0].position, [0.0, 0.0]);
        assert_eq!(quad[5].position, [PAGE_WIDTH, PAGE_HEIGHT]);
        let slide = generate_paper_quad(
            PaperTheme::White.paper_color(),
            glam::Vec2::new(2970.0, 1671.0),
        );
        assert_eq!(slide[5].position, [2970.0, 1671.0]);
    }
    const PATTERN: [f32; 4] = [0.5, 0.5, 0.5, 1.0];
    #[test]
-    fn test_background_meshes() {
+    fn test_pattern_quads() {
-        let blank = generate_background_mesh(PageBackground::Blank, PATTERN);
+        assert!(generate_pattern_quad(PageBackground::Blank, PATTERN, A4_SIZE).is_empty());
-        assert!(blank.is_empty());
+        for (background, kind) in [
-
+            (PageBackground::Grid5mm, 1.0),
-        let grid = generate_background_mesh(PageBackground::Grid5mm, PATTERN);
+            (PageBackground::Lined, 2.0),
-        assert!(!grid.is_empty());
+            (PageBackground::DotGrid, 3.0),
-        assert_eq!(
+        ] {
-            grid.len() % 6,
+            let quad = generate_pattern_quad(background, PATTERN, A4_SIZE);
-            0,
+            assert_eq!(quad.len(), 6);
-            "Muss ein Vielfaches von 6 Vertizes sein (Dreiecke)"
+            assert!(quad
-        );
+                .iter()
-
+                .all(|v| v.params[0] == kind && v.color == PATTERN));
-        let lined = generate_background_mesh(PageBackground::Lined, PATTERN);
+            assert_eq!(quad[5].position, [PAGE_WIDTH, PAGE_HEIGHT]);
-        assert!(!lined.is_empty());
+            assert_eq!(quad[0].bounds[..2], [PAGE_WIDTH, PAGE_HEIGHT]);
-        assert_eq!(lined.len() % 6, 0);
+        }
        let dots = generate_background_mesh(PageBackground::DotGrid, PATTERN);
        assert!(!dots.is_empty());
        assert_eq!(dots.len() % 6, 0);
    }
    #[test]
    fn test_background_mesh_uses_theme_color() {
-        let dark = PaperTheme::Black.pattern_color();
+        let quad = generate_paper_quad(PaperTheme::Cream.paper_color(), A4_SIZE);
        let mesh = generate_background_mesh(PageBackground::Lined, dark);
        assert!(mesh.iter().all(|v| v.color == dark));
        let quad = generate_paper_quad(PaperTheme::Cream.paper_color());
        assert!(quad
            .iter()
            .all(|v| v.color == PaperTheme::Cream.paper_color()));
@@ -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,10 +12,13 @@ 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_paper_quad, generate_pattern_quad, PaperTheme, PatternColor, PatternVertex,
 };
 use crate::document::{Page, PageBackground, PageViewport, Stroke, StylusSample};
 use crate::filter::OneEuroFilter;
 use crate::spline::{self, ControlPoint, SplineConfig};
 use crate::viewport::PageStack;
 /// 2D-Vertex für Inking-Meshes mit Positions- und Farbattributen (Multi-Color).
 #[repr(C)]
@@ -119,18 +122,22 @@ pub fn choose_present_mode(available: &[wgpu::PresentMode]) -> Option<wgpu::Pres
 struct NeighborFingerprint {
    page_id: u64,
    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),
@@ -141,12 +148,13 @@ impl NeighborFingerprint {
 /// GPU-Daten einer in der durchgehenden Ansicht sichtbaren Nachbarseite.
 struct NeighborPage {
    fingerprint: NeighborFingerprint,
-    /// Lage relativ zur aktuellen Seite (in Seiten, negativ = darüber)
+    /// Ecke oben links in Koordinaten der aktuellen Seite
-    offset: i64,
+    offset: glam::Vec2,
    camera_buffer: wgpu::Buffer,
    camera_bind_group: wgpu::BindGroup,
-    background_buffer: Option<wgpu::Buffer>,
+    /// Papier (Dreiecke) und Muster (Rechteck für `fs_pattern`)
-    background_vertex_count: u32,
+    paper_buffer: wgpu::Buffer,
    pattern_buffer: Option<wgpu::Buffer>,
    vertex_buffer: Option<wgpu::Buffer>,
    stroke_ranges: Vec<Range<u32>>,
 }
@@ -155,6 +163,13 @@ pub struct CanvasState {
    pub surface: wgpu::Surface<'static>,
    /// Verwendeter Grafikadapter (für erneute Abfrage der Surface-Fähigkeiten bei Größenänderung)
    adapter: wgpu::Adapter,
    /// Multisampling der Zeichenfläche (1 = aus) und das zugehörige Zwischenbild
    msaa_samples: u32,
    msaa_view: Option<wgpu::TextureView>,
    /// Stencil-Puffer: Jeder Strich deckt ein Pixel nur einmal, damit sich halbtransparente
    /// Tinte (Textmarker) dort, wo der Strich sich selbst überlappt, nicht verdunkelt
    stencil_view: wgpu::TextureView,
    stencil_reset_pipeline: wgpu::RenderPipeline,
    /// Meldung „keine Darstellungsmodi“ wurde bereits ausgegeben
    presentation_warned: bool,
    pub device: wgpu::Device,
@@ -179,14 +194,20 @@ pub struct CanvasState {
    // Statische Hintergrund-Geometrie
    pub paper_buffer: wgpu::Buffer,
    /// Musterrechteck der aktuellen Seite (6 Ecken, leer bei blankem Papier)
    pub background_buffer: wgpu::Buffer,
    pub background_vertex_capacity: usize,
    pub background_vertex_count: u32,
    pattern_pipeline: wgpu::RenderPipeline,
    pub current_background: PageBackground,
    /// Papierfarbe der Anzeige
    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,
    /// Textfelder der sichtbaren Seiten nach Texturschlüssel (für die Rasterung)
    text_specs: HashMap<String, TextSpec>,
    /// Gerade bearbeitetes Textfeld der aktuellen Seite: nicht zeichnen (die Bearbeitung
@@ -200,6 +221,9 @@ pub struct CanvasState {
    pub live_vertex_capacity: usize,
    pub live_vertex_count: u32,
    pub live_samples: Vec<StylusSample>,
    /// Ungefilterte Eingabepunkte des Live-Strichs (nach dem Lineal): Grundlage des fertigen
    /// Strichs, damit kleine Schleifen nicht durch die Filterverzögerung schrumpfen
    live_raw_samples: Vec<StylusSample>,
    pub live_control_points: Vec<ControlPoint>,
    pub live_vertices: Vec<InkVertex>,
    pub filter: OneEuroFilter,
@@ -230,7 +254,6 @@ pub struct CanvasState {
 impl CanvasState {
    const INITIAL_LIVE_CAPACITY: usize = 4096;
    const INITIAL_COMMITTED_CAPACITY: usize = 65536;
    const INITIAL_BACKGROUND_CAPACITY: usize = 16384;
    pub const VIEWPORT_MARGIN: f32 = 24.0;
    /// Initialisiert den CanvasState für das übergebene Winit-Fenster.
@@ -293,13 +316,20 @@ impl CanvasState {
            )
            .await?;
-        // 4. Zero-Latency-Pufferung (Mailbox, sonst Fifo) & Frame-Latency 1
+        // 4. Geringe Bildverzögerung (Mailbox, sonst Fifo) & Frame-Latency 1.
        //    Gezeichnet wird ohne sRGB-Umrechnung (siehe `render_format`); bietet die Fläche
        //    nur sRGB-Formate an, wird eine Ansicht ohne sRGB verwendet.
        let surface_format = surface_caps
            .formats
            .iter()
            .copied()
-            .find(|f| f.is_srgb())
+            .find(|f| !f.is_srgb())
            .unwrap_or(surface_caps.formats[0]);
        let view_formats = if surface_format.is_srgb() {
            vec![surface_format.remove_srgb_suffix()]
        } else {
            vec![]
        };
        let config = wgpu::SurfaceConfiguration {
            usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
@@ -308,11 +338,24 @@ impl CanvasState {
            height: size.height.max(1),
            present_mode,
            alpha_mode: surface_caps.alpha_modes[0],
-            view_formats: vec![],
+            view_formats,
            desired_maximum_frame_latency: 1, // Minimiert Eingabelatenz auf 1 Frame
        };
        surface.configure(&device, &config);
        // Kantenglättung der Zeichenfläche (4× Multisampling), falls das Format es erlaubt
        let msaa_samples = if adapter
            .get_texture_format_features(render_format(&config))
            .flags
            .sample_count_supported(MSAA_SAMPLES)
        {
            MSAA_SAMPLES
        } else {
            1
        };
        let msaa_view = create_msaa_view(&device, &config, msaa_samples);
        let stencil_view = create_stencil_view(&device, &config, msaa_samples);
        // 5. Shader & Bind Group Layout
        let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
            label: Some("Ink WGSL Shader"),
@@ -378,7 +421,7 @@ impl CanvasState {
                module: &shader,
                entry_point: "fs_ink",
                targets: &[Some(wgpu::ColorTargetState {
-                    format: config.format,
+                    format: render_format(&config),
                    blend: Some(wgpu::BlendState::ALPHA_BLENDING),
                    write_mask: wgpu::ColorWrites::ALL,
                })],
@@ -392,11 +435,42 @@ impl CanvasState {
                polygon_mode: wgpu::PolygonMode::Fill,
                conservative: false,
            },
-            depth_stencil: None,
+            depth_stencil: Some(stroke_stencil()),
-            multisample: wgpu::MultisampleState::default(),
+            multisample: wgpu::MultisampleState {
                count: msaa_samples,
                ..Default::default()
            },
            multiview: None,
        });
        // Setzt den Stencil-Puffer zurück, wenn die Strichnummern überlaufen
        let stencil_reset_pipeline =
            device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
                label: Some("Stencil Reset Pipeline"),
                layout: Some(&pipeline_layout),
                vertex: wgpu::VertexState {
                    module: &shader,
                    entry_point: "vs_fullscreen",
                    buffers: &[],
                },
                fragment: Some(wgpu::FragmentState {
                    module: &shader,
                    entry_point: "fs_none",
                    targets: &[Some(wgpu::ColorTargetState {
                        format: render_format(&config),
                        blend: None,
                        write_mask: wgpu::ColorWrites::empty(),
                    })],
                }),
                primitive: wgpu::PrimitiveState::default(),
                depth_stencil: Some(stencil_reset()),
                multisample: wgpu::MultisampleState {
                    count: msaa_samples,
                    ..Default::default()
                },
                multiview: None,
            });
        // TriangleList-Pipeline (für Hintergrundpapier und Muster)
        let triangle_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
            label: Some("Background TriangleList Pipeline"),
@@ -410,7 +484,7 @@ impl CanvasState {
                module: &shader,
                entry_point: "fs_main",
                targets: &[Some(wgpu::ColorTargetState {
-                    format: config.format,
+                    format: render_format(&config),
                    blend: Some(wgpu::BlendState::ALPHA_BLENDING),
                    write_mask: wgpu::ColorWrites::ALL,
                })],
@@ -424,14 +498,17 @@ impl CanvasState {
                polygon_mode: wgpu::PolygonMode::Fill,
                conservative: false,
            },
-            depth_stencil: None,
+            depth_stencil: Some(passive_stencil()),
-            multisample: wgpu::MultisampleState::default(),
+            multisample: wgpu::MultisampleState {
                count: msaa_samples,
                ..Default::default()
            },
            multiview: None,
        });
        // 6. Statische Buffer
        let paper_theme = PaperTheme::default();
-        let paper_quad = generate_paper_quad(paper_theme.paper_color());
+        let paper_quad = generate_paper_quad(paper_theme.paper_color(), crate::document::A4_SIZE);
        let paper_buffer = device.create_buffer(&wgpu::BufferDescriptor {
            label: Some("Paper Quad Buffer"),
            size: (paper_quad.len() * std::mem::size_of::<InkVertex>()) as u64,
@@ -441,15 +518,46 @@ impl CanvasState {
        queue.write_buffer(&paper_buffer, 0, bytemuck::cast_slice(&paper_quad));
        let current_background = PageBackground::Grid5mm;
-        let bg_mesh = generate_background_mesh(current_background, paper_theme.pattern_color());
+        let bg_mesh = generate_pattern_quad(
            current_background,
            paper_theme.pattern_color(),
            crate::document::A4_SIZE,
        );
        let background_buffer = device.create_buffer(&wgpu::BufferDescriptor {
-            label: Some("Background Mesh Buffer"),
+            label: Some("Pattern Quad Buffer"),
-            size: (Self::INITIAL_BACKGROUND_CAPACITY * std::mem::size_of::<InkVertex>()) as u64,
+            size: (6 * std::mem::size_of::<PatternVertex>()) as u64,
            usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
            mapped_at_creation: false,
        });
        queue.write_buffer(&background_buffer, 0, bytemuck::cast_slice(&bg_mesh));
        // Karo, Linien und Punkte: pro Pixel im Shader berechnet
        let pattern_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
            label: Some("Pattern Pipeline"),
            layout: Some(&pipeline_layout),
            vertex: wgpu::VertexState {
                module: &shader,
                entry_point: "vs_pattern",
                buffers: &[PatternVertex::desc()],
            },
            fragment: Some(wgpu::FragmentState {
                module: &shader,
                entry_point: "fs_pattern",
                targets: &[Some(wgpu::ColorTargetState {
                    format: render_format(&config),
                    blend: Some(wgpu::BlendState::ALPHA_BLENDING),
                    write_mask: wgpu::ColorWrites::ALL,
                })],
            }),
            primitive: wgpu::PrimitiveState::default(),
            depth_stencil: Some(passive_stencil()),
            multisample: wgpu::MultisampleState {
                count: msaa_samples,
                ..Default::default()
            },
            multiview: None,
        });
        // 7. GPU-Puffer für Live- und Committed-Geometrie
        let live_vertex_buffer = device.create_buffer(&wgpu::BufferDescriptor {
            label: Some("Live Stroke Vertex Buffer"),
@@ -469,15 +577,20 @@ impl CanvasState {
            &device,
            &shader,
            &bind_group_layout,
-            config.format,
+            render_format(&config),
            msaa_samples,
        );
        // 8. egui Renderer für das schwebende UI initialisieren
-        let egui_renderer = egui_wgpu::Renderer::new(&device, config.format, None, 1);
+        let egui_renderer = egui_wgpu::Renderer::new(&device, render_format(&config), None, 1);
        Ok(Self {
            surface,
            adapter,
            msaa_samples,
            msaa_view,
            stencil_view,
            stencil_reset_pipeline,
            presentation_warned: false,
            device,
            queue,
@@ -494,11 +607,14 @@ impl CanvasState {
            current_stroke_width_mm: 0.5,
            paper_buffer,
            background_buffer,
            background_vertex_capacity: Self::INITIAL_BACKGROUND_CAPACITY,
            background_vertex_count: bg_mesh.len() as u32,
            pattern_pipeline,
            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(),
            hidden_text: None,
            text_resolution: 1.0,
@@ -506,6 +622,7 @@ impl CanvasState {
            live_vertex_capacity: Self::INITIAL_LIVE_CAPACITY,
            live_vertex_count: 0,
            live_samples: Vec::with_capacity(256),
            live_raw_samples: Vec::with_capacity(256),
            live_control_points: Vec::with_capacity(256),
            live_vertices: Vec::with_capacity(1024),
            filter: OneEuroFilter::default(),
@@ -530,7 +647,7 @@ impl CanvasState {
    /// Aktualisiert die 2D-Kamera Uniforms (Scale & Offset im NDC-Raum) basierend auf Viewport und Kamera.
    pub fn update_uniforms(&mut self) {
-        let camera_uniforms = self.camera_uniforms(0);
+        let camera_uniforms = self.camera_uniforms(glam::Vec2::ZERO);
        self.queue.write_buffer(
            &self.camera_buffer,
            0,
@@ -545,10 +662,11 @@ impl CanvasState {
        }
    }
-    /// Kamera für die Seite `page_offset` Seiten unter (negativ: über) der aktuellen.
+    /// Kamera für eine Seite mit der Ecke `origin` (Koordinaten der aktuellen Seite).
-    fn camera_uniforms(&self, page_offset: i64) -> CameraUniforms {
+    fn camera_uniforms(&self, origin: glam::Vec2) -> CameraUniforms {
        let (scale, mut offset) = self.camera.ndc_transform(&self.viewport);
-        offset[1] += page_offset as f32 * crate::viewport::PAGE_PITCH * scale[1];
+        offset[0] += origin.x * scale[0];
        offset[1] += origin.y * scale[1];
        CameraUniforms {
            transform_scale: scale,
            transform_offset: offset,
@@ -577,13 +695,22 @@ impl CanvasState {
        true
    }
    /// Rahmen, in den alle Seiten des Notizbuchs passen (bestimmt den Maßstab bei 100 %).
    pub fn set_fit_box(&mut self, fit_box: glam::Vec2) {
        if self.fit_box != fit_box {
            self.fit_box = fit_box;
            self.recalculate_viewport();
        }
    }
    fn recalculate_viewport(&mut self) {
-        self.viewport = PageViewport::calculate_with_insets(
+        self.viewport = PageViewport::calculate_for(
            self.size.width as f32,
            self.size.height as f32,
            Self::VIEWPORT_MARGIN,
-            self.ui_inset_left,
+            (self.ui_inset_left, self.ui_inset_right),
-            self.ui_inset_right,
+            self.fit_box,
            self.page_size,
        );
        self.update_uniforms();
    }
@@ -612,6 +739,8 @@ impl CanvasState {
                }
            }
            self.surface.configure(&self.device, &self.config);
            self.msaa_view = create_msaa_view(&self.device, &self.config, self.msaa_samples);
            self.stencil_view = create_stencil_view(&self.device, &self.config, self.msaa_samples);
            self.recalculate_viewport();
        }
    }
@@ -653,60 +782,60 @@ impl CanvasState {
        self.camera.page_to_screen_vec2(page_pt, &self.viewport)
    }
-    /// Durchgehende Ansicht: Versatz (in Seiten) der Seite unter dem Bildschirmpunkt,
+    /// Durchgehende Ansicht: Seite unter dem Bildschirmpunkt, `None` neben den Seiten und
-    /// `None` neben den Seiten und zwischen zwei Seiten.
+    /// zwischen zwei Seiten.
-    pub fn page_offset_at_screen(&self, screen_x: f32, screen_y: f32) -> Option<i64> {
+    pub fn page_at_screen(&self, stack: &PageStack, screen_x: f32, screen_y: f32) -> Option<usize> {
        let p = self
            .camera
            .screen_to_page_unclamped(screen_x, screen_y, &self.viewport);
-        if !(0.0..=crate::document::PAGE_WIDTH).contains(&p.x) {
+        let index = stack.page_at(p.y)?;
-            return None;
+        let x = p.x - stack.origins[index].x;
-        }
+        (0.0..=stack.sizes[index].x).contains(&x).then_some(index)
        crate::viewport::page_offset_at(p.y)
    }
-    /// Durchgehende Ansicht: Versatz (in Seiten) der Seite in der Mitte des Fensters.
+    /// Durchgehende Ansicht: Seite auf Höhe der Fenstermitte.
-    pub fn page_offset_at_view_center(&self) -> Option<i64> {
+    pub fn page_at_view_center(&self, stack: &PageStack) -> Option<usize> {
        let p = self.camera.screen_to_page_unclamped(
            0.0,
            self.size.height as f32 / 2.0,
            &self.viewport,
        );
-        crate::viewport::page_offset_at(p.y)
+        stack.page_at(p.y)
    }
-    /// Durchgehende Ansicht: Versätze der sichtbaren Nachbarseiten der aktuellen Seite.
+    /// Durchgehende Ansicht: sichtbare Nachbarseiten der aktuellen Seite.
-    pub fn visible_neighbor_offsets(&self, current: usize, page_count: usize) -> Vec<i64> {
+    pub fn visible_neighbors(&self, stack: &PageStack) -> Vec<usize> {
        let top = self
            .camera
            .screen_to_page_unclamped(0.0, 0.0, &self.viewport);
        let bottom =
            self.camera
                .screen_to_page_unclamped(0.0, self.size.height as f32, &self.viewport);
-        crate::viewport::visible_neighbor_offsets(top.y, bottom.y, current, page_count)
+        stack.visible_neighbors(top.y, bottom.y)
    }
    /// Durchgehende Ansicht: Hält die Fenstermitte über dem Notizbuch (von der Oberkante der
-    /// ersten bis zur Unterkante der letzten Seite, waagerecht innerhalb der Seitenbreite), damit
+    /// ersten bis zur Unterkante der letzten Seite, waagerecht innerhalb der Seiten), damit
    /// man nicht ins Leere scrollt. `true`, wenn der Ausschnitt korrigiert wurde.
-    pub fn clamp_scroll(&mut self, current: usize, page_count: usize) -> bool {
+    pub fn clamp_scroll(&mut self, stack: &PageStack) -> bool {
        let center = [
            self.viewport.page_x + self.viewport.page_width / 2.0,
            self.size.height as f32 / 2.0,
        ];
-        let changed =
+        let changed = self
-            self.camera
+            .camera
-                .clamp_continuous_center(center, current, page_count, &self.viewport);
+            .clamp_continuous_center(center, stack, &self.viewport);
        if changed {
            self.update_uniforms();
        }
        changed
    }
-    /// Durchgehende Ansicht: Die Seite `k` Seiten weiter wird zur Bezugsseite, ohne dass sich
+    /// Durchgehende Ansicht: Die Seite mit der Ecke `origin` (Koordinaten der aktuellen Seite)
-    /// der Bildausschnitt bewegt. Die Nachbarseiten sind danach neu zu setzen.
+    /// wird zur Bezugsseite, ohne dass sich der Bildausschnitt bewegt. Danach ist die neue
-    pub fn shift_reference_page(&mut self, k: i64) {
+    /// Seite mit [`Self::sync_page`] zu setzen.
-        self.camera.shift_reference_page(k);
+    pub fn shift_reference_page(&mut self, origin: glam::Vec2) {
        self.camera.shift_reference_page(origin);
        self.update_uniforms();
    }
@@ -756,13 +885,21 @@ impl CanvasState {
            self.queue.write_buffer(
                &self.paper_buffer,
                0,
-                bytemuck::cast_slice(&generate_paper_quad(theme.paper_color())),
+                bytemuck::cast_slice(&generate_paper_quad(theme.paper_color(), self.page_size)),
            );
            self.upload_background_mesh();
        }
        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 {
@@ -774,20 +911,12 @@ impl CanvasState {
    /// Erzeugt das Muster für Hintergrund und Papierfarbe neu und lädt es auf die GPU.
    fn upload_background_mesh(&mut self) {
-        let mesh =
+        let mesh = generate_pattern_quad(
-            generate_background_mesh(self.current_background, self.paper_theme.pattern_color());
+            self.current_background,
            self.pattern.color(self.paper_theme),
            self.page_size,
        );
        self.background_vertex_count = mesh.len() as u32;
        if mesh.len() > self.background_vertex_capacity {
            self.background_vertex_capacity = mesh.len() * 2;
            self.background_buffer = self.device.create_buffer(&wgpu::BufferDescriptor {
                label: Some("Background Mesh Buffer (Reallocated)"),
                size: (self.background_vertex_capacity * std::mem::size_of::<InkVertex>()) as u64,
                usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
                mapped_at_creation: false,
            });
        }
        if !mesh.is_empty() {
            self.queue
                .write_buffer(&self.background_buffer, 0, bytemuck::cast_slice(&mesh));
@@ -799,6 +928,19 @@ impl CanvasState {
        page.rebuild_cache_if_dirty();
        // Die aktuelle Seite kann sich jetzt ändern: als Nachbarseite später neu hochladen
        self.neighbors.retain(|n| n.fingerprint.page_id != page.id);
        if self.page_size != page.size {
            self.page_size = page.size;
            self.queue.write_buffer(
                &self.paper_buffer,
                0,
                bytemuck::cast_slice(&generate_paper_quad(
                    self.paper_theme.paper_color(),
                    self.page_size,
                )),
            );
            self.upload_background_mesh();
            self.recalculate_viewport();
        }
        self.set_background(page.background);
        let quads = self.page_image_quads(page, self.hidden_text);
        self.image_layer.set_quads(quads);
@@ -832,11 +974,11 @@ impl CanvasState {
    /// aktuellen Seite (in Seiten). Die Vertex-Caches der Seiten müssen aktuell sein
    /// ([`Page::rebuild_cache_if_dirty`]); unveränderte Seiten werden nicht erneut hochgeladen.
    /// Eine leere Liste schaltet die Nachbarseiten ab.
-    pub fn set_neighbor_pages(&mut self, pages: &[(i64, &Page)]) {
+    pub fn set_neighbor_pages(&mut self, pages: &[(glam::Vec2, &Page)]) {
        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),
@@ -882,15 +1024,39 @@ impl CanvasState {
                buffer
            })
        };
-        let background =
+        // Eigenes Papier und Muster (Nachbarseiten können anders groß sein)
-            generate_background_mesh(page.background, self.paper_theme.pattern_color());
+        let paper = generate_paper_quad(self.paper_theme.paper_color(), page.size);
        let pattern = generate_pattern_quad(
            page.background,
            self.pattern.color(self.paper_theme),
            page.size,
        );
        let paper_buffer = self.device.create_buffer(&wgpu::BufferDescriptor {
            label: Some("Neighbor Paper Buffer"),
            size: std::mem::size_of_val(paper.as_slice()) as u64,
            usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
            mapped_at_creation: false,
        });
        self.queue
            .write_buffer(&paper_buffer, 0, bytemuck::cast_slice(&paper));
        let pattern_buffer = (!pattern.is_empty()).then(|| {
            let buffer = self.device.create_buffer(&wgpu::BufferDescriptor {
                label: Some("Neighbor Pattern Buffer"),
                size: std::mem::size_of_val(pattern.as_slice()) as u64,
                usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
                mapped_at_creation: false,
            });
            self.queue
                .write_buffer(&buffer, 0, bytemuck::cast_slice(&pattern));
            buffer
        });
        NeighborPage {
            fingerprint,
-            offset: 0,
+            offset: glam::Vec2::ZERO,
            camera_buffer,
            camera_bind_group,
-            background_buffer: vertex_buffer_with("Neighbor Background Buffer", &background),
+            paper_buffer,
-            background_vertex_count: background.len() as u32,
+            pattern_buffer,
            vertex_buffer: vertex_buffer_with("Neighbor Strokes Buffer", &page.vertex_cache),
            stroke_ranges: page.stroke_ranges.clone(),
        }
@@ -903,14 +1069,18 @@ impl CanvasState {
        load: &mut dyn FnMut(&str) -> crate::image_layer::TextureSource,
    ) {
        // Text schärfer rastern, sobald weiter hineingezoomt wird (und gröber beim Herauszoomen)
-        let resolution = text_resolution(
+        let resolution = text_resolution(self.viewport.scale * self.camera.zoom);
            self.viewport.page_width / crate::document::PAGE_WIDTH * self.camera.zoom,
        );
        if resolution != self.text_resolution {
            self.text_resolution = resolution;
            self.image_layer
                .forget_textures(|key| key.starts_with(TEXT_KEY_PREFIX));
        }
        // Importierte PDF-Seiten schärfer rendern, sobald die Standardauflösung vergrößert würde
        let page_long_edge = self.page_size.max_element() * self.viewport.scale * self.camera.zoom;
        self.image_layer.set_pdf_pixels(
            (page_long_edge > crate::pdf_doc::DISPLAY_RENDER_PIXELS as f32 * 1.25)
                .then_some(crate::pdf_doc::ZOOMED_RENDER_PIXELS),
        );
        let specs = &self.text_specs;
        self.image_layer
            .prepare(&self.device, &self.queue, &mut |key| match specs.get(key) {
@@ -941,7 +1111,7 @@ impl CanvasState {
        let mut quads: Vec<_> = page
            .pdf_background
            .iter()
-            .map(|pdf| (pdf.key(), pdf.corners()))
+            .map(|pdf| (pdf.key(), pdf.corners(page.size)))
            .collect();
        for stroke in &page.strokes {
            let Some(corners) = stroke.object_corners() else {
@@ -991,6 +1161,8 @@ impl CanvasState {
            .ruler
            .and_then(|r| r.edge_lock(glam::Vec2::new(page_x, page_y), half_width));
        let (page_x, page_y) = self.constrain_to_ruler(page_x, page_y);
        self.live_raw_samples.clear();
        self.push_raw_sample(page_x, page_y, pressure, timestamp);
        // 1. Zwingend durch den 1€-Filter leiten
        let (fx, fy, fp) = self.filter.filter(page_x, page_y, pressure, timestamp);
@@ -1016,6 +1188,7 @@ impl CanvasState {
        // 1. Zwingend durch den 1€-Filter leiten
        let (page_x, page_y) = self.constrain_to_ruler(page_x, page_y);
        self.push_raw_sample(page_x, page_y, pressure, timestamp);
        let (fx, fy, fp) = self.filter.filter(page_x, page_y, pressure, timestamp);
        let new_pt = ControlPoint::new(fx, fy, fp);
@@ -1038,6 +1211,25 @@ impl CanvasState {
        self.update_live_mesh();
    }
    /// Merkt sich einen ungefilterten Eingabepunkt (Punkte näher als 0,03 mm am vorigen
    /// entfallen).
    fn push_raw_sample(&mut self, x: f32, y: f32, pressure: f32, timestamp: f64) {
        let position = glam::Vec2::new(x, y);
        if !position.is_finite() || !pressure.is_finite() {
            return;
        }
        if let Some(last) = self.live_raw_samples.last() {
            if (position - last.position).length_squared() < 0.09 {
                return;
            }
        }
        self.live_raw_samples.push(StylusSample {
            position,
            pressure: pressure.clamp(0.0, 1.0),
            timestamp,
        });
    }
    /// Projiziert einen Punkt auf die Linealkante, falls der Live-Strich dort eingerastet ist.
    fn constrain_to_ruler(&self, x: f32, y: f32) -> (f32, f32) {
        match self.ruler_lock {
@@ -1054,6 +1246,7 @@ impl CanvasState {
    /// Bricht den aktuellen Live-Strich ab und setzt Puffer sowie 1€-Filter sauber zurück.
    pub fn cancel_stroke(&mut self) {
        self.live_samples.clear();
        self.live_raw_samples.clear();
        self.live_control_points.clear();
        self.live_vertices.clear();
        self.live_vertex_count = 0;
@@ -1071,10 +1264,16 @@ impl CanvasState {
            return None;
        }
-        // Post-Stroke Finalisierung (Corner Preservation, Druckglättung, RDP, runde Kappen)
+        // Post-Stroke Finalisierung (Glättung, RDP, Ecken, runde Kappen) aus den ungefilterten
        // Punkten: Der 1€-Filter dient nur der Anzeige während des Schreibens
        let source = if self.live_raw_samples.is_empty() {
            &self.live_samples
        } else {
            &self.live_raw_samples
        };
        let stroke = spline::finalize_stroke_with_config(
            stroke_id,
-            &self.live_samples,
+            source,
            self.current_ink_color,
            &self.spline_config,
        );
@@ -1084,6 +1283,7 @@ impl CanvasState {
        // Temporären GPU-Live-Buffer vollständig leeren
        self.live_samples.clear();
        self.live_raw_samples.clear();
        self.live_control_points.clear();
        self.live_vertices.clear();
        self.live_vertex_count = 0;
@@ -1147,9 +1347,10 @@ impl CanvasState {
        }
        let output = self.surface.get_current_texture()?;
-        let view = output
+        let view = output.texture.create_view(&wgpu::TextureViewDescriptor {
-            .texture
+            format: Some(render_format(&self.config)),
-            .create_view(&wgpu::TextureViewDescriptor::default());
+            ..Default::default()
        });
        let mut encoder = self
            .device
@@ -1170,28 +1371,42 @@ impl CanvasState {
        {
            let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
                label: Some("Ink Canvas Render Pass"),
                // Mit Multisampling ins Zwischenbild zeichnen und in die Fensterfläche auflösen
                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
-                    view: &view,
+                    view: self.msaa_view.as_ref().unwrap_or(&view),
-                    resolve_target: None,
+                    resolve_target: self.msaa_view.as_ref().map(|_| &view),
                    ops: wgpu::Operations {
                        load: wgpu::LoadOp::Clear(self.paper_theme.desk_color()), // Tischhintergrund
-                        store: wgpu::StoreOp::Store,
+                        store: if self.msaa_view.is_some() {
                            wgpu::StoreOp::Discard
                        } else {
                            wgpu::StoreOp::Store
                        },
                    },
                })],
-                depth_stencil_attachment: None,
+                depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
                    view: &self.stencil_view,
                    depth_ops: None,
                    stencil_ops: Some(wgpu::Operations {
                        load: wgpu::LoadOp::Clear(0),
                        store: wgpu::StoreOp::Discard,
                    }),
                }),
                timestamp_writes: None,
                occlusion_query_set: None,
            });
            let mut stencil_ref = 0;
            // 0. Nachbarseiten der durchgehenden Ansicht (je mit eigener Kamera)
            for (i, neighbor) in self.neighbors.iter().enumerate() {
                render_pass.set_bind_group(0, &neighbor.camera_bind_group, &[]);
                render_pass.set_pipeline(&self.triangle_pipeline);
-                render_pass.set_vertex_buffer(0, self.paper_buffer.slice(..));
+                render_pass.set_vertex_buffer(0, neighbor.paper_buffer.slice(..));
                render_pass.draw(0..6, 0..1);
-                if let Some(buffer) = &neighbor.background_buffer {
+                if let Some(buffer) = &neighbor.pattern_buffer {
                    render_pass.set_pipeline(&self.pattern_pipeline);
                    render_pass.set_vertex_buffer(0, buffer.slice(..));
-                    render_pass.draw(0..neighbor.background_vertex_count, 0..1);
+                    render_pass.draw(0..6, 0..1);
                }
                self.image_layer.draw(&mut render_pass, i + 1);
                if let Some(buffer) = &neighbor.vertex_buffer {
@@ -1199,6 +1414,7 @@ impl CanvasState {
                    render_pass.set_vertex_buffer(0, buffer.slice(..));
                    for range in &neighbor.stroke_ranges {
                        if range.end > range.start {
                            self.next_stroke_stencil(&mut render_pass, &mut stencil_ref);
                            render_pass.draw(range.clone(), 0..1);
                        }
                    }
@@ -1215,6 +1431,7 @@ impl CanvasState {
            // 2. Hintergrundmuster (5mm-Gitter, liniert oder Punktraster mit Vertex-Farbe)
            if self.background_vertex_count > 0 {
                render_pass.set_pipeline(&self.pattern_pipeline);
                render_pass.set_vertex_buffer(0, self.background_buffer.slice(..));
                render_pass.draw(0..self.background_vertex_count, 0..1);
            }
@@ -1229,6 +1446,7 @@ impl CanvasState {
                render_pass.set_vertex_buffer(0, self.committed_vertex_buffer.slice(..));
                for range in &self.committed_strokes {
                    if range.end > range.start {
                        self.next_stroke_stencil(&mut render_pass, &mut stencil_ref);
                        render_pass.draw(range.clone(), 0..1);
                    }
                }
@@ -1237,6 +1455,7 @@ impl CanvasState {
            // 5. Temporäre Live-Geometrie des aktuellen Strichs rendern (Zero Latency)
            if self.live_vertex_count > 0 {
                render_pass.set_vertex_buffer(0, self.live_vertex_buffer.slice(..));
                self.next_stroke_stencil(&mut render_pass, &mut stencil_ref);
                render_pass.draw(0..self.live_vertex_count, 0..1);
            }
        }
@@ -1273,6 +1492,20 @@ impl CanvasState {
        Ok(())
    }
    /// Gibt dem nächsten Strich eine eigene Stencil-Nummer: Die Strich-Pipeline zeichnet nur
    /// Pixel, die noch nicht diese Nummer tragen. Nach 255 Strichen wird der Stencil-Puffer
    /// zurückgesetzt, damit kein späterer Strich die Nummer eines früheren wiederfindet.
    fn next_stroke_stencil<'a>(&'a self, pass: &mut wgpu::RenderPass<'a>, stencil_ref: &mut u32) {
        if *stencil_ref == u32::from(u8::MAX) {
            pass.set_pipeline(&self.stencil_reset_pipeline);
            pass.draw(0..3, 0..1);
            pass.set_pipeline(&self.strip_pipeline);
            *stencil_ref = 0;
        }
        *stencil_ref += 1;
        pass.set_stencil_reference(*stencil_ref);
    }
    /// Rendert nur die Canvas-Fläche ohne UI (z. B. für Headless-Tests).
    pub fn render_canvas_only(&mut self) -> Result<(), wgpu::SurfaceError> {
        let dummy_delta = egui::TexturesDelta::default();
@@ -1284,6 +1517,113 @@ impl CanvasState {
    }
 }
 /// Format, in das gezeichnet wird: ohne sRGB-Umrechnung. Die Farben werden also in sRGB
 /// gemischt – wie im PDF-Export, damit halbtransparente Tinte (Textmarker) am Bildschirm
 /// genauso aussieht. Tintenfarben sind sRGB-Werte, Papier- und Musterfarben rechnet der
 /// Shader aus linearen Werten um.
 fn render_format(config: &wgpu::SurfaceConfiguration) -> wgpu::TextureFormat {
    config.format.remove_srgb_suffix()
 }
 /// Multisampling der Zeichenfläche gegen gezackte Strichkanten.
 const MSAA_SAMPLES: u32 = 4;
 /// Zwischenbild für das Multisampling in Fenstergröße; `None` ohne Multisampling.
 fn create_msaa_view(
    device: &wgpu::Device,
    config: &wgpu::SurfaceConfiguration,
    samples: u32,
 ) -> Option<wgpu::TextureView> {
    (samples > 1).then(|| {
        device
            .create_texture(&wgpu::TextureDescriptor {
                label: Some("MSAA Color Target"),
                size: wgpu::Extent3d {
                    width: config.width.max(1),
                    height: config.height.max(1),
                    depth_or_array_layers: 1,
                },
                mip_level_count: 1,
                sample_count: samples,
                dimension: wgpu::TextureDimension::D2,
                format: render_format(config),
                usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
                view_formats: &[],
            })
            .create_view(&wgpu::TextureViewDescriptor::default())
    })
 }
 /// Format des Stencil-Puffers der Zeichenfläche.
 const STENCIL_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Depth24PlusStencil8;
 /// Stencil-Puffer in Fenstergröße (mit derselben Abtastzahl wie die Zeichenfläche).
 fn create_stencil_view(
    device: &wgpu::Device,
    config: &wgpu::SurfaceConfiguration,
    samples: u32,
 ) -> wgpu::TextureView {
    device
        .create_texture(&wgpu::TextureDescriptor {
            label: Some("Stroke Stencil Buffer"),
            size: wgpu::Extent3d {
                width: config.width.max(1),
                height: config.height.max(1),
                depth_or_array_layers: 1,
            },
            mip_level_count: 1,
            sample_count: samples,
            dimension: wgpu::TextureDimension::D2,
            format: STENCIL_FORMAT,
            usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
            view_formats: &[],
        })
        .create_view(&wgpu::TextureViewDescriptor::default())
 }
 /// Stencil-Zustand mit gleicher Prüfung und Aktion für Vorder- und Rückseiten.
 fn stencil_state(
    compare: wgpu::CompareFunction,
    pass_op: wgpu::StencilOperation,
 ) -> wgpu::DepthStencilState {
    let face = wgpu::StencilFaceState {
        compare,
        fail_op: wgpu::StencilOperation::Keep,
        depth_fail_op: wgpu::StencilOperation::Keep,
        pass_op,
    };
    wgpu::DepthStencilState {
        format: STENCIL_FORMAT,
        depth_write_enabled: false,
        depth_compare: wgpu::CompareFunction::Always,
        stencil: wgpu::StencilState {
            front: face,
            back: face,
            read_mask: 0xff,
            write_mask: 0xff,
        },
        bias: wgpu::DepthBiasState::default(),
    }
 }
 /// Pipelines ohne Strichnummer (Papier, Muster, Bilder) lassen den Stencil-Puffer unberührt.
 pub(crate) fn passive_stencil() -> wgpu::DepthStencilState {
    stencil_state(wgpu::CompareFunction::Always, wgpu::StencilOperation::Keep)
 }
 /// Striche: nur Pixel, die die eigene Nummer noch nicht tragen, und diese dann markieren.
 fn stroke_stencil() -> wgpu::DepthStencilState {
    stencil_state(
        wgpu::CompareFunction::NotEqual,
        wgpu::StencilOperation::Replace,
    )
 }
 /// Zurücksetzen: überall 0 eintragen.
 fn stencil_reset() -> wgpu::DepthStencilState {
    stencil_state(wgpu::CompareFunction::Always, wgpu::StencilOperation::Zero)
 }
 /// Zu rasterndes Textfeld.
 struct TextSpec {
    text: crate::text::TextBox,
@@ -1309,12 +1649,12 @@ fn text_key(text: &crate::text::TextBox, color: [f32; 4]) -> String {
 }
 /// Auflösung der Texttexturen für `screen_px_per_unit` Bildschirmpixel je Seiteneinheit:
-/// auf Viertel-Zweierpotenzen aufgerundet (⅛ bis 4). So wird nicht bei jedem Zoomschritt neu
+/// auf Viertel-Zweierpotenzen aufgerundet (⅛ bis 8). So wird nicht bei jedem Zoomschritt neu
 /// gerastert, und die Textur ist höchstens ein Fünftel größer als dargestellt – stärker
 /// verkleinert wirkt die dünne Schrift blass.
 fn text_resolution(screen_px_per_unit: f32) -> f32 {
    let steps = (screen_px_per_unit.max(1e-3).log2() * 4.0).ceil();
-    2.0_f32.powf(steps / 4.0).clamp(0.125, 4.0)
+    2.0_f32.powf(steps / 4.0).clamp(0.125, 8.0)
 }
 #[cfg(test)]
@@ -1328,7 +1668,7 @@ mod tests {
            assert!(r >= px - 1e-4 && r < px * 1.2 + 1e-4, "{px} → {r}");
        }
        assert_eq!(text_resolution(0.27), text_resolution(0.28));
-        assert_eq!(text_resolution(100.0), 4.0);
+        assert_eq!(text_resolution(100.0), 8.0);
    }
    #[test]
@@ -15,6 +15,8 @@ pub const A4_ASPECT_RATIO: f32 = A4_WIDTH_MM / A4_HEIGHT_MM;
 /// Virtuelle Seitenauflösung in internen Einheiten (10 Einheiten = 1 mm).
 pub const PAGE_WIDTH: f32 = 2100.0;
 pub const PAGE_HEIGHT: f32 = 2970.0;
 /// Größe einer DIN-A4-Hochformatseite (Standard) in Seiteneinheiten.
 pub const A4_SIZE: glam::Vec2 = glam::Vec2::new(PAGE_WIDTH, PAGE_HEIGHT);
 pub const UNITS_PER_MM: f32 = 10.0;
 /// Ein gefilterter Stylus-Abtastpunkt in DIN-A4-Seitenkoordinaten.
@@ -156,21 +158,32 @@ impl PdfBackground {
        format!("{}#{}", self.asset, self.page)
    }
-    /// Ecken (oben links, oben rechts, unten rechts, unten links) der PDF-Seite auf dem
+    /// Ecken (oben links, oben rechts, unten rechts, unten links) der PDF-Seite auf einem
-    /// A4-Blatt, siehe [`pdf_placement`].
+    /// Blatt der Größe `page_size`, siehe [`pdf_placement`].
-    pub fn corners(&self) -> [glam::Vec2; 4] {
+    pub fn corners(&self, page_size: glam::Vec2) -> [glam::Vec2; 4] {
-        pdf_placement(self.width_pt, self.height_pt)
+        pdf_placement(self.width_pt, self.height_pt, page_size)
    }
 }
-/// Lage einer PDF-Seite von `width_pt` × `height_pt` auf dem A4-Blatt: so groß wie möglich,
+/// Seitengröße für eine importierte PDF-Seite von `width_pt` × `height_pt`: Hochformat wird
-/// waagerecht zentriert und oben bündig. Querformat-Folien liegen so oben auf der Seite,
+/// DIN A4 hoch (wie bisher), Querformat (z. B. Folien) eine Seite mit der Breite von A4 quer
-/// darunter bleibt Platz für Notizen.
+/// (297 mm) und dem Seitenverhältnis der PDF-Seite – ohne leeren Streifen darunter.
-pub fn pdf_placement(width_pt: f32, height_pt: f32) -> [glam::Vec2; 4] {
+pub fn pdf_page_size(width_pt: f32, height_pt: f32) -> glam::Vec2 {
    let (w, h) = (width_pt.max(1.0), height_pt.max(1.0));
-    let scale = (PAGE_WIDTH / w).min(PAGE_HEIGHT / h);
+    if w <= h {
        return A4_SIZE;
    }
    // Auf ganze Zehntelmillimeter runden, damit gleich große Folien gleich große Seiten geben
    glam::Vec2::new(PAGE_HEIGHT, (PAGE_HEIGHT * h / w).round().max(1.0))
 }
 /// Lage einer PDF-Seite von `width_pt` × `height_pt` auf einem Blatt der Größe `page_size`:
 /// so groß wie möglich, waagerecht zentriert und oben bündig.
 pub fn pdf_placement(width_pt: f32, height_pt: f32, page_size: glam::Vec2) -> [glam::Vec2; 4] {
    let (w, h) = (width_pt.max(1.0), height_pt.max(1.0));
    let scale = (page_size.x / w).min(page_size.y / h);
    let size = glam::Vec2::new(w * scale, h * scale);
-    let tl = glam::Vec2::new((PAGE_WIDTH - size.x) / 2.0, 0.0);
+    let tl = glam::Vec2::new((page_size.x - size.x) / 2.0, 0.0);
    [
        tl,
        tl + glam::Vec2::new(size.x, 0.0),
@@ -184,18 +197,24 @@ pub const IMAGE_UNITS_PER_PIXEL: f32 = UNITS_PER_MM * 25.4 / 96.0;
 /// Ecken (oben links, oben rechts, unten rechts, unten links) für ein neu eingefügtes Bild
 /// von `width` × `height` Pixeln um `center`: Bildschirmgröße bei 96 dpi, höchstens 80 % der
-/// Seitenbreite und 60 % der Seitenhöhe, und möglichst ganz auf dem Blatt.
+/// Seitenbreite und 60 % der Seitenhöhe eines Blatts der Größe `page_size`, und möglichst
-pub fn place_image(width: u32, height: u32, center: glam::Vec2) -> [glam::Vec2; 4] {
+/// ganz auf dem Blatt.
 pub fn place_image(
    width: u32,
    height: u32,
    center: glam::Vec2,
    page_size: glam::Vec2,
 ) -> [glam::Vec2; 4] {
    let natural =
        glam::Vec2::new(width.max(1) as f32, height.max(1) as f32) * IMAGE_UNITS_PER_PIXEL;
-    let fit = (PAGE_WIDTH * 0.8 / natural.x)
+    let fit = (page_size.x * 0.8 / natural.x)
-        .min(PAGE_HEIGHT * 0.6 / natural.y)
+        .min(page_size.y * 0.6 / natural.y)
        .min(1.0);
    let size = natural * fit;
    let half = size / 2.0;
    let center = glam::Vec2::new(
-        center.x.clamp(half.x, PAGE_WIDTH - half.x),
+        center.x.clamp(half.x, page_size.x - half.x),
-        center.y.clamp(half.y, PAGE_HEIGHT - half.y),
+        center.y.clamp(half.y, page_size.y - half.y),
    );
    let tl = center - half;
    [
@@ -693,6 +712,9 @@ pub struct Page {
    pub id: u64,
    pub strokes: Vec<Stroke>,
    pub background: PageBackground,
    /// Seitengröße in Seiteneinheiten (Standard DIN A4 hoch, Querformat für PDF-Folien); auch im
    /// Manifest, damit sie ohne Laden der Seite bekannt ist
    pub size: glam::Vec2,
    /// Importierte PDF-Seite als Hintergrund (unter Bildern und Tinte)
    pub pdf_background: Option<PdfBackground>,
    /// Seitentitel (Lesezeichen); auch im Manifest, damit er ohne Laden der Seite bekannt ist
@@ -711,6 +733,7 @@ impl Page {
            id,
            strokes: Vec::new(),
            background,
            size: A4_SIZE,
            pdf_background: None,
            title: None,
            vertex_cache: Vec::new(),
@@ -728,6 +751,7 @@ impl Page {
            id,
            strokes: Vec::new(),
            background,
            size: A4_SIZE,
            pdf_background: None,
            title: None,
            vertex_cache: Vec::new(),
@@ -739,6 +763,12 @@ impl Page {
        }
    }
    /// Dieselbe Seite mit der Größe `size`.
    pub fn with_size(mut self, size: glam::Vec2) -> Self {
        self.size = size;
        self
    }
    pub fn is_readonly(&self) -> bool {
        self.persist == PersistState::ReadOnlyAfterLoadError
    }
@@ -1054,9 +1084,9 @@ impl Page {
    }
 }
-/// Höhe des Bereichs am unteren Rand der letzten Seite, in dem Schreiben in der
+/// Anteil der Seitenhöhe am unteren Rand der letzten Seite, in dem Schreiben in der
 /// durchgehenden Ansicht automatisch eine neue Seite anhängt.
-pub const AUTO_APPEND_ZONE: f32 = PAGE_HEIGHT * 0.2;
+pub const AUTO_APPEND_FRACTION: f32 = 0.2;
 /// Das Notizbuch mit diskreter Seitenverwaltung und Navigation.
 #[derive(Debug, Clone)]
@@ -1141,20 +1171,81 @@ impl Notebook {
        id
    }
-    /// Fügt eine neue Seite mit dem angegebenen Hintergrund hinzu.
+    /// Rahmen, in den jede Seite des Notizbuchs passt (größte Breite und Höhe).
    pub fn fit_box(&self) -> glam::Vec2 {
        self.pages
            .iter()
            .map(|p| p.size)
            .fold(glam::Vec2::ZERO, glam::Vec2::max)
            .max(glam::Vec2::ONE)
    }
    /// Durchgehende Ansicht: Lage aller Seiten relativ zur aktuellen.
    pub fn page_stack(&self) -> crate::viewport::PageStack {
        crate::viewport::PageStack::new(
            self.pages.iter().map(|p| p.size).collect(),
            self.current_page_index,
        )
    }
    /// Hängt eine neue Seite mit dem angegebenen Hintergrund und der Größe der aktuellen
    /// Seite an.
    pub fn add_page(&mut self, background: PageBackground) -> usize {
        let id = self.next_page_id;
        self.next_page_id += 1;
-        self.pages.push(Page::new(id, background));
+        let size = self
            .pages
            .get(self.current_page_index)
            .map_or(A4_SIZE, |p| p.size);
        self.pages.push(Page::new(id, background).with_size(size));
        self.pages.len() - 1
    }
    /// Fügt direkt nach der aktuellen Seite eine leere Seite mit dem angegebenen
    /// Hintergrund und der Größe der aktuellen Seite ein (die aktuelle Seite bleibt aktuell)
    /// und gibt ihren Index zurück.
    pub fn insert_page_after_current(&mut self, background: PageBackground) -> usize {
        let id = self.next_page_id;
        self.next_page_id += 1;
        let index = (self.current_page_index + 1).min(self.pages.len());
        let size = self
            .pages
            .get(self.current_page_index)
            .map_or(A4_SIZE, |p| p.size);
        self.pages
            .insert(index, Page::new(id, background).with_size(size));
        index
    }
    /// Entfernt die aktuelle Seite und gibt sie zurück; danach ist die folgende Seite aktuell
    /// (bzw. die vorige, wenn es die letzte war). Die einzige Seite eines Notizbuchs bleibt
    /// stehen (`None`).
    pub fn remove_current_page(&mut self) -> Option<Page> {
        if self.pages.len() < 2 {
            return None;
        }
        let page = self.pages.remove(self.current_page_index);
        self.load_warnings.remove(&page.id);
        self.current_page_index = self.current_page_index.min(self.pages.len() - 1);
        Some(page)
    }
    /// Setzt eine mit [`Self::remove_current_page`] entfernte Seite wieder an `index` ein
    /// (höchstens ans Ende) und macht sie zur aktuellen Seite; gibt ihren Index zurück.
    pub fn restore_page(&mut self, index: usize, page: Page) -> usize {
        let index = index.min(self.pages.len());
        self.next_page_id = self.next_page_id.max(page.id + 1);
        self.pages.insert(index, page);
        self.current_page_index = index;
        index
    }
    /// Durchgehende Ansicht: Reicht ein neuer Strich auf der letzten Seite bis in deren
-    /// unteres Fünftel ([`AUTO_APPEND_ZONE`]), wird darunter eine leere Seite mit gleichem
+    /// unteres Fünftel ([`AUTO_APPEND_FRACTION`]), wird darunter eine leere Seite mit gleichem
    /// Hintergrund angehängt. `true`, wenn eine Seite angehängt wurde.
    pub fn append_page_if_writing_at_end(&mut self, stroke_bottom: f32) -> bool {
        if self.current_page_index + 1 != self.pages.len()
-            || stroke_bottom < PAGE_HEIGHT - AUTO_APPEND_ZONE
+            || stroke_bottom < self.current_page().size.y * (1.0 - AUTO_APPEND_FRACTION)
        {
            return false;
        }
@@ -1224,19 +1315,28 @@ impl Default for Notebook {
    }
 }
-/// Berechnet die DIN-A4-Darstellung im Fenster mit Letterboxing/Pillarboxing.
+/// Lage der aktuellen Seite im Fenster bei Zoom 100 % ohne Verschiebung: Ein Rahmen der
 /// Größe `fit_box` (alle Seiten des Notizbuchs passen hinein) wird ins Fenster eingepasst
 /// (Letterboxing/Pillarboxing); die aktuelle Seite liegt darin waagerecht zentriert und oben.
 /// So bleibt der Maßstab beim Wechsel zwischen verschieden großen Seiten gleich.
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub struct PageViewport {
    pub window_width: f32,
    pub window_height: f32,
    /// Bildschirmposition der linken oberen Ecke der aktuellen Seite
    pub page_x: f32,
    pub page_y: f32,
    /// Größe der aktuellen Seite auf dem Bildschirm (Pixel)
    pub page_width: f32,
    pub page_height: f32,
    /// Bildschirmpixel je Seiteneinheit
    pub scale: f32,
    /// Größe der aktuellen Seite in Seiteneinheiten
    pub page_size: glam::Vec2,
 }
 impl PageViewport {
-    /// Berechnet die zentrierte DIN-A4-Projektionsfläche unter Beibehaltung des 210x297-Seitenverhältnisses.
+    /// Zentrierte DIN-A4-Seite im Fenster.
    pub fn calculate(window_width: f32, window_height: f32, margin: f32) -> Self {
        Self::calculate_with_insets(window_width, window_height, margin, 0.0, 0.0)
    }
@@ -1249,66 +1349,70 @@ impl PageViewport {
        margin: f32,
        inset_left: f32,
        inset_right: f32,
    ) -> Self {
        Self::calculate_for(
            window_width,
            window_height,
            margin,
            (inset_left, inset_right),
            A4_SIZE,
            A4_SIZE,
        )
    }
    /// Wie [`Self::calculate_with_insets`] für eine Seite der Größe `page_size` in einem
    /// Notizbuch, dessen Seiten in `fit_box` passen.
    pub fn calculate_for(
        window_width: f32,
        window_height: f32,
        margin: f32,
        (inset_left, inset_right): (f32, f32),
        fit_box: glam::Vec2,
        page_size: glam::Vec2,
    ) -> Self {
        let inset_left = inset_left.clamp(0.0, window_width * 0.5);
        let inset_right = inset_right.clamp(0.0, window_width * 0.5);
        let avail_w = (window_width - inset_left - inset_right - 2.0 * margin).max(10.0);
        let avail_h = (window_height - 2.0 * margin).max(10.0);
        let fit_box = fit_box.max(page_size).max(glam::Vec2::ONE);
-        let window_ratio = avail_w / avail_h;
+        let scale = (avail_w / fit_box.x).min(avail_h / fit_box.y);
-        let page_ratio = A4_ASPECT_RATIO;
+        let box_x =
-
+            inset_left + (window_width - inset_left - inset_right - fit_box.x * scale) / 2.0;
-        let (page_w, page_h) = if window_ratio > page_ratio {
+        let box_y = (window_height - fit_box.y * scale) / 2.0;
            // Fenster ist breiter als DIN A4 -> Pillarboxing (Balken links/rechts)
            let h = avail_h;
            let w = h * page_ratio;
            (w, h)
        } else {
            // Fenster ist höher als DIN A4 -> Letterboxing (Balken oben/unten)
            let w = avail_w;
            let h = w / page_ratio;
            (w, h)
        };
        let page_x = inset_left + (window_width - inset_left - inset_right - page_w) / 2.0;
        let page_y = (window_height - page_h) / 2.0;
        Self {
            window_width,
            window_height,
-            page_x,
+            page_x: box_x + (fit_box.x - page_size.x) / 2.0 * scale,
-            page_y,
+            page_y: box_y,
-            page_width: page_w,
+            page_width: page_size.x * scale,
-            page_height: page_h,
+            page_height: page_size.y * scale,
            scale,
            page_size,
        }
    }
-    /// Transformiert einen Fenster-Pixelpunkt in DIN-A4-Seitenkoordinaten [0.0, PAGE_WIDTH] x [0.0, PAGE_HEIGHT].
+    /// Transformiert einen Fenster-Pixelpunkt in Seitenkoordinaten.
    ///
-    /// Liefert `None`, falls der Punkt außerhalb der DIN-A4-Papierfläche liegt.
+    /// Liefert `None`, falls der Punkt außerhalb der Seite liegt.
    pub fn screen_to_page(&self, screen_x: f32, screen_y: f32) -> Option<glam::Vec2> {
-        let u = (screen_x - self.page_x) / self.page_width;
+        let p = glam::Vec2::new(screen_x - self.page_x, screen_y - self.page_y) / self.scale;
-        let v = (screen_y - self.page_y) / self.page_height;
+        ((0.0..=self.page_size.x).contains(&p.x) && (0.0..=self.page_size.y).contains(&p.y))
-
+            .then_some(p)
        if (0.0..=1.0).contains(&u) && (0.0..=1.0).contains(&v) {
            Some(glam::Vec2::new(u * PAGE_WIDTH, v * PAGE_HEIGHT))
        } else {
            None
        }
    }
-    /// Transformiert einen Fenster-Pixelpunkt und klemmt ihn auf die DIN-A4-Papierfläche.
+    /// Transformiert einen Fenster-Pixelpunkt und klemmt ihn auf die Seite.
    pub fn screen_to_page_clamped(&self, screen_x: f32, screen_y: f32) -> glam::Vec2 {
-        let u = ((screen_x - self.page_x) / self.page_width).clamp(0.0, 1.0);
+        let p = glam::Vec2::new(screen_x - self.page_x, screen_y - self.page_y) / self.scale;
-        let v = ((screen_y - self.page_y) / self.page_height).clamp(0.0, 1.0);
+        p.clamp(glam::Vec2::ZERO, self.page_size)
        glam::Vec2::new(u * PAGE_WIDTH, v * PAGE_HEIGHT)
    }
    /// Berechnet die Shader-Transformationsparameter (Scale, Offset),
-    /// um DIN-A4-Seitenkoordinaten direkt im Vertex-Shader in den NDC-Bereich [-1.0, 1.0] abzubilden.
+    /// um Seitenkoordinaten direkt im Vertex-Shader in den NDC-Bereich [-1.0, 1.0] abzubilden.
    pub fn ndc_transform(&self) -> ([f32; 2], [f32; 2]) {
-        let scale_x = (2.0 * self.page_width) / (self.window_width * PAGE_WIDTH);
+        let scale_x = (2.0 * self.scale) / self.window_width;
-        let scale_y = (-2.0 * self.page_height) / (self.window_height * PAGE_HEIGHT);
+        let scale_y = (-2.0 * self.scale) / self.window_height;
        let offset_x = (2.0 * self.page_x) / self.window_width - 1.0;
        let offset_y = 1.0 - (2.0 * self.page_y) / self.window_height;
        ([scale_x, scale_y], [offset_x, offset_y])
@@ -1574,24 +1678,95 @@ mod tests {
        assert!(page.strokes.is_empty());
    }
    #[test]
    fn test_pdf_page_size_follows_orientation() {
        // Hochformat (A4, Letter) bleibt A4 hoch
        assert_eq!(pdf_page_size(595.0, 842.0), A4_SIZE);
        assert_eq!(pdf_page_size(612.0, 792.0), A4_SIZE);
        // 16:9-Folie: 297 mm breit, Höhe nach Seitenverhältnis
        let slide = pdf_page_size(960.0, 540.0);
        assert_eq!(slide, glam::Vec2::new(2970.0, 1671.0));
        // Die Folie füllt ihre Seite ganz aus
        let [tl, _, br, _] = pdf_placement(960.0, 540.0, slide);
        assert!(
            tl.length() < 1e-3 && (br - slide).length() < 1.0,
            "{tl} {br}"
        );
    }
    #[test]
    fn test_viewport_scale_is_shared_by_pages_of_different_size() {
        let slide = glam::Vec2::new(2970.0, 1671.0);
        // Nur Folien: die Folie wird ins Fenster eingepasst
        let only_slides =
            PageViewport::calculate_for(1600.0, 900.0, 20.0, (0.0, 0.0), slide, slide);
        // 1560 × 860 frei: die Höhe begrenzt
        assert!(
            (only_slides.page_height - 860.0).abs() < 0.5,
            "{only_slides:?}"
        );
        assert!(
            (only_slides.page_width / only_slides.page_height - slide.x / slide.y).abs() < 1e-3
        );
        // Gemischt: gleicher Maßstab für beide Seiten, schmale Seite waagerecht zentriert
        let fit = A4_SIZE.max(slide);
        let a4 = PageViewport::calculate_for(1600.0, 900.0, 20.0, (0.0, 0.0), fit, A4_SIZE);
        let wide = PageViewport::calculate_for(1600.0, 900.0, 20.0, (0.0, 0.0), fit, slide);
        assert_eq!(a4.scale, wide.scale);
        let center = |v: &PageViewport| v.page_x + v.page_width / 2.0;
        assert!((center(&a4) - center(&wide)).abs() < 1e-3);
        assert_eq!(a4.page_y, wide.page_y);
        // Bildschirm → Seite berücksichtigt die Seitengröße
        let p = wide
            .screen_to_page(wide.page_x + wide.page_width - 1.0, wide.page_y + 1.0)
            .unwrap();
        assert!(p.x > 2900.0);
        assert!(wide
            .screen_to_page(wide.page_x + 5.0, wide.page_y + wide.page_height + 5.0)
            .is_none());
    }
    #[test]
    fn test_new_pages_take_size_of_current_page() {
        let slide = glam::Vec2::new(2970.0, 1671.0);
        let mut nb = Notebook::new();
        nb.pages[0].size = slide;
        nb.add_page(PageBackground::Blank);
        nb.insert_page_after_current(PageBackground::Blank);
        nb.next_page();
        nb.current_page_index = nb.pages.len() - 1;
        nb.next_page();
        assert!(nb.pages.iter().all(|p| p.size == slide));
        assert_eq!(nb.fit_box(), slide);
        // Auto-Anhängen bezieht sich auf die Höhe der Folie
        nb.current_page_index = nb.pages.len() - 1;
        assert!(!nb.append_page_if_writing_at_end(slide.y * 0.7));
        assert!(nb.append_page_if_writing_at_end(slide.y * 0.9));
    }
    #[test]
    fn test_place_image() {
        let center = glam::Vec2::new(PAGE_WIDTH / 2.0, PAGE_HEIGHT / 2.0);
        // Kleines Bild: Bildschirmgröße, zentriert
-        let [tl, tr, br, bl] = place_image(200, 100, center);
+        let [tl, tr, br, bl] = place_image(200, 100, center, A4_SIZE);
        assert!(((tr - tl).length() - 200.0 * IMAGE_UNITS_PER_PIXEL).abs() < 1e-3);
        assert!(((bl - tl).length() - 100.0 * IMAGE_UNITS_PER_PIXEL).abs() < 1e-3);
        assert!(((tl + br) / 2.0 - center).length() < 1e-3);
        // Großer Screenshot: auf 80 % der Breite verkleinert, Seitenverhältnis bleibt
-        let [tl, tr, br, _] = place_image(3840, 2160, center);
+        let [tl, tr, br, _] = place_image(3840, 2160, center, A4_SIZE);
        let size = br - tl;
        assert!((size.x - PAGE_WIDTH * 0.8).abs() < 1e-2);
        assert!((size.x / size.y - 3840.0 / 2160.0).abs() < 1e-3);
        assert_eq!(tr.y, tl.y);
        // Am Rand eingefügt: wird aufs Blatt geschoben
-        let corners = place_image(400, 400, glam::Vec2::new(-50.0, PAGE_HEIGHT + 50.0));
+        let corners = place_image(
            400,
            400,
            glam::Vec2::new(-50.0, PAGE_HEIGHT + 50.0),
            A4_SIZE,
        );
        for c in corners {
            assert!(c.x >= -1e-3 && c.x <= PAGE_WIDTH + 1e-3);
            assert!(c.y >= -1e-3 && c.y <= PAGE_HEIGHT + 1e-3);
@@ -1809,6 +1984,60 @@ mod tests {
        ));
    }
    #[test]
    fn test_insert_page_after_current() {
        let mut nb = Notebook::new();
        nb.add_page(PageBackground::Lined);
        nb.add_page(PageBackground::Lined);
        let ids: Vec<u64> = nb.pages.iter().map(|p| p.id).collect();
        nb.current_page_index = 1;
        nb.pages[1].background = PageBackground::DotGrid;
        let index = nb.insert_page_after_current(PageBackground::DotGrid);
        assert_eq!(index, 2);
        assert_eq!(nb.current_page_index, 1);
        assert_eq!(nb.pages.len(), 4);
        assert_eq!(nb.pages[0].id, ids[0]);
        assert_eq!(nb.pages[1].id, ids[1]);
        assert_eq!(nb.pages[3].id, ids[2], "alte Seite 3 ist jetzt Seite 4");
        let new = &nb.pages[2];
        assert!(!ids.contains(&new.id) && new.strokes.is_empty());
        assert_eq!(new.background, PageBackground::DotGrid);
        assert!(new.pdf_background.is_none());
    }
    #[test]
    fn test_remove_and_restore_current_page() {
        let mut nb = Notebook::new();
        // Die einzige Seite bleibt
        assert!(nb.remove_current_page().is_none());
        nb.add_page(PageBackground::Lined);
        nb.add_page(PageBackground::DotGrid);
        let ids: Vec<u64> = nb.pages.iter().map(|p| p.id).collect();
        // Mittlere Seite: danach ist die folgende aktuell
        nb.current_page_index = 1;
        let removed = nb.remove_current_page().unwrap();
        assert_eq!(removed.id, ids[1]);
        assert_eq!(
            nb.pages.iter().map(|p| p.id).collect::<Vec<_>>(),
            [ids[0], ids[2]]
        );
        assert_eq!(nb.current_page_index, 1);
        // Wiederherstellen an der alten Stelle
        assert_eq!(nb.restore_page(1, removed), 1);
        assert_eq!(nb.pages.iter().map(|p| p.id).collect::<Vec<_>>(), ids);
        assert_eq!(nb.current_page_index, 1);
        // Letzte Seite: danach ist die vorige aktuell
        nb.current_page_index = 2;
        let last = nb.remove_current_page().unwrap();
        assert_eq!(last.id, ids[2]);
        assert_eq!(nb.current_page_index, 1);
        // Neue Seiten bekommen keine schon vergebene Kennung
        assert!(nb.next_page_id > ids[2]);
    }
    #[test]
    fn test_append_page_when_writing_at_bottom_of_last_page() {
        let mut nb = Notebook::new();
@@ -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,
 };
@@ -117,26 +117,54 @@ pub enum ExportStrategy {
 }
 /// Rechnet eine interne Seitenkoordinate (x, y) in PDF-Millimeter-Koordinaten um (mit Y-Inversion).
 ///
 /// Bezugshöhe ist die A4-Seite; für anders hohe Seiten verschiebt [`begin_page_layer`] die
 /// Ebene entsprechend.
 #[inline]
 pub fn page_to_pdf_mm(x: f32, y: f32) -> (f32, f32) {
-    let x_norm = (x / PAGE_WIDTH).clamp(0.0, 1.0);
+    let x_mm = x / PAGE_WIDTH * A4_WIDTH_MM;
-    let y_norm = (y / PAGE_HEIGHT).clamp(0.0, 1.0);
+    let y_mm = (1.0 - y / PAGE_HEIGHT) * A4_HEIGHT_MM; // PDF-Ursprung liegt unten links
    let x_mm = x_norm * A4_WIDTH_MM;
    let y_mm = (1.0 - y_norm) * A4_HEIGHT_MM; // PDF-Ursprung liegt unten links
    (x_mm, y_mm)
 }
 /// PDF-Punkte je Seiteneinheit.
 const PT_PER_UNIT: f32 = A4_WIDTH_MM / PAGE_WIDTH * 72.0 / 25.4;
 /// Größe der Seite `page` im PDF.
 fn pdf_page_mm(page: &Page) -> (Mm, Mm) {
    let mm = page.size / crate::document::UNITS_PER_MM;
    (Mm(mm.x), Mm(mm.y))
 }
 /// Beginnt eine Ebene: Koordinaten beziehen sich auf eine A4-hohe Seite (siehe
 /// [`page_to_pdf_mm`]) und werden auf die tatsächliche Höhe von `page` verschoben.
 fn begin_page_layer(layer: &printpdf::PdfLayerReference, page: &Page) {
    layer.save_graphics_state();
    let dy = (page.size.y - PAGE_HEIGHT) * PT_PER_UNIT;
    if dy != 0.0 {
        layer.set_ctm(printpdf::CurTransMat::Translate(
            printpdf::Pt(0.0),
            printpdf::Pt(dy),
        ));
    }
 }
 /// Beendet eine mit [`begin_page_layer`] begonnene Ebene.
 fn end_page_layer(layer: &printpdf::PdfLayerReference) {
    layer.restore_graphics_state();
 }
 /// 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)?;
@@ -149,9 +177,10 @@ 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)?;
+    let bytes = add_alpha_states(fix_text_encoding(doc.save_to_bytes()?, notebook)?, notebook)?;
    // Importierte PDF-Seiten als Vektorgrafik unterlegen
    let underlays = pdf_underlays(notebook);
@@ -176,8 +205,8 @@ 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 bytes = add_alpha_states(fix_text_encoding(doc.save_to_bytes()?, notebook)?, notebook)?;
    let remaining: Vec<_> = underlays
        .into_iter()
        .filter(|u| !raster.contains(&u.target_page))
@@ -218,6 +247,77 @@ fn fix_text_encoding(bytes: Vec<u8>, notebook: &Notebook) -> Result<Vec<u8>, Box
    Ok(out)
 }
 /// Name des Grafikzustands für halbtransparente Tinte mit Deckkraft `alpha` (auf Prozent
 /// gerundet); `None` für deckende Farben.
 fn alpha_state_name(alpha: f32) -> Option<String> {
    let percent = (alpha.clamp(0.0, 1.0) * 100.0).round() as u32;
    (percent < 100).then(|| format!("InkAlpha{percent}"))
 }
 /// printpdf kann keine Grafikzustände mit Deckkraft anlegen: Die Tintenebene verweist mit
 /// `gs` auf die Namen aus [`alpha_state_name`], die Zustände selbst (`ca`/`CA`) werden hier
 /// in die Ressourcen jeder Seite eingetragen. Ohne halbtransparente Striche bleibt das PDF
 /// unverändert.
 fn add_alpha_states(bytes: Vec<u8>, notebook: &Notebook) -> Result<Vec<u8>, Box<dyn Error>> {
    use printpdf::lopdf::{Dictionary, Object};
    let mut states: Vec<(String, f32)> = notebook
        .pages
        .iter()
        .flat_map(|p| &p.strokes)
        .filter(|s| !s.is_object())
        .filter_map(|s| alpha_state_name(s.color[3]).map(|name| (name, s.color[3])))
        .collect();
    if states.is_empty() {
        return Ok(bytes);
    }
    states.sort_by(|a, b| a.0.cmp(&b.0));
    states.dedup_by(|a, b| a.0 == b.0);
    let mut doc = printpdf::lopdf::Document::load_mem(&bytes)?;
    let page_ids: Vec<_> = doc.get_pages().into_values().collect();
    for page_id in page_ids {
        let resources = dict_object_id(&mut doc, page_id, b"Resources")?;
        let ext_g_state = dict_object_id(&mut doc, resources, b"ExtGState")?;
        let dict = doc.get_object_mut(ext_g_state)?.as_dict_mut()?;
        for (name, alpha) in &states {
            let alpha = (alpha.clamp(0.0, 1.0) * 100.0).round() / 100.0;
            let mut state = Dictionary::new();
            state.set("Type", Object::Name(b"ExtGState".to_vec()));
            state.set("ca", Object::Real(alpha));
            state.set("CA", Object::Real(alpha));
            dict.set(name.as_bytes().to_vec(), Object::Dictionary(state));
        }
    }
    let mut out = Vec::new();
    doc.save_to(&mut out)?;
    Ok(out)
 }
 /// Kennung des Wörterbuchs unter `key` im Objekt `owner`; ein eingebettetes oder fehlendes
 /// Wörterbuch wird dafür zu einem eigenen Objekt.
 fn dict_object_id(
    doc: &mut printpdf::lopdf::Document,
    owner: printpdf::lopdf::ObjectId,
    key: &[u8],
 ) -> Result<printpdf::lopdf::ObjectId, Box<dyn Error>> {
    use printpdf::lopdf::{Dictionary, Object};
    let entry = doc.get_object(owner)?.as_dict()?.get(key).ok().cloned();
    if let Some(Object::Reference(id)) = entry {
        return Ok(id);
    }
    let dict = match entry {
        Some(Object::Dictionary(dict)) => dict,
        _ => Dictionary::new(),
    };
    let id = doc.add_object(dict);
    doc.get_object_mut(owner)?
        .as_dict_mut()?
        .set(key.to_vec(), Object::Reference(id));
    Ok(id)
 }
 /// UTF-8-Text als PDF-Textstring in UTF-16BE mit BOM; `None` bei reinem ASCII oder
 /// ungültigem UTF-8.
 fn utf16be_text(raw: &[u8]) -> Option<Vec<u8>> {
@@ -240,9 +340,11 @@ fn pdf_underlays(notebook: &Notebook) -> Vec<crate::pdf_merge::Underlay> {
        .enumerate()
        .filter_map(|(i, page)| {
            let pdf = page.pdf_background.as_ref()?;
-            let corners = pdf.corners();
+            let corners = pdf.corners(page.size);
-            let top_right = page_to_pdf_pt(corners[1]);
+            // Unterlagen werden ohne die Verschiebung von `begin_page_layer` gesetzt
-            let bottom_left = page_to_pdf_pt(corners[3]);
+            let shift = glam::Vec2::new(0.0, (page.size.y - PAGE_HEIGHT) * PT_PER_UNIT);
            let top_right = page_to_pdf_pt(corners[1]) + shift;
            let bottom_left = page_to_pdf_pt(corners[3]) + shift;
            let size = top_right - bottom_left;
            Some(crate::pdf_merge::Underlay {
                target_page: i,
@@ -261,11 +363,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(),
    )
 }
@@ -276,6 +380,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() {
@@ -292,63 +397,59 @@ fn generate_pdf_document_with(
        .into());
    }
-    // 1. Erstes Dokument mit Seite 1 erstellen
+    // Erste Seite legt das Dokument an, alle weiteren werden angehängt (je in ihrer Größe)
    let title = "ink-notes Notebook";
-    let (doc, page1_idx, layer1_bg) =
+    let (width, height) = pdf_page_mm(&notebook.pages[0]);
-        PdfDocument::new(title, Mm(A4_WIDTH_MM), Mm(A4_HEIGHT_MM), "Background");
+    let (doc, page1_idx, layer1_bg) = PdfDocument::new(title, width, height, "Background");
    let fonts = embed_text_fonts(&doc, notebook)?;
-    // Seitentitel werden zu Lesezeichen (Inhaltsverzeichnis im PDF-Betrachter)
+    for (i, page) in notebook.pages.iter().enumerate() {
-    if let Some(title) = &notebook.pages[0].title {
+        let (page_idx, layer_bg) = if i == 0 {
-        doc.add_bookmark(title.clone(), page1_idx);
+            (page1_idx, layer1_bg)
-    }
+        } else {
-
+            let (width, height) = pdf_page_mm(page);
-    // Seite 1 befüllen
+            doc.add_page(width, height, "Background")
-    let page1_ref = doc.get_page(page1_idx);
+        };
-    let layer1_bg_ref = page1_ref.get_layer(layer1_bg);
+        // Seitentitel werden zu Lesezeichen (Inhaltsverzeichnis im PDF-Betrachter)
    render_background_layer(&layer1_bg_ref, notebook.pages[0].background);
    if raster_pdf_pages.contains(&0) {
        render_pdf_raster(&page1_ref.add_layer("PDF"), &notebook.pages[0], assets);
    }
    if notebook.pages[0].strokes.iter().any(Stroke::is_image) {
        render_image_layer(&page1_ref.add_layer("Images"), &notebook.pages[0], assets);
    }
    if notebook.pages[0].strokes.iter().any(Stroke::is_text) {
        render_text_layer(&page1_ref.add_layer("Text"), &notebook.pages[0], &fonts);
    }
    let layer1_ink_ref = page1_ref.add_layer("Ink");
    render_ink_layer(&layer1_ink_ref, &notebook.pages[0], strategy);
    // 2. Alle nachfolgenden Seiten hinzufügen
    for (i, page) in notebook.pages.iter().enumerate().skip(1) {
        let (page_idx, layer_bg) = doc.add_page(Mm(A4_WIDTH_MM), Mm(A4_HEIGHT_MM), "Background");
        if let Some(title) = &page.title {
            doc.add_bookmark(title.clone(), page_idx);
        }
        let page_ref = doc.get_page(page_idx);
-        let layer_bg_ref = page_ref.get_layer(layer_bg);
+        render_background_layer(&page_ref.get_layer(layer_bg), page, pattern);
-        render_background_layer(&layer_bg_ref, page.background);
+        let layer = |name: &str, render: &dyn Fn(&printpdf::PdfLayerReference)| {
            let layer = page_ref.add_layer(name);
            begin_page_layer(&layer, page);
            render(&layer);
            end_page_layer(&layer);
        };
        if raster_pdf_pages.contains(&i) {
-            render_pdf_raster(&page_ref.add_layer("PDF"), page, assets);
+            layer("PDF", &|l| render_pdf_raster(l, page, assets));
        }
        if page.strokes.iter().any(Stroke::is_image) {
-            render_image_layer(&page_ref.add_layer("Images"), page, assets);
+            layer("Images", &|l| render_image_layer(l, page, assets));
        }
        if page.strokes.iter().any(Stroke::is_text) {
-            render_text_layer(&page_ref.add_layer("Text"), page, &fonts);
+            layer("Text", &|l| render_text_layer(l, page, &fonts));
        }
-
+        layer("Ink", &|l| render_ink_layer(l, page, strategy));
        let layer_ink_ref = page_ref.add_layer("Ink");
        render_ink_layer(&layer_ink_ref, page, strategy);
    }
    Ok(doc)
 }
 /// Rendert das Vektorraster auf Layer 1 ("Background").
-fn render_background_layer(layer: &printpdf::PdfLayerReference, background: PageBackground) {
+fn render_background_layer(
-    let grid_color = Color::Rgb(Rgb::new(0.88, 0.88, 0.88, None));
+    layer: &printpdf::PdfLayerReference,
    page: &Page,
    pattern: PatternColor,
 ) {
    let background = page.background;
    let (Mm(page_width_mm), Mm(page_height_mm)) = pdf_page_mm(page);
    // Exportiert wird immer auf weißem Papier; die Musterfarbe ist linear, PDF erwartet sRGB
    let [r, g, b, _] = pattern
        .color(crate::background::PaperTheme::White)
        .map(crate::background::linear_to_srgb);
    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);
@@ -361,11 +462,11 @@ fn render_background_layer(layer: &printpdf::PdfLayerReference, background: Page
            // Vertikale Linien alle 5 mm
            let mut x = spacing_mm;
-            while x < A4_WIDTH_MM {
+            while x < page_width_mm {
                let line = Line {
                    points: vec![
                        (Point::new(Mm(x), Mm(0.0)), false),
-                        (Point::new(Mm(x), Mm(A4_HEIGHT_MM)), false),
+                        (Point::new(Mm(x), Mm(page_height_mm)), false),
                    ],
                    is_closed: false,
                };
@@ -375,11 +476,11 @@ fn render_background_layer(layer: &printpdf::PdfLayerReference, background: Page
            // Horizontale Linien alle 5 mm
            let mut y = spacing_mm;
-            while y < A4_HEIGHT_MM {
+            while y < page_height_mm {
                let line = Line {
                    points: vec![
                        (Point::new(Mm(0.0), Mm(y)), false),
-                        (Point::new(Mm(A4_WIDTH_MM), Mm(y)), false),
+                        (Point::new(Mm(page_width_mm), Mm(y)), false),
                    ],
                    is_closed: false,
                };
@@ -394,11 +495,11 @@ fn render_background_layer(layer: &printpdf::PdfLayerReference, background: Page
            let margin_bottom_mm = 15.0;
            let mut y = margin_bottom_mm;
-            while y <= A4_HEIGHT_MM - margin_top_mm {
+            while y <= page_height_mm - margin_top_mm {
                let line = Line {
                    points: vec![
                        (Point::new(Mm(0.0), Mm(y)), false),
-                        (Point::new(Mm(A4_WIDTH_MM), Mm(y)), false),
+                        (Point::new(Mm(page_width_mm), Mm(y)), false),
                    ],
                    is_closed: false,
                };
@@ -409,12 +510,12 @@ fn render_background_layer(layer: &printpdf::PdfLayerReference, background: 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 < A4_HEIGHT_MM {
+            while y < page_height_mm {
                let mut x = spacing_mm;
-                while x < A4_WIDTH_MM {
+                while x < page_width_mm {
                    let dot_poly = Polygon {
                        rings: vec![vec![
                            (Point::new(Mm(x - half_dot), Mm(y - half_dot)), false),
@@ -440,6 +541,17 @@ fn render_ink_layer(layer: &printpdf::PdfLayerReference, page: &Page, strategy:
        if stroke.is_object() {
            continue;
        }
        // Halbtransparente Tinte (Textmarker): Deckkraft über einen Grafikzustand, den
        // `add_alpha_states` anlegt. Jeder Strich ist ein einziger Pfad und deckt daher jede
        // Stelle nur einmal, auch wo er sich selbst überlappt.
        let alpha_state = alpha_state_name(stroke.color[3]);
        if let Some(name) = &alpha_state {
            layer.save_graphics_state();
            layer.add_operation(printpdf::lopdf::content::Operation::new(
                "gs",
                vec![printpdf::lopdf::Object::Name(name.as_bytes().to_vec())],
            ));
        }
        if let Some(ref shape) = stroke.shape {
            render_recognized_shape(layer, shape, stroke.color);
        } else {
@@ -452,6 +564,9 @@ fn render_ink_layer(layer: &printpdf::PdfLayerReference, page: &Page, strategy:
                }
            }
        }
        if alpha_state.is_some() {
            layer.restore_graphics_state();
        }
    }
 }
@@ -613,7 +728,7 @@ fn render_text_layer(
        let size = glam::Vec2::new(text.wrap_width.max(text.size), layout.height());
        let (origin, [right, down]) = crate::text::frame_axes(&corners, size);
        // Seite → PDF-Punkte: x · k, Höhe − y · k
-        let k = A4_WIDTH_MM / PAGE_WIDTH * 72.0 / 25.4;
+        let k = PT_PER_UNIT;
        let o = page_to_pdf_pt(origin);
        let matrix = [right.x * k, -right.y * k, -down.x * k, down.y * k, o.x, o.y];
        layer.save_graphics_state();
@@ -730,7 +845,7 @@ fn render_pdf_raster(
            placeholder_xobject()
        }
    };
-    draw_image_xobject(layer, xobject, &pdf.corners());
+    draw_image_xobject(layer, xobject, &pdf.corners(page.size));
 }
 /// Rendert eine mathematisch bereinigte Form (Gerade, Kreis, Rechteck, Koordinatensystem)
@@ -745,6 +860,10 @@ fn render_recognized_shape(
    let stroke_color = Color::Rgb(Rgb::new(color[0], color[1], color[2], None));
    layer.set_outline_color(stroke_color.clone());
    layer.set_outline_thickness(1.5); // ca. 0.5 mm Standard-Liniendicke
                                      // Wie auf dem Bildschirm: spitze Ecken und stumpfe Enden (der Grafikzustand kann noch
                                      // runde Verbindungen von einem vorherigen Freihandstrich enthalten)
    layer.set_line_cap_style(printpdf::LineCapStyle::Butt);
    layer.set_line_join_style(printpdf::LineJoinStyle::Miter);
    match shape {
        RecognizedShape::Line { start, end } => {
@@ -938,17 +1057,19 @@ fn render_recognized_shape(
                (*y_axis_end, *x_axis_end)
            };
-            let (ox, oy) = page_to_pdf_mm(origin.x, origin.y);
+            // Ein einziger Linienzug, damit die Ecke am Ursprung als Linienverbindung
-            for end in [y_line_end, x_line_end] {
+            // geschlossen gezeichnet wird statt als zwei stumpfe Enden
-                let (ex, ey) = page_to_pdf_mm(end.x, end.y);
+            let points = [y_line_end, *origin, x_line_end]
-                layer.add_line(Line {
+                .iter()
-                    points: vec![
+                .map(|p| {
-                        (Point::new(Mm(ox), Mm(oy)), false),
+                    let (px, py) = page_to_pdf_mm(p.x, p.y);
-                        (Point::new(Mm(ex), Mm(ey)), false),
+                    (Point::new(Mm(px), Mm(py)), false)
-                    ],
+                })
-                    is_closed: false,
+                .collect();
-                });
+            layer.add_line(Line {
-            }
+                points,
                is_closed: false,
            });
            // Pfeilspitzen als gefüllte Dreiecke
            if *with_arrows {
@@ -1243,8 +1364,13 @@ mod tests {
        let temp_dir = std::env::temp_dir();
        let pdf_path = temp_dir.join("ink_notes_test_export.pdf");
-        let export_res =
+        let export_res = export_notebook_to_pdf(
-            export_notebook_to_pdf(&notebook, &pdf_path, ExportStrategy::FilledPolygon, None);
+            &notebook,
            &pdf_path,
            ExportStrategy::FilledPolygon,
            None,
            PatternColor::default(),
        );
        assert!(
            export_res.is_ok(),
            "PDF-Export zu Datei muss erfolgreich sein"
@@ -1270,7 +1396,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);
@@ -1393,7 +1524,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);
@@ -1462,9 +1598,13 @@ mod tests {
            ));
        }
-        let bytes =
+        let bytes = export_notebook_to_bytes(
-            export_notebook_to_bytes(&notebook, ExportStrategy::FilledPolygon, Some(&assets))
+            &notebook,
-                .expect("Export mit Bildern");
+            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"),
@@ -1488,7 +1628,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]
@@ -1500,9 +1646,13 @@ mod tests {
        crate::storage::load_all_pages(&dir, &mut notebook).unwrap();
        let assets = AssetStore::new(&dir);
-        let bytes =
+        let bytes = export_notebook_to_bytes(
-            export_notebook_to_bytes(&notebook, ExportStrategy::FilledPolygon, Some(&assets))
+            &notebook,
-                .unwrap();
+            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() {
@@ -1513,7 +1663,8 @@ mod tests {
            );
        }
-        // Exportiertes PDF lässt sich wieder rendern: Folie oben, rotes Quadrat oben links
+        // Exportiertes PDF lässt sich wieder rendern: Querformat-Folie füllt ihre Seite, rotes
        // Quadrat oben links
        let pdf = hayro::hayro_syntax::Pdf::new(bytes).unwrap();
        let image = crate::pdf_doc::render_page(&pdf, 0, 600).unwrap();
        let px = |x: u32, y: u32| {
@@ -1521,10 +1672,10 @@ mod tests {
            image.pixels[i..i + 3].to_vec()
        };
        assert_eq!(px(5, 5), vec![255, 0, 0], "Quadrat der Folie oben links");
-        assert_eq!(
+        let ratio = image.width as f32 / image.height as f32;
-            px(200, 500),
+        assert!(
-            vec![255, 255, 255],
+            (ratio - 842.0 / 595.0).abs() < 0.01,
-            "unter der Folie ist Platz"
+            "Seite im Folienformat: {ratio}"
        );
        // Gedrehte Seite (/Rotate 90) erscheint wie im PDF-Betrachter: das Quadrat liegt
@@ -1546,7 +1697,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]
@@ -1557,8 +1714,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 =
+        let bytes = export_notebook_to_bytes(
-            export_notebook_to_bytes(&notebook, ExportStrategy::FilledPolygon, None).unwrap();
+            &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");
@@ -10,10 +10,13 @@ use std::f32::consts::PI;
 /// Standard-Minimal-Grenzfrequenz in Hz (reduziert Jitter bei niedrigen Geschwindigkeiten)
 pub const DEFAULT_FC_MIN: f32 = 4.5;
-/// Standard-Geschwindigkeitskoeffizient (reduziert Latenz bei schnellen Bewegungen)
+/// Standard-Geschwindigkeitskoeffizient (Hz je Seiteneinheit/s): Bei 400 Einheiten/s
-pub const DEFAULT_BETA: f32 = 0.05;
+/// (4 cm/s, zügige Handschrift) liegt die Grenzfrequenz bei rund 65 Hz, kleine Schleifen
-/// Standard-Grenzfrequenz für die Ableitung in Hz
+/// werden kaum noch verkleinert
-pub const DEFAULT_D_CUTOFF: f32 = 1.0;
+pub const DEFAULT_BETA: f32 = 0.15;
 /// Standard-Grenzfrequenz für die Geschwindigkeitsschätzung in Hz (reagiert nach wenigen
 /// Millisekunden auf schnellere Bewegung)
 pub const DEFAULT_D_CUTOFF: f32 = 8.0;
 /// Berechnet den Glättungsfaktor alpha = 1 / (1 + tau / dt) = 2*pi*fc*dt / (2*pi*fc*dt + 1).
 ///
@@ -157,13 +160,18 @@ pub struct FilteredPoint {
 }
 /// Adaptiver 1€-Filter für 2D-Position (x, y) und Stylus-Druck p ∈ [0.0, 1.0].
 ///
 /// Die Position wird mit der Geschwindigkeit in der Ebene gefiltert (nicht je Achse):
 /// Auf einer Kreisbahn ist eine Achse an den Umkehrpunkten in Ruhe, eine Filterung je
 /// Achse würde dort stark glätten und Schleifen zusammenziehen.
 #[derive(Debug, Clone)]
 pub struct OneEuroFilter {
    pub fc_min: f32,
    pub beta: f32,
    pub d_cutoff: f32,
-    x_filter: OneEuroFilter1D,
+    pos_prev: Option<glam::Vec2>,
-    y_filter: OneEuroFilter1D,
+    speed_prev: f32,
    t_prev: Option<f64>,
    p_filter: OneEuroFilter1D,
    last_output: Option<(f32, f32, f32)>,
 }
@@ -175,8 +183,9 @@ impl OneEuroFilter {
            fc_min,
            beta,
            d_cutoff,
-            x_filter: OneEuroFilter1D::new(fc_min, beta, d_cutoff),
+            pos_prev: None,
-            y_filter: OneEuroFilter1D::new(fc_min, beta, d_cutoff),
+            speed_prev: 0.0,
            t_prev: None,
            p_filter: OneEuroFilter1D::new(fc_min, beta, d_cutoff),
            last_output: None,
        }
@@ -184,8 +193,9 @@ impl OneEuroFilter {
    /// Setzt den Filter vollständig zurück (z. B. bei neuem Stroke).
    pub fn reset(&mut self) {
-        self.x_filter.reset();
+        self.pos_prev = None;
-        self.y_filter.reset();
+        self.speed_prev = 0.0;
        self.t_prev = None;
        self.p_filter.reset();
        self.last_output = None;
    }
@@ -202,8 +212,8 @@ impl OneEuroFilter {
        // Druck immer auf [0.0, 1.0] klemmen
        let p_in = pressure.clamp(0.0, 1.0);
-        let x_out = self.x_filter.filter(x, t);
+        let pos = self.filter_position(glam::Vec2::new(x, y), t);
-        let y_out = self.y_filter.filter(y, t);
+        let (x_out, y_out) = (pos.x, pos.y);
        let p_out = self.p_filter.filter(p_in, t).clamp(0.0, 1.0);
        let out = (x_out, y_out, p_out);
@@ -211,6 +221,51 @@ impl OneEuroFilter {
        out
    }
    /// 1€-Filter der Position mit der Geschwindigkeit in der Ebene.
    fn filter_position(&mut self, x: glam::Vec2, t: f64) -> glam::Vec2 {
        let (Some(prev), Some(prev_t)) = (self.pos_prev, self.t_prev) else {
            self.pos_prev = Some(x);
            self.speed_prev = 0.0;
            self.t_prev = Some(t);
            return x;
        };
        let raw_dt = t - prev_t;
        // Lange Pause: neu beginnen statt über die Pause hinweg zu glätten
        if raw_dt > 1.0 {
            self.pos_prev = Some(x);
            self.speed_prev = 0.0;
            self.t_prev = Some(t);
            return x;
        }
        let dt = if raw_dt <= 0.0 || !raw_dt.is_finite() {
            1e-4_f32
        } else {
            raw_dt as f32
        };
        self.t_prev = Some(t);
        let mut speed = (x - prev).length() / dt;
        if !speed.is_finite() {
            speed = 0.0;
        }
        let a_d = smoothing_factor(dt, self.d_cutoff);
        let speed_hat = a_d * speed + (1.0 - a_d) * self.speed_prev;
        let fc = (self.fc_min + self.beta * speed_hat).max(self.fc_min);
        let a = smoothing_factor(dt, fc);
        let mut out = prev + (x - prev) * a;
        if !out.is_finite() {
            out = prev;
        }
        self.pos_prev = Some(out);
        self.speed_prev = if speed_hat.is_finite() {
            speed_hat
        } else {
            0.0
        };
        out
    }
    /// Filtert einen 2D-Punkt `pos` und Druck `pressure` zum Zeitstempel `t`.
    pub fn filter_point(&mut self, pos: glam::Vec2, pressure: f32, t: f64) -> (glam::Vec2, f32) {
        let (x, y, p) = self.filter(pos.x, pos.y, pressure, t);
@@ -279,6 +334,25 @@ mod tests {
        );
    }
    #[test]
    fn test_small_loops_do_not_shrink() {
        // Kreis mit 0,8 mm Radius in 0,1 s: die Filterung in der Ebene folgt ihm
        let mut filter = OneEuroFilter::default();
        let (r, period, hz) = (8.0_f32, 0.1_f64, 200.0);
        let mut radii = Vec::new();
        for i in 0..=(period * hz) as usize * 2 {
            let t = i as f64 / hz;
            let a = std::f32::consts::TAU * (t / period) as f32;
            let p = glam::Vec2::new(500.0 + r * a.sin(), 500.0 - r * a.cos());
            let (out, _) = filter.filter_point(p, 0.5, t);
            if t > period {
                radii.push((out - glam::Vec2::new(500.0, 500.0)).length());
            }
        }
        let mean = radii.iter().sum::<f32>() / radii.len() as f32;
        assert!(mean > r * 0.9, "Schleife geschrumpft: {mean}");
    }
    #[test]
    fn test_high_frequency_jitter() {
        let mut filter = OneEuroFilter::default();
@@ -286,7 +360,8 @@ mod tests {
        let base_x = 100.0_f32;
        let base_y = 50.0_f32;
        let base_p = 0.5_f32;
-        let jitter_amplitude = 2.0_f32;
+        // Realistisches Digitizer-Rauschen (±0,05 mm) bei ruhendem Stift
        let jitter_amplitude = 0.5_f32;
        let num_samples = 120;
        let dt = 1.0 / 120.0; // 120 Hz Abtastrate
@@ -331,9 +406,10 @@ mod tests {
            .sum::<f32>()
            / count;
-        // Der 1€-Filter muss das hochfrequente Jitter massiv dämpfen
+        // Der 1€-Filter muss das hochfrequente Jitter deutlich dämpfen (der fertige Strich
        // wird zusätzlich symmetrisch geglättet)
        assert!(
-            filtered_variance < raw_variance * 0.05,
+            filtered_variance < raw_variance * 0.2,
            "Gefilterte Varianz ({filtered_variance}) muss deutlich kleiner sein als Raw-Varianz ({raw_variance})"
        );
    }
@@ -1924,16 +1924,21 @@ pub fn shape_to_mesh(
                (*y_axis_end, *x_axis_end)
            };
            // Beide Achsen beginnen um die halbe Linienbreite hinter dem Ursprung, damit die
            // äußere Ecke geschlossen ist (sonst bleibt dort eine quadratische Kerbe)
            let y_start = *origin - y_dir * half_w;
            let x_start = *origin - x_dir * half_w;
            // 1. Y-Achse (vom Ursprung zur Spitze)
            let y_norm = Vec2::new(-y_dir.y, y_dir.x) * half_w;
            vertices.push(InkVertex::new(
-                origin.x + y_norm.x,
+                y_start.x + y_norm.x,
-                origin.y + y_norm.y,
+                y_start.y + y_norm.y,
                color,
            ));
            vertices.push(InkVertex::new(
-                origin.x - y_norm.x,
+                y_start.x - y_norm.x,
-                origin.y - y_norm.y,
+                y_start.y - y_norm.y,
                color,
            ));
            vertices.push(InkVertex::new(
@@ -1950,15 +1955,15 @@ pub fn shape_to_mesh(
            // Degenerierte Dreiecke für den Übergang zur X-Achse
            let x_norm = Vec2::new(-x_dir.y, x_dir.x) * half_w;
            let last_v = *vertices.last().unwrap();
-            let next_v = InkVertex::new(origin.x + x_norm.x, origin.y + x_norm.y, color);
+            let next_v = InkVertex::new(x_start.x + x_norm.x, x_start.y + x_norm.y, color);
            vertices.push(last_v);
            vertices.push(next_v);
            // 2. X-Achse
            vertices.push(next_v);
            vertices.push(InkVertex::new(
-                origin.x - x_norm.x,
+                x_start.x - x_norm.x,
-                origin.y - x_norm.y,
+                x_start.y - x_norm.y,
                color,
            ));
            vertices.push(InkVertex::new(
@@ -2195,6 +2200,30 @@ mod tests {
        }
    }
    #[test]
    fn test_coordinate_system_corner_is_closed() {
        // Die Achsen treffen sich ohne Kerbe: Die äußere Ecke des Ursprungs ist ein Eckpunkt
        // der Achsenbänder (Issue #15)
        let origin = Vec2::new(300.0, 900.0);
        let shape = RecognizedShape::CoordinateSystem {
            origin,
            x_axis_end: Vec2::new(900.0, 900.0),
            y_axis_end: Vec2::new(300.0, 300.0),
            with_arrows: true,
        };
        let width = 30.0;
        let (_, vertices) = shape_to_mesh(&shape, width, [0.0, 0.0, 0.0, 1.0]);
        let corner = origin + Vec2::new(-width / 2.0, width / 2.0);
        let nearest = vertices
            .iter()
            .map(|v| (Vec2::from(v.position) - corner).length())
            .fold(f32::INFINITY, f32::min);
        assert!(
            nearest < 1e-3,
            "äußere Ecke fehlt, nächster Punkt {nearest}"
        );
    }
    #[test]
    fn test_detect_triangle() {
        let mut points = Vec::new();
@@ -91,6 +91,9 @@ pub struct ImageLayer {
    groups: Vec<Vec<(String, [glam::Vec2; 4])>>,
    vertex_buffer: Option<wgpu::Buffer>,
    vertices_dirty: bool,
    /// Importierte PDF-Seiten in höherer Auflösung (längste Kante in Pixeln) anzeigen;
    /// bis sie gerendert ist, bleibt die Standardauflösung sichtbar
    pdf_pixels: Option<u32>,
 }
 impl ImageLayer {
@@ -99,6 +102,7 @@ impl ImageLayer {
        shader: &wgpu::ShaderModule,
        camera_layout: &wgpu::BindGroupLayout,
        format: wgpu::TextureFormat,
        sample_count: u32,
    ) -> Self {
        let texture_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
            label: Some("Image Texture Bind Group Layout"),
@@ -147,8 +151,11 @@ impl ImageLayer {
                topology: wgpu::PrimitiveTopology::TriangleList,
                ..Default::default()
            },
-            depth_stencil: None,
+            depth_stencil: Some(crate::canvas::passive_stencil()),
-            multisample: wgpu::MultisampleState::default(),
+            multisample: wgpu::MultisampleState {
                count: sample_count,
                ..Default::default()
            },
            multiview: None,
        });
        let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
@@ -170,6 +177,7 @@ impl ImageLayer {
            groups: vec![Vec::new()],
            vertex_buffer: None,
            vertices_dirty: false,
            pdf_pixels: None,
        }
    }
@@ -194,6 +202,19 @@ impl ImageLayer {
        self.groups.iter().flatten()
    }
    /// Auflösung importierter PDF-Seiten (`None`: Standard), z. B. beim Hineinzoomen.
    pub fn set_pdf_pixels(&mut self, pixels: Option<u32>) {
        self.pdf_pixels = pixels;
    }
    /// Schlüssel der anzuzeigenden Textur: PDF-Seiten ggf. in höherer Auflösung.
    fn texture_key(&self, key: &str) -> String {
        match self.pdf_pixels {
            Some(pixels) if key.contains('#') => format!("{key}@{pixels}"),
            _ => key.to_string(),
        }
    }
    /// Lädt fehlende Texturen und den Vertex-Puffer hoch. Vor jedem Zeichnen aufrufen;
    /// ohne Änderungen kostet das nichts.
    pub fn prepare(
@@ -204,9 +225,8 @@ impl ImageLayer {
    ) {
        let missing: Vec<String> = self
            .all_quads()
-            .map(|(key, _)| key)
+            .map(|(key, _)| self.texture_key(key))
-            .filter(|key| !self.textures.contains_key(*key))
+            .filter(|key| !self.textures.contains_key(key))
            .cloned()
            .collect();
        for key in missing {
            if self.textures.contains_key(&key) {
@@ -230,7 +250,11 @@ impl ImageLayer {
        // Nicht mehr benötigte Texturen freigeben, wenn der Grafikspeicher knapp wird
        if self.texture_bytes > TEXTURE_CACHE_BYTES {
-            let used: HashSet<&String> = self.groups.iter().flatten().map(|(a, _)| a).collect();
+            // Die Standardauflösung bleibt als Ersatz, bis die höhere fertig ist
            let used: HashSet<String> = self
                .all_quads()
                .flat_map(|(key, _)| [key.clone(), self.texture_key(key)])
                .collect();
            self.textures.retain(|name, _| used.contains(name));
            self.texture_bytes = self.textures.values().map(|(_, b)| b).sum();
        }
@@ -279,7 +303,7 @@ impl ImageLayer {
    /// Fehlen noch Texturen sichtbarer Seiten (z. B. PDF-Seite im Hintergrund-Rendering)?
    pub fn is_waiting(&self) -> bool {
        self.all_quads()
-            .any(|(key, _)| !self.textures.contains_key(key))
+            .any(|(key, _)| !self.textures.contains_key(&self.texture_key(key)))
    }
    /// Zeichnet die Bilder einer Seite (Gruppe 0: aktuelle Seite). Bind Group 0 (Kamera der
@@ -298,7 +322,11 @@ impl ImageLayer {
        render_pass.set_pipeline(&self.pipeline);
        render_pass.set_vertex_buffer(0, buffer.slice(..));
        for (i, (asset, _)) in quads.iter().enumerate() {
-            let Some((bind_group, _)) = self.textures.get(asset) else {
+            let Some((bind_group, _)) = self
                .textures
                .get(&self.texture_key(asset))
                .or_else(|| self.textures.get(asset))
            else {
                continue;
            };
            render_pass.set_bind_group(1, bind_group, &[]);
@@ -335,7 +363,8 @@ impl ImageLayer {
            mip_level_count: levels.len() as u32,
            sample_count: 1,
            dimension: wgpu::TextureDimension::D2,
-            format: wgpu::TextureFormat::Rgba8UnormSrgb,
+            // sRGB-Werte ohne Umrechnung: gezeichnet wird in sRGB (siehe canvas::render_format)
            format: wgpu::TextureFormat::Rgba8Unorm,
            usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
            view_formats: &[],
        });
@@ -11,6 +11,7 @@ pub mod filter;
 pub mod geometry;
 pub mod history;
 pub mod image_layer;
 pub mod library;
 pub mod page_export;
 pub mod pdf_doc;
 pub mod pdf_merge;
@@ -0,0 +1,441 @@
 //! Ordner für Notizbücher (`<Basisordner>/library.json`).
 //!
 //! Ordner sind rein logisch: Die Notizbücher bleiben in ihren Verzeichnissen
 //! `<Basisordner>/<id>/`, `library.json` hält nur fest, welcher Ordner welches Notizbuch
 //! enthält. Umbenennen und Verschieben ändern so nie Notizbuch-Dateien. Fehlt die Datei oder
 //! ist sie unlesbar, liegen alle Notizbücher auf der obersten Ebene – verloren geht nichts.
 //!
 //! Ordner werden als Pfade mit `/` als Trenner gespeichert (z. B. `3. Semester/Mathe`);
 //! die oberste Ebene ist der leere Pfad.
 use std::collections::{BTreeMap, BTreeSet};
 use std::path::{Path, PathBuf};
 use serde::{Deserialize, Serialize};
 use crate::storage::{self, StorageError};
 /// Oberste Ebene.
 pub const ROOT: &str = "";
 /// Längster erlaubter Ordnername (Zeichen).
 const MAX_NAME_CHARS: usize = 80;
 /// Ordnerbaum und Zuordnung der Notizbücher.
 #[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(default)]
 pub struct Library {
    /// Alle Ordner als Pfade
    pub folders: BTreeSet<String>,
    /// Ordner je Notizbuch-Kennung; Notizbücher ohne Eintrag liegen auf oberster Ebene
    pub notebooks: BTreeMap<String, String>,
 }
 /// Letzter Teil eines Ordnerpfads (der angezeigte Name).
 pub fn folder_name(path: &str) -> &str {
    path.rsplit('/').next().unwrap_or(path)
 }
 /// Übergeordneter Ordner (oberste Ebene für Ordner der obersten Ebene).
 pub fn parent_folder(path: &str) -> &str {
    path.rsplit_once('/').map_or(ROOT, |(parent, _)| parent)
 }
 /// Pfad des Unterordners `name` in `parent`.
 fn join(parent: &str, name: &str) -> String {
    if parent.is_empty() {
        name.to_string()
    } else {
        format!("{parent}/{name}")
    }
 }
 /// `path` liegt in `folder` oder ist `folder` selbst.
 fn is_within(path: &str, folder: &str) -> bool {
    path == folder
        || path
            .strip_prefix(folder)
            .is_some_and(|rest| rest.starts_with('/'))
 }
 /// Bereinigt einen Ordnernamen; Fehlermeldung für die Oberfläche bei ungültigen Namen.
 pub fn validate_name(name: &str) -> Result<String, String> {
    let name = name.trim();
    if name.is_empty() {
        return Err("Der Ordnername ist leer".to_string());
    }
    if name.contains('/') {
        return Err("Ordnernamen dürfen kein „/“ enthalten".to_string());
    }
    if name.chars().count() > MAX_NAME_CHARS {
        return Err(format!(
            "Der Ordnername ist zu lang (höchstens {MAX_NAME_CHARS} Zeichen)"
        ));
    }
    Ok(name.to_string())
 }
 impl Library {
    /// Ort von `library.json` im Basisordner der Notizbücher.
    pub fn file_path(base_dir: &Path) -> PathBuf {
        base_dir.join("library.json")
    }
    /// Lädt die Ordner; fehlt die Datei oder ist sie beschädigt, gibt es keine Ordner.
    pub fn load(base_dir: &Path) -> Self {
        let path = Self::file_path(base_dir);
        let mut library: Self = match std::fs::read_to_string(&path) {
            Ok(content) => serde_json::from_str(&content).unwrap_or_else(|e| {
                eprintln!(
                    "[Ordner] '{}' ist ungültig ({e}), alle Notizbücher auf oberster Ebene.",
                    path.display()
                );
                Self::default()
            }),
            Err(_) => Self::default(),
        };
        library.repair();
        library
    }
    /// Speichert die Ordner atomar.
    pub fn save(&self, base_dir: &Path) -> Result<(), StorageError> {
        storage::atomic_write_json(&Self::file_path(base_dir), self)
    }
    /// Macht eine (evtl. von Hand bearbeitete) Datei stimmig: leere oder ungültige Namen
    /// fallen weg, jeder benutzte Ordner und seine übergeordneten Ordner existieren.
    fn repair(&mut self) {
        let valid = |path: &str| {
            !path.is_empty()
                && path
                    .split('/')
                    .all(|name| validate_name(name).as_deref() == Ok(name))
        };
        self.folders.retain(|f| valid(f));
        self.notebooks.retain(|_, f| f.is_empty() || valid(f));
        let used: Vec<String> = self
            .folders
            .iter()
            .chain(self.notebooks.values())
            .cloned()
            .collect();
        for mut folder in used {
            while !folder.is_empty() {
                let parent = parent_folder(&folder).to_string();
                self.folders.insert(folder);
                folder = parent;
            }
        }
    }
    /// Ordner, in dem das Notizbuch liegt.
    pub fn folder_of(&self, notebook_id: &str) -> &str {
        self.notebooks.get(notebook_id).map_or(ROOT, String::as_str)
    }
    /// Direkte Unterordner von `parent` (vollständige Pfade, nach Name sortiert).
    pub fn subfolders(&self, parent: &str) -> Vec<&str> {
        let mut list: Vec<&str> = self
            .folders
            .iter()
            .map(String::as_str)
            .filter(|f| parent_folder(f) == parent)
            .collect();
        list.sort_by_key(|f| folder_name(f).to_lowercase());
        list
    }
    /// Alle Ordner in Baumreihenfolge (Eltern vor Kindern, Geschwister nach Name).
    pub fn all_folders(&self) -> Vec<&str> {
        let mut out = Vec::with_capacity(self.folders.len());
        let mut stack: Vec<&str> = self.subfolders(ROOT).into_iter().rev().collect();
        while let Some(folder) = stack.pop() {
            out.push(folder);
            stack.extend(self.subfolders(folder).into_iter().rev());
        }
        out
    }
    /// Legt in `parent` den Ordner `name` an und gibt seinen Pfad zurück.
    pub fn create_folder(&mut self, parent: &str, name: &str) -> Result<String, String> {
        let name = validate_name(name)?;
        if !parent.is_empty() && !self.folders.contains(parent) {
            return Err("Der übergeordnete Ordner existiert nicht mehr".to_string());
        }
        let path = join(parent, &name);
        if !self.folders.insert(path.clone()) {
            return Err(format!("Den Ordner „{name}“ gibt es hier schon"));
        }
        Ok(path)
    }
    /// Benennt einen Ordner um (mitsamt Unterordnern und Zuordnungen); gibt den neuen Pfad
    /// zurück.
    pub fn rename_folder(&mut self, path: &str, new_name: &str) -> Result<String, String> {
        let new_name = validate_name(new_name)?;
        if !self.folders.contains(path) {
            return Err("Den Ordner gibt es nicht mehr".to_string());
        }
        let new_path = join(parent_folder(path), &new_name);
        if new_path == path {
            return Ok(new_path);
        }
        if self.folders.contains(&new_path) {
            return Err(format!("Den Ordner „{new_name}“ gibt es hier schon"));
        }
        self.move_contents(path, &new_path);
        Ok(new_path)
    }
    /// Löscht einen Ordner. Seine Notizbücher und Unterordner rücken eine Ebene nach oben
    /// (gleichnamige Unterordner werden zusammengelegt) – gelöscht wird kein Notizbuch.
    pub fn delete_folder(&mut self, path: &str) {
        if path.is_empty() || !self.folders.remove(path) {
            return;
        }
        let parent = parent_folder(path).to_string();
        let prefix = format!("{path}/");
        let moved: Vec<String> = self
            .folders
            .iter()
            .filter(|f| f.starts_with(&prefix))
            .cloned()
            .collect();
        for folder in moved {
            self.folders.remove(&folder);
            self.folders.insert(join(&parent, &folder[prefix.len()..]));
        }
        for folder in self.notebooks.values_mut() {
            if folder == path {
                *folder = parent.clone();
            } else if let Some(rest) = folder.strip_prefix(&prefix) {
                *folder = join(&parent, rest);
            }
        }
        self.notebooks.retain(|_, f| !f.is_empty());
    }
    /// Verschiebt einen Ordner samt Inhalt nach `new_path`.
    fn move_contents(&mut self, path: &str, new_path: &str) {
        let renamed = |f: &str| format!("{new_path}{}", &f[path.len()..]);
        let moved: Vec<String> = self
            .folders
            .iter()
            .filter(|f| is_within(f, path))
            .cloned()
            .collect();
        for folder in moved {
            self.folders.remove(&folder);
            self.folders.insert(renamed(&folder));
        }
        for folder in self.notebooks.values_mut() {
            if is_within(folder, path) {
                *folder = renamed(folder);
            }
        }
    }
    /// Verschiebt einen Ordner samt Inhalt nach `new_parent` (oberste Ebene: [`ROOT`]) und
    /// gibt seinen neuen Pfad zurück. Nicht in sich selbst oder einen eigenen Unterordner.
    pub fn move_folder(&mut self, path: &str, new_parent: &str) -> Result<String, String> {
        if !self.folders.contains(path) {
            return Err("Den Ordner gibt es nicht mehr".to_string());
        }
        if !new_parent.is_empty() && !self.folders.contains(new_parent) {
            return Err("Den Zielordner gibt es nicht mehr".to_string());
        }
        if is_within(new_parent, path) {
            return Err("Ein Ordner kann nicht in sich selbst verschoben werden".to_string());
        }
        let name = folder_name(path);
        let new_path = join(new_parent, name);
        if new_path == path {
            return Ok(new_path);
        }
        if self.folders.contains(&new_path) {
            return Err(format!("Im Zielordner gibt es schon einen Ordner „{name}“"));
        }
        self.move_contents(path, &new_path);
        Ok(new_path)
    }
    /// Mögliche Ziele für das Verschieben des Ordners `path`: alle Ordner außer ihm selbst und
    /// seinen Unterordnern (die oberste Ebene ist immer ein Ziel).
    pub fn folder_move_targets(&self, path: &str) -> Vec<&str> {
        self.all_folders()
            .into_iter()
            .filter(|f| !is_within(f, path))
            .collect()
    }
    /// Legt das Notizbuch in `folder` (oberste Ebene: [`ROOT`]).
    pub fn move_notebook(&mut self, notebook_id: &str, folder: &str) -> Result<(), String> {
        if folder.is_empty() {
            self.notebooks.remove(notebook_id);
            return Ok(());
        }
        if !self.folders.contains(folder) {
            return Err("Den Ordner gibt es nicht mehr".to_string());
        }
        self.notebooks
            .insert(notebook_id.to_string(), folder.to_string());
        Ok(())
    }
    /// Wie viele der Notizbücher `ids` in `folder` liegen, Unterordner eingeschlossen.
    pub fn count_within<'a>(&self, folder: &str, ids: impl IntoIterator<Item = &'a str>) -> usize {
        ids.into_iter()
            .filter(|id| is_within(self.folder_of(id), folder))
            .count()
    }
 }
 #[cfg(test)]
 mod tests {
    use super::*;
    fn library() -> Library {
        let mut lib = Library::default();
        let sem3 = lib.create_folder(ROOT, "3. Semester").unwrap();
        let mathe = lib.create_folder(&sem3, "Mathe").unwrap();
        lib.create_folder(&sem3, "Physik").unwrap();
        lib.move_notebook("analysis", &mathe).unwrap();
        lib.move_notebook("uebung", &sem3).unwrap();
        lib
    }
    #[test]
    fn test_paths_and_names() {
        assert_eq!(folder_name("3. Semester/Mathe"), "Mathe");
        assert_eq!(folder_name("Mathe"), "Mathe");
        assert_eq!(parent_folder("3. Semester/Mathe"), "3. Semester");
        assert_eq!(parent_folder("Mathe"), ROOT);
        assert_eq!(validate_name("  Mathe  ").unwrap(), "Mathe");
        assert!(validate_name("   ").is_err());
        assert!(validate_name("a/b").is_err());
        assert!(validate_name(&"x".repeat(81)).is_err());
    }
    #[test]
    fn test_create_and_list_folders() {
        let mut lib = library();
        assert_eq!(lib.subfolders(ROOT), ["3. Semester"]);
        assert_eq!(
            lib.subfolders("3. Semester"),
            ["3. Semester/Mathe", "3. Semester/Physik"]
        );
        assert_eq!(
            lib.all_folders(),
            ["3. Semester", "3. Semester/Mathe", "3. Semester/Physik"]
        );
        assert_eq!(lib.folder_of("analysis"), "3. Semester/Mathe");
        assert_eq!(lib.folder_of("unbekannt"), ROOT);
        // Doppelte Namen und fehlende Eltern werden abgelehnt
        assert!(lib.create_folder("3. Semester", " Mathe ").is_err());
        assert!(lib.create_folder("Gibt es nicht", "X").is_err());
        // Gleicher Name in einem anderen Ordner ist erlaubt
        lib.create_folder(ROOT, "4. Semester").unwrap();
        assert!(lib.create_folder("4. Semester", "Mathe").is_ok());
        assert_eq!(
            lib.count_within("3. Semester", ["analysis", "uebung", "lose"]),
            2
        );
    }
    #[test]
    fn test_rename_folder_keeps_contents() {
        let mut lib = library();
        let new = lib.rename_folder("3. Semester", "WS 25-26").unwrap();
        assert_eq!(new, "WS 25-26");
        assert_eq!(lib.folder_of("analysis"), "WS 25-26/Mathe");
        assert_eq!(lib.folder_of("uebung"), "WS 25-26");
        assert!(lib.folders.contains("WS 25-26/Physik"));
        assert!(!lib.folders.iter().any(|f| f.starts_with("3. Semester")));
        // Ein Ordner mit ähnlichem Namen bleibt unberührt
        let mut lib = library();
        lib.create_folder(ROOT, "3. Semester alt").unwrap();
        lib.rename_folder("3. Semester", "Drei").unwrap();
        assert!(lib.folders.contains("3. Semester alt"));
        // Kollision
        assert!(lib.rename_folder("Drei", "3. Semester alt").is_err());
    }
    #[test]
    fn test_delete_folder_moves_contents_up() {
        let mut lib = library();
        lib.delete_folder("3. Semester");
        assert_eq!(lib.folder_of("analysis"), "Mathe");
        assert_eq!(lib.folder_of("uebung"), ROOT);
        assert!(!lib.notebooks.contains_key("uebung"));
        assert_eq!(lib.subfolders(ROOT), ["Mathe", "Physik"]);
    }
    #[test]
    fn test_move_folder() {
        let mut lib = library();
        lib.create_folder(ROOT, "Mathe-Sammlung").unwrap();
        // Ordner samt Inhalt in einen anderen Ordner schieben
        let new = lib
            .move_folder("3. Semester/Mathe", "Mathe-Sammlung")
            .unwrap();
        assert_eq!(new, "Mathe-Sammlung/Mathe");
        assert_eq!(lib.folder_of("analysis"), "Mathe-Sammlung/Mathe");
        assert!(!lib.folders.contains("3. Semester/Mathe"));
        // Auf die oberste Ebene und zurück
        assert_eq!(
            lib.move_folder("Mathe-Sammlung/Mathe", ROOT).unwrap(),
            "Mathe"
        );
        assert_eq!(
            lib.move_folder("Mathe", "3. Semester").unwrap(),
            "3. Semester/Mathe"
        );
        // Nicht in sich selbst oder in einen eigenen Unterordner
        assert!(lib.move_folder("3. Semester", "3. Semester").is_err());
        assert!(lib.move_folder("3. Semester", "3. Semester/Mathe").is_err());
        assert_eq!(lib.folder_move_targets("3. Semester"), ["Mathe-Sammlung"]);
        // Namenskollision am Ziel
        lib.create_folder("Mathe-Sammlung", "Physik").unwrap();
        assert!(lib
            .move_folder("3. Semester/Physik", "Mathe-Sammlung")
            .is_err());
        assert_eq!(lib.folder_of("uebung"), "3. Semester");
    }
    #[test]
    fn test_move_notebook() {
        let mut lib = library();
        lib.move_notebook("uebung", "3. Semester/Physik").unwrap();
        assert_eq!(lib.folder_of("uebung"), "3. Semester/Physik");
        lib.move_notebook("uebung", ROOT).unwrap();
        assert_eq!(lib.folder_of("uebung"), ROOT);
        assert!(lib.move_notebook("uebung", "Gibt es nicht").is_err());
    }
    #[test]
    fn test_load_save_and_repair() {
        let dir = tempfile::tempdir().unwrap();
        // Fehlende Datei: keine Ordner
        assert_eq!(Library::load(dir.path()), Library::default());
        let lib = library();
        lib.save(dir.path()).unwrap();
        assert_eq!(Library::load(dir.path()), lib);
        // Beschädigt: alles auf oberster Ebene statt Absturz
        std::fs::write(Library::file_path(dir.path()), b"{ kaputt").unwrap();
        assert_eq!(Library::load(dir.path()), Library::default());
        // Von Hand bearbeitet: fehlende Elternordner werden ergänzt, Unsinn fällt weg
        std::fs::write(
            Library::file_path(dir.path()),
            br#"{"folders": ["A/B", "", "C//D"], "notebooks": {"x": "E/F", "y": "/kaputt"}}"#,
        )
        .unwrap();
        let lib = Library::load(dir.path());
        assert_eq!(lib.all_folders(), ["A", "A/B", "E", "E/F"]);
        assert_eq!(lib.folder_of("x"), "E/F");
        assert_eq!(lib.folder_of("y"), ROOT);
    }
 }
@@ -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>> {
+pub fn page_svg(
-    let pdf =
+    page: &Page,
-        Pdf::new(single_page_pdf(page, assets)?).map_err(|e| format!("PDF nicht lesbar: {e:?}"))?;
+    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,74 @@ mod tests {
        assert!(clear.height() as f32 / clear.width() as f32 - PAGE_HEIGHT / PAGE_WIDTH < 0.01);
    }
    #[test]
    fn test_highlighter_is_translucent_in_export() {
        // Schwarze Linie, darüber ein gelber Textmarker, der hin und zurück läuft
        let mut page = page_with_line();
        page.strokes[0].color = [0.0, 0.0, 0.0, 1.0];
        for v in &mut page.strokes[0].vertices {
            v.color = [0.0, 0.0, 0.0, 1.0];
        }
        let color = [1.0, 0.95, 0.1, 0.35];
        let samples: Vec<StylusSample> = (0..=40)
            .map(|i| {
                let x = if i <= 20 { i } else { 40 - i } as f32;
                StylusSample {
                    position: glam::Vec2::new(500.0 + x * 20.0, 1000.0 + (i as f32 * 0.5)),
                    pressure: 0.6,
                    timestamp: i as f64 * 0.01,
                }
            })
            .collect();
        let vertices = crate::storage::reconstruct_stroke_vertices(
            &samples,
            color,
            60.0,
            Default::default(),
            true,
        );
        let mut stroke = Stroke::new(8, samples, vertices, color);
        stroke.width = 60.0;
        stroke.tool = crate::document::StrokeTool::Highlighter;
        page.strokes.push(stroke);
        let png = decode(
            &page_png(&page, None, ImageBackground::Paper, PatternColor::default()).unwrap(),
        );
        let px_per_unit = png.width() as f32 / PAGE_WIDTH;
        let at = |x: f32, y: f32| {
            png.get_pixel((x * px_per_unit) as u32, (y * px_per_unit) as u32)
                .0
        };
        // Die schwarze Linie bleibt unter dem Textmarker sichtbar
        let line = at(700.0, 1000.0);
        assert!(line[0] < 110 && line[1] < 110, "Linie verdeckt: {line:?}");
        // Neben der Linie: einmal gelb getönt, auch wo der Strich sich selbst überlappt
        let tint = at(700.0, 1020.0);
        assert!(tint[2] < 200 && tint[0] > 200, "kein Textmarker: {tint:?}");
        let expected_blue = 255.0 * (1.0 - 0.35) + 0.1 * 255.0 * 0.35;
        assert!(
            (tint[2] as f32 - expected_blue).abs() < 25.0,
            "Textmarker mehrfach gedeckt: {tint:?}, erwartet Blau ≈ {expected_blue}"
        );
    }
    #[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 +344,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 +377,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);
@@ -296,6 +411,34 @@ mod tests {
        assert!((rotated.2 as f32) < 300.0 * px_per_unit + 2.0);
    }
    #[test]
    fn test_landscape_page_export_keeps_positions() {
        // Strich unten rechts auf einer Querformat-Seite: im PNG an derselben Stelle
        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,
                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;
        let at = |x: f32, y: f32| {
            png.get_pixel((x * px_per_unit) as u32, (y * px_per_unit) as u32)
                .0
        };
        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, PatternColor::default()).unwrap();
        assert!(svg.contains("<path"));
    }
    #[test]
    fn test_selection_image_is_cropped() {
        let page = page_with_line();
@@ -16,6 +16,19 @@ use crate::assets::RgbaImage;
 /// Längste Kante einer gerenderten Seite für die Anzeige in Pixeln (A4 ≈ 220 dpi).
 pub const DISPLAY_RENDER_PIXELS: u32 = 2560;
 /// Längste Kante beim starken Hineinzoomen (A4 ≈ 440 dpi).
 pub const ZOOMED_RENDER_PIXELS: u32 = 5120;
 /// Texturschlüssel einer PDF-Seite: `<asset>#<seite>`, gerendert mit mehr als
 /// [`DISPLAY_RENDER_PIXELS`] als `<asset>#<seite>@<pixel>`. Liefert Asset, Seite und Pixel.
 pub fn parse_page_key(key: &str) -> Option<(&str, usize, u32)> {
    let (asset, rest) = key.split_once('#')?;
    let (page, pixels) = match rest.split_once('@') {
        Some((page, pixels)) => (page, pixels.parse().ok()?),
        None => (rest, DISPLAY_RENDER_PIXELS),
    };
    Some((asset, page.parse().ok()?, pixels))
 }
 /// Größte Seitenzahl, die importiert wird.
 pub const MAX_IMPORT_PAGES: usize = 2000;
@@ -88,6 +101,7 @@ struct RenderRequest {
    key: String,
    path: PathBuf,
    page: usize,
    max_pixels: u32,
 }
 /// Ergebnis eines Render-Auftrags.
@@ -121,7 +135,7 @@ impl PdfRenderService {
                            .map(|pdf| (request.path.clone(), pdf));
                    }
                    let result = match &open_pdf {
-                        Some((_, pdf)) => render_page(pdf, request.page, DISPLAY_RENDER_PIXELS),
+                        Some((_, pdf)) => render_page(pdf, request.page, request.max_pixels),
                        None => Err("PDF kann nicht geöffnet werden".into()),
                    };
                    if res_tx.send((request.key, result)).is_err() {
@@ -150,7 +164,7 @@ impl PdfRenderService {
        if self.ready.len() >= 2 {
            self.ready.clear();
        }
-        self.request(key, path, page);
+        self.request(key, path, page, DISPLAY_RENDER_PIXELS);
    }
    fn collect(&mut self) {
@@ -161,7 +175,7 @@ impl PdfRenderService {
    }
    /// Erteilt den Auftrag, falls noch keiner läuft. `false`, wenn der Thread beendet ist.
-    fn request(&mut self, key: &str, path: PathBuf, page: usize) -> bool {
+    fn request(&mut self, key: &str, path: PathBuf, page: usize, max_pixels: u32) -> bool {
        if !self.pending.insert(key.to_string()) {
            return true;
        }
@@ -169,6 +183,7 @@ impl PdfRenderService {
            key: key.to_string(),
            path,
            page,
            max_pixels,
        };
        if self.requests.send(request).is_err() {
            self.pending.remove(key);
@@ -178,12 +193,19 @@ impl PdfRenderService {
    }
    /// Fertiges Ergebnis für `key` abholen; sonst den Auftrag (einmalig) erteilen und `None`.
-    pub fn take(&mut self, key: &str, path: PathBuf, page: usize) -> Option<RenderResult> {
+    /// Die Seite wird so gerendert, dass die längste Kante `max_pixels` lang ist.
    pub fn take(
        &mut self,
        key: &str,
        path: PathBuf,
        page: usize,
        max_pixels: u32,
    ) -> Option<RenderResult> {
        self.collect();
        if let Some(result) = self.ready.remove(key) {
            return Some(result);
        }
-        if !self.request(key, path, page) {
+        if !self.request(key, path, page, max_pixels) {
            return Some(Err("PDF-Render-Thread beendet".into()));
        }
        None
@@ -272,13 +294,14 @@ pub(crate) mod tests {
        let mut service = PdfRenderService::new(move || {
            let _ = wake_tx.send(());
        });
-        assert!(service.take("a#0", path.clone(), 0).is_none());
+        let px = DISPLAY_RENDER_PIXELS;
        assert!(service.take("a#0", path.clone(), 0, px).is_none());
        // Zweite Anfrage erteilt keinen weiteren Auftrag
-        assert!(service.take("a#0", path.clone(), 0).is_none());
+        assert!(service.take("a#0", path.clone(), 0, px).is_none());
        wake_rx
            .recv_timeout(std::time::Duration::from_secs(20))
            .unwrap();
-        let image = service.take("a#0", path.clone(), 0).unwrap().unwrap();
+        let image = service.take("a#0", path.clone(), 0, px).unwrap().unwrap();
        assert_eq!(image.width, DISPLAY_RENDER_PIXELS);
        // Vorab rendern: danach sofort verfügbar
@@ -286,6 +309,17 @@ pub(crate) mod tests {
        wake_rx
            .recv_timeout(std::time::Duration::from_secs(20))
            .unwrap();
-        assert!(service.take("a#0", path, 0).unwrap().is_ok());
+        assert!(service.take("a#0", path, 0, px).unwrap().is_ok());
    }
    #[test]
    fn test_parse_page_key() {
        assert_eq!(
            parse_page_key("abc.pdf#3"),
            Some(("abc.pdf", 3, DISPLAY_RENDER_PIXELS))
        );
        assert_eq!(parse_page_key("abc.pdf#3@5120"), Some(("abc.pdf", 3, 5120)));
        assert_eq!(parse_page_key("abc.png"), None);
        assert_eq!(parse_page_key("abc.pdf#x"), None);
    }
 }
@@ -203,13 +203,19 @@ impl SelectionState {
    pub fn paste_from_clipboard(
        &mut self,
        page: &mut Page,
        at: Option<Vec2>,
        next_id_gen: &mut impl FnMut() -> u64,
    ) -> Vec<u64> {
        if self.clipboard.is_empty() {
            return Vec::new();
        }
-        let offset = Vec2::new(30.0, 30.0); // ca. 3 mm Versatz nach rechts-unten
+        // Mit `at` (lange gedrückt → Einfügen) landet die Mitte der Objekte dort, sonst
        // ca. 3 mm nach rechts unten versetzt
        let offset = match (at, Page::selection_aabb(&self.clipboard)) {
            (Some(at), Some(aabb)) => at - (aabb.min + aabb.max) / 2.0,
            _ => Vec2::new(30.0, 30.0),
        };
        let mut new_strokes = Vec::with_capacity(self.clipboard.len());
        let mut new_ids = Vec::with_capacity(self.clipboard.len());
@@ -457,7 +463,7 @@ mod tests {
        // Paste
        let mut next_id = 100;
-        let new_ids = sel.paste_from_clipboard(&mut page, &mut || {
+        let new_ids = sel.paste_from_clipboard(&mut page, None, &mut || {
            next_id += 1;
            next_id
        });
@@ -465,6 +471,18 @@ mod tests {
        assert_eq!(page.strokes.len(), 3);
        assert_eq!(sel.selected_ids, new_ids);
        // An einer Stelle einfügen: die Mitte der Kopie liegt dort
        let target = Vec2::new(1000.0, 1500.0);
        let placed = sel.paste_from_clipboard(&mut page, Some(target), &mut || {
            next_id += 1;
            next_id
        });
        let aabb = sel.get_selection_aabb(&page).unwrap();
        assert_eq!(sel.selected_ids, placed);
        assert!(((aabb.min + aabb.max) / 2.0 - target).length() < 0.01);
        sel.delete_selected(&mut page);
        sel.selected_ids = new_ids.clone();
        // Delete
        let deleted = sel.delete_selected(&mut page);
        assert_eq!(deleted.len(), 1);
@@ -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.
@@ -73,6 +73,130 @@ impl Default for PressureCurve {
    }
 }
 /// Stift-Vorlage: Farbe und Stärke eines der Stifte in der Werkzeugleiste. Ändert man Farbe
 /// oder Stärke, während ein Stift gewählt ist, merkt sich die Vorlage die neuen Werte.
 #[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
 pub struct PenPreset {
    pub color: [f32; 4],
    pub width_mm: f32,
 }
 impl PenPreset {
    pub const WIDTH_RANGE: std::ops::RangeInclusive<f32> = 0.15..=5.0;
    /// Begrenzt Werte aus einer (evtl. von Hand bearbeiteten) Einstellungsdatei; Stifte sind
    /// immer deckend.
    pub fn sanitized(&self, fallback: PenPreset) -> Self {
        let color = sanitized_color(self.color, [0.0, 0.0, 0.0, 1.0]);
        let width_mm = if self.width_mm.is_finite() {
            self.width_mm
                .clamp(*Self::WIDTH_RANGE.start(), *Self::WIDTH_RANGE.end())
        } else {
            fallback.width_mm
        };
        Self { color, width_mm }
    }
 }
 /// Anzahl der Stifte in der Werkzeugleiste.
 pub const PEN_PRESET_COUNT: usize = 4;
 /// Standardstifte: Schwarz, Blau und Rot fein, Grün etwas kräftiger.
 pub const DEFAULT_PEN_PRESETS: [PenPreset; PEN_PRESET_COUNT] = [
    PenPreset {
        color: [0.12, 0.12, 0.14, 1.0],
        width_mm: 0.5,
    },
    PenPreset {
        color: [0.15, 0.35, 0.85, 1.0],
        width_mm: 0.5,
    },
    PenPreset {
        color: [0.85, 0.20, 0.20, 1.0],
        width_mm: 0.5,
    },
    PenPreset {
        color: [0.18, 0.65, 0.35, 1.0],
        width_mm: 0.8,
    },
 ];
 /// Farben des Textmarkers in der Werkzeugleiste (halbtransparent).
 pub const DEFAULT_HIGHLIGHTER_COLORS: [[f32; 4]; 4] = [
    [1.0, 0.95, 0.1, 0.35],
    [0.2, 0.9, 0.3, 0.35],
    [0.25, 0.7, 1.0, 0.35],
    [1.0, 0.3, 0.65, 0.35],
 ];
 /// Farben des Text-Werkzeugs in der Werkzeugleiste.
 pub const DEFAULT_TEXT_COLORS: [[f32; 4]; 5] = [
    [0.12, 0.12, 0.14, 1.0],
    [0.15, 0.35, 0.85, 1.0],
    [0.85, 0.20, 0.20, 1.0],
    [0.18, 0.65, 0.35, 1.0],
    [0.45, 0.45, 0.48, 1.0],
 ];
 /// Begrenzt eine Farbe aus der Einstellungsdatei auf 0–1; die Deckkraft kommt immer aus
 /// `fallback` (Stift und Text deckend, Textmarker halbtransparent).
 fn sanitized_color(color: [f32; 4], fallback: [f32; 4]) -> [f32; 4] {
    let mut out = fallback;
    if color.iter().all(|c| c.is_finite()) {
        for (o, c) in out.iter_mut().zip(color).take(3) {
            *o = c.clamp(0.0, 1.0);
        }
    }
    out
 }
 /// Was eine Taste am Stift bewirkt, solange sie gedrückt ist.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
 pub enum StylusAction {
    /// Radieren (Standard, wie bisher)
    #[default]
    Erase,
    /// Auswählen und verschieben
    Select,
    /// Mit dem Textmarker schreiben
    Highlighter,
    /// Mit dem gewählten Stift schreiben (z. B. während der Textmarker aktiv ist)
    Pen,
    /// Taste nicht verwenden
    Nothing,
 }
 impl StylusAction {
    pub const ALL: [StylusAction; 5] = [
        StylusAction::Erase,
        StylusAction::Select,
        StylusAction::Highlighter,
        StylusAction::Pen,
        StylusAction::Nothing,
    ];
    pub fn label(self) -> &'static str {
        match self {
            StylusAction::Erase => "Radieren",
            StylusAction::Select => "Auswählen",
            StylusAction::Highlighter => "Textmarker",
            StylusAction::Pen => "Stift",
            StylusAction::Nothing => "Nichts",
        }
    }
 }
 /// Eine Taste am Stift: Kennung (aus der Tablet-Schnittstelle, beim ersten Drücken gelernt)
 /// und ihre Belegung.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
 pub struct StylusButton {
    pub id: u64,
    pub action: StylusAction,
 }
 /// Höchstens so viele Stifttasten werden gemerkt.
 pub const MAX_STYLUS_BUTTONS: usize = 4;
 /// Benutzereinstellungen der Oberfläche.
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[serde(default)]
@@ -82,10 +206,22 @@ 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)
    pub continuous_scroll: bool,
    /// Stifte der Werkzeugleiste und der gewählte davon
    pub pen_presets: [PenPreset; PEN_PRESET_COUNT],
    pub active_pen: usize,
    /// Eigene Farben von Textmarker und Text-Werkzeug und die gewählte davon
    pub highlighter_colors: [[f32; 4]; 4],
    pub active_highlighter: usize,
    pub text_colors: [[f32; 4]; 5],
    pub active_text_color: usize,
    /// Tasten am Stift in der Reihenfolge, in der sie zuerst gedrückt wurden
    pub stylus_buttons: Vec<StylusButton>,
 }
 impl Default for UiSettings {
@@ -94,8 +230,16 @@ 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,
            pen_presets: DEFAULT_PEN_PRESETS,
            active_pen: 0,
            highlighter_colors: DEFAULT_HIGHLIGHTER_COLORS,
            active_highlighter: 0,
            text_colors: DEFAULT_TEXT_COLORS,
            active_text_color: 0,
            stylus_buttons: Vec::new(),
        }
    }
 }
@@ -123,6 +267,27 @@ impl UiSettings {
            Err(_) => Self::default(),
        };
        settings.pressure_curve = settings.pressure_curve.sanitized();
        for (preset, fallback) in settings.pen_presets.iter_mut().zip(DEFAULT_PEN_PRESETS) {
            *preset = preset.sanitized(fallback);
        }
        settings.active_pen = settings.active_pen.min(PEN_PRESET_COUNT - 1);
        for (color, fallback) in settings
            .highlighter_colors
            .iter_mut()
            .zip(DEFAULT_HIGHLIGHTER_COLORS)
        {
            *color = sanitized_color(*color, fallback);
        }
        settings.active_highlighter = settings
            .active_highlighter
            .min(settings.highlighter_colors.len() - 1);
        for (color, fallback) in settings.text_colors.iter_mut().zip(DEFAULT_TEXT_COLORS) {
            *color = sanitized_color(*color, fallback);
        }
        settings.active_text_color = settings
            .active_text_color
            .min(settings.text_colors.len() - 1);
        settings.stylus_buttons.truncate(MAX_STYLUS_BUTTONS);
        settings
    }
@@ -148,11 +313,31 @@ 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,
            },
            continuous_scroll: false,
            pen_presets: [PenPreset {
                color: [0.5, 0.2, 0.7, 1.0],
                width_mm: 1.5,
            }; PEN_PRESET_COUNT],
            active_pen: 2,
            highlighter_colors: [[0.9, 0.5, 0.1, 0.35]; 4],
            active_highlighter: 3,
            text_colors: [[0.3, 0.1, 0.6, 1.0]; 5],
            active_text_color: 4,
            stylus_buttons: vec![
                StylusButton {
                    id: 17,
                    action: StylusAction::Select,
                },
                StylusButton {
                    id: 42,
                    action: StylusAction::Nothing,
                },
            ],
        };
        settings.save_to(&path).unwrap();
        assert_eq!(UiSettings::load_from(&path), settings);
@@ -178,6 +363,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(
@@ -188,6 +374,39 @@ mod tests {
        let curve = UiSettings::load_from(&path).pressure_curve;
        assert_eq!(curve.exponent, 3.0);
        assert_eq!(curve.threshold, 0.0);
        // Ohne Stifte: die Standardstifte; unsinnige Stifte werden begrenzt
        assert_eq!(settings.pen_presets, DEFAULT_PEN_PRESETS);
        assert_eq!(settings.active_pen, 0);
        std::fs::write(
            &path,
            br#"{"active_pen": 9, "pen_presets": [
                {"color": [2.0, -1.0, 0.5, 0.2], "width_mm": 99.0},
                {"color": [0.1, 0.2, 0.3, 1.0], "width_mm": 0.0},
                {"color": [0.1, 0.2, 0.3, 1.0], "width_mm": 1.0},
                {"color": [0.1, 0.2, 0.3, 1.0], "width_mm": 1.0}
            ]}"#,
        )
        .unwrap();
        let settings = UiSettings::load_from(&path);
        assert_eq!(settings.active_pen, PEN_PRESET_COUNT - 1);
        assert_eq!(settings.pen_presets[0].color, [1.0, 0.0, 0.5, 1.0]);
        assert_eq!(settings.pen_presets[0].width_mm, 5.0);
        assert_eq!(settings.pen_presets[1].width_mm, 0.15);
        // Eigene Farben: Textmarker bleibt halbtransparent, Text deckend
        std::fs::write(
            &path,
            br#"{"highlighter_colors": [[0.1, 0.2, 0.3, 1.0], [0.1, 0.2, 0.3, 1.0],
                [0.1, 0.2, 0.3, 1.0], [0.1, 0.2, 0.3, 1.0]], "active_highlighter": 7,
                "text_colors": [[5.0, 0.2, 0.3, 0.1], [0.1, 0.2, 0.3, 1.0], [0.1, 0.2, 0.3, 1.0],
                [0.1, 0.2, 0.3, 1.0], [0.1, 0.2, 0.3, 1.0]]}"#,
        )
        .unwrap();
        let settings = UiSettings::load_from(&path);
        assert_eq!(settings.highlighter_colors[0], [0.1, 0.2, 0.3, 0.35]);
        assert_eq!(settings.active_highlighter, 3);
        assert_eq!(settings.text_colors[0], [1.0, 0.2, 0.3, 1.0]);
    }
    #[test]
@@ -30,25 +30,50 @@ fn vs_main(in: VertexInput) -> VertexOutput {
    return out;
 }
 // Linearer Farbwert (Papier, Muster) -> sRGB: Gezeichnet wird ohne sRGB-Umrechnung der GPU
 // (siehe `render_format` in canvas.rs), gemischt wird also wie im PDF in sRGB
 fn linear_to_srgb(c: vec3<f32>) -> vec3<f32> {
    let low = c * 12.92;
    let high = 1.055 * pow(c, vec3<f32>(1.0 / 2.4)) - vec3<f32>(0.055);
    return select(high, low, c <= vec3<f32>(0.0031308));
 }
 // Papier: Farbe linear
@fragment
 fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
-    return in.color;
+    return vec4<f32>(linear_to_srgb(clamp(in.color.rgb, vec3<f32>(0.0), vec3<f32>(1.0))), in.color.a);
 }
-// Striche: bei dunklem Papier wird die HSL-Helligkeit dunkler Farben gespiegelt
+// Striche: Tintenfarben sind sRGB-Werte wie im Export und in der Oberfläche. Bei dunklem
-// (L -> 1 - L, Farbton und Sättigung bleiben). Entspricht `background::adapt_ink_color`.
+// Papier wird die HSL-Helligkeit dunkler Farben gespiegelt (L -> 1 - L, Farbton und
 // Sättigung bleiben). Entspricht `background::adapt_ink_color`.
@fragment
 fn fs_ink(in: VertexOutput) -> @location(0) vec4<f32> {
-    if (camera.ink_params.x < 0.5) {
+    var rgb = clamp(in.color.rgb, vec3<f32>(0.0), vec3<f32>(1.0));
-        return in.color;
+    if (camera.ink_params.x >= 0.5) {
        let max_c = max(max(rgb.r, rgb.g), rgb.b);
        let min_c = min(min(rgb.r, rgb.g), rgb.b);
        let lift = max(1.0 - max_c - min_c, 0.0);
        rgb = min(rgb + vec3<f32>(lift), vec3<f32>(1.0));
    }
-    let max_c = max(max(in.color.r, in.color.g), in.color.b);
+    return vec4<f32>(rgb, in.color.a);
    let min_c = min(min(in.color.r, in.color.g), in.color.b);
    let lift = max(1.0 - max_c - min_c, 0.0);
    return vec4<f32>(in.color.rgb + vec3<f32>(lift), in.color.a);
 }
-// Eingefügte Bilder: texturierte Vierecke unter der Tinte
+// Bildschirmfüllendes Dreieck ohne Farbe (setzt den Stencil-Puffer zurück)
@vertex
 fn vs_fullscreen(@builtin(vertex_index) index: u32) -> @builtin(position) vec4<f32> {
    let x = f32((index << 1u) & 2u) * 2.0 - 1.0;
    let y = f32(index & 2u) * 2.0 - 1.0;
    return vec4<f32>(x, y, 0.0, 1.0);
 }
@fragment
 fn fs_none() -> @location(0) vec4<f32> {
    return vec4<f32>(0.0);
 }
 // Eingefügte Bilder: texturierte Vierecke unter der Tinte (Texturen enthalten sRGB-Werte
 // und werden unverändert übernommen)
 struct ImageVertexInput {
    @location(0) position: vec2<f32>,
    @location(1) uv: vec2<f32>,
@@ -77,3 +102,85 @@ fn vs_image(in: ImageVertexInput) -> ImageVertexOutput {
 fn fs_image(in: ImageVertexOutput) -> @location(0) vec4<f32> {
    return textureSample(image_texture, image_sampler, in.uv);
 }
 // Karo, Linien und Punkte: pro Pixel aus der Seitenkoordinate berechnet, damit die Abstände
 // in jedem Zoom gleichmäßig bleiben. Linien und Punkte sind mindestens ein Pixel breit und
 // kantengeglättet; werden die Abstände sehr klein, blendet das Muster aus statt zu flimmern.
 struct PatternInput {
    @location(0) position: vec2<f32>,
    @location(1) color: vec4<f32>,
    // Art (1 Karo, 2 Linien, 3 Punkte), Abstand, Linienstärke, Punktgröße
    @location(2) params: vec4<f32>,
    // Seitenbreite, Seitenhöhe, Rand oben/unten bei Linien
    @location(3) bounds: vec4<f32>,
 };
 struct PatternOutput {
    @builtin(position) clip_position: vec4<f32>,
    @location(0) page: vec2<f32>,
    @location(1) color: vec4<f32>,
    @location(2) params: vec4<f32>,
    @location(3) bounds: vec4<f32>,
 };
@vertex
 fn vs_pattern(in: PatternInput) -> PatternOutput {
    var out: PatternOutput;
    let ndc = in.position * camera.transform_scale + camera.transform_offset;
    out.clip_position = vec4<f32>(ndc, 0.0, 1.0);
    out.page = in.position;
    out.color = in.color;
    out.params = in.params;
    out.bounds = in.bounds;
    return out;
 }
 // Deckung einer Linie bei `line` für die Koordinate `c` (`upp`: Seiteneinheiten je Pixel).
 fn line_coverage(c: f32, line: f32, half_width: f32, upp: f32) -> f32 {
    let half_px = max(half_width / upp, 0.5);
    let d = abs(c - line) / upp;
    return clamp(half_px + 0.5 - d, 0.0, 1.0);
 }
@fragment
 fn fs_pattern(in: PatternOutput) -> @location(0) vec4<f32> {
    let p = in.page;
    let kind = in.params.x;
    let spacing = in.params.y;
    let upp = max(max(fwidth(p.x), fwidth(p.y)), 1e-4);
    let size = in.bounds.xy;
    // Unter 3 Pixel Abstand ausblenden (ganz herausgezoomt)
    let fade = clamp((spacing / upp - 3.0) / 3.0, 0.0, 1.0);
    var coverage = 0.0;
    if (kind < 1.5) {
        // Karo: senkrechte und waagerechte Linien bei k · Abstand, nicht am Blattrand
        let k = round(p / spacing);
        let line = k * spacing;
        if (k.x >= 1.0 && line.x < size.x - 0.01) {
            coverage = max(coverage, line_coverage(p.x, line.x, in.params.z * 0.5, upp));
        }
        if (k.y >= 1.0 && line.y < size.y - 0.01) {
            coverage = max(coverage, line_coverage(p.y, line.y, in.params.z * 0.5, upp));
        }
    } else if (kind < 2.5) {
        // Linien: waagerecht ab dem oberen Rand bis zum unteren Rand
        let margin = in.bounds.z;
        let k = round((p.y - margin) / spacing);
        let line = margin + k * spacing;
        if (k >= 0.0 && line <= size.y - margin + 0.01) {
            coverage = line_coverage(p.y, line, in.params.z * 0.5, upp);
        }
    } else {
        // Punkte: an den Kreuzungen des Karos
        let k = round(p / spacing);
        let point = k * spacing;
        if (all(k >= vec2<f32>(1.0)) && point.x < size.x - 0.01 && point.y < size.y - 0.01) {
            let radius_px = max(in.params.w * 0.5 / upp, 0.6);
            let d = length(p - point) / upp;
            coverage = clamp(radius_px + 0.5 - d, 0.0, 1.0);
        }
    }
    let rgb = linear_to_srgb(clamp(in.color.rgb, vec3<f32>(0.0), vec3<f32>(1.0)));
    return vec4<f32>(rgb, in.color.a * coverage * fade);
 }
@@ -17,6 +17,10 @@ pub const RDP_TOLERANCE_UNITS: f32 = 0.75;
 /// Schwellenwert für Ecken-Erkennung (Richtungsänderung > 65 Grad).
 pub const CORNER_ANGLE_THRESHOLD_DEG: f32 = 65.0;
 /// Ecken nur zwischen Abschnitten, die nach der Ausdünnung mindestens so lang sind (0,6 mm).
 /// Kleine Schleifen („o“, „a“, „e“) bestehen aus kurzen Abschnitten mit großem Knickwinkel;
 /// würden sie als Ecken getrennt, würden sie zu spitzen Zacken statt Rundungen.
 pub const CORNER_MIN_SEGMENT_UNITS: f32 = 6.0;
 /// GPU-Vertex für Triangle-Strips (Memory-Layout kompatibel mit GPU-Buffern).
 #[repr(C)]
@@ -270,7 +274,7 @@ pub fn generate_triangle_strip(
            // Einzelner Punkt (Stift-Tippen / Dot): Erzeuge kreisförmiges Pad
            let pt = control_points[0];
            let radius = calculate_radius(pt.pressure, config.min_radius, config.max_radius);
-            let segments = 8;
+            let segments = 20;
            let mut vertices = Vec::with_capacity((segments + 1) * 2);
            for i in 0..=segments {
@@ -357,6 +361,34 @@ pub fn smooth_pressure(samples: &[StylusSample]) -> Vec<StylusSample> {
    smoothed
 }
 /// Glättet die Positionen mit dem Fenster [0.25, 0.5, 0.25] gegen Digitizer-Rauschen.
 /// Symmetrisch (ohne Verzögerung), daher bleiben auch kleine Schleifen rund. Anfang, Ende
 /// und Punkte mit scharfem Knick (über [`CORNER_ANGLE_THRESHOLD_DEG`]) bleiben unverändert,
 /// damit Ecken spitz bleiben.
 pub fn smooth_positions(samples: &[StylusSample]) -> Vec<StylusSample> {
    if samples.len() < 3 {
        return samples.to_vec();
    }
    let cos_limit = CORNER_ANGLE_THRESHOLD_DEG.to_radians().cos();
    let mut smoothed = samples.to_vec();
    for i in 1..samples.len() - 1 {
        let (a, b, c) = (
            samples[i - 1].position,
            samples[i].position,
            samples[i + 1].position,
        );
        let (d_in, d_out) = (b - a, c - b);
        if d_in.length_squared() > 1e-8 && d_out.length_squared() > 1e-8 {
            let cos = d_in.normalize().dot(d_out.normalize());
            if cos < cos_limit {
                continue;
            }
        }
        smoothed[i].position = 0.25 * a + 0.5 * b + 0.25 * c;
    }
    smoothed
 }
 /// Rekursives RDP-Markieren zur Ausdünnung kollinearer Zwischenpunkte.
 fn rdp_mark(positions: &[glam::Vec2], start: usize, end: usize, epsilon: f32, keep: &mut [bool]) {
    if end <= start + 1 {
@@ -402,7 +434,8 @@ pub fn rdp_filter_samples(samples: &[StylusSample], epsilon: f32) -> Vec<StylusS
        .collect()
 }
-/// Berechnet die Richtungsänderung zwischen benachbarten Segmenten und findet Ecken mit Winkel > `threshold_deg`.
+/// Berechnet die Richtungsänderung zwischen benachbarten Segmenten und findet Ecken mit Winkel > `threshold_deg`
 /// (nur zwischen Segmenten von mindestens [`CORNER_MIN_SEGMENT_UNITS`] Länge).
 pub fn detect_corners(samples: &[StylusSample], threshold_deg: f32) -> Vec<usize> {
    if samples.len() < 3 {
        return Vec::new();
@@ -415,7 +448,7 @@ pub fn detect_corners(samples: &[StylusSample], threshold_deg: f32) -> Vec<usize
        let l_in = v_in.length();
        let l_out = v_out.length();
-        if l_in > 1e-4 && l_out > 1e-4 {
+        if l_in >= CORNER_MIN_SEGMENT_UNITS && l_out >= CORNER_MIN_SEGMENT_UNITS {
            let d_in = v_in / l_in;
            let d_out = v_out / l_out;
            let dot = d_in.dot(d_out).clamp(-1.0, 1.0);
@@ -566,7 +599,8 @@ pub fn generate_finalized_triangle_strip(
        return Vec::new();
    }
-    const CAP_STEPS: usize = 4;
+    // Runde Kappen fein genug unterteilt, dass sie auch stark vergrößert rund wirken
    const CAP_STEPS: usize = 10;
    let mut vertices = Vec::new();
    // 3. Runde Start-Kappe vor dem ersten Run
@@ -626,7 +660,7 @@ pub fn generate_finalized_triangle_strip(
 /// Finalisiert einen Strich nach dem Zwei-Stufen-Modell:
 /// 1. Ecken-Erkennung (Corner Preservation bei Richtungsänderung > 65°)
-/// 2. Druckglättung über gewichtetes 3-Punkt-Fenster [0.25, 0.5, 0.25]
+/// 2. Druck- und Positionsglättung über gewichtetes 3-Punkt-Fenster [0.25, 0.5, 0.25]
 /// 3. Ramer-Douglas-Peucker (RDP) Dezimierung (Toleranz ca. 0.05 bis 0.1 mm)
 /// 4. Generierung der finalen Triangle-Strips mit runden Kappen an Start und Ende.
 pub fn finalize_stroke(raw_samples: &[StylusSample]) -> Stroke {
@@ -649,8 +683,8 @@ pub fn finalize_stroke_with_config(
        return Stroke::new(stroke_id, Vec::new(), Vec::new(), color);
    }
-    // 1. Druckglättung über 3-Punkt-Fenster [0.25, 0.5, 0.25]
+    // 1. Druck- und Positionsglättung über 3-Punkt-Fenster [0.25, 0.5, 0.25]
-    let smoothed = smooth_pressure(raw_samples);
+    let smoothed = smooth_positions(&smooth_pressure(raw_samples));
    // 2. RDP-Dezimierung (ca. 0.075 mm = 0.75 Einheiten)
    let decimated = rdp_filter_samples(&smoothed, RDP_TOLERANCE_UNITS);
@@ -866,6 +900,31 @@ mod tests {
        assert!((corner_pt.position.y - 0.0).abs() < 1e-3);
    }
    #[test]
    fn test_small_loops_stay_round() {
        // Kleines „o“ (Radius 0,8 mm) in 0,1 s mit 200 Hz, mit Vorschub wie im Wort
        let (r, period, hz) = (8.0_f32, 0.1_f64, 200.0);
        let center = |t: f64| glam::Vec2::new(500.0 + t as f32 * 40.0, 500.0);
        let raw: Vec<StylusSample> = (0..=((period * hz) as usize))
            .map(|i| {
                let t = i as f64 / hz;
                let a = std::f32::consts::TAU * (t / period) as f32;
                StylusSample {
                    position: center(t) + glam::Vec2::new(r * a.sin(), -r * a.cos()),
                    pressure: 0.6,
                    timestamp: t,
                }
            })
            .collect();
        let stroke =
            finalize_stroke_with_config(1, &raw, [0.0; 4], &SplineConfig::from_width_units(5.0));
        for p in &stroke.points {
            let d = (p.position - center(p.timestamp)).length();
            assert!((d - r).abs() < 0.6, "Schleife verformt: Abstand {d}");
        }
        assert!(detect_corners(&stroke.points, CORNER_ANGLE_THRESHOLD_DEG).is_empty());
    }
    #[test]
    fn test_pressure_smoothing() {
        let samples = vec![
@@ -166,7 +166,8 @@ impl StrokeData {
 /// - Version 5: importierte PDF-Seiten als Seitenhintergrund (`pdf_background`).
 /// - Version 6: Seitentitel (`title` in Seite und Manifest).
 /// - Version 7: Textfelder (`text` am Strich).
-pub const CURRENT_FORMAT_VERSION: u32 = 7;
+/// - Version 8: Seitengröße je Seite (`size` in Seite und Manifest), Querformat für Folien.
 pub const CURRENT_FORMAT_VERSION: u32 = 8;
 /// Standardwert für ältere Dateien ohne explizite Formatversion (Legacy v0).
 pub fn legacy_format_version() -> u32 {
@@ -186,9 +187,27 @@ pub struct PageData {
    /// Seitentitel (steht zusätzlich im Manifest)
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub title: Option<String>,
    /// Seitengröße in Seiteneinheiten, wenn nicht DIN A4 hoch (steht zusätzlich im Manifest)
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub size: Option<[f32; 2]>,
    pub strokes: Vec<StrokeData>,
 }
 /// Gespeicherte Seitengröße: `None` für DIN A4 hoch.
 fn stored_size(size: glam::Vec2) -> Option<[f32; 2]> {
    (size != crate::document::A4_SIZE).then(|| size.to_array())
 }
 /// Seitengröße aus einer (evtl. von Hand bearbeiteten) Datei; unbrauchbare Werte ergeben A4.
 pub fn page_size_from(stored: Option<[f32; 2]>) -> glam::Vec2 {
    match stored {
        Some([w, h]) if w.is_finite() && h.is_finite() && w >= 100.0 && h >= 100.0 => {
            glam::Vec2::new(w.min(20_000.0), h.min(20_000.0))
        }
        _ => crate::document::A4_SIZE,
    }
 }
 impl From<&Page> for PageData {
    fn from(page: &Page) -> Self {
        Self {
@@ -197,6 +216,7 @@ impl From<&Page> for PageData {
            background: page.background,
            pdf_background: page.pdf_background.clone(),
            title: page.title.clone(),
            size: stored_size(page.size),
            strokes: page.strokes.iter().map(StrokeData::from).collect(),
        }
    }
@@ -205,7 +225,7 @@ impl From<&Page> for PageData {
 impl PageData {
    /// Wandelt die Seitendaten in eine runtime-aktive `Page` mit initialisiertem Cache um.
    pub fn to_page(&self) -> Page {
-        let mut page = Page::new(self.id, self.background);
+        let mut page = Page::new(self.id, self.background).with_size(page_size_from(self.size));
        page.pdf_background = self.pdf_background.clone();
        page.title = self.title.clone();
        for stroke_data in &self.strokes {
@@ -227,6 +247,9 @@ pub struct PageMeta {
    /// Seitentitel (Lesezeichen), damit die Seitenübersicht ihn ohne Laden der Seite kennt
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub title: Option<String>,
    /// Seitengröße, wenn nicht DIN A4 hoch (für Lage und Maßstab ungeladener Seiten)
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub size: Option<[f32; 2]>,
 }
 impl PageMeta {
@@ -235,6 +258,7 @@ impl PageMeta {
            id,
            background,
            title: None,
            size: None,
        }
    }
 }
@@ -292,6 +316,15 @@ impl NotebookManifest {
            .and_then(|p| p.title.clone())
    }
    pub fn size_for_page(&self, page_id: u64) -> glam::Vec2 {
        page_size_from(
            self.pages
                .iter()
                .find(|p| p.id == page_id)
                .and_then(|p| p.size),
        )
    }
    pub fn background_for_page(&self, page_id: u64) -> Option<PageBackground> {
        self.pages
            .iter()
@@ -308,6 +341,7 @@ impl NotebookManifest {
                id: p.id,
                background: Some(p.background),
                title: p.title.clone(),
                size: stored_size(p.size),
            })
            .collect();
        self.page_ids = self.pages.iter().map(|p| p.id).collect();
@@ -718,7 +752,7 @@ pub fn load_notebook(notebook_dir: &Path) -> Result<(Notebook, NotebookManifest)
                    quarantine_path: q_path,
                },
            );
-            let mut page = Page::new(id, first_bg);
+            let mut page = Page::new(id, first_bg).with_size(manifest.size_for_page(id));
            page.persist = PersistState::ReadOnlyAfterLoadError;
            page
        }
@@ -734,13 +768,15 @@ pub fn load_notebook(notebook_dir: &Path) -> Result<(Notebook, NotebookManifest)
                    quarantine_path: None,
                },
            );
-            let mut page = Page::new(first_id, first_bg);
+            let mut page =
                Page::new(first_id, first_bg).with_size(manifest.size_for_page(first_id));
            page.persist = PersistState::ReadOnlyAfterLoadError;
            page
        }
        Err(e) => {
            eprintln!("[Storage] Konnte erste Seite {first_id} nicht laden: {e}. Erstelle leere Ersatzseite.");
-            let mut page = Page::new(first_id, first_bg);
+            let mut page =
                Page::new(first_id, first_bg).with_size(manifest.size_for_page(first_id));
            page.persist = PersistState::ReadOnlyAfterLoadError;
            page
        }
@@ -752,7 +788,7 @@ pub fn load_notebook(notebook_dir: &Path) -> Result<(Notebook, NotebookManifest)
        let bg = manifest
            .background_for_page(page_id)
            .unwrap_or(PageBackground::Grid5mm);
-        pages.push(Page::new_unloaded(page_id, bg));
+        pages.push(Page::new_unloaded(page_id, bg).with_size(manifest.size_for_page(page_id)));
    }
    // Titel aus dem Manifest (Platzhalter und Ersatzseiten kennen sie sonst nicht)
@@ -808,7 +844,7 @@ pub fn ensure_page_loaded(
        // Angehängt, aber nie gespeichert (noch leer): leere Seite statt Ladefehler
        Err(StorageError::PageNotFound(_)) => {
            let placeholder = &mut notebook.pages[page_idx];
-            let mut page = Page::new(page_id, placeholder.background);
+            let mut page = Page::new(page_id, placeholder.background).with_size(placeholder.size);
            page.title = placeholder.title.take();
            *placeholder = page;
            Ok(())
@@ -1132,7 +1168,8 @@ pub fn create_notebook_from_pdf(
            .iter()
            .enumerate()
            .map(|(i, &(width_pt, height_pt))| {
-                let mut page = Page::new(i as u64 + 1, PageBackground::Blank);
+                let mut page = Page::new(i as u64 + 1, PageBackground::Blank)
                    .with_size(crate::document::pdf_page_size(width_pt, height_pt));
                page.pdf_background = Some(crate::document::PdfBackground {
                    asset: asset.clone(),
                    page: i as u32,
@@ -1358,7 +1395,9 @@ pub fn load_all_pages(notebook_dir: &Path, notebook: &mut Notebook) -> Result<()
            *page = match load_page(notebook_dir, page.id) {
                Ok(data) => data.to_page(),
                // Wie beim Lazy Loading: nie gespeicherte Seite = leere Seite
-                Err(StorageError::PageNotFound(_)) => Page::new(page.id, page.background),
+                Err(StorageError::PageNotFound(_)) => {
                    Page::new(page.id, page.background).with_size(page.size)
                }
                Err(e) => return Err(e),
            };
            page.title = page.title.take().or(title);
@@ -2299,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]
@@ -2525,6 +2576,35 @@ mod tests {
        assert!(stroke.is_text() && !stroke.is_image() && stroke.vertices.is_empty());
    }
    #[test]
    fn test_page_size_round_trips_and_is_known_before_loading() {
        let temp_dir = tempfile::tempdir().unwrap();
        let (mut notebook, mut manifest, dir) =
            create_new_notebook(temp_dir.path(), "Folien").unwrap();
        let slide = glam::Vec2::new(2970.0, 1671.0);
        notebook.pages[0].size = slide;
        notebook.add_page(PageBackground::Blank);
        notebook.add_page(PageBackground::Blank);
        notebook.pages[2].size = crate::document::A4_SIZE;
        save_notebook(&dir, &notebook, &mut manifest).unwrap();
        let (mut reloaded, _) = load_notebook(&dir).unwrap();
        let sizes: Vec<glam::Vec2> = reloaded.pages.iter().map(|p| p.size).collect();
        assert_eq!(sizes, vec![slide, slide, crate::document::A4_SIZE]);
        // Ungeladene Platzhalter kennen ihre Größe aus dem Manifest
        assert!(!reloaded.pages[1].is_loaded);
        ensure_page_loaded(&dir, &mut reloaded, 1).unwrap();
        assert_eq!(reloaded.pages[1].size, slide);
        // A4-Seiten speichern keine Größe (Dateien bleiben wie bisher)
        let data = load_page(&dir, reloaded.pages[2].id).unwrap();
        assert_eq!(data.size, None);
        // Unsinnige Werte aus einer bearbeiteten Datei ergeben A4
        assert_eq!(
            page_size_from(Some([f32::NAN, 5.0])),
            crate::document::A4_SIZE
        );
    }
    #[test]
    fn test_create_notebook_from_pdf() {
        let temp_dir = tempfile::tempdir().unwrap();
@@ -14,7 +14,7 @@ use ab_glyph::{Font, FontRef, GlyphId, PxScale};
 use serde::{Deserialize, Serialize};
 use crate::assets::RgbaImage;
-use crate::document::{Stroke, PAGE_WIDTH, UNITS_PER_MM};
+use crate::document::{Stroke, UNITS_PER_MM};
 /// Schriftart eines Textfelds.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
@@ -270,15 +270,16 @@ pub struct TextEditing {
 impl TextEditing {
    /// Neues, leeres Feld: die erste Zeile mittig auf `pos`, umbrochen 1 cm vor dem rechten
-    /// Blattrand (mindestens 3 cm breit).
+    /// Rand eines Blatts der Breite `page_width` (mindestens 3 cm breit).
    pub fn new_at(
        page_id: u64,
        pos: glam::Vec2,
        page_width: f32,
        size: f32,
        font: TextFont,
        color: [f32; 4],
    ) -> Self {
-        let right = PAGE_WIDTH - RIGHT_MARGIN;
+        let right = page_width - RIGHT_MARGIN;
        let x = pos.x.min(right - MIN_WRAP_WIDTH).max(0.0);
        let text = TextBox::new(String::new(), size, font, (right - x).max(MIN_WRAP_WIDTH));
        let line_height = text.layout().line_height;
@@ -347,7 +348,7 @@ const MAX_TEXTURE_SIDE: f32 = 4096.0;
 const MAX_TEXTURE_PIXELS: f32 = 16.0 * 1024.0 * 1024.0;
 /// Rastert ein Textfeld mit `px_per_unit` Pixeln je Seiteneinheit (begrenzt auf eine
-/// handhabbare Texturgröße). `color` ist linear wie die Tinte; die Pixel sind sRGB.
+/// handhabbare Texturgröße). `color` ist sRGB wie die Tinte, ebenso die Pixel.
 pub fn rasterize(text: &TextBox, color: [f32; 4], px_per_unit: f32) -> RgbaImage {
    let layout = text.layout();
    let size = glam::Vec2::new(text.wrap_width.max(text.size), layout.height());
@@ -382,7 +383,7 @@ pub fn rasterize(text: &TextBox, color: [f32; 4], px_per_unit: f32) -> RgbaImage
        }
    }
-    let rgb = [0, 1, 2].map(|i| egui::ecolor::gamma_u8_from_linear_f32(color[i]));
+    let rgb = [0, 1, 2].map(|i| (color[i].clamp(0.0, 1.0) * 255.0).round() as u8);
    let alpha = color[3].clamp(0.0, 1.0);
    let mut pixels = Vec::with_capacity(coverage.len() * 4);
    for c in coverage {
@@ -400,6 +401,7 @@ pub fn rasterize(text: &TextBox, color: [f32; 4], px_per_unit: f32) -> RgbaImage
 #[cfg(test)]
 mod tests {
    use super::*;
    use crate::document::PAGE_WIDTH;
    fn sample(content: &str, wrap_width: f32) -> TextBox {
        TextBox::new(content.to_string(), 50.0, TextFont::Sans, wrap_width)
@@ -474,8 +476,8 @@ mod tests {
        assert_eq!(image.height as f32, text.layout().height().ceil());
        let opaque = image.pixels.chunks(4).filter(|p| p[3] > 200).count();
        assert!(opaque > 100, "{opaque}");
-        // Farbe ist sRGB-kodiert
+        // Die Farbe ist schon sRGB und wird unverändert übernommen
-        assert!(image.pixels.chunks(4).all(|p| p[0] > 230 && p[1] < 130));
+        assert!(image.pixels.chunks(4).all(|p| p[..3] == [217, 51, 51]));
    }
    #[test]
@@ -483,6 +485,7 @@ mod tests {
        let edit = TextEditing::new_at(
            1,
            glam::Vec2::new(500.0, 800.0),
            PAGE_WIDTH,
            50.0,
            TextFont::Sans,
            [0.0; 4],
@@ -496,6 +499,7 @@ mod tests {
        let edge = TextEditing::new_at(
            1,
            glam::Vec2::new(2050.0, 100.0),
            PAGE_WIDTH,
            50.0,
            TextFont::Sans,
            [0.0; 4],
@@ -509,6 +513,7 @@ mod tests {
        let mut edit = TextEditing::new_at(
            1,
            glam::Vec2::new(400.0, 400.0),
            PAGE_WIDTH,
            50.0,
            TextFont::Sans,
            [0.0; 4],
@@ -3,52 +3,96 @@
 //! Berechnet die affine Transformation zwischen Bildschirmkoordinaten (Window-Pixel),
 //! virtuellen DIN-A4-Seitenkoordinaten ([0, 2100] x [0, 2970]) und dem GPU-NDC-Raum ([-1, 1]).
-use crate::document::{PageViewport, PAGE_HEIGHT, PAGE_WIDTH, UNITS_PER_MM};
+use crate::document::PageViewport;
 use glam::{Mat4, Vec2, Vec4};
 /// Minimaler und maximaler Zoomfaktor.
 pub const MIN_ZOOM: f32 = 0.25;
-pub const MAX_ZOOM: f32 = 5.0;
+pub const MAX_ZOOM: f32 = 10.0;
 /// Abstand zwischen zwei Seiten in der durchgehenden Ansicht (8 mm).
 pub const PAGE_GAP: f32 = 8.0 * UNITS_PER_MM;
 /// Vertikaler Abstand gleicher Punkte zweier aufeinanderfolgender Seiten.
 pub const PAGE_PITCH: f32 = PAGE_HEIGHT + PAGE_GAP;
 /// Höchstens so viele Nachbarseiten werden gleichzeitig dargestellt.
 pub const MAX_NEIGHBOR_PAGES: usize = 12;
-/// Durchgehende Ansicht: Die Seiten hängen untereinander, Koordinaten beziehen sich auf die
+/// Durchgehende Ansicht: Die Seiten hängen lückenlos untereinander (die Grenze markiert eine
-/// aktuelle Seite. Liefert den Versatz (in Seiten) der Seite, auf der die Höhe `y` liegt,
+/// Linie der Oberfläche) und sind waagerecht zueinander zentriert. Lage jeder Seite (Ecke oben links) in Koordinaten der
-/// oder `None` im Zwischenraum zweier Seiten.
+/// aktuellen Seite.
-pub fn page_offset_at(y: f32) -> Option<i64> {
+#[derive(Debug, Clone, PartialEq)]
-    let k = (y / PAGE_PITCH).floor();
+pub struct PageStack {
-    (y - k * PAGE_PITCH <= PAGE_HEIGHT).then_some(k as i64)
+    pub origins: Vec<Vec2>,
    pub sizes: Vec<Vec2>,
    pub current: usize,
 }
-/// Versätze der Seiten, die zwischen den Höhen `top` und `bottom` (Koordinaten der aktuellen
+impl PageStack {
-/// Seite) sichtbar sind, begrenzt auf die Seitenindizes `0..page_count` und ohne die aktuelle
+    /// Stapel aus den Seitengrößen; `current` ist die Bezugsseite.
-/// Seite selbst.
+    pub fn new(sizes: Vec<Vec2>, current: usize) -> Self {
-pub fn visible_neighbor_offsets(
+        let current = current.min(sizes.len().saturating_sub(1));
-    top: f32,
+        let width = sizes.get(current).map_or(0.0, |s| s.x);
-    bottom: f32,
+        let mut origins = vec![Vec2::ZERO; sizes.len()];
-    current: usize,
+        let x = |i: usize| (width - sizes[i].x) / 2.0;
-    page_count: usize,
+        for i in current + 1..sizes.len() {
-) -> Vec<i64> {
+            let y = origins[i - 1].y + sizes[i - 1].y;
-    if !(top.is_finite() && bottom.is_finite()) || bottom < top {
+            origins[i] = Vec2::new(x(i), y);
-        return Vec::new();
+        }
        for i in (0..current).rev() {
            let y = origins[i + 1].y - sizes[i].y;
            origins[i] = Vec2::new(x(i), y);
        }
        Self {
            origins,
            sizes,
            current,
        }
    }
-    let first = (top / PAGE_PITCH).floor().max(-(current as f32)) as i64;
+
-    let last = (bottom / PAGE_PITCH)
+    pub fn len(&self) -> usize {
-        .floor()
+        self.sizes.len()
-        .min((page_count as f32) - 1.0 - current as f32) as i64;
+    }
-    let mut offsets: Vec<i64> = (first..=last).filter(|&k| k != 0).collect();
+
-    // Sehr weit herausgezoomt: nur die nächstgelegenen Seiten
+    pub fn is_empty(&self) -> bool {
-    if offsets.len() > MAX_NEIGHBOR_PAGES {
+        self.sizes.is_empty()
-        offsets.sort_by_key(|k| k.unsigned_abs());
+    }
-        offsets.truncate(MAX_NEIGHBOR_PAGES);
+
-        offsets.sort_unstable();
+    /// Seite, auf deren Höhe `y` liegt (an der Grenze die untere); `None` außerhalb.
    pub fn page_at(&self, y: f32) -> Option<usize> {
        // Seiten liegen nach Index sortiert untereinander
        let i = self.origins.partition_point(|o| o.y <= y).checked_sub(1)?;
        (y <= self.origins[i].y + self.sizes[i].y).then_some(i)
    }
    /// Seiten (außer der aktuellen), die zwischen den Höhen `top` und `bottom` sichtbar sind;
    /// sehr weit herausgezoomt nur die [`MAX_NEIGHBOR_PAGES`] nächstgelegenen.
    pub fn visible_neighbors(&self, top: f32, bottom: f32) -> Vec<usize> {
        if !(top.is_finite() && bottom.is_finite()) || bottom < top {
            return Vec::new();
        }
        let first = self
            .origins
            .iter()
            .zip(&self.sizes)
            .position(|(o, s)| o.y + s.y >= top);
        let Some(first) = first else {
            return Vec::new();
        };
        let mut pages: Vec<usize> = (first..self.len())
            .take_while(|&i| self.origins[i].y <= bottom)
            .filter(|&i| i != self.current)
            .collect();
        if pages.len() > MAX_NEIGHBOR_PAGES {
            pages.sort_by_key(|&i| i.abs_diff(self.current));
            pages.truncate(MAX_NEIGHBOR_PAGES);
            pages.sort_unstable();
        }
        pages
    }
    /// Kleinstes Rechteck um alle Seiten (min, max).
    pub fn bounds(&self) -> (Vec2, Vec2) {
        self.origins.iter().zip(&self.sizes).fold(
            (Vec2::splat(f32::INFINITY), Vec2::splat(f32::NEG_INFINITY)),
            |(min, max), (&o, &s)| (min.min(o), max.max(o + s)),
        )
    }
    offsets
 }
 /// Verwaltet den Viewport-Kamerazustand für stufenlosen Zoom und Pan.
@@ -80,10 +124,13 @@ impl ViewportState {
        self.pan_offset = [0.0, 0.0];
    }
-    /// Durchgehende Ansicht: Die Seite `k` Seiten weiter wird zur Bezugsseite, ohne dass sich
+    /// Durchgehende Ansicht: Die Seite mit der Ecke `origin` (Koordinaten der bisherigen
-    /// der Bildausschnitt bewegt.
+    /// Bezugsseite) wird zur Bezugsseite, ohne dass sich der Bildausschnitt bewegt. Waagerecht
-    pub fn shift_reference_page(&mut self, k: i64) {
+    /// zentriert [`PageViewport`] die neue Seite bereits (ungezoomt); der Pan gleicht nur den
-        self.pan_offset[1] += k as f32 * PAGE_PITCH;
+    /// Zoomanteil aus.
    pub fn shift_reference_page(&mut self, origin: Vec2) {
        self.pan_offset[0] += origin.x * (1.0 - 1.0 / self.zoom.max(1e-6));
        self.pan_offset[1] += origin.y;
    }
    /// Durchgehende Ansicht: Verschiebt den Ausschnitt so, dass der Bildschirmpunkt `center`
@@ -92,14 +139,15 @@ impl ViewportState {
    pub fn clamp_continuous_center(
        &mut self,
        center: [f32; 2],
-        current: usize,
+        stack: &PageStack,
        page_count: usize,
        page_viewport: &PageViewport,
    ) -> bool {
        if stack.is_empty() {
            return false;
        }
        let c = self.screen_to_page_unclamped(center[0], center[1], page_viewport);
-        let top = -(current as f32) * PAGE_PITCH;
+        let (min, max) = stack.bounds();
-        let bottom = page_count.saturating_sub(1 + current) as f32 * PAGE_PITCH + PAGE_HEIGHT;
+        let clamped = c.clamp(min, max.max(min));
        let clamped = Vec2::new(c.x.clamp(0.0, PAGE_WIDTH), c.y.clamp(top, bottom.max(top)));
        if (clamped - c).length() < 1e-3 {
            return false;
        }
@@ -116,7 +164,7 @@ impl ViewportState {
        delta_y: f32,
        page_viewport: &PageViewport,
    ) {
-        let base_scale = page_viewport.page_width / PAGE_WIDTH;
+        let base_scale = page_viewport.scale;
        if base_scale * self.zoom > 1e-6 {
            self.pan_offset[0] += delta_x / (base_scale * self.zoom);
            self.pan_offset[1] += delta_y / (base_scale * self.zoom);
@@ -138,7 +186,7 @@ impl ViewportState {
            return;
        }
-        let base_scale = page_viewport.page_width / PAGE_WIDTH;
+        let base_scale = page_viewport.scale;
        // Bildschirmposition des Seitenursprungs (0, 0)
        let old_offset_x = page_viewport.page_x + self.pan_offset[0] * base_scale * old_zoom;
@@ -160,7 +208,7 @@ impl ViewportState {
        screen_y: f32,
        page_viewport: &PageViewport,
    ) -> Vec2 {
-        let base_scale = page_viewport.page_width / PAGE_WIDTH;
+        let base_scale = page_viewport.scale;
        let effective_scale = base_scale * self.zoom;
        if effective_scale < 1e-6 {
            return Vec2::ZERO;
@@ -182,7 +230,8 @@ impl ViewportState {
        page_viewport: &PageViewport,
    ) -> Option<Vec2> {
        let pt = self.screen_to_page_unclamped(screen_x, screen_y, page_viewport);
-        if (0.0..=PAGE_WIDTH).contains(&pt.x) && (0.0..=PAGE_HEIGHT).contains(&pt.y) {
+        let size = page_viewport.page_size;
        if (0.0..=size.x).contains(&pt.x) && (0.0..=size.y).contains(&pt.y) {
            Some(pt)
        } else {
            None
@@ -197,7 +246,7 @@ impl ViewportState {
        page_viewport: &PageViewport,
    ) -> Vec2 {
        let pt = self.screen_to_page_unclamped(screen_x, screen_y, page_viewport);
-        Vec2::new(pt.x.clamp(0.0, PAGE_WIDTH), pt.y.clamp(0.0, PAGE_HEIGHT))
+        pt.clamp(Vec2::ZERO, page_viewport.page_size)
    }
    /// Transformiert einen DIN-A4-Seitenpunkt in Fenster-Pixelkoordinaten.
@@ -212,7 +261,7 @@ impl ViewportState {
        page_y: f32,
        page_viewport: &PageViewport,
    ) -> [f32; 2] {
-        let base_scale = page_viewport.page_width / PAGE_WIDTH;
+        let base_scale = page_viewport.scale;
        let effective_scale = base_scale * self.zoom;
        let screen_x = page_viewport.page_x + (page_x + self.pan_offset[0]) * effective_scale;
        let screen_y = page_viewport.page_y + (page_y + self.pan_offset[1]) * effective_scale;
@@ -222,7 +271,7 @@ impl ViewportState {
    /// Berechnet die Shader-Transformationsparameter (Scale, Offset) für den Vertex-Shader,
    /// um DIN-A4-Seitenkoordinaten direkt in den GPU-NDC-Bereich [-1.0, 1.0] abzubilden.
    pub fn ndc_transform(&self, page_viewport: &PageViewport) -> ([f32; 2], [f32; 2]) {
-        let base_scale = page_viewport.page_width / PAGE_WIDTH;
+        let base_scale = page_viewport.scale;
        let effective_scale = base_scale * self.zoom;
        // ndc_x = (screen_x / window_width) * 2.0 - 1.0
@@ -260,30 +309,55 @@ impl ViewportState {
 mod tests {
    use super::*;
    const A4: Vec2 = crate::document::A4_SIZE;
    const PITCH: f32 = A4.y;
    fn a4_stack(count: usize, current: usize) -> PageStack {
        PageStack::new(vec![A4; count], current)
    }
    #[test]
    fn test_continuous_layout() {
-        assert_eq!(page_offset_at(100.0), Some(0));
+        let stack = a4_stack(5, 1);
-        assert_eq!(page_offset_at(PAGE_HEIGHT + PAGE_GAP / 2.0), None);
+        assert_eq!(stack.page_at(100.0), Some(1));
-        assert_eq!(page_offset_at(PAGE_PITCH + 5.0), Some(1));
+        // Lückenlos: direkt unter dem Seitenende beginnt die nächste Seite
-        assert_eq!(page_offset_at(-5.0), None);
+        assert_eq!(stack.page_at(A4.y - 1.0), Some(1));
-        assert_eq!(page_offset_at(-PAGE_GAP - 5.0), Some(-1));
+        assert_eq!(stack.page_at(A4.y + 1.0), Some(2));
        assert_eq!(stack.page_at(PITCH + 5.0), Some(2));
        assert_eq!(stack.page_at(-5.0), Some(0));
        assert_eq!(stack.page_at(-PITCH - 5.0), None, "vor der ersten Seite");
        // Ende von Seite 2 und Anfang von Seite 3 sichtbar (aktuell: Seite 2 von 5)
        assert_eq!(
-            visible_neighbor_offsets(PAGE_HEIGHT - 500.0, PAGE_PITCH + 500.0, 1, 5),
+            stack.visible_neighbors(A4.y - 500.0, PITCH + 500.0),
-            vec![1]
+            vec![2]
        );
        // Ganz oben im Notizbuch: keine Seite vor der ersten
-        assert!(visible_neighbor_offsets(-PAGE_PITCH * 3.0, 500.0, 0, 5).is_empty());
+        assert!(a4_stack(5, 0)
            .visible_neighbors(-PITCH * 3.0, 500.0)
            .is_empty());
        // Hinter der letzten Seite: keine weiteren
        assert_eq!(
-            visible_neighbor_offsets(-PAGE_PITCH, PAGE_PITCH * 4.0, 3, 5),
+            a4_stack(5, 3).visible_neighbors(-PITCH + 1.0, PITCH * 4.0),
-            vec![-1, 1]
+            vec![2, 4]
        );
        // Weit herausgezoomt: auf die nächstgelegenen Seiten begrenzt
-        let many = visible_neighbor_offsets(-PAGE_PITCH * 50.0, PAGE_PITCH * 50.0, 50, 200);
+        let many = a4_stack(200, 50).visible_neighbors(-PITCH * 50.0, PITCH * 50.0);
        assert_eq!(many.len(), MAX_NEIGHBOR_PAGES);
-        assert!(many.iter().all(|k| k.unsigned_abs() <= 6));
+        assert!(many.iter().all(|i| i.abs_diff(50) <= 6));
    }
    #[test]
    fn test_stack_of_different_page_sizes() {
        let slide = Vec2::new(2970.0, 1671.0);
        let stack = PageStack::new(vec![slide, A4, slide], 1);
        // Folien waagerecht zur A4-Seite zentriert, direkt darüber und darunter
        assert_eq!(stack.origins[0], Vec2::new(-435.0, -slide.y));
        assert_eq!(stack.origins[2], Vec2::new(-435.0, A4.y));
        assert_eq!(stack.page_at(A4.y + 10.0), Some(2));
        let (min, max) = stack.bounds();
        assert_eq!(min, Vec2::new(-435.0, -slide.y));
        assert_eq!(max, Vec2::new(2535.0, A4.y + slide.y));
    }
    #[test]
@@ -292,33 +366,51 @@ mod tests {
        let page_vp = PageViewport::calculate(1920.0, 1080.0, 24.0);
        vp.pan_by_screen_delta(0.0, -900.0, &page_vp);
        // Punkt oben auf der nächsten Seite, in Koordinaten der aktuellen Seite
-        let before = vp.page_to_screen(300.0, PAGE_PITCH + 200.0, &page_vp);
+        let before = vp.page_to_screen(300.0, PITCH + 200.0, &page_vp);
-        vp.shift_reference_page(1);
+        vp.shift_reference_page(a4_stack(2, 0).origins[1]);
        let after = vp.page_to_screen(300.0, 200.0, &page_vp);
        assert!((before[0] - after[0]).abs() < 0.01 && (before[1] - after[1]).abs() < 0.01);
    }
    #[test]
    fn test_shift_to_page_of_other_size_keeps_view_when_zoomed() {
        let slide = Vec2::new(2970.0, 1671.0);
        let fit = Vec2::new(2970.0, 2970.0);
        let view_a4 = PageViewport::calculate_for(1600.0, 900.0, 20.0, (0.0, 0.0), fit, A4);
        let view_slide = PageViewport::calculate_for(1600.0, 900.0, 20.0, (0.0, 0.0), fit, slide);
        let stack = PageStack::new(vec![A4, slide], 0);
        let mut vp = ViewportState::new();
        vp.zoom_at_cursor([500.0, 300.0], 2.5, &view_a4);
        vp.pan_by_screen_delta(-40.0, -700.0, &view_a4);
        let point = Vec2::new(900.0, 300.0);
        let before = vp.page_to_screen_vec2(stack.origins[1] + point, &view_a4);
        vp.shift_reference_page(stack.origins[1]);
        let after = vp.page_to_screen_vec2(point, &view_slide);
        assert!((before[0] - after[0]).abs() < 0.01 && (before[1] - after[1]).abs() < 0.01);
    }
    #[test]
    fn test_continuous_scroll_stays_on_the_notebook() {
        let page_vp = PageViewport::calculate(1280.0, 850.0, 24.0);
        let center = [640.0, 425.0];
        let stack = a4_stack(3, 1);
        let mut vp = ViewportState::new();
        // Mitte der Seite: nichts zu korrigieren
-        assert!(!vp.clamp_continuous_center(center, 1, 3, &page_vp));
+        assert!(!vp.clamp_continuous_center(center, &stack, &page_vp));
        // Weit über die erste Seite hinaus nach oben gescrollt (aktuell: Seite 2 von 3)
        vp.pan_by_screen_delta(0.0, 5000.0, &page_vp);
-        assert!(vp.clamp_continuous_center(center, 1, 3, &page_vp));
+        assert!(vp.clamp_continuous_center(center, &stack, &page_vp));
        let c = vp.screen_to_page_unclamped(center[0], center[1], &page_vp);
        assert!(
-            (c.y + PAGE_PITCH).abs() < 0.1,
+            (c.y + PITCH).abs() < 0.1,
            "Oberkante der ersten Seite: {c:?}"
        );
        // Weit nach unten: Unterkante der letzten Seite
        vp.pan_by_screen_delta(-3000.0, -20000.0, &page_vp);
-        assert!(vp.clamp_continuous_center(center, 1, 3, &page_vp));
+        assert!(vp.clamp_continuous_center(center, &stack, &page_vp));
        let c = vp.screen_to_page_unclamped(center[0], center[1], &page_vp);
-        assert!((c.y - (PAGE_PITCH + PAGE_HEIGHT)).abs() < 0.1, "{c:?}");
+        assert!((c.y - (PITCH + A4.y)).abs() < 0.1, "{c:?}");
-        assert!((c.x - PAGE_WIDTH).abs() < 0.1, "{c:?}");
+        assert!((c.x - A4.x).abs() < 0.1, "{c:?}");
    }
    #[test]
Author	SHA1	Message	Date
haraldandClaude Opus 5.5	ea9ee6c0d7	feat: Tasten am Stift belegen (Issue #23 ) - Im ☰-Menü unter Eingabe → „Tasten am Stift“: je Taste Radieren (Standard), Auswählen, Textmarker, Stift oder Nichts; gilt, solange die Taste gedrückt ist - Tasten werden beim ersten Drücken gelernt und in ui.json gemerkt; die gerade gedrückte leuchtet im Menü grün - Mit einer Werkzeug-Taste geschriebene Striche benutzen dieses Werkzeug, danach ist wieder das gewählte Werkzeug aktiv Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-08 19:05:09 +02:00
haraldandClaude Opus 5.5	d1f0b46fac	chore(release): bump version to 0.19.0 Build & Publish Release / Build Packages & Publish to Gitea (push) Successful in 7m40s Details Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-08 18:47:28 +02:00
haraldandClaude Opus 5.5	82a297f395	feat: Ordner in andere Ordner verschieben (Issue #18 ) - 📂 auch bei Ordnern: verschiebt den Ordner samt Unterordnern und Notizbüchern in einen anderen Ordner oder auf die oberste Ebene - Nicht in sich selbst oder einen eigenen Unterordner; gibt es am Ziel schon einen gleichnamigen Ordner, kommt eine Meldung statt einer Zusammenlegung Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-08 18:46:51 +02:00
haraldandClaude Opus 5.5	e33062fe0a	chore(release): bump version to 0.18.0 Build & Publish Release / Build Packages & Publish to Gitea (push) Successful in 7m17s Details Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-08 17:42:38 +02:00
haraldandClaude Opus 5.5	36a1a3cd2e	feat: Ordner für Notizbücher (Issue #18 ) - Beliebig verschachtelte Ordner (z. B. 3. Semester › Mathe) im Dokumenten-Manager: Pfadleiste zum Navigieren, Ordner anlegen, umbenennen, löschen (Inhalt rückt eine Ebene nach oben) und Notizbücher mit 📂 verschieben - Neue Notizbücher landen im angezeigten Ordner, importierte PDFs neben dem geöffneten Notizbuch; der Manager öffnet im Ordner des aktuellen Notizbuchs - Ordner sind logisch (library.json im Notizbuch-Basisordner), Notizbuch- Dateien werden nie verschoben; fehlt die Datei, liegt alles oben - Die ganze Titelfläche einer Zeile öffnet Notizbuch bzw. Ordner - Ein ganz neues Standard-Notizbuch wird sofort gespeichert (erschien sonst bis zur ersten Änderung als „beschädigt“) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-08 17:41:05 +02:00
haraldandClaude Opus 5.5	70317caeb5	chore(release): bump version to 0.17.0 Build & Publish Release / Build Packages & Publish to Gitea (push) Successful in 7m34s Details Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-08 17:10:14 +02:00
haraldandClaude Opus 5.5	f9a6f8524d	feat: Lange drücken zum Einfügen (Issue #16 ) - Ein Finger, der eine halbe Sekunde still auf dem Blatt liegt, öffnet ein Kontextmenü mit „Einfügen“ und „Bild aus Datei …“ (wie in Rnote) - Bild, Text oder kopierte Objekte aus der Zwischenablage landen an der gedrückten Stelle (Strg+V weiterhin in der Mitte) - Meldung, wenn die Zwischenablage leer ist Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-08 17:08:55 +02:00
haraldandClaude Opus 5.5	4a4492d034	chore(release): bump version to 0.16.0 Build & Publish Release / Build Packages & Publish to Gitea (push) Successful in 6m52s Details Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-08 16:53:15 +02:00
haraldandClaude Opus 5.5	bb9dbb52d0	feat: Eigene Farben, Bildschirmfarben wie im Export (Issue #13 ) - Jede Farbe der Werkzeugleiste (Stifte, Textmarker, Text) lässt sich anpassen: gewählte Farbe erneut antippen, Vorgabe oder mit 🎨 frei wählen (Farbwähler direkt im Popover). Die Leiste merkt sich die Farben (ui.json). - Tintenfarben sind sRGB-Werte wie im Export: Gezeichnet wird ohne sRGB-Umrechnung der GPU, Papier und Muster rechnet der Shader um. Schwarz ist am Bildschirm jetzt schwarz statt grau, der Textmarker mischt wie im PDF. - PDF-Export: Musterfarbe wird nach sRGB umgerechnet (war zu dunkel). - Auswahl wird in die Farben der Stifte umgefärbt. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-08 16:51:39 +02:00
haraldandClaude Opus 5.5	568714d727	Merge origin/main (Banner-Logo) nach v0.15.0 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-08 16:04:02 +02:00
haraldandClaude Opus 5.5	c87f4102d7	chore(release): bump version to 0.15.0 Build & Publish Release / Build Packages & Publish to Gitea (push) Successful in 7m47s Details Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-08 16:03:39 +02:00
haraldandClaude Opus 5.5	3890b6f182	feat: Stifte, Seiten löschen, lückenlose Seiten, sauberer Textmarker (Issues #11 , #12 , #14 , #15 , #17 , #19 ) - #15: Koordinatensystem ohne Kerbe am Ursprung (Achsen beginnen eine halbe Linienbreite hinter dem Ursprung; im PDF ein Linienzug mit spitzer Ecke) - #17: Jeder Strich deckt ein Pixel nur einmal (Stencil-Puffer), der Textmarker wird innerhalb eines Strichs nicht dunkler. Im PDF-Export ist der Textmarker jetzt halbtransparent statt deckend. - #11: ➕ in der Werkzeugleiste fügt nach der aktuellen Seite eine Seite ein - #12: Seite löschen im ☰-Menü mit Rückfrage, in der Sitzung wiederherstellbar - #14: Seiten liegen lückenlos untereinander, eine dunkle Linie markiert die Grenze - #19: Vier Stifte mit eigener Farbe und Stärke, die sich Änderungen merken (ui.json); Blätterpfeile nur noch in der Einzelseitenansicht Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-08 15:55:32 +02:00
harald	5115e217c2	docs: Banner-Logo hinzugefügt und in README.md eingebunden	2026-10-08 13:37:13 +02:00
haraldandClaude Opus 5.5	904b36e5f7	chore(release): bump version to 0.14.0 Build & Publish Release / Build Packages & Publish to Gitea (push) Successful in 6m25s Details Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-08 12:44:53 +02:00
haraldandClaude Opus 5.5	80d319099f	fix: Karos und Linien in gleichmäßigen Abständen (Issue #10 ) Karo, Linien und Punkte waren Dreiecke mit 0,15 mm breiten Linien – schmaler als ein Bildschirmpixel. Je nach Lage auf dem Pixelraster erschienen sie stärker, schwächer oder versetzt, die Abstände wirkten unregelmäßig. Jetzt berechnet ein Fragment-Shader das Muster für jedes Pixel aus der Seitenkoordinate: Linien und Punkte sind mindestens ein Pixel breit, kantengeglättet und gleichmäßig; bei sehr kleinen Abständen (weit herausgezoomt) blendet das Muster aus. Gemessen: Karo-Abstand 13,5 ± 0,04 Pixel bei gleicher Linienstärke. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-08 12:21:16 +02:00
haraldandClaude Opus 5.5	ee5257d744	fix: Umbenennen und Löschen in der Notizbuchverwaltung reagieren (Issue #9 ) Die Klickfläche zum Öffnen lag über der ganzen Zeile und wurde nach den Knöpfen angelegt; egui gibt Klicks dem zuletzt angelegten Element, die Knöpfe ✏ und 🗑 bekamen daher nie einen Klick. Jetzt öffnet nur der Titelbereich das Notizbuch. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-08 12:16:54 +02:00
haraldandClaude Opus 5.5	fa1ab5ab8f	chore(release): bump version to 0.13.0 Build & Publish Release / Build Packages & Publish to Gitea (push) Successful in 6m52s Details Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-08 12:01:25 +02:00
haraldandClaude Opus 5.5	47300f2ca2	fix: Glatte Strichkanten (Issue #7 ) Die Zeichenfläche wird mit 4× Multisampling gezeichnet und in die Fensterfläche aufgelöst; Strichkanten, Formen und Bildränder sind damit kantengeglättet (ohne Unterstützung des Formats wie bisher). Runde Strichenden und Punkte sind feiner unterteilt (10 statt 4 Schritte je Viertelkreis, 20 statt 8 für Punkte) und wirken auch stark vergrößert rund. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-08 11:54:12 +02:00
haraldandClaude Opus 5.5	27f84ff1b1	fix: Kleine Schleifen bleiben rund (Issue #8 ) Der fertige Strich entsteht jetzt aus den ungefilterten Eingabepunkten mit einer symmetrischen 3-Punkt-Glättung (ohne Verzögerung); der 1€-Filter dient nur der Anzeige während des Schreibens. Der Filter arbeitet mit der Geschwindigkeit in der Ebene statt je Achse und reagiert schneller. Ecken werden nur zwischen Abschnitten ab 0,6 mm getrennt. Ein „o“ mit 0,8 mm Radius behielt bisher im Mittel 6,1 mm/10 statt 8 und bekam zwei Zacken, jetzt 7,8 ohne Zacken. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-08 10:05:17 +02:00
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
haraldandClaude Opus 5.5	6caf3f7476	feat: Seitenformat folgt dem PDF (Querformat für Folien) Seiten haben jetzt eine eigene Größe. 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 (Issue #4). Eingefügte und angehängte Seiten übernehmen das Format der aktuellen Seite. Anzeige: Maßstab aus dem Rahmen aller Seiten, die durchgehende Ansicht stapelt verschieden große Seiten zentriert untereinander. Export (PDF, PNG, SVG) in der jeweiligen Seitengröße. Dateiformat-Version 8 (Größe in Seite und Manifest; A4-Seiten speichern keine Größe). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-08 08:20:44 +02:00
haraldandClaude Opus 5.5	9fde59798f	feat: Neue Seite direkt nach der aktuellen einfügen „Neue Seite einfügen“ (☰-Menü und Seitenauswahl) legt die leere Seite direkt hinter der aktuellen an und wechselt dorthin, statt sie ans Ende zu hängen – etwa zwischen zwei Folien eines PDFs (Issue #3). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-08 08:02:30 +02:00
haraldandClaude Opus 5.5	438106cafd	fix: Auswahlwerkzeug funktioniert mit dem Stift Bisher reagierte das Auswahlwerkzeug nur auf Maus und Finger (Issue #2). Drücken, Ziehen und Loslassen der Auswahl sind jetzt gemeinsame Funktionen für Maus, Finger und Stift. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-08 08:01:23 +02:00
haraldandClaude Opus 5.5	392c22bc4a	feat: Zoom bis 1000 %, PDF-Seiten beim Hineinzoomen schärfer Höchster Zoom 1000 % statt 500 % (Issue #1). Importierte PDF-Seiten werden mit doppelter Auflösung nachgerendert, sobald die Standardauflösung sichtbar vergrößert würde; bis dahin bleibt sie als Ersatz sichtbar. Texte werden bis 8 Pixel je Einheit gerastert. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-08 07:59:27 +02:00