chore(release): bump version to 0.10.0

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
feat: Text-Werkzeug
2026-10-08 07:43:56 +02:00 · 2026-10-08 07:40:45 +02:00 · 2026-10-08 06:52:01 +02:00 · 2026-10-07 23:36:19 +02:00 · 2026-10-07 22:52:19 +02:00 · 2026-10-07 20:46:08 +02:00
22 changed files with 5691 additions and 275 deletions
@@ -37,6 +37,21 @@ dependencies = [
 "zerocopy",
 ]
 [[package]]
 name = "alloc-no-stdlib"
 version = "2.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cc7bb162ec39d46ab1ca8c77bf72e890535becd1751bb45f64c597edb4c8c6b3"
 [[package]]
 name = "alloc-stdlib"
 version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0e76a019e91224d279006ff972f1e984179a6e9feb050adba6ce8274aef23195"
 dependencies = [
 "alloc-no-stdlib",
 ]
 [[package]]
 name = "allocator-api2"
 version = "0.2.21"
@@ -61,7 +76,7 @@ dependencies = [
 "ndk-context",
 "ndk-sys",
 "num_enum",
- "thiserror",
+ "thiserror 1.0.69",
 ]
 [[package]]
@@ -205,6 +220,27 @@ dependencies = [
 "objc2 0.4.1",
 ]
 [[package]]
 name = "brotli"
 version = "8.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5cc91aac060a7a1e25823bdccbfb6af1875b88f17c6daac97894eed8207166b3"
 dependencies = [
 "alloc-no-stdlib",
 "alloc-stdlib",
 "brotli-decompressor",
 ]
 [[package]]
 name = "brotli-decompressor"
 version = "5.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3a32acac15fe1967bc3986b2a6347dffc965602354ea6f450ad07e8bfd253583"
 dependencies = [
 "alloc-no-stdlib",
 "alloc-stdlib",
 ]
 [[package]]
 name = "bstr"
 version = "1.13.1"
@@ -265,7 +301,7 @@ dependencies = [
 "polling",
 "rustix 0.38.44",
 "slab",
- "thiserror",
+ "thiserror 1.0.69",
 ]
 [[package]]
@@ -335,6 +371,15 @@ dependencies = [
 "unicode-width",
 ]
 [[package]]
 name = "color"
 version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2ec7c5eb7a16992b1904d76c517d170ab353b0e0b3d5a0c81a8a0cd1037893cf"
 dependencies = [
 "bytemuck",
 ]
 [[package]]
 name = "color_quant"
 version = "1.1.0"
