chore(release): bump version to 0.4.0

Dunkelmodus & Papierfarben, Textmarker-Radierer, einstellbare Druckkurve.

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

Cargo.lock

@@ -1048,7 +1048,7 @@ dependencies = [
 
 [[package]]
 name = "ink-notes"
-version = "0.3.5"
+version = "0.4.0"
 dependencies = [
  "bytemuck",
  "egui",
@@ -1057,6 +1057,7 @@ dependencies = [
  "fs2",
  "glam",
  "minisign-verify",
+ "naga",
  "octotablet",
  "pollster",
  "printpdf",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ink-notes"
-version = "0.3.5"
+version = "0.4.0"
 edition = "2021"
 description = "Latenzoptimierte Vektor-Notizbuch- und Inking-Anwendung für Linux"
 repository = "https://gitea.pansi.eu/harald/ink-notes"
@@ -53,3 +53,5 @@ strip = true
 
 [dev-dependencies]
 tempfile = "3.27.0"
+# Prüft den WGSL-Shader in den Tests (dieselbe Version wie in wgpu 0.19)
+naga = { version = "0.19", features = ["wgsl-in"] }

packaging/release-notes.md.tmpl

@@ -3,7 +3,12 @@
 Latenzoptimierte Vektor-Notizbuch- und Inking-Anwendung für Linux (Zorin OS 18 / Ubuntu 24.04).
 
 ### Highlights:
+- **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
+- **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`
 - **Wichtige Fehlerbehebung**: Nach einem Neustart auf einer späteren Seite konnte Weiterschreiben den bisherigen Inhalt dieser Seite überschreiben (betrifft v0.2.3 – v0.3.2)
 - **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
@@ -11,7 +16,7 @@ Latenzoptimierte Vektor-Notizbuch- und Inking-Anwendung für Linux (Zorin OS 18
 - **Aktive Stylus-Unterstützung (Lazarite / MPP / AES)**: Natives Wayland-Tablet-Protokoll mit präziser Druck- und Neigungserfassung
 - **Touchscreen Multi-Touch**: Stufenloses 2-Finger Pinch-to-Zoom und Panning mit umschaltbarem Finger-Zeichenmodus
 - **Zwei-Stufen-Inking-Modell**: Kausale Echtzeit-Glättung via 1€-Filter & akausale Ecken-Erhaltung (Corner Preservation)
-- **Geometrie- und Formerkennung**: Geraden, Rechtecke, Kreise, Dreiecke, Rauten, Vielecke & Koordinatensysteme (Draw-and-Hold); Rechtecke werden zuverlässig erkannt, Freiformen bleiben unverändert
+- **Geometrie- und Formerkennung**: Geraden, Pfeile & Doppelpfeile, Rechtecke, Kreise, Ellipsen, Dreiecke, Rauten, Vielecke & Koordinatensysteme mit spitzen Pfeilspitzen (Draw-and-Hold); Freiformen bleiben unverändert
 - **Multi-Dokumenten-Manager**: Unbegrenzte Notizbücher mit atomarem Autosave, Papierkorb und fortlaufenden Backups
 - **Datensicherheit**: Versioniertes Dateiformat mit Migration, Quarantäne beschädigter Seiten, Schutz vor Doppelöffnung und Crash-getestetem Speichern
 - **In-App Updater**: Automatische Versionsprüfung und sichere Atomar-Aktualisierung via Gitea Releases – mit Pflicht-Signaturprüfung (Minisign) und durchgängigem HTTPS

src/background.rs

@@ -1,5 +1,7 @@
 //! Vektor-Generierung für DIN-A4-Seitenhintergründe (Kariert, Liniert, Punktraster, Blanko).
 
+use serde::{Deserialize, Serialize};
+
 use crate::canvas::InkVertex;
 use crate::document::{PageBackground, PAGE_HEIGHT, PAGE_WIDTH};
 
@@ -13,43 +15,122 @@ pub const GRID_5MM_SPACING: f32 = 50.0;
 /// Zeilenabstand für liniertes Papier (7.5 mm = 75 Einheiten).
 pub const LINED_SPACING: f32 = 75.0;
 
-/// Hellgraue Farbe für Hintergrundmuster (#E0E0E0).
-pub const BACKGROUND_PATTERN_COLOR: [f32; 4] = [0.88, 0.88, 0.88, 1.0];
-/// Papierweiß für das DIN-A4-Blatt (#FFFFFF).
-pub const PAPER_COLOR: [f32; 4] = [1.0, 1.0, 1.0, 1.0];
-/// Schreibtisch-Hintergrundfarbe (Letterbox-Bereich, #28282D).
-pub const DESK_COLOR: wgpu::Color = wgpu::Color {
-    r: 0.16,
-    g: 0.16,
-    b: 0.18,
-    a: 1.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).
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum PaperTheme {
+    #[default]
+    White,
+    /// Cremefarben (augenschonend, wie Recyclingpapier)
+    Cream,
+    /// Dunkelgrau (Nachtmodus)
+    DarkGray,
+    /// Schwarz (OLED)
+    Black,
+}
 
-/// Erzeugt die 6 Vertizes (2 Dreiecke) für das weiße DIN-A4-Papierblatt.
-pub fn generate_paper_quad() -> Vec<InkVertex> {
+impl PaperTheme {
+    pub const ALL: [PaperTheme; 4] = [
+        PaperTheme::White,
+        PaperTheme::Cream,
+        PaperTheme::DarkGray,
+        PaperTheme::Black,
+    ];
+
+    pub fn label(self) -> &'static str {
+        match self {
+            PaperTheme::White => "Weiß",
+            PaperTheme::Cream => "Creme",
+            PaperTheme::DarkGray => "Dunkelgrau",
+            PaperTheme::Black => "Schwarz",
+        }
+    }
+
+    /// Dunkles Papier: dunkle Tinte wird bei Bedarf aufgehellt.
+    pub fn is_dark(self) -> bool {
+        matches!(self, PaperTheme::DarkGray | PaperTheme::Black)
+    }
+
+    /// Farbe des Blatts.
+    pub fn paper_color(self) -> [f32; 4] {
+        match self {
+            PaperTheme::White => [1.0, 1.0, 1.0, 1.0],
+            // sRGB #FBF5E6
+            PaperTheme::Cream => [0.965, 0.913, 0.791, 1.0],
+            // sRGB #2B2B2E
+            PaperTheme::DarkGray => [0.024, 0.024, 0.027, 1.0],
+            PaperTheme::Black => [0.0, 0.0, 0.0, 1.0],
+        }
+    }
+
+    /// Farbe von Karos, Linien und Punkten.
+    pub fn pattern_color(self) -> [f32; 4] {
+        match self {
+            PaperTheme::White => [0.88, 0.88, 0.88, 1.0],
+            PaperTheme::Cream => [0.78, 0.72, 0.60, 1.0],
+            // sRGB #48484D bzw. #38383C
+            PaperTheme::DarkGray => [0.064, 0.064, 0.074, 1.0],
+            PaperTheme::Black => [0.040, 0.040, 0.045, 1.0],
+        }
+    }
+
+    /// Schreibtisch-Hintergrund um das Blatt; bei dunklem Papier noch dunkler, damit sich
+    /// das Blatt abhebt.
+    pub fn desk_color(self) -> wgpu::Color {
+        let (r, g, b) = match self {
+            PaperTheme::White | PaperTheme::Cream => (0.16, 0.16, 0.18),
+            PaperTheme::DarkGray => (0.004, 0.004, 0.005),
+            PaperTheme::Black => (0.03, 0.03, 0.035),
+        };
+        wgpu::Color { r, g, b, a: 1.0 }
+    }
+}
+
+/// Hellt dunkle Tinte für dunkles Papier auf: die HSL-Helligkeit L wird zu 1 − L gespiegelt,
+/// Farbton und Sättigung bleiben erhalten. Farben mit L ≥ 0.5 (Rot, Blau, Textmarker)
+/// bleiben unverändert. Muss mit `fs_ink` in `shader.wgsl` übereinstimmen.
+pub fn adapt_ink_color(color: [f32; 4]) -> [f32; 4] {
+    let max = color[0].max(color[1]).max(color[2]);
+    let min = color[0].min(color[1]).min(color[2]);
+    let lift = (1.0 - max - min).max(0.0);
+    [color[0] + lift, color[1] + lift, color[2] + lift, color[3]]
+}
+
+/// Erzeugt die 6 Vertizes (2 Dreiecke) für das DIN-A4-Papierblatt.
+pub fn generate_paper_quad(color: [f32; 4]) -> Vec<InkVertex> {
     vec![
-        InkVertex::new(0.0, 0.0, PAPER_COLOR),
-        InkVertex::new(PAGE_WIDTH, 0.0, PAPER_COLOR),
-        InkVertex::new(0.0, PAGE_HEIGHT, PAPER_COLOR),
-        InkVertex::new(0.0, PAGE_HEIGHT, PAPER_COLOR),
-        InkVertex::new(PAGE_WIDTH, 0.0, PAPER_COLOR),
-        InkVertex::new(PAGE_WIDTH, PAGE_HEIGHT, PAPER_COLOR),
+        InkVertex::new(0.0, 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(PAGE_WIDTH, 0.0, color),
+        InkVertex::new(PAGE_WIDTH, PAGE_HEIGHT, color),
     ]
 }
 
 /// Fügt ein Quad (2 Dreiecke) zur Vertexliste hinzu.
 #[inline]
-fn push_quad(vertices: &mut Vec<InkVertex>, x_min: f32, y_min: f32, x_max: f32, y_max: f32) {
-    vertices.push(InkVertex::new(x_min, y_min, BACKGROUND_PATTERN_COLOR));
-    vertices.push(InkVertex::new(x_max, y_min, BACKGROUND_PATTERN_COLOR));
-    vertices.push(InkVertex::new(x_min, y_max, BACKGROUND_PATTERN_COLOR));
-    vertices.push(InkVertex::new(x_min, y_max, BACKGROUND_PATTERN_COLOR));
-    vertices.push(InkVertex::new(x_max, y_min, BACKGROUND_PATTERN_COLOR));
-    vertices.push(InkVertex::new(x_max, y_max, BACKGROUND_PATTERN_COLOR));
+fn push_quad(
+    vertices: &mut Vec<InkVertex>,
+    color: [f32; 4],
+    x_min: f32,
+    y_min: f32,
+    x_max: f32,
+    y_max: f32,
+) {
+    vertices.push(InkVertex::new(x_min, y_min, color));
+    vertices.push(InkVertex::new(x_max, y_min, color));
+    vertices.push(InkVertex::new(x_min, y_max, color));
+    vertices.push(InkVertex::new(x_min, y_max, color));
+    vertices.push(InkVertex::new(x_max, y_min, color));
+    vertices.push(InkVertex::new(x_max, y_max, color));
 }
 
-/// Generiert das statische Vektor-Mesh für den gewählten Seitenhintergrund.
-pub fn generate_background_mesh(background: PageBackground) -> Vec<InkVertex> {
+/// Generiert das statische Vektor-Mesh für den gewählten Seitenhintergrund in `color`.
+pub fn generate_background_mesh(background: PageBackground, color: [f32; 4]) -> Vec<InkVertex> {
     match background {
         PageBackground::Blank => Vec::new(),
         PageBackground::Grid5mm => {
@@ -59,14 +140,28 @@ pub fn generate_background_mesh(background: PageBackground) -> Vec<InkVertex> {
             // Vertikale Linien alle 5 mm
             let mut x = GRID_5MM_SPACING;
             while x < PAGE_WIDTH {
-                push_quad(&mut vertices, x - half_t, 0.0, x + half_t, PAGE_HEIGHT);
+                push_quad(
+                    &mut vertices,
+                    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, 0.0, y - half_t, PAGE_WIDTH, y + half_t);
+                push_quad(
+                    &mut vertices,
+                    color,
+                    0.0,
+                    y - half_t,
+                    PAGE_WIDTH,
+                    y + half_t,
+                );
                 y += GRID_5MM_SPACING;
             }
 
@@ -82,7 +177,14 @@ pub fn generate_background_mesh(background: PageBackground) -> Vec<InkVertex> {
 
             let mut y = margin_top;
             while y <= PAGE_HEIGHT - margin_bottom {
-                push_quad(&mut vertices, 0.0, y - half_t, PAGE_WIDTH, y + half_t);
+                push_quad(
+                    &mut vertices,
+                    color,
+                    0.0,
+                    y - half_t,
+                    PAGE_WIDTH,
+                    y + half_t,
+                );
                 y += LINED_SPACING;
             }
 
@@ -98,6 +200,7 @@ pub fn generate_background_mesh(background: PageBackground) -> Vec<InkVertex> {
                 while x < PAGE_WIDTH {
                     push_quad(
                         &mut vertices,
+                        color,
                         x - half_d,
                         y - half_d,
                         x + half_d,
@@ -119,18 +222,20 @@ mod tests {
 
     #[test]
     fn test_paper_quad_generation() {
-        let quad = generate_paper_quad();
+        let quad = generate_paper_quad(PaperTheme::White.paper_color());
         assert_eq!(quad.len(), 6);
         assert_eq!(quad[0].position, [0.0, 0.0]);
         assert_eq!(quad[5].position, [PAGE_WIDTH, PAGE_HEIGHT]);
     }
 
+    const PATTERN: [f32; 4] = [0.5, 0.5, 0.5, 1.0];
+
     #[test]
     fn test_background_meshes() {
-        let blank = generate_background_mesh(PageBackground::Blank);
+        let blank = generate_background_mesh(PageBackground::Blank, PATTERN);
         assert!(blank.is_empty());
 
-        let grid = generate_background_mesh(PageBackground::Grid5mm);
+        let grid = generate_background_mesh(PageBackground::Grid5mm, PATTERN);
         assert!(!grid.is_empty());
         assert_eq!(
             grid.len() % 6,
@@ -138,12 +243,66 @@ mod tests {
             "Muss ein Vielfaches von 6 Vertizes sein (Dreiecke)"
         );
 
-        let lined = generate_background_mesh(PageBackground::Lined);
+        let lined = generate_background_mesh(PageBackground::Lined, PATTERN);
         assert!(!lined.is_empty());
         assert_eq!(lined.len() % 6, 0);
 
-        let dots = generate_background_mesh(PageBackground::DotGrid);
+        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 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()));
+    }
+
+    #[test]
+    fn test_adapt_ink_color() {
+        let close = |a: [f32; 4], b: [f32; 4]| a.iter().zip(b).all(|(x, y)| (x - y).abs() < 1e-5);
+        // Schwarz wird Weiß, Deckkraft bleibt
+        assert!(close(
+            adapt_ink_color([0.0, 0.0, 0.0, 0.7]),
+            [1.0, 1.0, 1.0, 0.7]
+        ));
+        // Notiz-Schwarz wird hell
+        let ink = adapt_ink_color([0.12, 0.12, 0.14, 1.0]);
+        assert!(ink[0] > 0.85 && ink[2] > 0.85);
+        // Dunkelblau wird Hellblau: Farbton bleibt (Blau bleibt der stärkste Kanal)
+        let blue = adapt_ink_color([0.0, 0.0, 0.5, 1.0]);
+        assert!(close(blue, [0.5, 0.5, 1.0, 1.0]));
+        // Helle und gesättigte Farben bleiben unverändert (Rot, Universitäts-Blau, Textmarker)
+        for c in [
+            [0.85, 0.20, 0.20, 1.0],
+            [0.15, 0.35, 0.85, 1.0],
+            [1.0, 0.95, 0.1, 0.35],
+            [1.0, 1.0, 1.0, 1.0],
+        ] {
+            assert!(close(adapt_ink_color(c), c), "{c:?} wurde verändert");
+        }
+        // Ergebnis ist nie heller als Weiß
+        for c in [[0.0, 0.3, 0.1, 1.0], [0.45, 0.45, 0.48, 1.0]] {
+            assert!(adapt_ink_color(c)[..3].iter().all(|&x| x <= 1.0 + 1e-6));
+        }
+    }
+
+    #[test]
+    fn test_paper_themes_contrast() {
+        for theme in PaperTheme::ALL {
+            let paper = theme.paper_color()[0];
+            let pattern = theme.pattern_color()[0];
+            assert!(
+                (paper - pattern).abs() > 0.03,
+                "{theme:?}: Muster hebt sich nicht vom Papier ab"
+            );
+            // Helles Papier ↔ dunkles Papier
+            assert_eq!(theme.is_dark(), paper < 0.5, "{theme:?}");
+        }
+    }
 }

src/canvas.rs

@@ -11,7 +11,7 @@ use std::sync::Arc;
 use winit::dpi::PhysicalSize;
 use winit::window::Window;
 
-use crate::background::{generate_background_mesh, generate_paper_quad, DESK_COLOR};
+use crate::background::{generate_background_mesh, generate_paper_quad, PaperTheme};
 use crate::document::{Page, PageBackground, PageViewport, Stroke, StylusSample};
 use crate::filter::OneEuroFilter;
 use crate::spline::{self, ControlPoint, SplineConfig};
@@ -58,6 +58,8 @@ impl InkVertex {
 pub struct CameraUniforms {
     pub transform_scale: [f32; 2],
     pub transform_offset: [f32; 2],
+    /// x: 1.0 = dunkle Tinte aufhellen (Shader `fs_ink`), y–w: ungenutzt (Ausrichtung)
+    pub ink_params: [f32; 4],
 }
 
 /// Transformiert einen Pixel-Koordinatenpunkt in den Normalized Device Coordinate (NDC) Raum [-1.0, 1.0].
@@ -135,7 +137,6 @@ pub struct CanvasState {
     pub camera_bind_group: wgpu::BindGroup,
     pub current_ink_color: [f32; 4],
     pub current_stroke_width_mm: f32,
-    pub current_tool: crate::document::StrokeTool,
 
     // Statische Hintergrund-Geometrie
     pub paper_buffer: wgpu::Buffer,
@@ -143,6 +144,10 @@ pub struct CanvasState {
     pub background_vertex_capacity: usize,
     pub background_vertex_count: u32,
     pub current_background: PageBackground,
+    /// Papierfarbe der Anzeige
+    pub paper_theme: PaperTheme,
+    /// Dunkle Tinte auf dunklem Papier aufhellen
+    pub adapt_ink: bool,
 
     // Pipeline-Trennung: Live-Strich (aktiver Stroke)
     pub live_vertex_buffer: wgpu::Buffer,
@@ -276,6 +281,7 @@ impl CanvasState {
         let camera_uniforms = CameraUniforms {
             transform_scale: scale,
             transform_offset: offset,
+            ink_params: [0.0; 4],
         };
         let camera_buffer = device.create_buffer(&wgpu::BufferDescriptor {
             label: Some("Camera Uniform Buffer"),
@@ -312,7 +318,7 @@ impl CanvasState {
             },
             fragment: Some(wgpu::FragmentState {
                 module: &shader,
-                entry_point: "fs_main",
+                entry_point: "fs_ink",
                 targets: &[Some(wgpu::ColorTargetState {
                     format: config.format,
                     blend: Some(wgpu::BlendState::ALPHA_BLENDING),
@@ -366,7 +372,8 @@ impl CanvasState {
         });
 
         // 6. Statische Buffer
-        let paper_quad = generate_paper_quad();
+        let paper_theme = PaperTheme::default();
+        let paper_quad = generate_paper_quad(paper_theme.paper_color());
         let paper_buffer = device.create_buffer(&wgpu::BufferDescriptor {
             label: Some("Paper Quad Buffer"),
             size: (paper_quad.len() * std::mem::size_of::<InkVertex>()) as u64,
@@ -376,7 +383,7 @@ 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);
+        let bg_mesh = generate_background_mesh(current_background, paper_theme.pattern_color());
         let background_buffer = device.create_buffer(&wgpu::BufferDescriptor {
             label: Some("Background Mesh Buffer"),
             size: (Self::INITIAL_BACKGROUND_CAPACITY * std::mem::size_of::<InkVertex>()) as u64,
@@ -420,12 +427,13 @@ impl CanvasState {
             camera_bind_group,
             current_ink_color: default_ink_color,
             current_stroke_width_mm: 0.5,
-            current_tool: crate::document::StrokeTool::Pen,
             paper_buffer,
             background_buffer,
             background_vertex_capacity: Self::INITIAL_BACKGROUND_CAPACITY,
             background_vertex_count: bg_mesh.len() as u32,
             current_background,
+            paper_theme,
+            adapt_ink: false,
             live_vertex_buffer,
             live_vertex_capacity: Self::INITIAL_LIVE_CAPACITY,
             live_vertex_count: 0,
@@ -453,6 +461,16 @@ impl CanvasState {
         let camera_uniforms = CameraUniforms {
             transform_scale: scale,
             transform_offset: offset,
+            ink_params: [
+                if self.adapt_ink && self.paper_theme.is_dark() {
+                    1.0
+                } else {
+                    0.0
+                },
+                0.0,
+                0.0,
+                0.0,
+            ],
         };
         self.queue.write_buffer(
             &self.camera_buffer,
@@ -587,9 +605,19 @@ impl CanvasState {
             SplineConfig::from_width_units(width_mm * crate::document::UNITS_PER_MM);
     }
 
-    /// Setzt das aktive Zeichenwerkzeug für den Stift.
-    pub fn set_tool(&mut self, tool: crate::document::StrokeTool) {
-        self.current_tool = tool;
+    /// Setzt die Papierfarbe und ob dunkle Tinte auf dunklem Papier aufgehellt wird.
+    pub fn set_paper_theme(&mut self, theme: PaperTheme, adapt_ink: bool) {
+        self.adapt_ink = adapt_ink;
+        if self.paper_theme != theme {
+            self.paper_theme = theme;
+            self.queue.write_buffer(
+                &self.paper_buffer,
+                0,
+                bytemuck::cast_slice(&generate_paper_quad(theme.paper_color())),
+            );
+            self.upload_background_mesh();
+        }
+        self.update_uniforms();
     }
 
     /// Setzt den Seitenhintergrund und aktualisiert bei Bedarf den Vertex-Puffer.
@@ -598,7 +626,13 @@ impl CanvasState {
             return;
         }
         self.current_background = background;
-        let mesh = generate_background_mesh(background);
+        self.upload_background_mesh();
+    }
+
+    /// Erzeugt das Muster für Hintergrund und Papierfarbe neu und lädt es auf die GPU.
+    fn upload_background_mesh(&mut self) {
+        let mesh =
+            generate_background_mesh(self.current_background, self.paper_theme.pattern_color());
         self.background_vertex_count = mesh.len() as u32;
 
         if mesh.len() > self.background_vertex_capacity {
@@ -728,7 +762,6 @@ impl CanvasState {
             &self.spline_config,
         );
         let mut stroke = stroke;
-        stroke.tool = self.current_tool;
         stroke.width = self.current_stroke_width_mm * crate::document::UNITS_PER_MM;
         stroke.finalized = true;
 
@@ -824,7 +857,7 @@ impl CanvasState {
                     view: &view,
                     resolve_target: None,
                     ops: wgpu::Operations {
-                        load: wgpu::LoadOp::Clear(DESK_COLOR), // Dunkler Tischhintergrund
+                        load: wgpu::LoadOp::Clear(self.paper_theme.desk_color()), // Tischhintergrund
                         store: wgpu::StoreOp::Store,
                     },
                 })],
@@ -836,7 +869,7 @@ impl CanvasState {
             // 2D-Kamera Uniforms (Scale & Offset) binden
             render_pass.set_bind_group(0, &self.camera_bind_group, &[]);
 
-            // 1. Weißes DIN-A4-Blatt zeichnen (Farbe ist direkt im Paper-Quad Vertex hinterlegt)
+            // 1. DIN-A4-Blatt in Papierfarbe zeichnen (Farbe ist direkt im Paper-Quad Vertex hinterlegt)
             render_pass.set_pipeline(&self.triangle_pipeline);
             render_pass.set_vertex_buffer(0, self.paper_buffer.slice(..));
             render_pass.draw(0..6, 0..1);
@@ -948,7 +981,40 @@ mod tests {
     #[test]
     fn test_camera_uniforms() {
         let _u = CameraUniforms::default();
-        assert_eq!(std::mem::size_of::<CameraUniforms>(), 16);
+        // Muss dem WGSL-Layout entsprechen: vec2 + vec2 + vec4
+        assert_eq!(std::mem::size_of::<CameraUniforms>(), 32);
+    }
+
+    #[test]
+    fn test_shader_is_valid_and_matches_uniforms() {
+        // Ein Shaderfehler fiele sonst erst beim Programmstart auf
+        let module = naga::front::wgsl::parse_str(include_str!("shader.wgsl"))
+            .unwrap_or_else(|e| panic!("WGSL-Fehler: {e}"));
+        naga::valid::Validator::new(
+            naga::valid::ValidationFlags::all(),
+            naga::valid::Capabilities::empty(),
+        )
+        .validate(&module)
+        .unwrap_or_else(|e| panic!("Shader ungültig: {e:?}"));
+
+        for name in ["vs_main", "fs_main", "fs_ink"] {
+            assert!(
+                module.entry_points.iter().any(|ep| ep.name == name),
+                "Einstiegspunkt {name} fehlt"
+            );
+        }
+        let camera = module
+            .types
+            .iter()
+            .find(|(_, ty)| ty.name.as_deref() == Some("CameraUniforms"))
+            .expect("CameraUniforms fehlt im Shader")
+            .1;
+        match camera.inner {
+            naga::TypeInner::Struct { span, .. } => {
+                assert_eq!(span as usize, std::mem::size_of::<CameraUniforms>())
+            }
+            ref other => panic!("CameraUniforms ist kein Struct: {other:?}"),
+        }
     }
 
     #[test]

src/document.rs

@@ -113,6 +113,39 @@ pub enum StrokeTool {
     Shape,
 }
 
+impl StrokeTool {
+    /// Werkzeug eines gespeicherten Strichs. Bis v0.3.7 wurde das Werkzeug nicht erfasst und
+    /// jeder Strich als `pen` gespeichert; Textmarker erkennt man dann an der
+    /// Halbtransparenz (der Stift ist immer deckend), Formen an der erkannten Form.
+    pub fn resolve_stored(stored: StrokeTool, color: [f32; 4], has_shape: bool) -> StrokeTool {
+        match stored {
+            StrokeTool::Pen if has_shape => StrokeTool::Shape,
+            StrokeTool::Pen if color[3] < 0.99 => StrokeTool::Highlighter,
+            other => other,
+        }
+    }
+}
+
+/// Welche Striche der Radierer entfernt.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub enum EraserMode {
+    /// Alle getroffenen Striche
+    #[default]
+    All,
+    /// Nur Textmarker – die Handschrift darunter bleibt erhalten
+    HighlighterOnly,
+}
+
+impl EraserMode {
+    /// Darf ein Strich dieses Werkzeugs radiert werden?
+    pub fn erases(self, tool: StrokeTool) -> bool {
+        match self {
+            EraserMode::All => true,
+            EraserMode::HighlighterOnly => tool == StrokeTool::Highlighter,
+        }
+    }
+}
+
 /// Ein einzelner Vektor-Strich auf einer Seite.
 #[derive(Debug, Clone, PartialEq)]
 pub struct Stroke {
@@ -469,7 +502,8 @@ impl Page {
         }
     }
 
-    /// Radiert alle Striche an der Position `eraser_pos` mit Radius `eraser_radius`.
+    /// Radiert alle Striche an der Position `eraser_pos` mit Radius `eraser_radius`,
+    /// die `mode` zulässt.
     ///
     /// Gibt die gelöschten Striche zurück (falls welche getroffen wurden).
     pub fn erase_at(
@@ -477,11 +511,14 @@ impl Page {
         eraser_pos: glam::Vec2,
         eraser_radius: f32,
         max_stroke_radius: f32,
+        mode: EraserMode,
     ) -> Vec<Stroke> {
         let mut hit_indices = Vec::new();
 
         for (i, stroke) in self.strokes.iter().enumerate() {
-            if stroke.intersects_eraser(eraser_pos, eraser_radius, max_stroke_radius) {
+            if mode.erases(stroke.tool)
+                && stroke.intersects_eraser(eraser_pos, eraser_radius, max_stroke_radius)
+            {
                 hit_indices.push(i);
             }
         }
@@ -1040,7 +1077,7 @@ mod tests {
         assert_eq!(page.strokes.len(), 2);
 
         // Radieren bei (30, 12): Trifft nur s1
-        let removed = page.erase_at(glam::Vec2::new(30.0, 12.0), 10.0, 2.0);
+        let removed = page.erase_at(glam::Vec2::new(30.0, 12.0), 10.0, 2.0, EraserMode::All);
         assert_eq!(removed.len(), 1);
         assert_eq!(removed[0].id, 1);
         assert_eq!(page.strokes.len(), 1);
@@ -1056,6 +1093,58 @@ mod tests {
         assert_eq!(page.strokes[0].id, 2);
     }
 
+    #[test]
+    fn test_erase_highlighter_only_keeps_handwriting() {
+        let mut page = Page::new(1, PageBackground::Grid5mm);
+        let line = |id: u64, tool: StrokeTool| {
+            let mut stroke = Stroke::new(
+                id,
+                vec![
+                    StylusSample {
+                        position: glam::Vec2::new(10.0, 10.0),
+                        pressure: 0.5,
+                        timestamp: 0.0,
+                    },
+                    StylusSample {
+                        position: glam::Vec2::new(50.0, 10.0),
+                        pressure: 0.5,
+                        timestamp: 0.01,
+                    },
+                ],
+                vec![
+                    InkVertex::new(10.0, 10.0, [0.0, 0.0, 0.0, 1.0]),
+                    InkVertex::new(50.0, 10.0, [0.0, 0.0, 0.0, 1.0]),
+                ],
+                [0.0, 0.0, 0.0, 1.0],
+            );
+            stroke.tool = tool;
+            stroke
+        };
+        // Handschrift, Form und Textmarker liegen übereinander
+        page.add_stroke(line(1, StrokeTool::Pen));
+        page.add_stroke(line(2, StrokeTool::Highlighter));
+        page.add_stroke(line(3, StrokeTool::Shape));
+
+        let at = glam::Vec2::new(30.0, 10.0);
+        let removed = page.erase_at(at, 10.0, 2.0, EraserMode::HighlighterOnly);
+        assert_eq!(removed.iter().map(|s| s.id).collect::<Vec<_>>(), vec![2]);
+        assert_eq!(
+            page.strokes.iter().map(|s| s.id).collect::<Vec<_>>(),
+            vec![1, 3]
+        );
+        // Kein Textmarker mehr da: nichts wird entfernt, kein Undo-Eintrag
+        assert!(page
+            .erase_at(at, 10.0, 2.0, EraserMode::HighlighterOnly)
+            .is_empty());
+        assert!(page.undo());
+        assert_eq!(page.strokes.len(), 3);
+
+        // Normaler Radierer entfernt alles
+        let removed = page.erase_at(at, 10.0, 2.0, EraserMode::All);
+        assert_eq!(removed.len(), 3);
+        assert!(page.strokes.is_empty());
+    }
+
     #[test]
     fn test_page_isolation() {
         let mut nb = Notebook::new();

src/export.rs

@@ -329,6 +329,59 @@ fn render_recognized_shape(
             layer.add_polygon(poly);
         }
 
+        RecognizedShape::Ellipse {
+            center,
+            radius_x,
+            radius_y,
+            rotation,
+        } => {
+            let ring = (0..72)
+                .map(|i| {
+                    let t = i as f32 / 72.0 * std::f32::consts::TAU;
+                    let p =
+                        crate::geometry::ellipse_point(*center, *radius_x, *radius_y, *rotation, t);
+                    let (x, y) = page_to_pdf_mm(p.x, p.y);
+                    (Point::new(Mm(x), Mm(y)), false)
+                })
+                .collect();
+            layer.add_polygon(Polygon {
+                rings: vec![ring],
+                mode: PaintMode::Stroke,
+                winding_order: WindingOrder::NonZero,
+            });
+        }
+
+        RecognizedShape::Arrow { start, end, double } => {
+            // Gleiche Spitzen wie auf dem Bildschirm; der Schaft endet an ihrer Basis
+            const PDF_SHAPE_HALF_WIDTH: f32 = 2.65;
+            let shaft_len = (*end - *start).length();
+            let dir = (*end - *start).normalize_or_zero();
+            let end_head = crate::geometry::arrow_head(*end, dir, PDF_SHAPE_HALF_WIDTH, shaft_len);
+            let start_head =
+                crate::geometry::arrow_head(*start, -dir, PDF_SHAPE_HALF_WIDTH, shaft_len);
+            let line_start = if *double { start_head.0 } else { *start };
+            let to_pdf = |p: glam::Vec2| {
+                let (x, y) = page_to_pdf_mm(p.x, p.y);
+                (Point::new(Mm(x), Mm(y)), false)
+            };
+            layer.add_line(Line {
+                points: vec![to_pdf(line_start), to_pdf(end_head.0)],
+                is_closed: false,
+            });
+            layer.set_fill_color(stroke_color);
+            let mut heads = vec![(*end, end_head)];
+            if *double {
+                heads.push((*start, start_head));
+            }
+            for (tip, (_, left, right)) in heads {
+                layer.add_polygon(Polygon {
+                    rings: vec![vec![to_pdf(tip), to_pdf(left), to_pdf(right)]],
+                    mode: PaintMode::Fill,
+                    winding_order: WindingOrder::NonZero,
+                });
+            }
+        }
+
         RecognizedShape::Rectangle { corners } => {
             let mut ring = Vec::with_capacity(4);
             for c in corners {
@@ -412,76 +465,58 @@ fn render_recognized_shape(
             y_axis_end,
             with_arrows,
         } => {
+            // Gleiche Pfeilspitzen wie auf dem Bildschirm; Achsen enden an der Basis der Spitze
+            // (Linienstärke 1,5 pt ≈ 5,3 Seiteneinheiten, halbe Breite ≈ 2,65)
+            const PDF_SHAPE_HALF_WIDTH: f32 = 2.65;
+            let y_dir = (*y_axis_end - *origin).normalize_or_zero();
+            let x_dir = (*x_axis_end - *origin).normalize_or_zero();
+            let y_arrow = crate::geometry::arrow_head(
+                *y_axis_end,
+                y_dir,
+                PDF_SHAPE_HALF_WIDTH,
+                (*y_axis_end - *origin).length(),
+            );
+            let x_arrow = crate::geometry::arrow_head(
+                *x_axis_end,
+                x_dir,
+                PDF_SHAPE_HALF_WIDTH,
+                (*x_axis_end - *origin).length(),
+            );
+            let (y_line_end, x_line_end) = if *with_arrows {
+                (y_arrow.0, x_arrow.0)
+            } else {
+                (*y_axis_end, *x_axis_end)
+            };
+
             let (ox, oy) = page_to_pdf_mm(origin.x, origin.y);
-            let (xx, xy) = page_to_pdf_mm(x_axis_end.x, x_axis_end.y);
-            let (yx, yy) = page_to_pdf_mm(y_axis_end.x, y_axis_end.y);
-
-            // Achse 1 (Y)
-            let line_y = Line {
-                points: vec![
-                    (Point::new(Mm(ox), Mm(oy)), false),
-                    (Point::new(Mm(yx), Mm(yy)), false),
-                ],
-                is_closed: false,
-            };
-            layer.add_line(line_y);
-
-            // Achse 2 (X)
-            let line_x = Line {
-                points: vec![
-                    (Point::new(Mm(ox), Mm(oy)), false),
-                    (Point::new(Mm(xx), Mm(xy)), false),
-                ],
-                is_closed: false,
-            };
-            layer.add_line(line_x);
+            for end in [y_line_end, x_line_end] {
+                let (ex, ey) = page_to_pdf_mm(end.x, end.y);
+                layer.add_line(Line {
+                    points: vec![
+                        (Point::new(Mm(ox), Mm(oy)), false),
+                        (Point::new(Mm(ex), Mm(ey)), false),
+                    ],
+                    is_closed: false,
+                });
+            }
 
             // Pfeilspitzen als gefüllte Dreiecke
             if *with_arrows {
                 layer.set_fill_color(stroke_color);
-
-                let y_dir = (*y_axis_end - *origin).normalize_or_zero();
-                let arrow_len_page = 25.0;
-                let arrow_w_page = 16.0;
-
-                let base_y = *y_axis_end - y_dir * arrow_len_page;
-                let left_y = base_y + glam::Vec2::new(-y_dir.y, y_dir.x) * (arrow_w_page * 0.5);
-                let right_y = base_y - glam::Vec2::new(-y_dir.y, y_dir.x) * (arrow_w_page * 0.5);
-
-                let (tx, ty) = page_to_pdf_mm(y_axis_end.x, y_axis_end.y);
-                let (lx, ly) = page_to_pdf_mm(left_y.x, left_y.y);
-                let (rx, ry) = page_to_pdf_mm(right_y.x, right_y.y);
-
-                let arrow_poly_y = Polygon {
-                    rings: vec![vec![
-                        (Point::new(Mm(tx), Mm(ty)), false),
-                        (Point::new(Mm(lx), Mm(ly)), false),
-                        (Point::new(Mm(rx), Mm(ry)), false),
-                    ]],
-                    mode: PaintMode::Fill,
-                    winding_order: WindingOrder::NonZero,
-                };
-                layer.add_polygon(arrow_poly_y);
-
-                let x_dir = (*x_axis_end - *origin).normalize_or_zero();
-                let base_x = *x_axis_end - x_dir * arrow_len_page;
-                let left_x = base_x + glam::Vec2::new(-x_dir.y, x_dir.x) * (arrow_w_page * 0.5);
-                let right_x = base_x - glam::Vec2::new(-x_dir.y, x_dir.x) * (arrow_w_page * 0.5);
-
-                let (tx_x, ty_x) = page_to_pdf_mm(x_axis_end.x, x_axis_end.y);
-                let (lx_x, ly_x) = page_to_pdf_mm(left_x.x, left_x.y);
-                let (rx_x, ry_x) = page_to_pdf_mm(right_x.x, right_x.y);
-
-                let arrow_poly_x = Polygon {
-                    rings: vec![vec![
-                        (Point::new(Mm(tx_x), Mm(ty_x)), false),
-                        (Point::new(Mm(lx_x), Mm(ly_x)), false),
-                        (Point::new(Mm(rx_x), Mm(ry_x)), false),
-                    ]],
-                    mode: PaintMode::Fill,
-                    winding_order: WindingOrder::NonZero,
-                };
-                layer.add_polygon(arrow_poly_x);
+                for (tip, (_, left, right)) in [(*y_axis_end, y_arrow), (*x_axis_end, x_arrow)] {
+                    let ring = [tip, left, right]
+                        .iter()
+                        .map(|p| {
+                            let (px, py) = page_to_pdf_mm(p.x, p.y);
+                            (Point::new(Mm(px), Mm(py)), false)
+                        })
+                        .collect();
+                    layer.add_polygon(Polygon {
+                        rings: vec![ring],
+                        mode: PaintMode::Fill,
+                        winding_order: WindingOrder::NonZero,
+                    });
+                }
             }
         }
     }
@@ -838,6 +873,27 @@ mod tests {
         );
         page.add_stroke(coords_stroke);
 
+        let ellipse_stroke = Stroke::new(40, vec![], vec![], [0.1, 0.5, 0.5, 1.0]).with_shape(
+            crate::geometry::RecognizedShape::Ellipse {
+                center: glam::Vec2::new(1400.0, 600.0),
+                radius_x: 300.0,
+                radius_y: 150.0,
+                rotation: 0.4,
+            },
+        );
+        page.add_stroke(ellipse_stroke);
+
+        for (id, double) in [(41, false), (42, true)] {
+            let arrow_stroke = Stroke::new(id, vec![], vec![], [0.2, 0.2, 0.2, 1.0]).with_shape(
+                crate::geometry::RecognizedShape::Arrow {
+                    start: glam::Vec2::new(1200.0, 1800.0 + id as f32 * 40.0),
+                    end: glam::Vec2::new(1800.0, 1800.0 + id as f32 * 40.0),
+                    double,
+                },
+            );
+            page.add_stroke(arrow_stroke);
+        }
+
         let tri_stroke = Stroke::new(5, vec![], vec![], [0.6, 0.2, 0.7, 1.0]).with_shape(
             crate::geometry::RecognizedShape::Triangle {
                 corners: [

src/geometry.rs

@@ -15,6 +15,8 @@ use crate::document::{Aabb, Stroke, StylusSample};
 pub enum ShapeKind {
     Line,
     Circle,
+    Ellipse,
+    Arrow,
     Rectangle,
     CoordinateSystem,
     Triangle,
@@ -34,6 +36,20 @@ pub enum RecognizedShape {
         center: Vec2,
         radius: f32,
     },
+    /// Ellipse mit den Halbachsen `radius_x` (entlang `rotation`) und `radius_y`.
+    Ellipse {
+        center: Vec2,
+        radius_x: f32,
+        radius_y: f32,
+        /// Drehwinkel der ersten Halbachse zur x-Achse (Bogenmaß)
+        rotation: f32,
+    },
+    /// Pfeil vom Schaftende `start` zur Spitze `end`; `double` = Spitzen an beiden Enden.
+    Arrow {
+        start: Vec2,
+        end: Vec2,
+        double: bool,
+    },
     Rectangle {
         /// 4 Eckpunkte in umlaufender Reihenfolge (strikt rechtwinklig).
         corners: [Vec2; 4],
@@ -70,6 +86,8 @@ impl RecognizedShape {
         match self {
             Self::Line { .. } => ShapeKind::Line,
             Self::Circle { .. } => ShapeKind::Circle,
+            Self::Ellipse { .. } => ShapeKind::Ellipse,
+            Self::Arrow { .. } => ShapeKind::Arrow,
             Self::Rectangle { .. } => ShapeKind::Rectangle,
             Self::CoordinateSystem { .. } => ShapeKind::CoordinateSystem,
             Self::Triangle { .. } => ShapeKind::Triangle,
@@ -83,6 +101,9 @@ impl RecognizedShape {
         match self {
             Self::Line { .. } => "Gerade",
             Self::Circle { .. } => "Kreis",
+            Self::Ellipse { .. } => "Ellipse",
+            Self::Arrow { double: false, .. } => "Pfeil",
+            Self::Arrow { double: true, .. } => "Doppelpfeil",
             Self::Rectangle { .. } => "Rechteck",
             Self::CoordinateSystem { .. } => "Koordinatensystem",
             Self::Triangle { .. } => "Dreieck",
@@ -104,9 +125,13 @@ impl RecognizedShape {
                 *start += delta;
                 *end += delta;
             }
-            Self::Circle { center, .. } => {
+            Self::Circle { center, .. } | Self::Ellipse { center, .. } => {
                 *center += delta;
             }
+            Self::Arrow { start, end, .. } => {
+                *start += delta;
+                *end += delta;
+            }
             Self::Rectangle { corners } | Self::Rhombus { corners } => {
                 for c in corners {
                     *c += delta;
@@ -154,6 +179,16 @@ impl RecognizedShape {
             Self::Circle { center, .. } => {
                 *center = rot(*center);
             }
+            Self::Ellipse {
+                center, rotation, ..
+            } => {
+                *center = rot(*center);
+                *rotation += angle_rad;
+            }
+            Self::Arrow { start, end, .. } => {
+                *start = rot(*start);
+                *end = rot(*end);
+            }
             Self::Rectangle { corners } | Self::Rhombus { corners } => {
                 for c in corners {
                     *c = rot(*c);
@@ -198,6 +233,26 @@ impl RecognizedShape {
                 *center = sc(*center);
                 *radius *= (factors.x.abs() + factors.y.abs()) * 0.5;
             }
+            Self::Ellipse {
+                center,
+                radius_x,
+                radius_y,
+                rotation,
+            } => {
+                // Halbachsen als Vektoren skalieren (bei schräger Ellipse und ungleicher
+                // Skalierung eine gute Näherung)
+                let (sin, cos) = rotation.sin_cos();
+                let axis_x = Vec2::new(cos, sin) * *radius_x * factors;
+                let axis_y = Vec2::new(-sin, cos) * *radius_y * factors;
+                *center = sc(*center);
+                *radius_x = axis_x.length();
+                *radius_y = axis_y.length();
+                *rotation = axis_x.y.atan2(axis_x.x);
+            }
+            Self::Arrow { start, end, .. } => {
+                *start = sc(*start);
+                *end = sc(*end);
+            }
             Self::Rectangle { corners } | Self::Rhombus { corners } => {
                 for c in corners {
                     *c = sc(*c);
@@ -912,6 +967,221 @@ pub fn detect_polygon(points: &[Vec2]) -> Option<RecognizedShape> {
     })
 }
 
+/// Tastet einen Linienzug gleichmäßig entlang der Bogenlänge neu ab (`samples` Abschnitte).
+fn resample_path(points: &[Vec2], samples: usize) -> Vec<Vec2> {
+    let total_len = path_length(points);
+    if points.is_empty() || total_len < 1e-3 || samples == 0 {
+        return points.to_vec();
+    }
+    let step = total_len / samples as f32;
+    let mut resampled = vec![points[0]];
+    let mut carried = 0.0;
+    for w in points.windows(2) {
+        let (a, b) = (w[0], w[1]);
+        let seg = (b - a).length();
+        let mut pos = step - carried;
+        while pos <= seg {
+            resampled.push(a + (b - a) * (pos / seg));
+            pos += step;
+        }
+        carried = seg - (pos - step);
+    }
+    resampled
+}
+
+/// Ellipsen, deren kürzere Halbachse mindestens diesen Anteil der längeren hat, gelten als Kreis.
+const ELLIPSE_MAX_ROUNDNESS: f32 = 0.85;
+/// Ellipsen, die höchstens so viele Grad schief liegen, werden achsenparallel ausgerichtet.
+const ELLIPSE_AXIS_SNAP_DEG: f32 = 8.0;
+
+/// Ellipsenerkennung: geschlossener Pfad, Achsen aus der Hauptkomponentenanalyse der
+/// gleichmäßig abgetasteten Punkte, Halbachsen aus der Ausdehnung entlang dieser Achsen
+/// (2.–98. Perzentil, robust gegen Überstriche). Fast runde Formen bleiben Kreise.
+pub fn detect_ellipse(points: &[Vec2]) -> Option<RecognizedShape> {
+    if points.len() < 8 {
+        return None;
+    }
+    let total_len = path_length(points);
+    if total_len < 40.0 {
+        return None;
+    }
+    let chord_len = (*points.last().unwrap() - points[0]).length();
+    if chord_len > 0.35 * total_len {
+        return None;
+    }
+
+    let pts = resample_path(points, 120);
+    let n = pts.len() as f32;
+    let mean = pts.iter().copied().sum::<Vec2>() / n;
+    let (mut sxx, mut syy, mut sxy) = (0.0_f32, 0.0_f32, 0.0_f32);
+    for p in &pts {
+        let d = *p - mean;
+        sxx += d.x * d.x;
+        syy += d.y * d.y;
+        sxy += d.x * d.y;
+    }
+    let mut rotation = 0.5 * (2.0 * sxy).atan2(sxx - syy);
+
+    // Achsenparallel ausrichten, wenn nur leicht schief
+    let deg = rotation.to_degrees().rem_euclid(90.0);
+    if deg <= ELLIPSE_AXIS_SNAP_DEG || deg >= 90.0 - ELLIPSE_AXIS_SNAP_DEG {
+        rotation = (rotation.to_degrees() / 90.0).round() * 90.0_f32.to_radians();
+    }
+
+    let (sin, cos) = rotation.sin_cos();
+    let mut along: Vec<f32> = pts.iter().map(|p| p.x * cos + p.y * sin).collect();
+    let mut across: Vec<f32> = pts.iter().map(|p| -p.x * sin + p.y * cos).collect();
+    along.sort_by(f32::total_cmp);
+    across.sort_by(f32::total_cmp);
+    let lo = pts.len() * 2 / 100;
+    let hi = pts.len() - 1 - lo;
+    let (a0, a1, b0, b1) = (along[lo], along[hi], across[lo], across[hi]);
+    let mut radius_x = (a1 - a0) * 0.5;
+    let mut radius_y = (b1 - b0) * 0.5;
+    let center = Vec2::new(cos, sin) * (a0 + a1) * 0.5 + Vec2::new(-sin, cos) * (b0 + b1) * 0.5;
+    if radius_x < 10.0 || radius_y < 5.0 {
+        return None;
+    }
+    // Erste Halbachse ist die längere
+    if radius_y > radius_x {
+        std::mem::swap(&mut radius_x, &mut radius_y);
+        rotation += std::f32::consts::FRAC_PI_2;
+    }
+    if radius_y / radius_x >= ELLIPSE_MAX_ROUNDNESS {
+        return None;
+    }
+    // Drehwinkel auf (−90°, 90°] normieren
+    if rotation > std::f32::consts::FRAC_PI_2 {
+        rotation -= std::f32::consts::PI;
+    } else if rotation <= -std::f32::consts::FRAC_PI_2 {
+        rotation += std::f32::consts::PI;
+    }
+
+    Some(RecognizedShape::Ellipse {
+        center,
+        radius_x,
+        radius_y,
+        rotation,
+    })
+}
+
+/// Höchster Abstand der Widerhaken von der Spitze, als Anteil der Schaftlänge.
+const ARROW_HEAD_REACH: f32 = 0.4;
+/// Punkte so nahe an der Spitze gelten als Rückweg zur Spitze, nicht als Widerhaken.
+const ARROW_TIP_ZONE: f32 = 0.08;
+
+/// Pfeilerkennung (auch Doppelpfeil) für einen in einem Zug gezeichneten Pfeil: langer Schaft
+/// und an mindestens einem Ende Widerhaken auf beiden Seiten, schräg nach hinten (10°–80°;
+/// ein T-Ende mit 90° ist kein Pfeil).
+pub fn detect_arrow(points: &[Vec2]) -> Option<RecognizedShape> {
+    if points.len() < 6 {
+        return None;
+    }
+    let total_len = path_length(points);
+    if total_len < 40.0 {
+        return None;
+    }
+    let epsilon = (total_len * 0.02).clamp(3.0, 15.0);
+    let simplified = ramer_douglas_peucker(points, epsilon);
+    if simplified.len() < 4 {
+        return None;
+    }
+
+    // Schaft = längstes Segment, an beiden Enden um fast gerade weiterlaufende Punkte
+    // verlängert (die Vereinfachung teilt den Schaft sonst gern kurz vor der Spitze)
+    let longest = (0..simplified.len() - 1).max_by(|&i, &j| {
+        let li = (simplified[i + 1] - simplified[i]).length();
+        let lj = (simplified[j + 1] - simplified[j]).length();
+        li.total_cmp(&lj)
+    })?;
+    let (mut first, mut last) = (longest, longest + 1);
+    // Ein Folgepunkt gehört zum Schaft, wenn er nahe der Schaftgeraden in Verlängerung liegt
+    // (kein Winkelkriterium: kurze Stücke haben durch das Zittern stark schwankende Richtungen)
+    let continues = |from: Vec2, to: Vec2, next: Vec2| {
+        let dir = (to - from).normalize_or_zero();
+        let beyond = (next - to).dot(dir) > 0.0;
+        let tolerance = (2.0 * epsilon).max(0.05 * (to - from).length());
+        beyond && point_to_line_dist(next, from, to) <= tolerance
+    };
+    while last + 1 < simplified.len()
+        && continues(simplified[first], simplified[last], simplified[last + 1])
+    {
+        last += 1;
+    }
+    while first > 0 && continues(simplified[last], simplified[first], simplified[first - 1]) {
+        first -= 1;
+    }
+    let (a, b) = (simplified[first], simplified[last]);
+    let shaft_len = (b - a).length();
+    if shaft_len < 0.4 * total_len {
+        return None;
+    }
+    let others: Vec<Vec2> = simplified
+        .iter()
+        .enumerate()
+        .filter(|(i, _)| *i < first || *i > last)
+        .map(|(_, p)| *p)
+        .collect();
+
+    // Hat das Schaftende `tip` (mit Gegenende `tail`) Widerhaken auf beiden Seiten?
+    // Liefert None, wenn ein zugeordneter Punkt nicht wie ein Widerhaken liegt.
+    let head_at = |tip: Vec2, tail: Vec2, cluster: &[Vec2]| -> Option<bool> {
+        let back = (tail - tip).normalize_or_zero();
+        let (mut left, mut right) = (false, false);
+        for p in cluster {
+            let v = *p - tip;
+            if v.length() < ARROW_TIP_ZONE * shaft_len {
+                continue;
+            }
+            let angle = back.angle_between(v).to_degrees().abs();
+            if !(10.0..=80.0).contains(&angle) {
+                return None;
+            }
+            if back.perp_dot(v) > 0.0 {
+                left = true;
+            } else {
+                right = true;
+            }
+        }
+        Some(left && right)
+    };
+
+    // Übrige Punkte dem näheren Schaftende zuordnen; sie müssen nahe an diesem liegen
+    let (mut near_a, mut near_b) = (Vec::new(), Vec::new());
+    for p in others {
+        let (da, db) = ((p - a).length(), (p - b).length());
+        if da.min(db) > ARROW_HEAD_REACH * shaft_len {
+            return None;
+        }
+        if da < db {
+            near_a.push(p);
+        } else {
+            near_b.push(p);
+        }
+    }
+    let head_b = head_at(b, a, &near_b)?;
+    let head_a = head_at(a, b, &near_a)?;
+
+    let (start, end, double) = match (head_a, head_b) {
+        (true, true) => (a, b, true),
+        (false, true) if near_a.is_empty() => (a, b, false),
+        (true, false) if near_b.is_empty() => (b, a, false),
+        _ => return None,
+    };
+
+    // Fast waagerechte/senkrechte Pfeile (≤ 5°) gerade ausrichten
+    let dir = end - start;
+    let angle_deg = dir.y.atan2(dir.x).to_degrees().abs();
+    let end = if angle_deg < 5.0 || (angle_deg - 180.0).abs() < 5.0 {
+        Vec2::new(end.x, start.y)
+    } else if (angle_deg - 90.0).abs() < 5.0 {
+        Vec2::new(start.x, end.y)
+    } else {
+        end
+    };
+    Some(RecognizedShape::Arrow { start, end, double })
+}
+
 /// Anteil der gesamten Richtungsänderung, der bei einem Vieleck in der Nähe der Ecken liegen muss.
 const POLYGON_TURNING_AT_CORNERS: f32 = 0.7;
 /// Umgebung einer Ecke als Anteil des Umfangs.
@@ -930,21 +1200,7 @@ fn corner_turning_ratio(points: &[Vec2], corners: &[Vec2]) -> Option<f32> {
     if total_len < 1e-3 || corners.is_empty() {
         return None;
     }
-    // Gleichmäßig neu abtasten (120 Punkte entlang der Bogenlänge)
-    const SAMPLES: usize = 120;
-    let step = total_len / SAMPLES as f32;
-    let mut resampled = vec![points[0]];
-    let mut carried = 0.0;
-    for w in points.windows(2) {
-        let (a, b) = (w[0], w[1]);
-        let seg = (b - a).length();
-        let mut pos = step - carried;
-        while pos <= seg {
-            resampled.push(a + (b - a) * (pos / seg));
-            pos += step;
-        }
-        carried = seg - (pos - step);
-    }
+    let resampled = resample_path(points, 120);
     // Richtungen über einen Abstand von 3 Punkten, um das Zittern zu glätten
     const W: usize = 3;
     if resampled.len() < 2 * W + 2 {
@@ -1177,9 +1433,10 @@ pub fn detect_shape(points: &[StylusSample]) -> Option<RecognizedShape> {
         },
         &|| best_closed.clone(),
         &|| detect_polygon(&pts),
+        // Pfeil vor Koordinatensystem und Gerade: Ein Pfeil ist eine Gerade mit Widerhaken
+        &|| detect_arrow(&pts),
         &|| detect_coordinate_system(&pts),
         &|| detect_line(&pts),
-        &|| None,
     ];
     candidates
         .iter()
@@ -1229,8 +1486,12 @@ pub fn shape_fit_error(points: &[Vec2], shape: &RecognizedShape) -> Option<f32>
 }
 
 /// Beschreibt die Form den Strich gut genug, um ihn zu ersetzen?
+/// Pfeile sind ausgenommen: Ihre Erkennung prüft die Struktur (Schaft, Widerhaken auf beiden
+/// Seiten) bereits streng, und gezeichnete Widerhaken weichen naturgemäß von der sauberen
+/// Spitze ab.
 fn shape_describes_stroke(points: &[Vec2], shape: &RecognizedShape) -> bool {
-    shape_fit_error(points, shape).is_some_and(|err| err <= SHAPE_MAX_FIT_ERROR)
+    matches!(shape, RecognizedShape::Arrow { .. })
+        || shape_fit_error(points, shape).is_some_and(|err| err <= SHAPE_MAX_FIT_ERROR)
 }
 
 /// Größte zulässige Abweichung (RMS) eines Rechtecks vom Strich, als Anteil der Diagonale.
@@ -1248,7 +1509,7 @@ const CLOSED_SHAPE_GOOD_FIT: f32 = 0.04;
 const RECTANGLE_WEIGHT: f32 = 1.0 / 1.5;
 const CIRCLE_WEIGHT: f32 = 1.5;
 
-/// Wählt unter Kreis, Dreieck, Rechteck, Raute und Vieleck die Form, deren Kontur am besten passt,
+/// Wählt unter Kreis, Ellipse, Dreieck, Rechteck, Raute und Vieleck die Form, deren Kontur am besten passt,
 /// und liefert sie mit ihrer Abweichung (RMS).
 fn best_closed_shape(pts: &[Vec2]) -> Option<(f32, RecognizedShape)> {
     // Gewichtete Abweichung: Bei fast gleicher Passung gewinnt die wahrscheinlichere Absicht.
@@ -1259,6 +1520,7 @@ fn best_closed_shape(pts: &[Vec2]) -> Option<(f32, RecognizedShape)> {
     };
     [
         fit(detect_circle(pts), CIRCLE_WEIGHT),
+        fit(detect_ellipse(pts), 1.0),
         fit(detect_triangle(pts), 1.0),
         fit(detect_rectangle(pts), RECTANGLE_WEIGHT),
         fit(detect_rhombus(pts), 1.0),
@@ -1269,6 +1531,45 @@ fn best_closed_shape(pts: &[Vec2]) -> Option<(f32, RecognizedShape)> {
     .min_by(|a, b| a.0.total_cmp(&b.0))
 }
 
+/// Halber Öffnungswinkel einer Pfeilspitze als Verhältnis halbe Breite zu Länge (tan 20° ≈ 0,36,
+/// also ~40° Öffnung – schlank genug, dass die Spitze spitz wirkt).
+const ARROW_HALF_WIDTH_RATIO: f32 = 0.36;
+
+/// Geometrie einer Pfeilspitze an `tip`, Richtung `dir` (Einheitsvektor), für eine Linie der
+/// halben Breite `half_w` (Seiteneinheiten) und der Länge `line_len`. Liefert (Basismitte,
+/// linke Ecke, rechte Ecke). Die Spitze ist ~4 mm lang (dicke Linien länger), höchstens ein
+/// Fünftel der Linie. Die Linie soll an der Basismitte enden – reicht sie bis zur Spitze,
+/// wirkt diese stumpf.
+pub fn arrow_head(tip: Vec2, dir: Vec2, half_w: f32, line_len: f32) -> (Vec2, Vec2, Vec2) {
+    let len = (half_w * 10.0).max(40.0).min(line_len * 0.2);
+    let half_width = len * ARROW_HALF_WIDTH_RATIO;
+    let base = tip - dir * len;
+    let normal = Vec2::new(-dir.y, dir.x);
+    (base, base + normal * half_width, base - normal * half_width)
+}
+
+/// Punkt auf einer Ellipse zum Parameter `t` (Bogenmaß).
+pub fn ellipse_point(center: Vec2, radius_x: f32, radius_y: f32, rotation: f32, t: f32) -> Vec2 {
+    let (sin, cos) = rotation.sin_cos();
+    let local = Vec2::new(t.cos() * radius_x, t.sin() * radius_y);
+    center + Vec2::new(local.x * cos - local.y * sin, local.x * sin + local.y * cos)
+}
+
+/// Näherungsweiser Abstand eines Punktes zum Rand einer Ellipse: Abstand zum Mittelpunkt
+/// minus Ellipsenradius in dieser Richtung (für die Formauswahl genau genug).
+fn ellipse_distance(p: Vec2, center: Vec2, radius_x: f32, radius_y: f32, rotation: f32) -> f32 {
+    let d = p - center;
+    let (sin, cos) = rotation.sin_cos();
+    let local = Vec2::new(d.x * cos + d.y * sin, -d.x * sin + d.y * cos);
+    let scaled = Vec2::new(local.x / radius_x.max(1e-3), local.y / radius_y.max(1e-3));
+    let scaled_len = scaled.length();
+    if scaled_len < 1e-6 {
+        return radius_x.min(radius_y);
+    }
+    let radius_in_direction = local.length() / scaled_len;
+    (local.length() - radius_in_direction).abs()
+}
+
 /// Abstand eines Punktes zur Strecke `a`–`b`.
 fn segment_distance(p: Vec2, a: Vec2, b: Vec2) -> f32 {
     let ab = b - a;
@@ -1299,6 +1600,14 @@ pub fn contour_rms(points: &[Vec2], shape: &RecognizedShape) -> Option<f32> {
             RecognizedShape::Circle { center, radius } => {
                 Some(((p - *center).length() - radius).abs())
             }
+            RecognizedShape::Ellipse {
+                center,
+                radius_x,
+                radius_y,
+                rotation,
+            } => Some(ellipse_distance(
+                p, *center, *radius_x, *radius_y, *rotation,
+            )),
             RecognizedShape::Triangle { corners } => Some(polygon_distance(p, corners)),
             RecognizedShape::Rectangle { corners } | RecognizedShape::Rhombus { corners } => {
                 Some(polygon_distance(p, corners))
@@ -1442,6 +1751,70 @@ pub fn shape_to_mesh(
             (samples, vertices)
         }
 
+        RecognizedShape::Ellipse {
+            center,
+            radius_x,
+            radius_y,
+            rotation,
+        } => {
+            const SEGMENTS: usize = 96;
+            let outline: Vec<Vec2> = (0..SEGMENTS)
+                .map(|i| {
+                    let t = i as f32 / SEGMENTS as f32 * 2.0 * PI;
+                    ellipse_point(*center, *radius_x, *radius_y, *rotation, t)
+                })
+                .collect();
+            closed_polygon_to_mesh(&outline, half_w, color)
+        }
+
+        RecognizedShape::Arrow { start, end, double } => {
+            let shaft_len = (*end - *start).length();
+            let dir = (*end - *start).normalize_or_zero();
+            let end_head = arrow_head(*end, dir, half_w, shaft_len);
+            let start_head = arrow_head(*start, -dir, half_w, shaft_len);
+            // Der Schaft endet an der Basis der Spitze(n), damit diese spitz bleiben
+            let line_start = if *double { start_head.0 } else { *start };
+            let line_end = end_head.0;
+
+            let norm = Vec2::new(-dir.y, dir.x) * half_w;
+            let mut vertices = vec![
+                InkVertex::new(line_start.x + norm.x, line_start.y + norm.y, color),
+                InkVertex::new(line_start.x - norm.x, line_start.y - norm.y, color),
+                InkVertex::new(line_end.x + norm.x, line_end.y + norm.y, color),
+                InkVertex::new(line_end.x - norm.x, line_end.y - norm.y, color),
+            ];
+            let mut heads = vec![(*end, end_head)];
+            if *double {
+                heads.push((*start, start_head));
+            }
+            for (tip, (_, left, right)) in &heads {
+                let last_v = *vertices.last().unwrap();
+                let tip_v = InkVertex::new(tip.x, tip.y, color);
+                vertices.push(last_v);
+                vertices.push(tip_v);
+                vertices.push(tip_v);
+                vertices.push(InkVertex::new(left.x, left.y, color));
+                vertices.push(InkVertex::new(right.x, right.y, color));
+            }
+
+            // Abtastpunkte als zusammenhängender Linienzug: (Spitze am Start,) Schaft, Spitze am Ende
+            let sample = |p: Vec2| StylusSample {
+                position: p,
+                pressure: 0.5,
+                timestamp: 0.0,
+            };
+            let mut samples = Vec::new();
+            if *double {
+                let (_, l, r) = start_head;
+                samples.extend([*start, l, r, *start].map(sample));
+            }
+            let steps = ((shaft_len / 5.0).ceil() as usize).max(2);
+            samples.extend((0..=steps).map(|i| sample(start.lerp(*end, i as f32 / steps as f32))));
+            let (_, l, r) = end_head;
+            samples.extend([l, r, *end].map(sample));
+            (samples, vertices)
+        }
+
         RecognizedShape::Circle { center, radius } => {
             let segments = 64;
             let r_in = (radius - half_w).max(0.1);
@@ -1539,11 +1912,20 @@ pub fn shape_to_mesh(
             let mut vertices = Vec::new();
             let mut samples = Vec::new();
 
-            // 1. Y-Achse (von Pfeilspitze oben zum Ursprung)
+            // Achsen enden bei Pfeilen an der Basis der Spitze, sonst überdeckt das Linienband
+            // die Spitze und sie wirkt stumpf
             let y_dir = (*y_axis_end - *origin).normalize_or_zero();
-            let y_norm = Vec2::new(-y_dir.y, y_dir.x) * half_w;
+            let x_dir = (*x_axis_end - *origin).normalize_or_zero();
+            let y_arrow = arrow_head(*y_axis_end, y_dir, half_w, (*y_axis_end - *origin).length());
+            let x_arrow = arrow_head(*x_axis_end, x_dir, half_w, (*x_axis_end - *origin).length());
+            let (y_line_end, x_line_end) = if *with_arrows {
+                (y_arrow.0, x_arrow.0)
+            } else {
+                (*y_axis_end, *x_axis_end)
+            };
 
-            // Y-Linienband
+            // 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,
                 origin.y + y_norm.y,
@@ -1555,26 +1937,24 @@ pub fn shape_to_mesh(
                 color,
             ));
             vertices.push(InkVertex::new(
-                y_axis_end.x + y_norm.x,
-                y_axis_end.y + y_norm.y,
+                y_line_end.x + y_norm.x,
+                y_line_end.y + y_norm.y,
                 color,
             ));
             vertices.push(InkVertex::new(
-                y_axis_end.x - y_norm.x,
-                y_axis_end.y - y_norm.y,
+                y_line_end.x - y_norm.x,
+                y_line_end.y - y_norm.y,
                 color,
             ));
 
-            // Degenerate Dreiecke für Übergang zur X-Achse
-            let x_dir = (*x_axis_end - *origin).normalize_or_zero();
+            // 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);
             vertices.push(last_v);
             vertices.push(next_v);
 
-            // 2. X-Linienband
+            // 2. X-Achse
             vertices.push(next_v);
             vertices.push(InkVertex::new(
                 origin.x - x_norm.x,
@@ -1582,48 +1962,27 @@ pub fn shape_to_mesh(
                 color,
             ));
             vertices.push(InkVertex::new(
-                x_axis_end.x + x_norm.x,
-                x_axis_end.y + x_norm.y,
+                x_line_end.x + x_norm.x,
+                x_line_end.y + x_norm.y,
                 color,
             ));
             vertices.push(InkVertex::new(
-                x_axis_end.x - x_norm.x,
-                x_axis_end.y - x_norm.y,
+                x_line_end.x - x_norm.x,
+                x_line_end.y - x_norm.y,
                 color,
             ));
 
-            // 3. Optionale Pfeilspitzen
+            // 3. Optionale Pfeilspitzen (je ein Dreieck, über degenerierte Dreiecke angehängt)
             if *with_arrows {
-                let arrow_len = (half_w * 5.0).max(18.0);
-                let arrow_w = (half_w * 3.5).max(12.0);
-
-                // Pfeilspitze Y
-                let y_base = *y_axis_end - y_dir * arrow_len;
-                let y_left = y_base + Vec2::new(-y_dir.y, y_dir.x) * arrow_w;
-                let y_right = y_base - Vec2::new(-y_dir.y, y_dir.x) * arrow_w;
-
-                let last_v = *vertices.last().unwrap();
-                let tip_v = InkVertex::new(y_axis_end.x, y_axis_end.y, color);
-                vertices.push(last_v);
-                vertices.push(tip_v);
-
-                vertices.push(tip_v);
-                vertices.push(InkVertex::new(y_left.x, y_left.y, color));
-                vertices.push(InkVertex::new(y_right.x, y_right.y, color));
-
-                // Pfeilspitze X
-                let x_base = *x_axis_end - x_dir * arrow_len;
-                let x_left = x_base + Vec2::new(-x_dir.y, x_dir.x) * arrow_w;
-                let x_right = x_base - Vec2::new(-x_dir.y, x_dir.x) * arrow_w;
-
-                let last_v = *vertices.last().unwrap();
-                let tip_x = InkVertex::new(x_axis_end.x, x_axis_end.y, color);
-                vertices.push(last_v);
-                vertices.push(tip_x);
-
-                vertices.push(tip_x);
-                vertices.push(InkVertex::new(x_left.x, x_left.y, color));
-                vertices.push(InkVertex::new(x_right.x, x_right.y, color));
+                for (tip, (_, left, right)) in [(*y_axis_end, y_arrow), (*x_axis_end, x_arrow)] {
+                    let last_v = *vertices.last().unwrap();
+                    let tip_v = InkVertex::new(tip.x, tip.y, color);
+                    vertices.push(last_v);
+                    vertices.push(tip_v);
+                    vertices.push(tip_v);
+                    vertices.push(InkVertex::new(left.x, left.y, color));
+                    vertices.push(InkVertex::new(right.x, right.y, color));
+                }
             }
 
             // Abtastpunkte
@@ -2084,6 +2443,9 @@ mod tests {
         match shape {
             Some(RecognizedShape::Line { .. }) => "Linie",
             Some(RecognizedShape::Circle { .. }) => "Kreis",
+            Some(RecognizedShape::Ellipse { .. }) => "Ellipse",
+            Some(RecognizedShape::Arrow { double: false, .. }) => "Pfeil",
+            Some(RecognizedShape::Arrow { double: true, .. }) => "Doppelpfeil",
             Some(RecognizedShape::Rectangle { .. }) => "Rechteck",
             Some(RecognizedShape::Triangle { .. }) => "Dreieck",
             Some(RecognizedShape::Rhombus { .. }) => "Raute",
@@ -2288,6 +2650,57 @@ mod tests {
                 add("Oval 0.6".to_string(), kind(&detect_shape(&pts)));
             }
         }
+        // Pfeile in einem Zug: Schaft, dann Widerhaken links, zurück zur Spitze, Widerhaken rechts
+        for &len in &[200.0_f32, 400.0, 700.0] {
+            for &angle in &[0.0_f32, 30.0, 135.0, 260.0] {
+                for &barb_deg in &[25.0_f32, 40.0, 55.0] {
+                    for &seed in &seeds[..3] {
+                        let dir = Vec2::from_angle(angle.to_radians());
+                        let tail = c - dir * len * 0.5;
+                        let tip = c + dir * len * 0.5;
+                        let barb = |side: f32| {
+                            tip + Vec2::from_angle(side * barb_deg.to_radians()).rotate(-dir)
+                                * len
+                                * 0.15
+                        };
+                        let single = [tail, tip, barb(1.0), tip, barb(-1.0)];
+                        add(
+                            format!("Pfeil {barb_deg}°"),
+                            kind(&detect_shape(&freehand(&single, false, seed))),
+                        );
+                        let barb_tail = |side: f32| {
+                            tail + Vec2::from_angle(side * barb_deg.to_radians()).rotate(dir)
+                                * len
+                                * 0.15
+                        };
+                        let double = [
+                            barb_tail(1.0),
+                            tail,
+                            barb_tail(-1.0),
+                            tail,
+                            tip,
+                            barb(1.0),
+                            tip,
+                            barb(-1.0),
+                        ];
+                        add(
+                            format!("Doppelpfeil {barb_deg}°"),
+                            kind(&detect_shape(&freehand(&double, false, seed))),
+                        );
+                    }
+                }
+                // Gerade bleibt Gerade
+                let dir = Vec2::from_angle(angle.to_radians());
+                add(
+                    "Linie".to_string(),
+                    kind(&detect_shape(&freehand(
+                        &[c - dir * len * 0.5, c + dir * len * 0.5],
+                        false,
+                        0.3,
+                    ))),
+                );
+            }
+        }
         // Freiformen, die KEIN Rechteck/Kreis werden sollen
         for &seed in &seeds {
             let star: Vec<Vec2> = (0..10)
@@ -2349,8 +2762,19 @@ mod tests {
         for group in stats.keys() {
             let expected = if group.starts_with("Rechteck") {
                 Some("Rechteck")
-            } else if group == "Kreis/Ellipse 1" || group == "Kreis/Ellipse 0.8" {
+            } else if group == "Kreis/Ellipse 1" {
                 Some("Kreis")
+            } else if group == "Kreis/Ellipse 0.8"
+                || group == "Kreis/Ellipse 0.6"
+                || group == "Oval 0.6"
+            {
+                Some("Ellipse")
+            } else if group.starts_with("Pfeil") {
+                Some("Pfeil")
+            } else if group.starts_with("Doppelpfeil") {
+                Some("Doppelpfeil")
+            } else if group.starts_with("Linie") {
+                Some("Linie")
             } else if group == "Dreieck" {
                 Some("Dreieck")
             } else if group.starts_with("Vieleck") {
@@ -2364,7 +2788,7 @@ mod tests {
             if let Some(kind) = expected {
                 let (hits, total) = count(group, kind);
                 // Achteck/Sechseck und leicht ovale Kreise sind von Hand kaum zu unterscheiden
-                let min_share = if group.starts_with("Vieleck") || group == "Kreis/Ellipse 0.8" {
+                let min_share = if group.starts_with("Vieleck") {
                     0.9
                 } else {
                     1.0
@@ -2400,4 +2824,145 @@ mod tests {
             })
             .collect()
     }
+
+    #[test]
+    fn test_arrow_head_is_slender_and_axes_end_at_its_base() {
+        // Spitze schlank (~40° Öffnung) und breiter als die Linie
+        let (base, left, right) = arrow_head(Vec2::new(0.0, 0.0), Vec2::new(0.0, -1.0), 2.5, 500.0);
+        let len = base.length();
+        let half_width = (left - base).length();
+        let opening = 2.0 * (half_width / len).atan().to_degrees();
+        assert!(
+            (35.0..=45.0).contains(&opening),
+            "Öffnungswinkel {opening}°"
+        );
+        assert!(
+            half_width > 2.5 * 2.0,
+            "Spitze muss breiter als die Linie sein"
+        );
+        assert!(((left + right) * 0.5 - base).length() < 1e-4);
+        assert!(len >= 40.0, "Spitze mindestens 4 mm lang: {len}");
+        // Bei kurzen Linien höchstens ein Fünftel der Linie
+        let (short_base, ..) = arrow_head(Vec2::ZERO, Vec2::new(1.0, 0.0), 2.5, 100.0);
+        assert!((short_base.length() - 20.0).abs() < 1e-3);
+
+        // Kein Vertex des Linienbands ragt über die Basis hinaus in die Spitze hinein
+        let origin = Vec2::new(100.0, 300.0);
+        let y_end = Vec2::new(100.0, 100.0);
+        let x_end = Vec2::new(300.0, 300.0);
+        let shape = RecognizedShape::CoordinateSystem {
+            origin,
+            x_axis_end: x_end,
+            y_axis_end: y_end,
+            with_arrows: true,
+        };
+        let (_, vertices) = shape_to_mesh(&shape, 5.0, [0.0, 0.0, 0.0, 1.0]);
+        let (y_base, ..) = arrow_head(y_end, Vec2::new(0.0, -1.0), 2.5, 200.0);
+        let (x_base, ..) = arrow_head(x_end, Vec2::new(1.0, 0.0), 2.5, 200.0);
+        for v in &vertices {
+            let p = Vec2::new(v.position[0], v.position[1]);
+            let is_tip = (p - y_end).length() < 1e-3 || (p - x_end).length() < 1e-3;
+            assert!(
+                is_tip || p.y >= y_base.y - 1e-3,
+                "Y-Achse ragt in die Spitze: {p:?}"
+            );
+            assert!(
+                is_tip || p.x <= x_base.x + 1e-3,
+                "X-Achse ragt in die Spitze: {p:?}"
+            );
+        }
+    }
+
+    #[test]
+    fn test_arrow_negative_cases() {
+        let c = Vec2::new(1000.0, 1400.0);
+        // T-Ende: Querbalken im rechten Winkel ist kein Pfeil
+        let t_shape = [
+            c - Vec2::new(300.0, 0.0),
+            c + Vec2::new(300.0, 0.0),
+            c + Vec2::new(300.0, 60.0),
+            c + Vec2::new(300.0, -60.0),
+        ];
+        assert_ne!(
+            kind(&detect_shape(&freehand(&t_shape, false, 0.4))),
+            "Pfeil"
+        );
+        // Zickzack ist kein Pfeil
+        let zigzag: Vec<Vec2> = (0..8)
+            .map(|i| c + Vec2::new(i as f32 * 80.0, if i % 2 == 0 { 0.0 } else { 60.0 }))
+            .collect();
+        let got = kind(&detect_shape(&freehand(&zigzag, false, 0.4)));
+        assert!(
+            got != "Pfeil" && got != "Doppelpfeil",
+            "Zickzack erkannt als {got}"
+        );
+    }
+
+    #[test]
+    fn test_ellipse_and_arrow_transforms_and_mesh() {
+        let mut ellipse = RecognizedShape::Ellipse {
+            center: Vec2::new(500.0, 500.0),
+            radius_x: 200.0,
+            radius_y: 100.0,
+            rotation: 0.0,
+        };
+        ellipse.translate(Vec2::new(10.0, 20.0));
+        ellipse.rotate(Vec2::new(510.0, 520.0), std::f32::consts::FRAC_PI_2);
+        ellipse.scale(Vec2::new(510.0, 520.0), Vec2::new(2.0, 1.0));
+        if let RecognizedShape::Ellipse {
+            center,
+            radius_x,
+            radius_y,
+            rotation,
+        } = ellipse
+        {
+            assert!((center - Vec2::new(510.0, 520.0)).length() < 1e-3);
+            // Nach 90°-Drehung liegt die lange Achse senkrecht; die x-Skalierung trifft die kurze
+            assert!((radius_x - 200.0).abs() < 1e-2, "radius_x {radius_x}");
+            assert!((radius_y - 200.0).abs() < 1e-2, "radius_y {radius_y}");
+            assert!((rotation.abs() - std::f32::consts::FRAC_PI_2).abs() < 1e-3);
+        } else {
+            panic!("Ellipse erwartet");
+        }
+
+        // Ellipsen-Mesh: alle Abtastpunkte liegen auf der Ellipse
+        let shape = RecognizedShape::Ellipse {
+            center: Vec2::new(0.0, 0.0),
+            radius_x: 300.0,
+            radius_y: 120.0,
+            rotation: 0.5,
+        };
+        let (samples, vertices) = shape_to_mesh(&shape, 5.0, [0.0; 4]);
+        assert!(!vertices.is_empty());
+        let pts: Vec<Vec2> = samples.iter().map(|s| s.position).collect();
+        assert!(contour_rms(&pts, &shape).unwrap() < 1.0);
+
+        // Pfeil: Verschieben/Skalieren bewegt beide Enden, Mesh hat Spitze(n)
+        let mut arrow = RecognizedShape::Arrow {
+            start: Vec2::new(0.0, 0.0),
+            end: Vec2::new(100.0, 0.0),
+            double: true,
+        };
+        arrow.translate(Vec2::new(5.0, 5.0));
+        arrow.scale(Vec2::new(5.0, 5.0), Vec2::new(2.0, 2.0));
+        assert_eq!(
+            arrow,
+            RecognizedShape::Arrow {
+                start: Vec2::new(5.0, 5.0),
+                end: Vec2::new(205.0, 5.0),
+                double: true
+            }
+        );
+        let (_, single_v) = shape_to_mesh(
+            &RecognizedShape::Arrow {
+                start: Vec2::ZERO,
+                end: Vec2::new(300.0, 0.0),
+                double: false,
+            },
+            5.0,
+            [0.0; 4],
+        );
+        let (_, double_v) = shape_to_mesh(&arrow, 5.0, [0.0; 4]);
+        assert_eq!(double_v.len(), single_v.len() + 5, "zweite Spitze fehlt");
+    }
 }

src/lib.rs

@@ -8,6 +8,7 @@ pub mod export;
 pub mod filter;
 pub mod geometry;
 pub mod history;
+pub mod platform;
 pub mod selection;
 pub mod settings;
 pub mod spline;

src/main.rs

@@ -9,8 +9,9 @@ use winit::{
     event::{
         ElementState, Event, KeyEvent, MouseButton, MouseScrollDelta, TouchPhase, WindowEvent,
     },
-    event_loop::{ControlFlow, EventLoop},
+    event_loop::{ControlFlow, EventLoopBuilder},
     keyboard::{Key, ModifiersState, NamedKey},
+    platform::{wayland::EventLoopBuilderExtWayland, x11::EventLoopBuilderExtX11},
     window::{Window, WindowBuilder},
 };
 
@@ -20,6 +21,7 @@ use ink_notes::canvas::CanvasState;
 use ink_notes::document::{Notebook, PageBackground};
 use ink_notes::export::{self, export_notebook_to_pdf, ExportStrategy};
 use ink_notes::geometry::{self, RecognizedShape};
+use ink_notes::platform::{self, DisplayBackend};
 use ink_notes::selection::{
     render_selection_overlay, DragMode, SelectionHandleHit, SelectionState,
 };
@@ -29,6 +31,19 @@ use ink_notes::ui::{self, ActiveTool, UiAction, UiState};
 use ink_notes::updater::UpdaterController;
 
 /// Aktualisiert den Fenstertitel als minimales On-Screen-Display (OSD) inklusive Autosave-Status.
+/// Speichert die UI-Einstellungen; ein Fehler wird gemeldet, bricht aber nichts ab.
+fn save_ui_settings(settings: &UiSettings, path: Option<&std::path::Path>, ui_state: &mut UiState) {
+    if let Some(path) = path {
+        if let Err(err) = settings.save_to(path) {
+            eprintln!(
+                "[Einstellungen] Konnte '{}' nicht speichern: {err}",
+                path.display()
+            );
+            ui_state.set_export_message(format!("Einstellung nicht gespeichert: {err}"));
+        }
+    }
+}
+
 fn update_window_title(
     window: &Window,
     notebook: &Notebook,
@@ -119,7 +134,8 @@ fn commit_stroke_to_notebook(
         canvas.finish_stroke(new_id)
     };
 
-    if let Some(stroke) = stroke_opt {
+    if let Some(mut stroke) = stroke_opt {
+        stroke.tool = ui_state.active_tool.stroke_tool(stroke.shape.is_some());
         let page = notebook.current_page_mut();
         page.add_stroke(stroke);
         canvas.sync_page(page);
@@ -137,7 +153,20 @@ fn commit_stroke_to_notebook(
 }
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let event_loop = EventLoop::new()?;
+    // Anzeigesystem wählen: Unter WSL (WSLg) bricht Wayland ab, X11 (Xwayland) läuft stabil
+    let mut event_loop_builder = EventLoopBuilder::new();
+    match platform::display_backend_from_env() {
+        DisplayBackend::X11 => {
+            eprintln!("[Anzeige] Verwende X11 (unter WSL Standard; übersteuerbar mit INK_NOTES_DISPLAY=wayland)");
+            event_loop_builder.with_x11();
+        }
+        DisplayBackend::Wayland => {
+            eprintln!("[Anzeige] Verwende Wayland (INK_NOTES_DISPLAY=wayland)");
+            event_loop_builder.with_wayland();
+        }
+        DisplayBackend::Automatic => {}
+    }
+    let event_loop = event_loop_builder.build()?;
     let window = Arc::new(
         WindowBuilder::new()
             .with_title("ink-notes (Latenzoptimiertes Linux-Inking)")
@@ -244,6 +273,9 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         .map(UiSettings::load_from)
         .unwrap_or_default();
     ui_state.sidebar_side = ui_settings.sidebar_side;
+    ui_state.paper_theme = ui_settings.paper_theme;
+    ui_state.adapt_ink_colors = ui_settings.adapt_ink_colors;
+    ui_state.pressure_curve = ui_settings.pressure_curve;
     ui_state.current_notebook_id = manifest.id.clone();
     ui_state.document_title = manifest.title.clone();
     ui_state.available_notebooks = available_notebooks;
@@ -275,6 +307,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     canvas.sync_page(notebook.current_page_mut());
     canvas.set_stroke_color(ui_state.pen_color);
     canvas.set_stroke_width_mm(ui_state.pen_stroke_width_mm);
+    canvas.set_paper_theme(ui_state.paper_theme, ui_state.adapt_ink_colors);
 
     let start_time = Instant::now();
     let mut cursor_screen_pos = (0.0_f32, 0.0_f32);
@@ -456,7 +489,8 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                         cursor_screen_pos = (sx, sy);
 
                                         if let Some(p) = pose.pressure.get() {
-                                            current_pressure = p;
+                                            current_pressure = ui_state.pressure_curve.apply(p);
+                                            ui_state.last_raw_pressure = Some(p);
                                         }
 
                                         // Stiftbewegung an egui weitergeben (Hover, Schieberegler ziehen),
@@ -483,8 +517,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                                 let removed = page.erase_at(
                                                     page_pt,
                                                     eraser_radius,
-                                                    stroke_max_radius,
-                                                );
+                                                    stroke_max_radius, ui_state.eraser_mode);
                                                 if !removed.is_empty() {
                                                     canvas.sync_page(page);
                                                     autosave.mark_dirty(&notebook, &mut manifest);
@@ -551,8 +584,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                                 let removed = page.erase_at(
                                                     page_pt,
                                                     eraser_radius,
-                                                    stroke_max_radius,
-                                                );
+                                                    stroke_max_radius, ui_state.eraser_mode);
                                                 if !removed.is_empty() {
                                                     canvas.sync_page(page);
                                                     autosave.mark_dirty(&notebook, &mut manifest);
@@ -1172,7 +1204,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                     let (sx, sy) = cursor_screen_pos;
                                     if let Some(page_pt) = canvas.screen_to_page(sx, sy) {
                                         let page = notebook.current_page_mut();
-                                        let removed = page.erase_at(page_pt, eraser_radius, stroke_max_radius);
+                                        let removed = page.erase_at(page_pt, eraser_radius, stroke_max_radius, ui_state.eraser_mode);
                                         if !removed.is_empty() {
                                             canvas.sync_page(page);
                                             autosave.mark_dirty(&notebook, &mut manifest);
@@ -1440,7 +1472,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                             } else if is_erasing {
                                 if let Some(page_pt) = canvas.screen_to_page(sx, sy) {
                                     let page = notebook.current_page_mut();
-                                    let removed = page.erase_at(page_pt, eraser_radius, stroke_max_radius);
+                                    let removed = page.erase_at(page_pt, eraser_radius, stroke_max_radius, ui_state.eraser_mode);
                                     if !removed.is_empty() {
                                         canvas.sync_page(page);
                                         autosave.mark_dirty(&notebook, &mut manifest);
@@ -1501,15 +1533,18 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                         let now = start_time.elapsed().as_secs_f64();
                         let tx = touch.location.x as f32;
                         let ty = touch.location.y as f32;
-                        let pressure = match touch.force {
-                            Some(winit::event::Force::Normalized(f)) => f as f32,
+                        let raw_pressure = match touch.force {
+                            Some(winit::event::Force::Normalized(f)) => Some(f as f32),
                             Some(winit::event::Force::Calibrated {
                                 force,
                                 max_possible_force,
                                 ..
-                            }) => (force / max_possible_force).clamp(0.0, 1.0) as f32,
-                            None => 0.5,
+                            }) => Some((force / max_possible_force).clamp(0.0, 1.0) as f32),
+                            None => None,
                         };
+                        // Druckkurve nur bei echtem Druck; Finger ohne Druck zeichnen mittelstark
+                        let pressure =
+                            raw_pressure.map_or(0.5, |p| ui_state.pressure_curve.apply(p));
 
                         let is_eraser_action = ui_state.active_tool == ActiveTool::Eraser;
 
@@ -1576,7 +1611,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                             is_erasing = true;
                                             if let Some(page_pt) = canvas.screen_to_page(tx, ty) {
                                                 let page = notebook.current_page_mut();
-                                                let removed = page.erase_at(page_pt, eraser_radius, stroke_max_radius);
+                                                let removed = page.erase_at(page_pt, eraser_radius, stroke_max_radius, ui_state.eraser_mode);
                                                 if !removed.is_empty() {
                                                     canvas.sync_page(page);
                                                     autosave.mark_dirty(&notebook, &mut manifest);
@@ -1717,7 +1752,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                     } else if is_erasing {
                                         if let Some(page_pt) = canvas.screen_to_page(tx, ty) {
                                             let page = notebook.current_page_mut();
-                                            let removed = page.erase_at(page_pt, eraser_radius, stroke_max_radius);
+                                            let removed = page.erase_at(page_pt, eraser_radius, stroke_max_radius, ui_state.eraser_mode);
                                             if !removed.is_empty() {
                                                 canvas.sync_page(page);
                                                 autosave.mark_dirty(&notebook, &mut manifest);
@@ -2395,14 +2430,20 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                 }
                                 UiAction::SetSidebarSide(side) => {
                                     ui_settings.sidebar_side = side;
-                                    if let Some(path) = ui_settings_path.as_deref() {
-                                        if let Err(err) = ui_settings.save_to(path) {
-                                            eprintln!("[Einstellungen] Konnte '{}' nicht speichern: {err}", path.display());
-                                            ui_state.set_export_message(format!("Einstellung nicht gespeichert: {err}"));
-                                        }
-                                    }
+                                    save_ui_settings(&ui_settings, ui_settings_path.as_deref(), &mut ui_state);
                                     window.request_redraw();
                                 }
+                                UiAction::SetPaperTheme { theme, adapt_ink } => {
+                                    canvas.set_paper_theme(theme, adapt_ink);
+                                    ui_settings.paper_theme = theme;
+                                    ui_settings.adapt_ink_colors = adapt_ink;
+                                    save_ui_settings(&ui_settings, ui_settings_path.as_deref(), &mut ui_state);
+                                    window.request_redraw();
+                                }
+                                UiAction::SavePressureCurve(curve) => {
+                                    ui_settings.pressure_curve = curve;
+                                    save_ui_settings(&ui_settings, ui_settings_path.as_deref(), &mut ui_state);
+                                }
                                 UiAction::ForceExit => {
                                     println!("[Shutdown] Beenden erzwungen trotz ungespeicherter Änderungen.");
                                     target.exit();

src/platform.rs

@@ -0,0 +1,96 @@
+//! Erkennung der Laufzeitumgebung und Wahl des Anzeigesystems (X11 oder Wayland).
+//!
+//! Unter WSL (WSLg) trennt der Wayland-Compositor die Verbindung, sobald die App ein Bild
+//! über Vulkan übergibt ("Connection reset by peer"). Über X11 (Xwayland) läuft sie stabil,
+//! daher wird unter WSL standardmäßig X11 verwendet. `INK_NOTES_DISPLAY=x11|wayland`
+//! übersteuert die Wahl.
+
+/// Anzeigesystem, mit dem die Ereignisschleife erzeugt wird.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum DisplayBackend {
+    /// Automatische Wahl von winit (Wayland, falls verfügbar, sonst X11)
+    Automatic,
+    X11,
+    Wayland,
+}
+
+/// Wählt das Anzeigesystem.
+///
+/// - `override_value`: Inhalt von `INK_NOTES_DISPLAY` (`x11` oder `wayland`, sonst ignoriert)
+/// - `is_wsl`: läuft unter WSL
+/// - `has_x11_display`: `DISPLAY` ist gesetzt (X11/Xwayland erreichbar)
+pub fn choose_display_backend(
+    override_value: Option<&str>,
+    is_wsl: bool,
+    has_x11_display: bool,
+) -> DisplayBackend {
+    match override_value
+        .map(|v| v.trim().to_ascii_lowercase())
+        .as_deref()
+    {
+        Some("x11") => return DisplayBackend::X11,
+        Some("wayland") => return DisplayBackend::Wayland,
+        _ => {}
+    }
+    if is_wsl && has_x11_display {
+        DisplayBackend::X11
+    } else {
+        DisplayBackend::Automatic
+    }
+}
+
+/// Läuft das Programm unter WSL (Windows-Subsystem für Linux)?
+pub fn is_wsl() -> bool {
+    if std::env::var_os("WSL_DISTRO_NAME").is_some() || std::env::var_os("WSL_INTEROP").is_some() {
+        return true;
+    }
+    std::fs::read_to_string("/proc/sys/kernel/osrelease")
+        .map(|release| release.to_ascii_lowercase().contains("microsoft"))
+        .unwrap_or(false)
+}
+
+/// Wahl anhand der aktuellen Umgebung.
+pub fn display_backend_from_env() -> DisplayBackend {
+    choose_display_backend(
+        std::env::var("INK_NOTES_DISPLAY").ok().as_deref(),
+        is_wsl(),
+        std::env::var_os("DISPLAY").is_some_and(|d| !d.is_empty()),
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_choose_display_backend() {
+        // WSL mit X11-Display: X11 (Wayland unter WSLg bricht ab)
+        assert_eq!(
+            choose_display_backend(None, true, true),
+            DisplayBackend::X11
+        );
+        // WSL ohne X11-Display: winit entscheiden lassen
+        assert_eq!(
+            choose_display_backend(None, true, false),
+            DisplayBackend::Automatic
+        );
+        // Natives Linux: winit entscheiden lassen
+        assert_eq!(
+            choose_display_backend(None, false, true),
+            DisplayBackend::Automatic
+        );
+        // Übersteuerung
+        assert_eq!(
+            choose_display_backend(Some("wayland"), true, true),
+            DisplayBackend::Wayland
+        );
+        assert_eq!(
+            choose_display_backend(Some(" X11 "), false, true),
+            DisplayBackend::X11
+        );
+        assert_eq!(
+            choose_display_backend(Some("quatsch"), true, true),
+            DisplayBackend::X11
+        );
+    }
+}

src/settings.rs

@@ -6,6 +6,7 @@ use std::path::{Path, PathBuf};
 
 use serde::{Deserialize, Serialize};
 
+use crate::background::PaperTheme;
 use crate::storage::{self, StorageError};
 
 /// Fensterseite, an der die Werkzeugleiste angedockt ist.
@@ -18,11 +19,82 @@ pub enum SidebarSide {
     Right,
 }
 
+/// Druckkennlinie des Stifts: passt die sehr unterschiedlichen Druckbereiche verschiedener
+/// Digitizer (Wacom EMR, MPP, …) an das Schreibgefühl an.
+#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
+#[serde(default)]
+pub struct PressureCurve {
+    /// Exponent der Kennlinie: < 1 weich (schon leichter Druck ergibt kräftige Linien),
+    /// > 1 hart (erst fester Druck ergibt kräftige Linien)
+    pub exponent: f32,
+    /// Rohdruck unterhalb dieser Schwelle zählt als kein Druck (dünnste Linie);
+    /// unterdrückt das Grundrauschen empfindlicher Stifte
+    pub threshold: f32,
+}
+
+impl PressureCurve {
+    pub const EXPONENT_RANGE: std::ops::RangeInclusive<f32> = 0.3..=3.0;
+    pub const THRESHOLD_RANGE: std::ops::RangeInclusive<f32> = 0.0..=0.5;
+
+    /// Rechnet den Rohdruck des Stifts (0–1) in den Druck für die Strichbreite um.
+    pub fn apply(&self, raw: f32) -> f32 {
+        let curve = self.sanitized();
+        if !raw.is_finite() {
+            return 0.0;
+        }
+        let normalized = ((raw - curve.threshold) / (1.0 - curve.threshold)).clamp(0.0, 1.0);
+        normalized.powf(curve.exponent)
+    }
+
+    /// Begrenzt Werte aus einer (evtl. von Hand bearbeiteten) Einstellungsdatei auf den
+    /// gültigen Bereich.
+    pub fn sanitized(&self) -> Self {
+        let default = Self::default();
+        let clamp = |v: f32, range: &std::ops::RangeInclusive<f32>, fallback: f32| {
+            if v.is_finite() {
+                v.clamp(*range.start(), *range.end())
+            } else {
+                fallback
+            }
+        };
+        Self {
+            exponent: clamp(self.exponent, &Self::EXPONENT_RANGE, default.exponent),
+            threshold: clamp(self.threshold, &Self::THRESHOLD_RANGE, default.threshold),
+        }
+    }
+}
+
+impl Default for PressureCurve {
+    fn default() -> Self {
+        Self {
+            exponent: 1.0,
+            threshold: 0.0,
+        }
+    }
+}
+
 /// Benutzereinstellungen der Oberfläche.
-#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[serde(default)]
 pub struct UiSettings {
     pub sidebar_side: SidebarSide,
+    /// Papierfarbe der Anzeige
+    pub paper_theme: PaperTheme,
+    /// Dunkle Stiftfarben auf dunklem Papier aufhellen
+    pub adapt_ink_colors: bool,
+    /// Druckkennlinie des Stifts
+    pub pressure_curve: PressureCurve,
+}
+
+impl Default for UiSettings {
+    fn default() -> Self {
+        Self {
+            sidebar_side: SidebarSide::default(),
+            paper_theme: PaperTheme::default(),
+            adapt_ink_colors: true,
+            pressure_curve: PressureCurve::default(),
+        }
+    }
 }
 
 impl UiSettings {
@@ -37,7 +109,7 @@ impl UiSettings {
 
     /// Lädt die Einstellungen; bei fehlender oder beschädigter Datei gelten Standardwerte.
     pub fn load_from(path: &Path) -> Self {
-        match std::fs::read_to_string(path) {
+        let mut settings: Self = match std::fs::read_to_string(path) {
             Ok(content) => serde_json::from_str(&content).unwrap_or_else(|e| {
                 eprintln!(
                     "[Einstellungen] '{}' ist ungültig ({e}), verwende Standardwerte.",
@@ -46,7 +118,9 @@ impl UiSettings {
                 Self::default()
             }),
             Err(_) => Self::default(),
-        }
+        };
+        settings.pressure_curve = settings.pressure_curve.sanitized();
+        settings
     }
 
     /// Speichert die Einstellungen atomar.
@@ -69,6 +143,12 @@ mod tests {
 
         let settings = UiSettings {
             sidebar_side: SidebarSide::Right,
+            paper_theme: PaperTheme::Black,
+            adapt_ink_colors: false,
+            pressure_curve: PressureCurve {
+                exponent: 1.8,
+                threshold: 0.1,
+            },
         };
         settings.save_to(&path).unwrap();
         assert_eq!(UiSettings::load_from(&path), settings);
@@ -81,4 +161,70 @@ mod tests {
         std::fs::write(&path, br#"{"zukunft": 1}"#).unwrap();
         assert_eq!(UiSettings::load_from(&path), UiSettings::default());
     }
+
+    #[test]
+    fn test_old_settings_file_keeps_new_defaults() {
+        // ui.json aus v0.3.x kennt nur die Seite der Werkzeugleiste
+        let dir = tempfile::tempdir().unwrap();
+        let path = dir.path().join("ui.json");
+        std::fs::write(&path, br#"{"sidebar_side": "Right"}"#).unwrap();
+        let settings = UiSettings::load_from(&path);
+        assert_eq!(settings.sidebar_side, SidebarSide::Right);
+        assert_eq!(settings.paper_theme, PaperTheme::White);
+        assert!(settings.adapt_ink_colors);
+        assert_eq!(settings.pressure_curve, PressureCurve::default());
+
+        // Unsinnige Werte aus einer von Hand bearbeiteten Datei werden begrenzt
+        std::fs::write(
+            &path,
+            br#"{"pressure_curve": {"exponent": 50.0, "threshold": -3.0}}"#,
+        )
+        .unwrap();
+        let curve = UiSettings::load_from(&path).pressure_curve;
+        assert_eq!(curve.exponent, 3.0);
+        assert_eq!(curve.threshold, 0.0);
+    }
+
+    #[test]
+    fn test_pressure_curve() {
+        // Standard: unverändert
+        let linear = PressureCurve::default();
+        for p in [0.0, 0.25, 0.5, 1.0] {
+            assert!((linear.apply(p) - p).abs() < 1e-6);
+        }
+        // Weich: halber Druck ergibt mehr als halbe Breite, hart: weniger
+        let soft = PressureCurve {
+            exponent: 0.5,
+            threshold: 0.0,
+        };
+        let hard = PressureCurve {
+            exponent: 2.0,
+            threshold: 0.0,
+        };
+        assert!(soft.apply(0.5) > 0.6);
+        assert!(hard.apply(0.5) < 0.3);
+        // Endpunkte bleiben fest
+        for curve in [soft, hard] {
+            assert_eq!(curve.apply(0.0), 0.0);
+            assert!((curve.apply(1.0) - 1.0).abs() < 1e-6);
+        }
+        // Schwelle: darunter kein Druck, darüber auf den vollen Bereich gestreckt
+        let gated = PressureCurve {
+            exponent: 1.0,
+            threshold: 0.2,
+        };
+        assert_eq!(gated.apply(0.15), 0.0);
+        assert!((gated.apply(0.6) - 0.5).abs() < 1e-6);
+        assert!((gated.apply(1.0) - 1.0).abs() < 1e-6);
+        // Monoton steigend
+        let mut last = -1.0;
+        for i in 0..=100 {
+            let v = hard.apply(i as f32 / 100.0);
+            assert!(v >= last);
+            last = v;
+        }
+        // Ungültige Eingaben ergeben nie NaN
+        assert_eq!(linear.apply(f32::NAN), 0.0);
+        assert_eq!(linear.apply(7.0), 1.0);
+    }
 }

src/shader.wgsl

@@ -14,6 +14,8 @@ struct VertexOutput {
 struct CameraUniforms {
     transform_scale: vec2<f32>,
     transform_offset: vec2<f32>,
+    // x: 1.0 = dunkle Tinte für dunkles Papier aufhellen (siehe `adapt_ink_color`)
+    ink_params: vec4<f32>,
 };
 
 @group(0) @binding(0)
@@ -32,3 +34,16 @@ fn vs_main(in: VertexInput) -> VertexOutput {
 fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
     return in.color;
 }
+
+// Striche: bei dunklem 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) {
+        return in.color;
+    }
+    let max_c = max(max(in.color.r, in.color.g), in.color.b);
+    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);
+}

src/storage.rs

@@ -117,15 +117,23 @@ impl StrokeData {
         };
         let mut stroke = Stroke::new(self.id, stylus_samples, vertices, self.color);
         stroke.shape = self.shape.clone();
-        stroke.tool = self.tool;
+        stroke.tool = crate::document::StrokeTool::resolve_stored(
+            self.tool,
+            self.color,
+            self.shape.is_some(),
+        );
         stroke.width = width;
         stroke.finalized = self.finalized;
         stroke
     }
 }
 
-/// Aktuelle Dateiformat-Version von ink-notes (Version 2: Stroke-Treue mit tool, width, finalized).
-pub const CURRENT_FORMAT_VERSION: u32 = 2;
+/// Aktuelle Dateiformat-Version von ink-notes.
+/// - Version 2: Stroke-Treue mit tool, width, finalized
+/// - Version 3: neue Formen (Ellipse, Pfeil). Ältere App-Versionen kennen sie nicht und würden
+///   betroffene Seiten für beschädigt halten; mit Version 3 lehnen sie das Notizbuch stattdessen
+///   sauber als „neuere Version“ ab.
+pub const CURRENT_FORMAT_VERSION: u32 = 3;
 
 /// Standardwert für ältere Dateien ohne explizite Formatversion (Legacy v0).
 pub fn legacy_format_version() -> u32 {
@@ -2233,4 +2241,79 @@ mod tests {
             "Seitendatei wurde überschrieben"
         );
     }
+
+    #[test]
+    fn test_new_shapes_round_trip_through_page_file() {
+        let temp_dir = tempfile::tempdir().unwrap();
+        let (mut notebook, mut manifest, dir) =
+            create_new_notebook(temp_dir.path(), "Neue Formen").unwrap();
+        let shapes = [
+            crate::geometry::RecognizedShape::Ellipse {
+                center: glam::Vec2::new(500.0, 600.0),
+                radius_x: 250.0,
+                radius_y: 120.0,
+                rotation: 0.3,
+            },
+            crate::geometry::RecognizedShape::Arrow {
+                start: glam::Vec2::new(100.0, 100.0),
+                end: glam::Vec2::new(700.0, 300.0),
+                double: true,
+            },
+        ];
+        for (i, shape) in shapes.iter().enumerate() {
+            notebook
+                .current_page_mut()
+                .strokes
+                .push(crate::geometry::shape_to_stroke(
+                    shape.clone(),
+                    i as u64 + 1,
+                    [0.0, 0.0, 0.0, 1.0],
+                    5.0,
+                ));
+        }
+        save_notebook(&dir, &notebook, &mut manifest).unwrap();
+        assert_eq!(
+            load_manifest(&dir).unwrap().format_version,
+            CURRENT_FORMAT_VERSION
+        );
+
+        let (reloaded, _) = load_notebook(&dir).unwrap();
+        let loaded: Vec<_> = reloaded
+            .current_page()
+            .strokes
+            .iter()
+            .map(|s| s.shape.clone())
+            .collect();
+        assert_eq!(loaded, shapes.iter().cloned().map(Some).collect::<Vec<_>>());
+    }
+
+    #[test]
+    fn test_stroke_tool_of_old_files_is_recovered() {
+        // Bis v0.3.7 wurde jeder Strich als "pen" gespeichert
+        let json = r#"{"id": 1, "color": [1.0, 0.95, 0.1, 0.35], "tool": "pen",
+            "samples": [{"x": 10.0, "y": 10.0, "p": 0.5, "t": 0.0},
+                        {"x": 90.0, "y": 10.0, "p": 0.5, "t": 0.1}]}"#;
+        let data: StrokeData = serde_json::from_str(json).unwrap();
+        let highlighter = data.to_stroke();
+        assert_eq!(highlighter.tool, crate::document::StrokeTool::Highlighter);
+
+        let mut pen = data.clone();
+        pen.color = [0.12, 0.12, 0.14, 1.0];
+        assert_eq!(pen.to_stroke().tool, crate::document::StrokeTool::Pen);
+
+        let mut shape = pen.clone();
+        shape.shape = Some(crate::geometry::RecognizedShape::Line {
+            start: glam::Vec2::new(10.0, 10.0),
+            end: glam::Vec2::new(90.0, 10.0),
+        });
+        assert_eq!(shape.to_stroke().tool, crate::document::StrokeTool::Shape);
+
+        // Ausdrücklich gespeicherte Werkzeuge bleiben unverändert
+        let mut explicit = data.clone();
+        explicit.tool = crate::document::StrokeTool::Shape;
+        assert_eq!(
+            explicit.to_stroke().tool,
+            crate::document::StrokeTool::Shape
+        );
+    }
 }

src/ui.rs

@@ -4,16 +4,19 @@
 //! (links oder rechts, umschaltbar):
 //! - Symbol-Knöpfe mit 40 px Kantenlänge (stift- und fingertauglich), Tooltips mit Kürzeln
 //! - Werkzeuge, Farben des aktiven Werkzeugs, Auswahl-Aktionen, Undo/Redo, Seitennavigation
-//! - Selten genutzte Funktionen (PDF, Hintergrund, Zoom, Touch-Modus, Leistenseite,
-//!   Updates, Speicherstatus) im ☰-Menü
+//! - Selten genutzte Funktionen (PDF, Hintergrund, Papierfarbe, Zoom, Touch-Modus,
+//!   Druckkurve, Leistenseite, Updates, Speicherstatus) im ☰-Menü
 //! - Popover (Stift/Marker/Menü) öffnen sich zur Blattseite hin
 //! - Hit-Testing für Event-Transparenz außerhalb der Leiste und der Popover
 
 use std::time::Instant;
 
 use crate::autosave::AutosaveStatus;
-use crate::document::{Notebook, Page, PageBackground, StrokeTool, PAGE_HEIGHT, PAGE_WIDTH};
-use crate::settings::SidebarSide;
+use crate::background::{adapt_ink_color, PaperTheme};
+use crate::document::{
+    EraserMode, Notebook, Page, PageBackground, StrokeTool, PAGE_HEIGHT, PAGE_WIDTH,
+};
+use crate::settings::{PressureCurve, SidebarSide};
 use crate::storage::NotebookSummary;
 
 /// Aktives Werkzeug für das Zeichnen oder Bearbeiten.
@@ -40,6 +43,15 @@ impl ActiveTool {
     pub fn is_drawing(&self) -> bool {
         matches!(self, ActiveTool::Pen | ActiveTool::Highlighter)
     }
+
+    /// Werkzeug, das ein mit diesem Werkzeug gezeichneter Strich erhält.
+    pub fn stroke_tool(&self, has_shape: bool) -> StrokeTool {
+        match self {
+            _ if has_shape => StrokeTool::Shape,
+            ActiveTool::Highlighter => StrokeTool::Highlighter,
+            _ => StrokeTool::Pen,
+        }
+    }
 }
 
 /// Farbvorgabe: RGBA-Farbe und Bezeichnung.
@@ -132,6 +144,13 @@ pub enum UiAction {
     UnlockCorruptedPage(u64),
     /// Werkzeugleiste an die andere Fensterseite verlegen (wird gespeichert)
     SetSidebarSide(SidebarSide),
+    /// Papierfarbe der Anzeige und Aufhellen dunkler Tinte (wird gespeichert)
+    SetPaperTheme {
+        theme: PaperTheme,
+        adapt_ink: bool,
+    },
+    /// Druckkurve speichern (gilt während des Ziehens bereits über `UiState::pressure_curve`)
+    SavePressureCurve(PressureCurve),
     // Beenden-Sicherheit bei Fehlschlag
     RetryShutdown,
     ExportRecoveryAndExit,
@@ -183,6 +202,16 @@ pub struct UiState {
     pub sidebar_side: SidebarSide,
     /// Öffnungszustand des ☰-Menüs
     pub is_more_menu_open: bool,
+    /// Welche Striche der Radierer entfernt (gilt auch für Stiftrückseite und Seitentaste)
+    pub eraser_mode: EraserMode,
+    /// Papierfarbe der Anzeige
+    pub paper_theme: PaperTheme,
+    /// Dunkle Tinte auf dunklem Papier aufhellen
+    pub adapt_ink_colors: bool,
+    /// Druckkurve des Stifts
+    pub pressure_curve: PressureCurve,
+    /// Zuletzt gemessener Rohdruck des Stifts (Anzeige in der Druckkurve)
+    pub last_raw_pressure: Option<f32>,
 }
 
 impl Default for UiState {
@@ -218,6 +247,11 @@ impl Default for UiState {
             shutdown_error: None,
             sidebar_side: SidebarSide::Left,
             is_more_menu_open: false,
+            eraser_mode: EraserMode::All,
+            paper_theme: PaperTheme::White,
+            adapt_ink_colors: true,
+            pressure_curve: PressureCurve::default(),
+            last_raw_pressure: None,
         }
     }
 }
@@ -706,14 +740,21 @@ const PAGE_TILE: egui::Vec2 = egui::vec2(66.0, 66.0 * PAGE_HEIGHT / PAGE_WIDTH +
 /// Höchstzahl gezeichneter Punkte pro Vorschau (dünnt volle Seiten aus).
 const THUMBNAIL_POINT_BUDGET: usize = 1500;
 
-/// Zeichenbefehle für die verkleinerte Vorschau einer Seite in `rect` (A4-Format).
-/// Striche werden als Linien gezeichnet und bei vielen Punkten gleichmäßig ausgedünnt.
-pub fn page_thumbnail_shapes(page: &Page, rect: egui::Rect) -> Vec<egui::Shape> {
+/// Zeichenbefehle für die verkleinerte Vorschau einer Seite in `rect` (A4-Format) in der
+/// Papierfarbe `paper`. Striche werden als Linien gezeichnet und bei vielen Punkten
+/// gleichmäßig ausgedünnt; `adapt_ink` hellt dunkle Tinte wie auf dem Blatt auf.
+pub fn page_thumbnail_shapes(
+    page: &Page,
+    rect: egui::Rect,
+    paper: PaperTheme,
+    adapt_ink: bool,
+) -> Vec<egui::Shape> {
     let mut shapes = vec![egui::Shape::rect_filled(
         rect,
         egui::Rounding::same(3.0),
-        egui::Color32::WHITE,
+        linear_color32(paper.paper_color()),
     )];
+    let adapt = adapt_ink && paper.is_dark();
     let scale = rect.width() / PAGE_WIDTH;
     let to_screen = |p: glam::Vec2| rect.min + egui::vec2(p.x * scale, p.y * scale);
 
@@ -721,7 +762,12 @@ pub fn page_thumbnail_shapes(page: &Page, rect: egui::Rect) -> Vec<egui::Shape>
     let step = total.div_ceil(THUMBNAIL_POINT_BUDGET).max(1);
 
     for stroke in &page.strokes {
-        let mut color = color32_from(stroke.color);
+        let ink = if adapt {
+            adapt_ink_color(stroke.color)
+        } else {
+            stroke.color
+        };
+        let mut color = color32_from(ink);
         if stroke.tool == StrokeTool::Highlighter {
             color = color.gamma_multiply(0.45);
         }
@@ -743,9 +789,15 @@ pub fn page_thumbnail_shapes(page: &Page, rect: egui::Rect) -> Vec<egui::Shape>
     shapes
 }
 
+/// Linearer Farbwert (wie auf der GPU) als egui-Farbe (sRGB).
+fn linear_color32(color: [f32; 4]) -> egui::Color32 {
+    egui::Rgba::from_rgba_unmultiplied(color[0], color[1], color[2], color[3]).into()
+}
+
 /// Kachel der Seitenauswahl: Vorschau der Seite mit Seitenzahl darunter.
 fn page_thumbnail(
     ui: &mut egui::Ui,
+    state: &UiState,
     page: &Page,
     number: usize,
     is_current: bool,
@@ -757,7 +809,12 @@ fn page_thumbnail(
             egui::vec2(PAGE_TILE.x, PAGE_TILE.x * PAGE_HEIGHT / PAGE_WIDTH),
         );
         let painter = ui.painter();
-        painter.extend(page_thumbnail_shapes(page, thumb));
+        painter.extend(page_thumbnail_shapes(
+            page,
+            thumb,
+            state.paper_theme,
+            state.adapt_ink_colors,
+        ));
         if !page.is_loaded {
             painter.text(
                 thumb.center(),
@@ -790,6 +847,112 @@ fn page_thumbnail(
     response.on_hover_text(format!("Seite {number}"))
 }
 
+/// Auswahlknopf für eine Papierfarbe: Farbmuster und Name.
+fn paper_theme_button(ui: &mut egui::Ui, theme: PaperTheme, selected: bool) -> egui::Response {
+    let response = ui.add_sized(
+        [115.0, 28.0],
+        egui::SelectableLabel::new(selected, format!("     {}", theme.label())),
+    );
+    let swatch = egui::Rect::from_center_size(
+        egui::pos2(response.rect.min.x + 14.0, response.rect.center().y),
+        egui::vec2(14.0, 14.0),
+    );
+    ui.painter().rect_filled(
+        swatch,
+        egui::Rounding::same(3.0),
+        linear_color32(theme.paper_color()),
+    );
+    ui.painter().rect_stroke(
+        swatch,
+        egui::Rounding::same(3.0),
+        egui::Stroke::new(1.0_f32, egui::Color32::from_gray(120)),
+    );
+    response
+}
+
+/// Schieberegler für die Druckkurve mit Vorschau der Kennlinie. Änderungen gelten sofort
+/// (`state.pressure_curve`); zurückgegeben wird die Kurve, sobald sie gespeichert werden soll
+/// (Regler losgelassen oder per Tastatur geändert).
+fn pressure_curve_editor(ui: &mut egui::Ui, state: &mut UiState) -> Option<PressureCurve> {
+    let mut save = false;
+    let mut track = |response: egui::Response| {
+        if response.drag_stopped() || (response.changed() && !response.dragged()) {
+            save = true;
+        }
+    };
+
+    ui.add_space(4.0);
+    ui.label("Druckkurve des Stifts");
+    let (graph, _) =
+        ui.allocate_exact_size(egui::vec2(ui.available_width(), 56.0), egui::Sense::hover());
+    let painter = ui.painter_at(graph);
+    painter.rect_filled(
+        graph,
+        egui::Rounding::same(4.0),
+        egui::Color32::from_black_alpha(90),
+    );
+    let to_screen = |raw: f32, out: f32| {
+        egui::pos2(
+            graph.min.x + 6.0 + raw * (graph.width() - 12.0),
+            graph.max.y - 6.0 - out * (graph.height() - 12.0),
+        )
+    };
+    painter.line_segment(
+        [to_screen(0.0, 0.0), to_screen(1.0, 1.0)],
+        egui::Stroke::new(1.0_f32, egui::Color32::from_white_alpha(40)),
+    );
+    let curve = state.pressure_curve;
+    let points: Vec<egui::Pos2> = (0..=48)
+        .map(|i| {
+            let raw = i as f32 / 48.0;
+            to_screen(raw, curve.apply(raw))
+        })
+        .collect();
+    painter.add(egui::Shape::line(
+        points,
+        egui::Stroke::new(2.0_f32, egui::Color32::from_rgb(110, 165, 255)),
+    ));
+    if let Some(raw) = state.last_raw_pressure {
+        let raw = raw.clamp(0.0, 1.0);
+        painter.circle_filled(
+            to_screen(raw, curve.apply(raw)),
+            4.0,
+            egui::Color32::from_rgb(255, 200, 80),
+        );
+    }
+
+    ui.horizontal(|ui| {
+        ui.label("weich");
+        ui.spacing_mut().slider_width = (ui.available_width() - 40.0).max(60.0);
+        track(ui.add(
+            egui::Slider::new(&mut state.pressure_curve.exponent, PressureCurve::EXPONENT_RANGE)
+                .logarithmic(true)
+                .show_value(false),
+        ).on_hover_text("Weich: schon leichter Druck ergibt kräftige Linien.\nHart: erst fester Druck ergibt kräftige Linien."));
+        ui.label("hart");
+    });
+    ui.horizontal(|ui| {
+        ui.label("Mindestdruck");
+        ui.spacing_mut().slider_width = (ui.available_width() - 60.0).max(60.0);
+        track(ui.add(
+            egui::Slider::new(&mut state.pressure_curve.threshold, PressureCurve::THRESHOLD_RANGE)
+                .custom_formatter(|v, _| format!("{:.0} %", v * 100.0))
+                .custom_parser(|s| s.trim().trim_end_matches('%').trim().parse::<f64>().ok().map(|v| v / 100.0)),
+        ).on_hover_text("Leichterer Druck zählt als kein Druck (dünnste Linie).\nHilft bei Stiften, die schon beim Schweben Druck melden."));
+    });
+    if ui
+        .add_enabled(
+            state.pressure_curve != PressureCurve::default(),
+            egui::Button::new("Druckkurve zurücksetzen"),
+        )
+        .clicked()
+    {
+        state.pressure_curve = PressureCurve::default();
+        save = true;
+    }
+    save.then_some(state.pressure_curve)
+}
+
 /// Rahmen der Popover neben der Werkzeugleiste.
 fn popover_frame() -> egui::Frame {
     egui::Frame::none()
@@ -1085,7 +1248,7 @@ pub fn render_ui(
                                     (
                                         ActiveTool::Eraser,
                                         SidebarIcon::Eraser,
-                                        "Radierer (E oder rechte Maustaste)",
+                                        "Radierer (E oder rechte Maustaste) – darunter: alles oder nur Textmarker",
                                     ),
                                     (
                                         ActiveTool::Select,
@@ -1146,10 +1309,44 @@ pub fn render_ui(
                                         }
                                     }
                                 }
-                                let missing = UiState::MAX_PALETTE_LEN.saturating_sub(shown);
-                                if missing > 0 {
-                                    let spacing = ui.spacing().item_spacing.y;
-                                    ui.add_space(missing as f32 * (swatch + spacing));
+                                let spacing = ui.spacing().item_spacing.y;
+                                let mut used = shown as f32 * (swatch + spacing);
+                                // Radierer: statt Farben die Radier-Modi im selben Platz
+                                if state.active_tool == ActiveTool::Eraser {
+                                    for (mode, icon, indicator, tooltip) in [
+                                        (
+                                            EraserMode::All,
+                                            SidebarIcon::Text("Alle"),
+                                            None,
+                                            "Alle Striche radieren",
+                                        ),
+                                        (
+                                            EraserMode::HighlighterOnly,
+                                            SidebarIcon::Glyph("🖊"),
+                                            Some(state.highlighter_color),
+                                            "Nur Textmarker radieren – Handschrift darunter bleibt",
+                                        ),
+                                    ] {
+                                        if sidebar_button(
+                                            ui,
+                                            btn,
+                                            icon,
+                                            state.eraser_mode == mode,
+                                            true,
+                                            indicator,
+                                            tooltip,
+                                        )
+                                        .clicked()
+                                        {
+                                            state.eraser_mode = mode;
+                                        }
+                                        used += btn + spacing;
+                                    }
+                                }
+                                let reserved =
+                                    UiState::MAX_PALETTE_LEN as f32 * (swatch + spacing);
+                                if reserved > used {
+                                    ui.add_space(reserved - used);
                                 }
 
                                 // --- Aktionen für die Auswahl ---
@@ -1623,6 +1820,10 @@ pub fn render_ui(
                                 );
                             });
 
+                            // Bei kleinen Fenstern scrollen statt abschneiden
+                            egui::ScrollArea::vertical()
+                                .max_height((ctx.screen_rect().height() - 90.0).max(150.0))
+                                .show(ui, |ui| {
                             section(ui, "DOKUMENT");
                             if ui
                                 .add_sized([ui.available_width(), 30.0], egui::Button::new("📄  Als PDF exportieren (Strg+E)"))
@@ -1668,6 +1869,48 @@ pub fn render_ui(
                                     }
                                 });
 
+                            section(ui, "PAPIERFARBE (NUR ANZEIGE)");
+                            let mut paper_changed = false;
+                            egui::Grid::new("more_menu_paper")
+                                .num_columns(2)
+                                .spacing([6.0, 6.0])
+                                .show(ui, |ui| {
+                                    for (i, theme) in PaperTheme::ALL.into_iter().enumerate() {
+                                        if paper_theme_button(ui, theme, state.paper_theme == theme)
+                                            .clicked()
+                                            && state.paper_theme != theme
+                                        {
+                                            state.paper_theme = theme;
+                                            paper_changed = true;
+                                        }
+                                        if i % 2 == 1 {
+                                            ui.end_row();
+                                        }
+                                    }
+                                });
+                            if ui
+                                .add_enabled(
+                                    state.paper_theme.is_dark(),
+                                    egui::Checkbox::new(
+                                        &mut state.adapt_ink_colors,
+                                        "Dunkle Stiftfarben aufhellen",
+                                    ),
+                                )
+                                .on_hover_text(
+                                    "Schwarz wird Weiß, Dunkelblau wird Hellblau. Gespeichert und \
+                                     als PDF exportiert werden immer die Originalfarben.",
+                                )
+                                .changed()
+                            {
+                                paper_changed = true;
+                            }
+                            if paper_changed {
+                                actions.push(UiAction::SetPaperTheme {
+                                    theme: state.paper_theme,
+                                    adapt_ink: state.adapt_ink_colors,
+                                });
+                            }
+
                             section(ui, "ZOOM");
                             ui.horizontal(|ui| {
                                 if ui
@@ -1702,6 +1945,9 @@ pub fn render_ui(
                             .on_hover_text(
                                 "Aus: ein Finger verschiebt, zwei Finger zoomen (empfohlen mit Stift).\nAn: ein Finger zeichnet.",
                             );
+                            if let Some(curve) = pressure_curve_editor(ui, state) {
+                                actions.push(UiAction::SavePressureCurve(curve));
+                            }
 
                             section(ui, "WERKZEUGLEISTE");
                             ui.horizontal(|ui| {
@@ -1757,6 +2003,7 @@ pub fn render_ui(
                                 state.close_overlays();
                                 state.is_update_dialog_open = true;
                             }
+                                });
                         })
                         .response
                         .rect
@@ -1796,8 +2043,14 @@ pub fn render_ui(
                                         .show(ui, |ui| {
                                             for (idx, page) in notebook.pages.iter().enumerate() {
                                                 let is_current = idx == notebook.current_page_index;
-                                                if page_thumbnail(ui, page, idx + 1, is_current)
-                                                    .clicked()
+                                                if page_thumbnail(
+                                                    ui,
+                                                    state,
+                                                    page,
+                                                    idx + 1,
+                                                    is_current,
+                                                )
+                                                .clicked()
                                                 {
                                                     actions.push(UiAction::GoToPage(idx));
                                                     state.show_page_jump_popup = false;
@@ -2917,6 +3170,19 @@ mod tests {
         out
     }
 
+    #[test]
+    fn test_stroke_tool_follows_active_tool() {
+        assert_eq!(ActiveTool::Pen.stroke_tool(false), StrokeTool::Pen);
+        assert_eq!(
+            ActiveTool::Highlighter.stroke_tool(false),
+            StrokeTool::Highlighter
+        );
+        assert_eq!(ActiveTool::Shape.stroke_tool(false), StrokeTool::Pen);
+        // Eingerastete Form (Formwerkzeug oder Halten am Strichende)
+        assert_eq!(ActiveTool::Shape.stroke_tool(true), StrokeTool::Shape);
+        assert_eq!(ActiveTool::Pen.stroke_tool(true), StrokeTool::Shape);
+    }
+
     #[test]
     fn test_all_ui_texts_are_renderable() {
         // Zeichen ohne Glyphe in den eingebauten egui-Schriften erscheinen als leere Kästchen
@@ -3130,11 +3396,14 @@ mod tests {
 
         // Leere Seite: nur das weiße Blatt
         let empty = Page::new(1, PageBackground::Blank);
-        assert_eq!(page_thumbnail_shapes(&empty, rect).len(), 1);
+        assert_eq!(
+            page_thumbnail_shapes(&empty, rect, PaperTheme::White, true).len(),
+            1
+        );
 
         // Striche liegen innerhalb der Kachel
         let page = page_with_strokes(3, 20);
-        let shapes = page_thumbnail_shapes(&page, rect);
+        let shapes = page_thumbnail_shapes(&page, rect, PaperTheme::White, true);
         assert_eq!(shapes.len(), 1 + 3);
         let pts = shape_points(&shapes);
         assert!(!pts.is_empty());
@@ -3145,7 +3414,7 @@ mod tests {
 
         // Sehr volle Seite wird auf das Punktbudget ausgedünnt (+ Endpunkte je Strich)
         let full = page_with_strokes(100, 1000);
-        let pts = shape_points(&page_thumbnail_shapes(&full, rect));
+        let pts = shape_points(&page_thumbnail_shapes(&full, rect, PaperTheme::White, true));
         assert!(
             pts.len() <= THUMBNAIL_POINT_BUDGET + 2 * 100,
             "{} Punkte statt höchstens {}",