chore(release): bump version to 0.21.0

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

Cargo.lock

@@ -1393,7 +1393,7 @@ dependencies = [
 
 [[package]]
 name = "ink-notes"
-version = "0.17.0"
+version = "0.21.0"
 dependencies = [
  "ab_glyph",
  "arboard",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ink-notes"
-version = "0.17.0"
+version = "0.21.0"
 edition = "2021"
 description = "Notizbuch-App für Stift, Touch und Maus unter Linux"
 repository = "https://gitea.pansi.eu/harald/ink-notes"

README.md

@@ -22,12 +22,13 @@ Getestet wird vor allem unter Zorin OS 18 / Ubuntu 24.04 (Wayland und X11).
 - **Eigene Farben:** Jede Farbe in der Werkzeugleiste (Stifte, Textmarker, Text) lässt sich anpassen – gewählte Farbe erneut antippen, eine Vorgabe oder mit 🎨 einen freien Farbton wählen. Die Leiste merkt sich die Farben. Am Bildschirm erscheinen sie genauso wie im PDF- und Bildexport.
 - **Glättung in zwei Stufen:** Während des Schreibens glättet ein 1€-Filter das Zittern, die Linie erscheint sofort. Beim Absetzen wird der Strich nachbearbeitet: Ecken (Knicke über 65°) bleiben erhalten, der Druckverlauf wird geglättet, überflüssige Punkte entfallen, die Enden werden rund.
 - **Druckkurve** im ☰-Menü an den eigenen Stift anpassen (weicher/härter, Schwelle gegen Grundrauschen).
-- **Radierer** in drei Modi: ganze Striche, nur den überstrichenen Teil (Teilstrich) oder nur Textmarker. Stiftrückseite und Seitentaste des Stifts radieren ebenfalls.
+- **Tasten am Stift** im ☰-Menü belegen: Radieren (Standard), Auswählen, Textmarker, Stift oder nichts – gilt, solange die Taste gedrückt ist. Jede Taste erscheint dort nach dem ersten Drücken.
+- **Radierer** in drei Modi: ganze Striche, nur den überstrichenen Teil (Teilstrich) oder nur Textmarker. Die Stiftrückseite radiert ebenfalls.
 - **Virtuelles Lineal** (`L`): verschieben, am Griff drehen (rastet bei 15° ein); Striche entlang einer Kante werden gerade.
 
 ### Formerkennung
 - **Formen-Werkzeug** (`S`/`F`) oder **Halten** am Strichende (über 400 ms stillhalten): Die Skizze wird durch eine saubere Form ersetzt.
-- Erkannt werden Linien, Pfeile, Kreise, Ellipsen, Rechtecke, Dreiecke, Rauten, Vielecke, Koordinatensysteme und Oktaeder (Skizze als 3D-Körper).
+- Erkannt werden Linien, Pfeile, Kreise, Ellipsen, Rechtecke, Dreiecke, Rauten, Vielecke, Koordinatensysteme (L-Form), Achsenkreuze (ein „+“ in einem Zug, Pfeilspitzen an allen vier Enden) und Oktaeder (Skizze als 3D-Körper).
 - Die Erkennung arbeitet rein geometrisch (Bogenlänge, Douglas-Peucker, Kreis-Fit), ohne Machine Learning. Nicht alles wird erkannt – was nicht passt, bleibt Handschrift.
 
 ### Auswählen und Bearbeiten
@@ -53,6 +54,7 @@ Getestet wird vor allem unter Zorin OS 18 / Ubuntu 24.04 (Wayland und X11).
 
 ### Notizbücher und Speichern
 - Mehrere **Notizbücher** anlegen, umbenennen, wechseln und löschen (gelöschte landen zunächst im Papierkorb und lassen sich wiederherstellen).
+- **Ordner** für Notizbücher, beliebig verschachtelt (z. B. 3. Semester › Mathe): anlegen, umbenennen, löschen (der Inhalt rückt eine Ebene nach oben) und Notizbücher wie Ordner (samt Inhalt) mit 📂 verschieben. Neue Notizbücher landen im gerade geöffneten Ordner.
 - **Automatisches Speichern** im Hintergrund: 1,5 Sekunden nach der letzten Änderung, bei ununterbrochenem Schreiben spätestens alle 10 Sekunden. Zeichnen wird dabei nicht unterbrochen.
 - Jede Datei wird erst vollständig in eine temporäre Datei geschrieben und dann ersetzt – ein Absturz beim Speichern hinterlässt keine halbe Datei.
 - **Beim Schließen** (Fenster oder `Strg + Q`) und beim Wechsel des Notizbuchs wird alles Ausstehende geschrieben, bevor es weitergeht. Schlägt das fehl, bleibt die App offen und bietet Wiederholen oder eine Notfall-Sicherung an.
@@ -162,6 +164,7 @@ src/
 ├── document.rs     # Datenmodell: Notizbuch, Seiten, Striche, Seitengrößen
 ├── history.rs      # Rückgängig/Wiederholen
 ├── storage.rs      # Laden/Speichern (atomar), Notizbücher, Papierkorb
+├── library.rs      # Ordner der Notizbücher (library.json)
 ├── autosave.rs     # Speichern im Hintergrund
 ├── export.rs       # PDF-Export (printpdf)
 ├── page_export.rs  # Seite als PNG/SVG, Auswahl als Bild

docs/ARCHITECTURE.md

@@ -136,12 +136,13 @@ Jede Seite hat einen eigenen Verlauf (`history.rs`): Hinzufügen, Entfernen, Ers
 
 ## 6. Formerkennung
 
-`geometry.rs` erkennt Formen rein geometrisch, ohne Machine Learning. Geschlossene Formen (Kreis, Ellipse, Dreieck, Rechteck, Raute) treten gegeneinander an; gewählt wird die, deren Umriss am besten zu den Punkten passt. Danach folgen Vielecke, Pfeile, Koordinatensysteme und Linien. Übernommen wird eine Form nur, wenn der Strich im Mittel höchstens 4 % seiner Diagonale von ihr abweicht – sonst bleibt er Handschrift.
+`geometry.rs` erkennt Formen rein geometrisch, ohne Machine Learning. Zuerst wird auf ein Achsenkreuz geprüft (alle Teilstücke liegen auf einer waagerechten und einer senkrechten Linie, beide reichen auf beiden Seiten über den Schnittpunkt hinaus). Geschlossene Formen (Kreis, Ellipse, Dreieck, Rechteck, Raute) treten gegeneinander an; gewählt wird die, deren Umriss am besten zu den Punkten passt. Danach folgen Vielecke, Pfeile, Koordinatensysteme und Linien. Übernommen wird eine Form nur, wenn der Strich im Mittel höchstens 4 % seiner Diagonale von ihr abweicht – sonst bleibt er Handschrift.
 
 - **Linie:** Verhältnis von Abstand Anfang–Ende zur Strichlänge über 0,92.
 - **Kreis, Ellipse:** Kreis- bzw. Ellipsen-Fit über die Punkte.
 - **Rechteck, Dreieck, Raute, Vieleck, Pfeil:** Analyse der mit Douglas-Peucker vereinfachten Kontur (Eckenzahl, Winkel, Seitenverhältnisse).
 - **Koordinatensystem:** zwei etwa rechtwinklige Achsen; der Winkel wird auf 90° gesetzt.
+- **Achsenkreuz:** ein „+“ in einem Zug; die Achsen werden waagerecht und senkrecht ausgerichtet und bekommen an allen vier Enden Pfeilspitzen.
 - **Oktaeder:** Skizze einer Doppelpyramide als 3D-Kantenmodell; nur, wenn kein einfacher Umriss passt.
 
 **Halten am Strichende:** Bleibt der Stift über 400 ms innerhalb von 3 Pixeln ruhig, wird die erkannte Form schon vor dem Absetzen angezeigt und beim Absetzen übernommen. Mit dem Formen-Werkzeug wird jeder Strich beim Absetzen geprüft.

docs/FILE_FORMAT.md

@@ -9,6 +9,7 @@ Dieses Dokument beschreibt, wo und wie ink-notes Notizbücher speichert, und die
 ```text
 ~/.local/share/ink-notes/              ($XDG_DATA_HOME/ink-notes)
 ├── notebooks/
+│   ├── library.json                   Ordner der Notizbücher (siehe unten)
 │   ├── <notizbuch-id>/
 │   │   ├── manifest.json              Metadaten und Seitenreihenfolge
 │   │   ├── manifest.json.bak          Kopie des vorherigen Manifests
@@ -29,6 +30,21 @@ Dieses Dokument beschreibt, wo und wie ink-notes Notizbücher speichert, und die
 - **Assets** sind nach dem SHA-256-Hash ihres Inhalts benannt; dasselbe Bild wird nur einmal gespeichert. Bilder werden als PNG oder (unverändert) JPEG abgelegt, PDFs unverändert.
 - Alle Dateien werden mit Rechten `0600`, Ordner mit `0700` angelegt.
 
+### Ordner (`library.json`)
+Ordner wie „3. Semester › Mathe“ sind rein logisch: Die Notizbücher bleiben in ihren Verzeichnissen, `library.json` hält nur fest, welcher Ordner welches Notizbuch enthält. Umbenennen, Verschieben (samt Inhalt) und Löschen von Ordnern ändern deshalb nie eine Notizbuch-Datei.
+
+```json
+{
+  "folders": ["3. Semester", "3. Semester/Mathe", "4. Semester"],
+  "notebooks": { "analysis_1775460000": "3. Semester/Mathe" }
+}
+```
+
+- Ordner sind Pfade mit `/` als Trenner; Namen enthalten selbst kein `/` und höchstens 80 Zeichen.
+- Notizbücher ohne Eintrag liegen auf der obersten Ebene.
+- Wird ein Ordner gelöscht, rücken seine Notizbücher und Unterordner eine Ebene nach oben.
+- Fehlt die Datei oder ist sie unlesbar, liegen alle Notizbücher auf der obersten Ebene; fehlende übergeordnete Ordner werden beim Laden ergänzt.
+
 ---
 
 ## 2. Manifest (`manifest.json`)
@@ -109,7 +125,7 @@ Jedes Objekt hat eine `id`, eine `color` (RGBA, linear, Werte 0–1) und `sample
 "shape": { "Rectangle": { "corners": [[500, 600], [800, 600], [800, 800], [500, 800]] } }
 ```
 
-Mögliche Formen: `Line { start, end }`, `Arrow { start, end, double }`, `Circle { center, radius }`, `Ellipse { center, radius_x, radius_y, rotation }`, `Rectangle { corners }`, `Triangle { corners }`, `Rhombus { corners }`, `Polygon { vertices }`, `CoordinateSystem { origin, x_axis_end, y_axis_end, with_arrows }`, `Octahedron { … }`. Punkte sind `[x, y]`.
+Mögliche Formen: `Line { start, end }`, `Arrow { start, end, double }`, `Circle { center, radius }`, `Ellipse { center, radius_x, radius_y, rotation }`, `Rectangle { corners }`, `Triangle { corners }`, `Rhombus { corners }`, `Polygon { vertices }`, `CoordinateSystem { origin, x_axis_end, y_axis_end, with_arrows, negative_ends? }`, `Octahedron { … }`. Punkte sind `[x, y]`. Beim Achsenkreuz enthält `negative_ends` die Enden der x- und der y-Achse auf der anderen Seite des Ursprungs; ältere Versionen ignorieren das Feld und zeigen ein L-förmiges Koordinatensystem.
 
 **Bilder** haben `image` (Dateiname in `assets/`); die vier `samples` sind die Ecken oben links, oben rechts, unten rechts, unten links:
 

packaging/release-notes.md.tmpl

@@ -3,6 +3,11 @@
 Notizbuch-App für Stift, Touch und Maus unter Linux (getestet mit Zorin OS 18 / Ubuntu 24.04).
 
 ### Highlights:
+- **Achsenkreuz**: Ein „+“ in einem Zug (mit Halten oder dem Formen-Werkzeug) wird zum Achsenkreuz mit Pfeilspitzen an allen vier Enden; auch im PDF-/Bildexport
+- **Fehlerbehebung Stift**: Das erste Antippen mit dem Stift trifft jetzt – Knöpfe und Notizbücher reagieren sofort statt erst beim zweiten Tippen; Striche beginnen nicht mehr mit einer Linie von der vorherigen Stiftposition
+- **Tasten am Stift belegen**: Im ☰-Menü unter Eingabe jede Stifttaste mit Radieren, Auswählen, Textmarker, Stift oder Nichts belegen (gilt, solange die Taste gedrückt ist); Tasten erscheinen nach dem ersten Drücken und leuchten beim Drücken grün
+- **Ordner verschieben**: Ordner lassen sich jetzt wie Notizbücher mit 📂 samt Inhalt in andere Ordner oder auf die oberste Ebene verschieben
+- **Ordner für Notizbücher**: Beliebig verschachtelte Ordner (z. B. 3. Semester › Mathe) im Dokumenten-Manager anlegen, umbenennen und löschen, Notizbücher mit 📂 verschieben; neue Notizbücher landen im geöffneten Ordner. Die Notizbuch-Dateien bleiben unverändert (Zuordnung in library.json)
 - **Einfügen per Finger**: Lange (½ s) mit dem Finger aufs Blatt drücken öffnet ein Menü „Einfügen“ – Screenshot, kopierter Text oder kopierte Objekte landen genau an dieser Stelle (wie in Rnote)
 - **Eigene Farben**: Jede Farbe der Werkzeugleiste (Stifte, Textmarker, Text) lässt sich anpassen – erneut antippen, Vorgabe oder mit 🎨 frei wählen; die Leiste merkt sich die Farben. Farben am Bildschirm wie im PDF-/Bildexport (Schwarz ist schwarz, Textmarker mischt wie im PDF); Karos und Linien im PDF so hell wie am Bildschirm
 - **Beta-Feedback II**: Vier Stifte mit eigener Farbe und Stärke, die sich Änderungen merken; Textmarker wird innerhalb eines Strichs nicht dunkler und ist jetzt auch im PDF-/PNG-/SVG-Export durchsichtig; Seiten lückenlos untereinander mit Trennlinie; neue Seite per ➕ in der Werkzeugleiste; Seite löschen im ☰-Menü (wiederherstellbar); Koordinatensystem ohne Loch am Ursprung

src/export.rs

@@ -1033,6 +1033,59 @@ fn render_recognized_shape(
             x_axis_end,
             y_axis_end,
             with_arrows,
+            negative_ends: Some([x_axis_start, y_axis_start]),
+        } => {
+            // Achsenkreuz: zwei durchgehende Achsen, Pfeilspitzen an allen vier Enden
+            const PDF_SHAPE_HALF_WIDTH: f32 = 2.65;
+            let to_pdf = |p: &glam::Vec2| {
+                let (px, py) = page_to_pdf_mm(p.x, p.y);
+                (Point::new(Mm(px), Mm(py)), false)
+            };
+            let mut heads = Vec::new();
+            for (neg, pos) in [(*x_axis_start, *x_axis_end), (*y_axis_start, *y_axis_end)] {
+                let dir = (pos - neg).normalize_or_zero();
+                let pos_head = crate::geometry::arrow_head(
+                    pos,
+                    dir,
+                    PDF_SHAPE_HALF_WIDTH,
+                    (pos - *origin).length(),
+                );
+                let neg_head = crate::geometry::arrow_head(
+                    neg,
+                    -dir,
+                    PDF_SHAPE_HALF_WIDTH,
+                    (neg - *origin).length(),
+                );
+                let (from, to) = if *with_arrows {
+                    (neg_head.0, pos_head.0)
+                } else {
+                    (neg, pos)
+                };
+                layer.add_line(Line {
+                    points: [from, to].iter().map(to_pdf).collect(),
+                    is_closed: false,
+                });
+                heads.push((pos, pos_head));
+                heads.push((neg, neg_head));
+            }
+            if *with_arrows {
+                layer.set_fill_color(stroke_color);
+                for (tip, (_, left, right)) in heads {
+                    layer.add_polygon(Polygon {
+                        rings: vec![[tip, left, right].iter().map(to_pdf).collect()],
+                        mode: PaintMode::Fill,
+                        winding_order: WindingOrder::NonZero,
+                    });
+                }
+            }
+        }
+
+        RecognizedShape::CoordinateSystem {
+            origin,
+            x_axis_end,
+            y_axis_end,
+            with_arrows,
+            negative_ends: None,
         } => {
             // 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)
@@ -1450,6 +1503,7 @@ mod tests {
                 x_axis_end: glam::Vec2::new(800.0, 1500.0),
                 y_axis_end: glam::Vec2::new(300.0, 1000.0),
                 with_arrows: true,
+                negative_ends: None,
             },
         );
         page.add_stroke(coords_stroke);

src/geometry.rs

@@ -59,6 +59,11 @@ pub enum RecognizedShape {
         x_axis_end: Vec2,
         y_axis_end: Vec2,
         with_arrows: bool,
+        /// Achsenkreuz: Enden der x- und der y-Achse auf der anderen Seite des Ursprungs
+        /// (Pfeilspitzen an allen vier Enden). Fehlt es, ist es das L-förmige
+        /// Koordinatensystem; ältere Versionen ignorieren das Feld und zeigen das L.
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        negative_ends: Option<[Vec2; 2]>,
     },
     Triangle {
         /// 3 Eckpunkte in umlaufender Reihenfolge.
@@ -105,6 +110,10 @@ impl RecognizedShape {
             Self::Arrow { double: false, .. } => "Pfeil",
             Self::Arrow { double: true, .. } => "Doppelpfeil",
             Self::Rectangle { .. } => "Rechteck",
+            Self::CoordinateSystem {
+                negative_ends: Some(_),
+                ..
+            } => "Achsenkreuz",
             Self::CoordinateSystem { .. } => "Koordinatensystem",
             Self::Triangle { .. } => "Dreieck",
             Self::Rhombus { .. } => "Raute (Rhombus)",
@@ -146,11 +155,15 @@ impl RecognizedShape {
                 origin,
                 x_axis_end,
                 y_axis_end,
+                negative_ends,
                 ..
             } => {
                 *origin += delta;
                 *x_axis_end += delta;
                 *y_axis_end += delta;
+                for end in negative_ends.iter_mut().flatten() {
+                    *end += delta;
+                }
             }
             Self::Polygon { vertices } => {
                 for v in vertices {
@@ -203,11 +216,15 @@ impl RecognizedShape {
                 origin: o,
                 x_axis_end,
                 y_axis_end,
+                negative_ends,
                 ..
             } => {
                 *o = rot(*o);
                 *x_axis_end = rot(*x_axis_end);
                 *y_axis_end = rot(*y_axis_end);
+                for end in negative_ends.iter_mut().flatten() {
+                    *end = rot(*end);
+                }
             }
             Self::Polygon { vertices } => {
                 for v in vertices {
@@ -267,11 +284,15 @@ impl RecognizedShape {
                 origin: o,
                 x_axis_end,
                 y_axis_end,
+                negative_ends,
                 ..
             } => {
                 *o = sc(*o);
                 *x_axis_end = sc(*x_axis_end);
                 *y_axis_end = sc(*y_axis_end);
+                for end in negative_ends.iter_mut().flatten() {
+                    *end = sc(*end);
+                }
             }
             Self::Polygon { vertices } => {
                 for v in vertices {
@@ -1394,6 +1415,87 @@ pub fn detect_coordinate_system(points: &[Vec2]) -> Option<RecognizedShape> {
         x_axis_end: x_end,
         y_axis_end: y_end,
         with_arrows: true,
+        negative_ends: None,
+    })
+}
+
+/// Achsenkreuz in einem Strich („+“, z. B. waagerecht hin und zurück, dann senkrecht): Alle
+/// Teilstücke liegen auf einer waagerechten und einer senkrechten Linie, und beide reichen
+/// auf beiden Seiten deutlich über den Schnittpunkt hinaus. Ergebnis wie beim
+/// Koordinatensystem achsenparallel, mit Pfeilspitzen an allen vier Enden.
+pub fn detect_axis_cross(points: &[Vec2]) -> Option<RecognizedShape> {
+    if points.len() < 8 {
+        return None;
+    }
+    let aabb = Aabb::from_points(points);
+    let diagonal = (aabb.max - aabb.min).length();
+    if diagonal < 60.0 {
+        return None;
+    }
+    let simplified = ramer_douglas_peucker(points, (diagonal * 0.05).clamp(8.0, 40.0));
+
+    // Teilstücke nach Richtung: waagerecht oder senkrecht (höchstens 25° schief); kurze
+    // Stücke (Umkehrpunkte) zählen nicht, schräge lange Stücke schließen ein Kreuz aus
+    let max_slope = 25.0_f32.to_radians().tan();
+    let (mut horizontal, mut vertical) = ((0.0, 0.0), (0.0, 0.0));
+    for w in simplified.windows(2) {
+        let d = w[1] - w[0];
+        let len = d.length();
+        if len < diagonal * 0.08 {
+            continue;
+        }
+        let mid = (w[0] + w[1]) * 0.5;
+        if d.y.abs() <= d.x.abs() * max_slope {
+            horizontal = (horizontal.0 + mid.y * len, horizontal.1 + len);
+        } else if d.x.abs() <= d.y.abs() * max_slope {
+            vertical = (vertical.0 + mid.x * len, vertical.1 + len);
+        } else {
+            return None;
+        }
+    }
+    if horizontal.1 == 0.0 || vertical.1 == 0.0 {
+        return None;
+    }
+    let origin = Vec2::new(vertical.0 / vertical.1, horizontal.0 / horizontal.1);
+
+    // Jeder Punkt liegt auf einer der beiden Linien
+    let tolerance = (diagonal * 0.08).max(10.0);
+    let (mut x_min, mut x_max) = (f32::INFINITY, f32::NEG_INFINITY);
+    let (mut y_min, mut y_max) = (f32::INFINITY, f32::NEG_INFINITY);
+    for p in points {
+        let on_horizontal = (p.y - origin.y).abs() <= tolerance;
+        let on_vertical = (p.x - origin.x).abs() <= tolerance;
+        if !on_horizontal && !on_vertical {
+            return None;
+        }
+        if on_horizontal {
+            x_min = x_min.min(p.x);
+            x_max = x_max.max(p.x);
+        }
+        if on_vertical {
+            y_min = y_min.min(p.y);
+            y_max = y_max.max(p.y);
+        }
+    }
+
+    // Vier Arme: jeder mindestens ein Fünftel seiner Achse und deutlich länger als die Toleranz
+    let arm_ok = |arm: f32, axis: f32| arm >= axis * 0.2 && arm >= tolerance * 1.5;
+    let (width, height) = (x_max - x_min, y_max - y_min);
+    if !(arm_ok(origin.x - x_min, width)
+        && arm_ok(x_max - origin.x, width)
+        && arm_ok(origin.y - y_min, height)
+        && arm_ok(y_max - origin.y, height))
+    {
+        return None;
+    }
+
+    // x nach rechts, y nach oben (auf dem Blatt: kleineres y)
+    Some(RecognizedShape::CoordinateSystem {
+        origin,
+        x_axis_end: Vec2::new(x_max, origin.y),
+        y_axis_end: Vec2::new(origin.x, y_min),
+        with_arrows: true,
+        negative_ends: Some([Vec2::new(x_min, origin.y), Vec2::new(origin.x, y_max)]),
     })
 }
 
@@ -1423,7 +1525,10 @@ pub fn detect_shape(points: &[StylusSample]) -> Option<RecognizedShape> {
     // Kandidaten in Prioritätsreihenfolge; 3. offene Formen (Koordinatensystem, Gerade) zuletzt.
     // Übernommen wird der erste, der den Strich wirklich beschreibt. Passt keiner, bleibt der
     // Strich unverändert (vorher wurde fast jede geschlossene Kritzelei zu einer Form).
-    let candidates: [&dyn Fn() -> Option<RecognizedShape>; 6] = [
+    let candidates: [&dyn Fn() -> Option<RecognizedShape>; 7] = [
+        // Das Achsenkreuz zuerst: Seine Prüfung ist streng, und ein hin und her gezeichnetes
+        // „+“ könnte sonst als Vieleck durchgehen
+        &|| detect_axis_cross(&pts),
         &|| {
             if closed_fits_well {
                 None
@@ -1908,6 +2013,51 @@ pub fn shape_to_mesh(
             x_axis_end,
             y_axis_end,
             with_arrows,
+            negative_ends: Some([x_axis_start, y_axis_start]),
+        } => {
+            // Achsenkreuz: zwei durchgehende Achsen, Pfeilspitzen an allen vier Enden
+            let mut vertices = Vec::new();
+            for (neg, pos) in [(*x_axis_start, *x_axis_end), (*y_axis_start, *y_axis_end)] {
+                let dir = (pos - neg).normalize_or_zero();
+                let pos_head = arrow_head(pos, dir, half_w, (pos - *origin).length());
+                let neg_head = arrow_head(neg, -dir, half_w, (neg - *origin).length());
+                let (from, to) = if *with_arrows {
+                    (neg_head.0, pos_head.0)
+                } else {
+                    (neg, pos)
+                };
+                push_band(&mut vertices, from, to, half_w, color);
+                if *with_arrows {
+                    for (tip, (_, left, right)) in [(pos, pos_head), (neg, neg_head)] {
+                        push_triangle(&mut vertices, tip, left, right, color);
+                    }
+                }
+            }
+            // Abtastpunkte als Linienzug ohne Diagonalen (jeder Arm vom Ursprung aus)
+            let samples = [
+                *x_axis_start,
+                *origin,
+                *x_axis_end,
+                *origin,
+                *y_axis_end,
+                *origin,
+                *y_axis_start,
+            ]
+            .map(|position| StylusSample {
+                position,
+                pressure: 0.5,
+                timestamp: 0.0,
+            })
+            .to_vec();
+            (samples, vertices)
+        }
+
+        RecognizedShape::CoordinateSystem {
+            origin,
+            x_axis_end,
+            y_axis_end,
+            with_arrows,
+            negative_ends: None,
         } => {
             let mut vertices = Vec::new();
             let mut samples = Vec::new();
@@ -2012,6 +2162,40 @@ pub fn shape_to_mesh(
     }
 }
 
+/// Hängt ein gerades Band der halben Breite `half_w` von `a` nach `b` an einen Triangle-Strip
+/// an (über degenerierte Dreiecke, falls er schon Vertizes hat).
+fn push_band(vertices: &mut Vec<InkVertex>, a: Vec2, b: Vec2, half_w: f32, color: [f32; 4]) {
+    let dir = (b - a).normalize_or_zero();
+    let norm = Vec2::new(-dir.y, dir.x) * half_w;
+    let first = InkVertex::new(a.x + norm.x, a.y + norm.y, color);
+    if let Some(&last) = vertices.last() {
+        vertices.push(last);
+        vertices.push(first);
+    }
+    vertices.push(first);
+    vertices.push(InkVertex::new(a.x - norm.x, a.y - norm.y, color));
+    vertices.push(InkVertex::new(b.x + norm.x, b.y + norm.y, color));
+    vertices.push(InkVertex::new(b.x - norm.x, b.y - norm.y, color));
+}
+
+/// Hängt ein Dreieck (Pfeilspitze) an einen Triangle-Strip an.
+fn push_triangle(
+    vertices: &mut Vec<InkVertex>,
+    tip: Vec2,
+    left: Vec2,
+    right: Vec2,
+    color: [f32; 4],
+) {
+    let tip_v = InkVertex::new(tip.x, tip.y, color);
+    if let Some(&last) = vertices.last() {
+        vertices.push(last);
+        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));
+}
+
 /// Erzeugt einen neuen `Stroke` aus einer erkannten Form.
 pub fn shape_to_stroke(
     shape: RecognizedShape,
@@ -2210,6 +2394,7 @@ mod tests {
             x_axis_end: Vec2::new(900.0, 900.0),
             y_axis_end: Vec2::new(300.0, 300.0),
             with_arrows: true,
+            negative_ends: None,
         };
         let width = 30.0;
         let (_, vertices) = shape_to_mesh(&shape, width, [0.0, 0.0, 0.0, 1.0]);
@@ -2479,12 +2664,167 @@ mod tests {
             Some(RecognizedShape::Triangle { .. }) => "Dreieck",
             Some(RecognizedShape::Rhombus { .. }) => "Raute",
             Some(RecognizedShape::Polygon { .. }) => "Polygon",
+            Some(RecognizedShape::CoordinateSystem {
+                negative_ends: Some(_),
+                ..
+            }) => "Achsenkreuz",
             Some(RecognizedShape::CoordinateSystem { .. }) => "Koordinatensystem",
             Some(RecognizedShape::Octahedron { .. }) => "Oktaeder",
             None => "nichts",
         }
     }
 
+    #[test]
+    fn test_detect_axis_cross_in_one_stroke() {
+        let c = Vec2::new(800.0, 900.0);
+        let v = |x: f32, y: f32| c + Vec2::new(x, y);
+        // Verschiedene Zeichenreihenfolgen eines „+“ in einem Zug
+        let crosses: [(&str, Vec<Vec2>); 4] = [
+            (
+                "waagerecht hin, zurück zur Mitte, senkrecht",
+                vec![
+                    v(-200.0, 0.0),
+                    v(200.0, 0.0),
+                    v(0.0, 0.0),
+                    v(0.0, -150.0),
+                    v(0.0, 150.0),
+                ],
+            ),
+            (
+                "senkrecht zuerst",
+                vec![
+                    v(0.0, -180.0),
+                    v(0.0, 180.0),
+                    v(0.0, 0.0),
+                    v(-220.0, 0.0),
+                    v(220.0, 0.0),
+                ],
+            ),
+            (
+                "Arme ungleich lang",
+                vec![
+                    v(-100.0, 0.0),
+                    v(320.0, 0.0),
+                    v(0.0, 0.0),
+                    v(0.0, 250.0),
+                    v(0.0, -120.0),
+                ],
+            ),
+            (
+                "Mitte zuerst, alle Arme hin und zurück",
+                vec![
+                    v(0.0, 0.0),
+                    v(200.0, 0.0),
+                    v(0.0, 0.0),
+                    v(0.0, -200.0),
+                    v(0.0, 0.0),
+                    v(-200.0, 0.0),
+                    v(0.0, 0.0),
+                    v(0.0, 200.0),
+                ],
+            ),
+        ];
+        for (seed, (name, outline)) in crosses.iter().enumerate() {
+            let samples = freehand(outline, false, seed as f32);
+            let shape = detect_shape(&samples);
+            assert_eq!(kind(&shape), "Achsenkreuz", "{name}");
+            let Some(RecognizedShape::CoordinateSystem {
+                origin,
+                x_axis_end,
+                y_axis_end,
+                negative_ends: Some([x_start, y_start]),
+                with_arrows: true,
+            }) = shape
+            else {
+                unreachable!()
+            };
+            assert!((origin - c).length() < 8.0, "{name}: Ursprung {origin}");
+            // Achsenparallel, x nach rechts, y nach oben
+            assert_eq!(x_axis_end.y, origin.y);
+            assert_eq!(x_start.y, origin.y);
+            assert_eq!(y_axis_end.x, origin.x);
+            assert!(x_axis_end.x > origin.x && x_start.x < origin.x, "{name}");
+            assert!(y_axis_end.y < origin.y && y_start.y > origin.y, "{name}");
+        }
+
+        // Keine Kreuze: L-Form, T-Form, einzelne Linie, Rechteck
+        let not_crosses: [(&str, Vec<Vec2>, bool); 4] = [
+            ("L", vec![v(0.0, -200.0), v(0.0, 0.0), v(250.0, 0.0)], false),
+            (
+                "T",
+                vec![v(-200.0, 0.0), v(200.0, 0.0), v(0.0, 0.0), v(0.0, 200.0)],
+                false,
+            ),
+            ("Linie", vec![v(-200.0, 0.0), v(200.0, 0.0)], false),
+            (
+                "Rechteck",
+                vec![
+                    v(-200.0, -100.0),
+                    v(200.0, -100.0),
+                    v(200.0, 100.0),
+                    v(-200.0, 100.0),
+                ],
+                true,
+            ),
+        ];
+        for (seed, (name, outline, closed)) in not_crosses.iter().enumerate() {
+            let samples = freehand(outline, *closed, seed as f32 + 10.0);
+            let points: Vec<Vec2> = samples.iter().map(|s| s.position).collect();
+            assert!(
+                detect_axis_cross(&points).is_none(),
+                "{name} ist kein Kreuz"
+            );
+            assert_ne!(kind(&detect_shape(&samples)), "Achsenkreuz", "{name}");
+        }
+    }
+
+    #[test]
+    fn test_axis_cross_mesh_and_transforms() {
+        let mut shape = RecognizedShape::CoordinateSystem {
+            origin: Vec2::new(500.0, 500.0),
+            x_axis_end: Vec2::new(800.0, 500.0),
+            y_axis_end: Vec2::new(500.0, 300.0),
+            with_arrows: true,
+            negative_ends: Some([Vec2::new(300.0, 500.0), Vec2::new(500.0, 700.0)]),
+        };
+        assert_eq!(shape.name(), "Achsenkreuz");
+        let (samples, vertices) = shape_to_mesh(&shape, 10.0, [0.0, 0.0, 0.0, 1.0]);
+        // Alle vier Pfeilspitzen sind Eckpunkte des Netzes
+        for tip in [
+            (800.0, 500.0),
+            (500.0, 300.0),
+            (300.0, 500.0),
+            (500.0, 700.0),
+        ] {
+            assert!(
+                vertices
+                    .iter()
+                    .any(|v| (Vec2::from(v.position) - Vec2::from(tip)).length() < 1e-3),
+                "Spitze {tip:?} fehlt"
+            );
+        }
+        // Die Form passt zu sich selbst gezeichnet (Abtastpunkte ohne Diagonalen)
+        let points: Vec<Vec2> = samples.iter().map(|s| s.position).collect();
+        assert!(shape_fit_error(&points, &shape).unwrap() < 1e-3);
+        // Verschieben bewegt auch die negativen Enden
+        shape.translate(Vec2::new(10.0, 20.0));
+        let RecognizedShape::CoordinateSystem {
+            negative_ends: Some([x_start, y_start]),
+            ..
+        } = shape
+        else {
+            unreachable!()
+        };
+        assert_eq!(x_start, Vec2::new(310.0, 520.0));
+        assert_eq!(y_start, Vec2::new(510.0, 720.0));
+        // Ältere Dateien ohne das Feld bleiben L-Koordinatensysteme; neue Dateien enthalten es
+        let json = serde_json::to_string(&shape).unwrap();
+        assert!(json.contains("negative_ends"));
+        let old = r#"{"CoordinateSystem":{"origin":[0.0,0.0],"x_axis_end":[1.0,0.0],"y_axis_end":[0.0,-1.0],"with_arrows":true}}"#;
+        let parsed: RecognizedShape = serde_json::from_str(old).unwrap();
+        assert_eq!(parsed.name(), "Koordinatensystem");
+    }
+
     #[test]
     fn test_detect_shape_freehand_classification() {
         let c = Vec2::new(1000.0, 1400.0);
@@ -2884,6 +3224,7 @@ mod tests {
             x_axis_end: x_end,
             y_axis_end: y_end,
             with_arrows: true,
+            negative_ends: None,
         };
         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);

src/history.rs

@@ -3,6 +3,9 @@
 use crate::document::Stroke;
 
 /// Eine rückgängig machbare Benutzeraktion auf einer Seite.
+// Der Verlauf hält nur wenige hundert Einträge; die Größe des Ersetzen-Eintrags (zwei Striche)
+// fällt nicht ins Gewicht, eine Box würde nur die Aufrufe umständlicher machen
+#[allow(clippy::large_enum_variant)]
 #[derive(Debug, Clone)]
 pub enum HistoryAction {
     /// Ein Strich wurde neu gezeichnet.

src/lib.rs

@@ -11,6 +11,7 @@ pub mod filter;
 pub mod geometry;
 pub mod history;
 pub mod image_layer;
+pub mod library;
 pub mod page_export;
 pub mod pdf_doc;
 pub mod pdf_merge;

src/library.rs

@@ -0,0 +1,441 @@
+//! Ordner für Notizbücher (`<Basisordner>/library.json`).
+//!
+//! Ordner sind rein logisch: Die Notizbücher bleiben in ihren Verzeichnissen
+//! `<Basisordner>/<id>/`, `library.json` hält nur fest, welcher Ordner welches Notizbuch
+//! enthält. Umbenennen und Verschieben ändern so nie Notizbuch-Dateien. Fehlt die Datei oder
+//! ist sie unlesbar, liegen alle Notizbücher auf der obersten Ebene – verloren geht nichts.
+//!
+//! Ordner werden als Pfade mit `/` als Trenner gespeichert (z. B. `3. Semester/Mathe`);
+//! die oberste Ebene ist der leere Pfad.
+
+use std::collections::{BTreeMap, BTreeSet};
+use std::path::{Path, PathBuf};
+
+use serde::{Deserialize, Serialize};
+
+use crate::storage::{self, StorageError};
+
+/// Oberste Ebene.
+pub const ROOT: &str = "";
+
+/// Längster erlaubter Ordnername (Zeichen).
+const MAX_NAME_CHARS: usize = 80;
+
+/// Ordnerbaum und Zuordnung der Notizbücher.
+#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(default)]
+pub struct Library {
+    /// Alle Ordner als Pfade
+    pub folders: BTreeSet<String>,
+    /// Ordner je Notizbuch-Kennung; Notizbücher ohne Eintrag liegen auf oberster Ebene
+    pub notebooks: BTreeMap<String, String>,
+}
+
+/// Letzter Teil eines Ordnerpfads (der angezeigte Name).
+pub fn folder_name(path: &str) -> &str {
+    path.rsplit('/').next().unwrap_or(path)
+}
+
+/// Übergeordneter Ordner (oberste Ebene für Ordner der obersten Ebene).
+pub fn parent_folder(path: &str) -> &str {
+    path.rsplit_once('/').map_or(ROOT, |(parent, _)| parent)
+}
+
+/// Pfad des Unterordners `name` in `parent`.
+fn join(parent: &str, name: &str) -> String {
+    if parent.is_empty() {
+        name.to_string()
+    } else {
+        format!("{parent}/{name}")
+    }
+}
+
+/// `path` liegt in `folder` oder ist `folder` selbst.
+fn is_within(path: &str, folder: &str) -> bool {
+    path == folder
+        || path
+            .strip_prefix(folder)
+            .is_some_and(|rest| rest.starts_with('/'))
+}
+
+/// Bereinigt einen Ordnernamen; Fehlermeldung für die Oberfläche bei ungültigen Namen.
+pub fn validate_name(name: &str) -> Result<String, String> {
+    let name = name.trim();
+    if name.is_empty() {
+        return Err("Der Ordnername ist leer".to_string());
+    }
+    if name.contains('/') {
+        return Err("Ordnernamen dürfen kein „/“ enthalten".to_string());
+    }
+    if name.chars().count() > MAX_NAME_CHARS {
+        return Err(format!(
+            "Der Ordnername ist zu lang (höchstens {MAX_NAME_CHARS} Zeichen)"
+        ));
+    }
+    Ok(name.to_string())
+}
+
+impl Library {
+    /// Ort von `library.json` im Basisordner der Notizbücher.
+    pub fn file_path(base_dir: &Path) -> PathBuf {
+        base_dir.join("library.json")
+    }
+
+    /// Lädt die Ordner; fehlt die Datei oder ist sie beschädigt, gibt es keine Ordner.
+    pub fn load(base_dir: &Path) -> Self {
+        let path = Self::file_path(base_dir);
+        let mut library: Self = match std::fs::read_to_string(&path) {
+            Ok(content) => serde_json::from_str(&content).unwrap_or_else(|e| {
+                eprintln!(
+                    "[Ordner] '{}' ist ungültig ({e}), alle Notizbücher auf oberster Ebene.",
+                    path.display()
+                );
+                Self::default()
+            }),
+            Err(_) => Self::default(),
+        };
+        library.repair();
+        library
+    }
+
+    /// Speichert die Ordner atomar.
+    pub fn save(&self, base_dir: &Path) -> Result<(), StorageError> {
+        storage::atomic_write_json(&Self::file_path(base_dir), self)
+    }
+
+    /// Macht eine (evtl. von Hand bearbeitete) Datei stimmig: leere oder ungültige Namen
+    /// fallen weg, jeder benutzte Ordner und seine übergeordneten Ordner existieren.
+    fn repair(&mut self) {
+        let valid = |path: &str| {
+            !path.is_empty()
+                && path
+                    .split('/')
+                    .all(|name| validate_name(name).as_deref() == Ok(name))
+        };
+        self.folders.retain(|f| valid(f));
+        self.notebooks.retain(|_, f| f.is_empty() || valid(f));
+        let used: Vec<String> = self
+            .folders
+            .iter()
+            .chain(self.notebooks.values())
+            .cloned()
+            .collect();
+        for mut folder in used {
+            while !folder.is_empty() {
+                let parent = parent_folder(&folder).to_string();
+                self.folders.insert(folder);
+                folder = parent;
+            }
+        }
+    }
+
+    /// Ordner, in dem das Notizbuch liegt.
+    pub fn folder_of(&self, notebook_id: &str) -> &str {
+        self.notebooks.get(notebook_id).map_or(ROOT, String::as_str)
+    }
+
+    /// Direkte Unterordner von `parent` (vollständige Pfade, nach Name sortiert).
+    pub fn subfolders(&self, parent: &str) -> Vec<&str> {
+        let mut list: Vec<&str> = self
+            .folders
+            .iter()
+            .map(String::as_str)
+            .filter(|f| parent_folder(f) == parent)
+            .collect();
+        list.sort_by_key(|f| folder_name(f).to_lowercase());
+        list
+    }
+
+    /// Alle Ordner in Baumreihenfolge (Eltern vor Kindern, Geschwister nach Name).
+    pub fn all_folders(&self) -> Vec<&str> {
+        let mut out = Vec::with_capacity(self.folders.len());
+        let mut stack: Vec<&str> = self.subfolders(ROOT).into_iter().rev().collect();
+        while let Some(folder) = stack.pop() {
+            out.push(folder);
+            stack.extend(self.subfolders(folder).into_iter().rev());
+        }
+        out
+    }
+
+    /// Legt in `parent` den Ordner `name` an und gibt seinen Pfad zurück.
+    pub fn create_folder(&mut self, parent: &str, name: &str) -> Result<String, String> {
+        let name = validate_name(name)?;
+        if !parent.is_empty() && !self.folders.contains(parent) {
+            return Err("Der übergeordnete Ordner existiert nicht mehr".to_string());
+        }
+        let path = join(parent, &name);
+        if !self.folders.insert(path.clone()) {
+            return Err(format!("Den Ordner „{name}“ gibt es hier schon"));
+        }
+        Ok(path)
+    }
+
+    /// Benennt einen Ordner um (mitsamt Unterordnern und Zuordnungen); gibt den neuen Pfad
+    /// zurück.
+    pub fn rename_folder(&mut self, path: &str, new_name: &str) -> Result<String, String> {
+        let new_name = validate_name(new_name)?;
+        if !self.folders.contains(path) {
+            return Err("Den Ordner gibt es nicht mehr".to_string());
+        }
+        let new_path = join(parent_folder(path), &new_name);
+        if new_path == path {
+            return Ok(new_path);
+        }
+        if self.folders.contains(&new_path) {
+            return Err(format!("Den Ordner „{new_name}“ gibt es hier schon"));
+        }
+        self.move_contents(path, &new_path);
+        Ok(new_path)
+    }
+
+    /// Löscht einen Ordner. Seine Notizbücher und Unterordner rücken eine Ebene nach oben
+    /// (gleichnamige Unterordner werden zusammengelegt) – gelöscht wird kein Notizbuch.
+    pub fn delete_folder(&mut self, path: &str) {
+        if path.is_empty() || !self.folders.remove(path) {
+            return;
+        }
+        let parent = parent_folder(path).to_string();
+        let prefix = format!("{path}/");
+        let moved: Vec<String> = self
+            .folders
+            .iter()
+            .filter(|f| f.starts_with(&prefix))
+            .cloned()
+            .collect();
+        for folder in moved {
+            self.folders.remove(&folder);
+            self.folders.insert(join(&parent, &folder[prefix.len()..]));
+        }
+        for folder in self.notebooks.values_mut() {
+            if folder == path {
+                *folder = parent.clone();
+            } else if let Some(rest) = folder.strip_prefix(&prefix) {
+                *folder = join(&parent, rest);
+            }
+        }
+        self.notebooks.retain(|_, f| !f.is_empty());
+    }
+
+    /// Verschiebt einen Ordner samt Inhalt nach `new_path`.
+    fn move_contents(&mut self, path: &str, new_path: &str) {
+        let renamed = |f: &str| format!("{new_path}{}", &f[path.len()..]);
+        let moved: Vec<String> = self
+            .folders
+            .iter()
+            .filter(|f| is_within(f, path))
+            .cloned()
+            .collect();
+        for folder in moved {
+            self.folders.remove(&folder);
+            self.folders.insert(renamed(&folder));
+        }
+        for folder in self.notebooks.values_mut() {
+            if is_within(folder, path) {
+                *folder = renamed(folder);
+            }
+        }
+    }
+
+    /// Verschiebt einen Ordner samt Inhalt nach `new_parent` (oberste Ebene: [`ROOT`]) und
+    /// gibt seinen neuen Pfad zurück. Nicht in sich selbst oder einen eigenen Unterordner.
+    pub fn move_folder(&mut self, path: &str, new_parent: &str) -> Result<String, String> {
+        if !self.folders.contains(path) {
+            return Err("Den Ordner gibt es nicht mehr".to_string());
+        }
+        if !new_parent.is_empty() && !self.folders.contains(new_parent) {
+            return Err("Den Zielordner gibt es nicht mehr".to_string());
+        }
+        if is_within(new_parent, path) {
+            return Err("Ein Ordner kann nicht in sich selbst verschoben werden".to_string());
+        }
+        let name = folder_name(path);
+        let new_path = join(new_parent, name);
+        if new_path == path {
+            return Ok(new_path);
+        }
+        if self.folders.contains(&new_path) {
+            return Err(format!("Im Zielordner gibt es schon einen Ordner „{name}“"));
+        }
+        self.move_contents(path, &new_path);
+        Ok(new_path)
+    }
+
+    /// Mögliche Ziele für das Verschieben des Ordners `path`: alle Ordner außer ihm selbst und
+    /// seinen Unterordnern (die oberste Ebene ist immer ein Ziel).
+    pub fn folder_move_targets(&self, path: &str) -> Vec<&str> {
+        self.all_folders()
+            .into_iter()
+            .filter(|f| !is_within(f, path))
+            .collect()
+    }
+
+    /// Legt das Notizbuch in `folder` (oberste Ebene: [`ROOT`]).
+    pub fn move_notebook(&mut self, notebook_id: &str, folder: &str) -> Result<(), String> {
+        if folder.is_empty() {
+            self.notebooks.remove(notebook_id);
+            return Ok(());
+        }
+        if !self.folders.contains(folder) {
+            return Err("Den Ordner gibt es nicht mehr".to_string());
+        }
+        self.notebooks
+            .insert(notebook_id.to_string(), folder.to_string());
+        Ok(())
+    }
+
+    /// Wie viele der Notizbücher `ids` in `folder` liegen, Unterordner eingeschlossen.
+    pub fn count_within<'a>(&self, folder: &str, ids: impl IntoIterator<Item = &'a str>) -> usize {
+        ids.into_iter()
+            .filter(|id| is_within(self.folder_of(id), folder))
+            .count()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn library() -> Library {
+        let mut lib = Library::default();
+        let sem3 = lib.create_folder(ROOT, "3. Semester").unwrap();
+        let mathe = lib.create_folder(&sem3, "Mathe").unwrap();
+        lib.create_folder(&sem3, "Physik").unwrap();
+        lib.move_notebook("analysis", &mathe).unwrap();
+        lib.move_notebook("uebung", &sem3).unwrap();
+        lib
+    }
+
+    #[test]
+    fn test_paths_and_names() {
+        assert_eq!(folder_name("3. Semester/Mathe"), "Mathe");
+        assert_eq!(folder_name("Mathe"), "Mathe");
+        assert_eq!(parent_folder("3. Semester/Mathe"), "3. Semester");
+        assert_eq!(parent_folder("Mathe"), ROOT);
+        assert_eq!(validate_name("  Mathe  ").unwrap(), "Mathe");
+        assert!(validate_name("   ").is_err());
+        assert!(validate_name("a/b").is_err());
+        assert!(validate_name(&"x".repeat(81)).is_err());
+    }
+
+    #[test]
+    fn test_create_and_list_folders() {
+        let mut lib = library();
+        assert_eq!(lib.subfolders(ROOT), ["3. Semester"]);
+        assert_eq!(
+            lib.subfolders("3. Semester"),
+            ["3. Semester/Mathe", "3. Semester/Physik"]
+        );
+        assert_eq!(
+            lib.all_folders(),
+            ["3. Semester", "3. Semester/Mathe", "3. Semester/Physik"]
+        );
+        assert_eq!(lib.folder_of("analysis"), "3. Semester/Mathe");
+        assert_eq!(lib.folder_of("unbekannt"), ROOT);
+        // Doppelte Namen und fehlende Eltern werden abgelehnt
+        assert!(lib.create_folder("3. Semester", " Mathe ").is_err());
+        assert!(lib.create_folder("Gibt es nicht", "X").is_err());
+        // Gleicher Name in einem anderen Ordner ist erlaubt
+        lib.create_folder(ROOT, "4. Semester").unwrap();
+        assert!(lib.create_folder("4. Semester", "Mathe").is_ok());
+        assert_eq!(
+            lib.count_within("3. Semester", ["analysis", "uebung", "lose"]),
+            2
+        );
+    }
+
+    #[test]
+    fn test_rename_folder_keeps_contents() {
+        let mut lib = library();
+        let new = lib.rename_folder("3. Semester", "WS 25-26").unwrap();
+        assert_eq!(new, "WS 25-26");
+        assert_eq!(lib.folder_of("analysis"), "WS 25-26/Mathe");
+        assert_eq!(lib.folder_of("uebung"), "WS 25-26");
+        assert!(lib.folders.contains("WS 25-26/Physik"));
+        assert!(!lib.folders.iter().any(|f| f.starts_with("3. Semester")));
+        // Ein Ordner mit ähnlichem Namen bleibt unberührt
+        let mut lib = library();
+        lib.create_folder(ROOT, "3. Semester alt").unwrap();
+        lib.rename_folder("3. Semester", "Drei").unwrap();
+        assert!(lib.folders.contains("3. Semester alt"));
+        // Kollision
+        assert!(lib.rename_folder("Drei", "3. Semester alt").is_err());
+    }
+
+    #[test]
+    fn test_delete_folder_moves_contents_up() {
+        let mut lib = library();
+        lib.delete_folder("3. Semester");
+        assert_eq!(lib.folder_of("analysis"), "Mathe");
+        assert_eq!(lib.folder_of("uebung"), ROOT);
+        assert!(!lib.notebooks.contains_key("uebung"));
+        assert_eq!(lib.subfolders(ROOT), ["Mathe", "Physik"]);
+    }
+
+    #[test]
+    fn test_move_folder() {
+        let mut lib = library();
+        lib.create_folder(ROOT, "Mathe-Sammlung").unwrap();
+        // Ordner samt Inhalt in einen anderen Ordner schieben
+        let new = lib
+            .move_folder("3. Semester/Mathe", "Mathe-Sammlung")
+            .unwrap();
+        assert_eq!(new, "Mathe-Sammlung/Mathe");
+        assert_eq!(lib.folder_of("analysis"), "Mathe-Sammlung/Mathe");
+        assert!(!lib.folders.contains("3. Semester/Mathe"));
+        // Auf die oberste Ebene und zurück
+        assert_eq!(
+            lib.move_folder("Mathe-Sammlung/Mathe", ROOT).unwrap(),
+            "Mathe"
+        );
+        assert_eq!(
+            lib.move_folder("Mathe", "3. Semester").unwrap(),
+            "3. Semester/Mathe"
+        );
+        // Nicht in sich selbst oder in einen eigenen Unterordner
+        assert!(lib.move_folder("3. Semester", "3. Semester").is_err());
+        assert!(lib.move_folder("3. Semester", "3. Semester/Mathe").is_err());
+        assert_eq!(lib.folder_move_targets("3. Semester"), ["Mathe-Sammlung"]);
+        // Namenskollision am Ziel
+        lib.create_folder("Mathe-Sammlung", "Physik").unwrap();
+        assert!(lib
+            .move_folder("3. Semester/Physik", "Mathe-Sammlung")
+            .is_err());
+        assert_eq!(lib.folder_of("uebung"), "3. Semester");
+    }
+
+    #[test]
+    fn test_move_notebook() {
+        let mut lib = library();
+        lib.move_notebook("uebung", "3. Semester/Physik").unwrap();
+        assert_eq!(lib.folder_of("uebung"), "3. Semester/Physik");
+        lib.move_notebook("uebung", ROOT).unwrap();
+        assert_eq!(lib.folder_of("uebung"), ROOT);
+        assert!(lib.move_notebook("uebung", "Gibt es nicht").is_err());
+    }
+
+    #[test]
+    fn test_load_save_and_repair() {
+        let dir = tempfile::tempdir().unwrap();
+        // Fehlende Datei: keine Ordner
+        assert_eq!(Library::load(dir.path()), Library::default());
+
+        let lib = library();
+        lib.save(dir.path()).unwrap();
+        assert_eq!(Library::load(dir.path()), lib);
+
+        // Beschädigt: alles auf oberster Ebene statt Absturz
+        std::fs::write(Library::file_path(dir.path()), b"{ kaputt").unwrap();
+        assert_eq!(Library::load(dir.path()), Library::default());
+
+        // Von Hand bearbeitet: fehlende Elternordner werden ergänzt, Unsinn fällt weg
+        std::fs::write(
+            Library::file_path(dir.path()),
+            br#"{"folders": ["A/B", "", "C//D"], "notebooks": {"x": "E/F", "y": "/kaputt"}}"#,
+        )
+        .unwrap();
+        let lib = Library::load(dir.path());
+        assert_eq!(lib.all_folders(), ["A", "A/B", "E", "E/F"]);
+        assert_eq!(lib.folder_of("x"), "E/F");
+        assert_eq!(lib.folder_of("y"), ROOT);
+    }
+}

src/main.rs

@@ -24,16 +24,75 @@ 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::image_layer::TextureSource;
+use ink_notes::library::Library;
 use ink_notes::pdf_doc::PdfRenderService;
 use ink_notes::platform::{self, DisplayBackend};
 use ink_notes::selection::{
     render_selection_overlay, DragMode, SelectionHandleHit, SelectionState,
 };
-use ink_notes::settings::{SidebarSide, UiSettings};
+use ink_notes::settings::{
+    SidebarSide, StylusAction, StylusButton, UiSettings, MAX_STYLUS_BUTTONS,
+};
 use ink_notes::storage::{self, NotebookManifest};
 use ink_notes::ui::{self, ActiveTool, UiAction, UiState};
 use ink_notes::updater::UpdaterController;
 
+/// Wählt `tool` und stellt Farbe und Stärke des Live-Strichs passend ein.
+fn activate_tool(tool: ActiveTool, ui_state: &mut UiState, canvas: &mut CanvasState) {
+    ui_state.active_tool = tool;
+    match tool {
+        ActiveTool::Pen | ActiveTool::Shape => {
+            canvas.set_stroke_color(ui_state.pen_color);
+            canvas.set_stroke_width_mm(ui_state.pen_stroke_width_mm);
+        }
+        ActiveTool::Highlighter => {
+            canvas.set_stroke_color(ui_state.highlighter_color);
+            canvas.set_stroke_width_mm(ui_state.highlighter_stroke_width_mm);
+        }
+        ActiveTool::Eraser | ActiveTool::Select | ActiveTool::Text => {}
+    }
+}
+
+/// Kennung einer Stifttaste, die über Programmstarts hinweg gleich bleibt (die Tablet-
+/// Schnittstelle liefert nur eine undurchsichtige, aber vergleichbare Kennung).
+fn stylus_button_key(id: &octotablet::tool::ButtonID) -> u64 {
+    use std::hash::{Hash, Hasher};
+    // DefaultHasher::new() verwendet feste Schlüssel: gleiche Taste, gleicher Wert
+    let mut hasher = std::collections::hash_map::DefaultHasher::new();
+    id.hash(&mut hasher);
+    hasher.finish()
+}
+
+/// Liest Notizbücher und Ordner für den Dokumenten-Manager neu ein.
+fn refresh_notebooks(base_dir: &Path, ui_state: &mut UiState) {
+    ui_state.available_notebooks = storage::list_notebooks(base_dir);
+    ui_state.library = Library::load(base_dir);
+}
+
+/// Ändert die Ordner (`library.json`) und liest sie neu ein; Fehler erscheinen als Meldung.
+/// Gibt bei Erfolg das Ergebnis von `change` zurück.
+fn change_library<T>(
+    base_dir: &Path,
+    ui_state: &mut UiState,
+    change: impl FnOnce(&mut Library) -> Result<T, String>,
+) -> Option<T> {
+    let mut library = Library::load(base_dir);
+    let result = change(&mut library).and_then(|value| {
+        library
+            .save(base_dir)
+            .map(|()| value)
+            .map_err(|e| format!("Ordner nicht gespeichert: {e}"))
+    });
+    ui_state.library = Library::load(base_dir);
+    match result {
+        Ok(value) => Some(value),
+        Err(message) => {
+            ui_state.set_export_message(message);
+            None
+        }
+    }
+}
+
 /// 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) {
@@ -1027,10 +1086,17 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
             "[Storage] Erstelle neues Notizbuch in: {}",
             storage_dir.display()
         );
-        (
-            Notebook::new(),
-            NotebookManifest::new(&initial_id, &initial_title),
-        )
+        let notebook = Notebook::new();
+        let mut manifest = NotebookManifest::new(&initial_id, &initial_title);
+        // Ganz neu (z. B. erster Start): sofort speichern, sonst steht es bis zur ersten
+        // Änderung ohne Manifest als „beschädigt“ in der Notizbuchliste. Ein vorhandener
+        // Ordner ohne Manifest bleibt unangetastet.
+        if !storage_dir.exists() {
+            if let Err(err) = storage::save_notebook(&storage_dir, &notebook, &mut manifest) {
+                eprintln!("[Storage] Neues Notizbuch nicht gespeichert: {err}");
+            }
+        }
+        (notebook, manifest)
     };
 
     // 2. Asynchronen Autosave-Controller mit 1.5s Debounce starten
@@ -1069,6 +1135,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     ui_state.pressure_curve = ui_settings.pressure_curve;
     ui_state.continuous_scroll = ui_settings.continuous_scroll;
     ui_state.pen_presets = ui_settings.pen_presets;
+    ui_state.stylus_buttons = ui_settings.stylus_buttons.clone();
     ui_state.select_pen(ui_settings.active_pen);
     ui_state.highlighter_colors = ui_settings.highlighter_colors;
     ui_state.select_highlighter_color(ui_settings.active_highlighter);
@@ -1078,8 +1145,9 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     ui_state.current_notebook_id = manifest.id.clone();
     ui_state.document_title = manifest.title.clone();
     ui_state.available_notebooks = available_notebooks;
+    ui_state.library = Library::load(&storage_base_dir);
     if let Some(warning) = startup_warning {
-        ui_state.available_notebooks = storage::list_notebooks(&storage_base_dir);
+        refresh_notebooks(&storage_base_dir, &mut ui_state);
         ui_state.set_export_message(warning);
     }
     let mut selection_state = SelectionState::new();
@@ -1147,7 +1215,10 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     let mut is_stylus_selecting = false;
     let mut is_stylus_in_proximity = false;
     let mut stylus_tool_id: Option<octotablet::tool::ID> = None;
-    let mut stylus_barrel_pressed = false;
+    // Gedrückte Stifttaste (Kennung, Belegung) und das Werkzeug, das während eines Strichs mit
+    // einer Werkzeug-Taste (Auswählen, Textmarker, Stift) vertreten wird
+    let mut stylus_held: Option<(u64, StylusAction)> = None;
+    let mut tool_before_button: Option<ActiveTool> = None;
     let mut stylus_screen_pos = (0.0_f32, 0.0_f32);
     // Stift hat auf der UI aufgesetzt: alle Ereignisse bis zum Abheben gehen an egui
     let mut stylus_ui_capture = false;
@@ -1268,6 +1339,12 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                     if let Ok(tablet_events) = mgr.pump() {
                         let scale = window.scale_factor() as f32;
                         let now = start_time.elapsed().as_secs_f64();
+                        // Aufsetzen erst mit der Position desselben Frames verarbeiten
+                        let tablet_events = ink_notes::platform::down_after_pose(
+                            tablet_events,
+                            |e| matches!(e, octotablet::events::Event::Tool { event: octotablet::events::ToolEvent::Down, .. }),
+                            |e| matches!(e, octotablet::events::Event::Tool { event: octotablet::events::ToolEvent::Pose(_), .. }),
+                        );
 
                         for t_event in tablet_events {
                             if let octotablet::events::Event::Tool { tool, event } = t_event {
@@ -1318,23 +1395,45 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                                 selection_release(false, &mut notebook, &mut manifest, &mut autosave, &mut selection_state);
                                                 window.request_redraw();
                                             }
+                                            if let Some(tool) = tool_before_button.take() {
+                                                activate_tool(tool, &mut ui_state, &mut canvas);
+                                            }
+                                            stylus_held = None;
+                                            ui_state.pressed_stylus_button = None;
                                         }
                                     }
-                                    octotablet::events::ToolEvent::Button { pressed, .. } => {
-                                        stylus_barrel_pressed = pressed;
-                                        if pressed && is_stylus_drawing {
-                                            is_stylus_drawing = false;
-                                            is_drawing = false;
-                                            canvas.cancel_stroke();
-                                            is_erasing = true;
-                                            window.request_redraw();
-                                        } else if !pressed
-                                            && is_erasing
-                                            && !tool_is_hardware_eraser
-                                            && ui_state.active_tool != ActiveTool::Eraser
-                                        {
-                                            is_erasing = false;
+                                    octotablet::events::ToolEvent::Button { button_id, pressed } => {
+                                        // Tasten werden beim ersten Drücken gelernt (Standard: Radieren)
+                                        let key = stylus_button_key(&button_id);
+                                        let mut index = ui_state.stylus_buttons.iter().position(|b| b.id == key);
+                                        if index.is_none() && pressed && ui_state.stylus_buttons.len() < MAX_STYLUS_BUTTONS {
+                                            ui_state.stylus_buttons.push(StylusButton { id: key, action: StylusAction::Erase });
+                                            index = Some(ui_state.stylus_buttons.len() - 1);
+                                            ui_settings.stylus_buttons = ui_state.stylus_buttons.clone();
+                                            save_ui_settings(&ui_settings, ui_settings_path.as_deref(), &mut ui_state);
                                         }
+                                        let action = index.map_or(StylusAction::Erase, |i| ui_state.stylus_buttons[i].action);
+                                        if pressed {
+                                            stylus_held = Some((key, action));
+                                            ui_state.pressed_stylus_button = index;
+                                            if action == StylusAction::Erase && is_stylus_drawing {
+                                                is_stylus_drawing = false;
+                                                is_drawing = false;
+                                                canvas.cancel_stroke();
+                                                is_erasing = true;
+                                            }
+                                        } else if stylus_held.is_some_and(|(held, _)| held == key) {
+                                            stylus_held = None;
+                                            ui_state.pressed_stylus_button = None;
+                                            if action == StylusAction::Erase
+                                                && is_erasing
+                                                && !tool_is_hardware_eraser
+                                                && ui_state.active_tool != ActiveTool::Eraser
+                                            {
+                                                is_erasing = false;
+                                            }
+                                        }
+                                        window.request_redraw();
                                     }
                                     octotablet::events::ToolEvent::Pose(pose) => {
                                         is_stylus_in_proximity = true;
@@ -1432,8 +1531,22 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                         }
 
                                         focus_page_at!((sx, sy));
+                                        // Werkzeug-Taste gedrückt: für diesen Strich dieses Werkzeug
+                                        let button_action = stylus_held.map(|(_, action)| action);
+                                        let button_tool = match button_action {
+                                            Some(StylusAction::Select) => Some(ActiveTool::Select),
+                                            Some(StylusAction::Highlighter) => Some(ActiveTool::Highlighter),
+                                            Some(StylusAction::Pen) => Some(ActiveTool::Pen),
+                                            _ => None,
+                                        };
+                                        if let Some(tool) = button_tool
+                                            .filter(|&t| !tool_is_hardware_eraser && t != ui_state.active_tool)
+                                        {
+                                            tool_before_button = Some(ui_state.active_tool);
+                                            activate_tool(tool, &mut ui_state, &mut canvas);
+                                        }
                                         let should_erase = tool_is_hardware_eraser
-                                            || stylus_barrel_pressed
+                                            || button_action == Some(StylusAction::Erase)
                                             || ui_state.active_tool == ActiveTool::Eraser;
 
                                         if !should_erase && ui_state.active_tool == ActiveTool::Text {
@@ -1511,6 +1624,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                                 window.request_redraw();
                                             }
                                         }
+                                        let restore_tool = tool_before_button.take();
 
                                         if is_stylus_drawing {
                                             is_stylus_drawing = false;
@@ -1545,6 +1659,11 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                                 snapped_shape,
                                             );
                                         }
+                                        // Nach einem Strich mit Werkzeug-Taste wieder das gewählte Werkzeug
+                                        if let Some(tool) = restore_tool {
+                                            activate_tool(tool, &mut ui_state, &mut canvas);
+                                            window.request_redraw();
+                                        }
                                     }
                                     _ => {}
                                 }
@@ -2692,22 +2811,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                         for action in actions {
                             match action {
                                 UiAction::SetTool(tool) => {
-                                    ui_state.active_tool = tool;
-                                    match tool {
-                                        ActiveTool::Pen => {
-                                            canvas.set_stroke_color(ui_state.pen_color);
-                                            canvas.set_stroke_width_mm(ui_state.pen_stroke_width_mm);
-                                        }
-                                        ActiveTool::Highlighter => {
-                                            canvas.set_stroke_color(ui_state.highlighter_color);
-                                            canvas.set_stroke_width_mm(ui_state.highlighter_stroke_width_mm);
-                                        }
-                                        ActiveTool::Shape => {
-                                            canvas.set_stroke_color(ui_state.pen_color);
-                                            canvas.set_stroke_width_mm(ui_state.pen_stroke_width_mm);
-                                        }
-                                        ActiveTool::Eraser | ActiveTool::Select | ActiveTool::Text => {}
-                                    }
+                                    activate_tool(tool, &mut ui_state, &mut canvas);
                                     update_window_title(&window, &notebook, &manifest, tool, autosave.status());
                                     window.request_redraw();
                                 }
@@ -2969,8 +3073,81 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                     window.request_redraw();
                                 }
 
+                                UiAction::CreateFolder { parent, name } => {
+                                    if let Some(path) = change_library(&storage_base_dir, &mut ui_state, |library| {
+                                        library.create_folder(&parent, &name)
+                                    }) {
+                                        ui_state.set_export_message(format!(
+                                            "Ordner „{}“ angelegt",
+                                            ink_notes::library::folder_name(&path)
+                                        ));
+                                    }
+                                    window.request_redraw();
+                                }
+                                UiAction::RenameFolder { path, new_name } => {
+                                    if let Some(new_path) = change_library(&storage_base_dir, &mut ui_state, |library| {
+                                        library.rename_folder(&path, &new_name)
+                                    }) {
+                                        // Der gezeigte Ordner kann darin liegen
+                                        let shown = &ui_state.notebook_folder;
+                                        if shown == &path || shown.starts_with(&format!("{path}/")) {
+                                            ui_state.notebook_folder = format!("{new_path}{}", &shown[path.len()..]);
+                                        }
+                                    }
+                                    window.request_redraw();
+                                }
+                                UiAction::DeleteFolder(path) => {
+                                    if change_library(&storage_base_dir, &mut ui_state, |library| {
+                                        library.delete_folder(&path);
+                                        Ok(())
+                                    })
+                                    .is_some()
+                                    {
+                                        ui_state.set_export_message(format!(
+                                            "Ordner „{}“ gelöscht, sein Inhalt liegt eine Ebene höher",
+                                            ink_notes::library::folder_name(&path)
+                                        ));
+                                    }
+                                    window.request_redraw();
+                                }
+                                UiAction::MoveFolder { path, new_parent } => {
+                                    if let Some(new_path) = change_library(&storage_base_dir, &mut ui_state, |library| {
+                                        library.move_folder(&path, &new_parent)
+                                    }) {
+                                        // Der gezeigte Ordner kann darin liegen
+                                        let shown = &ui_state.notebook_folder;
+                                        if shown == &path || shown.starts_with(&format!("{path}/")) {
+                                            ui_state.notebook_folder = format!("{new_path}{}", &shown[path.len()..]);
+                                        }
+                                        let target = if new_parent.is_empty() {
+                                            "die oberste Ebene".to_string()
+                                        } else {
+                                            format!("„{}“", ink_notes::library::folder_name(&new_parent))
+                                        };
+                                        ui_state.set_export_message(format!(
+                                            "Ordner „{}“ verschoben in {target}",
+                                            ink_notes::library::folder_name(&path)
+                                        ));
+                                    }
+                                    window.request_redraw();
+                                }
+                                UiAction::MoveNotebook { id, folder } => {
+                                    if change_library(&storage_base_dir, &mut ui_state, |library| {
+                                        library.move_notebook(&id, &folder)
+                                    })
+                                    .is_some()
+                                    {
+                                        let target = if folder.is_empty() {
+                                            "die oberste Ebene".to_string()
+                                        } else {
+                                            format!("„{}“", ink_notes::library::folder_name(&folder))
+                                        };
+                                        ui_state.set_export_message(format!("Verschoben in {target}"));
+                                    }
+                                    window.request_redraw();
+                                }
                                 UiAction::RefreshNotebooks => {
-                                    ui_state.available_notebooks = storage::list_notebooks(&storage_base_dir);
+                                    refresh_notebooks(&storage_base_dir, &mut ui_state);
                                     window.request_redraw();
                                 }
                                 UiAction::OpenNotebook(id) => {
@@ -3006,7 +3183,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                                 selection_state.clear();
                                                 ui_state.current_notebook_id = manifest.id.clone();
                                                 ui_state.document_title = manifest.title.clone();
-                                                ui_state.available_notebooks = storage::list_notebooks(&storage_base_dir);
+                                                refresh_notebooks(&storage_base_dir, &mut ui_state);
                                                 ui_state.is_document_menu_open = false;
                                                 canvas.sync_page(notebook.current_page_mut());
                                                 update_window_title(&window, &notebook, &manifest, ui_state.active_tool, autosave.status());
@@ -3023,6 +3200,8 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                     }
                                 }
                                 UiAction::ImportPdf(path) => {
+                                    // Neben das gerade geöffnete Notizbuch
+                                    let folder = ui_state.library.folder_of(&manifest.id).to_string();
                                     let title = path
                                         .file_stem()
                                         .map(|s| s.to_string_lossy().into_owned())
@@ -3032,6 +3211,10 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                         .and_then(|bytes| storage::create_notebook_from_pdf(&storage_base_dir, &title, bytes));
                                     match result {
                                         Ok((new_nb, new_manifest, new_dir)) => {
+                                            let id = new_manifest.id.clone();
+                                            change_library(&storage_base_dir, &mut ui_state, |library| {
+                                                library.move_notebook(&id, &folder)
+                                            });
                                             let _ = autosave.flush();
                                             _notebook_lock = storage::NotebookLock::acquire(&new_dir).ok();
                                             autosave.set_read_only(_notebook_lock.is_none());
@@ -3042,7 +3225,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                             selection_state.clear();
                                             ui_state.current_notebook_id = manifest.id.clone();
                                             ui_state.document_title = manifest.title.clone();
-                                            ui_state.available_notebooks = storage::list_notebooks(&storage_base_dir);
+                                            refresh_notebooks(&storage_base_dir, &mut ui_state);
                                             canvas.reset_view();
                                             canvas.sync_page(notebook.current_page_mut());
                                             update_window_title(&window, &notebook, &manifest, ui_state.active_tool, autosave.status());
@@ -3059,10 +3242,14 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                     }
                                     window.request_redraw();
                                 }
-                                UiAction::CreateNotebook(title) => {
+                                UiAction::CreateNotebook { title, folder } => {
                                     let _ = autosave.flush();
                                     match storage::create_new_notebook(&storage_base_dir, &title) {
                                         Ok((new_nb, new_manifest, new_dir)) => {
+                                            let id = new_manifest.id.clone();
+                                            change_library(&storage_base_dir, &mut ui_state, |library| {
+                                                library.move_notebook(&id, &folder)
+                                            });
                                             _notebook_lock = storage::NotebookLock::acquire(&new_dir).ok();
                                             autosave.set_read_only(_notebook_lock.is_none());
                                             autosave.switch_notebook_dir(new_dir.clone());
@@ -3072,7 +3259,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                             selection_state.clear();
                                             ui_state.current_notebook_id = manifest.id.clone();
                                             ui_state.document_title = manifest.title.clone();
-                                            ui_state.available_notebooks = storage::list_notebooks(&storage_base_dir);
+                                            refresh_notebooks(&storage_base_dir, &mut ui_state);
                                             ui_state.is_document_menu_open = false;
                                             canvas.sync_page(notebook.current_page_mut());
                                             update_window_title(&window, &notebook, &manifest, ui_state.active_tool, autosave.status());
@@ -3091,7 +3278,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                         match storage::rename_notebook(&target_dir, &mut manifest, &new_title) {
                                             Ok(()) => {
                                                 ui_state.document_title = manifest.title.clone();
-                                                ui_state.available_notebooks = storage::list_notebooks(&storage_base_dir);
+                                                refresh_notebooks(&storage_base_dir, &mut ui_state);
                                                 manifest.sync_from_notebook(&notebook);
                                                 autosave.mark_manifest_dirty(&manifest);
                                                 update_window_title(&window, &notebook, &manifest, ui_state.active_tool, autosave.status());
@@ -3108,7 +3295,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                         if let Ok(content) = std::fs::read_to_string(&manifest_path) {
                                             if let Ok(mut other_manifest) = serde_json::from_str::<NotebookManifest>(&content) {
                                                 let _ = storage::rename_notebook(&target_dir, &mut other_manifest, &new_title);
-                                                ui_state.available_notebooks = storage::list_notebooks(&storage_base_dir);
+                                                refresh_notebooks(&storage_base_dir, &mut ui_state);
                                                 ui_state.set_export_message(format!("Umbenannt in '{}'", new_title));
                                                 window.request_redraw();
                                             }
@@ -3133,7 +3320,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                     match storage::delete_notebook(&target_dir, &storage_base_dir) {
                                         Ok(trash_path) => {
                                             ui_state.last_deleted_notebook = Some((trash_path, deleted_title));
-                                            ui_state.available_notebooks = storage::list_notebooks(&storage_base_dir);
+                                            refresh_notebooks(&storage_base_dir, &mut ui_state);
                                             if is_current {
                                                 if let Some(first) = ui_state
                                                     .available_notebooks
@@ -3171,7 +3358,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                                     selection_state.clear();
                                                     ui_state.current_notebook_id = manifest.id.clone();
                                                     ui_state.document_title = manifest.title.clone();
-                                                    ui_state.available_notebooks = storage::list_notebooks(&storage_base_dir);
+                                                    refresh_notebooks(&storage_base_dir, &mut ui_state);
                                                     canvas.sync_page(notebook.current_page_mut());
                                                     update_window_title(&window, &notebook, &manifest, ui_state.active_tool, autosave.status());
                                                     ui_state.set_export_message("Standard-Notizbuch erstellt".to_string());
@@ -3191,7 +3378,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                     if let Some((trash_path, _title)) = ui_state.last_deleted_notebook.take() {
                                         match storage::restore_notebook_from_trash(&storage_base_dir, &trash_path) {
                                             Ok(_restored_dir) => {
-                                                ui_state.available_notebooks = storage::list_notebooks(&storage_base_dir);
+                                                refresh_notebooks(&storage_base_dir, &mut ui_state);
                                                 ui_state.set_export_message("Notizbuch wiederhergestellt".to_string());
                                                 window.request_redraw();
                                             }
@@ -3206,7 +3393,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                     let target_dir = storage_base_dir.join(&id);
                                     match storage::restore_manifest_from_backup(&target_dir) {
                                         Ok(()) => {
-                                            ui_state.available_notebooks = storage::list_notebooks(&storage_base_dir);
+                                            refresh_notebooks(&storage_base_dir, &mut ui_state);
                                             ui_state.set_export_message("Manifest aus Backup wiederhergestellt".to_string());
                                             window.request_redraw();
                                         }
@@ -3311,6 +3498,10 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                     save_ui_settings(&ui_settings, ui_settings_path.as_deref(), &mut ui_state);
                                     window.request_redraw();
                                 }
+                                UiAction::SaveStylusButtons => {
+                                    ui_settings.stylus_buttons = ui_state.stylus_buttons.clone();
+                                    save_ui_settings(&ui_settings, ui_settings_path.as_deref(), &mut ui_state);
+                                }
                                 UiAction::SavePressureCurve(curve) => {
                                     ui_settings.pressure_curve = curve;
                                     save_ui_settings(&ui_settings, ui_settings_path.as_deref(), &mut ui_state);

src/platform.rs

@@ -58,10 +58,62 @@ pub fn display_backend_from_env() -> DisplayBackend {
     )
 }
 
+/// Bringt die Ereignisse eines Tablet-Frames in eine brauchbare Reihenfolge: octotablet meldet
+/// das Aufsetzen des Stifts (`Down`) vor der Position desselben Frames (`Pose`). Bis dahin
+/// gälte noch die alte Position – kam der Stift schnell heran (Annähern und Aufsetzen im selben
+/// Frame), läge sie ganz woanders: Ein Tippen auf einen Knopf ginge daneben, ein Strich begänne
+/// mit einer Linie von der alten Stelle. Hier folgt jedes `Down` auf die nächste `Pose`, spätestens
+/// vor dem nächsten anderen Ereignis.
+pub fn down_after_pose<T>(
+    events: impl IntoIterator<Item = T>,
+    is_down: impl Fn(&T) -> bool,
+    is_pose: impl Fn(&T) -> bool,
+) -> Vec<T> {
+    let mut ordered = Vec::new();
+    let mut deferred = None;
+    for event in events {
+        if is_down(&event) {
+            if let Some(down) = deferred.replace(event) {
+                ordered.push(down);
+            }
+            continue;
+        }
+        let pose = is_pose(&event);
+        if !pose {
+            ordered.extend(deferred.take());
+        }
+        ordered.push(event);
+        if pose {
+            ordered.extend(deferred.take());
+        }
+    }
+    ordered.extend(deferred);
+    ordered
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
 
+    #[test]
+    fn test_down_follows_pose_of_its_frame() {
+        let order = |events: &str| {
+            down_after_pose(events.chars(), |c| *c == 'D', |c| *c == 'P')
+                .into_iter()
+                .collect::<String>()
+        };
+        // In, Down, Pose, Button, Frame  ->  Down erst mit der neuen Position
+        assert_eq!(order("IDPBF"), "IPDBF");
+        // Down ohne Pose im Frame: vor dem Frame-Ende
+        assert_eq!(order("DF"), "DF");
+        assert_eq!(order("DBF"), "DBF");
+        // Am Ende ohne weiteres Ereignis
+        assert_eq!(order("PD"), "PD");
+        // Andere Ereignisse bleiben unverändert
+        assert_eq!(order("PFPFUF"), "PFPFUF");
+        assert_eq!(order("IDPFPFUF"), "IPDFPFUF");
+    }
+
     #[test]
     fn test_choose_display_backend() {
         // WSL mit X11-Display: X11 (Wayland unter WSLg bricht ab)

src/settings.rs

@@ -150,6 +150,53 @@ fn sanitized_color(color: [f32; 4], fallback: [f32; 4]) -> [f32; 4] {
     out
 }
 
+/// Was eine Taste am Stift bewirkt, solange sie gedrückt ist.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
+pub enum StylusAction {
+    /// Radieren (Standard, wie bisher)
+    #[default]
+    Erase,
+    /// Auswählen und verschieben
+    Select,
+    /// Mit dem Textmarker schreiben
+    Highlighter,
+    /// Mit dem gewählten Stift schreiben (z. B. während der Textmarker aktiv ist)
+    Pen,
+    /// Taste nicht verwenden
+    Nothing,
+}
+
+impl StylusAction {
+    pub const ALL: [StylusAction; 5] = [
+        StylusAction::Erase,
+        StylusAction::Select,
+        StylusAction::Highlighter,
+        StylusAction::Pen,
+        StylusAction::Nothing,
+    ];
+
+    pub fn label(self) -> &'static str {
+        match self {
+            StylusAction::Erase => "Radieren",
+            StylusAction::Select => "Auswählen",
+            StylusAction::Highlighter => "Textmarker",
+            StylusAction::Pen => "Stift",
+            StylusAction::Nothing => "Nichts",
+        }
+    }
+}
+
+/// Eine Taste am Stift: Kennung (aus der Tablet-Schnittstelle, beim ersten Drücken gelernt)
+/// und ihre Belegung.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+pub struct StylusButton {
+    pub id: u64,
+    pub action: StylusAction,
+}
+
+/// Höchstens so viele Stifttasten werden gemerkt.
+pub const MAX_STYLUS_BUTTONS: usize = 4;
+
 /// Benutzereinstellungen der Oberfläche.
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[serde(default)]
@@ -173,6 +220,8 @@ pub struct UiSettings {
     pub active_highlighter: usize,
     pub text_colors: [[f32; 4]; 5],
     pub active_text_color: usize,
+    /// Tasten am Stift in der Reihenfolge, in der sie zuerst gedrückt wurden
+    pub stylus_buttons: Vec<StylusButton>,
 }
 
 impl Default for UiSettings {
@@ -190,6 +239,7 @@ impl Default for UiSettings {
             active_highlighter: 0,
             text_colors: DEFAULT_TEXT_COLORS,
             active_text_color: 0,
+            stylus_buttons: Vec::new(),
         }
     }
 }
@@ -237,6 +287,7 @@ impl UiSettings {
         settings.active_text_color = settings
             .active_text_color
             .min(settings.text_colors.len() - 1);
+        settings.stylus_buttons.truncate(MAX_STYLUS_BUTTONS);
         settings
     }
 
@@ -277,6 +328,16 @@ mod tests {
             active_highlighter: 3,
             text_colors: [[0.3, 0.1, 0.6, 1.0]; 5],
             active_text_color: 4,
+            stylus_buttons: vec![
+                StylusButton {
+                    id: 17,
+                    action: StylusAction::Select,
+                },
+                StylusButton {
+                    id: 42,
+                    action: StylusAction::Nothing,
+                },
+            ],
         };
         settings.save_to(&path).unwrap();
         assert_eq!(UiSettings::load_from(&path), settings);

src/ui.rs

@@ -171,6 +171,14 @@ impl LongPress {
     }
 }
 
+/// Was im Dokumenten-Manager gerade verschoben wird.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum MoveSubject {
+    Notebook(String),
+    /// Pfad des Ordners
+    Folder(String),
+}
+
 /// Kontextmenü nach langem Drücken auf das Blatt.
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub struct ContextMenu {
@@ -228,7 +236,31 @@ pub enum UiAction {
     RotateSelected,
     // Dokumenten- & Notizbuch-Verwaltung
     OpenNotebook(String),
-    CreateNotebook(String),
+    /// Neues Notizbuch im Ordner `folder` anlegen und öffnen
+    CreateNotebook {
+        title: String,
+        folder: String,
+    },
+    /// Ordnerverwaltung (siehe `library.rs`)
+    CreateFolder {
+        parent: String,
+        name: String,
+    },
+    RenameFolder {
+        path: String,
+        new_name: String,
+    },
+    /// Ordner löschen; Inhalt rückt eine Ebene nach oben
+    DeleteFolder(String),
+    MoveNotebook {
+        id: String,
+        folder: String,
+    },
+    /// Ordner samt Inhalt nach `new_parent` verschieben
+    MoveFolder {
+        path: String,
+        new_parent: String,
+    },
     RenameNotebook {
         id: String,
         new_title: String,
@@ -256,6 +288,8 @@ pub enum UiAction {
         theme: PaperTheme,
         adapt_ink: bool,
     },
+    /// Belegung der Stifttasten speichern (gilt sofort über `UiState::stylus_buttons`)
+    SaveStylusButtons,
     /// Druckkurve speichern (gilt während des Ziehens bereits über `UiState::pressure_curve`)
     SavePressureCurve(PressureCurve),
     /// Seiten durchgehend untereinander statt einzeln anzeigen (wird gespeichert)
@@ -306,6 +340,14 @@ pub struct UiState {
     pub available_notebooks: Vec<NotebookSummary>,
     pub new_notebook_title_input: String,
     pub renaming_notebook_id: Option<String>,
+    /// Ordner der Notizbücher und der gerade angezeigte Ordner im Dokumenten-Manager
+    pub library: crate::library::Library,
+    pub notebook_folder: String,
+    /// Ordner, der gerade umbenannt wird, bzw. dessen Löschen bestätigt werden soll
+    pub renaming_folder: Option<String>,
+    pub confirm_delete_folder: Option<String>,
+    /// Notizbuch oder Ordner, für das gerade ein Zielordner gewählt wird
+    pub moving: Option<MoveSubject>,
     pub renaming_title_input: String,
     pub document_modal_rect: Option<egui::Rect>,
     /// Gitea Release- & Update-Manager
@@ -336,6 +378,9 @@ pub struct UiState {
     pub show_color_picker: bool,
     /// Kontextmenü nach langem Drücken (Einfügen an dieser Stelle)
     pub context_menu: Option<ContextMenu>,
+    /// Tasten am Stift und ihre Belegung; die gerade gedrückte (Index) wird hervorgehoben
+    pub stylus_buttons: Vec<crate::settings::StylusButton>,
+    pub pressed_stylus_button: Option<usize>,
     /// Rückfrage „Seite löschen?“ im ☰-Menü ist offen
     pub confirm_delete_page: bool,
     /// Seitenzahl der zuletzt gelöschten Seite, solange sie wiederhergestellt werden kann
@@ -408,6 +453,11 @@ impl Default for UiState {
             available_notebooks: Vec::new(),
             new_notebook_title_input: String::new(),
             renaming_notebook_id: None,
+            library: crate::library::Library::default(),
+            notebook_folder: String::new(),
+            renaming_folder: None,
+            confirm_delete_folder: None,
+            moving: None,
             renaming_title_input: String::new(),
             document_modal_rect: None,
             is_update_dialog_open: false,
@@ -426,6 +476,8 @@ impl Default for UiState {
             is_text_color_menu_open: false,
             show_color_picker: false,
             context_menu: None,
+            stylus_buttons: Vec::new(),
+            pressed_stylus_button: None,
             confirm_delete_page: false,
             restorable_page: None,
             shutdown_error: None,
@@ -1590,6 +1642,70 @@ fn pattern_color_button(
 /// 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).
+/// Belegung der Tasten am Stift. Tasten erscheinen, sobald sie einmal gedrückt wurden; die
+/// gerade gedrückte ist markiert. `true`, wenn sich etwas geändert hat.
+fn stylus_buttons_editor(ui: &mut egui::Ui, state: &mut UiState) -> bool {
+    use crate::settings::StylusAction;
+    let mut changed = false;
+    ui.add_space(4.0);
+    ui.label(egui::RichText::new("Tasten am Stift").color(egui::Color32::from_gray(200)));
+    if state.stylus_buttons.is_empty() {
+        ui.label(
+            egui::RichText::new(
+                "Drücke eine Taste am Stift (über dem Bildschirm) – sie erscheint dann hier. \
+                 Bis dahin radieren alle Tasten.",
+            )
+            .size(11.0)
+            .color(egui::Color32::from_gray(150)),
+        );
+        return false;
+    }
+    let mut remove = None;
+    for i in 0..state.stylus_buttons.len() {
+        ui.horizontal(|ui| {
+            let pressed = state.pressed_stylus_button == Some(i);
+            let label = egui::RichText::new(format!("Taste {}", i + 1));
+            ui.label(if pressed {
+                label.strong().color(egui::Color32::from_rgb(46, 204, 113))
+            } else {
+                label
+            })
+            .on_hover_text("Leuchtet grün, solange die Taste gedrückt ist");
+            let current = state.stylus_buttons[i].action;
+            egui::ComboBox::from_id_source(("stylus_button", i))
+                .selected_text(current.label())
+                .width(130.0)
+                .show_ui(ui, |ui| {
+                    for action in StylusAction::ALL {
+                        if ui
+                            .selectable_label(action == current, action.label())
+                            .clicked()
+                            && action != current
+                        {
+                            state.stylus_buttons[i].action = action;
+                            changed = true;
+                        }
+                    }
+                });
+            if ui
+                .small_button("🗙")
+                .on_hover_text(
+                    "Vergessen (erscheint beim nächsten Drücken wieder, dann mit Radieren)",
+                )
+                .clicked()
+            {
+                remove = Some(i);
+            }
+        });
+    }
+    if let Some(i) = remove {
+        state.stylus_buttons.remove(i);
+        state.pressed_stylus_button = None;
+        changed = true;
+    }
+    changed
+}
+
 fn pressure_curve_editor(ui: &mut egui::Ui, state: &mut UiState) -> Option<PressureCurve> {
     let mut save = false;
     let mut track = |response: egui::Response| {
@@ -1670,6 +1786,240 @@ fn pressure_curve_editor(ui: &mut egui::Ui, state: &mut UiState) -> Option<Press
     save.then_some(state.pressure_curve)
 }
 
+/// Pfad des gezeigten Ordners im Dokumenten-Manager: „📚 Alle › 3. Semester › Mathe“, jeder
+/// Teil antippbar.
+fn folder_breadcrumbs(ui: &mut egui::Ui, state: &mut UiState, folder: &str) {
+    ui.horizontal_wrapped(|ui| {
+        ui.spacing_mut().item_spacing.x = 4.0;
+        let mut target = None;
+        if ui
+            .selectable_label(folder.is_empty(), egui::RichText::new("📚 Alle").size(13.0))
+            .clicked()
+        {
+            target = Some(String::new());
+        }
+        let mut path = String::new();
+        for name in folder.split('/').filter(|n| !n.is_empty()) {
+            ui.label(egui::RichText::new("›").color(egui::Color32::from_gray(140)));
+            if !path.is_empty() {
+                path.push('/');
+            }
+            path.push_str(name);
+            if ui
+                .selectable_label(path == folder, egui::RichText::new(name).size(13.0))
+                .clicked()
+            {
+                target = Some(path.clone());
+            }
+        }
+        if let Some(target) = target {
+            state.notebook_folder = target;
+            state.renaming_folder = None;
+            state.confirm_delete_folder = None;
+        }
+    });
+}
+
+/// Zeile eines Unterordners: antippen öffnet ihn; umbenennen und löschen (mit Rückfrage).
+fn folder_row(ui: &mut egui::Ui, state: &mut UiState, path: &str, actions: &mut Vec<UiAction>) {
+    let name = crate::library::folder_name(path);
+    if state.renaming_folder.as_deref() == Some(path) {
+        ui.horizontal(|ui| {
+            let edit = ui.add(
+                egui::TextEdit::singleline(&mut state.renaming_title_input)
+                    .margin(egui::vec2(8.0, 8.0))
+                    .desired_width(260.0),
+            );
+            if ui.button("✔").clicked()
+                || (edit.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter)))
+            {
+                actions.push(UiAction::RenameFolder {
+                    path: path.to_string(),
+                    new_name: state.renaming_title_input.trim().to_string(),
+                });
+                state.renaming_folder = None;
+            }
+            if ui.button("🗙").clicked() {
+                state.renaming_folder = None;
+            }
+        });
+        return;
+    }
+    if state.confirm_delete_folder.as_deref() == Some(path) {
+        egui::Frame::none()
+            .fill(egui::Color32::from_rgba_unmultiplied(170, 50, 45, 40))
+            .rounding(egui::Rounding::same(8.0))
+            .inner_margin(egui::Margin::symmetric(10.0, 8.0))
+            .show(ui, |ui| {
+                ui.vertical(|ui| {
+                    ui.add(
+                        egui::Label::new(format!(
+                    "Ordner „{name}“ löschen? Seine Notizbücher und Unterordner rücken eine \
+                     Ebene nach oben, gelöscht wird kein Notizbuch."
+                ))
+                        .wrap(true),
+                    );
+                    ui.horizontal(|ui| {
+                        if ui
+                            .button(
+                                egui::RichText::new("Ordner löschen").color(egui::Color32::WHITE),
+                            )
+                            .clicked()
+                        {
+                            actions.push(UiAction::DeleteFolder(path.to_string()));
+                            state.confirm_delete_folder = None;
+                        }
+                        if ui.button("Abbrechen").clicked() {
+                            state.confirm_delete_folder = None;
+                        }
+                    });
+                });
+            });
+        return;
+    }
+
+    let ids = state.available_notebooks.iter().map(|s| s.id.as_str());
+    let count = state.library.count_within(path, ids);
+    let mut open = false;
+    egui::Frame::none()
+        .fill(egui::Color32::from_rgba_unmultiplied(255, 255, 255, 8))
+        .stroke(egui::Stroke::new(
+            1.0_f32,
+            egui::Color32::from_rgba_unmultiplied(255, 255, 255, 16),
+        ))
+        .rounding(egui::Rounding::same(8.0))
+        .inner_margin(egui::Margin::symmetric(10.0, 8.0))
+        .show(ui, |ui| {
+            // Erst die Knöpfe (rechts), der Name füllt den Rest und öffnet den Ordner
+            ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+                if ui
+                    .button(
+                        egui::RichText::new("🗑")
+                            .size(16.0)
+                            .color(egui::Color32::from_rgb(255, 120, 120)),
+                    )
+                    .on_hover_text("Ordner löschen (die Notizbücher bleiben erhalten)")
+                    .clicked()
+                {
+                    state.confirm_delete_folder = Some(path.to_string());
+                }
+                if ui
+                    .button(egui::RichText::new("📂").size(16.0))
+                    .on_hover_text("Ordner samt Inhalt in einen anderen Ordner verschieben")
+                    .clicked()
+                {
+                    state.moving = Some(MoveSubject::Folder(path.to_string()));
+                }
+                if ui
+                    .button(egui::RichText::new("✏").size(16.0))
+                    .on_hover_text("Ordner umbenennen")
+                    .clicked()
+                {
+                    state.renaming_folder = Some(path.to_string());
+                    state.renaming_title_input = name.to_string();
+                }
+                let title_area = ui
+                    .with_layout(egui::Layout::left_to_right(egui::Align::Center), |ui| {
+                        ui.vertical(|ui| {
+                            ui.set_min_width(ui.available_width());
+                            ui.label(
+                                egui::RichText::new(format!("📁 {name}"))
+                                    .strong()
+                                    .size(13.0)
+                                    .color(egui::Color32::WHITE),
+                            );
+                            ui.label(
+                                egui::RichText::new(match count {
+                                    1 => "1 Notizbuch".to_string(),
+                                    n => format!("{n} Notizbücher"),
+                                })
+                                .size(11.0)
+                                .color(egui::Color32::from_gray(160)),
+                            );
+                        })
+                    })
+                    .inner;
+                open = title_area
+                    .response
+                    .interact(egui::Sense::click())
+                    .on_hover_cursor(egui::CursorIcon::PointingHand)
+                    .clicked();
+            });
+        });
+    if open {
+        state.notebook_folder = path.to_string();
+    }
+}
+
+/// Zielordner für das Verschieben eines Notizbuchs oder Ordners: oberste Ebene und alle
+/// Ordner als Baum (ein Ordner nicht in sich selbst oder seine Unterordner).
+fn move_target_list(
+    ui: &mut egui::Ui,
+    state: &mut UiState,
+    subject: &MoveSubject,
+    actions: &mut Vec<UiAction>,
+) {
+    let (title, current, folders) = match subject {
+        MoveSubject::Notebook(id) => (
+            state
+                .available_notebooks
+                .iter()
+                .find(|s| &s.id == id)
+                .map_or(id.as_str(), |s| s.title.as_str())
+                .to_string(),
+            state.library.folder_of(id).to_string(),
+            state.library.all_folders(),
+        ),
+        MoveSubject::Folder(path) => (
+            format!("📁 {}", crate::library::folder_name(path)),
+            crate::library::parent_folder(path).to_string(),
+            state.library.folder_move_targets(path),
+        ),
+    };
+    ui.label(egui::RichText::new(format!("„{title}“ verschieben nach:")).strong());
+    ui.add_space(4.0);
+    let mut targets = vec![(String::new(), "📚 Oberste Ebene".to_string(), 0)];
+    for path in folders {
+        let depth = path.matches('/').count() + 1;
+        targets.push((
+            path.to_string(),
+            format!("📁 {}", crate::library::folder_name(path)),
+            depth,
+        ));
+    }
+    egui::ScrollArea::vertical()
+        .max_height(300.0)
+        .show(ui, |ui| {
+            for (path, label, depth) in targets {
+                ui.horizontal(|ui| {
+                    ui.add_space(depth as f32 * 18.0);
+                    let here = path == current;
+                    if ui
+                        .add_enabled(!here, egui::Button::new(label))
+                        .on_disabled_hover_text("Liegt bereits hier")
+                        .clicked()
+                    {
+                        actions.push(match subject {
+                            MoveSubject::Notebook(id) => UiAction::MoveNotebook {
+                                id: id.clone(),
+                                folder: path.clone(),
+                            },
+                            MoveSubject::Folder(folder) => UiAction::MoveFolder {
+                                path: folder.clone(),
+                                new_parent: path.clone(),
+                            },
+                        });
+                        state.moving = None;
+                    }
+                });
+            }
+        });
+    ui.add_space(6.0);
+    if ui.button("Abbrechen").clicked() {
+        state.moving = None;
+    }
+}
+
 /// „Seite löschen“ mit Rückfrage im ☰-Menü und „Gelöschte Seite wiederherstellen“.
 fn delete_page_buttons(
     ui: &mut egui::Ui,
@@ -2288,6 +2638,14 @@ pub fn render_ui(
                                     state.close_overlays();
                                     state.is_document_menu_open = open;
                                     if open {
+                                        // Im Ordner des geöffneten Notizbuchs beginnen
+                                        state.notebook_folder = state
+                                            .library
+                                            .folder_of(&state.current_notebook_id)
+                                            .to_string();
+                                        state.renaming_folder = None;
+                                        state.confirm_delete_folder = None;
+                                        state.moving = None;
                                         actions.push(UiAction::RefreshNotebooks);
                                     }
                                 }
@@ -3273,6 +3631,9 @@ pub fn render_ui(
                             if let Some(curve) = pressure_curve_editor(ui, state) {
                                 actions.push(UiAction::SavePressureCurve(curve));
                             }
+                            if stylus_buttons_editor(ui, state) {
+                                actions.push(UiAction::SaveStylusButtons);
+                            }
 
                             section(ui, "WERKZEUGLEISTE");
                             ui.horizontal(|ui| {
@@ -3505,51 +3866,89 @@ pub fn render_ui(
                     state.is_document_menu_open = false;
                 }
 
-                // Neues Dokument anlegen
-                ui.label(
-                    egui::RichText::new("NEUES NOTIZBUCH ERSTELLEN")
-                        .size(10.5)
-                        .strong()
-                        .color(egui::Color32::from_gray(160)),
-                );
-                ui.add_space(4.0);
+                // Gezeigter Ordner (gibt es ihn nicht mehr, die oberste Ebene)
+                if !state.notebook_folder.is_empty()
+                    && !state.library.folders.contains(&state.notebook_folder)
+                {
+                    state.notebook_folder.clear();
+                }
+                let folder = state.notebook_folder.clone();
+                folder_breadcrumbs(ui, state, &folder);
+                ui.add_space(6.0);
+
+                // Neues Notizbuch oder neuer Ordner hier
                 ui.horizontal(|ui| {
                     let text_edit = ui.add(
                         egui::TextEdit::singleline(&mut state.new_notebook_title_input)
-                            .hint_text("Titel des neuen Notizbuchs …")
+                            .hint_text("Name …")
                             .margin(egui::vec2(8.0, 8.0))
-                            .desired_width(270.0),
+                            .desired_width(190.0),
                     );
-                    let create_btn = ui.button(egui::RichText::new("➕ Erstellen").strong());
-                    let submit = create_btn.clicked()
-                        || (text_edit.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter)));
-
-                    if submit {
-                        let title = state.new_notebook_title_input.trim();
-                        if !title.is_empty() {
-                            actions.push(UiAction::CreateNotebook(title.to_string()));
+                    let create_btn = ui
+                        .button(egui::RichText::new("➕ Notizbuch").strong())
+                        .on_hover_text("Neues Notizbuch in diesem Ordner anlegen und öffnen");
+                    let folder_btn = ui
+                        .button(egui::RichText::new("📁 Ordner").strong())
+                        .on_hover_text("Neuen Ordner hier anlegen (z. B. Semester oder Fach)");
+                    let title = state.new_notebook_title_input.trim().to_string();
+                    if !title.is_empty() {
+                        if create_btn.clicked()
+                            || (text_edit.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter)))
+                        {
+                            actions.push(UiAction::CreateNotebook {
+                                title,
+                                folder: folder.clone(),
+                            });
+                            state.new_notebook_title_input.clear();
+                        } else if folder_btn.clicked() {
+                            actions.push(UiAction::CreateFolder {
+                                parent: folder.clone(),
+                                name: title,
+                            });
                             state.new_notebook_title_input.clear();
                         }
                     }
                 });
 
-                ui.add_space(12.0);
-                ui.separator();
                 ui.add_space(8.0);
+                ui.separator();
+                ui.add_space(6.0);
 
-                // Liste vorhandener Dokumente
-                ui.label(
-                    egui::RichText::new("VORHANDENE DOKUMENTE")
-                        .size(10.5)
-                        .strong()
-                        .color(egui::Color32::from_gray(160)),
-                );
-                ui.add_space(4.0);
+                // Zielordner für „Verschieben“ wählen
+                if let Some(moving) = state.moving.clone() {
+                    move_target_list(ui, state, &moving, &mut actions);
+                    return;
+                }
 
-                egui::ScrollArea::vertical().max_height(260.0).show(ui, |ui| {
-                    for summary in &state.available_notebooks {
+                let summaries: Vec<NotebookSummary> = state
+                    .available_notebooks
+                    .iter()
+                    .filter(|s| state.library.folder_of(&s.id) == folder)
+                    .cloned()
+                    .collect();
+                let subfolders: Vec<String> = state
+                    .library
+                    .subfolders(&folder)
+                    .into_iter()
+                    .map(str::to_string)
+                    .collect();
+
+                egui::ScrollArea::vertical().max_height(340.0).show(ui, |ui| {
+                    for path in &subfolders {
+                        ui.push_id(path, |ui| {
+                            ui.horizontal(|ui| folder_row(ui, state, path, &mut actions))
+                        });
+                        ui.add_space(4.0);
+                    }
+                    if subfolders.is_empty() && summaries.is_empty() {
+                        ui.label(
+                            egui::RichText::new("Dieser Ordner ist leer.")
+                                .color(egui::Color32::from_gray(150)),
+                        );
+                    }
+                    for summary in &summaries {
                         let is_current = summary.id == state.current_notebook_id;
-                        ui.horizontal(|ui| {
+                        ui.push_id(&summary.id, |ui| ui.horizontal(|ui| {
                             ui.spacing_mut().item_spacing = egui::vec2(6.0, 0.0);
 
                             if state.renaming_notebook_id.as_deref() == Some(&summary.id) {
@@ -3596,39 +3995,9 @@ pub fn render_ui(
                                     .rounding(egui::Rounding::same(8.0))
                                     .inner_margin(egui::Margin::symmetric(10.0, 8.0))
                                     .show(ui, |ui| {
-                                        ui.horizontal(|ui| {
-                                            let title_area = ui.vertical(|ui| {
-                                                ui.horizontal(|ui| {
-                                                    ui.label(
-                                                        egui::RichText::new(&summary.title)
-                                                            .strong()
-                                                            .size(13.0)
-                                                            .color(egui::Color32::WHITE),
-                                                    );
-                                                    if summary.status == crate::storage::NotebookStatus::Damaged {
-                                                        ui.colored_label(egui::Color32::from_rgb(255, 100, 100), "⚠ Beschädigt");
-                                                    } else if is_current {
-                                                        ui.colored_label(egui::Color32::from_rgb(46, 204, 113), "⚫ Aktiv");
-                                                    }
-                                                });
-                                                let subtext = if let Some(ref err) = summary.error {
-                                                    format!("Fehler: {err}")
-                                                } else {
-                                                    format!("{} Seite(n)", summary.page_count)
-                                                };
-                                                ui.label(
-                                                    egui::RichText::new(subtext)
-                                                        .size(11.0)
-                                                        .color(egui::Color32::from_gray(160)),
-                                                );
-                                            });
-                                            open_clicked = title_area
-                                                .response
-                                                .interact(egui::Sense::click())
-                                                .on_hover_cursor(egui::CursorIcon::PointingHand)
-                                                .clicked();
-
-                                            ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+                                        // Erst die Knöpfe (rechts), der Titel füllt den Rest: Die ganze
+                                        // Titelfläche öffnet das Notizbuch, ohne die Knöpfe zu überdecken
+                                        ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
                                                 if summary.status == crate::storage::NotebookStatus::Damaged {
                                                     if ui
                                                         .button(egui::RichText::new("🔄 Backup").size(13.0).color(egui::Color32::from_rgb(100, 200, 255)))
@@ -3654,6 +4023,14 @@ pub fn render_ui(
                                                         actions.push(UiAction::DeleteNotebook(summary.id.clone()));
                                                     }
 
+                                                    if ui
+                                                        .button(egui::RichText::new("📂").size(16.0))
+                                                        .on_hover_text("In einen anderen Ordner verschieben")
+                                                        .clicked()
+                                                    {
+                                                        state.moving = Some(MoveSubject::Notebook(summary.id.clone()));
+                                                    }
+
                                                     if ui.button(egui::RichText::new("✏").size(16.0))
                                                         .on_hover_text("Titel umbenennen")
                                                         .clicked()
@@ -3662,7 +4039,42 @@ pub fn render_ui(
                                                         state.renaming_title_input = summary.title.clone();
                                                     }
                                                 }
-                                            });
+
+                                            let title_area = ui
+                                                .with_layout(egui::Layout::left_to_right(egui::Align::Center), |ui| {
+                                                    ui.vertical(|ui| {
+                                                        ui.set_min_width(ui.available_width());
+                                                ui.horizontal_wrapped(|ui| {
+                                                    ui.label(
+                                                        egui::RichText::new(&summary.title)
+                                                            .strong()
+                                                            .size(13.0)
+                                                            .color(egui::Color32::WHITE),
+                                                    );
+                                                    if summary.status == crate::storage::NotebookStatus::Damaged {
+                                                        ui.colored_label(egui::Color32::from_rgb(255, 100, 100), "⚠ Beschädigt");
+                                                    } else if is_current {
+                                                        ui.colored_label(egui::Color32::from_rgb(46, 204, 113), "⚫ Aktiv");
+                                                    }
+                                                });
+                                                let subtext = if let Some(ref err) = summary.error {
+                                                    format!("Fehler: {err}")
+                                                } else {
+                                                    format!("{} Seite(n)", summary.page_count)
+                                                };
+                                                ui.label(
+                                                    egui::RichText::new(subtext)
+                                                        .size(11.0)
+                                                        .color(egui::Color32::from_gray(160)),
+                                                );
+                                                    })
+                                                })
+                                                .inner;
+                                            open_clicked = title_area
+                                                .response
+                                                .interact(egui::Sense::click())
+                                                .on_hover_cursor(egui::CursorIcon::PointingHand)
+                                                .clicked();
                                         });
                                     });
 
@@ -3674,7 +4086,7 @@ pub fn render_ui(
                                     state.is_document_menu_open = false;
                                 }
                             }
-                        });
+                        }));
                         ui.add_space(4.0);
                     }
                 });
@@ -4957,6 +5369,43 @@ mod tests {
         actions
     }
 
+    #[test]
+    fn test_stylus_buttons_in_menu() {
+        use crate::settings::{StylusAction, StylusButton};
+        let notebook = Notebook::new();
+        let mut state = UiState::new();
+        state.is_more_menu_open = true;
+        // Ohne gelernte Tasten: nur der Hinweis, keine Aktion
+        let ctx = egui::Context::default();
+        let updater = crate::updater::UpdaterController::new();
+        let shapes = ctx
+            .run(egui::RawInput::default(), |ctx| {
+                let _ = render_ui(ctx, &mut state, &notebook, AutosaveStatus::Saved, &updater);
+            })
+            .shapes
+            .len();
+        assert!(shapes > 0);
+
+        // Mit zwei Tasten: beide Zeilen, die gedrückte hervorgehoben, ohne Fehler
+        state.stylus_buttons = vec![
+            StylusButton {
+                id: 1,
+                action: StylusAction::Erase,
+            },
+            StylusButton {
+                id: 2,
+                action: StylusAction::Select,
+            },
+        ];
+        state.pressed_stylus_button = Some(1);
+        let output = ctx.run(egui::RawInput::default(), |ctx| {
+            let actions = render_ui(ctx, &mut state, &notebook, AutosaveStatus::Saved, &updater);
+            assert!(!actions.contains(&UiAction::SaveStylusButtons));
+        });
+        assert!(!output.shapes.is_empty());
+        assert_eq!(state.stylus_buttons.len(), 2);
+    }
+
     #[test]
     fn test_long_press_detection() {
         let t0 = Instant::now();