@@ -593,7 +638,7 @@ dependencies = [
 "egui",
 "epaint",
 "log",
- "thiserror",
+ "thiserror 1.0.69",
 "type-map",
 "web-time",
 "wgpu",
@@ -686,6 +731,15 @@ version = "3.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0b5343afd4a8365a643ac588dab4cf234a190c7f6c88c9f6dd6ffe00837661b7"
 [[package]]
 name = "euclid"
 version = "0.22.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f1a05365e3b1c6d1650318537c7460c6923f1abdd272ad6842baa2b509957a06"
 dependencies = [
 "num-traits",
 ]
 [[package]]
 name = "fastrand"
 version = "2.5.0"
@@ -707,6 +761,18 @@ dependencies = [
 "simd-adler32",
 ]
 [[package]]
 name = "fearless_simd"
 version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f4beca3cb2444e3304ac30843cc091f44ed58932353cd492ce740067bfce6b12"
 [[package]]
 name = "fearless_simd"
 version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3296eb97d869113eaf148a6bdf01884e90b3828ad7ae2340b0f93362fc158611"
 [[package]]
 name = "find-msvc-tools"
 version = "0.1.14"
@@ -724,6 +790,21 @@ dependencies = [
 "zlib-rs",
 ]
 [[package]]
 name = "foldhash"
 version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
 [[package]]
 name = "font-types"
 version = "0.12.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6c92d9081c7ab3bd83ef1eecdfad090f3d966e3ce74106779664114cfe1a6274"
 dependencies = [
 "bytemuck",
 ]
 [[package]]
 name = "foreign-types"
 version = "0.5.0"
@@ -878,6 +959,23 @@ dependencies = [
 "serde",
 ]
 [[package]]
 name = "glifo"
 version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9f1218dedd5348c1b166ec3b8b3cbca49d2f527bd43b3fa072ea5123c523ed3f"
 dependencies = [
 "bytemuck",
 "foldhash",
 "hashbrown 0.17.1",
 "log",
 "peniko",
 "png",
 "skrifa 0.44.0",
 "smallvec",
 "vello_common",
 ]
 [[package]]
 name = "glow"
 version = "0.13.1"
@@ -926,7 +1024,7 @@ checksum = "6f56f6318968d03c18e1bcf4857ff88c61157e9da8e47c5f29055d60e1228884"
 dependencies = [
 "log",
 "presser",
- "thiserror",
+ "thiserror 1.0.69",
 "winapi",
 "windows 0.52.0",
 ]
@@ -951,6 +1049,15 @@ dependencies = [
 "bitflags 2.13.2",
 ]
 [[package]]
 name = "guillotiere"
 version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6b17e70c989c36bad147b27a58d148c0741c51448aa5653436547323e524d0ab"
 dependencies = [
 "euclid",
 ]
 [[package]]
 name = "half"
 version = "2.7.1"
@@ -977,6 +1084,9 @@ name = "hashbrown"
 version = "0.17.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"
 dependencies = [
 "foldhash",
 ]
 [[package]]
 name = "hassle-rs"
@@ -988,11 +1098,118 @@ dependencies = [
 "com",
 "libc",
 "libloading 0.8.9",
- "thiserror",
+ "thiserror 1.0.69",
 "widestring",
 "winapi",
 ]
 [[package]]
 name = "hayro"
 version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4675ff5acd7ca41c0c34ccd2a3a154f5c86d8b5ec92bef0a114bfb194969e2af"
 dependencies = [
 "bytemuck",
 "fearless_simd 1.1.0",
 "hayro-interpret",
 "image",
 "kurbo",
 "pic-scale",
 "rustc-hash 2.1.3",
 "vello_cpu",
 ]
 [[package]]
 name = "hayro-ccitt"
 version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2866f0d976e76497480b853d5e258dab6e4b89ecfe991124e08f15dfa8fd03ad"
 [[package]]
 name = "hayro-cmap"
 version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "24d285dc30731c8485de5fa732fbdf2b3affdf01e4da7c2135022ca6fa664bf6"
 dependencies = [
 "brotli",
 "hayro-postscript",
 ]
 [[package]]
 name = "hayro-interpret"
 version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ac9df074ff163a63864cec9b0bf640ccbff8abf4e44481df7369ce0ac172ffbe"
 dependencies = [
 "bitflags 2.13.2",
 "hayro-cmap",
 "hayro-syntax",
 "kurbo",
 "moxcms",
 "phf",
 "rustc-hash 2.1.3",
 "siphasher",
 "skrifa 0.46.2",
 "smallvec",
 "yoke",
 ]
 [[package]]
 name = "hayro-jbig2"
 version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "000e025850f4592ddcaee85640db70704151f2bafd43b6f431aa5b6a2c6a35a9"
 dependencies = [
 "fearless_simd 1.1.0",
 "hayro-ccitt",
 ]
 [[package]]
 name = "hayro-jpeg2000"
 version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "122c5f834c37a2260b9c851bb8be685cf539b2a8b94b704a931ef7d2525d5835"
 dependencies = [
 "fearless_simd 1.1.0",
 ]
 [[package]]
 name = "hayro-postscript"
 version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "885c5ef0654933139a9b9546fc2c69e18d37f38aa2520f079092b1be18f1fcaa"
 [[package]]
 name = "hayro-svg"
 version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e7377affc9513cf5b66c4a8b5fa1e6058ae652eef3d13fdc4709004a03968488"
 dependencies = [
 "base64",
 "hayro-interpret",
 "image",
 "kurbo",
 "rustc-hash 2.1.3",
 "siphasher",
 "xmlwriter",
 ]
 [[package]]
 name = "hayro-syntax"
 version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6cdc818d8d265dcb42081d488f7599df4f73fb79e9d347ecedcd3c23809d2026"
 dependencies = [
 "flate2",
 "hayro-ccitt",
 "hayro-jbig2",
 "hayro-jpeg2000",
 "memchr",
 "rustc-hash 2.1.3",
 "smallvec",
 "zune-jpeg",
 ]
 [[package]]
 name = "heck"
 version = "0.5.0"
@@ -1176,8 +1393,9 @@ dependencies = [
 [[package]]
 name = "ink-notes"
-version = "0.5.0"
+version = "0.10.0"
 dependencies = [
 "ab_glyph",
 "arboard",
 "bytemuck",
 "egui",
@@ -1185,6 +1403,8 @@ dependencies = [
 "egui-winit",
 "fs2",
 "glam",
 "hayro",
 "hayro-svg",
 "image",
 "minisign-verify",
 "naga",
@@ -1220,7 +1440,7 @@ dependencies = [
 "combine",
 "jni-sys 0.3.1",
 "log",
- "thiserror",
+ "thiserror 1.0.69",
 "walkdir",
 "windows-sys 0.45.0",
 ]
@@ -1291,6 +1511,18 @@ version = "3.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e2db585e1d738fc771bf08a151420d3ed193d9d895a36df7f6f8a9456b911ddc"
 [[package]]
 name = "kurbo"
 version = "0.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4b60dfc32f652b926df6192e55525b16d186c69d47876c3ead4da5cc9f8450e2"
 dependencies = [
 "arrayvec",
 "euclid",
 "polycool",
 "smallvec",
 ]
 [[package]]
 name = "libc"
 version = "0.2.190"
@@ -1329,6 +1561,12 @@ dependencies = [
 "redox_syscall 0.9.4",
 ]
 [[package]]
 name = "linebender_resource_handle"
 version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d4a5ff6bcca6c4867b1c4fd4ef63e4db7436ef363e0ad7531d1558856bae64f4"
 [[package]]
 name = "linked-hash-map"
 version = "0.5.6"
@@ -1494,7 +1732,7 @@ dependencies = [
 "rustc-hash 1.1.0",
 "spirv",
 "termcolor",
- "thiserror",
+ "thiserror 1.0.69",
 "unicode-xid",
 ]
@@ -1510,7 +1748,7 @@ dependencies = [
 "ndk-sys",
 "num_enum",
 "raw-window-handle 0.6.2",
- "thiserror",
+ "thiserror 1.0.69",
 ]
 [[package]]
@@ -1697,7 +1935,7 @@ dependencies = [
 "raw-window-handle 0.6.2",
 "smallvec",
 "strum",
- "thiserror",
+ "thiserror 1.0.69",
 "wayland-backend",
 "wayland-client",
 "wayland-protocols",
@@ -1767,12 +2005,77 @@ version = "1.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
 [[package]]
 name = "peniko"
 version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "839c8299360d2e998bdb106dc0a6cd71dcc5f4df51df1b620361bf50e283cca6"
 dependencies = [
 "bytemuck",
 "color",
 "kurbo",
 "linebender_resource_handle",
 "smallvec",
 ]
 [[package]]
 name = "percent-encoding"
 version = "2.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
 [[package]]
 name = "phf"
 version = "0.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c1562dc717473dbaa4c1f85a36410e03c047b2e7df7f45ee938fbef64ae7fadf"
 dependencies = [
 "phf_macros",
 "phf_shared",
 ]
 [[package]]
 name = "phf_generator"
 version = "0.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "135ace3a761e564ec88c03a77317a7c6b80bb7f7135ef2544dbe054243b89737"
 dependencies = [
 "fastrand",
 "phf_shared",
 ]
 [[package]]
 name = "phf_macros"
 version = "0.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "812f032b54b1e759ccd5f8b6677695d5268c588701effba24601f6932f8269ef"
 dependencies = [
 "phf_generator",
 "phf_shared",
 "proc-macro2",
 "quote",
 "syn 2.0.119",
 ]
 [[package]]
 name = "phf_shared"
 version = "0.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e57fef6bc5981e38c2ce2d63bfa546861309f875b8a75f092d1d54ae2d64f266"
 dependencies = [
 "siphasher",
 ]
 [[package]]
 name = "pic-scale"
 version = "0.7.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6edb0ff645d35accaec252de081d55984a0d6c952cb1e5dc2b9afa7c78f07288"
 dependencies = [
 "num-traits",
 "pxfm",
 ]
 [[package]]
 name = "pin-project-lite"
 version = "0.2.17"
@@ -1824,6 +2127,15 @@ version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "22686f4785f02a4fcc856d3b3bb19bf6c8160d103f7a99cc258bddd0251dc7f2"
 [[package]]
 name = "polycool"
 version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "50596ddc09eb5ad5f75cacd40209568e66df71baf86e1499a0e99c4cff12a5a6"
 dependencies = [
 "arrayvec",
 ]
 [[package]]
 name = "pom"
 version = "3.4.0"
@@ -1950,6 +2262,28 @@ version = "0.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "20675572f6f24e9e76ef639bc5552774ed45f1c30e2951e1e99c59888861c539"
 [[package]]
 name = "read-fonts"
 version = "0.41.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "046a7d674daf459825b32f5062056d6882db0d2f5a479fbd76ccfc870ac18709"
 dependencies = [
 "bytemuck",
 "font-types",
 "once_cell",
 ]
 [[package]]
 name = "read-fonts"
 version = "0.43.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "005c8acf251756c478b0bf402885bfd88a1476020c4c7e6060edc1aa68da38ea"
 dependencies = [
 "bytemuck",
 "font-types",
 "once_cell",
 ]
 [[package]]
 name = "redox_syscall"
 version = "0.3.5"
@@ -2194,6 +2528,32 @@ version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e3a9fe34e3e7a50316060351f37187a3f546bce95496156754b601a5fa71b76e"
 [[package]]
 name = "siphasher"
 version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "33f4fe9184a62d842c9ef383018f3306d8ba224fd9d836f56d7288308847c256"
 [[package]]
 name = "skrifa"
 version = "0.44.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "819ab7d62b1d3e72d9d9dea5650bac30424f9111364bb94928dbf5ecad1baa68"
 dependencies = [
 "bytemuck",
 "read-fonts 0.41.0",
 ]
 [[package]]
 name = "skrifa"
 version = "0.46.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d4febebda507fb889c545a37a135517769d1391941013561292897961d1887d6"
 dependencies = [
 "bytemuck",
 "read-fonts 0.43.3",
 ]
 [[package]]
 name = "slab"
 version = "0.4.12"
@@ -2229,7 +2589,7 @@ dependencies = [
 "log",
 "memmap2",
 "rustix 0.38.44",
- "thiserror",
+ "thiserror 1.0.69",
 "wayland-backend",
 "wayland-client",
 "wayland-csd-frame",
@@ -2376,7 +2736,16 @@ version = "1.0.69"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
 dependencies = [
- "thiserror-impl",
+ "thiserror-impl 1.0.69",
 ]
 [[package]]
 name = "thiserror"
 version = "2.0.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "09e52cb86a36cede5cb101bf8908837b3e4c6e5e59fe7fd85c23fb56200d189e"
 dependencies = [
 "thiserror-impl 2.0.21",
 ]
 [[package]]
@@ -2390,6 +2759,17 @@ dependencies = [
 "syn 2.0.119",
 ]
 [[package]]
 name = "thiserror-impl"
 version = "2.0.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fe5197923287db20a58125f0bc85c062f7f2c892de97b18c356f9efb14b28524"
 dependencies = [
 "proc-macro2",
 "quote",
 "syn 3.0.6",
 ]
 [[package]]
 name = "tiff"
 version = "0.11.3"
@@ -2601,6 +2981,35 @@ version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
 [[package]]
 name = "vello_common"
 version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "73c2fbe53548bcd25c8ff42f75a93770a8611a16b37bee56d7ef7b44e36027f1"
 dependencies = [
 "bytemuck",
 "fearless_simd 0.7.0",
 "guillotiere",
 "log",
 "peniko",
 "png",
 "smallvec",
 "thiserror 2.0.21",
 ]
 [[package]]
 name = "vello_cpu"
 version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ed1fec424fbba6acf6cbc78bb526447eb77590d95f40419d598870fe37535212"
 dependencies = [
 "bytemuck",
 "glifo",
 "hashbrown 0.17.1",
 "png",
 "vello_common",
 ]
 [[package]]
 name = "version_check"
 version = "0.9.5"
@@ -2903,7 +3312,7 @@ dependencies = [
 "raw-window-handle 0.6.2",
 "rustc-hash 1.1.0",
 "smallvec",
- "thiserror",
+ "thiserror 1.0.69",
 "web-sys",
 "wgpu-hal",
 "wgpu-types",
@@ -2947,7 +3356,7 @@ dependencies = [
 "renderdoc-sys",
 "rustc-hash 1.1.0",
 "smallvec",
- "thiserror",
+ "thiserror 1.0.69",
 "wasm-bindgen",
 "web-sys",
 "wgpu-types",
@@ -3435,6 +3844,12 @@ version = "0.8.29"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e450f9b2ed1dff33c94c12589a87338689467b9c4f5d8a5710bd09a847d2c8a7"
 [[package]]
 name = "xmlwriter"
 version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ec7a2a501ed189703dba8b08142f057e887dfc4b2cc4db2d343ac6376ba3e0b9"
 [[package]]
 name = "yoke"
 version = "0.8.3"
@@ -1,12 +1,12 @@
 [package]
 name = "ink-notes"
-version = "0.5.0"
+version = "0.10.0"
 edition = "2021"
 description = "Latenzoptimierte Vektor-Notizbuch- und Inking-Anwendung für Linux"
 repository = "https://gitea.pansi.eu/harald/ink-notes"
 license = "MIT"
 readme = "README.md"
-rust-version = "1.75"
+rust-version = "1.92"
 [dependencies]
 # Fenster- & Event-Handling (Wayland/X11, Stylus)
@@ -45,6 +45,11 @@ image = { version = "0.25", default-features = false, features = ["png", "jpeg",
 arboard = { version = "3", default-features = false, features = ["image-data"] }
 minisign-verify = "0.3.0"
 fs2 = "0.4"
 hayro = "0.8"
 hayro-svg = "0.8"
 # Text-Werkzeug: Schriftmetriken und Rasterung (Schriften aus egui)
 ab_glyph = "0.2"
 [profile.dev]
 opt-level = 1 # Erhöht Rendering-Performance auch im Debug-Modus
@@ -18,10 +18,12 @@ Eine latenzoptimierte, hardwarebeschleunigte Inking- und Notizbuch-Anwendung fü
  - **Stift (Pen):** Feine, variable Strichstärken (0.3 mm bis 1.2 mm) mit Notiz-Farben (Schwarz, Blau, Rot, Grün, Grau).
  - **Textmarker (Highlighter):** Breite, halbtransparente Striche (4.0 mm bis 8.0 mm) mit Multiplikations-Blending.
  - **Radierer (Eraser):** Segment- und abstandsbasierte Löschung einzelner Striche auf dem DIN-A4-Canvas.
  - **Text (`T`):** Ins Blatt tippen und mit der Tastatur schreiben – für Überschriften, Code-Schnipsel oder kopierten Text. Normale Schrift oder Code-Schrift (feste Zeichenbreite, Tab rückt ein), 8 bis 36 pt, Farben der Stiftpalette; Zeilen werden am rechten Rand des Textfelds umbrochen. Vorhandenen Text antippen zum Ändern, `Esc` beendet. Textfelder lassen sich wie Bilder verschieben, drehen und skalieren; im PDF-Export ist der Text echt (durchsuchbar und kopierbar). Aus anderen Programmen kopierter Text wird mit `Strg + V` zum Textfeld.
 ### 🔍 Stufenloser Zoom & Pan (Kamera)
 - **Viewport-Transformation:** 2D-Projektionsmatrix im WGSL-Vertex-Shader.
- **Cursor-zentrierter Zoom:** Stufenloses Zoomen von **25 % bis 500 %** zentriert auf die Cursor-Position via Mausrad, Trackpad-Pinch oder Tastenkürzel (`Strg +` / `Strg -` / `Strg 0`).
+- **Durchgehendes Scrollen:** Seiten hängen untereinander und werden mit Mausrad, Finger oder Touchpad fließend gescrollt; wer im unteren Fünftel der letzten Seite schreibt, bekommt automatisch eine neue Seite angehängt. Abschaltbar im ☰-Menü unter „Ansicht“ (dann Seite für Seite blättern).
 - **Cursor-zentrierter Zoom:** Stufenloses Zoomen von **25 % bis 500 %** zentriert auf die Cursor-Position via `Strg + Mausrad` (ohne durchgehende Ansicht: Mausrad), Trackpad-Pinch oder Tastenkürzel (`Strg +` / `Strg -` / `Strg 0`).
 - **Pan:** Verschieben des Canvas per mittlerer Maustaste, `Leertaste + Drag` oder Trackpad-Pan.
 - **Inverse Koordinatentransformation:** Präzise Umrechnung von Bildschirm- in DIN-A4-Dokumentkoordinaten (`screen_to_page`).
@@ -219,10 +221,12 @@ cargo run --release
 | :--- | :--- |
 | **Zeichnen** | Linke Maustaste / Stiftspitze |
 | **Canvas verschieben (Pan)** | Mittlere Maustaste **oder** `Leertaste + Drag` |
-| **Zoom zentriert auf Cursor** | Mausrad / Touchpad-Pinch |
+| **Scrollen (durchgehende Ansicht)** | Mausrad (`Umschalt` = waagerecht) / ein Finger |
 | **Zoom zentriert auf Cursor** | `Strg + Mausrad` / Touchpad-Pinch (Einzelseiten-Ansicht: Mausrad) |
 | **Zoom zurücksetzen (100 %)** | `Strg + 0` |
 | **Zoom In / Out** | `Strg + +` / `Strg + -` |
 | **Auswahlwerkzeug (Lasso)** | `V` |
 | **Text-Werkzeug** | `T`, dann ins Blatt klicken; `Esc` beendet die Eingabe |
 | **Auswahl um 90° drehen** | `R` |
 | **Kopieren & Einfügen** | `Strg + C` / `Strg + V` |
 | **Auswahl löschen** | `Entf` oder `Backspace` |
@@ -3,6 +3,13 @@
 Latenzoptimierte Vektor-Notizbuch- und Inking-Anwendung für Linux (Zorin OS 18 / Ubuntu 24.04).
 ### Highlights:
 - **Text-Werkzeug**: Mit T ins Blatt tippen und schreiben – normale oder Code-Schrift, 8–36 pt, Zeilenumbruch am Feldrand; Textfelder verschieben, drehen und skalieren wie Bilder; im PDF echter, durchsuchbarer Text; kopierter Text wird mit Strg+V zum Textfeld (Dateiformat-Version 7)
 - **Durchgehendes Scrollen**: Seiten untereinander mit Mausrad, Finger oder Touchpad scrollen (Strg+Mausrad zoomt); Schreiben im unteren Fünftel der letzten Seite hängt automatisch eine neue an; abschaltbar unter ☰ → Ansicht
 - **Virtuelles Lineal**: Ein- und ausblenden mit L oder über die Werkzeugleiste; verschieben, am Griff drehen (rastet bei 15° ein); Striche entlang einer Kante werden exakt gerade – mit Stift, Textmarker und Formwerkzeug
 - **Teilstrich-Radierer**: Nur den überstrichenen Teil eines Strichs entfernen – ein Radierzug ist ein Undo-Schritt
 - **Export & Zwischenablage**: Aktuelle Seite als PNG (auch transparent) oder SVG; Strg+C legt die Auswahl zusätzlich als Bild in die Zwischenablage für Chat, Mail oder Office
 - **Seitentitel & Inhaltsverzeichnis**: Seiten benennen, Inhaltsansicht in der Seitenübersicht, Titel werden zu PDF-Lesezeichen (Dateiformat-Version 6)
 - **PDF importieren & annotieren**: Vorlesungsfolien, Übungsblätter oder Formulare als neues Notizbuch öffnen (☰-Menü oder Drag & Drop), darauf schreiben und markieren; beim Export liegen die Originalseiten verlustfrei als Vektor unter den Notizen (Dateiformat-Version 5: ältere Versionen öffnen solche Notizbücher nicht)
 - **Bilder einfügen**: Screenshots per Strg+V, Bilddateien über die eingebaute Dateiauswahl (Strg+I) oder per Drag & Drop; verschieben, drehen, skalieren und darauf schreiben – auch im PDF-Export (Dateiformat-Version 4: ältere Versionen öffnen solche Notizbücher nicht)
 - **Dunkelmodus & Papierfarben**: Weiß, Creme, Dunkelgrau oder Schwarz; auf dunklem Papier werden dunkle Stiftfarben automatisch aufgehellt (nur Anzeige – Dateien und PDF-Export bleiben unverändert)
 - **Nur Textmarker radieren**: Markierungen korrigieren, ohne die Handschrift darunter zu löschen – auch mit Stiftrückseite und Seitentaste
@@ -78,7 +78,7 @@ pub struct RgbaImage {
    pub pixels: Vec<u8>,
 }
-/// Prüft einen Asset-Namen: genau 64 Hex-Zeichen und `.png` oder `.jpg`. Verhindert, dass
+/// Prüft einen Asset-Namen: genau 64 Hex-Zeichen und `.png`, `.jpg` oder `.pdf`. Verhindert, dass
 /// eine manipulierte Seitendatei auf Dateien außerhalb des Asset-Ordners verweist.
 pub fn is_valid_asset_name(name: &str) -> bool {
    let Some((hash, ext)) = name.split_once('.') else {
@@ -88,7 +88,7 @@ pub fn is_valid_asset_name(name: &str) -> bool {
        && hash
            .bytes()
            .all(|b| b.is_ascii_digit() || (b'a'..=b'f').contains(&b))
-        && matches!(ext, "png" | "jpg")
+        && matches!(ext, "png" | "jpg" | "pdf")
 }
 /// Bilddateien eines Notizbuchs.
@@ -146,6 +146,17 @@ impl AssetStore {
        self.store(&png, "png", decoded.width(), decoded.height())
    }
    /// Übernimmt eine PDF-Datei unverändert (der Inhalt muss vorher geprüft sein).
    pub fn import_pdf(&self, bytes: &[u8]) -> Result<String, AssetError> {
        let hash = Sha256::digest(bytes);
        let asset = format!("{}.pdf", hex(&hash));
        let path = self.path_of(&asset)?;
        if !path.exists() {
            storage::atomic_write_file(&path, bytes)?;
        }
        Ok(asset)
    }
    /// Übernimmt rohe RGBA-Pixel (z. B. aus der Zwischenablage) als PNG.
    pub fn import_rgba(
        &self,
@@ -6,6 +6,7 @@
 //! - NDC-Transformation der 2D-Vektor-Meshes über Vertex-Shader-Uniforms.
 //! - Alpha-Blending (`wgpu::BlendState::ALPHA_BLENDING`).
 use std::collections::HashMap;
 use std::ops::Range;
 use std::sync::Arc;
 use winit::dpi::PhysicalSize;
@@ -112,6 +113,44 @@ pub fn choose_present_mode(available: &[wgpu::PresentMode]) -> Option<wgpu::Pres
        .or_else(|| available.first().copied())
 }
 /// Erkennt, ob die GPU-Daten einer Nachbarseite noch zur Seite passen. Änderungen an der
 /// aktuellen Seite verwerfen deren Eintrag ohnehin (siehe [`CanvasState::sync_page`]).
 #[derive(Debug, Clone, PartialEq)]
 struct NeighborFingerprint {
    page_id: u64,
    background: PageBackground,
    paper_theme: PaperTheme,
    vertex_count: usize,
    stroke_count: usize,
    last_stroke_id: Option<u64>,
 }
 impl NeighborFingerprint {
    fn of(page: &Page, paper_theme: PaperTheme) -> Self {
        Self {
            page_id: page.id,
            background: page.background,
            paper_theme,
            vertex_count: page.vertex_cache.len(),
            stroke_count: page.strokes.len(),
            last_stroke_id: page.strokes.last().map(|s| s.id),
        }
    }
 }
 /// GPU-Daten einer in der durchgehenden Ansicht sichtbaren Nachbarseite.
 struct NeighborPage {
    fingerprint: NeighborFingerprint,
    /// Lage relativ zur aktuellen Seite (in Seiten, negativ = darüber)
    offset: i64,
    camera_buffer: wgpu::Buffer,
    camera_bind_group: wgpu::BindGroup,
    background_buffer: Option<wgpu::Buffer>,
    background_vertex_count: u32,
    vertex_buffer: Option<wgpu::Buffer>,
    stroke_ranges: Vec<Range<u32>>,
 }
 pub struct CanvasState {
    pub surface: wgpu::Surface<'static>,
    /// Verwendeter Grafikadapter (für erneute Abfrage der Surface-Fähigkeiten bei Größenänderung)
@@ -148,6 +187,13 @@ pub struct CanvasState {
    pub paper_theme: PaperTheme,
    /// Dunkle Tinte auf dunklem Papier aufhellen
    pub adapt_ink: bool,
    /// Textfelder der sichtbaren Seiten nach Texturschlüssel (für die Rasterung)
    text_specs: HashMap<String, TextSpec>,
    /// Gerade bearbeitetes Textfeld der aktuellen Seite: nicht zeichnen (die Bearbeitung
    /// zeigt es)
    hidden_text: Option<u64>,
    /// Auflösung der Texttexturen in Pixeln je Seiteneinheit
    text_resolution: f32,
    // Pipeline-Trennung: Live-Strich (aktiver Stroke)
    pub live_vertex_buffer: wgpu::Buffer,
@@ -168,6 +214,15 @@ pub struct CanvasState {
    // Eingefügte Bilder der aktuellen Seite
    image_layer: crate::image_layer::ImageLayer,
    /// Durchgehende Ansicht: sichtbare Nachbarseiten der aktuellen Seite
    neighbors: Vec<NeighborPage>,
    camera_layout: wgpu::BindGroupLayout,
    /// Eingeblendetes Lineal (Striche nahe einer Kante rasten ein)
    pub ruler: Option<crate::ruler::Ruler>,
    /// Kante, an der der aktuelle Live-Strich eingerastet ist
    ruler_lock: Option<crate::ruler::EdgeLock>,
    // egui UI-Renderer
    pub egui_renderer: egui_wgpu::Renderer,
 }
@@ -444,6 +499,9 @@ impl CanvasState {
            current_background,
            paper_theme,
            adapt_ink: false,
            text_specs: HashMap::new(),
            hidden_text: None,
            text_resolution: 1.0,
            live_vertex_buffer,
            live_vertex_capacity: Self::INITIAL_LIVE_CAPACITY,
            live_vertex_count: 0,
@@ -461,6 +519,10 @@ impl CanvasState {
            committed_vertex_count: 0,
            committed_strokes: Vec::with_capacity(128),
            image_layer,
            neighbors: Vec::new(),
            camera_layout: bind_group_layout,
            ruler: None,
            ruler_lock: None,
            egui_renderer,
            camera: crate::viewport::ViewportState::new(),
        })
@@ -468,8 +530,26 @@ impl CanvasState {
    /// Aktualisiert die 2D-Kamera Uniforms (Scale & Offset im NDC-Raum) basierend auf Viewport und Kamera.
    pub fn update_uniforms(&mut self) {
-        let (scale, offset) = self.camera.ndc_transform(&self.viewport);
+        let camera_uniforms = self.camera_uniforms(0);
-        let camera_uniforms = CameraUniforms {
+        self.queue.write_buffer(
            &self.camera_buffer,
            0,
            bytemuck::cast_slice(&[camera_uniforms]),
        );
        for neighbor in &self.neighbors {
            self.queue.write_buffer(
                &neighbor.camera_buffer,
                0,
                bytemuck::cast_slice(&[self.camera_uniforms(neighbor.offset)]),
            );
        }
    }
    /// Kamera für die Seite `page_offset` Seiten unter (negativ: über) der aktuellen.
    fn camera_uniforms(&self, page_offset: i64) -> CameraUniforms {
        let (scale, mut offset) = self.camera.ndc_transform(&self.viewport);
        offset[1] += page_offset as f32 * crate::viewport::PAGE_PITCH * scale[1];
        CameraUniforms {
            transform_scale: scale,
            transform_offset: offset,
            ink_params: [
@@ -482,12 +562,7 @@ impl CanvasState {
                0.0,
                0.0,
            ],
-        };
+        }
        self.queue.write_buffer(
            &self.camera_buffer,
            0,
            bytemuck::cast_slice(&[camera_uniforms]),
        );
    }
    /// Setzt die von seitlicher UI belegten Streifen (physische Pixel), damit die Seite
@@ -578,6 +653,63 @@ impl CanvasState {
        self.camera.page_to_screen_vec2(page_pt, &self.viewport)
    }
    /// Durchgehende Ansicht: Versatz (in Seiten) der Seite unter dem Bildschirmpunkt,
    /// `None` neben den Seiten und zwischen zwei Seiten.
    pub fn page_offset_at_screen(&self, screen_x: f32, screen_y: f32) -> Option<i64> {
        let p = self
            .camera
            .screen_to_page_unclamped(screen_x, screen_y, &self.viewport);
        if !(0.0..=crate::document::PAGE_WIDTH).contains(&p.x) {
            return None;
        }
        crate::viewport::page_offset_at(p.y)
    }
    /// Durchgehende Ansicht: Versatz (in Seiten) der Seite in der Mitte des Fensters.
    pub fn page_offset_at_view_center(&self) -> Option<i64> {
        let p = self.camera.screen_to_page_unclamped(
            0.0,
            self.size.height as f32 / 2.0,
            &self.viewport,
        );
        crate::viewport::page_offset_at(p.y)
    }
    /// Durchgehende Ansicht: Versätze der sichtbaren Nachbarseiten der aktuellen Seite.
    pub fn visible_neighbor_offsets(&self, current: usize, page_count: usize) -> Vec<i64> {
        let top = self
            .camera
            .screen_to_page_unclamped(0.0, 0.0, &self.viewport);
        let bottom =
            self.camera
                .screen_to_page_unclamped(0.0, self.size.height as f32, &self.viewport);
        crate::viewport::visible_neighbor_offsets(top.y, bottom.y, current, page_count)
    }
    /// Durchgehende Ansicht: Hält die Fenstermitte über dem Notizbuch (von der Oberkante der
    /// ersten bis zur Unterkante der letzten Seite, waagerecht innerhalb der Seitenbreite), damit
    /// man nicht ins Leere scrollt. `true`, wenn der Ausschnitt korrigiert wurde.
    pub fn clamp_scroll(&mut self, current: usize, page_count: usize) -> bool {
        let center = [
            self.viewport.page_x + self.viewport.page_width / 2.0,
            self.size.height as f32 / 2.0,
        ];
        let changed =
            self.camera
                .clamp_continuous_center(center, current, page_count, &self.viewport);
        if changed {
            self.update_uniforms();
        }
        changed
    }
    /// Durchgehende Ansicht: Die Seite `k` Seiten weiter wird zur Bezugsseite, ohne dass sich
    /// der Bildausschnitt bewegt. Die Nachbarseiten sind danach neu zu setzen.
    pub fn shift_reference_page(&mut self, k: i64) {
        self.camera.shift_reference_page(k);
        self.update_uniforms();
    }
    /// Ersetzt die Live-Vertices des aktiven Strichs durch ein bereinigtes Form-Mesh (für Draw-and-Hold).
    pub fn set_live_shape_mesh(&mut self, samples: Vec<StylusSample>, vertices: Vec<InkVertex>) {
        self.live_samples = samples;
@@ -665,13 +797,11 @@ impl CanvasState {
    /// Synchronisiert die GPU-Puffer mit den Daten der aktiven Seite.
    pub fn sync_page(&mut self, page: &mut Page) {
        page.rebuild_cache_if_dirty();
        // Die aktuelle Seite kann sich jetzt ändern: als Nachbarseite später neu hochladen
        self.neighbors.retain(|n| n.fingerprint.page_id != page.id);
        self.set_background(page.background);
-        self.image_layer.set_quads(
+        let quads = self.page_image_quads(page, self.hidden_text);
-            page.strokes
+        self.image_layer.set_quads(quads);
                .iter()
                .filter_map(|s| Some((s.image.clone()?, s.image_corners()?)))
                .collect(),
        );
        self.committed_vertex_count = page.vertex_cache.len() as u32;
        self.committed_strokes = page.stroke_ranges.clone();
@@ -698,10 +828,153 @@ impl CanvasState {
        );
    }
-    /// Lädt Bilder der aktuellen Seite, die noch nicht auf der GPU liegen. Vor jedem
+    /// Durchgehende Ansicht: übernimmt die sichtbaren Nachbarseiten mit ihrem Versatz zur
-    /// Zeichnen aufrufen; ohne Änderungen kostet das nichts.
+    /// aktuellen Seite (in Seiten). Die Vertex-Caches der Seiten müssen aktuell sein
-    pub fn prepare_images(&mut self, assets: &crate::assets::AssetStore) {
+    /// ([`Page::rebuild_cache_if_dirty`]); unveränderte Seiten werden nicht erneut hochgeladen.
-        self.image_layer.prepare(&self.device, &self.queue, assets);
+    /// Eine leere Liste schaltet die Nachbarseiten ab.
    pub fn set_neighbor_pages(&mut self, pages: &[(i64, &Page)]) {
        let mut old = std::mem::take(&mut self.neighbors);
        let mut image_groups = Vec::with_capacity(pages.len());
        for &(offset, page) in pages {
            let fingerprint = NeighborFingerprint::of(page, self.paper_theme);
            let mut neighbor = match old.iter().position(|n| n.fingerprint == fingerprint) {
                Some(i) => old.swap_remove(i),
                None => self.upload_neighbor(page, fingerprint),
            };
            neighbor.offset = offset;
            self.queue.write_buffer(
                &neighbor.camera_buffer,
                0,
                bytemuck::cast_slice(&[self.camera_uniforms(offset)]),
            );
            self.neighbors.push(neighbor);
            image_groups.push(self.page_image_quads(page, None));
        }
        self.image_layer.set_neighbor_quads(image_groups);
    }
    /// Lädt Raster und Striche einer Nachbarseite auf die GPU.
    fn upload_neighbor(&self, page: &Page, fingerprint: NeighborFingerprint) -> NeighborPage {
        let camera_buffer = self.device.create_buffer(&wgpu::BufferDescriptor {
            label: Some("Neighbor Camera Uniform Buffer"),
            size: std::mem::size_of::<CameraUniforms>() as wgpu::BufferAddress,
            usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
            mapped_at_creation: false,
        });
        let camera_bind_group = self.device.create_bind_group(&wgpu::BindGroupDescriptor {
            label: Some("Neighbor Camera Bind Group"),
            layout: &self.camera_layout,
            entries: &[wgpu::BindGroupEntry {
                binding: 0,
                resource: camera_buffer.as_entire_binding(),
            }],
        });
        let vertex_buffer_with = |label: &str, vertices: &[InkVertex]| {
            (!vertices.is_empty()).then(|| {
                let buffer = self.device.create_buffer(&wgpu::BufferDescriptor {
                    label: Some(label),
                    size: std::mem::size_of_val(vertices) as u64,
                    usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
                    mapped_at_creation: false,
                });
                self.queue
                    .write_buffer(&buffer, 0, bytemuck::cast_slice(vertices));
                buffer
            })
        };
        let background =
            generate_background_mesh(page.background, self.paper_theme.pattern_color());
        NeighborPage {
            fingerprint,
            offset: 0,
            camera_buffer,
            camera_bind_group,
            background_buffer: vertex_buffer_with("Neighbor Background Buffer", &background),
            background_vertex_count: background.len() as u32,
            vertex_buffer: vertex_buffer_with("Neighbor Strokes Buffer", &page.vertex_cache),
            stroke_ranges: page.stroke_ranges.clone(),
        }
    }
    /// Lädt Bilder und PDF-Seiten der aktuellen Seite, die noch nicht auf der GPU liegen.
    /// Vor jedem Zeichnen aufrufen; ohne Änderungen kostet das fast nichts.
    pub fn prepare_images(
        &mut self,
        load: &mut dyn FnMut(&str) -> crate::image_layer::TextureSource,
    ) {
        // Text schärfer rastern, sobald weiter hineingezoomt wird (und gröber beim Herauszoomen)
        let resolution = text_resolution(
            self.viewport.page_width / crate::document::PAGE_WIDTH * self.camera.zoom,
        );
        if resolution != self.text_resolution {
            self.text_resolution = resolution;
            self.image_layer
                .forget_textures(|key| key.starts_with(TEXT_KEY_PREFIX));
        }
        let specs = &self.text_specs;
        self.image_layer
            .prepare(&self.device, &self.queue, &mut |key| match specs.get(key) {
                Some(spec) => crate::image_layer::TextureSource::Ready(crate::text::rasterize(
                    &spec.text,
                    spec.color,
                    resolution * spec.scale,
                )),
                None => load(key),
            });
        let layer = &self.image_layer;
        self.text_specs.retain(|key, _| layer.uses(key));
    }
    /// Blendet das gerade bearbeitete Textfeld aus (wirksam ab dem nächsten `sync_page`).
    pub fn set_hidden_text(&mut self, id: Option<u64>) {
        self.hidden_text = id;
    }
    /// Bilder einer Seite für die Bildebene: zuerst die PDF-Seite, darüber die eingefügten
    /// Bilder und Textfelder (außer `hidden`) in ihrer Reihenfolge.
    fn page_image_quads(
        &mut self,
        page: &Page,
        hidden: Option<u64>,
    ) -> Vec<(String, [glam::Vec2; 4])> {
        let adapt = self.adapt_ink && self.paper_theme.is_dark();
        let mut quads: Vec<_> = page
            .pdf_background
            .iter()
            .map(|pdf| (pdf.key(), pdf.corners()))
            .collect();
        for stroke in &page.strokes {
            let Some(corners) = stroke.object_corners() else {
                continue;
            };
            if let Some(asset) = &stroke.image {
                quads.push((asset.clone(), corners));
            } else if let Some(text) = &stroke.text {
                if Some(stroke.id) == hidden {
                    continue;
                }
                let color = if adapt {
                    crate::background::adapt_ink_color(stroke.color)
                } else {
                    stroke.color
                };
                let key = text_key(text, color);
                let scale = ((corners[1] - corners[0]).length() / text.wrap_width.max(text.size))
                    .max((corners[3] - corners[0]).length() / text.layout().height());
                self.text_specs.entry(key.clone()).or_insert(TextSpec {
                    text: text.clone(),
                    color,
                    scale,
                });
                quads.push((key, corners));
            }
        }
        quads
    }
    /// Wird noch eine PDF-Seite im Hintergrund gerendert?
    pub fn is_waiting_for_images(&self) -> bool {
        self.image_layer.is_waiting()
    }
    /// Startet einen neuen Live-Strich in DIN-A4-Seitenkoordinaten.
@@ -712,6 +985,13 @@ impl CanvasState {
        self.live_vertices.clear();
        self.live_vertex_count = 0;
        // Beginnt der Strich an einer Linealkante, bleibt er bis zum Abheben auf ihr
        let half_width = self.current_stroke_width_mm * crate::document::UNITS_PER_MM / 2.0;
        self.ruler_lock = self
            .ruler
            .and_then(|r| r.edge_lock(glam::Vec2::new(page_x, page_y), half_width));
        let (page_x, page_y) = self.constrain_to_ruler(page_x, page_y);
        // 1. Zwingend durch den 1€-Filter leiten
        let (fx, fy, fp) = self.filter.filter(page_x, page_y, pressure, timestamp);
        let pt = ControlPoint::new(fx, fy, fp);
@@ -735,6 +1015,7 @@ impl CanvasState {
        }
        // 1. Zwingend durch den 1€-Filter leiten
        let (page_x, page_y) = self.constrain_to_ruler(page_x, page_y);
        let (fx, fy, fp) = self.filter.filter(page_x, page_y, pressure, timestamp);
        let new_pt = ControlPoint::new(fx, fy, fp);
@@ -757,6 +1038,19 @@ impl CanvasState {
        self.update_live_mesh();
    }
    /// Projiziert einen Punkt auf die Linealkante, falls der Live-Strich dort eingerastet ist.
    fn constrain_to_ruler(&self, x: f32, y: f32) -> (f32, f32) {
        match self.ruler_lock {
            Some(lock) => lock.project(glam::Vec2::new(x, y)).into(),
            None => (x, y),
        }
    }
    /// Ist der aktuelle Live-Strich an einer Linealkante eingerastet?
    pub fn is_ruler_locked(&self) -> bool {
        self.ruler_lock.is_some()
    }
    /// Bricht den aktuellen Live-Strich ab und setzt Puffer sowie 1€-Filter sauber zurück.
    pub fn cancel_stroke(&mut self) {
        self.live_samples.clear();
@@ -889,6 +1183,28 @@ impl CanvasState {
                occlusion_query_set: None,
            });
            // 0. Nachbarseiten der durchgehenden Ansicht (je mit eigener Kamera)
            for (i, neighbor) in self.neighbors.iter().enumerate() {
                render_pass.set_bind_group(0, &neighbor.camera_bind_group, &[]);
                render_pass.set_pipeline(&self.triangle_pipeline);
                render_pass.set_vertex_buffer(0, self.paper_buffer.slice(..));
                render_pass.draw(0..6, 0..1);
                if let Some(buffer) = &neighbor.background_buffer {
                    render_pass.set_vertex_buffer(0, buffer.slice(..));
                    render_pass.draw(0..neighbor.background_vertex_count, 0..1);
                }
                self.image_layer.draw(&mut render_pass, i + 1);
                if let Some(buffer) = &neighbor.vertex_buffer {
                    render_pass.set_pipeline(&self.strip_pipeline);
                    render_pass.set_vertex_buffer(0, buffer.slice(..));
                    for range in &neighbor.stroke_ranges {
                        if range.end > range.start {
                            render_pass.draw(range.clone(), 0..1);
                        }
                    }
                }
            }
            // 2D-Kamera Uniforms (Scale & Offset) binden
            render_pass.set_bind_group(0, &self.camera_bind_group, &[]);
@@ -904,7 +1220,7 @@ impl CanvasState {
            }
            // 3. Eingefügte Bilder (unter der Tinte)
-            self.image_layer.draw(&mut render_pass);
+            self.image_layer.draw(&mut render_pass, 0);
            // 4. Abgeschlossene Striche der aktiven Seite rendern (TriangleStrip mit Vertex-Farben)
            render_pass.set_pipeline(&self.strip_pipeline);
@@ -968,10 +1284,53 @@ impl CanvasState {
    }
 }
 /// Zu rasterndes Textfeld.
 struct TextSpec {
    text: crate::text::TextBox,
    /// Angezeigte (ggf. aufgehellte) Farbe
    color: [f32; 4],
    /// Vergrößerung des Felds durch Skalieren der Auswahl
    scale: f32,
 }
 /// Schlüssel der Texttexturen beginnen hiermit.
 const TEXT_KEY_PREFIX: &str = "text:";
 /// Texturschlüssel eines Textfelds: ändert sich mit Inhalt, Satz und Farbe.
 fn text_key(text: &crate::text::TextBox, color: [f32; 4]) -> String {
    use std::hash::{Hash, Hasher};
    let mut hasher = std::collections::hash_map::DefaultHasher::new();
    text.content.hash(&mut hasher);
    text.font.hash(&mut hasher);
    for v in [text.size, text.wrap_width].into_iter().chain(color) {
        v.to_bits().hash(&mut hasher);
    }
    format!("{TEXT_KEY_PREFIX}{:016x}", hasher.finish())
 }
 /// Auflösung der Texttexturen für `screen_px_per_unit` Bildschirmpixel je Seiteneinheit:
 /// auf Viertel-Zweierpotenzen aufgerundet (⅛ bis 4). So wird nicht bei jedem Zoomschritt neu
 /// gerastert, und die Textur ist höchstens ein Fünftel größer als dargestellt – stärker
 /// verkleinert wirkt die dünne Schrift blass.
 fn text_resolution(screen_px_per_unit: f32) -> f32 {
    let steps = (screen_px_per_unit.max(1e-3).log2() * 4.0).ceil();
    2.0_f32.powf(steps / 4.0).clamp(0.125, 4.0)
 }
 #[cfg(test)]
 mod tests {
    use super::*;
    #[test]
    fn test_text_resolution_is_quantized_and_never_below_screen() {
        for px in [0.2_f32, 0.27, 0.5, 1.3, 3.9] {
            let r = text_resolution(px);
            assert!(r >= px - 1e-4 && r < px * 1.2 + 1e-4, "{px} → {r}");
        }
        assert_eq!(text_resolution(0.27), text_resolution(0.28));
        assert_eq!(text_resolution(100.0), 4.0);
    }
    #[test]
    fn test_choose_present_mode() {
        use wgpu::PresentMode::{Fifo, Immediate, Mailbox};
@@ -122,6 +122,63 @@ pub fn point_in_convex_quad(p: glam::Vec2, quad: &[glam::Vec2; 4]) -> bool {
    true
 }
 /// Größte Länge eines Seitentitels in Zeichen.
 pub const MAX_PAGE_TITLE_CHARS: usize = 120;
 /// Bereinigt einen Seitentitel: Zeilenumbrüche und doppelte Leerzeichen entfernen, auf
 /// [`MAX_PAGE_TITLE_CHARS`] kürzen; leer bedeutet „kein Titel“.
 pub fn normalize_page_title(title: &str) -> Option<String> {
    let cleaned: String = title
        .split_whitespace()
        .collect::<Vec<_>>()
        .join(" ")
        .chars()
        .take(MAX_PAGE_TITLE_CHARS)
        .collect();
    (!cleaned.is_empty()).then_some(cleaned)
 }
 /// Verweis auf eine Seite eines importierten PDFs (Datei im Asset-Ordner).
 #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct PdfBackground {
    /// Name der PDF-Datei im Asset-Ordner
    pub asset: String,
    /// Seitennummer im PDF, ab 0
    pub page: u32,
    /// Angezeigte Größe der PDF-Seite in Punkt (Drehung berücksichtigt)
    pub width_pt: f32,
    pub height_pt: f32,
 }
 impl PdfBackground {
    /// Schlüssel für Texturen und Render-Aufträge.
    pub fn key(&self) -> String {
        format!("{}#{}", self.asset, self.page)
    }
    /// Ecken (oben links, oben rechts, unten rechts, unten links) der PDF-Seite auf dem
    /// A4-Blatt, siehe [`pdf_placement`].
    pub fn corners(&self) -> [glam::Vec2; 4] {
        pdf_placement(self.width_pt, self.height_pt)
    }
 }
 /// Lage einer PDF-Seite von `width_pt` × `height_pt` auf dem A4-Blatt: so groß wie möglich,
 /// waagerecht zentriert und oben bündig. Querformat-Folien liegen so oben auf der Seite,
 /// darunter bleibt Platz für Notizen.
 pub fn pdf_placement(width_pt: f32, height_pt: f32) -> [glam::Vec2; 4] {
    let (w, h) = (width_pt.max(1.0), height_pt.max(1.0));
    let scale = (PAGE_WIDTH / w).min(PAGE_HEIGHT / h);
    let size = glam::Vec2::new(w * scale, h * scale);
    let tl = glam::Vec2::new((PAGE_WIDTH - size.x) / 2.0, 0.0);
    [
        tl,
        tl + glam::Vec2::new(size.x, 0.0),
        tl + size,
        tl + glam::Vec2::new(0.0, size.y),
    ]
 }
 /// Seiteneinheiten pro Bildpixel beim Einfügen (96 dpi wie am Bildschirm: 1 px ≈ 0,26 mm).
 pub const IMAGE_UNITS_PER_PIXEL: f32 = UNITS_PER_MM * 25.4 / 96.0;
@@ -180,18 +237,124 @@ pub enum EraserMode {
    All,
    /// Nur Textmarker – die Handschrift darunter bleibt erhalten
    HighlighterOnly,
    /// Nur den überstrichenen Teil eines Strichs entfernen; der Rest bleibt in Stücken
    /// erhalten. Formen werden als Ganzes radiert.
    Partial,
 }
 impl EraserMode {
    /// Darf ein Strich dieses Werkzeugs radiert werden?
    pub fn erases(self, tool: StrokeTool) -> bool {
        match self {
-            EraserMode::All => true,
+            EraserMode::All | EraserMode::Partial => true,
            EraserMode::HighlighterOnly => tool == StrokeTool::Highlighter,
        }
    }
 }
 /// Zeitfenster, in dem aufeinanderfolgende Teilradierungen zu einem Undo-Schritt
 /// zusammengefasst werden (ein Radierzug besteht aus vielen kleinen Schnitten).
 pub const PARTIAL_ERASE_MERGE_WINDOW: std::time::Duration = std::time::Duration::from_millis(500);
 /// Zerlegt die Punktfolge eines Strichs an einem Kreis (Radierer): übrig bleiben die Stücke
 /// außerhalb des Kreises, an den Kreisrand gekürzt. `None`, wenn der Kreis den Strich nicht
 /// berührt. Stücke kürzer als `min_length` entfallen.
 pub fn split_samples_at_circle(
    samples: &[StylusSample],
    center: glam::Vec2,
    radius: f32,
    min_length: f32,
 ) -> Option<Vec<Vec<StylusSample>>> {
    let inside = |p: glam::Vec2| (p - center).length_squared() <= radius * radius;
    let lerp = |a: &StylusSample, b: &StylusSample, t: f32| StylusSample {
        position: a.position.lerp(b.position, t),
        pressure: a.pressure + (b.pressure - a.pressure) * t,
        timestamp: a.timestamp + (b.timestamp - a.timestamp) * t as f64,
    };
    // Schnittparameter t ∈ (0, 1) einer Strecke mit dem Kreisrand, aufsteigend
    let crossings = |a: glam::Vec2, b: glam::Vec2| -> Vec<f32> {
        let d = b - a;
        let f = a - center;
        let qa = d.dot(d);
        if qa < 1e-12 {
            return Vec::new();
        }
        let qb = 2.0 * f.dot(d);
        let qc = f.dot(f) - radius * radius;
        let disc = qb * qb - 4.0 * qa * qc;
        if disc < 0.0 {
            return Vec::new();
        }
        let root = disc.sqrt();
        [(-qb - root) / (2.0 * qa), (-qb + root) / (2.0 * qa)]
            .into_iter()
            .filter(|t| *t > 0.0 && *t < 1.0)
            .collect()
    };
    match samples {
        [] => return None,
        [single] => return inside(single.position).then(Vec::new),
        _ => {}
    }
    let touched = samples.iter().any(|s| inside(s.position))
        || samples
            .windows(2)
            .any(|w| crossings(w[0].position, w[1].position).len() == 2);
    if !touched {
        return None;
    }
    let mut pieces = Vec::new();
    let mut current: Vec<StylusSample> = Vec::new();
    if !inside(samples[0].position) {
        current.push(samples[0]);
    }
    for w in samples.windows(2) {
        let (a, b) = (&w[0], &w[1]);
        let (a_in, b_in) = (inside(a.position), inside(b.position));
        let ts = crossings(a.position, b.position);
        match (a_in, b_in) {
            (false, false) => {
                if let [t_enter, t_exit] = ts[..] {
                    // Strecke läuft durch den Kreis
                    current.push(lerp(a, b, t_enter));
                    pieces.push(std::mem::take(&mut current));
                    current.push(lerp(a, b, t_exit));
                }
                current.push(*b);
            }
            (false, true) => {
                if let Some(&t) = ts.first() {
                    current.push(lerp(a, b, t));
                }
                pieces.push(std::mem::take(&mut current));
            }
            (true, false) => {
                current.clear();
                if let Some(&t) = ts.last() {
                    current.push(lerp(a, b, t));
                }
                current.push(*b);
            }
            (true, true) => {}
        }
    }
    pieces.push(current);
    let length = |p: &Vec<StylusSample>| -> f32 {
        p.windows(2)
            .map(|w| (w[1].position - w[0].position).length())
            .sum()
    };
    Some(
        pieces
            .into_iter()
            .filter(|p| p.len() >= 2 && length(p) >= min_length)
            .collect(),
    )
 }
 /// Ein einzelner Vektor-Strich auf einer Seite.
 #[derive(Debug, Clone, PartialEq)]
 pub struct Stroke {
@@ -208,6 +371,9 @@ pub struct Stroke {
    /// Bildecken oben links, oben rechts, unten rechts, unten links; Verschieben, Drehen und
    /// Skalieren wirken so automatisch auch auf Bilder. Bilder liegen immer unter der Tinte.
    pub image: Option<String>,
    /// Textfeld (Text-Werkzeug); die vier Punkte sind wie bei Bildern die Ecken des Felds.
    /// Textfelder liegen wie Bilder unter der Tinte.
    pub text: Option<crate::text::TextBox>,
 }
 impl Stroke {
@@ -241,6 +407,7 @@ impl Stroke {
            width: 5.0,
            finalized: true,
            image: None,
            text: None,
        }
    }
@@ -260,11 +427,48 @@ impl Stroke {
        stroke
    }
    /// Erzeugt ein Textfeld mit den Ecken oben links, oben rechts, unten rechts, unten links.
    pub fn new_text(
        id: u64,
        text: crate::text::TextBox,
        corners: [glam::Vec2; 4],
        color: [f32; 4],
    ) -> Self {
        let mut stroke = Self::new_image(id, String::new(), corners);
        stroke.image = None;
        stroke.color = color;
        stroke.text = Some(text);
        stroke
    }
    /// Ist dieses Objekt ein Bild?
    pub fn is_image(&self) -> bool {
        self.image.is_some()
    }
    /// Ist dieses Objekt ein Textfeld?
    pub fn is_text(&self) -> bool {
        self.text.is_some()
    }
    /// Bild oder Textfeld (Objekt mit vier Ecken statt Tinte)?
    pub fn is_object(&self) -> bool {
        self.is_image() || self.is_text()
    }
    /// Ecken eines Bildes oder Textfelds (oben links, oben rechts, unten rechts, unten links).
    pub fn object_corners(&self) -> Option<[glam::Vec2; 4]> {
        if !self.is_object() || self.points.len() < 4 {
            return None;
        }
        Some([
            self.points[0].position,
            self.points[1].position,
            self.points[2].position,
            self.points[3].position,
        ])
    }
    /// Bildecken (oben links, oben rechts, unten rechts, unten links), falls ein Bild.
    pub fn image_corners(&self) -> Option<[glam::Vec2; 4]> {
        if self.image.is_none() || self.points.len() < 4 {
@@ -311,9 +515,9 @@ impl Stroke {
    }
    /// Berechnet den minimalen euklidischen Abstand eines Punktes zu diesem Strich.
-    /// Bei Bildern ist der Abstand innerhalb der Bildfläche 0.
+    /// Bei Bildern und Textfeldern ist der Abstand innerhalb der Fläche 0.
    pub fn distance_to_point(&self, p: glam::Vec2) -> f32 {
-        if let Some(corners) = self.image_corners() {
+        if let Some(corners) = self.object_corners() {
            if point_in_convex_quad(p, &corners) {
                return 0.0;
            }
@@ -489,6 +693,10 @@ pub struct Page {
    pub id: u64,
    pub strokes: Vec<Stroke>,
    pub background: PageBackground,
    /// Importierte PDF-Seite als Hintergrund (unter Bildern und Tinte)
    pub pdf_background: Option<PdfBackground>,
    /// Seitentitel (Lesezeichen); auch im Manifest, damit er ohne Laden der Seite bekannt ist
    pub title: Option<String>,
    pub vertex_cache: Vec<InkVertex>,
    pub stroke_ranges: Vec<Range<u32>>,
    pub is_dirty: bool,
@@ -503,6 +711,8 @@ impl Page {
            id,
            strokes: Vec::new(),
            background,
            pdf_background: None,
            title: None,
            vertex_cache: Vec::new(),
            stroke_ranges: Vec::new(),
            is_dirty: false,
@@ -518,6 +728,8 @@ impl Page {
            id,
            strokes: Vec::new(),
            background,
            pdf_background: None,
            title: None,
            vertex_cache: Vec::new(),
            stroke_ranges: Vec::new(),
            is_dirty: false,
@@ -560,7 +772,8 @@ impl Page {
    }
    /// Findet den nächsten Strich an Position `pos` innerhalb eines maximalen Suchradius.
-    /// Tinte hat Vorrang vor Bildern darunter, damit Notizen auf einem Bild auswählbar bleiben.
+    /// Tinte hat Vorrang vor Bildern und Textfeldern darunter, damit Notizen darauf
    /// auswählbar bleiben.
    pub fn find_stroke_at(&self, pos: glam::Vec2, max_dist: f32) -> Option<&Stroke> {
        let mut best: Option<(&Stroke, (bool, f32))> = None;
        for s in &self.strokes {
@@ -569,8 +782,8 @@ impl Page {
            }
            let d = s.distance_to_point(pos);
            if d <= max_dist {
-                let key = (s.is_image(), d);
+                let key = (s.is_object(), d);
-                if best.map_or(true, |(_, best_key)| key < best_key) {
+                if best.is_none_or(|(_, best_key)| key < best_key) {
                    best = Some((s, key));
                }
            }
@@ -612,7 +825,7 @@ impl Page {
        let mut hit_indices = Vec::new();
        for (i, stroke) in self.strokes.iter().enumerate() {
-            if !stroke.is_image()
+            if !stroke.is_object()
                && mode.erases(stroke.tool)
                && stroke.intersects_eraser(eraser_pos, eraser_radius, max_stroke_radius)
            {
@@ -638,6 +851,66 @@ impl Page {
        removed
    }
    /// Teilradierer: entfernt den Teil aller Striche im Kreis um `eraser_pos`. Getroffene
    /// Striche werden durch ihre übrig gebliebenen Stücke ersetzt (neue IDs aus `next_id`),
    /// Formen als Ganzes entfernt, Bilder und Textfelder nie. Aufeinanderfolgende Schnitte
    /// eines Radierzugs bilden einen gemeinsamen Undo-Schritt. Gibt `true` zurück, wenn sich etwas geändert hat.
    pub fn erase_partial_at(
        &mut self,
        eraser_pos: glam::Vec2,
        eraser_radius: f32,
        next_id: &mut u64,
    ) -> bool {
        let mut removed = Vec::new();
        let mut added = Vec::new();
        let mut result = Vec::with_capacity(self.strokes.len());
        for stroke in std::mem::take(&mut self.strokes) {
            let reach = eraser_radius + stroke.width / 2.0;
            if stroke.is_object() || !stroke.aabb.expanded(reach).contains_point(eraser_pos) {
                result.push(stroke);
                continue;
            }
            if stroke.shape.is_some() {
                // Formen werden ganz radiert, sobald der Radierer sie berührt
                if stroke.distance_to_point(eraser_pos) <= reach {
                    removed.push(stroke);
                } else {
                    result.push(stroke);
                }
                continue;
            }
            match split_samples_at_circle(&stroke.points, eraser_pos, reach, stroke.width * 0.5) {
                None => result.push(stroke),
                Some(pieces) => {
                    for samples in pieces {
                        let vertices = crate::storage::reconstruct_stroke_vertices(
                            &samples,
                            stroke.color,
                            stroke.width,
                            stroke.tool,
                            true,
                        );
                        let mut piece = Stroke::new(*next_id, samples, vertices, stroke.color);
                        *next_id += 1;
                        piece.tool = stroke.tool;
                        piece.width = stroke.width;
                        piece.finalized = true;
                        result.push(piece.clone());
                        added.push(piece);
                    }
                    removed.push(stroke);
                }
            }
        }
        self.strokes = result;
        if removed.is_empty() {
            return false;
        }
        self.history.push_split(removed, added);
        self.is_dirty = true;
        true
    }
    /// Baut den gecachten Vertex-Puffer der Seite neu auf, wenn `is_dirty` gesetzt ist.
    pub fn rebuild_cache_if_dirty(&mut self) {
        if !self.is_dirty {
@@ -669,8 +942,8 @@ impl Page {
    }
    /// Findet die IDs aller Striche, die die gegebene Auswahlbox schneiden oder darin liegen.
-    /// Bilder werden nur ausgewählt, wenn sie ganz in der Box liegen – sonst würde jede
+    /// Bilder und Textfelder werden nur ausgewählt, wenn sie ganz in der Box liegen – sonst
-    /// Auswahl von Notizen auf einem Bild das Bild mitnehmen.
+    /// würde jede Auswahl von Notizen auf einem Bild das Bild mitnehmen.
    pub fn find_strokes_in_box(&self, box_min: glam::Vec2, box_max: glam::Vec2) -> Vec<u64> {
        let sel_box = Aabb::new(
            glam::Vec2::new(box_min.x.min(box_max.x), box_min.y.min(box_max.y)),
@@ -679,7 +952,7 @@ impl Page {
        self.strokes
            .iter()
            .filter(|s| {
-                if s.is_image() {
+                if s.is_object() {
                    sel_box.contains_point(s.aabb.min) && sel_box.contains_point(s.aabb.max)
                } else {
                    s.aabb.intersects(&sel_box)
@@ -781,6 +1054,10 @@ impl Page {
    }
 }
 /// Höhe des Bereichs am unteren Rand der letzten Seite, in dem Schreiben in der
 /// durchgehenden Ansicht automatisch eine neue Seite anhängt.
 pub const AUTO_APPEND_ZONE: f32 = PAGE_HEIGHT * 0.2;
 /// Das Notizbuch mit diskreter Seitenverwaltung und Navigation.
 #[derive(Debug, Clone)]
 pub struct Notebook {
@@ -838,6 +1115,25 @@ impl Notebook {
        &mut self.pages[self.current_page_index]
    }
    /// Radiert auf der aktuellen Seite gemäß `mode` (ganze Striche, nur Textmarker oder
    /// Teilstriche). Gibt `true` zurück, wenn sich etwas geändert hat.
    pub fn erase_at(
        &mut self,
        eraser_pos: glam::Vec2,
        eraser_radius: f32,
        max_stroke_radius: f32,
        mode: EraserMode,
    ) -> bool {
        let page = &mut self.pages[self.current_page_index];
        if mode == EraserMode::Partial {
            page.erase_partial_at(eraser_pos, eraser_radius, &mut self.next_stroke_id)
        } else {
            !page
                .erase_at(eraser_pos, eraser_radius, max_stroke_radius, mode)
                .is_empty()
        }
    }
    /// Erzeugt eine eindeutige neue Stroke-ID.
    pub fn next_stroke_id(&mut self) -> u64 {
        let id = self.next_stroke_id;
@@ -853,6 +1149,20 @@ impl Notebook {
        self.pages.len() - 1
    }
    /// Durchgehende Ansicht: Reicht ein neuer Strich auf der letzten Seite bis in deren
    /// unteres Fünftel ([`AUTO_APPEND_ZONE`]), wird darunter eine leere Seite mit gleichem
    /// Hintergrund angehängt. `true`, wenn eine Seite angehängt wurde.
    pub fn append_page_if_writing_at_end(&mut self, stroke_bottom: f32) -> bool {
        if self.current_page_index + 1 != self.pages.len()
            || stroke_bottom < PAGE_HEIGHT - AUTO_APPEND_ZONE
        {
            return false;
        }
        let background = self.current_page().background;
        self.add_page(background);
        true
    }
    /// Wechselt zur nächsten Seite (PageDown / N). Hängt automatisch eine neue Seite an, falls am Ende.
    pub fn next_page(&mut self) {
        if self.current_page_index + 1 < self.pages.len() {
@@ -884,6 +1194,20 @@ impl Notebook {
        }
    }
    /// Setzt den Titel der Seite `page_id` (leer = kein Titel). `true`, wenn er sich geändert
    /// hat.
    pub fn set_page_title(&mut self, page_id: u64, title: &str) -> bool {
        let title = normalize_page_title(title);
        let Some(page) = self.pages.iter_mut().find(|p| p.id == page_id) else {
            return false;
        };
        if page.title == title || !page.is_loaded || page.is_readonly() {
            return false;
        }
        page.title = title;
        true
    }
    /// Text für das On-Screen-Display (OSD), z. B. "Seite 3 / 12".
    pub fn osd_text(&self) -> String {
        format!(
@@ -1340,6 +1664,168 @@ mod tests {
        assert!((rotated[0] - glam::Vec2::new(250.0, 50.0)).length() < 1e-3);
    }
    fn line_samples(points: &[(f32, f32)]) -> Vec<StylusSample> {
        points
            .iter()
            .enumerate()
            .map(|(i, &(x, y))| StylusSample {
                position: glam::Vec2::new(x, y),
                pressure: 0.5,
                timestamp: i as f64,
            })
            .collect()
    }
    #[test]
    fn test_split_samples_at_circle() {
        let c = glam::Vec2::new(50.0, 0.0);
        // Lange Strecke mit nur zwei Punkten, Kreis in der Mitte: zwei Stücke, am Rand gekürzt
        let pieces =
            split_samples_at_circle(&line_samples(&[(0.0, 0.0), (100.0, 0.0)]), c, 10.0, 1.0)
                .unwrap();
        assert_eq!(pieces.len(), 2);
        assert!((pieces[0].last().unwrap().position.x - 40.0).abs() < 1e-3);
        assert!((pieces[1][0].position.x - 60.0).abs() < 1e-3);
        // Druck und Zeit werden am Schnittpunkt interpoliert
        assert!((pieces[0].last().unwrap().timestamp - 0.4).abs() < 1e-3);
        // Viele Punkte, Kreis am Ende: ein Stück bleibt
        let dense: Vec<(f32, f32)> = (0..=10).map(|i| (i as f32 * 10.0, 0.0)).collect();
        let pieces = split_samples_at_circle(
            &line_samples(&dense),
            glam::Vec2::new(100.0, 0.0),
            15.0,
            1.0,
        )
        .unwrap();
        assert_eq!(pieces.len(), 1);
        assert!((pieces[0].last().unwrap().position.x - 85.0).abs() < 1e-3);
        // Ganz im Kreis: nichts bleibt; Kreis weit weg: unberührt
        assert_eq!(
            split_samples_at_circle(&line_samples(&[(48.0, 0.0), (52.0, 0.0)]), c, 10.0, 1.0),
            Some(Vec::new())
        );
        assert_eq!(
            split_samples_at_circle(
                &line_samples(&dense),
                glam::Vec2::new(50.0, 40.0),
                10.0,
                1.0
            ),
            None
        );
        // Winziger Rest wird verworfen
        let pieces = split_samples_at_circle(
            &line_samples(&[(0.0, 0.0), (100.0, 0.0)]),
            glam::Vec2::new(5.0, 0.0),
            4.0,
            2.0,
        )
        .unwrap();
        assert_eq!(pieces.len(), 1);
        assert!((pieces[0][0].position.x - 9.0).abs() < 1e-3);
    }
    #[test]
    fn test_partial_erase_splits_and_undoes_in_one_step() {
        let mut notebook = Notebook::new();
        let mut stroke = Stroke::new(
            1,
            line_samples(&[(100.0, 100.0), (500.0, 100.0)]),
            Vec::new(),
            [0.0, 0.0, 0.0, 1.0],
        );
        stroke.width = 5.0;
        notebook.next_stroke_id = 10;
        let page = notebook.current_page_mut();
        page.add_stroke(stroke);
        page.add_stroke(Stroke::new_image(
            2,
            "a.png".into(),
            [
                glam::Vec2::new(0.0, 0.0),
                glam::Vec2::new(900.0, 0.0),
                glam::Vec2::new(900.0, 900.0),
                glam::Vec2::new(0.0, 900.0),
            ],
        ));
        let mut shape = crate::geometry::shape_to_stroke(
            crate::geometry::RecognizedShape::Line {
                start: glam::Vec2::new(100.0, 300.0),
                end: glam::Vec2::new(500.0, 300.0),
            },
            3,
            [0.0, 0.0, 0.0, 1.0],
            5.0,
        );
        shape.recompute_aabb();
        page.add_stroke(shape);
        let undo_depth = page.history.undo_stack.len();
        // Zwei Schnitte desselben Zugs durch die Linie
        assert!(notebook.erase_at(
            glam::Vec2::new(200.0, 100.0),
            20.0,
            12.0,
            EraserMode::Partial
        ));
        assert!(notebook.erase_at(
            glam::Vec2::new(400.0, 100.0),
            20.0,
            12.0,
            EraserMode::Partial
        ));
        // Form wird als Ganzes radiert
        assert!(notebook.erase_at(
            glam::Vec2::new(300.0, 300.0),
            20.0,
            12.0,
            EraserMode::Partial
        ));
        let page = notebook.current_page();
        let ink: Vec<&Stroke> = page.strokes.iter().filter(|s| !s.is_image()).collect();
        assert_eq!(ink.len(), 3, "Linie in drei Stücke zerlegt, Form entfernt");
        assert!(ink.iter().all(|s| s.id >= 10 && !s.vertices.is_empty()));
        assert!(page.strokes.iter().any(|s| s.id == 2), "Bild bleibt");
        assert!(notebook.next_stroke_id > 10);
        // Ein einziger Undo-Schritt stellt alles wieder her
        let page = notebook.current_page_mut();
        assert_eq!(page.history.undo_stack.len(), undo_depth + 1);
        assert!(page.undo());
        let mut ids: Vec<u64> = page.strokes.iter().map(|s| s.id).collect();
        ids.sort();
        assert_eq!(ids, vec![1, 2, 3]);
        assert!(page.redo());
        assert_eq!(page.strokes.iter().filter(|s| !s.is_image()).count(), 3);
        // Danebenradieren ändert nichts
        assert!(!notebook.erase_at(
            glam::Vec2::new(800.0, 800.0),
            20.0,
            12.0,
            EraserMode::Partial
        ));
    }
    #[test]
    fn test_append_page_when_writing_at_bottom_of_last_page() {
        let mut nb = Notebook::new();
        nb.current_page_mut().background = PageBackground::Lined;
        // Oben auf der Seite: nichts
        assert!(!nb.append_page_if_writing_at_end(PAGE_HEIGHT * 0.5));
        assert_eq!(nb.pages.len(), 1);
        // Unten: neue Seite mit gleichem Hintergrund, die aktuelle Seite bleibt
        assert!(nb.append_page_if_writing_at_end(PAGE_HEIGHT - 10.0));
        assert_eq!(nb.pages.len(), 2);
        assert_eq!(nb.current_page_index, 0);
        assert_eq!(nb.pages[1].background, PageBackground::Lined);
        // Nicht auf der letzten Seite: nichts
        assert!(!nb.append_page_if_writing_at_end(PAGE_HEIGHT - 10.0));
        assert_eq!(nb.pages.len(), 2);
    }
    #[test]
    fn test_page_isolation() {
        let mut nb = Notebook::new();
@@ -2,13 +2,15 @@
 //!
 //! Features:
 //! - Hochformat DIN A4 (210 mm x 297 mm)
-//! - Layer pro Seite: "Background", "Images" (nur bei eingefügten Bildern) und "Ink"
+//! - Layer pro Seite: "Background", "Images" (nur bei eingefügten Bildern), "Text" (nur bei
 //!   Textfeldern; echter, durchsuchbarer Text mit eingebetteter Schrift) und "Ink"
 //! - Y-Achsen-Spiegelung (PDF-Ursprung unten links vs. Bildschirmursprung oben links)
 //! - Vektor-Hintergründe (Kariert 5mm, Liniert, Punktraster, Blanko)
 //! - Zwei Export-Strategien:
 //!   - `FilledPolygon`: Glatte gefüllte Polygone aus den Triangle-Strip-Hüllen (variable Pinselstärke)
 //!   - `BezierCurve`: Glatte kubische Bézier-Kurven via `printpdf::Line`
 use std::collections::HashMap;
 use std::error::Error;
 use std::fs::File;
 use std::io::BufWriter;
@@ -22,6 +24,9 @@ use crate::background::{GRID_5MM_SPACING, LINED_SPACING};
 use crate::document::{
    Notebook, Page, PageBackground, Stroke, A4_HEIGHT_MM, A4_WIDTH_MM, PAGE_HEIGHT, PAGE_WIDTH,
 };
 use ab_glyph::Font as _;
 use crate::text::TextFont;
 /// Bereinigt einen Titel für die Verwendung in Dateinamen (entfernt illegale Zeichen).
 pub fn sanitize_filename_component(title: &str) -> String {
@@ -79,6 +84,20 @@ pub fn resolve_pdf_export_path_in_dir(dir: &Path, title: &str) -> PathBuf {
    }
 }
 /// Kollisionsfreier Pfad `~/Documents/<name>.<ext>` (Verzeichnis wird angelegt).
 pub fn resolve_export_path(name: &str, ext: &str) -> PathBuf {
    let dir = default_documents_dir();
    let _ = std::fs::create_dir_all(&dir);
    let base = sanitize_filename_component(name);
    let mut candidate = dir.join(format!("{base}.{ext}"));
    let mut counter = 1;
    while candidate.exists() {
        candidate = dir.join(format!("{base}_{counter}.{ext}"));
        counter += 1;
    }
    candidate
 }
 /// Ermittelt das Ziel für den PDF-Export unter Berücksichtigung von XDG_DOCUMENTS_DIR
 /// und automatischer Namenskollisionsvermeidung. Erstellt das Verzeichnis, falls nötig.
 pub fn resolve_pdf_export_path(title: &str) -> PathBuf {
@@ -117,10 +136,11 @@ pub fn export_notebook_to_pdf<P: AsRef<Path>>(
    strategy: ExportStrategy,
    assets: Option<&AssetStore>,
 ) -> Result<(), Box<dyn Error>> {
    let bytes = export_notebook_to_bytes(notebook, strategy, assets)?;
    let file = File::create(path)?;
    let mut writer = BufWriter::new(file);
-    let doc = generate_pdf_document(notebook, strategy, assets)?;
+    std::io::Write::write_all(&mut writer, &bytes)?;
-    doc.save(&mut writer)?;
+    std::io::Write::flush(&mut writer)?;
    Ok(())
 }
@@ -131,15 +151,132 @@ pub fn export_notebook_to_bytes(
    assets: Option<&AssetStore>,
 ) -> Result<Vec<u8>, Box<dyn Error>> {
    let doc = generate_pdf_document(notebook, strategy, assets)?;
-    let bytes = doc.save_to_bytes()?;
+    let bytes = fix_text_encoding(doc.save_to_bytes()?, notebook)?;
-    Ok(bytes)
+
    // Importierte PDF-Seiten als Vektorgrafik unterlegen
    let underlays = pdf_underlays(notebook);
    if underlays.is_empty() {
        return Ok(bytes);
    }
    let sources: std::collections::HashMap<String, Vec<u8>> = underlays
        .iter()
        .filter_map(|u| Some((u.source.clone(), assets?.read_bytes(&u.source).ok()?)))
        .collect();
    let (merged, failed) = crate::pdf_merge::apply_underlays(&bytes, &underlays, &sources)?;
    if failed.is_empty() {
        return Ok(merged);
    }
    // Nicht übernehmbare Seiten (z. B. verschlüsselte PDFs) als Bild einbetten
    let mut raster = std::collections::HashSet::new();
    for (underlay, err) in &failed {
        eprintln!(
            "[PDF-Export] Seite {} des PDFs als Bild statt als Vektor: {err}",
            underlay.source_page + 1
        );
        raster.insert(underlay.target_page);
    }
    let doc = generate_pdf_document_with(notebook, strategy, assets, &raster)?;
    let bytes = fix_text_encoding(doc.save_to_bytes()?, notebook)?;
    let remaining: Vec<_> = underlays
        .into_iter()
        .filter(|u| !raster.contains(&u.target_page))
        .collect();
    if remaining.is_empty() {
        return Ok(bytes);
    }
    let (merged, _) = crate::pdf_merge::apply_underlays(&bytes, &remaining, &sources)?;
    Ok(merged)
 }
 /// printpdf schreibt Lesezeichen-Titel als rohes UTF-8, PDF-Betrachter lesen Textstrings aber
 /// als PDFDocEncoding oder UTF-16BE: Umlaute und Gedankenstriche würden verstümmelt. Titel
 /// mit Nicht-ASCII-Zeichen werden deshalb nach UTF-16BE (mit BOM) umgeschrieben.
 fn fix_text_encoding(bytes: Vec<u8>, notebook: &Notebook) -> Result<Vec<u8>, Box<dyn Error>> {
    let needs_fix = notebook
        .pages
        .iter()
        .filter_map(|p| p.title.as_deref())
        .any(|t| !t.is_ascii());
    if !needs_fix {
        return Ok(bytes);
    }
    let mut doc = printpdf::lopdf::Document::load_mem(&bytes)?;
    for object in doc.objects.values_mut() {
        let Ok(dict) = object.as_dict_mut() else {
            continue;
        };
        if let Ok(printpdf::lopdf::Object::String(raw, format)) = dict.get_mut(b"Title") {
            if let Some(utf16) = utf16be_text(raw) {
                *raw = utf16;
                *format = printpdf::lopdf::StringFormat::Hexadecimal;
            }
        }
    }
    let mut out = Vec::new();
    doc.save_to(&mut out)?;
    Ok(out)
 }
 /// UTF-8-Text als PDF-Textstring in UTF-16BE mit BOM; `None` bei reinem ASCII oder
 /// ungültigem UTF-8.
 fn utf16be_text(raw: &[u8]) -> Option<Vec<u8>> {
    let text = std::str::from_utf8(raw).ok()?;
    if text.is_ascii() {
        return None;
    }
    let mut out = vec![0xFE, 0xFF];
    for unit in text.encode_utf16() {
        out.extend_from_slice(&unit.to_be_bytes());
    }
    Some(out)
 }
 /// Unterlagen für alle Seiten mit importierter PDF-Seite.
 fn pdf_underlays(notebook: &Notebook) -> Vec<crate::pdf_merge::Underlay> {
    notebook
        .pages
        .iter()
        .enumerate()
        .filter_map(|(i, page)| {
            let pdf = page.pdf_background.as_ref()?;
            let corners = pdf.corners();
            let top_right = page_to_pdf_pt(corners[1]);
            let bottom_left = page_to_pdf_pt(corners[3]);
            let size = top_right - bottom_left;
            Some(crate::pdf_merge::Underlay {
                target_page: i,
                source: pdf.asset.clone(),
                source_page: pdf.page as usize,
                rect: [bottom_left.x, bottom_left.y, size.x, size.y],
            })
        })
        .collect()
 }
 /// Generiert das `printpdf::PdfDocumentReference` für alle Seiten des Notizbuchs.
 /// Importierte PDF-Seiten sind darin noch nicht enthalten; die legt
 /// [`export_notebook_to_bytes`] anschließend als Vektorgrafik darunter.
 pub fn generate_pdf_document(
    notebook: &Notebook,
    strategy: ExportStrategy,
    assets: Option<&AssetStore>,
 ) -> Result<PdfDocumentReference, Box<dyn Error>> {
    generate_pdf_document_with(
        notebook,
        strategy,
        assets,
        &std::collections::HashSet::new(),
    )
 }
 /// Wie [`generate_pdf_document`]; die PDF-Seiten der Seiten in `raster_pdf_pages` werden
 /// gerendert und als Bild eingebettet.
 fn generate_pdf_document_with(
    notebook: &Notebook,
    strategy: ExportStrategy,
    assets: Option<&AssetStore>,
    raster_pdf_pages: &std::collections::HashSet<usize>,
 ) -> Result<PdfDocumentReference, Box<dyn Error>> {
    if notebook.pages.is_empty() {
        return Err("Notizbuch enthält keine Seiten".into());
@@ -159,27 +296,48 @@ pub fn generate_pdf_document(
    let title = "ink-notes Notebook";
    let (doc, page1_idx, layer1_bg) =
        PdfDocument::new(title, Mm(A4_WIDTH_MM), Mm(A4_HEIGHT_MM), "Background");
    let fonts = embed_text_fonts(&doc, notebook)?;
    // Seitentitel werden zu Lesezeichen (Inhaltsverzeichnis im PDF-Betrachter)
    if let Some(title) = &notebook.pages[0].title {
        doc.add_bookmark(title.clone(), page1_idx);
    }
    // Seite 1 befüllen
    let page1_ref = doc.get_page(page1_idx);
    let layer1_bg_ref = page1_ref.get_layer(layer1_bg);
    render_background_layer(&layer1_bg_ref, notebook.pages[0].background);
    if raster_pdf_pages.contains(&0) {
        render_pdf_raster(&page1_ref.add_layer("PDF"), &notebook.pages[0], assets);
    }
    if notebook.pages[0].strokes.iter().any(Stroke::is_image) {
        render_image_layer(&page1_ref.add_layer("Images"), &notebook.pages[0], assets);
    }
    if notebook.pages[0].strokes.iter().any(Stroke::is_text) {
        render_text_layer(&page1_ref.add_layer("Text"), &notebook.pages[0], &fonts);
    }
    let layer1_ink_ref = page1_ref.add_layer("Ink");
    render_ink_layer(&layer1_ink_ref, &notebook.pages[0], strategy);
    // 2. Alle nachfolgenden Seiten hinzufügen
-    for page in &notebook.pages[1..] {
+    for (i, page) in notebook.pages.iter().enumerate().skip(1) {
        let (page_idx, layer_bg) = doc.add_page(Mm(A4_WIDTH_MM), Mm(A4_HEIGHT_MM), "Background");
        if let Some(title) = &page.title {
            doc.add_bookmark(title.clone(), page_idx);
        }
        let page_ref = doc.get_page(page_idx);
        let layer_bg_ref = page_ref.get_layer(layer_bg);
        render_background_layer(&layer_bg_ref, page.background);
        if raster_pdf_pages.contains(&i) {
            render_pdf_raster(&page_ref.add_layer("PDF"), page, assets);
        }
        if page.strokes.iter().any(Stroke::is_image) {
            render_image_layer(&page_ref.add_layer("Images"), page, assets);
        }
        if page.strokes.iter().any(Stroke::is_text) {
            render_text_layer(&page_ref.add_layer("Text"), page, &fonts);
        }
        let layer_ink_ref = page_ref.add_layer("Ink");
        render_ink_layer(&layer_ink_ref, page, strategy);
@@ -279,7 +437,7 @@ fn render_background_layer(layer: &printpdf::PdfLayerReference, background: Page
 /// Rendert alle Striche einer Seite auf Layer 2 ("Ink").
 fn render_ink_layer(layer: &printpdf::PdfLayerReference, page: &Page, strategy: ExportStrategy) {
    for stroke in &page.strokes {
-        if stroke.is_image() {
+        if stroke.is_object() {
            continue;
        }
        if let Some(ref shape) = stroke.shape {
@@ -390,17 +548,7 @@ fn pdf_image_xobject(
            rgb.push(((*c as u32 * alpha + 255 * (255 - alpha)) / 255) as u8);
        }
    }
-    Ok(ImageXObject {
+    Ok(rgb_xobject(rgba.width(), rgba.height(), rgb))
        width: Px(rgba.width() as usize),
        height: Px(rgba.height() as usize),
        color_space: ColorSpace::Rgb,
        bits_per_component: ColorBits::Bit8,
        interpolate: true,
        image_data: rgb,
        image_filter: None,
        smask: None,
        clipping_bbox: None,
    })
 }
 /// Rendert die eingefügten Bilder einer Seite. Fehlt eine Bilddatei, erscheint an ihrer
@@ -420,37 +568,171 @@ fn render_image_layer(
                if let Some(Err(err)) = other {
                    eprintln!("[PDF-Export] Bild '{asset}' fehlt oder ist beschädigt: {err}");
                }
-                printpdf::ImageXObject {
+                placeholder_xobject()
                    width: printpdf::Px(1),
                    height: printpdf::Px(1),
                    color_space: printpdf::ColorSpace::Rgb,
                    bits_per_component: printpdf::ColorBits::Bit8,
                    interpolate: false,
                    image_data: vec![200, 200, 200],
                    image_filter: None,
                    smask: None,
                    clipping_bbox: None,
                }
            }
        };
-        let (width, height) = (xobject.width.0 as f32, xobject.height.0 as f32);
+        draw_image_xobject(layer, xobject, &corners);
    }
 }
 /// Bettet die von Textfeldern des Notizbuchs verwendeten Schriften ein.
 fn embed_text_fonts(
    doc: &PdfDocumentReference,
    notebook: &Notebook,
 ) -> Result<HashMap<TextFont, printpdf::IndirectFontRef>, Box<dyn Error>> {
    let mut fonts = HashMap::new();
    let used = notebook
        .pages
        .iter()
        .flat_map(|p| &p.strokes)
        .filter_map(|s| s.text.as_ref().map(|t| t.font));
    for font in used {
        if let std::collections::hash_map::Entry::Vacant(entry) = fonts.entry(font) {
            entry.insert(doc.add_external_font(font.bytes())?);
        }
    }
    Ok(fonts)
 }
 /// Rendert die Textfelder einer Seite als echten Text: Jedes Feld wird in seinem eigenen
 /// Koordinatensystem (eine Einheit = eine Seiteneinheit, y nach oben) gesetzt, das eine
 /// Transformationsmatrix auf seine Ecken abbildet – so stimmen Drehung und Skalierung.
 fn render_text_layer(
    layer: &printpdf::PdfLayerReference,
    page: &Page,
    fonts: &HashMap<TextFont, printpdf::IndirectFontRef>,
 ) {
    for stroke in &page.strokes {
        let (Some(text), Some(corners)) = (&stroke.text, stroke.object_corners()) else {
            continue;
        };
        let Some(font) = fonts.get(&text.font) else {
            continue;
        };
        let layout = text.layout();
        let size = glam::Vec2::new(text.wrap_width.max(text.size), layout.height());
        let (origin, [right, down]) = crate::text::frame_axes(&corners, size);
        // Seite → PDF-Punkte: x · k, Höhe − y · k
        let k = A4_WIDTH_MM / PAGE_WIDTH * 72.0 / 25.4;
        let o = page_to_pdf_pt(origin);
        let matrix = [right.x * k, -right.y * k, -down.x * k, down.y * k, o.x, o.y];
        layer.save_graphics_state();
-        layer.set_ctm(printpdf::CurTransMat::Raw(image_matrix(&corners)));
+        layer.set_ctm(printpdf::CurTransMat::Raw(matrix));
-        // Bei 72 dpi ist ein Pixel ein Punkt; die Skalierung bildet das Bild auf das
+        layer.set_fill_color(Color::Rgb(Rgb::new(
-        // Einheitsquadrat ab, die Matrix oben auf die Bildecken
+            stroke.color[0],
-        printpdf::Image::from(xobject).add_to_layer(
+            stroke.color[1],
-            layer.clone(),
+            stroke.color[2],
-            printpdf::ImageTransform {
+            None,
-                dpi: Some(72.0),
+        )));
-                scale_x: Some(1.0 / width),
+        layer.begin_text_section();
-                scale_y: Some(1.0 / height),
+        layer.set_font(font, text.size);
-                ..Default::default()
+        for (i, line) in layout.lines.iter().enumerate() {
-            },
+            if line.text.trim().is_empty() {
-        );
+                continue;
            }
            layer.set_text_matrix(printpdf::TextMatrix::Translate(
                printpdf::Pt(0.0),
                printpdf::Pt(-layout.baseline(i)),
            ));
            // Glyphen samt Unterschneidung wie auf dem Bildschirm (Abstände in 1/1000 Em)
            let face = text.font.face();
            let per_em = 1000.0 / face.units_per_em().unwrap_or(1000.0);
            let mut previous: Option<ab_glyph::GlyphId> = None;
            layer.write_positioned_codepoints(line.glyphs.iter().map(|&(id, _)| {
                let kern = previous.map_or(0.0, |p| face.kern_unscaled(p, id));
                previous = Some(id);
                ((-kern * per_em).round() as i64, id.0)
            }));
        }
        layer.end_text_section();
        layer.restore_graphics_state();
    }
 }
 /// Graue 1×1-Fläche für fehlende Bilder.
 fn placeholder_xobject() -> printpdf::ImageXObject {
    rgb_xobject(1, 1, vec![200, 200, 200])
 }
 fn rgb_xobject(width: u32, height: u32, rgb: Vec<u8>) -> printpdf::ImageXObject {
    printpdf::ImageXObject {
        width: printpdf::Px(width as usize),
        height: printpdf::Px(height as usize),
        color_space: printpdf::ColorSpace::Rgb,
        bits_per_component: printpdf::ColorBits::Bit8,
        interpolate: true,
        image_data: rgb,
        image_filter: None,
        smask: None,
        clipping_bbox: None,
    }
 }
 /// Zeichnet ein Bild so, dass es die Ecken oben links, oben rechts, unten rechts,
 /// unten links ausfüllt.
 fn draw_image_xobject(
    layer: &printpdf::PdfLayerReference,
    xobject: printpdf::ImageXObject,
    corners: &[glam::Vec2; 4],
 ) {
    let (width, height) = (xobject.width.0 as f32, xobject.height.0 as f32);
    layer.save_graphics_state();
    layer.set_ctm(printpdf::CurTransMat::Raw(image_matrix(corners)));
    // Bei 72 dpi ist ein Pixel ein Punkt; die Skalierung bildet das Bild auf das
    // Einheitsquadrat ab, die Matrix oben auf die Bildecken
    printpdf::Image::from(xobject).add_to_layer(
        layer.clone(),
        printpdf::ImageTransform {
            dpi: Some(72.0),
            scale_x: Some(1.0 / width),
            scale_y: Some(1.0 / height),
            ..Default::default()
        },
    );
    layer.restore_graphics_state();
 }
 /// Auflösung, mit der PDF-Seiten gerendert werden, die nicht als Vektor übernommen
 /// werden können.
 const PDF_RASTER_DPI: f32 = 200.0;
 /// Bettet die importierte PDF-Seite als gerendertes Bild ein (Ausweichlösung).
 fn render_pdf_raster(
    layer: &printpdf::PdfLayerReference,
    page: &Page,
    assets: Option<&AssetStore>,
 ) {
    let Some(pdf) = &page.pdf_background else {
        return;
    };
    let longest_pt = pdf.width_pt.max(pdf.height_pt);
    let max_pixels = (longest_pt / 72.0 * PDF_RASTER_DPI).ceil() as u32;
    let rendered = assets
        .ok_or_else(|| "kein Asset-Ordner".to_string())
        .and_then(|a| a.path_of(&pdf.asset).map_err(|e| e.to_string()))
        .and_then(|path| crate::pdf_doc::render_file_page(&path, pdf.page as usize, max_pixels));
    let xobject = match rendered {
        Ok(image) => {
            let rgb = image
                .pixels
                .as_chunks::<4>()
                .0
                .iter()
                .flat_map(|px| [px[0], px[1], px[2]])
                .collect();
            rgb_xobject(image.width, image.height, rgb)
        }
        Err(err) => {
            eprintln!(
                "[PDF-Export] PDF-Seite {} nicht darstellbar: {err}",
                pdf.page + 1
            );
            placeholder_xobject()
        }
    };
    draw_image_xobject(layer, xobject, &pdf.corners());
 }
 /// Rendert eine mathematisch bereinigte Form (Gerade, Kreis, Rechteck, Koordinatensystem)
 /// als verlustfreien Vektorpfad im PDF.
 fn render_recognized_shape(
@@ -1209,6 +1491,106 @@ mod tests {
        assert!(export_notebook_to_bytes(&notebook, ExportStrategy::FilledPolygon, None).is_ok());
    }
    #[test]
    fn test_pdf_export_underlays_imported_pages() {
        let temp_dir = tempfile::tempdir().unwrap();
        let source = crate::pdf_doc::tests::sample_pdf(&[(842.0, 595.0, 0), (595.0, 842.0, 90)]);
        let (mut notebook, _, dir) =
            crate::storage::create_notebook_from_pdf(temp_dir.path(), "Folien", source).unwrap();
        crate::storage::load_all_pages(&dir, &mut notebook).unwrap();
        let assets = AssetStore::new(&dir);
        let bytes =
            export_notebook_to_bytes(&notebook, ExportStrategy::FilledPolygon, Some(&assets))
                .unwrap();
        let doc = printpdf::lopdf::Document::load_mem(&bytes).unwrap();
        assert_eq!(doc.get_pages().len(), 2);
        for page_id in doc.get_pages().into_values() {
            let content = doc.get_page_content(page_id).unwrap();
            assert!(
                String::from_utf8_lossy(&content).starts_with("q "),
                "Originalseite fehlt als Unterlage"
            );
        }
        // Exportiertes PDF lässt sich wieder rendern: Folie oben, rotes Quadrat oben links
        let pdf = hayro::hayro_syntax::Pdf::new(bytes).unwrap();
        let image = crate::pdf_doc::render_page(&pdf, 0, 600).unwrap();
        let px = |x: u32, y: u32| {
            let i = ((y * image.width + x) * 4) as usize;
            image.pixels[i..i + 3].to_vec()
        };
        assert_eq!(px(5, 5), vec![255, 0, 0], "Quadrat der Folie oben links");
        assert_eq!(
            px(200, 500),
            vec![255, 255, 255],
            "unter der Folie ist Platz"
        );
        // Gedrehte Seite (/Rotate 90) erscheint wie im PDF-Betrachter: das Quadrat liegt
        // dort oben rechts, in der Quelle wie im Export
        let source_pdf = hayro::hayro_syntax::Pdf::new(
            assets
                .read_bytes(&notebook.pages[1].pdf_background.as_ref().unwrap().asset)
                .unwrap(),
        )
        .unwrap();
        let shown = crate::pdf_doc::render_page(&source_pdf, 1, 600).unwrap();
        let red_at = |img: &crate::assets::RgbaImage, x: u32, y: u32| {
            let i = ((y * img.width + x) * 4) as usize;
            img.pixels[i..i + 3] == [255, 0, 0]
        };
        assert!(red_at(&shown, shown.width - 5, 5));
        let exported = crate::pdf_doc::render_page(&pdf, 1, 600).unwrap();
        assert!(red_at(&exported, exported.width - 5, 5));
        assert!(!red_at(&exported, 5, 5));
        // Ohne Zugriff auf das PDF: Export klappt trotzdem (graue Ersatzfläche)
        assert!(export_notebook_to_bytes(&notebook, ExportStrategy::FilledPolygon, None).is_ok());
    }
    #[test]
    fn test_page_titles_become_pdf_bookmarks() {
        let mut notebook = Notebook::new();
        notebook.add_page(PageBackground::Blank);
        notebook.add_page(PageBackground::Blank);
        let ids: Vec<u64> = notebook.pages.iter().map(|p| p.id).collect();
        notebook.set_page_title(ids[0], "Einleitung");
        notebook.set_page_title(ids[2], "Übung 2 – Integrale");
        let bytes =
            export_notebook_to_bytes(&notebook, ExportStrategy::FilledPolygon, None).unwrap();
        let doc = printpdf::lopdf::Document::load_mem(&bytes).unwrap();
        let catalog = doc.catalog().unwrap();
        assert!(catalog.has(b"Outlines"), "Lesezeichen fehlen");
        // Titel als PDF-Textstrings: ASCII unverändert, Umlaute als UTF-16BE mit BOM
        let titles: Vec<String> = doc
            .objects
            .values()
            .filter_map(|o| o.as_dict().ok())
            .filter(|d| d.has(b"Parent"))
            .filter_map(|d| match d.get(b"Title") {
                Ok(printpdf::lopdf::Object::String(raw, _)) => {
                    Some(if raw.starts_with(&[0xFE, 0xFF]) {
                        let units: Vec<u16> = raw[2..]
                            .chunks(2)
                            .map(|c| u16::from_be_bytes([c[0], c[1]]))
                            .collect();
                        String::from_utf16(&units).unwrap()
                    } else {
                        String::from_utf8(raw.clone()).unwrap()
                    })
                }
                _ => None,
            })
            .collect();
        assert!(titles.contains(&"Einleitung".to_string()), "{titles:?}");
        assert!(
            titles.contains(&"Übung 2 – Integrale".to_string()),
            "{titles:?}"
        );
    }
    #[test]
    fn test_jpeg_component_count() {
        let color = crate::assets::tests::sample_image_bytes(8, 8, image::ImageFormat::Jpeg);
@@ -1,7 +1,7 @@
-//! Eingebaute, stift- und fingertaugliche Dateiauswahl für Bilder.
+//! Eingebaute, stift- und fingertaugliche Dateiauswahl für Bilder und PDFs.
 //!
 //! Bewusst ohne Systemdialog: der bräuchte GTK oder das Desktop-Portal, die unter WSL und auf
-//! schlanken Systemen oft fehlen. Die Auswahl zeigt Ordner und unterstützte Bilder des
+//! schlanken Systemen oft fehlen. Die Auswahl zeigt Ordner und die passenden Dateien des
 //! aktuellen Ordners; versteckte Dateien bleiben ausgeblendet.
 use std::path::{Path, PathBuf};
@@ -16,9 +16,36 @@ pub struct PickerEntry {
    pub is_dir: bool,
 }
 /// Welche Dateien die Auswahl anbietet.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum PickerKind {
    /// Bilder zum Einfügen auf der aktuellen Seite
    Image,
    /// PDF zum Importieren als neues Notizbuch
    Pdf,
 }
 impl PickerKind {
    /// Passt die Datei zu dieser Auswahl?
    pub fn accepts(self, path: &Path) -> bool {
        match self {
            PickerKind::Image => is_supported_image_path(path),
            PickerKind::Pdf => is_pdf_path(path),
        }
    }
 }
 /// Ist die Datei dem Namen nach ein PDF?
 pub fn is_pdf_path(path: &Path) -> bool {
    path.extension()
        .and_then(|e| e.to_str())
        .is_some_and(|e| e.eq_ignore_ascii_case("pdf"))
 }
 /// Zustand der Dateiauswahl.
 #[derive(Debug, Clone, PartialEq)]
 pub struct FilePicker {
    pub kind: PickerKind,
    pub dir: PathBuf,
    pub entries: Vec<PickerEntry>,
    /// Ordner nicht lesbar
@@ -26,14 +53,26 @@ pub struct FilePicker {
 }
 impl FilePicker {
-    /// Öffnet die Auswahl in `dir`, sonst im Bilder-Ordner, sonst im Home-Ordner.
+    /// Öffnet die Auswahl in `dir`, sonst im Bilder-Ordner (Bilder) bzw. Downloads (PDF),
-    pub fn open(dir: Option<&Path>) -> Self {
+    /// sonst im Home-Ordner.
    pub fn open(kind: PickerKind, dir: Option<&Path>) -> Self {
        let start = dir
            .filter(|d| d.is_dir())
            .map(Path::to_path_buf)
-            .or_else(|| shortcuts().into_iter().map(|(_, p)| p).find(|p| p.is_dir()))
+            .or_else(|| {
                let preferred = match kind {
                    PickerKind::Image => "🖼 Bilder",
                    PickerKind::Pdf => "⬇ Downloads",
                };
                let all = shortcuts();
                all.iter()
                    .find(|(label, _)| *label == preferred)
                    .or_else(|| all.last())
                    .map(|(_, p)| p.clone())
            })
            .unwrap_or_else(|| PathBuf::from("/"));
        let mut picker = Self {
            kind,
            dir: start.clone(),
            entries: Vec::new(),
            error: None,
@@ -44,7 +83,7 @@ impl FilePicker {
    /// Wechselt in `dir` und liest den Inhalt neu ein.
    pub fn navigate(&mut self, dir: &Path) {
-        match list_dir(dir) {
+        match list_dir(dir, self.kind) {
            Ok(entries) => {
                self.dir = dir.to_path_buf();
                self.entries = entries;
@@ -67,9 +106,9 @@ impl FilePicker {
    }
 }
-/// Ordner und unterstützte Bilder in `dir`: erst Ordner, dann Dateien, jeweils alphabetisch
+/// Ordner und passende Dateien in `dir`: erst Ordner, dann Dateien, jeweils alphabetisch
 /// ohne Groß-/Kleinschreibung; versteckte Einträge (Punkt am Anfang) fehlen.
-pub fn list_dir(dir: &Path) -> std::io::Result<Vec<PickerEntry>> {
+pub fn list_dir(dir: &Path, kind: PickerKind) -> std::io::Result<Vec<PickerEntry>> {
    let mut entries: Vec<PickerEntry> = std::fs::read_dir(dir)?
        .filter_map(Result::ok)
        .filter_map(|entry| {
@@ -80,7 +119,7 @@ pub fn list_dir(dir: &Path) -> std::io::Result<Vec<PickerEntry>> {
            let path = entry.path();
            // Symlinks auflösen: ein Link auf einen Ordner ist ein Ordner
            let is_dir = path.is_dir();
-            (is_dir || is_supported_image_path(&path)).then_some(PickerEntry { name, path, is_dir })
+            (is_dir || kind.accepts(&path)).then_some(PickerEntry { name, path, is_dir })
        })
        .collect();
    entries.sort_by(|a, b| {
@@ -143,19 +182,32 @@ mod tests {
    #[test]
    fn test_list_dir_sorts_and_filters() {
        let dir = tempfile::tempdir().unwrap();
-        for name in ["b.png", "A.jpg", "notiz.txt", ".versteckt.png", "c.webp"] {
+        for name in [
            "b.png",
            "A.jpg",
            "notiz.txt",
            ".versteckt.png",
            "c.webp",
            "Skript.PDF",
        ] {
            std::fs::write(dir.path().join(name), b"x").unwrap();
        }
        std::fs::create_dir(dir.path().join("zOrdner")).unwrap();
        std::fs::create_dir(dir.path().join("aOrdner")).unwrap();
        std::fs::create_dir(dir.path().join(".cache")).unwrap();
-        let names: Vec<String> = list_dir(dir.path())
+        let names = |kind| -> Vec<String> {
-            .unwrap()
+            list_dir(dir.path(), kind)
-            .into_iter()
+                .unwrap()
-            .map(|e| e.name)
+                .into_iter()
-            .collect();
+                .map(|e| e.name)
-        assert_eq!(names, ["aOrdner", "zOrdner", "A.jpg", "b.png", "c.webp"]);
+                .collect()
        };
        assert_eq!(
            names(PickerKind::Image),
            ["aOrdner", "zOrdner", "A.jpg", "b.png", "c.webp"]
        );
        assert_eq!(names(PickerKind::Pdf), ["aOrdner", "zOrdner", "Skript.PDF"]);
    }
    #[test]
@@ -165,7 +217,7 @@ mod tests {
        std::fs::create_dir(&sub).unwrap();
        std::fs::write(sub.join("tafel.jpg"), b"x").unwrap();
-        let mut picker = FilePicker::open(Some(&sub));
+        let mut picker = FilePicker::open(PickerKind::Image, Some(&sub));
        assert_eq!(picker.dir, sub);
        assert_eq!(picker.entries.len(), 1);
@@ -18,6 +18,13 @@ pub enum HistoryAction {
        before: Vec<Stroke>,
        after: Vec<Stroke>,
    },
    /// Teilradierer: Striche wurden durch ihre übrig gebliebenen Stücke ersetzt.
    SplitStrokes {
        removed: Vec<Stroke>,
        added: Vec<Stroke>,
        /// Zeitpunkt des letzten Schnitts (zum Zusammenfassen eines Radierzugs)
        at: std::time::Instant,
    },
 }
 /// History-Stack für Transaktionsverwaltung (Undo / Redo).
@@ -41,6 +48,40 @@ impl HistoryStack {
        self.redo_stack.clear();
    }
    /// Registriert einen Teilradier-Schnitt. Folgt er innerhalb von
    /// [`crate::document::PARTIAL_ERASE_MERGE_WINDOW`] auf einen vorherigen, werden beide zu
    /// einem Undo-Schritt zusammengefasst: Stücke, die im selben Zug wieder zerschnitten
    /// wurden, verschwinden aus der Bilanz.
    pub fn push_split(&mut self, removed: Vec<Stroke>, added: Vec<Stroke>) {
        let now = std::time::Instant::now();
        if let Some(HistoryAction::SplitStrokes {
            removed: prev_removed,
            added: prev_added,
            at,
        }) = self.undo_stack.last_mut()
        {
            if now.duration_since(*at) <= crate::document::PARTIAL_ERASE_MERGE_WINDOW
                && self.redo_stack.is_empty()
            {
                for stroke in removed {
                    if let Some(pos) = prev_added.iter().position(|s| s.id == stroke.id) {
                        prev_added.remove(pos);
                    } else {
                        prev_removed.push(stroke);
                    }
                }
                prev_added.extend(added);
                *at = now;
                return;
            }
        }
        self.push(HistoryAction::SplitStrokes {
            removed,
            added,
            at: now,
        });
    }
    /// Gibt zurück, ob Undo verfügbar ist.
    pub fn can_undo(&self) -> bool {
        !self.undo_stack.is_empty()
@@ -95,6 +136,12 @@ impl HistoryStack {
                self.redo_stack
                    .push(HistoryAction::ModifyStrokes { before, after });
            }
            HistoryAction::SplitStrokes { removed, added, at } => {
                strokes.retain(|s| !added.iter().any(|a| a.id == s.id));
                strokes.extend(removed.iter().cloned());
                self.redo_stack
                    .push(HistoryAction::SplitStrokes { removed, added, at });
            }
        }
        true
@@ -140,6 +187,12 @@ impl HistoryStack {
                self.undo_stack
                    .push(HistoryAction::ModifyStrokes { before, after });
            }
            HistoryAction::SplitStrokes { removed, added, at } => {
                strokes.retain(|s| !removed.iter().any(|r| r.id == s.id));
                strokes.extend(added.iter().cloned());
                self.undo_stack
                    .push(HistoryAction::SplitStrokes { removed, added, at });
            }
        }
        true
@@ -1,13 +1,13 @@
 //! GPU-Darstellung eingefügter Bilder: ein texturiertes Viereck pro Bild, gezeichnet nach dem
 //! Papier und vor der Tinte.
 //!
-//! Texturen werden beim ersten Bedarf aus dem Asset-Ordner geladen (verkleinert auf
+//! Texturen liefert beim ersten Bedarf eine Texturquelle (Bilddatei oder gerenderte
-//! `assets::MAX_DISPLAY_DIMENSION`) und mit Mipmaps versehen, damit verkleinerte Bilder
+//! PDF-Seite); sie werden mit Mipmaps versehen, damit verkleinerte Bilder beim
-//! beim Herauszoomen nicht flimmern.
+//! Herauszoomen nicht flimmern.
 use std::collections::{HashMap, HashSet};
-use crate::assets::{AssetStore, RgbaImage, MAX_DISPLAY_DIMENSION};
+use crate::assets::RgbaImage;
 /// Vertex eines Bildvierecks: Seitenkoordinate und Texturkoordinate.
 #[repr(C)]
@@ -67,19 +67,30 @@ pub fn mip_chain(base: &RgbaImage) -> Vec<RgbaImage> {
 /// Name der Ersatztextur für Bilder, deren Datei fehlt oder beschädigt ist.
 const MISSING: &str = "";
-/// So viele Texturen bleiben höchstens im Speicher, auch wenn sie auf der aktuellen Seite
+/// Bis zu dieser Grafikspeichermenge bleiben Texturen anderer Seiten erhalten (schnelles
-/// nicht mehr gebraucht werden (schnelles Zurückblättern).
+/// Zurückblättern); darüber werden alle nicht mehr sichtbaren freigegeben.
-const TEXTURE_CACHE_LIMIT: usize = 24;
+const TEXTURE_CACHE_BYTES: u64 = 384 * 1024 * 1024;
 /// Antwort einer Texturquelle für einen Schlüssel.
 pub enum TextureSource {
    Ready(RgbaImage),
    /// Wird gerade erzeugt; später erneut fragen
    Pending,
    Failed(String),
 }
 pub struct ImageLayer {
    pipeline: wgpu::RenderPipeline,
    texture_layout: wgpu::BindGroupLayout,
    sampler: wgpu::Sampler,
-    textures: HashMap<String, wgpu::BindGroup>,
+    /// Texturen nach Schlüssel (Asset-Name bzw. `<pdf>#<seite>`) mit belegtem Speicher
-    /// Bilder der aktuellen Seite: Asset-Name und Ecken
+    textures: HashMap<String, (wgpu::BindGroup, u64)>,
-    quads: Vec<(String, [glam::Vec2; 4])>,
+    texture_bytes: u64,
    /// Bilder je Seite (Gruppe 0: aktuelle Seite, danach die sichtbaren Nachbarseiten):
    /// Asset-Name und Ecken in Koordinaten der jeweiligen Seite
    groups: Vec<Vec<(String, [glam::Vec2; 4])>>,
    vertex_buffer: Option<wgpu::Buffer>,
-    needs_upload: bool,
+    vertices_dirty: bool,
 }
 impl ImageLayer {
@@ -155,58 +166,81 @@ impl ImageLayer {
            texture_layout,
            sampler,
            textures: HashMap::new(),
-            quads: Vec::new(),
+            texture_bytes: 0,
            groups: vec![Vec::new()],
            vertex_buffer: None,
-            needs_upload: false,
+            vertices_dirty: false,
        }
    }
    /// Übernimmt die Bilder der aktuellen Seite (Asset-Name und Ecken in Seitenkoordinaten).
    pub fn set_quads(&mut self, quads: Vec<(String, [glam::Vec2; 4])>) {
-        if quads != self.quads {
+        if quads != self.groups[0] {
-            self.quads = quads;
+            self.groups[0] = quads;
-            self.needs_upload = true;
+            self.vertices_dirty = true;
        }
    }
    /// Übernimmt die Bilder der sichtbaren Nachbarseiten (Gruppen 1, 2, …).
    pub fn set_neighbor_quads(&mut self, neighbors: Vec<Vec<(String, [glam::Vec2; 4])>>) {
        if neighbors[..] != self.groups[1..] {
            self.groups.truncate(1);
            self.groups.extend(neighbors);
            self.vertices_dirty = true;
        }
    }
    fn all_quads(&self) -> impl Iterator<Item = &(String, [glam::Vec2; 4])> {
        self.groups.iter().flatten()
    }
    /// Lädt fehlende Texturen und den Vertex-Puffer hoch. Vor jedem Zeichnen aufrufen;
    /// ohne Änderungen kostet das nichts.
-    pub fn prepare(&mut self, device: &wgpu::Device, queue: &wgpu::Queue, assets: &AssetStore) {
+    pub fn prepare(
-        if !self.needs_upload {
+        &mut self,
-            return;
+        device: &wgpu::Device,
-        }
+        queue: &wgpu::Queue,
-        self.needs_upload = false;
+        load: &mut dyn FnMut(&str) -> TextureSource,
-
+    ) {
        let missing: Vec<String> = self
-            .quads
+            .all_quads()
-            .iter()
+            .map(|(key, _)| key)
-            .map(|(asset, _)| asset)
+            .filter(|key| !self.textures.contains_key(*key))
            .filter(|asset| !self.textures.contains_key(*asset))
            .cloned()
            .collect();
-        for asset in missing {
+        for key in missing {
-            if self.textures.contains_key(&asset) {
+            if self.textures.contains_key(&key) {
                continue;
            }
-            let bind_group = match assets.load_rgba(&asset, MAX_DISPLAY_DIMENSION) {
+            let (bind_group, bytes) = match load(&key) {
-                Ok(image) => self.upload_texture(device, queue, &asset, &image),
+                TextureSource::Ready(image) => (
-                Err(err) => {
+                    self.upload_texture(device, queue, &key, &image),
-                    eprintln!("[Bilder] '{asset}' kann nicht angezeigt werden: {err}");
+                    image.pixels.len() as u64 * 4 / 3,
-                    self.missing_texture(device, queue)
+                ),
                // Noch in Arbeit (PDF-Seite wird gerendert): beim nächsten Bild erneut fragen
                TextureSource::Pending => continue,
                TextureSource::Failed(err) => {
                    eprintln!("[Bilder] '{key}' kann nicht angezeigt werden: {err}");
                    (self.missing_texture(device, queue), 4)
                }
            };
-            self.textures.insert(asset, bind_group);
+            self.texture_bytes += bytes;
            self.textures.insert(key, (bind_group, bytes));
        }
-        // Nicht mehr benötigte Texturen freigeben, wenn der Speicher voll wird
+        // Nicht mehr benötigte Texturen freigeben, wenn der Grafikspeicher knapp wird
-        if self.textures.len() > TEXTURE_CACHE_LIMIT {
+        if self.texture_bytes > TEXTURE_CACHE_BYTES {
-            let used: HashSet<&String> = self.quads.iter().map(|(a, _)| a).collect();
+            let used: HashSet<&String> = self.groups.iter().flatten().map(|(a, _)| a).collect();
            self.textures.retain(|name, _| used.contains(name));
            self.texture_bytes = self.textures.values().map(|(_, b)| b).sum();
        }
        if !self.vertices_dirty {
            return;
        }
        self.vertices_dirty = false;
        let vertices: Vec<ImageVertex> = self
-            .quads
+            .all_quads()
            .iter()
            .flat_map(|(_, corners)| quad_vertices(corners))
            .collect();
        if vertices.is_empty() {
@@ -216,7 +250,7 @@ impl ImageLayer {
        let too_small = self
            .vertex_buffer
            .as_ref()
-            .map_or(true, |b| b.size() < bytes.len() as u64);
+            .is_none_or(|b| b.size() < bytes.len() as u64);
        if too_small {
            self.vertex_buffer = Some(device.create_buffer(&wgpu::BufferDescriptor {
                label: Some("Image Vertex Buffer"),
@@ -230,22 +264,45 @@ impl ImageLayer {
        }
    }
-    /// Zeichnet die Bilder der aktuellen Seite. Bind Group 0 (Kamera) muss gesetzt sein.
+    /// Wird die Textur `key` von einer sichtbaren Seite verwendet?
-    pub fn draw<'a>(&'a self, render_pass: &mut wgpu::RenderPass<'a>) {
+    pub fn uses(&self, key: &str) -> bool {
        self.all_quads().any(|(k, _)| k == key)
    }
    /// Gibt alle Texturen frei, deren Schlüssel `matches` erfüllt (sie werden beim nächsten
    /// `prepare` neu angefordert).
    pub fn forget_textures(&mut self, mut matches: impl FnMut(&str) -> bool) {
        self.textures.retain(|key, _| !matches(key));
        self.texture_bytes = self.textures.values().map(|(_, b)| b).sum();
    }
    /// Fehlen noch Texturen sichtbarer Seiten (z. B. PDF-Seite im Hintergrund-Rendering)?
    pub fn is_waiting(&self) -> bool {
        self.all_quads()
            .any(|(key, _)| !self.textures.contains_key(key))
    }
    /// Zeichnet die Bilder einer Seite (Gruppe 0: aktuelle Seite). Bind Group 0 (Kamera der
    /// Seite) muss gesetzt sein.
    pub fn draw<'a>(&'a self, render_pass: &mut wgpu::RenderPass<'a>, group: usize) {
        let Some(buffer) = &self.vertex_buffer else {
            return;
        };
-        if self.quads.is_empty() || self.needs_upload {
+        let Some(quads) = self.groups.get(group) else {
            return;
        };
        if quads.is_empty() || self.vertices_dirty {
            return;
        }
        let first: usize = self.groups[..group].iter().map(Vec::len).sum();
        render_pass.set_pipeline(&self.pipeline);
        render_pass.set_vertex_buffer(0, buffer.slice(..));
-        for (i, (asset, _)) in self.quads.iter().enumerate() {
+        for (i, (asset, _)) in quads.iter().enumerate() {
-            let Some(bind_group) = self.textures.get(asset) else {
+            let Some((bind_group, _)) = self.textures.get(asset) else {
                continue;
            };
            render_pass.set_bind_group(1, bind_group, &[]);
-            let start = (i * 6) as u32;
+            let start = ((first + i) * 6) as u32;
            render_pass.draw(start..start + 6, 0..1);
        }
    }
@@ -11,11 +11,16 @@ pub mod filter;
 pub mod geometry;
 pub mod history;
 pub mod image_layer;
 pub mod page_export;
 pub mod pdf_doc;
 pub mod pdf_merge;
 pub mod platform;
 pub mod ruler;
 pub mod selection;
 pub mod settings;
 pub mod spline;
 pub mod storage;
 pub mod text;
 pub mod ui;
 pub mod updater;
 pub mod viewport;
@@ -0,0 +1,314 @@
 //! Export einzelner Seiten als PNG oder SVG und einer Auswahl als Bild.
 //!
 //! Grundlage ist immer der PDF-Export: die Seite wird als einseitiges PDF erzeugt (mit
 //! Bildern, importierten PDF-Seiten und Formen) und anschließend mit `hayro` gerastert bzw.
 //! mit `hayro-svg` nach SVG umgewandelt. So sehen PDF, PNG und SVG gleich aus.
 use std::error::Error;
 use hayro::hayro_interpret::InterpreterSettings;
 use hayro::hayro_syntax::Pdf;
 use hayro::vello_cpu::color::palette::css::{TRANSPARENT, WHITE};
 use hayro::{PixmapSettings, RenderCache, RenderSettings};
 use crate::assets::{AssetStore, RgbaImage};
 use crate::document::{Aabb, Notebook, Page, PageBackground, A4_WIDTH_MM, PAGE_WIDTH};
 use crate::export::{export_notebook_to_bytes, ExportStrategy};
 /// Auflösung des PNG-Exports einer Seite.
 pub const PAGE_PNG_DPI: f32 = 200.0;
 /// Auflösung einer in die Zwischenablage kopierten Auswahl.
 pub const SELECTION_PNG_DPI: f32 = 150.0;
 /// Hintergrund beim Bild-Export.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum ImageBackground {
    /// Weißes Papier mit Raster bzw. importierter PDF-Seite
    Paper,
    /// Transparent, nur Bilder und Tinte (ohne Raster und ohne importierte PDF-Seite)
    Transparent,
 }
 /// Erzeugt ein einseitiges PDF aus `page`.
 fn single_page_pdf(page: &Page, assets: Option<&AssetStore>) -> Result<Vec<u8>, Box<dyn Error>> {
    let notebook = Notebook::from_pages(vec![page.clone()], 0, 1, page.id + 1);
    export_notebook_to_bytes(&notebook, ExportStrategy::FilledPolygon, assets)
 }
 /// Seite ohne Raster und PDF-Hintergrund (für transparenten Export und Auswahlen).
 fn content_only(page: &Page) -> Page {
    let mut page = page.clone();
    page.background = PageBackground::Blank;
    page.pdf_background = None;
    page
 }
 /// Rastert die erste Seite eines PDFs mit `dpi`; Farben ohne Vormultiplikation.
 fn rasterize(pdf_bytes: Vec<u8>, dpi: f32, transparent: bool) -> Result<RgbaImage, Box<dyn Error>> {
    let pdf = Pdf::new(pdf_bytes).map_err(|e| format!("PDF nicht lesbar: {e:?}"))?;
    let page = pdf.pages().first().ok_or("PDF ohne Seite")?;
    let scale = dpi / 72.0;
    let pixmap = hayro::render(
        page,
        &RenderCache::new(),
        &InterpreterSettings::default(),
        &RenderSettings::default(),
        &PixmapSettings {
            x_scale: scale,
            y_scale: scale,
            bg_color: if transparent { TRANSPARENT } else { WHITE },
        },
    );
    let mut pixels = pixmap.data_as_u8_slice().to_vec();
    // hayro liefert vormultiplizierte Farben; PNG erwartet gerade Farben
    for px in pixels.as_chunks_mut::<4>().0 {
        let a = px[3] as u32;
        if a > 0 && a < 255 {
            for c in &mut px[..3] {
                *c = ((*c as u32 * 255 + a / 2) / a).min(255) as u8;
            }
        }
    }
    Ok(RgbaImage {
        width: pixmap.width() as u32,
        height: pixmap.height() as u32,
        pixels,
    })
 }
 /// Kodiert ein Bild als PNG.
 pub fn encode_png(image: &RgbaImage) -> Result<Vec<u8>, Box<dyn Error>> {
    let buffer = image::RgbaImage::from_raw(image.width, image.height, image.pixels.clone())
        .ok_or("Pixeldaten passen nicht zur Bildgröße")?;
    let mut out = Vec::new();
    image::DynamicImage::ImageRgba8(buffer)
        .write_to(&mut std::io::Cursor::new(&mut out), image::ImageFormat::Png)?;
    Ok(out)
 }
 /// Seite als PNG (A4 mit [`PAGE_PNG_DPI`]).
 pub fn page_png(
    page: &Page,
    assets: Option<&AssetStore>,
    background: ImageBackground,
 ) -> Result<Vec<u8>, Box<dyn Error>> {
    let image = match background {
        ImageBackground::Paper => rasterize(single_page_pdf(page, assets)?, PAGE_PNG_DPI, false)?,
        ImageBackground::Transparent => rasterize(
            single_page_pdf(&content_only(page), assets)?,
            PAGE_PNG_DPI,
            true,
        )?,
    };
    encode_png(&image)
 }
 /// Seite als SVG (Vektor; Schriften importierter PDFs werden zu Pfaden).
 pub fn page_svg(page: &Page, assets: Option<&AssetStore>) -> Result<String, Box<dyn Error>> {
    let pdf =
        Pdf::new(single_page_pdf(page, assets)?).map_err(|e| format!("PDF nicht lesbar: {e:?}"))?;
    let pdf_page = pdf.pages().first().ok_or("PDF ohne Seite")?;
    Ok(hayro_svg::convert(
        pdf_page,
        &hayro_svg::RenderCache::new(),
        &InterpreterSettings::default(),
        &hayro_svg::SvgRenderSettings {
            bg_color: [255, 255, 255, 255],
        },
    ))
 }
 /// Bild der Objekte `ids` auf `page`, auf ihren Umriss zugeschnitten, mit transparentem
 /// Hintergrund. `None`, wenn keines der Objekte auf der Seite liegt.
 pub fn selection_image(
    page: &Page,
    ids: &[u64],
    assets: Option<&AssetStore>,
 ) -> Result<Option<RgbaImage>, Box<dyn Error>> {
    let mut selected = content_only(page);
    selected.strokes.retain(|s| ids.contains(&s.id));
    let Some(bounds) = Page::selection_aabb(&selected.strokes) else {
        return Ok(None);
    };
    let max_width = selected.strokes.iter().map(|s| s.width).fold(0.0, f32::max);
    let bounds: Aabb = bounds.expanded(max_width / 2.0 + 4.0);
    let full = rasterize(single_page_pdf(&selected, assets)?, SELECTION_PNG_DPI, true)?;
    // Seiteneinheiten → Pixel
    let px_per_unit = SELECTION_PNG_DPI / 25.4 * A4_WIDTH_MM / PAGE_WIDTH;
    let x0 = ((bounds.min.x * px_per_unit).floor().max(0.0) as u32).min(full.width);
    let y0 = ((bounds.min.y * px_per_unit).floor().max(0.0) as u32).min(full.height);
    let x1 = ((bounds.max.x * px_per_unit).ceil().max(0.0) as u32).min(full.width);
    let y1 = ((bounds.max.y * px_per_unit).ceil().max(0.0) as u32).min(full.height);
    if x1 <= x0 || y1 <= y0 {
        return Ok(None);
    }
    let (w, h) = (x1 - x0, y1 - y0);
    let mut pixels = Vec::with_capacity((w * h * 4) as usize);
    for y in y0..y1 {
        let start = ((y * full.width + x0) * 4) as usize;
        pixels.extend_from_slice(&full.pixels[start..start + (w * 4) as usize]);
    }
    Ok(Some(RgbaImage {
        width: w,
        height: h,
        pixels,
    }))
 }
 #[cfg(test)]
 mod tests {
    use super::*;
    use crate::document::{Stroke, StylusSample, PAGE_HEIGHT};
    fn page_with_line() -> Page {
        let mut page = Page::new(1, PageBackground::Grid5mm);
        let samples: Vec<StylusSample> = (0..=20)
            .map(|i| StylusSample {
                position: glam::Vec2::new(500.0 + i as f32 * 20.0, 1000.0),
                pressure: 0.6,
                timestamp: i as f64 * 0.01,
            })
            .collect();
        let vertices = crate::storage::reconstruct_stroke_vertices(
            &samples,
            [0.9, 0.1, 0.1, 1.0],
            20.0,
            Default::default(),
            true,
        );
        let mut stroke = Stroke::new(7, samples, vertices, [0.9, 0.1, 0.1, 1.0]);
        stroke.width = 20.0;
        page.strokes.push(stroke);
        page
    }
    fn decode(png: &[u8]) -> image::RgbaImage {
        image::load_from_memory(png).unwrap().into_rgba8()
    }
    #[test]
    fn test_page_png_paper_and_transparent() {
        let page = page_with_line();
        let paper = decode(&page_png(&page, None, ImageBackground::Paper).unwrap());
        // A4 mit 200 dpi
        assert_eq!(paper.width(), (A4_WIDTH_MM / 25.4 * PAGE_PNG_DPI) as u32);
        assert_eq!(paper.get_pixel(5, 5).0[3], 255, "Papier ist deckend");
        let clear = decode(&page_png(&page, None, ImageBackground::Transparent).unwrap());
        assert_eq!(clear.get_pixel(5, 5).0[3], 0, "Hintergrund ist transparent");
        // Die Linie ist rot und deckend
        let px_per_unit = clear.width() as f32 / PAGE_WIDTH;
        let line = clear.get_pixel((700.0 * px_per_unit) as u32, (1000.0 * px_per_unit) as u32);
        assert!(
            line.0[0] > 180 && line.0[1] < 80 && line.0[3] > 200,
            "{line:?}"
        );
        assert!(clear.height() as f32 / clear.width() as f32 - PAGE_HEIGHT / PAGE_WIDTH < 0.01);
    }
    #[test]
    fn test_page_svg_contains_ink() {
        let svg = page_svg(&page_with_line(), None).unwrap();
        assert!(svg.starts_with("<svg") || svg.contains("<svg"));
        assert!(svg.contains("<path"));
        assert!(svg.trim_end().ends_with("</svg>"));
    }
    /// Begrenzungsrechteck (x0, y0, x1, y1) der deckenden Pixel.
    fn ink_bounds(width: u32, pixels: &[u8]) -> (u32, u32, u32, u32) {
        let mut b = (u32::MAX, u32::MAX, 0, 0);
        for (i, p) in pixels.as_chunks::<4>().0.iter().enumerate() {
            if p[3] > 128 {
                let (x, y) = (i as u32 % width, i as u32 / width);
                b = (b.0.min(x), b.1.min(y), b.2.max(x), b.3.max(y));
            }
        }
        b
    }
    fn page_with_text() -> (Page, crate::text::TextBox) {
        let text = crate::text::TextBox::new(
            "Hallo Welt\nzweite Zeile".into(),
            100.0,
            crate::text::TextFont::Sans,
            1200.0,
        );
        let size = glam::Vec2::new(1200.0, text.layout().height());
        let corners = crate::text::frame_corners(
            glam::Vec2::new(300.0, 400.0),
            [glam::Vec2::X, glam::Vec2::Y],
            size,
        );
        let mut page = Page::new(1, PageBackground::Grid5mm);
        page.strokes.push(Stroke::new_text(
            3,
            text.clone(),
            corners,
            [0.0, 0.0, 0.0, 1.0],
        ));
        (page, text)
    }
    #[test]
    fn test_exported_text_matches_screen_rendering() {
        let (page, text) = page_with_text();
        let png = decode(&page_png(&page, None, ImageBackground::Transparent).unwrap());
        let px_per_unit = png.width() as f32 / PAGE_WIDTH;
        let exported = ink_bounds(png.width(), png.as_raw());
        // Dieselbe Stelle, wie sie die Bildschirmtextur zeigt
        let screen = crate::text::rasterize(&text, [0.0, 0.0, 0.0, 1.0], px_per_unit);
        let local = ink_bounds(screen.width, &screen.pixels);
        let (ox, oy) = ((300.0 * px_per_unit) as u32, (400.0 * px_per_unit) as u32);
        let expected = (local.0 + ox, local.1 + oy, local.2 + ox, local.3 + oy);
        for (a, b) in [
            (exported.0, expected.0),
            (exported.1, expected.1),
            (exported.2, expected.2),
            (exported.3, expected.3),
        ] {
            assert!(
                a.abs_diff(b) <= 3,
                "PDF {exported:?} ≠ Bildschirm {expected:?}"
            );
        }
    }
    #[test]
    fn test_exported_text_follows_rotation() {
        let (mut page, _) = page_with_text();
        let png = decode(&page_png(&page, None, ImageBackground::Transparent).unwrap());
        let straight = ink_bounds(png.width(), png.as_raw());
        let center = page.strokes[0].aabb.min;
        page.strokes[0].rotate(center, std::f32::consts::FRAC_PI_2);
        let png = decode(&page_png(&page, None, ImageBackground::Transparent).unwrap());
        let rotated = ink_bounds(png.width(), png.as_raw());
        // 90° im Uhrzeigersinn: Breite und Höhe tauschen, Text liegt links vom Drehpunkt
        let (w, h) = (straight.2 - straight.0, straight.3 - straight.1);
        let (rw, rh) = (rotated.2 - rotated.0, rotated.3 - rotated.1);
        assert!(
            rw.abs_diff(h) <= 4 && rh.abs_diff(w) <= 4,
            "{straight:?} → {rotated:?}"
        );
        let px_per_unit = png.width() as f32 / PAGE_WIDTH;
        assert!((rotated.2 as f32) < 300.0 * px_per_unit + 2.0);
    }
    #[test]
    fn test_selection_image_is_cropped() {
        let page = page_with_line();
        let image = selection_image(&page, &[7], None).unwrap().unwrap();
        // Linie 400 Einheiten (40 mm) lang: Bild etwas breiter als 40 mm bei 150 dpi
        let expected = 40.0 / 25.4 * SELECTION_PNG_DPI;
        assert!(
            (image.width as f32) > expected && (image.width as f32) < expected * 1.25,
            "{} px",
            image.width
        );
        assert!(image.height < image.width / 3);
        assert!(image.pixels.as_chunks::<4>().0.iter().any(|p| p[3] > 200));
        assert!(selection_image(&page, &[99], None).unwrap().is_none());
    }
 }
@@ -0,0 +1,291 @@
 //! Lesen und Rendern importierter PDF-Dateien mit `hayro` (reines Rust, nur CPU).
 //!
 //! Das Rendern einer Seite kann einige hundert Millisekunden dauern; [`PdfRenderService`]
 //! erledigt es deshalb in einem Hintergrund-Thread und meldet fertige Seiten zurück.
 use std::collections::{HashMap, HashSet};
 use std::path::PathBuf;
 use std::sync::mpsc::{self, Receiver, Sender};
 use hayro::hayro_interpret::InterpreterSettings;
 use hayro::hayro_syntax::{LoadPdfError, Pdf};
 use hayro::vello_cpu::color::palette::css::WHITE;
 use hayro::{PixmapSettings, RenderCache, RenderSettings};
 use crate::assets::RgbaImage;
 /// Längste Kante einer gerenderten Seite für die Anzeige in Pixeln (A4 ≈ 220 dpi).
 pub const DISPLAY_RENDER_PIXELS: u32 = 2560;
 /// Größte Seitenzahl, die importiert wird.
 pub const MAX_IMPORT_PAGES: usize = 2000;
 /// Öffnet ein PDF und liefert die angezeigte Größe jeder Seite in Punkt (Drehung
 /// berücksichtigt).
 pub fn page_sizes(bytes: Vec<u8>) -> Result<Vec<(f32, f32)>, String> {
    let pdf = open(bytes)?;
    let sizes: Vec<(f32, f32)> = pdf.pages().iter().map(|p| p.render_dimensions()).collect();
    if sizes.is_empty() {
        return Err("Das PDF enthält keine Seiten".into());
    }
    if sizes.len() > MAX_IMPORT_PAGES {
        return Err(format!(
            "Das PDF hat {} Seiten, höchstens {MAX_IMPORT_PAGES} werden unterstützt",
            sizes.len()
        ));
    }
    Ok(sizes)
 }
 fn open(bytes: Vec<u8>) -> Result<Pdf, String> {
    Pdf::new(bytes).map_err(|e| match e {
        LoadPdfError::Decryption(_) => {
            "Das PDF ist verschlüsselt oder passwortgeschützt und kann nicht geöffnet werden"
                .to_string()
        }
        LoadPdfError::Invalid => "Die Datei ist kein lesbares PDF".to_string(),
    })
 }
 /// Rendert Seite `index` so, dass die längste Kante höchstens `max_pixels` lang ist,
 /// auf weißem Grund.
 pub fn render_page(pdf: &Pdf, index: usize, max_pixels: u32) -> Result<RgbaImage, String> {
    let page = pdf
        .pages()
        .get(index)
        .ok_or_else(|| format!("Seite {} fehlt im PDF", index + 1))?;
    let (w, h) = page.render_dimensions();
    let scale = (max_pixels as f32 / w.max(h).max(1.0)).min(16.0);
    let pixmap = hayro::render(
        page,
        &RenderCache::new(),
        &InterpreterSettings::default(),
        &RenderSettings::default(),
        &PixmapSettings {
            x_scale: scale,
            y_scale: scale,
            bg_color: WHITE,
        },
    );
    // Auf weißem Grund ist jedes Pixel deckend: vormultipliziert = gerade Farbe
    Ok(RgbaImage {
        width: pixmap.width() as u32,
        height: pixmap.height() as u32,
        pixels: pixmap.data_as_u8_slice().to_vec(),
    })
 }
 /// Öffnet die Datei und rendert eine Seite (für den PDF-Export als Ersatzbild).
 pub fn render_file_page(
    path: &std::path::Path,
    index: usize,
    max_pixels: u32,
 ) -> Result<RgbaImage, String> {
    let bytes = std::fs::read(path).map_err(|e| e.to_string())?;
    render_page(&open(bytes)?, index, max_pixels)
 }
 struct RenderRequest {
    key: String,
    path: PathBuf,
    page: usize,
 }
 /// Ergebnis eines Render-Auftrags.
 pub type RenderResult = Result<RgbaImage, String>;
 /// Rendert PDF-Seiten im Hintergrund. Fertige Seiten holt der Event-Loop mit
 /// [`PdfRenderService::take`] ab; `on_ready` weckt ihn dafür auf.
 pub struct PdfRenderService {
    requests: Sender<RenderRequest>,
    results: Receiver<(String, RenderResult)>,
    pending: HashSet<String>,
    ready: HashMap<String, RenderResult>,
 }
 impl PdfRenderService {
    pub fn new(on_ready: impl Fn() + Send + 'static) -> Self {
        let (req_tx, req_rx) = mpsc::channel::<RenderRequest>();
        let (res_tx, res_rx) = mpsc::channel();
        std::thread::Builder::new()
            .name("pdf-render".into())
            .spawn(move || {
                // Zuletzt geöffnetes PDF behalten: Blättern rendert meist dieselbe Datei
                let mut open_pdf: Option<(PathBuf, Pdf)> = None;
                while let Ok(request) = req_rx.recv() {
                    if open_pdf.as_ref().map(|(p, _)| p) != Some(&request.path) {
                        open_pdf = std::fs::read(&request.path)
                            .map_err(|e| e.to_string())
                            .and_then(open)
                            .map_err(|e| eprintln!("[PDF] '{}': {e}", request.path.display()))
                            .ok()
                            .map(|pdf| (request.path.clone(), pdf));
                    }
                    let result = match &open_pdf {
                        Some((_, pdf)) => render_page(pdf, request.page, DISPLAY_RENDER_PIXELS),
                        None => Err("PDF kann nicht geöffnet werden".into()),
                    };
                    if res_tx.send((request.key, result)).is_err() {
                        break;
                    }
                    on_ready();
                }
            })
            .expect("PDF-Render-Thread konnte nicht gestartet werden");
        Self {
            requests: req_tx,
            results: res_rx,
            pending: HashSet::new(),
            ready: HashMap::new(),
        }
    }
    /// Rendert eine Seite vorab (z. B. die nächste), ohne auf das Ergebnis zu warten;
    /// [`Self::take`] liefert es später sofort.
    pub fn prefetch(&mut self, key: &str, path: PathBuf, page: usize) {
        self.collect();
        if self.ready.contains_key(key) || self.pending.contains(key) {
            return;
        }
        // Vorab gerenderte Seiten nicht unbegrenzt aufheben
        if self.ready.len() >= 2 {
            self.ready.clear();
        }
        self.request(key, path, page);
    }
    fn collect(&mut self) {
        while let Ok((done, result)) = self.results.try_recv() {
            self.pending.remove(&done);
            self.ready.insert(done, result);
        }
    }
    /// Erteilt den Auftrag, falls noch keiner läuft. `false`, wenn der Thread beendet ist.
    fn request(&mut self, key: &str, path: PathBuf, page: usize) -> bool {
        if !self.pending.insert(key.to_string()) {
            return true;
        }
        let request = RenderRequest {
            key: key.to_string(),
            path,
            page,
        };
        if self.requests.send(request).is_err() {
            self.pending.remove(key);
            return false;
        }
        true
    }
    /// Fertiges Ergebnis für `key` abholen; sonst den Auftrag (einmalig) erteilen und `None`.
    pub fn take(&mut self, key: &str, path: PathBuf, page: usize) -> Option<RenderResult> {
        self.collect();
        if let Some(result) = self.ready.remove(key) {
            return Some(result);
        }
        if !self.request(key, path, page) {
            return Some(Err("PDF-Render-Thread beendet".into()));
        }
        None
    }
 }
 #[cfg(test)]
 pub(crate) mod tests {
    use super::*;
    /// Minimales gültiges PDF mit Seiten der angegebenen Größen (Punkt); jede Seite zeigt ein
    /// rotes Rechteck in der linken oberen Ecke. Optional mit `/Rotate`.
    pub(crate) fn sample_pdf(pages: &[(f32, f32, i32)]) -> Vec<u8> {
        let mut objects: Vec<String> = Vec::new();
        let n = pages.len();
        // 1: Katalog, 2: Seitenbaum, danach je Seite: Seite + Inhalt
        objects.push("<< /Type /Catalog /Pages 2 0 R >>".into());
        let kids: Vec<String> = (0..n).map(|i| format!("{} 0 R", 3 + 2 * i)).collect();
        objects.push(format!(
            "<< /Type /Pages /Kids [{}] /Count {n} >>",
            kids.join(" ")
        ));
        for (i, (w, h, rotate)) in pages.iter().enumerate() {
            let content_id = 4 + 2 * i;
            objects.push(format!(
                "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 {w} {h}] /Rotate {rotate} /Contents {content_id} 0 R /Resources << >> >>"
            ));
            let content = format!("1 0 0 rg 0 {} 40 40 re f", h - 40.0);
            objects.push(format!(
                "<< /Length {} >>\nstream\n{content}\nendstream",
                content.len()
            ));
        }
        let mut out = b"%PDF-1.4\n".to_vec();
        let mut offsets = Vec::new();
        for (i, obj) in objects.iter().enumerate() {
            offsets.push(out.len());
            out.extend_from_slice(format!("{} 0 obj\n{obj}\nendobj\n", i + 1).as_bytes());
        }
        let xref_pos = out.len();
        out.extend_from_slice(
            format!("xref\n0 {}\n0000000000 65535 f \n", objects.len() + 1).as_bytes(),
        );
        for off in offsets {
            out.extend_from_slice(format!("{off:010} 00000 n \n").as_bytes());
        }
        out.extend_from_slice(
            format!(
                "trailer\n<< /Size {} /Root 1 0 R >>\nstartxref\n{xref_pos}\n%%EOF\n",
                objects.len() + 1
            )
            .as_bytes(),
        );
        out
    }
    #[test]
    fn test_page_sizes_and_errors() {
        let pdf = sample_pdf(&[(595.0, 842.0, 0), (842.0, 595.0, 0), (595.0, 842.0, 90)]);
        let sizes = page_sizes(pdf).unwrap();
        assert_eq!(sizes, vec![(595.0, 842.0), (842.0, 595.0), (842.0, 595.0)]);
        assert!(page_sizes(b"kein pdf".to_vec()).is_err());
    }
    #[test]
    fn test_render_page_draws_content() {
        let pdf = open(sample_pdf(&[(200.0, 100.0, 0)])).unwrap();
        let image = render_page(&pdf, 0, 400).unwrap();
        assert_eq!((image.width, image.height), (400, 200));
        let px = |x: u32, y: u32| {
            let i = ((y * image.width + x) * 4) as usize;
            &image.pixels[i..i + 4]
        };
        // Rotes Quadrat oben links, sonst weiß
        assert_eq!(px(20, 20), &[255, 0, 0, 255]);
        assert_eq!(px(300, 150), &[255, 255, 255, 255]);
        assert!(render_page(&pdf, 5, 400).is_err());
    }
    #[test]
    fn test_render_service_delivers_in_background() {
        let dir = tempfile::tempdir().unwrap();
        let path = dir.path().join("a.pdf");
        std::fs::write(&path, sample_pdf(&[(400.0, 300.0, 0)])).unwrap();
        let (wake_tx, wake_rx) = mpsc::channel();
        let mut service = PdfRenderService::new(move || {
            let _ = wake_tx.send(());
        });
        assert!(service.take("a#0", path.clone(), 0).is_none());
        // Zweite Anfrage erteilt keinen weiteren Auftrag
        assert!(service.take("a#0", path.clone(), 0).is_none());
        wake_rx
            .recv_timeout(std::time::Duration::from_secs(20))
            .unwrap();
        let image = service.take("a#0", path.clone(), 0).unwrap().unwrap();
        assert_eq!(image.width, DISPLAY_RENDER_PIXELS);
        // Vorab rendern: danach sofort verfügbar
        service.prefetch("a#0", path.clone(), 0);
        wake_rx
            .recv_timeout(std::time::Duration::from_secs(20))
            .unwrap();
        assert!(service.take("a#0", path, 0).unwrap().is_ok());
    }
 }
@@ -0,0 +1,383 @@
 //! Legt beim PDF-Export die Originalseiten importierter PDFs als Vektorgrafik unter die
 //! Notizen (Text bleibt scharf und auswählbar).
 //!
 //! Vorgehen: Das von printpdf erzeugte PDF wird mit `lopdf` geöffnet. Jede benötigte Seite
 //! des Quell-PDFs wird als Form-XObject (Inhalt + Ressourcen der Seite) übernommen und am
 //! Anfang der Zielseite gezeichnet, also unter Hintergrund, Bildern und Tinte.
 use std::collections::{BTreeMap, HashMap};
 use printpdf::lopdf::{Dictionary, Document, Object, ObjectId, Stream};
 /// Eine Zielseite, unter die eine Seite eines Quell-PDFs gelegt wird.
 #[derive(Debug, Clone, PartialEq)]
 pub struct Underlay {
    /// Seitennummer im Ziel-PDF, ab 0
    pub target_page: usize,
    /// Schlüssel des Quell-PDFs in `sources`
    pub source: String,
    /// Seitennummer im Quell-PDF, ab 0
    pub source_page: usize,
    /// Zielrechteck in PDF-Punkten (links, unten, Breite, Höhe; Ursprung unten links)
    pub rect: [f32; 4],
 }
 /// Nicht übernommene Unterlagen samt Grund.
 pub type FailedUnderlays = Vec<(Underlay, String)>;
 /// Affine PDF-Matrix `[a b c d e f]`: x' = a·x + c·y + e, y' = b·x + d·y + f.
 pub type Matrix = [f32; 6];
 /// `outer ∘ inner`: erst `inner`, dann `outer` anwenden.
 pub fn compose(outer: Matrix, inner: Matrix) -> Matrix {
    let [a1, b1, c1, d1, e1, f1] = outer;
    let [a2, b2, c2, d2, e2, f2] = inner;
    [
        a1 * a2 + c1 * b2,
        b1 * a2 + d1 * b2,
        a1 * c2 + c1 * d2,
        b1 * c2 + d1 * d2,
        a1 * e2 + c1 * f2 + e1,
        b1 * e2 + d1 * f2 + f1,
    ]
 }
 /// Matrix, die den Seitenbereich `bbox` (links, unten, rechts, oben) einer um `rotate` Grad
 /// im Uhrzeigersinn gedrehten Seite so abbildet, wie ein Betrachter sie zeigt, eingepasst
 /// in `rect` (links, unten, Breite, Höhe).
 pub fn placement_matrix(bbox: [f32; 4], rotate: i64, rect: [f32; 4]) -> Matrix {
    let (w, h) = ((bbox[2] - bbox[0]).max(1e-3), (bbox[3] - bbox[1]).max(1e-3));
    let to_origin = [1.0, 0.0, 0.0, 1.0, -bbox[0], -bbox[1]];
    let (rotation, shown_w, shown_h): (Matrix, f32, f32) = match rotate.rem_euclid(360) {
        90 => ([0.0, -1.0, 1.0, 0.0, 0.0, w], h, w),
        180 => ([-1.0, 0.0, 0.0, -1.0, w, h], w, h),
        270 => ([0.0, 1.0, -1.0, 0.0, h, 0.0], h, w),
        _ => ([1.0, 0.0, 0.0, 1.0, 0.0, 0.0], w, h),
    };
    let scale = (rect[2] / shown_w).min(rect[3] / shown_h);
    let place = [scale, 0.0, 0.0, scale, rect[0], rect[1]];
    compose(place, compose(rotation, to_origin))
 }
 /// Erbt ein Seitenattribut über die `Parent`-Kette.
 fn inherited<'a>(doc: &'a Document, page: &'a Dictionary, key: &[u8]) -> Option<&'a Object> {
    let mut node = page;
    for _ in 0..64 {
        if let Ok(value) = node.get(key) {
            return Some(value);
        }
        let parent = node.get(b"Parent").and_then(Object::as_reference).ok()?;
        node = doc.get_dictionary(parent).ok()?;
    }
    None
 }
 fn resolve<'a>(doc: &'a Document, object: &'a Object) -> &'a Object {
    doc.dereference(object).map(|(_, o)| o).unwrap_or(object)
 }
 fn read_box(doc: &Document, object: Option<&Object>) -> Option<[f32; 4]> {
    let array = resolve(doc, object?).as_array().ok()?;
    let values: Vec<f32> = array
        .iter()
        .filter_map(|v| resolve(doc, v).as_float().ok())
        .collect();
    let [x0, y0, x1, y1] = <[f32; 4]>::try_from(values).ok()?;
    Some([x0.min(x1), y0.min(y1), x0.max(x1), y0.max(y1)])
 }
 /// Baut aus einer Seite des (bereits umnummerierten) Quelldokuments ein Form-XObject.
 /// Liefert das XObject und die Matrix für die Platzierung in `rect`.
 fn page_as_form(
    doc: &Document,
    page_id: ObjectId,
    rect: [f32; 4],
 ) -> Result<(Stream, Matrix), String> {
    let page = doc.get_dictionary(page_id).map_err(|e| e.to_string())?;
    let media =
        read_box(doc, inherited(doc, page, b"MediaBox")).unwrap_or([0.0, 0.0, 595.0, 842.0]);
    let bbox = match read_box(doc, inherited(doc, page, b"CropBox")) {
        // Sichtbarer Bereich: Schnitt aus Crop- und Media-Box
        Some(c) => [
            c[0].max(media[0]),
            c[1].max(media[1]),
            c[2].min(media[2]),
            c[3].min(media[3]),
        ],
        None => media,
    };
    let rotate = inherited(doc, page, b"Rotate")
        .and_then(|r| resolve(doc, r).as_i64().ok())
        .unwrap_or(0);
    let resources = inherited(doc, page, b"Resources")
        .cloned()
        .unwrap_or_else(|| Object::Dictionary(Dictionary::new()));
    // Ein einzelner Inhaltsstrom wird unverändert (samt Kompression) übernommen,
    // mehrere werden entpackt und aneinandergehängt
    let streams = doc.get_page_contents(page_id);
    let (content, filter) = match streams.as_slice() {
        [single] => {
            let stream = doc
                .get_object(*single)
                .and_then(Object::as_stream)
                .map_err(|e| e.to_string())?;
            let filter = ["Filter", "DecodeParms"]
                .into_iter()
                .filter_map(|k| Some((k, stream.dict.get(k.as_bytes()).ok()?.clone())))
                .collect::<Vec<_>>();
            (stream.content.clone(), filter)
        }
        _ => {
            let mut content = Vec::new();
            for id in streams {
                let stream = doc
                    .get_object(id)
                    .and_then(Object::as_stream)
                    .map_err(|e| e.to_string())?;
                let data = stream
                    .decompressed_content()
                    .map_err(|e| format!("Inhalt nicht lesbar: {e}"))?;
                content.extend_from_slice(&data);
                content.push(b'\n');
            }
            (content, Vec::new())
        }
    };
    let mut dict = Dictionary::new();
    dict.set("Type", Object::Name(b"XObject".to_vec()));
    dict.set("Subtype", Object::Name(b"Form".to_vec()));
    dict.set(
        "BBox",
        Object::Array(bbox.iter().map(|&v| Object::Real(v)).collect()),
    );
    dict.set("Resources", resources);
    for (key, value) in filter {
        dict.set(key, value);
    }
    Ok((
        Stream::new(dict, content),
        placement_matrix(bbox, rotate, rect),
    ))
 }
 /// Legt die Quellseiten unter die Zielseiten. `sources` enthält die Quell-PDFs als Bytes.
 /// Gibt die neuen PDF-Bytes zurück und die Underlays, die nicht übernommen werden konnten
 /// (z. B. verschlüsselte PDFs), samt Grund.
 pub fn apply_underlays(
    target_bytes: &[u8],
    underlays: &[Underlay],
    sources: &HashMap<String, Vec<u8>>,
 ) -> Result<(Vec<u8>, FailedUnderlays), String> {
    let mut target = Document::load_mem(target_bytes).map_err(|e| e.to_string())?;
    let target_pages: Vec<ObjectId> = target.get_pages().into_values().collect();
    let mut failed = Vec::new();
    // Quell-PDFs einmal laden und mit freien Objektnummern in das Ziel übernehmen
    let mut loaded: HashMap<&str, Result<BTreeMap<u32, ObjectId>, String>> = HashMap::new();
    for underlay in underlays {
        if loaded.contains_key(underlay.source.as_str()) {
            continue;
        }
        let result = (|| {
            let bytes = sources
                .get(&underlay.source)
                .ok_or_else(|| "Quell-PDF fehlt".to_string())?;
            let mut source = Document::load_mem(bytes).map_err(|e| e.to_string())?;
            if source.is_encrypted() {
                return Err("Quell-PDF ist verschlüsselt".to_string());
            }
            source.renumber_objects_with(target.max_id + 1);
            let pages = source.get_pages();
            target.max_id = target.max_id.max(source.max_id);
            // Katalog und Seitenbaum der Quelle werden nicht referenziert und beim Speichern
            // mit `prune_objects` entfernt
            target.objects.extend(source.objects);
            Ok(pages)
        })();
        loaded.insert(&underlay.source, result);
    }
    for underlay in underlays {
        let result = (|| {
            let pages = loaded[underlay.source.as_str()]
                .as_ref()
                .map_err(Clone::clone)?;
            let source_page = *pages
                .get(&(underlay.source_page as u32 + 1))
                .ok_or_else(|| format!("Seite {} fehlt im Quell-PDF", underlay.source_page + 1))?;
            let target_page = *target_pages
                .get(underlay.target_page)
                .ok_or_else(|| "Zielseite fehlt".to_string())?;
            let (form, matrix) = page_as_form(&target, source_page, underlay.rect)?;
            let form_id = target.add_object(Object::Stream(form));
            let name = format!("InkPdf{}", form_id.0);
            add_xobject(&mut target, target_page, &name, form_id)?;
            let ops = format!(
                "q {} {} {} {} {} {} cm /{name} Do Q\n",
                matrix[0], matrix[1], matrix[2], matrix[3], matrix[4], matrix[5]
            );
            prepend_content(&mut target, target_page, ops.into_bytes())
        })();
        if let Err(err) = result {
            failed.push((underlay.clone(), err));
        }
    }
    target.prune_objects();
    // Neue, noch unkomprimierte Ströme packen (bereits gefilterte bleiben unverändert)
    target.compress();
    let mut out = Vec::new();
    target.save_to(&mut out).map_err(|e| e.to_string())?;
    Ok((out, failed))
 }
 /// Trägt ein XObject in die Ressourcen der Seite ein.
 fn add_xobject(
    doc: &mut Document,
    page_id: ObjectId,
    name: &str,
    id: ObjectId,
 ) -> Result<(), String> {
    // Ressourcen der Seite als eigenes Wörterbuch an der Seite (geerbte werden übernommen)
    let resources = {
        let page = doc.get_dictionary(page_id).map_err(|e| e.to_string())?;
        match inherited(doc, page, b"Resources").map(|r| resolve(doc, r)) {
            Some(Object::Dictionary(d)) => d.clone(),
            _ => Dictionary::new(),
        }
    };
    let mut xobjects = match resources.get(b"XObject").map(|x| resolve(doc, x)) {
        Ok(Object::Dictionary(d)) => d.clone(),
        _ => Dictionary::new(),
    };
    xobjects.set(name, Object::Reference(id));
    let mut resources = resources;
    resources.set("XObject", Object::Dictionary(xobjects));
    let page = doc
        .get_object_mut(page_id)
        .and_then(Object::as_dict_mut)
        .map_err(|e| e.to_string())?;
    page.set("Resources", Object::Dictionary(resources));
    Ok(())
 }
 /// Stellt einen Inhaltsstrom an den Anfang der Seite (zeichnet also zuunterst).
 fn prepend_content(doc: &mut Document, page_id: ObjectId, content: Vec<u8>) -> Result<(), String> {
    let existing: Vec<Object> = doc
        .get_page_contents(page_id)
        .into_iter()
        .map(Object::Reference)
        .collect();
    let id = doc.add_object(Object::Stream(Stream::new(Dictionary::new(), content)));
    let mut contents = vec![Object::Reference(id)];
    contents.extend(existing);
    let page = doc
        .get_object_mut(page_id)
        .and_then(Object::as_dict_mut)
        .map_err(|e| e.to_string())?;
    page.set("Contents", Object::Array(contents));
    Ok(())
 }
 #[cfg(test)]
 mod tests {
    use super::*;
    fn apply(m: Matrix, x: f32, y: f32) -> (f32, f32) {
        (m[0] * x + m[2] * y + m[4], m[1] * x + m[3] * y + m[5])
    }
    fn close(a: (f32, f32), b: (f32, f32)) -> bool {
        (a.0 - b.0).abs() < 1e-3 && (a.1 - b.1).abs() < 1e-3
    }
    #[test]
    fn test_placement_matrix() {
        // Querformat-Folie 800 × 600 ohne Drehung in ein 400 × 300-Rechteck bei (10, 20)
        let m = placement_matrix([0.0, 0.0, 800.0, 600.0], 0, [10.0, 20.0, 400.0, 300.0]);
        assert!(close(apply(m, 0.0, 0.0), (10.0, 20.0)));
        assert!(close(apply(m, 800.0, 600.0), (410.0, 320.0)));
        // Verschobene MediaBox
        let m = placement_matrix([100.0, 50.0, 300.0, 150.0], 0, [0.0, 0.0, 200.0, 100.0]);
        assert!(close(apply(m, 100.0, 50.0), (0.0, 0.0)));
        // Um 90° gedrehte Hochformatseite (200 × 400) erscheint quer (400 × 200):
        // die linke untere Ecke landet links oben
        let m = placement_matrix([0.0, 0.0, 200.0, 400.0], 90, [0.0, 0.0, 400.0, 200.0]);
        assert!(close(apply(m, 0.0, 0.0), (0.0, 200.0)));
        assert!(close(apply(m, 200.0, 0.0), (0.0, 0.0)));
        assert!(close(apply(m, 0.0, 400.0), (400.0, 200.0)));
        // 180° und 270° (= -90°)
        let m = placement_matrix([0.0, 0.0, 200.0, 400.0], 180, [0.0, 0.0, 200.0, 400.0]);
        assert!(close(apply(m, 0.0, 0.0), (200.0, 400.0)));
        let m = placement_matrix([0.0, 0.0, 200.0, 400.0], -90, [0.0, 0.0, 400.0, 200.0]);
        assert!(close(apply(m, 0.0, 0.0), (400.0, 0.0)));
    }
    #[test]
    fn test_apply_underlays_embeds_source_pages() {
        let source = crate::pdf_doc::tests::sample_pdf(&[(842.0, 595.0, 0), (595.0, 842.0, 0)]);
        let target = crate::pdf_doc::tests::sample_pdf(&[(595.0, 842.0, 0), (595.0, 842.0, 0)]);
        let sources = HashMap::from([("folien".to_string(), source)]);
        let underlays = vec![
            Underlay {
                target_page: 0,
                source: "folien".into(),
                source_page: 0,
                rect: [0.0, 421.0, 595.0, 421.0],
            },
            Underlay {
                target_page: 1,
                source: "folien".into(),
                source_page: 5,
                rect: [0.0, 0.0, 595.0, 842.0],
            },
            Underlay {
                target_page: 1,
                source: "fehlt".into(),
                source_page: 0,
                rect: [0.0, 0.0, 595.0, 842.0],
            },
        ];
        let (bytes, failed) = apply_underlays(&target, &underlays, &sources).unwrap();
        // Fehlende Quellseite und fehlendes PDF werden gemeldet, der Rest klappt
        assert_eq!(failed.len(), 2);
        let doc = Document::load_mem(&bytes).unwrap();
        let pages: Vec<ObjectId> = doc.get_pages().into_values().collect();
        assert_eq!(
            pages.len(),
            2,
            "Quellseiten dürfen nicht als eigene Seiten auftauchen"
        );
        let first = doc.get_page_content(pages[0]).unwrap();
        let text = String::from_utf8_lossy(&first);
        assert!(
            text.starts_with("q "),
            "Unterlage muss zuerst gezeichnet werden: {text}"
        );
        assert!(text.contains("Do Q"));
        // Ursprünglicher Seiteninhalt bleibt erhalten
        assert!(text.contains("re f"));
        // Form-XObject mit dem Inhalt der Folie ist in den Ressourcen eingetragen
        let page = doc.get_dictionary(pages[0]).unwrap();
        let resources = page.get(b"Resources").unwrap().as_dict().unwrap();
        let xobjects = resources.get(b"XObject").unwrap().as_dict().unwrap();
        let (_, form_ref) = xobjects.iter().next().unwrap();
        let form = doc
            .get_object(form_ref.as_reference().unwrap())
            .unwrap()
            .as_stream()
            .unwrap();
        assert_eq!(
            form.dict.get(b"Subtype").unwrap().as_name().unwrap(),
            b"Form"
        );
        assert!(String::from_utf8_lossy(&form.content).contains("1 0 0 rg"));
    }
 }
@@ -0,0 +1,239 @@
 //! Virtuelles Lineal: ein verschieb- und drehbares Lineal über dem Blatt. Striche, die nahe
 //! einer Längskante beginnen, rasten auf dieser Kante ein und werden zu geraden Linien.
 //!
 //! Alle Maße in Seiteneinheiten (10 Einheiten = 1 mm).
 use glam::Vec2;
 use crate::document::UNITS_PER_MM;
 /// Länge des Lineals (26 cm).
 pub const RULER_LENGTH: f32 = 260.0 * UNITS_PER_MM;
 /// Breite des Lineals (3,2 cm).
 pub const RULER_WIDTH: f32 = 32.0 * UNITS_PER_MM;
 /// Abstand zu einer Längskante, innerhalb dessen ein Strich einrastet (innen wie außen).
 pub const SNAP_DISTANCE: f32 = 6.0 * UNITS_PER_MM;
 /// Radius des Dreh-Griffs.
 pub const HANDLE_RADIUS: f32 = 8.0 * UNITS_PER_MM;
 /// Winkel rasten in diesen Schritten ein …
 pub const ANGLE_SNAP_STEP_DEG: f32 = 15.0;
 /// … wenn sie höchstens so weit davon entfernt sind.
 pub const ANGLE_SNAP_TOLERANCE_DEG: f32 = 2.0;
 /// Lage des Lineals auf dem Blatt.
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub struct Ruler {
    /// Mittelpunkt
    pub center: Vec2,
    /// Drehwinkel der Längsachse in Bogenmaß (0 = waagerecht)
    pub angle: f32,
 }
 /// Was an einer Stelle des Lineals liegt.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum RulerHit {
    /// Fläche zum Verschieben
    Body,
    /// Griff zum Drehen
    RotateHandle,
 }
 /// Eine Kante, an der ein Strich eingerastet ist: Gerade durch `origin` in Richtung `dir`.
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub struct EdgeLock {
    pub origin: Vec2,
    pub dir: Vec2,
 }
 impl EdgeLock {
    /// Fußpunkt von `p` auf der Geraden.
    pub fn project(&self, p: Vec2) -> Vec2 {
        self.origin + self.dir * (p - self.origin).dot(self.dir)
    }
 }
 impl Ruler {
    pub fn new(center: Vec2) -> Self {
        Self { center, angle: 0.0 }
    }
    /// Einheitsvektor entlang der Längsachse.
    pub fn axis(&self) -> Vec2 {
        Vec2::from_angle(self.angle)
    }
    /// Einheitsvektor quer zur Längsachse (zur „unteren“ Kante, bei 0° nach unten).
    pub fn normal(&self) -> Vec2 {
        self.axis().perp()
    }
    /// Lage von `p` im Lineal-Koordinatensystem: (entlang der Achse, quer dazu).
    pub fn local(&self, p: Vec2) -> Vec2 {
        let d = p - self.center;
        Vec2::new(d.dot(self.axis()), d.dot(self.normal()))
    }
    /// Ecken: oben links, oben rechts, unten rechts, unten links (bei 0°).
    pub fn corners(&self) -> [Vec2; 4] {
        let a = self.axis() * (RULER_LENGTH / 2.0);
        let n = self.normal() * (RULER_WIDTH / 2.0);
        [
            self.center - a - n,
            self.center + a - n,
            self.center + a + n,
            self.center - a + n,
        ]
    }
    /// Mittelpunkt des Dreh-Griffs (nahe dem rechten Ende).
    pub fn handle_center(&self) -> Vec2 {
        self.center + self.axis() * (RULER_LENGTH / 2.0 - HANDLE_RADIUS * 1.6)
    }
    /// Was liegt an `p`? Die Streifen entlang der Kanten gehören nicht dazu: dort beginnen
    /// eingerastete Striche.
    pub fn hit(&self, p: Vec2) -> Option<RulerHit> {
        if (p - self.handle_center()).length() <= HANDLE_RADIUS {
            return Some(RulerHit::RotateHandle);
        }
        let l = self.local(p);
        let inside_band = l.y.abs() <= RULER_WIDTH / 2.0 - SNAP_DISTANCE;
        (l.x.abs() <= RULER_LENGTH / 2.0 && inside_band).then_some(RulerHit::Body)
    }
    /// Kante, an der ein bei `p` beginnender Strich einrastet, verschoben um `offset` nach
    /// außen (halbe Strichbreite: die Tinte liegt dann neben dem Lineal, nicht darunter).
    pub fn edge_lock(&self, p: Vec2, offset: f32) -> Option<EdgeLock> {
        let l = self.local(p);
        if l.x.abs() > RULER_LENGTH / 2.0 + SNAP_DISTANCE {
            return None;
        }
        let half = RULER_WIDTH / 2.0;
        let side = if (l.y - half).abs() <= SNAP_DISTANCE {
            1.0
        } else if (l.y + half).abs() <= SNAP_DISTANCE {
            -1.0
        } else {
            return None;
        };
        Some(EdgeLock {
            origin: self.center + self.normal() * side * (half + offset),
            dir: self.axis(),
        })
    }
    /// Dreht das Lineal so, dass die Achse vom Mittelpunkt auf `toward` zeigt; Vielfache von
    /// 15° rasten ein.
    pub fn rotate_toward(&mut self, toward: Vec2) {
        let d = toward - self.center;
        if d.length_squared() < 1e-6 {
            return;
        }
        self.angle = snap_angle(d.y.atan2(d.x));
    }
    /// Winkel für die Anzeige in Grad, 0–179 (ein Lineal hat keine Richtung).
    pub fn display_degrees(&self) -> u32 {
        (self.angle.to_degrees().round() as i32).rem_euclid(180) as u32
    }
 }
 /// Rastet einen Winkel (Bogenmaß) auf das nächste Vielfache von 15° ein, wenn er nahe genug ist.
 pub fn snap_angle(angle: f32) -> f32 {
    let deg = angle.to_degrees();
    let nearest = (deg / ANGLE_SNAP_STEP_DEG).round() * ANGLE_SNAP_STEP_DEG;
    if (deg - nearest).abs() <= ANGLE_SNAP_TOLERANCE_DEG {
        nearest.to_radians()
    } else {
        angle
    }
 }
 #[cfg(test)]
 mod tests {
    use super::*;
    fn close(a: Vec2, b: Vec2) -> bool {
        (a - b).length() < 1e-2
    }
    #[test]
    fn test_geometry_and_hits() {
        let ruler = Ruler::new(Vec2::new(1000.0, 1000.0));
        let [tl, tr, br, bl] = ruler.corners();
        assert!(close(
            tl,
            Vec2::new(1000.0 - RULER_LENGTH / 2.0, 1000.0 - RULER_WIDTH / 2.0)
        ));
        assert!(close(
            br,
            Vec2::new(1000.0 + RULER_LENGTH / 2.0, 1000.0 + RULER_WIDTH / 2.0)
        ));
        assert!(close(
            tr - tl,
            bl - tl + Vec2::new(RULER_LENGTH, -RULER_WIDTH)
        ));
        assert_eq!(ruler.hit(ruler.center), Some(RulerHit::Body));
        assert_eq!(
            ruler.hit(ruler.handle_center()),
            Some(RulerHit::RotateHandle)
        );
        // Kantenstreifen und außerhalb: kein Treffer (dort wird gezeichnet)
        assert_eq!(
            ruler.hit(Vec2::new(1000.0, 1000.0 - RULER_WIDTH / 2.0 + 10.0)),
            None
        );
        assert_eq!(ruler.hit(Vec2::new(1000.0, 1300.0)), None);
        assert_eq!(ruler.hit(Vec2::new(1000.0 + RULER_LENGTH, 1000.0)), None);
    }
    #[test]
    fn test_edge_lock_projects_onto_offset_edge() {
        let ruler = Ruler::new(Vec2::new(1000.0, 1000.0));
        let edge_y = 1000.0 - RULER_WIDTH / 2.0;
        // Knapp oberhalb der oberen Kante: rastet ein, Linie liegt um den Versatz außerhalb
        let lock = ruler
            .edge_lock(Vec2::new(900.0, edge_y - 20.0), 3.0)
            .unwrap();
        let p = lock.project(Vec2::new(1300.0, edge_y - 55.0));
        assert!(close(p, Vec2::new(1300.0, edge_y - 3.0)));
        // Knapp innerhalb der unteren Kante
        let lock = ruler
            .edge_lock(Vec2::new(900.0, 1000.0 + RULER_WIDTH / 2.0 - 20.0), 0.0)
            .unwrap();
        assert!(close(
            lock.project(Vec2::new(0.0, 0.0)),
            Vec2::new(0.0, 1000.0 + RULER_WIDTH / 2.0)
        ));
        // Mitte oder weit weg: kein Einrasten
        assert!(ruler.edge_lock(ruler.center, 0.0).is_none());
        assert!(ruler.edge_lock(Vec2::new(1000.0, 500.0), 0.0).is_none());
        assert!(ruler
            .edge_lock(Vec2::new(1000.0 + RULER_LENGTH, edge_y), 0.0)
            .is_none());
        // Gedrehtes Lineal: die Linie folgt der Drehung
        let mut tilted = ruler;
        tilted.angle = 30f32.to_radians();
        let near_edge = tilted.center - tilted.normal() * (RULER_WIDTH / 2.0 + 10.0);
        let lock = tilted.edge_lock(near_edge, 0.0).unwrap();
        let a = lock.project(near_edge);
        let b = lock.project(near_edge + Vec2::new(300.0, 0.0));
        let dir = (b - a).normalize();
        assert!((dir.y.atan2(dir.x).to_degrees() - 30.0).abs() < 0.01);
    }
    #[test]
    fn test_rotation_snaps_to_15_degrees() {
        let mut ruler = Ruler::new(Vec2::ZERO);
        ruler.rotate_toward(Vec2::from_angle(44.0f32.to_radians()) * 100.0);
        assert_eq!(ruler.display_degrees(), 45);
        ruler.rotate_toward(Vec2::from_angle(37.0f32.to_radians()) * 100.0);
        assert_eq!(ruler.display_degrees(), 37);
        // Gegenrichtung zeigt denselben Winkel
        ruler.rotate_toward(Vec2::from_angle(-150.0f32.to_radians()) * 100.0);
        assert_eq!(ruler.display_degrees(), 30);
        assert_eq!(snap_angle(1.0f32.to_radians()), 0.0);
    }
 }
@@ -84,6 +84,8 @@ pub struct UiSettings {
    pub adapt_ink_colors: bool,
    /// Druckkennlinie des Stifts
    pub pressure_curve: PressureCurve,
    /// Seiten durchgehend untereinander anzeigen (sonst einzeln blättern)
    pub continuous_scroll: bool,
 }
 impl Default for UiSettings {
@@ -93,6 +95,7 @@ impl Default for UiSettings {
            paper_theme: PaperTheme::default(),
            adapt_ink_colors: true,
            pressure_curve: PressureCurve::default(),
            continuous_scroll: true,
        }
    }
 }
@@ -149,6 +152,7 @@ mod tests {
                exponent: 1.8,
                threshold: 0.1,
            },
            continuous_scroll: false,
        };
        settings.save_to(&path).unwrap();
        assert_eq!(UiSettings::load_from(&path), settings);
@@ -173,6 +177,7 @@ mod tests {
        assert_eq!(settings.paper_theme, PaperTheme::White);
        assert!(settings.adapt_ink_colors);
        assert_eq!(settings.pressure_curve, PressureCurve::default());
        assert!(settings.continuous_scroll);
        // Unsinnige Werte aus einer von Hand bearbeiteten Datei werden begrenzt
        std::fs::write(
@@ -73,6 +73,9 @@ pub struct StrokeData {
    /// Eingefügtes Bild (Name im Asset-Ordner); die Samples sind dann die vier Bildecken
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub image: Option<String>,
    /// Textfeld; die Samples sind dann die vier Ecken des Felds
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub text: Option<crate::text::TextBox>,
 }
 impl From<&Stroke> for StrokeData {
@@ -86,6 +89,7 @@ impl From<&Stroke> for StrokeData {
            width: stroke.width,
            finalized: stroke.finalized,
            image: stroke.image.clone(),
            text: stroke.text.clone(),
        }
    }
 }
@@ -100,6 +104,14 @@ impl StrokeData {
            .copied()
            .map(StylusSample::from)
            .collect();
        if let (Some(text), [a, b, c, d, ..]) = (&self.text, stylus_samples.as_slice()) {
            return Stroke::new_text(
                self.id,
                text.clone(),
                [a.position, b.position, c.position, d.position],
                self.color,
            );
        }
        if let Some(asset) = &self.image {
            if let [a, b, c, d, ..] = stylus_samples.as_slice() {
                let mut stroke = Stroke::new_image(
@@ -151,7 +163,10 @@ impl StrokeData {
 /// - Version 4: eingefügte Bilder (`image` am Strich, Ordner `assets/`). Ältere Versionen würden
 ///   das unbekannte Feld ignorieren, Bilder als Rechteckstrich anzeigen und beim Speichern
 ///   verlieren.
-pub const CURRENT_FORMAT_VERSION: u32 = 4;
+/// - Version 5: importierte PDF-Seiten als Seitenhintergrund (`pdf_background`).
 /// - Version 6: Seitentitel (`title` in Seite und Manifest).
 /// - Version 7: Textfelder (`text` am Strich).
 pub const CURRENT_FORMAT_VERSION: u32 = 7;
 /// Standardwert für ältere Dateien ohne explizite Formatversion (Legacy v0).
 pub fn legacy_format_version() -> u32 {
@@ -165,6 +180,12 @@ pub struct PageData {
    pub format_version: u32,
    pub id: u64,
    pub background: PageBackground,
    /// Importierte PDF-Seite als Hintergrund
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub pdf_background: Option<crate::document::PdfBackground>,
    /// Seitentitel (steht zusätzlich im Manifest)
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub title: Option<String>,
    pub strokes: Vec<StrokeData>,
 }
@@ -174,6 +195,8 @@ impl From<&Page> for PageData {
            format_version: CURRENT_FORMAT_VERSION,
            id: page.id,
            background: page.background,
            pdf_background: page.pdf_background.clone(),
            title: page.title.clone(),
            strokes: page.strokes.iter().map(StrokeData::from).collect(),
        }
    }
@@ -183,6 +206,8 @@ impl PageData {
    /// Wandelt die Seitendaten in eine runtime-aktive `Page` mit initialisiertem Cache um.
    pub fn to_page(&self) -> Page {
        let mut page = Page::new(self.id, self.background);
        page.pdf_background = self.pdf_background.clone();
        page.title = self.title.clone();
        for stroke_data in &self.strokes {
            page.strokes.push(stroke_data.to_stroke());
        }
@@ -199,11 +224,18 @@ pub struct PageMeta {
    pub id: u64,
    #[serde(default)]
    pub background: Option<PageBackground>,
    /// Seitentitel (Lesezeichen), damit die Seitenübersicht ihn ohne Laden der Seite kennt
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub title: Option<String>,
 }
 impl PageMeta {
    pub fn new(id: u64, background: Option<PageBackground>) -> Self {
-        Self { id, background }
+        Self {
            id,
            background,
            title: None,
        }
    }
 }
@@ -253,6 +285,13 @@ impl NotebookManifest {
        }
    }
    pub fn title_for_page(&self, page_id: u64) -> Option<String> {
        self.pages
            .iter()
            .find(|p| p.id == page_id)
            .and_then(|p| p.title.clone())
    }
    pub fn background_for_page(&self, page_id: u64) -> Option<PageBackground> {
        self.pages
            .iter()
@@ -268,6 +307,7 @@ impl NotebookManifest {
            .map(|p| PageMeta {
                id: p.id,
                background: Some(p.background),
                title: p.title.clone(),
            })
            .collect();
        self.page_ids = self.pages.iter().map(|p| p.id).collect();
@@ -715,6 +755,13 @@ pub fn load_notebook(notebook_dir: &Path) -> Result<(Notebook, NotebookManifest)
        pages.push(Page::new_unloaded(page_id, bg));
    }
    // Titel aus dem Manifest (Platzhalter und Ersatzseiten kennen sie sonst nicht)
    for page in &mut pages {
        if page.title.is_none() {
            page.title = manifest.title_for_page(page.id);
        }
    }
    let mut notebook = Notebook::from_pages(
        pages,
        manifest.current_page_index,
@@ -752,7 +799,18 @@ pub fn ensure_page_loaded(
    let page_id = notebook.pages[page_idx].id;
    match load_page(notebook_dir, page_id) {
        Ok(data) => {
-            notebook.pages[page_idx] = data.to_page();
+            let title = notebook.pages[page_idx].title.take();
            let mut page = data.to_page();
            page.title = page.title.or(title);
            notebook.pages[page_idx] = page;
            Ok(())
        }
        // Angehängt, aber nie gespeichert (noch leer): leere Seite statt Ladefehler
        Err(StorageError::PageNotFound(_)) => {
            let placeholder = &mut notebook.pages[page_idx];
            let mut page = Page::new(page_id, placeholder.background);
            page.title = placeholder.title.take();
            *placeholder = page;
            Ok(())
        }
        Err(StorageError::CorruptedPage(id, err_msg)) => {
@@ -1056,6 +1114,50 @@ pub fn create_new_notebook(
    Ok((notebook, manifest, notebook_dir))
 }
 /// Legt ein neues Notizbuch aus einem PDF an: eine Seite je PDF-Seite, die PDF-Seite als
 /// Hintergrund. Das PDF wird unverändert im Asset-Ordner abgelegt; alle Seiten werden sofort
 /// gespeichert.
 pub fn create_notebook_from_pdf(
    base_dir: &Path,
    title: &str,
    pdf_bytes: Vec<u8>,
 ) -> Result<(Notebook, NotebookManifest, PathBuf), String> {
    let sizes = crate::pdf_doc::page_sizes(pdf_bytes.clone())?;
    let (_, _, dir) = create_new_notebook(base_dir, title).map_err(|e| e.to_string())?;
    let result = (|| {
        let asset = crate::assets::AssetStore::new(&dir)
            .import_pdf(&pdf_bytes)
            .map_err(|e| e.to_string())?;
        let pages: Vec<Page> = sizes
            .iter()
            .enumerate()
            .map(|(i, &(width_pt, height_pt))| {
                let mut page = Page::new(i as u64 + 1, PageBackground::Blank);
                page.pdf_background = Some(crate::document::PdfBackground {
                    asset: asset.clone(),
                    page: i as u32,
                    width_pt,
                    height_pt,
                });
                page
            })
            .collect();
        let page_count = pages.len() as u64;
        let notebook = Notebook::from_pages(pages, 0, 1, page_count + 1);
        let mut manifest = load_manifest(&dir).map_err(|e| e.to_string())?;
        save_notebook(&dir, &notebook, &mut manifest).map_err(|e| e.to_string())?;
        Ok((notebook, manifest))
    })();
    match result {
        Ok((notebook, manifest)) => Ok((notebook, manifest, dir)),
        Err(err) => {
            // Halbfertiges Notizbuch nicht liegen lassen
            let _ = fs::remove_dir_all(&dir);
            Err(err)
        }
    }
 }
 /// Benennt ein Notizbuch um und aktualisiert das Manifest atomar auf der Festplatte.
 pub fn rename_notebook(
    notebook_dir: &Path,
@@ -1252,12 +1354,14 @@ pub fn load_all_pages(notebook_dir: &Path, notebook: &mut Notebook) -> Result<()
            ));
        }
        if !page.is_loaded {
            let title = page.title.take();
            *page = match load_page(notebook_dir, page.id) {
                Ok(data) => data.to_page(),
                // Wie beim Lazy Loading: nie gespeicherte Seite = leere Seite
                Err(StorageError::PageNotFound(_)) => Page::new(page.id, page.background),
                Err(e) => return Err(e),
            };
            page.title = page.title.take().or(title);
        }
    }
    Ok(())
@@ -2235,6 +2339,26 @@ mod tests {
        assert_eq!(reloaded.current_page().strokes.len(), 2);
    }
    #[test]
    fn test_never_saved_page_loads_as_empty_page() {
        // Angehängte, nie beschriebene Seite: steht im Manifest, hat aber keine Datei
        let temp_dir = tempfile::tempdir().unwrap();
        let (mut notebook, mut manifest, dir) =
            create_new_notebook(temp_dir.path(), "Angehängt").unwrap();
        notebook.add_page(PageBackground::Lined);
        save_notebook(&dir, &notebook, &mut manifest).unwrap();
        let _ = fs::remove_file(dir.join(format!("page_{}.json", notebook.pages[1].id)));
        let (mut loaded, _) = load_notebook(&dir).unwrap();
        assert!(!loaded.pages[1].is_loaded);
        ensure_page_loaded(&dir, &mut loaded, 1).unwrap();
        let page = &loaded.pages[1];
        assert!(page.is_loaded && !page.is_readonly());
        assert_eq!(page.background, PageBackground::Lined);
        assert!(page.strokes.is_empty());
        assert!(loaded.load_warnings.is_empty());
    }
    #[test]
    fn test_autosave_never_writes_unloaded_placeholder() {
        let temp_dir = tempfile::tempdir().unwrap();
@@ -2354,7 +2478,10 @@ mod tests {
            corners,
        ));
        save_notebook(&dir, &notebook, &mut manifest).unwrap();
-        assert_eq!(load_manifest(&dir).unwrap().format_version, 4);
+        assert_eq!(
            load_manifest(&dir).unwrap().format_version,
            CURRENT_FORMAT_VERSION
        );
        let (reloaded, _) = load_notebook(&dir).unwrap();
        let image = &reloaded.current_page().strokes[0];
@@ -2364,4 +2491,102 @@ mod tests {
        // Bilddatei liegt im Notizbuchordner
        assert!(dir.join("assets").join(&imported.asset).exists());
    }
    #[test]
    fn test_text_boxes_round_trip_through_page_file() {
        let temp_dir = tempfile::tempdir().unwrap();
        let (mut notebook, mut manifest, dir) =
            create_new_notebook(temp_dir.path(), "Mit Text").unwrap();
        let text = crate::text::TextBox::new(
            "Überschrift\n\tfn main() {}".into(),
            42.0,
            crate::text::TextFont::Mono,
            900.0,
        );
        let corners = [
            glam::Vec2::new(100.0, 100.0),
            glam::Vec2::new(1000.0, 100.0),
            glam::Vec2::new(1000.0, 220.0),
            glam::Vec2::new(100.0, 220.0),
        ];
        notebook.current_page_mut().strokes.push(Stroke::new_text(
            8,
            text.clone(),
            corners,
            [0.15, 0.35, 0.85, 1.0],
        ));
        save_notebook(&dir, &notebook, &mut manifest).unwrap();
        let (reloaded, _) = load_notebook(&dir).unwrap();
        let stroke = &reloaded.current_page().strokes[0];
        assert_eq!(stroke.text.as_ref(), Some(&text));
        assert_eq!(stroke.object_corners(), Some(corners));
        assert_eq!(stroke.color, [0.15, 0.35, 0.85, 1.0]);
        assert!(stroke.is_text() && !stroke.is_image() && stroke.vertices.is_empty());
    }
    #[test]
    fn test_create_notebook_from_pdf() {
        let temp_dir = tempfile::tempdir().unwrap();
        let pdf = crate::pdf_doc::tests::sample_pdf(&[(842.0, 595.0, 0), (595.0, 842.0, 0)]);
        let (notebook, manifest, dir) =
            create_notebook_from_pdf(temp_dir.path(), "Vorlesung 3", pdf.clone()).unwrap();
        assert_eq!(manifest.title, "Vorlesung 3");
        assert_eq!(notebook.pages.len(), 2);
        assert_eq!(notebook.next_page_id, 3);
        // Nach dem Neuladen: jede Seite verweist auf ihre PDF-Seite, das PDF liegt unverändert
        // im Asset-Ordner
        let (mut reloaded, _) = load_notebook(&dir).unwrap();
        load_all_pages(&dir, &mut reloaded).unwrap();
        for (i, page) in reloaded.pages.iter().enumerate() {
            let bg = page.pdf_background.as_ref().expect("PDF-Hintergrund fehlt");
            assert_eq!(bg.page, i as u32);
            assert_eq!(page.background, PageBackground::Blank);
        }
        let first = reloaded.pages[0].pdf_background.clone().unwrap();
        assert_eq!((first.width_pt, first.height_pt), (842.0, 595.0));
        let assets = crate::assets::AssetStore::new(&dir);
        assert_eq!(assets.read_bytes(&first.asset).unwrap(), pdf);
        // Kein PDF: Fehler und kein halbfertiges Notizbuch
        let before = std::fs::read_dir(temp_dir.path()).unwrap().count();
        assert!(
            create_notebook_from_pdf(temp_dir.path(), "Kaputt", b"%PDF-kaputt".to_vec()).is_err()
        );
        assert_eq!(std::fs::read_dir(temp_dir.path()).unwrap().count(), before);
    }
    #[test]
    fn test_page_titles_survive_restart_and_lazy_loading() {
        let temp_dir = tempfile::tempdir().unwrap();
        let (mut notebook, mut manifest, dir) =
            create_new_notebook(temp_dir.path(), "Mit Titeln").unwrap();
        notebook.add_page(PageBackground::Lined);
        notebook.add_page(PageBackground::Lined);
        let ids: Vec<u64> = notebook.pages.iter().map(|p| p.id).collect();
        assert!(notebook.set_page_title(ids[0], "  Einleitung \n"));
        assert!(notebook.set_page_title(ids[2], "Kapitel 2 – Integrale"));
        assert!(!notebook.set_page_title(ids[2], "Kapitel 2 – Integrale"));
        save_notebook(&dir, &notebook, &mut manifest).unwrap();
        assert_eq!(manifest.pages[0].title.as_deref(), Some("Einleitung"));
        // Neustart: Folgeseiten sind Platzhalter, kennen ihren Titel aber aus dem Manifest
        let (mut reloaded, _) = load_notebook(&dir).unwrap();
        assert!(!reloaded.pages[2].is_loaded);
        assert_eq!(
            reloaded.pages[2].title.as_deref(),
            Some("Kapitel 2 – Integrale")
        );
        ensure_page_loaded(&dir, &mut reloaded, 2).unwrap();
        assert_eq!(
            reloaded.pages[2].title.as_deref(),
            Some("Kapitel 2 – Integrale")
        );
        assert_eq!(reloaded.pages[1].title, None);
        // Titel entfernen
        assert!(reloaded.set_page_title(ids[0], "   "));
        assert_eq!(reloaded.pages[0].title, None);
    }
 }
@@ -0,0 +1,541 @@
 //! Textfelder (Text-Werkzeug): Datenmodell, Zeilenumbruch und Rasterung.
 //!
 //! Ein Textfeld ist ein Objekt mit vier Ecken wie ein Bild (siehe `Stroke::text`). Der Text
 //! wird in einem eigenen Koordinatensystem gesetzt – Breite = Umbruchbreite, Höhe = Zeilen ×
 //! Zeilenhöhe, in Seiteneinheiten – und dieses Rechteck auf die Ecken abgebildet. So wirken
 //! Verschieben, Drehen und Skalieren der Auswahl ohne Sonderfälle auf Text.
 //!
 //! Bildschirm (Textur), PDF-Export (eingebettete Schrift, durchsuchbar) und Bearbeitung (egui)
 //! verwenden dieselben Schriften aus egui und denselben Zeilenumbruch.
 use std::sync::OnceLock;
 use ab_glyph::{Font, FontRef, GlyphId, PxScale};
 use serde::{Deserialize, Serialize};
 use crate::assets::RgbaImage;
 use crate::document::{Stroke, PAGE_WIDTH, UNITS_PER_MM};
 /// Schriftart eines Textfelds.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
 pub enum TextFont {
    /// Proportionalschrift (Ubuntu Light) für Überschriften und Notizen
    #[default]
    Sans,
    /// Festbreitenschrift (Hack) für Code
    Mono,
 }
 impl TextFont {
    pub fn label(self) -> &'static str {
        match self {
            TextFont::Sans => "Normal",
            TextFont::Mono => "Code",
        }
    }
    /// Name der Schrift in den egui-Standardschriften.
    fn egui_name(self) -> &'static str {
        match self {
            TextFont::Sans => "Ubuntu-Light",
            TextFont::Mono => "Hack",
        }
    }
    /// egui-Schriftfamilie, deren erste Schrift diese ist (für die Bearbeitung).
    pub fn egui_family(self) -> egui::FontFamily {
        match self {
            TextFont::Sans => egui::FontFamily::Proportional,
            TextFont::Mono => egui::FontFamily::Monospace,
        }
    }
    /// TrueType-Daten der Schrift (aus den in egui eingebauten Schriften).
    pub fn bytes(self) -> &'static [u8] {
        static DEFINITIONS: OnceLock<egui::FontDefinitions> = OnceLock::new();
        let definitions = DEFINITIONS.get_or_init(egui::FontDefinitions::default);
        &definitions.font_data[self.egui_name()].font
    }
    pub fn face(self) -> &'static FontRef<'static> {
        static SANS: OnceLock<FontRef<'static>> = OnceLock::new();
        static MONO: OnceLock<FontRef<'static>> = OnceLock::new();
        let cell = match self {
            TextFont::Sans => &SANS,
            TextFont::Mono => &MONO,
        };
        cell.get_or_init(|| {
            FontRef::try_from_slice(self.bytes()).expect("eingebaute egui-Schrift ist gültig")
        })
    }
    fn units_per_em(self) -> f32 {
        self.face().units_per_em().unwrap_or(1000.0)
    }
    /// Höhe von Ober- bis Unterlänge je Em: ab_glyph skaliert auf diese Höhe, PDF, egui und
    /// dieses Modul messen die Schriftgröße als Em.
    pub fn height_per_em(self) -> f32 {
        let face = self.face();
        (face.ascent_unscaled() - face.descent_unscaled()) / self.units_per_em()
    }
 }
 /// Seiteneinheiten je typografischem Punkt.
 pub const UNITS_PER_PT: f32 = 25.4 / 72.0 * UNITS_PER_MM;
 /// Wählbare Schriftgrößen in Punkt.
 pub const TEXT_SIZES_PT: [f32; 7] = [8.0, 10.0, 12.0, 14.0, 18.0, 24.0, 36.0];
 pub const DEFAULT_TEXT_SIZE_PT: f32 = 12.0;
 /// Kleinste Umbruchbreite eines neuen Textfelds (3 cm).
 pub const MIN_WRAP_WIDTH: f32 = 300.0;
 /// Abstand neuer Textfelder zum rechten Blattrand (1 cm).
 pub const RIGHT_MARGIN: f32 = 100.0;
 /// Ein Tabulator wird durch so viele Leerzeichen ersetzt.
 const TAB_WIDTH: usize = 4;
 /// Inhalt und Satz eines Textfelds.
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct TextBox {
    pub content: String,
    /// Schriftgröße (Em) in Seiteneinheiten
    pub size: f32,
    #[serde(default)]
    pub font: TextFont,
    /// Umbruchbreite in Seiteneinheiten (Breite des ungedrehten, unskalierten Felds)
    pub wrap_width: f32,
 }
 /// Eine gesetzte Zeile: Zeichen (ohne Zeichen, die die Schrift nicht kennt) und ihre
 /// Glyphen mit x-Position.
 #[derive(Debug, Clone, PartialEq)]
 pub struct LaidLine {
    pub text: String,
    pub glyphs: Vec<(GlyphId, f32)>,
    pub width: f32,
 }
 #[derive(Debug, Clone, PartialEq)]
 pub struct TextLayout {
    pub lines: Vec<LaidLine>,
    /// Oberlänge (Abstand Zeilenoberkante → Grundlinie)
    pub ascent: f32,
    pub line_height: f32,
 }
 impl TextLayout {
    /// Höhe des Felds; ein leeres Feld ist eine Zeile hoch.
    pub fn height(&self) -> f32 {
        self.lines.len().max(1) as f32 * self.line_height
    }
    /// Grundlinie der Zeile `i` (von der Oberkante des Felds).
    pub fn baseline(&self, i: usize) -> f32 {
        i as f32 * self.line_height + self.ascent
    }
 }
 impl TextBox {
    pub fn new(content: String, size: f32, font: TextFont, wrap_width: f32) -> Self {
        Self {
            content,
            size,
            font,
            wrap_width,
        }
    }
    /// Größe des ungedrehten, unskalierten Felds in Seiteneinheiten.
    pub fn box_size(&self) -> glam::Vec2 {
        glam::Vec2::new(self.wrap_width.max(self.size), self.layout().height())
    }
    /// Setzt den Text mit Zeilenumbruch an Leerzeichen; zu lange Wörter werden zeichenweise
    /// umbrochen, Zeilenumbrüche im Text bleiben erhalten.
    pub fn layout(&self) -> TextLayout {
        let face = self.font.face();
        let em = self.size / self.font.units_per_em();
        let line_height =
            (face.ascent_unscaled() - face.descent_unscaled() + face.line_gap_unscaled()) * em;
        let width = self.wrap_width.max(self.size);
        let mut lines = Vec::new();
        for paragraph in self.content.split('\n') {
            let mut chars: Vec<(char, GlyphId, f32)> = paragraph
                .chars()
                .flat_map(|c| {
                    let (c, n) = if c == '\t' { (' ', TAB_WIDTH) } else { (c, 1) };
                    std::iter::repeat_n(c, n)
                })
                .filter_map(|c| {
                    let id = face.glyph_id(c);
                    (id.0 != 0).then(|| (c, id, face.h_advance_unscaled(id) * em))
                })
                .collect();
            // Unterschneidung (wie egui) dem vorderen Zeichen des Paars zurechnen
            for i in 1..chars.len() {
                chars[i - 1].2 += face.kern_unscaled(chars[i - 1].1, chars[i].1) * em;
            }
            let mut start = 0;
            let mut x = 0.0;
            // Letztes Leerzeichen der Zeile (möglicher Umbruch)
            let mut last_space: Option<usize> = None;
            for i in 0..chars.len() {
                let (c, _, advance) = chars[i];
                if c != ' ' && x + advance > width && i > start {
                    let end = match last_space {
                        Some(space) if space > start => space,
                        _ => i,
                    };
                    lines.push(laid_line(&chars[start..end]));
                    start = end;
                    while start < i && chars[start].0 == ' ' {
                        start += 1;
                    }
                    x = chars[start..i].iter().map(|g| g.2).sum();
                    last_space = None;
                }
                x += advance;
                if c == ' ' {
                    last_space = Some(i);
                }
            }
            lines.push(laid_line(&chars[start..]));
        }
        // Leere Zeilen am Ende zählen mit (Platz für den Cursor), ein leerer Text ist eine Zeile
        TextLayout {
            lines,
            ascent: face.ascent_unscaled() * em,
            line_height,
        }
    }
 }
 fn laid_line(chars: &[(char, GlyphId, f32)]) -> LaidLine {
    let mut x = 0.0;
    let mut glyphs = Vec::with_capacity(chars.len());
    let mut width: f32 = 0.0;
    for &(c, id, advance) in chars {
        glyphs.push((id, x));
        x += advance;
        if c != ' ' {
            width = x;
        }
    }
    LaidLine {
        text: chars.iter().map(|g| g.0).collect(),
        glyphs,
        width,
    }
 }
 /// Ecken eines Felds der Größe `size` mit Ursprung (oben links) `origin` und den Achsen
 /// `axes` (Seitenvektor je Einheit nach rechts bzw. unten): oben links, oben rechts,
 /// unten rechts, unten links.
 pub fn frame_corners(
    origin: glam::Vec2,
    axes: [glam::Vec2; 2],
    size: glam::Vec2,
 ) -> [glam::Vec2; 4] {
    let right = axes[0] * size.x;
    let down = axes[1] * size.y;
    [origin, origin + right, origin + right + down, origin + down]
 }
 /// Ursprung und Achsen (je Einheit) eines Felds der Größe `size` mit den Ecken `corners`.
 pub fn frame_axes(corners: &[glam::Vec2; 4], size: glam::Vec2) -> (glam::Vec2, [glam::Vec2; 2]) {
    let [tl, tr, _, bl] = *corners;
    (
        tl,
        [(tr - tl) / size.x.max(1e-3), (bl - tl) / size.y.max(1e-3)],
    )
 }
 /// Laufende Bearbeitung eines Textfelds (neu oder vorhanden).
 #[derive(Debug, Clone, PartialEq)]
 pub struct TextEditing {
    /// Seite, auf der das Feld liegt
    pub page_id: u64,
    /// Bearbeitetes vorhandenes Feld im Zustand vor der Bearbeitung; `None` bei einem neuen
    pub original: Option<Stroke>,
    /// Ecke oben links und Achsen (Seitenvektor je Einheit nach rechts bzw. unten)
    pub origin: glam::Vec2,
    pub axes: [glam::Vec2; 2],
    pub text: TextBox,
    pub color: [f32; 4],
    /// Beim nächsten Bild den Tastaturfokus auf das Feld setzen
    pub focus: bool,
    /// Bearbeitung beenden (Esc)
    pub finish: bool,
 }
 impl TextEditing {
    /// Neues, leeres Feld: die erste Zeile mittig auf `pos`, umbrochen 1 cm vor dem rechten
    /// Blattrand (mindestens 3 cm breit).
    pub fn new_at(
        page_id: u64,
        pos: glam::Vec2,
        size: f32,
        font: TextFont,
        color: [f32; 4],
    ) -> Self {
        let right = PAGE_WIDTH - RIGHT_MARGIN;
        let x = pos.x.min(right - MIN_WRAP_WIDTH).max(0.0);
        let text = TextBox::new(String::new(), size, font, (right - x).max(MIN_WRAP_WIDTH));
        let line_height = text.layout().line_height;
        Self {
            page_id,
            original: None,
            origin: glam::Vec2::new(x, (pos.y - line_height / 2.0).max(0.0)),
            axes: [glam::Vec2::X, glam::Vec2::Y],
            text,
            color,
            focus: true,
            finish: false,
        }
    }
    /// Bearbeitung des vorhandenen Textfelds `stroke`.
    pub fn of_stroke(page_id: u64, stroke: &Stroke) -> Option<Self> {
        let text = stroke.text.clone()?;
        let corners = stroke.object_corners()?;
        let (origin, axes) = frame_axes(&corners, text.box_size());
        Some(Self {
            page_id,
            original: Some(stroke.clone()),
            origin,
            axes,
            text,
            color: stroke.color,
            focus: true,
            finish: false,
        })
    }
    /// Wurde gegenüber dem Ausgangszustand etwas geändert?
    pub fn is_changed(&self) -> bool {
        match &self.original {
            Some(original) => {
                original.text.as_ref() != Some(&self.text) || original.color != self.color
            }
            None => !self.is_empty(),
        }
    }
    /// Enthält das Feld nur Leerraum?
    pub fn is_empty(&self) -> bool {
        self.text.content.trim().is_empty()
    }
    /// Ergebnis als Textfeld mit der ID `id`; die Höhe passt sich dem Text an, Lage,
    /// Drehung und Skalierung bleiben. `None` für ein leeres Feld.
    pub fn to_stroke(&self, id: u64) -> Option<Stroke> {
        if self.is_empty() {
            return None;
        }
        let corners = frame_corners(self.origin, self.axes, self.text.box_size());
        Some(Stroke::new_text(id, self.text.clone(), corners, self.color))
    }
 }
 /// Exponent für die Kantendeckung der Glyphen (wie egui, damit Bearbeitung und Anzeige
 /// gleich kräftig wirken).
 const COVERAGE_GAMMA: f32 = 0.55;
 /// Größte Kantenlänge einer Texttextur in Pixeln.
 const MAX_TEXTURE_SIDE: f32 = 4096.0;
 /// Größte Pixelzahl einer Texttextur (64 MB RGBA).
 const MAX_TEXTURE_PIXELS: f32 = 16.0 * 1024.0 * 1024.0;
 /// Rastert ein Textfeld mit `px_per_unit` Pixeln je Seiteneinheit (begrenzt auf eine
 /// handhabbare Texturgröße). `color` ist linear wie die Tinte; die Pixel sind sRGB.
 pub fn rasterize(text: &TextBox, color: [f32; 4], px_per_unit: f32) -> RgbaImage {
    let layout = text.layout();
    let size = glam::Vec2::new(text.wrap_width.max(text.size), layout.height());
    let scale = px_per_unit
        .min(MAX_TEXTURE_SIDE / size.x)
        .min(MAX_TEXTURE_SIDE / size.y)
        .min((MAX_TEXTURE_PIXELS / (size.x * size.y)).sqrt())
        .max(1e-3);
    let width = ((size.x * scale).ceil() as u32).max(1);
    let height = ((size.y * scale).ceil() as u32).max(1);
    let face = text.font.face();
    // ab_glyph misst die Skalierung als Höhe Ober- bis Unterlänge
    let px_scale = PxScale::from(text.size * scale * text.font.height_per_em());
    let mut coverage = vec![0.0_f32; (width * height) as usize];
    for (i, line) in layout.lines.iter().enumerate() {
        let baseline = layout.baseline(i) * scale;
        for &(id, x) in &line.glyphs {
            let glyph = id.with_scale_and_position(px_scale, ab_glyph::point(x * scale, baseline));
            let Some(outlined) = face.outline_glyph(glyph) else {
                continue;
            };
            let bounds = outlined.px_bounds();
            outlined.draw(|gx, gy, c| {
                let px = bounds.min.x as i64 + gx as i64;
                let py = bounds.min.y as i64 + gy as i64;
                if px >= 0 && py >= 0 && (px as u32) < width && (py as u32) < height {
                    let cell = &mut coverage[(py as u32 * width + px as u32) as usize];
                    *cell = (*cell + c).min(1.0);
                }
            });
        }
    }
    let rgb = [0, 1, 2].map(|i| egui::ecolor::gamma_u8_from_linear_f32(color[i]));
    let alpha = color[3].clamp(0.0, 1.0);
    let mut pixels = Vec::with_capacity(coverage.len() * 4);
    for c in coverage {
        pixels.extend_from_slice(&rgb);
        // Wie egui: Deckung anheben, sonst wirkt die dünne Schrift verkleinert blass
        pixels.push((c.powf(COVERAGE_GAMMA) * alpha * 255.0).round() as u8);
    }
    RgbaImage {
        width,
        height,
        pixels,
    }
 }
 #[cfg(test)]
 mod tests {
    use super::*;
    fn sample(content: &str, wrap_width: f32) -> TextBox {
        TextBox::new(content.to_string(), 50.0, TextFont::Sans, wrap_width)
    }
    #[test]
    fn test_fonts_load() {
        for font in [TextFont::Sans, TextFont::Mono] {
            assert!(font.face().glyph_id('ä').0 != 0);
            let factor = font.height_per_em();
            assert!((1.0..1.4).contains(&factor), "{factor}");
        }
    }
    #[test]
    fn test_layout_wraps_at_spaces() {
        let text = sample("eins zwei drei vier fünf sechs", 400.0);
        let layout = text.layout();
        assert!(layout.lines.len() > 1);
        for line in &layout.lines {
            assert!(line.width <= 400.0 + 1e-3, "{line:?}");
            assert!(!line.text.starts_with(' ') && !line.text.ends_with(' '));
        }
        let words: Vec<String> = layout.lines.iter().map(|l| l.text.clone()).collect();
        assert_eq!(words.join(" "), "eins zwei drei vier fünf sechs");
    }
    #[test]
    fn test_layout_breaks_long_words_and_keeps_newlines() {
        let text = sample("Donaudampfschifffahrtsgesellschaft\n\nende", 300.0);
        let layout = text.layout();
        assert!(layout.lines.iter().all(|l| l.width <= 300.0 + 1e-3));
        let joined: String = layout.lines.iter().map(|l| l.text.as_str()).collect();
        assert_eq!(joined, "Donaudampfschifffahrtsgesellschaftende");
        // Leere Zeile bleibt erhalten
        assert!(layout.lines.iter().any(|l| l.text.is_empty()));
        assert_eq!(layout.lines.last().unwrap().text, "ende");
    }
    #[test]
    fn test_empty_text_is_one_line_high() {
        let layout = sample("", 500.0).layout();
        assert!((layout.height() - layout.line_height).abs() < 1e-3);
        assert!(layout.line_height > 50.0);
    }
    #[test]
    fn test_tabs_become_spaces_and_indent_is_kept() {
        let text = TextBox::new("\tx".into(), 50.0, TextFont::Mono, 2000.0);
        let line = &text.layout().lines[0];
        assert_eq!(line.text, "    x");
        // Festbreitenschrift: x steht vier Zeichenbreiten weiter
        let advance = line.glyphs[1].1;
        assert!((line.glyphs[4].1 - 4.0 * advance).abs() < 1e-3);
    }
    #[test]
    fn test_frame_round_trip() {
        let size = glam::Vec2::new(400.0, 120.0);
        let axes = [glam::Vec2::new(0.0, 2.0), glam::Vec2::new(-2.0, 0.0)];
        let corners = frame_corners(glam::Vec2::new(100.0, 50.0), axes, size);
        let (origin, back) = frame_axes(&corners, size);
        assert_eq!(origin, glam::Vec2::new(100.0, 50.0));
        assert!((back[0] - axes[0]).length() < 1e-4 && (back[1] - axes[1]).length() < 1e-4);
    }
    #[test]
    fn test_rasterize_draws_ink_in_color() {
        let text = sample("Hallo", 400.0);
        let image = rasterize(&text, [0.85, 0.2, 0.2, 1.0], 1.0);
        assert_eq!(image.width, 400);
        assert_eq!(image.height as f32, text.layout().height().ceil());
        let opaque = image.pixels.chunks(4).filter(|p| p[3] > 200).count();
        assert!(opaque > 100, "{opaque}");
        // Farbe ist sRGB-kodiert
        assert!(image.pixels.chunks(4).all(|p| p[0] > 230 && p[1] < 130));
    }
    #[test]
    fn test_editing_new_text_box() {
        let edit = TextEditing::new_at(
            1,
            glam::Vec2::new(500.0, 800.0),
            50.0,
            TextFont::Sans,
            [0.0; 4],
        );
        assert!((edit.text.wrap_width - (PAGE_WIDTH - RIGHT_MARGIN - 500.0)).abs() < 1e-3);
        assert!(edit.origin.y < 800.0);
        assert!(!edit.is_changed());
        assert!(edit.to_stroke(9).is_none(), "leeres Feld wird verworfen");
        // Ganz rechts: Feld wird nach links versetzt, damit es mindestens 3 cm breit ist
        let edge = TextEditing::new_at(
            1,
            glam::Vec2::new(2050.0, 100.0),
            50.0,
            TextFont::Sans,
            [0.0; 4],
        );
        assert!((edge.text.wrap_width - MIN_WRAP_WIDTH).abs() < 1e-3);
        assert!(edge.origin.x + MIN_WRAP_WIDTH <= PAGE_WIDTH);
    }
    #[test]
    fn test_editing_keeps_transform_and_grows_with_text() {
        let mut edit = TextEditing::new_at(
            1,
            glam::Vec2::new(400.0, 400.0),
            50.0,
            TextFont::Sans,
            [0.0; 4],
        );
        edit.text.content = "eine Zeile".into();
        let mut stroke = edit.to_stroke(5).unwrap();
        assert!(stroke.is_text() && stroke.is_object());
        stroke.rotate(glam::Vec2::new(400.0, 400.0), 0.5);
        stroke.scale(glam::Vec2::new(400.0, 400.0), glam::Vec2::new(2.0, 2.0));
        let before = stroke.object_corners().unwrap();
        let mut edit = TextEditing::of_stroke(1, &stroke).unwrap();
        assert!(!edit.is_changed());
        edit.text.content = "eine Zeile\nzwei Zeilen".into();
        assert!(edit.is_changed());
        let after = edit.to_stroke(5).unwrap().object_corners().unwrap();
        // Obere Kante bleibt, die Seitenkanten werden in ihrer Richtung doppelt so lang
        assert!((after[0] - before[0]).length() < 1e-2 && (after[1] - before[1]).length() < 1e-2);
        let (old_side, new_side) = (before[3] - before[0], after[3] - after[0]);
        assert!((new_side.length() / old_side.length() - 2.0).abs() < 1e-3);
        assert!(old_side.normalize().dot(new_side.normalize()) > 0.9999);
    }
    #[test]
    fn test_rasterize_limits_texture_size() {
        let text = sample("x", 2000.0);
        let image = rasterize(&text, [0.0, 0.0, 0.0, 1.0], 100.0);
        assert!(image.width as f32 <= MAX_TEXTURE_SIDE);
    }
 }
@@ -3,13 +3,54 @@
 //! Berechnet die affine Transformation zwischen Bildschirmkoordinaten (Window-Pixel),
 //! virtuellen DIN-A4-Seitenkoordinaten ([0, 2100] x [0, 2970]) und dem GPU-NDC-Raum ([-1, 1]).
-use crate::document::{PageViewport, PAGE_HEIGHT, PAGE_WIDTH};
+use crate::document::{PageViewport, PAGE_HEIGHT, PAGE_WIDTH, UNITS_PER_MM};
 use glam::{Mat4, Vec2, Vec4};
 /// Minimaler und maximaler Zoomfaktor.
 pub const MIN_ZOOM: f32 = 0.25;
 pub const MAX_ZOOM: f32 = 5.0;
 /// Abstand zwischen zwei Seiten in der durchgehenden Ansicht (8 mm).
 pub const PAGE_GAP: f32 = 8.0 * UNITS_PER_MM;
 /// Vertikaler Abstand gleicher Punkte zweier aufeinanderfolgender Seiten.
 pub const PAGE_PITCH: f32 = PAGE_HEIGHT + PAGE_GAP;
 /// Höchstens so viele Nachbarseiten werden gleichzeitig dargestellt.
 pub const MAX_NEIGHBOR_PAGES: usize = 12;
 /// Durchgehende Ansicht: Die Seiten hängen untereinander, Koordinaten beziehen sich auf die
 /// aktuelle Seite. Liefert den Versatz (in Seiten) der Seite, auf der die Höhe `y` liegt,
 /// oder `None` im Zwischenraum zweier Seiten.
 pub fn page_offset_at(y: f32) -> Option<i64> {
    let k = (y / PAGE_PITCH).floor();
    (y - k * PAGE_PITCH <= PAGE_HEIGHT).then_some(k as i64)
 }
 /// Versätze der Seiten, die zwischen den Höhen `top` und `bottom` (Koordinaten der aktuellen
 /// Seite) sichtbar sind, begrenzt auf die Seitenindizes `0..page_count` und ohne die aktuelle
 /// Seite selbst.
 pub fn visible_neighbor_offsets(
    top: f32,
    bottom: f32,
    current: usize,
    page_count: usize,
 ) -> Vec<i64> {
    if !(top.is_finite() && bottom.is_finite()) || bottom < top {
        return Vec::new();
    }
    let first = (top / PAGE_PITCH).floor().max(-(current as f32)) as i64;
    let last = (bottom / PAGE_PITCH)
        .floor()
        .min((page_count as f32) - 1.0 - current as f32) as i64;
    let mut offsets: Vec<i64> = (first..=last).filter(|&k| k != 0).collect();
    // Sehr weit herausgezoomt: nur die nächstgelegenen Seiten
    if offsets.len() > MAX_NEIGHBOR_PAGES {
        offsets.sort_by_key(|k| k.unsigned_abs());
        offsets.truncate(MAX_NEIGHBOR_PAGES);
        offsets.sort_unstable();
    }
    offsets
 }
 /// Verwaltet den Viewport-Kamerazustand für stufenlosen Zoom und Pan.
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub struct ViewportState {
@@ -39,6 +80,35 @@ impl ViewportState {
        self.pan_offset = [0.0, 0.0];
    }
    /// Durchgehende Ansicht: Die Seite `k` Seiten weiter wird zur Bezugsseite, ohne dass sich
    /// der Bildausschnitt bewegt.
    pub fn shift_reference_page(&mut self, k: i64) {
        self.pan_offset[1] += k as f32 * PAGE_PITCH;
    }
    /// Durchgehende Ansicht: Verschiebt den Ausschnitt so, dass der Bildschirmpunkt `center`
    /// über dem Notizbuch liegt (zwischen Oberkante der ersten und Unterkante der letzten
    /// Seite, waagerecht innerhalb der Seitenbreite). `true`, wenn korrigiert wurde.
    pub fn clamp_continuous_center(
        &mut self,
        center: [f32; 2],
        current: usize,
        page_count: usize,
        page_viewport: &PageViewport,
    ) -> bool {
        let c = self.screen_to_page_unclamped(center[0], center[1], page_viewport);
        let top = -(current as f32) * PAGE_PITCH;
        let bottom = page_count.saturating_sub(1 + current) as f32 * PAGE_PITCH + PAGE_HEIGHT;
        let clamped = Vec2::new(c.x.clamp(0.0, PAGE_WIDTH), c.y.clamp(top, bottom.max(top)));
        if (clamped - c).length() < 1e-3 {
            return false;
        }
        // Bildschirm = Viewport + (Seite + Pan) · Maßstab: der Pan gleicht die Differenz aus
        self.pan_offset[0] += c.x - clamped.x;
        self.pan_offset[1] += c.y - clamped.y;
        true
    }
    /// Passt den Pan-Offset um eine Bildschirmverschiebung (in Fensterpixeln) an.
    pub fn pan_by_screen_delta(
        &mut self,
@@ -190,6 +260,67 @@ impl ViewportState {
 mod tests {
    use super::*;
    #[test]
    fn test_continuous_layout() {
        assert_eq!(page_offset_at(100.0), Some(0));
        assert_eq!(page_offset_at(PAGE_HEIGHT + PAGE_GAP / 2.0), None);
        assert_eq!(page_offset_at(PAGE_PITCH + 5.0), Some(1));
        assert_eq!(page_offset_at(-5.0), None);
        assert_eq!(page_offset_at(-PAGE_GAP - 5.0), Some(-1));
        // Ende von Seite 2 und Anfang von Seite 3 sichtbar (aktuell: Seite 2 von 5)
        assert_eq!(
            visible_neighbor_offsets(PAGE_HEIGHT - 500.0, PAGE_PITCH + 500.0, 1, 5),
            vec![1]
        );
        // Ganz oben im Notizbuch: keine Seite vor der ersten
        assert!(visible_neighbor_offsets(-PAGE_PITCH * 3.0, 500.0, 0, 5).is_empty());
        // Hinter der letzten Seite: keine weiteren
        assert_eq!(
            visible_neighbor_offsets(-PAGE_PITCH, PAGE_PITCH * 4.0, 3, 5),
            vec![-1, 1]
        );
        // Weit herausgezoomt: auf die nächstgelegenen Seiten begrenzt
        let many = visible_neighbor_offsets(-PAGE_PITCH * 50.0, PAGE_PITCH * 50.0, 50, 200);
        assert_eq!(many.len(), MAX_NEIGHBOR_PAGES);
        assert!(many.iter().all(|k| k.unsigned_abs() <= 6));
    }
    #[test]
    fn test_shift_reference_page_keeps_view() {
        let mut vp = ViewportState::new();
        let page_vp = PageViewport::calculate(1920.0, 1080.0, 24.0);
        vp.pan_by_screen_delta(0.0, -900.0, &page_vp);
        // Punkt oben auf der nächsten Seite, in Koordinaten der aktuellen Seite
        let before = vp.page_to_screen(300.0, PAGE_PITCH + 200.0, &page_vp);
        vp.shift_reference_page(1);
        let after = vp.page_to_screen(300.0, 200.0, &page_vp);
        assert!((before[0] - after[0]).abs() < 0.01 && (before[1] - after[1]).abs() < 0.01);
    }
    #[test]
    fn test_continuous_scroll_stays_on_the_notebook() {
        let page_vp = PageViewport::calculate(1280.0, 850.0, 24.0);
        let center = [640.0, 425.0];
        let mut vp = ViewportState::new();
        // Mitte der Seite: nichts zu korrigieren
        assert!(!vp.clamp_continuous_center(center, 1, 3, &page_vp));
        // Weit über die erste Seite hinaus nach oben gescrollt (aktuell: Seite 2 von 3)
        vp.pan_by_screen_delta(0.0, 5000.0, &page_vp);
        assert!(vp.clamp_continuous_center(center, 1, 3, &page_vp));
        let c = vp.screen_to_page_unclamped(center[0], center[1], &page_vp);
        assert!(
            (c.y + PAGE_PITCH).abs() < 0.1,
            "Oberkante der ersten Seite: {c:?}"
        );
        // Weit nach unten: Unterkante der letzten Seite
        vp.pan_by_screen_delta(-3000.0, -20000.0, &page_vp);
        assert!(vp.clamp_continuous_center(center, 1, 3, &page_vp));
        let c = vp.screen_to_page_unclamped(center[0], center[1], &page_vp);
        assert!((c.y - (PAGE_PITCH + PAGE_HEIGHT)).abs() < 0.1, "{c:?}");
        assert!((c.x - PAGE_WIDTH).abs() < 0.1, "{c:?}");
    }
    #[test]
    fn test_viewport_zoom_limits() {
        let mut vp = ViewportState::new();
Author	SHA1	Message	Date
haraldandClaude Opus 5.5	6002eee9e8	chore(release): bump version to 0.10.0 Build & Publish Release / Build Packages & Publish to Gitea (push) Successful in 6m39s Details Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-08 07:43:56 +02:00
haraldandClaude Opus 5.5	2eab394257	feat: Text-Werkzeug Textfelder per Tastatur (T): normale oder Code-Schrift, 8–36 pt, Farben der Stiftpalette, Umbruch am rechten Feldrand. Textfelder sind Objekte mit vier Ecken wie Bilder (verschieben, drehen, skalieren) und werden als Textur gerastert; im PDF-Export echter, durchsuchbarer Text mit eingebetteter Schrift. Kopierter Text wird mit Strg+V zum Textfeld. Dateiformat-Version 7. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-08 07:40:45 +02:00
haraldandClaude Opus 5.5	6a51ca3aa4	chore(release): bump version to 0.9.0 Build & Publish Release / Build Packages & Publish to Gitea (push) Successful in 5m52s Details Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-08 06:52:01 +02:00
haraldandClaude Opus 5.5	6f2b414bb8	feat: durchgehendes Scrollen Seiten hängen untereinander (8 mm Abstand) und werden mit Mausrad, Finger oder Touchpad fließend gescrollt; Strg+Mausrad zoomt. Sichtbare Nachbarseiten werden bei Bedarf geladen und mit eigener Kamera gezeichnet. Die Seite in der Fenstermitte wird nach dem Scrollen zur aktuellen; Zeichnen, Radieren und Auswählen auf einer Nachbarseite wechseln zuerst dorthin. Wer im unteren Fünftel der letzten Seite schreibt, bekommt automatisch eine neue Seite. Scrollen bleibt auf das Notizbuch begrenzt. Abschaltbar im ☰-Menü (Ansicht). Nie gespeicherte, angehängte Seiten laden jetzt als leere Seite statt als schreibgeschützte Fehlerseite. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-07 23:36:19 +02:00
haraldandClaude Opus 5.5	9dec688b84	chore(release): bump version to 0.8.0 Build & Publish Release / Build Packages & Publish to Gitea (push) Successful in 8m53s Details Virtuelles Lineal. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-07 22:52:19 +02:00
haraldandClaude Opus 5.5	7e05b33ee3	feat: virtuelles Lineal - Lineal ein-/ausblenden über die Werkzeugleiste oder Taste L (26 cm, mm-/cm-Skala an beiden Kanten, Winkelanzeige) - Fläche ziehen verschiebt, Griff ⟳ dreht; 15°-Schritte rasten ein - Striche, die bis 6 mm neben einer Längskante beginnen, folgen bis zum Abheben exakt der Kante (Stift, Textmarker, Formen); die Tinte liegt um die halbe Strichbreite neben dem Lineal - Lineal bleibt beim Blättern an seiner Stelle; nur seine Fläche und der Griff nehmen Eingaben an, an den Kanten wird gezeichnet Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-07 20:46:08 +02:00
haraldandClaude Opus 5.5	587632b173	chore(release): bump version to 0.7.0 Build & Publish Release / Build Packages & Publish to Gitea (push) Successful in 12m16s Details Teilstrich-Radierer, Seiten-Export als PNG/SVG, Auswahl als Bild, Seitentitel. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-07 19:32:56 +02:00
haraldandClaude Opus 5.5	701fa03f33	feat: Teilstrich-Radierer, Seiten-Export (PNG/SVG), Auswahl als Bild, Seitentitel - Radierer-Modus „✂ Teilstrich“: entfernt nur den überstrichenen Teil, der Rest bleibt in Stücken; ein Radierzug ist ein Undo-Schritt, Formen werden ganz radiert - ☰ → „Seite als PNG / PNG transparent / SVG“ nach ~/Documents (über den PDF-Export gerendert: Bilder und importierte PDF-Seiten inklusive) - Strg+C legt die Auswahl zusätzlich als Bild in die Systemzwischenablage (für Chat, Mail, Office); in ink-notes fügt Strg+V weiter die Objekte ein - Seitentitel in der Seitenübersicht, Ansicht „Inhalt“ als Inhaltsverzeichnis, Lesezeichen-Ecke an benannten Seiten, Titel im Fenstertitel und als PDF-Lesezeichen (Umlaute als UTF-16) - Dateiformat-Version 6 (Seitentitel) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-07 19:19:13 +02:00
haraldandClaude Opus 5.5	91a24b9f82	chore(release): bump version to 0.6.1 Build & Publish Release / Build Packages & Publish to Gitea (push) Successful in 11m45s Details PDF importieren und annotiert exportieren (v0.6.0 scheiterte in der CI an Clippy). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-07 18:29:30 +02:00
haraldandClaude Opus 5.5	64e13e1155	fix(ci): Clippy-Hinweise seit Anhebung der Mindest-Rust-Version Mit rust-version 1.92 meldet Clippy is_none_or statt map_or(true, …) und as_chunks statt chunks_exact mit fester Größe; die CI bricht bei Warnungen ab. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-07 18:25:30 +02:00
haraldandClaude Opus 5.5	8a0477740e	chore(release): bump version to 0.6.0 Build & Publish Release / Build Packages & Publish to Gitea (push) Failing after 3m32s Details PDF importieren und annotiert exportieren, Dateiformat-Version 5. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-07 18:07:25 +02:00
haraldandClaude Opus 5.5	66679e51ae	feat: PDF importieren und annotiert exportieren - ☰ → „PDF importieren …“ oder PDF ins Fenster ziehen: neues Notizbuch mit einer Seite je PDF-Seite, die Originalseite als Hintergrund - Querformat-Folien liegen oben auf dem A4-Blatt, darunter ist Platz für Notizen; gedrehte Seiten (/Rotate) erscheinen wie im PDF-Betrachter - Anzeige mit hayro (reines Rust) im Hintergrund-Thread, nächste Seite wird vorab gerendert - PDF-Export legt die Originalseiten als Vektorgrafik (Form-XObject via lopdf) unter Bilder und Tinte; nicht übernehmbare Seiten (z. B. verschlüsselt) werden als Bild mit 200 dpi eingebettet - Dateiformat-Version 5 (pdf_background an der Seite) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-07 17:47:49 +02:00