mirror of
https://github.com/storytold/deckcraft.git
synced 2026-11-16 19:04:13 -06:00
Compare commits
51
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
117f852bc8 | ||
|
|
f9bc097b4e | ||
|
|
6c52db0172 | ||
|
|
c3bce89b2d | ||
|
|
62af9fa114 | ||
|
|
7e1d6925ec | ||
|
|
dea0af6ceb | ||
|
|
3b6f9e7cb8 | ||
|
|
5f58c3c208 | ||
|
|
596ec54b59 | ||
|
|
9e975b0049 | ||
|
|
4c844f9332 | ||
|
|
5cf7f5f20a | ||
|
|
fb7755717b | ||
|
|
d04db56f3b | ||
|
|
ea1b4c5539 | ||
|
|
e6574eb39e | ||
|
|
48de308315 | ||
|
|
1d30834cca | ||
|
|
97423d80fd | ||
|
|
9e7fa3b571 | ||
|
|
bb2c2254ee | ||
|
|
0d5c0b854b | ||
|
|
349d3d1c24 | ||
|
|
f33d22001c | ||
|
|
d842a0cc2a | ||
|
|
e51ff1a6a8 | ||
|
|
455a3fdc35 | ||
|
|
988d721d7d | ||
|
|
6bbb593d82 | ||
|
|
187afbd4e5 | ||
|
|
1af57126a0 | ||
|
|
b0c532d2d1 | ||
|
|
3bad02d1f1 | ||
|
|
1ff3b87f5a | ||
|
|
9f7d1c426f | ||
|
|
a4674dbd1c | ||
|
|
04907481c1 | ||
|
|
3c60448691 | ||
|
|
772219838e | ||
|
|
e86c25af9c | ||
|
|
10fef35fe6 | ||
|
|
3746f259a0 | ||
|
|
175fa54642 | ||
|
|
64c89064ea | ||
|
|
96c6b5da4c | ||
|
|
40052f4b09 | ||
|
|
8ecb818f81 | ||
|
|
953ae8d060 | ||
|
|
1b2b48c0d7 | ||
|
|
9e7fab1038 |
@@ -35,6 +35,7 @@ artwork. The ribbon and menu icons stay original drawings.
|
||||
| `crates/fonts/tests/fixtures/legacy-semibold.ttf` | DeckCraft contributors | a one-glyph Semibold face named like Segoe UI Semibold (its Windows family differs from the typographic one), built by `make_legacy_font.py` (fontTools as the builder only) | CC0-1.0 | Font lookup by Windows family name tests |
|
||||
| `crates/fonts/tests/fixtures/legacy-regular.ttf` | DeckCraft contributors | the same family's one-glyph Regular face, built by `make_legacy_font.py` (fontTools as the builder only) | CC0-1.0 | Font lookup by Windows family name tests |
|
||||
| `crates/render/tests/fixtures/make_colr_font.py` | DeckCraft contributors | this repository | MIT OR Apache-2.0 | Regenerates the COLR test font |
|
||||
| `crates/format/tests/golden/deck.deckcraft` | DeckCraft contributors | a synthetic deck (placeholder bytes, no images or text from elsewhere) written by `crates/format/src/golden_tests.rs` with `DECKCRAFT_BLESS_GOLDEN=1` | CC0-1.0 | Native format golden bytes |
|
||||
| Lucide icon paths in `crates/engine/src/icon_data.rs` (Insert › Icons) | Lucide Contributors; Feather icons by Cole Bemis | https://github.com/lucide-icons/lucide/tree/440a1e1dfb1e712505308da46bead3c28b1f1398/icons (release 1.56.0, 2026-10-13) | ISC; MIT for the Feather-derived icons named in that commit's LICENSE | Stroke icons inserted as shapes |
|
||||
|
||||
## Bundled through dependencies
|
||||
|
||||
Generated
+142
-29
@@ -222,7 +222,7 @@ dependencies = [
|
||||
"objc2-foundation 0.3.2",
|
||||
"parking_lot",
|
||||
"percent-encoding",
|
||||
"windows-sys 0.61.2",
|
||||
"windows-sys 0.52.0",
|
||||
"wl-clipboard-rs",
|
||||
"x11rb",
|
||||
]
|
||||
@@ -853,6 +853,44 @@ dependencies = [
|
||||
"thiserror 2.0.21",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-cfb"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=ea24422ae9859dc5da398d0462bc87f8e02e0d10#ea24422ae9859dc5da398d0462bc87f8e02e0d10"
|
||||
|
||||
[[package]]
|
||||
name = "craft-codepage"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=254e9a409b410dc93c0e06ff66cd1e767893ac32#254e9a409b410dc93c0e06ff66cd1e767893ac32"
|
||||
|
||||
[[package]]
|
||||
name = "craft-codepage"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=63196e66f3033a6623eb629af95a104d26986725#63196e66f3033a6623eb629af95a104d26986725"
|
||||
|
||||
[[package]]
|
||||
name = "craft-deckcraft-format"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=254e9a409b410dc93c0e06ff66cd1e767893ac32#254e9a409b410dc93c0e06ff66cd1e767893ac32"
|
||||
dependencies = [
|
||||
"craft-zip 0.1.0 (git+https://github.com/storytold/craft-libs?rev=254e9a409b410dc93c0e06ff66cd1e767893ac32)",
|
||||
"serde",
|
||||
"serde_json",
|
||||
"thiserror 2.0.21",
|
||||
"zip 9.1.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-drawingml"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=44d83fa8f635333dcb3c231f87381387a1f5631b#44d83fa8f635333dcb3c231f87381387a1f5631b"
|
||||
dependencies = [
|
||||
"craft-xml 0.1.0 (git+https://github.com/storytold/craft-libs?rev=44d83fa8f635333dcb3c231f87381387a1f5631b)",
|
||||
"kurbo",
|
||||
"log",
|
||||
"serde",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-fonts-build"
|
||||
version = "0.1.0"
|
||||
@@ -900,6 +938,27 @@ dependencies = [
|
||||
"thiserror 2.0.21",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-mime"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=254e9a409b410dc93c0e06ff66cd1e767893ac32#254e9a409b410dc93c0e06ff66cd1e767893ac32"
|
||||
dependencies = [
|
||||
"chrono",
|
||||
"craft-codepage 0.1.0 (git+https://github.com/storytold/craft-libs?rev=254e9a409b410dc93c0e06ff66cd1e767893ac32)",
|
||||
"encoding_rs",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-opc"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=ea24422ae9859dc5da398d0462bc87f8e02e0d10#ea24422ae9859dc5da398d0462bc87f8e02e0d10"
|
||||
dependencies = [
|
||||
"craft-xml 0.1.0 (git+https://github.com/storytold/craft-libs?rev=ea24422ae9859dc5da398d0462bc87f8e02e0d10)",
|
||||
"craft-zip 0.1.0 (git+https://github.com/storytold/craft-libs?rev=ea24422ae9859dc5da398d0462bc87f8e02e0d10)",
|
||||
"log",
|
||||
"thiserror 2.0.21",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-pdf"
|
||||
version = "0.1.0"
|
||||
@@ -909,6 +968,15 @@ dependencies = [
|
||||
"thiserror 2.0.21",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-rtf"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=63196e66f3033a6623eb629af95a104d26986725#63196e66f3033a6623eb629af95a104d26986725"
|
||||
dependencies = [
|
||||
"craft-codepage 0.1.0 (git+https://github.com/storytold/craft-libs?rev=63196e66f3033a6623eb629af95a104d26986725)",
|
||||
"encoding_rs",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-ui"
|
||||
version = "0.1.0"
|
||||
@@ -986,6 +1054,45 @@ dependencies = [
|
||||
"web-sys",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-xml"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=44d83fa8f635333dcb3c231f87381387a1f5631b#44d83fa8f635333dcb3c231f87381387a1f5631b"
|
||||
dependencies = [
|
||||
"quick-xml 0.41.0",
|
||||
"serde",
|
||||
"thiserror 2.0.21",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-xml"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=ea24422ae9859dc5da398d0462bc87f8e02e0d10#ea24422ae9859dc5da398d0462bc87f8e02e0d10"
|
||||
dependencies = [
|
||||
"quick-xml 0.41.0",
|
||||
"thiserror 2.0.21",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-zip"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=254e9a409b410dc93c0e06ff66cd1e767893ac32#254e9a409b410dc93c0e06ff66cd1e767893ac32"
|
||||
dependencies = [
|
||||
"flate2",
|
||||
"thiserror 2.0.21",
|
||||
"zip 9.1.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-zip"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=ea24422ae9859dc5da398d0462bc87f8e02e0d10#ea24422ae9859dc5da398d0462bc87f8e02e0d10"
|
||||
dependencies = [
|
||||
"flate2",
|
||||
"thiserror 2.0.21",
|
||||
"zip 9.1.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "crc32fast"
|
||||
version = "1.5.2"
|
||||
@@ -1059,7 +1166,7 @@ checksum = "0c87e182de0887fd5361989c677c4e8f5000cd9491d6d563161a8f3a5519fc7f"
|
||||
|
||||
[[package]]
|
||||
name = "deckcraft"
|
||||
version = "0.18.1"
|
||||
version = "0.19.0"
|
||||
dependencies = [
|
||||
"arboard",
|
||||
"chrono",
|
||||
@@ -1081,7 +1188,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "deckcraft-anim"
|
||||
version = "0.18.1"
|
||||
version = "0.19.0"
|
||||
dependencies = [
|
||||
"deckcraft-geom",
|
||||
"deckcraft-model",
|
||||
@@ -1090,7 +1197,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "deckcraft-cli"
|
||||
version = "0.18.1"
|
||||
version = "0.19.0"
|
||||
dependencies = [
|
||||
"deckcraft-engine",
|
||||
"deckcraft-mcp",
|
||||
@@ -1100,16 +1207,17 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "deckcraft-color"
|
||||
version = "0.18.1"
|
||||
version = "0.19.0"
|
||||
dependencies = [
|
||||
"serde",
|
||||
"craft-drawingml",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "deckcraft-engine"
|
||||
version = "0.18.1"
|
||||
version = "0.19.0"
|
||||
dependencies = [
|
||||
"chrono",
|
||||
"craft-mime",
|
||||
"deckcraft-anim",
|
||||
"deckcraft-color",
|
||||
"deckcraft-fonts",
|
||||
@@ -1133,7 +1241,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "deckcraft-fonts"
|
||||
version = "0.18.1"
|
||||
version = "0.19.0"
|
||||
dependencies = [
|
||||
"epaint_default_fonts",
|
||||
"harfrust 0.13.3",
|
||||
@@ -1145,26 +1253,27 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "deckcraft-format"
|
||||
version = "0.18.1"
|
||||
version = "0.19.0"
|
||||
dependencies = [
|
||||
"craft-deckcraft-format",
|
||||
"craft-rtf",
|
||||
"deckcraft-model",
|
||||
"serde",
|
||||
"serde_json",
|
||||
"thiserror 2.0.21",
|
||||
"zip 3.0.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "deckcraft-geom"
|
||||
version = "0.18.1"
|
||||
version = "0.19.0"
|
||||
dependencies = [
|
||||
"craft-drawingml",
|
||||
"kurbo",
|
||||
"serde",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "deckcraft-mcp"
|
||||
version = "0.18.1"
|
||||
version = "0.19.0"
|
||||
dependencies = [
|
||||
"deckcraft-engine",
|
||||
"deckcraft-render",
|
||||
@@ -1174,7 +1283,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "deckcraft-media"
|
||||
version = "0.18.1"
|
||||
version = "0.19.0"
|
||||
dependencies = [
|
||||
"craft-audio",
|
||||
"craft-media",
|
||||
@@ -1187,7 +1296,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "deckcraft-model"
|
||||
version = "0.18.1"
|
||||
version = "0.19.0"
|
||||
dependencies = [
|
||||
"deckcraft-color",
|
||||
"deckcraft-geom",
|
||||
@@ -1199,7 +1308,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "deckcraft-pdf"
|
||||
version = "0.18.1"
|
||||
version = "0.19.0"
|
||||
dependencies = [
|
||||
"craft-pdf",
|
||||
"deckcraft-fonts",
|
||||
@@ -1217,8 +1326,12 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "deckcraft-pptx"
|
||||
version = "0.18.1"
|
||||
version = "0.19.0"
|
||||
dependencies = [
|
||||
"craft-cfb",
|
||||
"craft-drawingml",
|
||||
"craft-opc",
|
||||
"craft-xml 0.1.0 (git+https://github.com/storytold/craft-libs?rev=ea24422ae9859dc5da398d0462bc87f8e02e0d10)",
|
||||
"deckcraft-color",
|
||||
"deckcraft-engine",
|
||||
"deckcraft-geom",
|
||||
@@ -1233,7 +1346,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "deckcraft-render"
|
||||
version = "0.18.1"
|
||||
version = "0.19.0"
|
||||
dependencies = [
|
||||
"craft-metafile",
|
||||
"deckcraft-anim",
|
||||
@@ -1252,7 +1365,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "deckcraft-text"
|
||||
version = "0.18.1"
|
||||
version = "0.19.0"
|
||||
dependencies = [
|
||||
"chrono",
|
||||
"deckcraft-color",
|
||||
@@ -1266,7 +1379,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "deckcraft-ui-egui"
|
||||
version = "0.18.1"
|
||||
version = "0.19.0"
|
||||
dependencies = [
|
||||
"craft-ui",
|
||||
"craft-update",
|
||||
@@ -1292,7 +1405,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "deckcraft-web"
|
||||
version = "0.18.1"
|
||||
version = "0.19.0"
|
||||
dependencies = [
|
||||
"craft-web-api",
|
||||
"craft-web-host",
|
||||
@@ -1687,7 +1800,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
|
||||
dependencies = [
|
||||
"libc",
|
||||
"windows-sys 0.61.2",
|
||||
"windows-sys 0.52.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -3049,7 +3162,7 @@ version = "0.50.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
|
||||
dependencies = [
|
||||
"windows-sys 0.61.2",
|
||||
"windows-sys 0.59.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -4077,7 +4190,7 @@ dependencies = [
|
||||
"errno",
|
||||
"libc",
|
||||
"linux-raw-sys 0.12.1",
|
||||
"windows-sys 0.61.2",
|
||||
"windows-sys 0.52.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -4134,7 +4247,7 @@ dependencies = [
|
||||
"security-framework",
|
||||
"security-framework-sys",
|
||||
"webpki-root-certs",
|
||||
"windows-sys 0.61.2",
|
||||
"windows-sys 0.52.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -4805,10 +4918,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
|
||||
dependencies = [
|
||||
"fastrand",
|
||||
"getrandom 0.4.3",
|
||||
"getrandom 0.3.4",
|
||||
"once_cell",
|
||||
"rustix 1.1.5",
|
||||
"windows-sys 0.61.2",
|
||||
"windows-sys 0.52.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -5759,7 +5872,7 @@ version = "0.1.11"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
|
||||
dependencies = [
|
||||
"windows-sys 0.61.2",
|
||||
"windows-sys 0.52.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -6277,7 +6390,7 @@ checksum = "9440ea3e5aeabb0ac63af70daf835274065238cdd0cec83418f417eae38bacee"
|
||||
|
||||
[[package]]
|
||||
name = "xtask"
|
||||
version = "0.18.1"
|
||||
version = "0.19.0"
|
||||
dependencies = [
|
||||
"serde_json",
|
||||
]
|
||||
|
||||
+14
-1
@@ -4,13 +4,21 @@ members = ["crates/*", "apps/*", "xtask"]
|
||||
default-members = ["crates/*", "apps/deckcraft", "apps/deckcraft-cli"]
|
||||
|
||||
[workspace.package]
|
||||
version = "0.18.1"
|
||||
version = "0.19.0"
|
||||
edition = "2024"
|
||||
license = "MIT OR Apache-2.0"
|
||||
rust-version = "1.95"
|
||||
repository = "https://github.com/storytold/deckcraft"
|
||||
|
||||
[workspace.dependencies]
|
||||
# OPC part-name primitives; relationship admission stays app-local.
|
||||
craft-opc = { git = "https://github.com/storytold/craft-libs", rev = "ea24422ae9859dc5da398d0462bc87f8e02e0d10", version = "0.1.0" }
|
||||
# Compound File Binary directory reads (password-protected deck detection).
|
||||
craft-cfb = { git = "https://github.com/storytold/craft-libs", rev = "ea24422ae9859dc5da398d0462bc87f8e02e0d10", version = "0.1.0" }
|
||||
# XML writer primitives; parser admission and OOXML policy stay app-local.
|
||||
craft-xml = { git = "https://github.com/storytold/craft-libs", rev = "ea24422ae9859dc5da398d0462bc87f8e02e0d10", version = "0.1.0" }
|
||||
# DrawingML colours, themes and text (craft-libs#778, #792): the model DeckCraft reads and writes.
|
||||
craft-drawingml = { git = "https://github.com/storytold/craft-libs", rev = "44d83fa8f635333dcb3c231f87381387a1f5631b", version = "0.1.0" }
|
||||
# internal
|
||||
deckcraft-geom = { path = "crates/geom" }
|
||||
deckcraft-color = { path = "crates/color" }
|
||||
@@ -48,7 +56,12 @@ harfrust = "0.13"
|
||||
vello_cpu = "0.2"
|
||||
vello_common = { version = "0.2", default-features = false }
|
||||
image = { version = "0.25", default-features = false, features = ["png", "jpeg", "webp", "gif", "tiff", "bmp"] }
|
||||
# Base64 for command payloads (engine); base64_compat keeps the legacy lenient decoder. Same rev as craft-deckcraft-format.
|
||||
craft-mime = { git = "https://github.com/storytold/craft-libs", rev = "254e9a409b410dc93c0e06ff66cd1e767893ac32", version = "=0.1.0" }
|
||||
# craft-media, craft-audio and craft-video share types and stay on one rev.
|
||||
# The .deckcraft package layer (identity, manifest, member names, bounded reads); crates/format maps the presentation onto it.
|
||||
craft-deckcraft-format = { git = "https://github.com/storytold/craft-libs", rev = "254e9a409b410dc93c0e06ff66cd1e767893ac32", version = "=0.1.0" }
|
||||
craft-rtf = { git = "https://github.com/storytold/craft-libs", rev = "63196e66f3033a6623eb629af95a104d26986725", version = "=0.1.0" }
|
||||
craft-media = { git = "https://github.com/storytold/craft-libs", rev = "63196e66f3033a6623eb629af95a104d26986725", version = "=0.1.0", default-features = false }
|
||||
craft-audio = { git = "https://github.com/storytold/craft-libs", rev = "63196e66f3033a6623eb629af95a104d26986725", version = "=0.1.0", default-features = false, features = ["opus-decode"] }
|
||||
# H.264, HEVC, VP9 and AV1 decoders.
|
||||
|
||||
+3
-1
@@ -2,7 +2,7 @@
|
||||
|
||||
**Stage: alpha** · next: beta, ~20 points and ~120–210 h away
|
||||
|
||||
> **Last reviewed:** 2026-11-04 · **Last updated:** 2026-11-11 · **Change:** trivial (slide-list entries with missing relationships are reported as lost slides and open as repaired copies; the Opus decoder and the Ogg, MP4 and Matroska demuxers come from craft-libs; parity scores unchanged) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
|
||||
> **Last reviewed:** 2026-11-04 · **Last updated:** 2026-11-14 · **Change:** trivial (a slide the show advances to again plays its animations again, #2090; slide-list entries with missing relationships are reported as lost slides and open as repaired copies; the Opus decoder and the Ogg, MP4 and Matroska demuxers come from craft-libs; parity scores unchanged) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
|
||||
> **Last reviewed:** 2026-11-02 · **Last updated:** 2026-11-03 · **Change:** trivial (progress log: web `?host=parent` bridge opens and saves through a same-origin framing page; scores unchanged) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
|
||||
|
||||
> **Last reviewed:** 2026-11-02 · **Last updated:** 2026-11-03 · **Change:** trivial (community PR wave 10: PPTX and native saves keep table cell centred anchoring, text overflow, compatible line spacing, normalised character height, Thai distributed alignment, RTL table direction, alternate run language and reflection transforms; imported effects placed by parent time-node delays; Reuse Slides fits the destination size and brings custom table styles; deleted slides leave custom shows; merged shapes drop their animations; Compress Pictures measures grouped pictures at displayed size; parity scores unchanged) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
|
||||
@@ -154,6 +154,7 @@ app's JSON control channel (`deckcraft --control PORT`).
|
||||
|
||||
| Date | What landed |
|
||||
|---|---|
|
||||
| 2026-11-14 | Slide show: a slide the show advances to again (click, →, Space, automatic advance or a loop) starts over, so its animations play again, as in PowerPoint. Back and links still show it as it was left (#2090) |
|
||||
| 2026-11-11 | Media: the Opus decoder and the Ogg, MP4/MOV and Matroska demuxers are craft-audio and craft-media from craft-libs; DeckCraft's own copies and re-export crates are removed |
|
||||
| 2026-11-07 | PPTX slide-list entries with missing relationships are reported in lostSlides instead of silently omitted. The engine opens the partial deck as a repaired copy with no original save path. Slide lists over 10,000 entries are explicitly refused before a partial load; exactly 10,000 remain supported. Synthetic 13-slide regression; does not establish the cause of #1910's field report. |
|
||||
| 2026-11-04 | Ogg Opus recovery keeps trailing packets without granules in the total duration, matching their recovered positions; valid end trimming stays covered |
|
||||
@@ -342,6 +343,7 @@ app's JSON control channel (`deckcraft --control PORT`).
|
||||
|
||||
| Date | Change | Summary |
|
||||
|---|---|---|
|
||||
| 2026-11-14 | trivial | Progress log: a slide the show advances to again plays its animations again (#2090); parity scores unchanged |
|
||||
| 2026-11-11 | trivial | Opus and container code moved to craft-libs crates; parity scores unchanged |
|
||||
| 2026-11-04 | trivial | Ogg Opus recovery duration includes its recovered tail; parity scores unchanged |
|
||||
| 2026-11-02 | trivial | Progress log: run alternate-language metadata round-trips through native and PPTX formats; product parity scores unchanged |
|
||||
|
||||
@@ -9,7 +9,8 @@
|
||||
//! - a shape with a link and a triggered animation follows the link at once. The animation's clock
|
||||
//! runs only while its slide is shown, so it goes on where it stopped when the show returns;
|
||||
//! - with "advance on click" off a click never leaves the slide, but it still plays animation steps;
|
||||
//! - a slide the show returns to (link or arrow keys) looks as it was left.
|
||||
//! - a slide the show returns to by a link or by going back looks as it was left; going forward
|
||||
//! to a slide starts it over (#2090).
|
||||
|
||||
use deckcraft_model::text::Action;
|
||||
use deckcraft_model::{Presentation, ShapeId};
|
||||
|
||||
+12
-3
@@ -47,7 +47,8 @@ pub enum LinkJump {
|
||||
|
||||
/// Where a slide show is. Besides the current position it remembers what was played on every slide
|
||||
/// the show has visited (main steps, triggered sequences), so a slide reached again by a link or
|
||||
/// the arrow keys looks the way it was left, as in PowerPoint.
|
||||
/// by going back looks the way it was left, as in PowerPoint. Going forward to a slide starts it
|
||||
/// over, so its animations play again (#2090).
|
||||
#[derive(Clone, Debug, PartialEq, Default)]
|
||||
pub struct ShowState {
|
||||
/// Index into `presentation.slides`.
|
||||
@@ -226,6 +227,14 @@ impl ShowState {
|
||||
}
|
||||
}
|
||||
|
||||
/// Advance to slide `i`: it starts over, as if the show had not been there, so its
|
||||
/// animations play again (#2090). Links and Back keep a slide as it was left.
|
||||
fn enter_forward(&mut self, pres: &Presentation, i: usize) {
|
||||
self.leave(pres);
|
||||
self.runs.remove(&i);
|
||||
self.enter(pres, i);
|
||||
}
|
||||
|
||||
fn next_index(&self, pres: &Presentation) -> Option<usize> {
|
||||
let order = self.visit(pres);
|
||||
match order.iter().position(|&i| i == self.slide) {
|
||||
@@ -271,12 +280,12 @@ impl ShowState {
|
||||
}
|
||||
match self.next_index(pres) {
|
||||
Some(i) => {
|
||||
self.enter(pres, i);
|
||||
self.enter_forward(pres, i);
|
||||
ShowAction::Slide(i)
|
||||
}
|
||||
None if looping(pres) => match self.visit(pres).first() {
|
||||
Some(&i) => {
|
||||
self.enter(pres, i);
|
||||
self.enter_forward(pres, i);
|
||||
ShowAction::Slide(i)
|
||||
}
|
||||
None => {
|
||||
|
||||
@@ -876,6 +876,8 @@ fn show_back_leaves_a_slide_whose_first_step_is_automatic() {
|
||||
// While the automatic step plays.
|
||||
assert_eq!(s.prev(&p), ShowAction::Slide(0), "{start:?}");
|
||||
assert_eq!(s.next(&p), ShowAction::Slide(1));
|
||||
// Going forward again plays the automatic step again (#2090).
|
||||
assert_eq!(s.step_done(&p), ShowAction::FinishStep(0), "{start:?}");
|
||||
// Once it has played, the click step is undone first, then Back leaves the slide.
|
||||
assert_eq!(s.next(&p), ShowAction::PlayStep(1));
|
||||
assert_eq!(s.step_done(&p), ShowAction::FinishStep(1));
|
||||
@@ -885,6 +887,56 @@ fn show_back_leaves_a_slide_whose_first_step_is_automatic() {
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_slide_entered_going_forward_again_plays_its_animations_again() {
|
||||
// #2090: the show remembered slide 2 as fully built, so its entrance effects did not play the
|
||||
// second time the show advanced to it.
|
||||
for start in [AnimStart::WithPrevious, AnimStart::AfterPrevious] {
|
||||
let mut p = pres(3);
|
||||
Arc::make_mut(&mut p.slides[1]).shapes = vec![shape(1, "A")];
|
||||
Arc::make_mut(&mut p.slides[1]).animations = vec![anim(1, AnimClass::Entrance, "fade", start)];
|
||||
let mut s = ShowState::new(&p);
|
||||
assert_eq!(s.next(&p), ShowAction::Slide(1));
|
||||
assert_eq!(s.step_done(&p), ShowAction::FinishStep(0));
|
||||
assert_eq!(s.prev(&p), ShowAction::Slide(0), "{start:?}");
|
||||
assert_eq!(s.next(&p), ShowAction::Slide(1));
|
||||
assert_eq!((s.step, s.playing), (0, true), "{start:?}: the slide starts again");
|
||||
let a = ShowState::timeline(&p, 1).state(ShapeId(1), None, s.step, 0.0);
|
||||
assert!(!a.visible || a.opacity < 0.01, "{start:?}: the shape has not come in yet");
|
||||
// Back from the next slide still shows it as it was left.
|
||||
assert_eq!(s.step_done(&p), ShowAction::FinishStep(0));
|
||||
assert_eq!(s.next(&p), ShowAction::Slide(2));
|
||||
assert_eq!(s.prev(&p), ShowAction::Slide(1));
|
||||
assert_eq!((s.step, s.playing), (1, false), "{start:?}");
|
||||
}
|
||||
// An On Click build left by a jump starts again when the show advances to the slide.
|
||||
let mut p = pres(2);
|
||||
Arc::make_mut(&mut p.slides[1]).shapes = vec![shape(1, "A")];
|
||||
Arc::make_mut(&mut p.slides[1]).animations = vec![anim(1, AnimClass::Entrance, "fade", AnimStart::OnClick)];
|
||||
let mut s = ShowState::new(&p);
|
||||
assert_eq!(s.next(&p), ShowAction::Slide(1));
|
||||
assert_eq!(s.next(&p), ShowAction::PlayStep(0));
|
||||
assert_eq!(s.step_done(&p), ShowAction::FinishStep(0));
|
||||
assert_eq!(s.goto(&p, 0), ShowAction::Slide(0));
|
||||
assert_eq!(s.next(&p), ShowAction::Slide(1));
|
||||
assert_eq!((s.step, s.playing), (0, false));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_looping_show_plays_the_first_slide_again() {
|
||||
// #2090: a kiosk or loop-until-Esc show comes round to the first slide going forward.
|
||||
let mut p = pres(2);
|
||||
p.show.loop_until_esc = true;
|
||||
Arc::make_mut(&mut p.slides[0]).shapes = vec![shape(1, "A")];
|
||||
Arc::make_mut(&mut p.slides[0]).animations = vec![anim(1, AnimClass::Entrance, "fade", AnimStart::WithPrevious)];
|
||||
let mut s = ShowState::new(&p);
|
||||
assert!(s.playing);
|
||||
assert_eq!(s.step_done(&p), ShowAction::FinishStep(0));
|
||||
assert_eq!(s.next(&p), ShowAction::Slide(1));
|
||||
assert_eq!(s.next(&p), ShowAction::Slide(0));
|
||||
assert_eq!((s.step, s.playing), (0, true));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn show_auto_advance() {
|
||||
let mut p = pres(2);
|
||||
|
||||
@@ -325,6 +325,23 @@ fn a_slide_comes_back_the_way_it_was_left() {
|
||||
assert_eq!(s.step, ShowState::steps(&pres, 1));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_slide_entered_going_forward_again_starts_over() {
|
||||
// #2090: the show advances to slide 2 a second time; its triggered animation is undone too.
|
||||
let s1 = slide(1000, vec![], vec![], true);
|
||||
let s2 = slide(1001, vec![shape(4)], vec![exit_on_click(4, 4, 0)], true);
|
||||
let pres = Presentation { slides: vec![s1, s2], ..Default::default() };
|
||||
let mut r = Run::new(pres, vec![vec![], vec![hit(4, None)]]);
|
||||
assert_eq!(r.show.next(&r.pres), ShowAction::Slide(1));
|
||||
assert_eq!(r.click(), Click::Animated);
|
||||
assert!(!r.visible(ShapeId(4)));
|
||||
assert_eq!(r.show.prev(&r.pres), ShowAction::Slide(0));
|
||||
assert_eq!(r.show.prev(&r.pres), ShowAction::None);
|
||||
assert_eq!(r.show.next(&r.pres), ShowAction::Slide(1));
|
||||
assert!(r.visible(ShapeId(4)), "the shape is back");
|
||||
assert!(r.show.trigger_plays().is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_playing_main_step_is_finished_when_the_show_leaves() {
|
||||
let a = Animation { shape: ShapeId(1), class: AnimClass::Entrance, effect: "fade".into(), duration_ms: 500, ..Default::default() };
|
||||
|
||||
@@ -9,4 +9,4 @@ description = "DeckCraft colour: RGB/HSL, theme colour slots, DrawingML-style co
|
||||
workspace = true
|
||||
|
||||
[dependencies]
|
||||
serde = { workspace = true }
|
||||
craft-drawingml = { workspace = true }
|
||||
|
||||
+5
-753
@@ -1,758 +1,10 @@
|
||||
//! DeckCraft colour: sRGB colours, theme colour slots and DrawingML-style colour transforms
|
||||
//! (tint, shade, luminance modulation/offset, alpha…), so theme-relative colours resolve the way
|
||||
//! presentation files expect.
|
||||
//! DrawingML colours for DeckCraft: `Rgba`, scheme slots, colour schemes and colour transforms.
|
||||
//! They live in craft-libs (`craft_drawingml::color`, craft-libs#778 and #792), shared with the
|
||||
//! PPTX reader and writer; this crate re-exports them under the name the app uses.
|
||||
#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
|
||||
#![forbid(unsafe_code)]
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
/// An sRGB colour with straight alpha, components 0–255.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
|
||||
pub struct Rgba {
|
||||
pub r: u8,
|
||||
pub g: u8,
|
||||
pub b: u8,
|
||||
pub a: u8,
|
||||
}
|
||||
|
||||
impl Default for Rgba {
|
||||
fn default() -> Self {
|
||||
Rgba::BLACK
|
||||
}
|
||||
}
|
||||
|
||||
impl Rgba {
|
||||
pub const BLACK: Rgba = Rgba::rgb(0, 0, 0);
|
||||
pub const WHITE: Rgba = Rgba::rgb(255, 255, 255);
|
||||
pub const TRANSPARENT: Rgba = Rgba { r: 0, g: 0, b: 0, a: 0 };
|
||||
|
||||
pub const fn rgb(r: u8, g: u8, b: u8) -> Self {
|
||||
Rgba { r, g, b, a: 255 }
|
||||
}
|
||||
pub const fn rgba(r: u8, g: u8, b: u8, a: u8) -> Self {
|
||||
Rgba { r, g, b, a }
|
||||
}
|
||||
/// `RRGGBB` or `#RRGGBB` (also `RRGGBBAA`).
|
||||
pub fn from_hex(s: &str) -> Option<Self> {
|
||||
let s = s.trim();
|
||||
let s = s.strip_prefix('#').unwrap_or(s);
|
||||
if !s.bytes().all(|b| b.is_ascii_hexdigit()) {
|
||||
return None;
|
||||
}
|
||||
let byte = |i: usize| s.get(i..i + 2).and_then(|h| u8::from_str_radix(h, 16).ok());
|
||||
match s.len() {
|
||||
6 => Some(Rgba::rgb(byte(0)?, byte(2)?, byte(4)?)),
|
||||
8 => Some(Rgba::rgba(byte(0)?, byte(2)?, byte(4)?, byte(6)?)),
|
||||
3 => {
|
||||
let n = |i: usize| s.get(i..i + 1).and_then(|h| u8::from_str_radix(h, 16).ok()).map(|v| v * 17);
|
||||
Some(Rgba::rgb(n(0)?, n(1)?, n(2)?))
|
||||
}
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
/// `RRGGBB` uppercase (no alpha).
|
||||
pub fn hex(&self) -> String {
|
||||
format!("{:02X}{:02X}{:02X}", self.r, self.g, self.b)
|
||||
}
|
||||
pub fn with_alpha(self, a: u8) -> Self {
|
||||
Rgba { a, ..self }
|
||||
}
|
||||
pub fn to_f32(self) -> [f32; 4] {
|
||||
[self.r as f32 / 255.0, self.g as f32 / 255.0, self.b as f32 / 255.0, self.a as f32 / 255.0]
|
||||
}
|
||||
pub fn from_f64(r: f64, g: f64, b: f64, a: f64) -> Self {
|
||||
let c = |v: f64| if v.is_finite() { (v.clamp(0.0, 1.0) * 255.0).round() as u8 } else { 0 };
|
||||
Rgba { r: c(r), g: c(g), b: c(b), a: c(a) }
|
||||
}
|
||||
/// Relative luminance (WCAG), 0–1.
|
||||
pub fn luminance(self) -> f64 {
|
||||
let lin = |c: u8| {
|
||||
let v = c as f64 / 255.0;
|
||||
if v <= 0.04045 { v / 12.92 } else { ((v + 0.055) / 1.055).powf(2.4) }
|
||||
};
|
||||
0.2126 * lin(self.r) + 0.7152 * lin(self.g) + 0.0722 * lin(self.b)
|
||||
}
|
||||
/// WCAG contrast ratio between two colours (1–21).
|
||||
pub fn contrast(self, other: Rgba) -> f64 {
|
||||
let (a, b) = (self.luminance(), other.luminance());
|
||||
let (hi, lo) = if a > b { (a, b) } else { (b, a) };
|
||||
(hi + 0.05) / (lo + 0.05)
|
||||
}
|
||||
pub fn to_hsl(self) -> (f64, f64, f64) {
|
||||
let r = self.r as f64 / 255.0;
|
||||
let g = self.g as f64 / 255.0;
|
||||
let b = self.b as f64 / 255.0;
|
||||
let max = r.max(g).max(b);
|
||||
let min = r.min(g).min(b);
|
||||
let l = (max + min) / 2.0;
|
||||
if (max - min).abs() < 1e-12 {
|
||||
return (0.0, 0.0, l);
|
||||
}
|
||||
let d = max - min;
|
||||
let s = if l > 0.5 { d / (2.0 - max - min) } else { d / (max + min) };
|
||||
let h = if (max - r).abs() < 1e-12 {
|
||||
(g - b) / d + if g < b { 6.0 } else { 0.0 }
|
||||
} else if (max - g).abs() < 1e-12 {
|
||||
(b - r) / d + 2.0
|
||||
} else {
|
||||
(r - g) / d + 4.0
|
||||
};
|
||||
(h * 60.0, s, l)
|
||||
}
|
||||
pub fn from_hsl(h: f64, s: f64, l: f64, a: u8) -> Self {
|
||||
let h = ((h % 360.0) + 360.0) % 360.0 / 360.0;
|
||||
let s = s.clamp(0.0, 1.0);
|
||||
let l = l.clamp(0.0, 1.0);
|
||||
if s == 0.0 {
|
||||
return Rgba::from_f64(l, l, l, a as f64 / 255.0);
|
||||
}
|
||||
let q = if l < 0.5 { l * (1.0 + s) } else { l + s - l * s };
|
||||
let p = 2.0 * l - q;
|
||||
let f = |t: f64| {
|
||||
let t = if t < 0.0 {
|
||||
t + 1.0
|
||||
} else if t > 1.0 {
|
||||
t - 1.0
|
||||
} else {
|
||||
t
|
||||
};
|
||||
if t < 1.0 / 6.0 {
|
||||
p + (q - p) * 6.0 * t
|
||||
} else if t < 0.5 {
|
||||
q
|
||||
} else if t < 2.0 / 3.0 {
|
||||
p + (q - p) * (2.0 / 3.0 - t) * 6.0
|
||||
} else {
|
||||
p
|
||||
}
|
||||
};
|
||||
Rgba::from_f64(f(h + 1.0 / 3.0), f(h), f(h - 1.0 / 3.0), a as f64 / 255.0)
|
||||
}
|
||||
/// Linear interpolation (straight alpha).
|
||||
pub fn lerp(self, o: Rgba, t: f64) -> Rgba {
|
||||
let t = if t.is_finite() { t.clamp(0.0, 1.0) } else { 0.0 };
|
||||
let m = |a: u8, b: u8| (a as f64 + (b as f64 - a as f64) * t).round().clamp(0.0, 255.0) as u8;
|
||||
Rgba { r: m(self.r, o.r), g: m(self.g, o.g), b: m(self.b, o.b), a: m(self.a, o.a) }
|
||||
}
|
||||
}
|
||||
|
||||
/// The twelve theme colour slots, plus the mapped aliases (`bg1`, `tx1`…) and `phClr` (the
|
||||
/// placeholder colour a style matrix entry is applied with).
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum SchemeSlot {
|
||||
Dk1,
|
||||
Lt1,
|
||||
Dk2,
|
||||
Lt2,
|
||||
Accent1,
|
||||
Accent2,
|
||||
Accent3,
|
||||
Accent4,
|
||||
Accent5,
|
||||
Accent6,
|
||||
Hlink,
|
||||
FolHlink,
|
||||
Bg1,
|
||||
Tx1,
|
||||
Bg2,
|
||||
Tx2,
|
||||
PhClr,
|
||||
}
|
||||
|
||||
impl SchemeSlot {
|
||||
pub const THEME: [SchemeSlot; 12] = [
|
||||
SchemeSlot::Dk1,
|
||||
SchemeSlot::Lt1,
|
||||
SchemeSlot::Dk2,
|
||||
SchemeSlot::Lt2,
|
||||
SchemeSlot::Accent1,
|
||||
SchemeSlot::Accent2,
|
||||
SchemeSlot::Accent3,
|
||||
SchemeSlot::Accent4,
|
||||
SchemeSlot::Accent5,
|
||||
SchemeSlot::Accent6,
|
||||
SchemeSlot::Hlink,
|
||||
SchemeSlot::FolHlink,
|
||||
];
|
||||
pub fn xml_name(self) -> &'static str {
|
||||
match self {
|
||||
SchemeSlot::Dk1 => "dk1",
|
||||
SchemeSlot::Lt1 => "lt1",
|
||||
SchemeSlot::Dk2 => "dk2",
|
||||
SchemeSlot::Lt2 => "lt2",
|
||||
SchemeSlot::Accent1 => "accent1",
|
||||
SchemeSlot::Accent2 => "accent2",
|
||||
SchemeSlot::Accent3 => "accent3",
|
||||
SchemeSlot::Accent4 => "accent4",
|
||||
SchemeSlot::Accent5 => "accent5",
|
||||
SchemeSlot::Accent6 => "accent6",
|
||||
SchemeSlot::Hlink => "hlink",
|
||||
SchemeSlot::FolHlink => "folHlink",
|
||||
SchemeSlot::Bg1 => "bg1",
|
||||
SchemeSlot::Tx1 => "tx1",
|
||||
SchemeSlot::Bg2 => "bg2",
|
||||
SchemeSlot::Tx2 => "tx2",
|
||||
SchemeSlot::PhClr => "phClr",
|
||||
}
|
||||
}
|
||||
pub fn from_xml(s: &str) -> Option<Self> {
|
||||
Some(match s {
|
||||
"dk1" => SchemeSlot::Dk1,
|
||||
"lt1" => SchemeSlot::Lt1,
|
||||
"dk2" => SchemeSlot::Dk2,
|
||||
"lt2" => SchemeSlot::Lt2,
|
||||
"accent1" => SchemeSlot::Accent1,
|
||||
"accent2" => SchemeSlot::Accent2,
|
||||
"accent3" => SchemeSlot::Accent3,
|
||||
"accent4" => SchemeSlot::Accent4,
|
||||
"accent5" => SchemeSlot::Accent5,
|
||||
"accent6" => SchemeSlot::Accent6,
|
||||
"hlink" => SchemeSlot::Hlink,
|
||||
"folHlink" => SchemeSlot::FolHlink,
|
||||
"bg1" => SchemeSlot::Bg1,
|
||||
"tx1" => SchemeSlot::Tx1,
|
||||
"bg2" => SchemeSlot::Bg2,
|
||||
"tx2" => SchemeSlot::Tx2,
|
||||
"phClr" => SchemeSlot::PhClr,
|
||||
_ => return None,
|
||||
})
|
||||
}
|
||||
pub fn label(self) -> &'static str {
|
||||
match self {
|
||||
SchemeSlot::Dk1 | SchemeSlot::Tx1 => "Text/Background - Dark 1",
|
||||
SchemeSlot::Lt1 | SchemeSlot::Bg1 => "Text/Background - Light 1",
|
||||
SchemeSlot::Dk2 | SchemeSlot::Tx2 => "Text/Background - Dark 2",
|
||||
SchemeSlot::Lt2 | SchemeSlot::Bg2 => "Text/Background - Light 2",
|
||||
SchemeSlot::Accent1 => "Accent 1",
|
||||
SchemeSlot::Accent2 => "Accent 2",
|
||||
SchemeSlot::Accent3 => "Accent 3",
|
||||
SchemeSlot::Accent4 => "Accent 4",
|
||||
SchemeSlot::Accent5 => "Accent 5",
|
||||
SchemeSlot::Accent6 => "Accent 6",
|
||||
SchemeSlot::Hlink => "Hyperlink",
|
||||
SchemeSlot::FolHlink => "Followed Hyperlink",
|
||||
SchemeSlot::PhClr => "Placeholder colour",
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A colour scheme: the twelve theme colours.
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct ColorScheme {
|
||||
pub name: String,
|
||||
pub colors: [Rgba; 12],
|
||||
}
|
||||
|
||||
impl ColorScheme {
|
||||
pub fn get(&self, slot: SchemeSlot) -> Rgba {
|
||||
let i = match slot {
|
||||
SchemeSlot::Dk1 | SchemeSlot::Tx1 => 0,
|
||||
SchemeSlot::Lt1 | SchemeSlot::Bg1 => 1,
|
||||
SchemeSlot::Dk2 | SchemeSlot::Tx2 => 2,
|
||||
SchemeSlot::Lt2 | SchemeSlot::Bg2 => 3,
|
||||
SchemeSlot::Accent1 => 4,
|
||||
SchemeSlot::Accent2 => 5,
|
||||
SchemeSlot::Accent3 => 6,
|
||||
SchemeSlot::Accent4 => 7,
|
||||
SchemeSlot::Accent5 => 8,
|
||||
SchemeSlot::Accent6 => 9,
|
||||
SchemeSlot::Hlink => 10,
|
||||
SchemeSlot::FolHlink => 11,
|
||||
SchemeSlot::PhClr => 4,
|
||||
};
|
||||
self.colors.get(i).copied().unwrap_or(Rgba::BLACK)
|
||||
}
|
||||
pub fn set(&mut self, slot: SchemeSlot, c: Rgba) {
|
||||
if let Some(i) = SchemeSlot::THEME.iter().position(|s| *s == slot)
|
||||
&& let Some(v) = self.colors.get_mut(i)
|
||||
{
|
||||
*v = c;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// One colour transform, in file units (percentages ×1000, angles ×60000), applied in order.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "camelCase", tag = "op", content = "val")]
|
||||
pub enum ColorTransform {
|
||||
Tint(i32),
|
||||
Shade(i32),
|
||||
LumMod(i32),
|
||||
LumOff(i32),
|
||||
SatMod(i32),
|
||||
SatOff(i32),
|
||||
HueMod(i32),
|
||||
HueOff(i32),
|
||||
Alpha(i32),
|
||||
AlphaMod(i32),
|
||||
AlphaOff(i32),
|
||||
Comp,
|
||||
Inv,
|
||||
Gray,
|
||||
RedMod(i32),
|
||||
GreenMod(i32),
|
||||
BlueMod(i32),
|
||||
}
|
||||
|
||||
impl ColorTransform {
|
||||
pub fn xml_name(&self) -> &'static str {
|
||||
match self {
|
||||
ColorTransform::Tint(_) => "tint",
|
||||
ColorTransform::Shade(_) => "shade",
|
||||
ColorTransform::LumMod(_) => "lumMod",
|
||||
ColorTransform::LumOff(_) => "lumOff",
|
||||
ColorTransform::SatMod(_) => "satMod",
|
||||
ColorTransform::SatOff(_) => "satOff",
|
||||
ColorTransform::HueMod(_) => "hueMod",
|
||||
ColorTransform::HueOff(_) => "hueOff",
|
||||
ColorTransform::Alpha(_) => "alpha",
|
||||
ColorTransform::AlphaMod(_) => "alphaMod",
|
||||
ColorTransform::AlphaOff(_) => "alphaOff",
|
||||
ColorTransform::Comp => "comp",
|
||||
ColorTransform::Inv => "inv",
|
||||
ColorTransform::Gray => "gray",
|
||||
ColorTransform::RedMod(_) => "redMod",
|
||||
ColorTransform::GreenMod(_) => "greenMod",
|
||||
ColorTransform::BlueMod(_) => "blueMod",
|
||||
}
|
||||
}
|
||||
pub fn value(&self) -> Option<i32> {
|
||||
match *self {
|
||||
ColorTransform::Tint(v)
|
||||
| ColorTransform::Shade(v)
|
||||
| ColorTransform::LumMod(v)
|
||||
| ColorTransform::LumOff(v)
|
||||
| ColorTransform::SatMod(v)
|
||||
| ColorTransform::SatOff(v)
|
||||
| ColorTransform::HueMod(v)
|
||||
| ColorTransform::HueOff(v)
|
||||
| ColorTransform::Alpha(v)
|
||||
| ColorTransform::AlphaMod(v)
|
||||
| ColorTransform::AlphaOff(v)
|
||||
| ColorTransform::RedMod(v)
|
||||
| ColorTransform::GreenMod(v)
|
||||
| ColorTransform::BlueMod(v) => Some(v),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
pub fn from_xml(name: &str, val: Option<i32>) -> Option<Self> {
|
||||
let v = val.unwrap_or(0);
|
||||
Some(match name {
|
||||
"tint" => ColorTransform::Tint(v),
|
||||
"shade" => ColorTransform::Shade(v),
|
||||
"lumMod" => ColorTransform::LumMod(v),
|
||||
"lumOff" => ColorTransform::LumOff(v),
|
||||
"satMod" => ColorTransform::SatMod(v),
|
||||
"satOff" => ColorTransform::SatOff(v),
|
||||
"hueMod" => ColorTransform::HueMod(v),
|
||||
"hueOff" => ColorTransform::HueOff(v),
|
||||
"alpha" => ColorTransform::Alpha(v),
|
||||
"alphaMod" => ColorTransform::AlphaMod(v),
|
||||
"alphaOff" => ColorTransform::AlphaOff(v),
|
||||
"comp" => ColorTransform::Comp,
|
||||
"inv" => ColorTransform::Inv,
|
||||
"gray" => ColorTransform::Gray,
|
||||
"redMod" => ColorTransform::RedMod(v),
|
||||
"greenMod" => ColorTransform::GreenMod(v),
|
||||
"blueMod" => ColorTransform::BlueMod(v),
|
||||
_ => return None,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// Apply transforms to a base colour.
|
||||
pub fn apply(base: Rgba, transforms: &[ColorTransform]) -> Rgba {
|
||||
let mut c = base;
|
||||
for t in transforms {
|
||||
c = apply_one(c, *t);
|
||||
}
|
||||
c
|
||||
}
|
||||
|
||||
fn pct(v: i32) -> f64 {
|
||||
v as f64 / 100_000.0
|
||||
}
|
||||
|
||||
fn apply_one(c: Rgba, t: ColorTransform) -> Rgba {
|
||||
match t {
|
||||
// tint: towards white by (1 - value); shade: towards black by (1 - value). Office applies
|
||||
// these in linear light, which keeps mid-tones from washing out.
|
||||
ColorTransform::Tint(v) => {
|
||||
let k = pct(v).clamp(0.0, 1.0);
|
||||
map_linear(c, |x| x * k + (1.0 - k))
|
||||
}
|
||||
ColorTransform::Shade(v) => {
|
||||
let k = pct(v).clamp(0.0, 1.0);
|
||||
map_linear(c, |x| x * k)
|
||||
}
|
||||
ColorTransform::LumMod(v) => {
|
||||
let (h, s, l) = c.to_hsl();
|
||||
Rgba::from_hsl(h, s, l * pct(v), c.a)
|
||||
}
|
||||
ColorTransform::LumOff(v) => {
|
||||
let (h, s, l) = c.to_hsl();
|
||||
Rgba::from_hsl(h, s, l + pct(v), c.a)
|
||||
}
|
||||
ColorTransform::SatMod(v) => {
|
||||
let (h, s, l) = c.to_hsl();
|
||||
Rgba::from_hsl(h, s * pct(v), l, c.a)
|
||||
}
|
||||
ColorTransform::SatOff(v) => {
|
||||
let (h, s, l) = c.to_hsl();
|
||||
Rgba::from_hsl(h, s + pct(v), l, c.a)
|
||||
}
|
||||
ColorTransform::HueMod(v) => {
|
||||
let (h, s, l) = c.to_hsl();
|
||||
Rgba::from_hsl(h * pct(v), s, l, c.a)
|
||||
}
|
||||
ColorTransform::HueOff(v) => {
|
||||
let (h, s, l) = c.to_hsl();
|
||||
Rgba::from_hsl(h + v as f64 / 60_000.0, s, l, c.a)
|
||||
}
|
||||
ColorTransform::Alpha(v) => c.with_alpha((pct(v).clamp(0.0, 1.0) * 255.0).round() as u8),
|
||||
ColorTransform::AlphaMod(v) => c.with_alpha((c.a as f64 * pct(v)).round().clamp(0.0, 255.0) as u8),
|
||||
ColorTransform::AlphaOff(v) => c.with_alpha((c.a as f64 + pct(v) * 255.0).round().clamp(0.0, 255.0) as u8),
|
||||
ColorTransform::Comp => {
|
||||
let (h, s, l) = c.to_hsl();
|
||||
Rgba::from_hsl(h + 180.0, s, l, c.a)
|
||||
}
|
||||
ColorTransform::Inv => Rgba { r: 255 - c.r, g: 255 - c.g, b: 255 - c.b, a: c.a },
|
||||
ColorTransform::Gray => {
|
||||
let y = (0.299 * c.r as f64 + 0.587 * c.g as f64 + 0.114 * c.b as f64).round().clamp(0.0, 255.0) as u8;
|
||||
Rgba { r: y, g: y, b: y, a: c.a }
|
||||
}
|
||||
ColorTransform::RedMod(v) => Rgba { r: (c.r as f64 * pct(v)).round().clamp(0.0, 255.0) as u8, ..c },
|
||||
ColorTransform::GreenMod(v) => Rgba { g: (c.g as f64 * pct(v)).round().clamp(0.0, 255.0) as u8, ..c },
|
||||
ColorTransform::BlueMod(v) => Rgba { b: (c.b as f64 * pct(v)).round().clamp(0.0, 255.0) as u8, ..c },
|
||||
}
|
||||
}
|
||||
|
||||
fn to_lin(v: u8) -> f64 {
|
||||
let v = v as f64 / 255.0;
|
||||
if v <= 0.04045 { v / 12.92 } else { ((v + 0.055) / 1.055).powf(2.4) }
|
||||
}
|
||||
fn from_lin(v: f64) -> f64 {
|
||||
let v = v.clamp(0.0, 1.0);
|
||||
if v <= 0.003_130_8 { v * 12.92 } else { 1.055 * v.powf(1.0 / 2.4) - 0.055 }
|
||||
}
|
||||
fn map_linear(c: Rgba, f: impl Fn(f64) -> f64) -> Rgba {
|
||||
Rgba::from_f64(from_lin(f(to_lin(c.r))), from_lin(f(to_lin(c.g))), from_lin(f(to_lin(c.b))), c.a as f64 / 255.0)
|
||||
}
|
||||
|
||||
/// The colour-picker grid shown under each theme colour: lighter 80/60/40%, darker 25/50%
|
||||
/// (for dark colours: lighter 90/75/50/25/10%).
|
||||
pub fn theme_variants(c: Rgba) -> [(Vec<ColorTransform>, &'static str); 5] {
|
||||
let (_, _, l) = c.to_hsl();
|
||||
if l < 0.2 {
|
||||
[
|
||||
(vec![ColorTransform::LumMod(10000), ColorTransform::LumOff(90000)], "Lighter 90%"),
|
||||
(vec![ColorTransform::LumMod(25000), ColorTransform::LumOff(75000)], "Lighter 75%"),
|
||||
(vec![ColorTransform::LumMod(50000), ColorTransform::LumOff(50000)], "Lighter 50%"),
|
||||
(vec![ColorTransform::LumMod(75000), ColorTransform::LumOff(25000)], "Lighter 25%"),
|
||||
(vec![ColorTransform::LumMod(90000), ColorTransform::LumOff(10000)], "Lighter 10%"),
|
||||
]
|
||||
} else if l > 0.8 {
|
||||
[
|
||||
(vec![ColorTransform::LumMod(95000)], "Darker 5%"),
|
||||
(vec![ColorTransform::LumMod(85000)], "Darker 15%"),
|
||||
(vec![ColorTransform::LumMod(75000)], "Darker 25%"),
|
||||
(vec![ColorTransform::LumMod(65000)], "Darker 35%"),
|
||||
(vec![ColorTransform::LumMod(50000)], "Darker 50%"),
|
||||
]
|
||||
} else {
|
||||
[
|
||||
(vec![ColorTransform::LumMod(20000), ColorTransform::LumOff(80000)], "Lighter 80%"),
|
||||
(vec![ColorTransform::LumMod(40000), ColorTransform::LumOff(60000)], "Lighter 60%"),
|
||||
(vec![ColorTransform::LumMod(60000), ColorTransform::LumOff(40000)], "Lighter 40%"),
|
||||
(vec![ColorTransform::LumMod(75000)], "Darker 25%"),
|
||||
(vec![ColorTransform::LumMod(50000)], "Darker 50%"),
|
||||
]
|
||||
}
|
||||
}
|
||||
|
||||
/// Standard colours row of the colour picker.
|
||||
pub const STANDARD_COLORS: [(Rgba, &str); 10] = [
|
||||
(Rgba::rgb(0xC0, 0x00, 0x00), "Dark Red"),
|
||||
(Rgba::rgb(0xFF, 0x00, 0x00), "Red"),
|
||||
(Rgba::rgb(0xFF, 0xC0, 0x00), "Orange"),
|
||||
(Rgba::rgb(0xFF, 0xFF, 0x00), "Yellow"),
|
||||
(Rgba::rgb(0x92, 0xD0, 0x50), "Light Green"),
|
||||
(Rgba::rgb(0x00, 0xB0, 0x50), "Green"),
|
||||
(Rgba::rgb(0x00, 0xB0, 0xF0), "Light Blue"),
|
||||
(Rgba::rgb(0x00, 0x70, 0xC0), "Blue"),
|
||||
(Rgba::rgb(0x00, 0x20, 0x60), "Dark Blue"),
|
||||
(Rgba::rgb(0x70, 0x30, 0xA0), "Purple"),
|
||||
];
|
||||
|
||||
/// A few CSS-like preset colour names (`prstClr`).
|
||||
pub fn preset(name: &str) -> Option<Rgba> {
|
||||
let c = match name {
|
||||
"black" => (0, 0, 0),
|
||||
"white" => (255, 255, 255),
|
||||
"red" => (255, 0, 0),
|
||||
"green" => (0, 128, 0),
|
||||
"lime" => (0, 255, 0),
|
||||
"blue" => (0, 0, 255),
|
||||
"yellow" => (255, 255, 0),
|
||||
"cyan" | "aqua" => (0, 255, 255),
|
||||
"magenta" | "fuchsia" => (255, 0, 255),
|
||||
"gray" | "grey" => (128, 128, 128),
|
||||
"silver" => (192, 192, 192),
|
||||
"maroon" => (128, 0, 0),
|
||||
"navy" => (0, 0, 128),
|
||||
"olive" => (128, 128, 0),
|
||||
"purple" => (128, 0, 128),
|
||||
"teal" => (0, 128, 128),
|
||||
"orange" => (255, 165, 0),
|
||||
"pink" => (255, 192, 203),
|
||||
"brown" => (165, 42, 42),
|
||||
"gold" => (255, 215, 0),
|
||||
"ltGray" | "lightGray" => (211, 211, 211),
|
||||
"dkGray" | "darkGray" => (169, 169, 169),
|
||||
_ => return None,
|
||||
};
|
||||
Some(Rgba::rgb(c.0, c.1, c.2))
|
||||
}
|
||||
|
||||
/// Every preset colour name a file may write (`ST_PresetColorVal`, with the later editions' aliases).
|
||||
pub const PRESET_NAMES: [&str; 190] = [
|
||||
"aliceBlue",
|
||||
"antiqueWhite",
|
||||
"aqua",
|
||||
"aquamarine",
|
||||
"azure",
|
||||
"beige",
|
||||
"bisque",
|
||||
"black",
|
||||
"blanchedAlmond",
|
||||
"blue",
|
||||
"blueViolet",
|
||||
"brown",
|
||||
"burlyWood",
|
||||
"cadetBlue",
|
||||
"chartreuse",
|
||||
"chocolate",
|
||||
"coral",
|
||||
"cornflowerBlue",
|
||||
"cornsilk",
|
||||
"crimson",
|
||||
"cyan",
|
||||
"darkBlue",
|
||||
"darkCyan",
|
||||
"darkGoldenrod",
|
||||
"darkGray",
|
||||
"darkGrey",
|
||||
"darkGreen",
|
||||
"darkKhaki",
|
||||
"darkMagenta",
|
||||
"darkOliveGreen",
|
||||
"darkOrange",
|
||||
"darkOrchid",
|
||||
"darkRed",
|
||||
"darkSalmon",
|
||||
"darkSeaGreen",
|
||||
"darkSlateBlue",
|
||||
"darkSlateGray",
|
||||
"darkSlateGrey",
|
||||
"darkTurquoise",
|
||||
"darkViolet",
|
||||
"dkBlue",
|
||||
"dkCyan",
|
||||
"dkGoldenrod",
|
||||
"dkGray",
|
||||
"dkGrey",
|
||||
"dkGreen",
|
||||
"dkKhaki",
|
||||
"dkMagenta",
|
||||
"dkOliveGreen",
|
||||
"dkOrange",
|
||||
"dkOrchid",
|
||||
"dkRed",
|
||||
"dkSalmon",
|
||||
"dkSeaGreen",
|
||||
"dkSlateBlue",
|
||||
"dkSlateGray",
|
||||
"dkSlateGrey",
|
||||
"dkTurquoise",
|
||||
"dkViolet",
|
||||
"deepPink",
|
||||
"deepSkyBlue",
|
||||
"dimGray",
|
||||
"dimGrey",
|
||||
"dodgerBlue",
|
||||
"firebrick",
|
||||
"floralWhite",
|
||||
"forestGreen",
|
||||
"fuchsia",
|
||||
"gainsboro",
|
||||
"ghostWhite",
|
||||
"gold",
|
||||
"goldenrod",
|
||||
"gray",
|
||||
"grey",
|
||||
"green",
|
||||
"greenYellow",
|
||||
"honeydew",
|
||||
"hotPink",
|
||||
"indianRed",
|
||||
"indigo",
|
||||
"ivory",
|
||||
"khaki",
|
||||
"lavender",
|
||||
"lavenderBlush",
|
||||
"lawnGreen",
|
||||
"lemonChiffon",
|
||||
"lightBlue",
|
||||
"lightCoral",
|
||||
"lightCyan",
|
||||
"lightGoldenrodYellow",
|
||||
"lightGray",
|
||||
"lightGrey",
|
||||
"lightGreen",
|
||||
"lightPink",
|
||||
"lightSalmon",
|
||||
"lightSeaGreen",
|
||||
"lightSkyBlue",
|
||||
"lightSlateGray",
|
||||
"lightSlateGrey",
|
||||
"lightSteelBlue",
|
||||
"lightYellow",
|
||||
"ltBlue",
|
||||
"ltCoral",
|
||||
"ltCyan",
|
||||
"ltGoldenrodYellow",
|
||||
"ltGray",
|
||||
"ltGrey",
|
||||
"ltGreen",
|
||||
"ltPink",
|
||||
"ltSalmon",
|
||||
"ltSeaGreen",
|
||||
"ltSkyBlue",
|
||||
"ltSlateGray",
|
||||
"ltSlateGrey",
|
||||
"ltSteelBlue",
|
||||
"ltYellow",
|
||||
"lime",
|
||||
"limeGreen",
|
||||
"linen",
|
||||
"magenta",
|
||||
"maroon",
|
||||
"medAquamarine",
|
||||
"medBlue",
|
||||
"medOrchid",
|
||||
"medPurple",
|
||||
"medSeaGreen",
|
||||
"medSlateBlue",
|
||||
"medSpringGreen",
|
||||
"medTurquoise",
|
||||
"medVioletRed",
|
||||
"mediumAquamarine",
|
||||
"mediumBlue",
|
||||
"mediumOrchid",
|
||||
"mediumPurple",
|
||||
"mediumSeaGreen",
|
||||
"mediumSlateBlue",
|
||||
"mediumSpringGreen",
|
||||
"mediumTurquoise",
|
||||
"mediumVioletRed",
|
||||
"midnightBlue",
|
||||
"mintCream",
|
||||
"mistyRose",
|
||||
"moccasin",
|
||||
"navajoWhite",
|
||||
"navy",
|
||||
"oldLace",
|
||||
"olive",
|
||||
"oliveDrab",
|
||||
"orange",
|
||||
"orangeRed",
|
||||
"orchid",
|
||||
"paleGoldenrod",
|
||||
"paleGreen",
|
||||
"paleTurquoise",
|
||||
"paleVioletRed",
|
||||
"papayaWhip",
|
||||
"peachPuff",
|
||||
"peru",
|
||||
"pink",
|
||||
"plum",
|
||||
"powderBlue",
|
||||
"purple",
|
||||
"red",
|
||||
"rosyBrown",
|
||||
"royalBlue",
|
||||
"saddleBrown",
|
||||
"salmon",
|
||||
"sandyBrown",
|
||||
"seaGreen",
|
||||
"seaShell",
|
||||
"sienna",
|
||||
"silver",
|
||||
"skyBlue",
|
||||
"slateBlue",
|
||||
"slateGray",
|
||||
"slateGrey",
|
||||
"snow",
|
||||
"springGreen",
|
||||
"steelBlue",
|
||||
"tan",
|
||||
"teal",
|
||||
"thistle",
|
||||
"tomato",
|
||||
"turquoise",
|
||||
"violet",
|
||||
"wheat",
|
||||
"white",
|
||||
"whiteSmoke",
|
||||
"yellow",
|
||||
"yellowGreen",
|
||||
];
|
||||
|
||||
/// Every system colour name a file may write (`ST_SystemColorVal`).
|
||||
pub const SYSTEM_NAMES: [&str; 30] = [
|
||||
"scrollBar",
|
||||
"background",
|
||||
"activeCaption",
|
||||
"inactiveCaption",
|
||||
"menu",
|
||||
"window",
|
||||
"windowFrame",
|
||||
"menuText",
|
||||
"windowText",
|
||||
"captionText",
|
||||
"activeBorder",
|
||||
"inactiveBorder",
|
||||
"appWorkspace",
|
||||
"highlight",
|
||||
"highlightText",
|
||||
"btnFace",
|
||||
"btnShadow",
|
||||
"grayText",
|
||||
"btnText",
|
||||
"inactiveCaptionText",
|
||||
"btnHighlight",
|
||||
"3dDkShadow",
|
||||
"3dLight",
|
||||
"infoText",
|
||||
"infoBk",
|
||||
"hotLight",
|
||||
"gradientActiveCaption",
|
||||
"gradientInactiveCaption",
|
||||
"menuHighlight",
|
||||
"menuBar",
|
||||
];
|
||||
|
||||
/// Whether `name` is a preset colour name a file may write.
|
||||
pub fn is_preset_name(name: &str) -> bool {
|
||||
PRESET_NAMES.contains(&name)
|
||||
}
|
||||
|
||||
/// Whether `name` is a system colour name a file may write.
|
||||
pub fn is_system_name(name: &str) -> bool {
|
||||
SYSTEM_NAMES.contains(&name)
|
||||
}
|
||||
pub use craft_drawingml::color::*;
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
@@ -820,7 +72,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn scheme_slots() {
|
||||
let mut s = ColorScheme { name: "t".into(), colors: [Rgba::BLACK; 12] };
|
||||
let mut s = ColorScheme::new("t", [Rgba::BLACK; 12]);
|
||||
s.set(SchemeSlot::Accent3, Rgba::WHITE);
|
||||
assert_eq!(s.get(SchemeSlot::Accent3), Rgba::WHITE);
|
||||
assert_eq!(s.get(SchemeSlot::Tx1), Rgba::BLACK);
|
||||
|
||||
@@ -9,6 +9,7 @@ description = "DeckCraft engine: sessions, undo history, selection, the command
|
||||
workspace = true
|
||||
|
||||
[dependencies]
|
||||
craft-mime = { workspace = true }
|
||||
deckcraft-geom = { workspace = true }
|
||||
deckcraft-color = { workspace = true }
|
||||
deckcraft-model = { workspace = true }
|
||||
|
||||
+113
-31
@@ -607,51 +607,133 @@ fn param_optional(alt: &str) -> Option<bool> {
|
||||
|
||||
/// Base64 (standard alphabet) for binary payloads in JSON params and results.
|
||||
pub fn base64_encode(data: &[u8]) -> String {
|
||||
const A: &[u8; 64] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
||||
let mut out = String::with_capacity(data.len().div_ceil(3) * 4);
|
||||
for chunk in data.chunks(3) {
|
||||
let b = [chunk.first().copied().unwrap_or(0), chunk.get(1).copied().unwrap_or(0), chunk.get(2).copied().unwrap_or(0)];
|
||||
let n = ((b[0] as u32) << 16) | ((b[1] as u32) << 8) | b[2] as u32;
|
||||
for (i, shift) in [18, 12, 6, 0].iter().enumerate() {
|
||||
if i <= chunk.len() {
|
||||
out.push(A.get(((n >> shift) & 63) as usize).copied().unwrap_or(b'A') as char);
|
||||
} else {
|
||||
out.push('=');
|
||||
}
|
||||
}
|
||||
}
|
||||
out
|
||||
craft_mime::base64::STANDARD.encode(data)
|
||||
}
|
||||
|
||||
pub fn base64_decode(s: &str) -> Option<Vec<u8>> {
|
||||
let s = s.split_once("base64,").map(|(_, b)| b).unwrap_or(s);
|
||||
let mut out = Vec::with_capacity(s.len() / 4 * 3);
|
||||
let mut acc = 0u32;
|
||||
let mut bits = 0;
|
||||
// Preserve the command transport's admission rules before the shared legacy decoder:
|
||||
// padding ends the payload and one trailing symbol cannot encode a byte.
|
||||
let (mut symbols_mod_four, mut padded) = (0u8, false);
|
||||
for c in s.bytes() {
|
||||
let v = match c {
|
||||
b'A'..=b'Z' => c - b'A',
|
||||
b'a'..=b'z' => c - b'a' + 26,
|
||||
b'0'..=b'9' => c - b'0' + 52,
|
||||
b'+' | b'-' => 62,
|
||||
b'/' | b'_' => 63,
|
||||
b'=' | b'\n' | b'\r' | b' ' => continue,
|
||||
match c {
|
||||
b'=' => padded = true,
|
||||
b'\n' | b'\r' | b' ' => {}
|
||||
b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'+' | b'-' | b'/' | b'_' if !padded => {
|
||||
symbols_mod_four = (symbols_mod_four + 1) % 4;
|
||||
}
|
||||
_ => return None,
|
||||
} as u32;
|
||||
acc = (acc << 6) | v;
|
||||
bits += 6;
|
||||
if bits >= 8 {
|
||||
bits -= 8;
|
||||
out.push(((acc >> bits) & 0xff) as u8);
|
||||
}
|
||||
}
|
||||
Some(out)
|
||||
if symbols_mod_four == 1 {
|
||||
return None;
|
||||
}
|
||||
craft_mime::base64_compat::decode(s).ok()
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
// Frozen pre-cutover implementation (Brandon Thomas, with Mex's padding/tail fixes).
|
||||
fn previous_base64_decode(s: &str) -> Option<Vec<u8>> {
|
||||
let s = s.split_once("base64,").map(|(_, b)| b).unwrap_or(s);
|
||||
let mut out = Vec::with_capacity(s.len() / 4 * 3);
|
||||
let mut acc = 0u32;
|
||||
let mut bits = 0;
|
||||
let mut padded = false;
|
||||
for c in s.bytes() {
|
||||
let v = match c {
|
||||
b'A'..=b'Z' => c - b'A',
|
||||
b'a'..=b'z' => c - b'a' + 26,
|
||||
b'0'..=b'9' => c - b'0' + 52,
|
||||
b'+' | b'-' => 62,
|
||||
b'/' | b'_' => 63,
|
||||
b'=' => {
|
||||
padded = true;
|
||||
continue;
|
||||
}
|
||||
b'\n' | b'\r' | b' ' => continue,
|
||||
_ => return None,
|
||||
} as u32;
|
||||
// Padding ends the payload; no further data may be decoded.
|
||||
if padded {
|
||||
return None;
|
||||
}
|
||||
acc = (acc << 6) | v;
|
||||
bits += 6;
|
||||
if bits >= 8 {
|
||||
bits -= 8;
|
||||
out.push(((acc >> bits) & 0xff) as u8);
|
||||
}
|
||||
}
|
||||
// A trailing lone Base64 character cannot encode another byte.
|
||||
(bits != 6).then_some(out)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn shared_decoder_preserves_command_transport_admission() {
|
||||
for text in ["", "=", "Zg== \r\n==", "Zg==A", "A", "AAAAA", "AB", "+_8=", "Z=m9v", "Zm9v\t", "Zm9v!", "data:text/plain;base64,Zm9v"] {
|
||||
assert_eq!(base64_decode(text), previous_base64_decode(text), "{text:?}");
|
||||
}
|
||||
let alphabet = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/-_= \r\n!\t";
|
||||
let mut seed = 0x1234_5678u32;
|
||||
for n in 0..50_000 {
|
||||
let mut text = String::new();
|
||||
for _ in 0..n % 65 {
|
||||
seed = seed.wrapping_mul(1_664_525).wrapping_add(1_013_904_223);
|
||||
text.push(char::from(alphabet[(seed as usize) % alphabet.len()]));
|
||||
}
|
||||
assert_eq!(base64_decode(&text), previous_base64_decode(&text), "{text:?}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn shared_encoder_preserves_rfc4648_and_all_byte_remainders() {
|
||||
for (input, expected) in
|
||||
[("", ""), ("f", "Zg=="), ("fo", "Zm8="), ("foo", "Zm9v"), ("foob", "Zm9vYg=="), ("fooba", "Zm9vYmE="), ("foobar", "Zm9vYmFy")]
|
||||
{
|
||||
assert_eq!(base64_encode(input.as_bytes()), expected);
|
||||
}
|
||||
// The decoder accepts both alphabets, so pin the standard one explicitly.
|
||||
assert_eq!(base64_encode(&[0xfb, 0xff]), "+/8=");
|
||||
let all: Vec<u8> = (0..=255).cycle().take(513).collect();
|
||||
for len in 0..=all.len() {
|
||||
let encoded = base64_encode(&all[..len]);
|
||||
assert_eq!(encoded.len(), len.div_ceil(3) * 4);
|
||||
assert_eq!(encoded.bytes().rev().take_while(|b| *b == b'=').count(), (3 - len % 3) % 3);
|
||||
assert_eq!(base64_decode(&encoded).as_deref(), Some(&all[..len]));
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn base64_rejects_a_single_character_tail() {
|
||||
for (encoded, decoded) in [
|
||||
("", b"".as_slice()),
|
||||
("Zg==", b"f"),
|
||||
("Zg", b"f"),
|
||||
("Zm8=", b"fo"),
|
||||
("Zm8", b"fo"),
|
||||
(" Zm9v \r\n", b"foo"),
|
||||
("data:text/plain;base64,Zm9v", b"foo"),
|
||||
("+/8=", &[0xfb, 0xff]),
|
||||
("-_8=", &[0xfb, 0xff]),
|
||||
] {
|
||||
assert_eq!(base64_decode(encoded).as_deref(), Some(decoded), "{encoded:?}");
|
||||
}
|
||||
for encoded in ["A", "AAAAA", "Zm9vZ", " Zm9vZ \r\n", "data:text/plain;base64,Z"] {
|
||||
assert!(base64_decode(encoded).is_none(), "{encoded:?}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn base64_rejects_data_after_padding() {
|
||||
assert_eq!(base64_decode("Zg== \r\n=="), Some(b"f".to_vec()));
|
||||
for encoded in ["Zg==A", "Zg== Zm8=", "Zm8=A", "=Zg", "Zg==\r\nA", "data:text/plain;base64,Zg==A"] {
|
||||
assert!(base64_decode(encoded).is_none(), "{encoded:?}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_palette_skips_a_command_that_needs_a_value() {
|
||||
assert!(needs_arguments("{path}"));
|
||||
|
||||
@@ -417,17 +417,28 @@ fn regroup(s: &mut Session, _p: &Value) -> Result<Value> {
|
||||
}
|
||||
}
|
||||
|
||||
/// `to` of arrange.align and arrange.distribute: `Some(true)` for the slide, `Some(false)` for the
|
||||
/// selection, `None` when it is left out. Any other value, a non-string included, is refused.
|
||||
fn align_to(cmd: &str, p: &Value) -> Result<Option<bool>> {
|
||||
match p.get("to").map(Value::as_str) {
|
||||
None => Ok(None),
|
||||
Some(Some("slide")) => Ok(Some(true)),
|
||||
Some(Some("selection")) => Ok(Some(false)),
|
||||
Some(_) => Err(bad(cmd, "`to` must be slide or selection")),
|
||||
}
|
||||
}
|
||||
|
||||
fn align(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let edge = str_param(p, "edge").unwrap_or("left").to_string();
|
||||
let edge = match str_param(p, "edge") {
|
||||
Some(e @ ("left" | "center" | "right" | "top" | "middle" | "bottom")) => e.to_string(),
|
||||
_ => return Err(bad("arrange.align", "`edge` must be left, center, right, top, middle or bottom")),
|
||||
};
|
||||
let to = align_to("arrange.align", p)?;
|
||||
let ids = targets(s, p)?;
|
||||
let st = s.doc()?;
|
||||
let size = st.doc.slide_size;
|
||||
let boxes: Vec<(ShapeId, Xfrm)> = ids.iter().filter_map(|id| st.shape(*id).map(|x| (*id, xfrm_of(&st.doc, &st.selection, x)))).collect();
|
||||
let to_slide = match str_param(p, "to") {
|
||||
Some("slide") => true,
|
||||
Some(_) => false,
|
||||
None => boxes.len() < 2,
|
||||
};
|
||||
let to_slide = to.unwrap_or(boxes.len() < 2);
|
||||
let reference = if to_slide {
|
||||
Rect::new(0.0, 0.0, size.width, size.height)
|
||||
} else {
|
||||
@@ -453,13 +464,18 @@ fn align(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
}
|
||||
|
||||
fn distribute(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let horiz = !str_param(p, "dir").unwrap_or("horizontal").starts_with('v');
|
||||
let horiz = match p.get("dir").map(Value::as_str) {
|
||||
None | Some(Some("horizontal")) => true,
|
||||
Some(Some("vertical")) => false,
|
||||
Some(_) => return Err(bad("arrange.distribute", "`dir` must be horizontal or vertical")),
|
||||
};
|
||||
let to = align_to("arrange.distribute", p)?;
|
||||
let ids = targets(s, p)?;
|
||||
let st = s.doc()?;
|
||||
let size = st.doc.slide_size;
|
||||
let mut boxes: Vec<(ShapeId, Rect)> =
|
||||
ids.iter().filter_map(|id| st.shape(*id).map(|x| (*id, xfrm_of(&st.doc, &st.selection, x).bounds()))).collect();
|
||||
let to_slide = str_param(p, "to") == Some("slide") || boxes.len() < 3;
|
||||
let to_slide = to == Some(true) || boxes.len() < 3;
|
||||
if boxes.is_empty() {
|
||||
return ok();
|
||||
}
|
||||
|
||||
@@ -9,7 +9,7 @@ pub(super) fn adjust(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let v = f64_param(p, "value").ok_or_else(|| bad("shape.adjust", "missing `value`"))?;
|
||||
edit_geometry(s, p, "shape.adjust", |sh| {
|
||||
if let Geom::Preset { name, adj } = &mut sh.geom {
|
||||
let defaults = deckcraft_geom::preset::info(name).map(|x| x.defaults).unwrap_or(&[]);
|
||||
let defaults = deckcraft_geom::preset::adjust_defaults(name);
|
||||
while adj.len() <= i {
|
||||
let k = adj.len();
|
||||
adj.push(defaults.get(k).copied().unwrap_or(0.0));
|
||||
|
||||
@@ -1184,6 +1184,82 @@ fn distribute_wide_middle_stays_in_selection_bounds() {
|
||||
assert!(xs.iter().all(|x| (*x - [0.0, 10.0, 110.0][xs.iter().position(|y| y == x).unwrap()]).abs() < 1e-6), "{xs:?}");
|
||||
}
|
||||
|
||||
/// An `edge`, `dir` or `to` that the commands do not name, or no `edge` at all, is refused with
|
||||
/// the accepted values. Before, such a call reported its shapes as edited and moved nothing,
|
||||
/// aligned to the selection, or fell back to the left edge or to horizontal.
|
||||
#[test]
|
||||
fn align_and_distribute_refuse_values_they_do_not_name() {
|
||||
let mut s = session();
|
||||
let mut ids = vec![];
|
||||
for (x, y) in [(10.0, 10.0), (200.0, 50.0), (500.0, 200.0)] {
|
||||
ids.push(s.execute("shape.insert", &json!({"preset": "rect", "rect": [x, y, 40, 40]})).unwrap()["id"].as_u64().unwrap());
|
||||
}
|
||||
s.execute("edit.select", &json!({"ids": ids})).unwrap();
|
||||
let before = s.doc().unwrap().revision;
|
||||
let edges = "`edge` must be left, center, right, top, middle or bottom";
|
||||
let dirs = "`dir` must be horizontal or vertical";
|
||||
let tos = "`to` must be slide or selection";
|
||||
for (cmd, params, want) in [
|
||||
("arrange.align", json!({"edge": "centre"}), edges),
|
||||
("arrange.align", json!({"edge": "Left"}), edges),
|
||||
("arrange.align", json!({"edge": "hcenter"}), edges),
|
||||
("arrange.align", json!({}), edges),
|
||||
("arrange.align", json!({"ids": [ids[0]], "edge": "left", "to": "Slide"}), tos),
|
||||
("arrange.distribute", json!({"dir": "Vertical"}), dirs),
|
||||
("arrange.distribute", json!({"dir": "columns"}), dirs),
|
||||
("arrange.distribute", json!({"dir": "v"}), dirs),
|
||||
("arrange.distribute", json!({"dir": "vertical", "to": "page"}), tos),
|
||||
] {
|
||||
let err = s.execute(cmd, ¶ms).unwrap_err().to_string();
|
||||
assert!(err.contains(want), "{cmd} {params}: {err}");
|
||||
}
|
||||
assert_eq!(s.doc().unwrap().revision, before, "a refused call leaves the slide as it was");
|
||||
let pos = |s: &mut Session, id: u64, k: &str| s.execute("shape.inspect", &json!({"id": id})).unwrap()["box"][k].as_f64().unwrap();
|
||||
s.execute("arrange.align", &json!({"ids": [ids[1]], "edge": "left", "to": "slide"})).unwrap();
|
||||
assert!(pos(&mut s, ids[1], "x").abs() < 1e-6);
|
||||
// Within the selection's span, 10..240: 120 pt of shapes leaves two 55 pt gaps.
|
||||
s.execute("arrange.distribute", &json!({"ids": ids, "dir": "vertical", "to": "selection"})).unwrap();
|
||||
assert!((pos(&mut s, ids[1], "y") - 105.0).abs() < 1e-6);
|
||||
}
|
||||
|
||||
/// A `dir` or `to` that is present but is not a string (null, a number, a bool, an object or an
|
||||
/// array) is refused with the accepted values, and the shapes and the revision stay as they were.
|
||||
/// Before, such a value counted as left out: `dir` meant horizontal and `to` each command's
|
||||
/// default, so the call moved the selected shapes.
|
||||
#[test]
|
||||
fn align_and_distribute_refuse_dir_and_to_that_are_not_strings() {
|
||||
let dirs = "`dir` must be horizontal or vertical";
|
||||
let tos = "`to` must be slide or selection";
|
||||
let mut failures = vec![];
|
||||
for v in [json!(null), json!(123), json!(false), json!({}), json!([])] {
|
||||
for (cmd, params, want) in [
|
||||
("arrange.distribute", json!({"dir": v.clone()}), dirs),
|
||||
("arrange.distribute", json!({"dir": "horizontal", "to": v.clone()}), tos),
|
||||
("arrange.align", json!({"edge": "left", "to": v.clone()}), tos),
|
||||
] {
|
||||
let mut s = session();
|
||||
let mut ids = vec![];
|
||||
for (x, y) in [(10.0, 10.0), (200.0, 50.0), (500.0, 200.0)] {
|
||||
ids.push(s.execute("shape.insert", &json!({"preset": "rect", "rect": [x, y, 40, 40]})).unwrap()["id"].as_u64().unwrap());
|
||||
}
|
||||
s.execute("edit.select", &json!({"ids": ids})).unwrap();
|
||||
let boxes = |s: &mut Session| -> Vec<Value> {
|
||||
ids.iter().map(|id| s.execute("shape.inspect", &json!({"id": id})).unwrap()["box"].clone()).collect()
|
||||
};
|
||||
let (rev, before) = (s.doc().unwrap().revision, boxes(&mut s));
|
||||
match s.execute(cmd, ¶ms) {
|
||||
Ok(_) => failures.push(format!("{cmd} {params}: accepted")),
|
||||
Err(e) if !e.to_string().contains(want) => failures.push(format!("{cmd} {params}: {e}")),
|
||||
Err(_) => {}
|
||||
}
|
||||
if s.doc().unwrap().revision != rev || boxes(&mut s) != before {
|
||||
failures.push(format!("{cmd} {params}: moved the shapes"));
|
||||
}
|
||||
}
|
||||
}
|
||||
assert!(failures.is_empty(), "{failures:#?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pointer_draw_move_resize() {
|
||||
let mut s = session();
|
||||
|
||||
@@ -293,7 +293,7 @@ impl Session {
|
||||
if let Some(sh) = deckcraft_model::find_shape_mut(list, id)
|
||||
&& let deckcraft_model::Geom::Preset { name, adj } = &mut sh.geom
|
||||
{
|
||||
let defaults = deckcraft_geom::preset::info(name).map(|x| x.defaults).unwrap_or(&[]);
|
||||
let defaults = deckcraft_geom::preset::adjust_defaults(name);
|
||||
for (i, v) in &vals {
|
||||
while adj.len() <= *i {
|
||||
let k = adj.len();
|
||||
|
||||
@@ -9,8 +9,10 @@ description = "DeckCraft native file format (.deckcraft: zip of a JSON manifest
|
||||
workspace = true
|
||||
|
||||
[dependencies]
|
||||
craft-deckcraft-format = { workspace = true }
|
||||
craft-rtf = { workspace = true }
|
||||
deckcraft-model = { workspace = true }
|
||||
serde = { workspace = true }
|
||||
|
||||
[dev-dependencies]
|
||||
serde_json = { workspace = true }
|
||||
zip = { workspace = true }
|
||||
thiserror = { workspace = true }
|
||||
|
||||
@@ -1,14 +1,14 @@
|
||||
//! Keep opaque chart payloads out of the JSON manifest and within the media load budget.
|
||||
use std::collections::HashSet;
|
||||
use std::io::Cursor;
|
||||
use std::sync::Arc;
|
||||
|
||||
use craft_deckcraft_format::{MAX_ENTRY, Package, chart_part_entry, is_chart_part_entry};
|
||||
|
||||
use deckcraft_model::chart::ChartPart;
|
||||
use deckcraft_model::{Master, Presentation, Shape, ShapeKind};
|
||||
|
||||
use crate::{FormatError, MAX_ENTRY, Result, read_entry_max};
|
||||
use crate::{FormatError, Result};
|
||||
|
||||
const PREFIX: &str = "chart-parts/";
|
||||
type Payload = (String, String, Vec<u8>);
|
||||
|
||||
pub(super) fn separate(p: &mut Presentation) -> Result<Vec<Payload>> {
|
||||
@@ -16,7 +16,7 @@ pub(super) fn separate(p: &mut Presentation) -> Result<Vec<Payload>> {
|
||||
visit_parts(p, |part| {
|
||||
// The native namespace is independent of the original OPC names, which may repeat
|
||||
// when charts from several decks are combined. No user-supplied path is extracted.
|
||||
let entry = format!("{PREFIX}{}", payloads.len());
|
||||
let entry = chart_part_entry(payloads.len());
|
||||
part.native_entry = Some(entry.clone());
|
||||
payloads.push((entry, part.content_type.clone(), std::mem::take(&mut part.bytes)));
|
||||
Ok(())
|
||||
@@ -26,7 +26,7 @@ pub(super) fn separate(p: &mut Presentation) -> Result<Vec<Payload>> {
|
||||
|
||||
pub(super) fn restore(
|
||||
p: &mut Presentation,
|
||||
z: &mut zip::ZipArchive<Cursor<&[u8]>>,
|
||||
z: &mut Package<'_>,
|
||||
left: &mut u64,
|
||||
mut items: usize,
|
||||
max_items: usize,
|
||||
@@ -40,21 +40,21 @@ pub(super) fn restore(
|
||||
items += 1;
|
||||
if let Some(entry) = part.native_entry.take() {
|
||||
// Accept only names produced by separate(), and inflate each member once.
|
||||
let canonical = entry.strip_prefix(PREFIX).and_then(|s| s.parse::<usize>().ok()).is_some_and(|n| entry == format!("{PREFIX}{n}"));
|
||||
let canonical = is_chart_part_entry(&entry);
|
||||
if !canonical || !seen.insert(entry.clone()) || !part.bytes.is_empty() {
|
||||
return Err(FormatError::Damaged("invalid or ambiguous chart part reference".into()));
|
||||
}
|
||||
if z.index_for_name(&entry).is_none() {
|
||||
if !z.contains(&entry) {
|
||||
// Missing members consume no inflation work and can be reported for recovery.
|
||||
damaged.push(format!("{entry}: missing chart part"));
|
||||
return Ok(());
|
||||
}
|
||||
if z.by_name(&entry).is_ok_and(|f| f.size() > *left) {
|
||||
if z.declared_size(&entry).is_some_and(|size| size > *left) {
|
||||
return Err(FormatError::Damaged("embedded media and chart parts are larger than DeckCraft can open".into()));
|
||||
}
|
||||
// A CRC/decode error may already have inflated bytes. Stop on that first error
|
||||
// rather than letting later corrupt members reuse the unchanged byte budget.
|
||||
let bytes = read_entry_max(z, &entry, (*left).min(MAX_ENTRY))?;
|
||||
let bytes = z.read_max(&entry, (*left).min(MAX_ENTRY))?;
|
||||
*left -= bytes.len() as u64;
|
||||
part.bytes = bytes;
|
||||
} else {
|
||||
|
||||
@@ -1,185 +0,0 @@
|
||||
//! A serde serializer adapter that writes non-finite floats as 0.
|
||||
//!
|
||||
//! serde_json writes NaN and ±infinity as `null`, which doesn't read back as a number: a single
|
||||
//! NaN anywhere in the model (a rotation, a crop, a stroke width) made a saved file fail to open
|
||||
//! as "damaged". [`Finite`] wraps any `Serialize` value and replaces those floats on the way out;
|
||||
//! everything else passes through unchanged.
|
||||
|
||||
use serde::ser::{self, Serialize, Serializer};
|
||||
|
||||
/// `T`, serialized with non-finite floats written as 0.
|
||||
pub struct Finite<'a, T: ?Sized>(pub &'a T);
|
||||
|
||||
impl<T: ?Sized + Serialize> Serialize for Finite<'_, T> {
|
||||
fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
|
||||
self.0.serialize(Wrap(s))
|
||||
}
|
||||
}
|
||||
|
||||
struct Wrap<S>(S);
|
||||
|
||||
macro_rules! pass {
|
||||
($($m:ident($t:ty)),* $(,)?) => {
|
||||
$(fn $m(self, v: $t) -> Result<S::Ok, S::Error> { self.0.$m(v) })*
|
||||
};
|
||||
}
|
||||
|
||||
impl<S: Serializer> Serializer for Wrap<S> {
|
||||
type Ok = S::Ok;
|
||||
type Error = S::Error;
|
||||
type SerializeSeq = Wrap<S::SerializeSeq>;
|
||||
type SerializeTuple = Wrap<S::SerializeTuple>;
|
||||
type SerializeTupleStruct = Wrap<S::SerializeTupleStruct>;
|
||||
type SerializeTupleVariant = Wrap<S::SerializeTupleVariant>;
|
||||
type SerializeMap = Wrap<S::SerializeMap>;
|
||||
type SerializeStruct = Wrap<S::SerializeStruct>;
|
||||
type SerializeStructVariant = Wrap<S::SerializeStructVariant>;
|
||||
|
||||
pass!(
|
||||
serialize_bool(bool),
|
||||
serialize_i8(i8),
|
||||
serialize_i16(i16),
|
||||
serialize_i32(i32),
|
||||
serialize_i64(i64),
|
||||
serialize_i128(i128),
|
||||
serialize_u8(u8),
|
||||
serialize_u16(u16),
|
||||
serialize_u32(u32),
|
||||
serialize_u64(u64),
|
||||
serialize_u128(u128),
|
||||
serialize_char(char),
|
||||
serialize_str(&str),
|
||||
serialize_bytes(&[u8]),
|
||||
);
|
||||
|
||||
fn serialize_f32(self, v: f32) -> Result<S::Ok, S::Error> {
|
||||
self.0.serialize_f32(if v.is_finite() { v } else { 0.0 })
|
||||
}
|
||||
fn serialize_f64(self, v: f64) -> Result<S::Ok, S::Error> {
|
||||
self.0.serialize_f64(if v.is_finite() { v } else { 0.0 })
|
||||
}
|
||||
fn serialize_none(self) -> Result<S::Ok, S::Error> {
|
||||
self.0.serialize_none()
|
||||
}
|
||||
fn serialize_some<T: ?Sized + Serialize>(self, v: &T) -> Result<S::Ok, S::Error> {
|
||||
self.0.serialize_some(&Finite(v))
|
||||
}
|
||||
fn serialize_unit(self) -> Result<S::Ok, S::Error> {
|
||||
self.0.serialize_unit()
|
||||
}
|
||||
fn serialize_unit_struct(self, name: &'static str) -> Result<S::Ok, S::Error> {
|
||||
self.0.serialize_unit_struct(name)
|
||||
}
|
||||
fn serialize_unit_variant(self, name: &'static str, i: u32, variant: &'static str) -> Result<S::Ok, S::Error> {
|
||||
self.0.serialize_unit_variant(name, i, variant)
|
||||
}
|
||||
fn serialize_newtype_struct<T: ?Sized + Serialize>(self, name: &'static str, v: &T) -> Result<S::Ok, S::Error> {
|
||||
self.0.serialize_newtype_struct(name, &Finite(v))
|
||||
}
|
||||
fn serialize_newtype_variant<T: ?Sized + Serialize>(self, name: &'static str, i: u32, variant: &'static str, v: &T) -> Result<S::Ok, S::Error> {
|
||||
self.0.serialize_newtype_variant(name, i, variant, &Finite(v))
|
||||
}
|
||||
fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, S::Error> {
|
||||
self.0.serialize_seq(len).map(Wrap)
|
||||
}
|
||||
fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, S::Error> {
|
||||
self.0.serialize_tuple(len).map(Wrap)
|
||||
}
|
||||
fn serialize_tuple_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeTupleStruct, S::Error> {
|
||||
self.0.serialize_tuple_struct(name, len).map(Wrap)
|
||||
}
|
||||
fn serialize_tuple_variant(self, name: &'static str, i: u32, variant: &'static str, len: usize) -> Result<Self::SerializeTupleVariant, S::Error> {
|
||||
self.0.serialize_tuple_variant(name, i, variant, len).map(Wrap)
|
||||
}
|
||||
fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, S::Error> {
|
||||
self.0.serialize_map(len).map(Wrap)
|
||||
}
|
||||
fn serialize_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeStruct, S::Error> {
|
||||
self.0.serialize_struct(name, len).map(Wrap)
|
||||
}
|
||||
fn serialize_struct_variant(
|
||||
self,
|
||||
name: &'static str,
|
||||
i: u32,
|
||||
variant: &'static str,
|
||||
len: usize,
|
||||
) -> Result<Self::SerializeStructVariant, S::Error> {
|
||||
self.0.serialize_struct_variant(name, i, variant, len).map(Wrap)
|
||||
}
|
||||
fn is_human_readable(&self) -> bool {
|
||||
self.0.is_human_readable()
|
||||
}
|
||||
}
|
||||
|
||||
macro_rules! compound {
|
||||
($tr:ident, $m:ident) => {
|
||||
impl<S: ser::$tr> ser::$tr for Wrap<S> {
|
||||
type Ok = S::Ok;
|
||||
type Error = S::Error;
|
||||
fn $m<T: ?Sized + Serialize>(&mut self, v: &T) -> Result<(), S::Error> {
|
||||
self.0.$m(&Finite(v))
|
||||
}
|
||||
fn end(self) -> Result<S::Ok, S::Error> {
|
||||
self.0.end()
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
compound!(SerializeSeq, serialize_element);
|
||||
compound!(SerializeTuple, serialize_element);
|
||||
compound!(SerializeTupleStruct, serialize_field);
|
||||
compound!(SerializeTupleVariant, serialize_field);
|
||||
|
||||
impl<S: ser::SerializeMap> ser::SerializeMap for Wrap<S> {
|
||||
type Ok = S::Ok;
|
||||
type Error = S::Error;
|
||||
fn serialize_key<T: ?Sized + Serialize>(&mut self, k: &T) -> Result<(), S::Error> {
|
||||
self.0.serialize_key(&Finite(k))
|
||||
}
|
||||
fn serialize_value<T: ?Sized + Serialize>(&mut self, v: &T) -> Result<(), S::Error> {
|
||||
self.0.serialize_value(&Finite(v))
|
||||
}
|
||||
fn end(self) -> Result<S::Ok, S::Error> {
|
||||
self.0.end()
|
||||
}
|
||||
}
|
||||
|
||||
macro_rules! fields {
|
||||
($tr:ident) => {
|
||||
impl<S: ser::$tr> ser::$tr for Wrap<S> {
|
||||
type Ok = S::Ok;
|
||||
type Error = S::Error;
|
||||
fn serialize_field<T: ?Sized + Serialize>(&mut self, key: &'static str, v: &T) -> Result<(), S::Error> {
|
||||
self.0.serialize_field(key, &Finite(v))
|
||||
}
|
||||
fn skip_field(&mut self, key: &'static str) -> Result<(), S::Error> {
|
||||
self.0.skip_field(key)
|
||||
}
|
||||
fn end(self) -> Result<S::Ok, S::Error> {
|
||||
self.0.end()
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
fields!(SerializeStruct);
|
||||
fields!(SerializeStructVariant);
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn non_finite_floats_are_written_as_zero_and_nothing_else_changes() {
|
||||
#[derive(serde::Serialize)]
|
||||
struct T {
|
||||
a: f64,
|
||||
b: Option<f64>,
|
||||
c: Vec<(f32, f64)>,
|
||||
d: Option<String>,
|
||||
e: std::collections::BTreeMap<String, f64>,
|
||||
}
|
||||
let t = T { a: f64::NAN, b: Some(f64::INFINITY), c: vec![(f32::NEG_INFINITY, 1.5)], d: None, e: [("k".to_string(), f64::NAN)].into() };
|
||||
let s = serde_json::to_string(&Finite(&t)).unwrap_or_default();
|
||||
assert_eq!(s, r#"{"a":0.0,"b":0.0,"c":[[0.0,1.5]],"d":null,"e":{"k":0.0}}"#);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,118 @@
|
||||
//! Byte-for-byte checks on the `.deckcraft` package. The files in `tests/golden` were written by
|
||||
//! the format code as it was before the package layer moved to `craft-deckcraft-format`
|
||||
//! (storytold/craft-libs). A save of the same deck must give the same bytes, and a load must give
|
||||
//! the same presentation and the same damage report.
|
||||
//! `DECKCRAFT_BLESS_GOLDEN=1` rewrites them. Only do that for a deliberate format change.
|
||||
|
||||
use std::path::PathBuf;
|
||||
use std::sync::Arc;
|
||||
|
||||
use deckcraft_model::chart::{Chart, ChartPart, ChartType};
|
||||
use deckcraft_model::text::TextBody;
|
||||
use deckcraft_model::{MediaId, MediaItem, Presentation, Shape, ShapeId, ShapeKind, Xfrm, defaults};
|
||||
|
||||
use super::{load_checked, save_as};
|
||||
|
||||
/// A fixed generator, so the golden bytes don't change with the app's version.
|
||||
const GENERATOR: &str = "DeckCraft golden";
|
||||
|
||||
fn golden(name: &str) -> PathBuf {
|
||||
PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests").join("golden").join(name)
|
||||
}
|
||||
|
||||
fn media(id: u32, name: &str, content_type: &str, data: &[u8], link: Option<&str>) -> MediaItem {
|
||||
MediaItem { id: MediaId(id), name: name.into(), content_type: content_type.into(), data: Arc::new(data.to_vec()), link: link.map(Into::into) }
|
||||
}
|
||||
|
||||
/// A deck that reaches every kind of package member: stored and deflated media, linked media
|
||||
/// without bytes (not written), stored and deflated chart parts, and a non-finite number.
|
||||
fn deck() -> Presentation {
|
||||
let mut p = defaults::new_presentation(None);
|
||||
let slide = Arc::make_mut(&mut p.slides[0]);
|
||||
if let Some(title) = slide.shapes.first_mut() {
|
||||
title.text = Some(TextBody::from_text("Golden «deck» ✓"));
|
||||
}
|
||||
let mut chart = Chart::sample(ChartType::Bar);
|
||||
for (i, (content_type, bytes)) in
|
||||
[("application/zip", vec![80, 75, 3, 4, 1, 2, 3]), ("application/vnd.ms-office.chartstyle+xml", b"<cs:chartStyle id=\"201\"/>".repeat(8))]
|
||||
.into_iter()
|
||||
.enumerate()
|
||||
{
|
||||
chart.kept.parts.push(ChartPart { name: format!("ppt/charts/part{i}"), content_type: content_type.into(), bytes, native_entry: None });
|
||||
}
|
||||
let chart_id = ShapeId(p.alloc_id().unwrap_or(9000));
|
||||
let odd_id = ShapeId(p.alloc_id().unwrap_or(9001));
|
||||
let slide = Arc::make_mut(&mut p.slides[0]);
|
||||
slide.shapes.push(Shape {
|
||||
id: chart_id,
|
||||
xfrm: Some(Xfrm::new(10.0, 20.0, 300.0, 200.0)),
|
||||
kind: ShapeKind::Chart(Box::new(chart)),
|
||||
..Default::default()
|
||||
});
|
||||
// Written as 0 by the NaN-safe writer, then clamped on load.
|
||||
slide.shapes.push(Shape { id: odd_id, xfrm: Some(Xfrm::new(f64::NAN, 5.0, f64::INFINITY, 7.5)), ..Default::default() });
|
||||
p.media = vec![
|
||||
media(1, "image1.png", "image/png", &[0x89, b'P', b'N', b'G', 13, 10, 26, 10, 0, 0, 0, 0], None),
|
||||
media(
|
||||
2,
|
||||
"drawing.svg",
|
||||
"image/svg+xml",
|
||||
&b"<svg xmlns=\"http://www.w3.org/2000/svg\"><rect width=\"4\" height=\"4\"/></svg>".repeat(4),
|
||||
None,
|
||||
),
|
||||
media(3, "clip.mp4", "video/mp4", &[0, 0, 0, 24, b'f', b't', b'y', b'p'], Some("https://example.invalid/clip.mp4")),
|
||||
media(4, "linked.png", "image/png", &[], Some("file:///nowhere/linked.png")),
|
||||
];
|
||||
p
|
||||
}
|
||||
|
||||
/// The loaded deck and its damage report, as JSON. Media bytes are not in the model's JSON, so
|
||||
/// each item's bytes follow it in hex. `with_model: false` leaves the presentation out.
|
||||
fn loaded_json(bytes: &[u8], with_model: bool) -> String {
|
||||
let (p, damaged) = load_checked(bytes).unwrap_or_else(|e| panic!("load: {e}"));
|
||||
let hex = |b: &[u8]| b.iter().map(|x| format!("{x:02x}")).collect::<String>();
|
||||
let media: Vec<(u32, String)> = p.media.iter().map(|m| (m.id.0, hex(&m.data))).collect();
|
||||
let mut value = serde_json::json!({ "damaged": damaged, "media": media });
|
||||
if with_model {
|
||||
value["presentation"] = serde_json::to_value(&p).unwrap_or_default();
|
||||
}
|
||||
serde_json::to_string(&value).unwrap_or_default() + "\n"
|
||||
}
|
||||
|
||||
fn check(name: &str, actual: &[u8]) {
|
||||
let path = golden(name);
|
||||
if std::env::var_os("DECKCRAFT_BLESS_GOLDEN").is_some() {
|
||||
std::fs::write(&path, actual).unwrap_or_else(|e| panic!("{}: {e}", path.display()));
|
||||
return;
|
||||
}
|
||||
let expected = std::fs::read(&path).unwrap_or_else(|e| panic!("{}: {e}", path.display()));
|
||||
assert!(expected == actual, "{name} changed ({} bytes, golden has {})", actual.len(), expected.len());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_save_writes_the_golden_package_bytes() {
|
||||
let bytes = save_as(&deck(), GENERATOR).unwrap_or_else(|e| panic!("save: {e}"));
|
||||
check("deck.deckcraft", &bytes);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_load_of_the_golden_package_gives_the_golden_presentation() {
|
||||
let bytes = std::fs::read(golden("deck.deckcraft")).unwrap_or_else(|e| panic!("{e}"));
|
||||
check("deck.loaded.json", loaded_json(&bytes, true).as_bytes());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_load_of_a_damaged_package_gives_the_golden_report() {
|
||||
// The PNG member and the second chart part removed: both are reported, nothing is refused.
|
||||
let bytes = std::fs::read(golden("deck.deckcraft")).unwrap_or_else(|e| panic!("{e}"));
|
||||
let mut z = zip::ZipArchive::new(std::io::Cursor::new(bytes.as_slice())).unwrap_or_else(|e| panic!("{e}"));
|
||||
let mut out = zip::ZipWriter::new(std::io::Cursor::new(Vec::new()));
|
||||
for i in 0..z.len() {
|
||||
let Ok(f) = z.by_index_raw(i) else { continue };
|
||||
if f.name() != "media/1" && f.name() != "chart-parts/1" {
|
||||
out.raw_copy_file(f).unwrap_or_else(|e| panic!("{e}"));
|
||||
}
|
||||
}
|
||||
let damaged = out.finish().unwrap_or_else(|e| panic!("{e}")).into_inner();
|
||||
check("damaged.loaded.json", loaded_json(&damaged, false).as_bytes());
|
||||
}
|
||||
+35
-232
@@ -5,158 +5,63 @@
|
||||
#![forbid(unsafe_code)]
|
||||
|
||||
mod chart_parts;
|
||||
mod finite;
|
||||
pub mod rtf;
|
||||
|
||||
#[cfg(test)]
|
||||
mod chart_parts_tests;
|
||||
#[cfg(test)]
|
||||
mod golden_tests;
|
||||
|
||||
use std::io::{Cursor, Read, Write};
|
||||
use std::sync::Arc;
|
||||
|
||||
use deckcraft_model::text::{Paragraph, TextBody};
|
||||
use deckcraft_model::{LayoutType, Presentation, ShapeKind, defaults};
|
||||
|
||||
pub const MIMETYPE: &str = "application/vnd.storyteller.deckcraft+zip";
|
||||
/// Files written before the SlideCraft → DeckCraft rename (`.slidecraft`) are still read.
|
||||
pub const LEGACY_MIMETYPE: &str = concat!("application/vnd.storyteller.", "slide", "craft+zip");
|
||||
pub const EXTENSION: &str = "deckcraft";
|
||||
/// Format version written into the manifest.
|
||||
pub const VERSION: u32 = 1;
|
||||
/// Largest entry we will inflate (guards against zip bombs).
|
||||
const MAX_ENTRY: u64 = 2 << 30;
|
||||
/// All embedded media and chart sidecars together, inflated (#393).
|
||||
const MAX_TOTAL_MEDIA: u64 = 4 << 30;
|
||||
/// Media items and chart sidecar parts one file may list.
|
||||
const MAX_MEDIA_ITEMS: usize = 100_000;
|
||||
/// Largest `presentation.json` we will inflate. The manifest holds no media bytes, so it is far
|
||||
/// smaller than a media entry may be; inflating and parsing one is what dominates memory.
|
||||
const MAX_MANIFEST: u64 = 256 << 20;
|
||||
|
||||
/// What one load may inflate.
|
||||
#[derive(Clone, Copy)]
|
||||
struct Budget {
|
||||
total: u64,
|
||||
items: usize,
|
||||
manifest: u64,
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
impl Budget {
|
||||
/// A media budget with the default manifest limit.
|
||||
fn media(total: u64, items: usize) -> Self {
|
||||
Budget { total, items, manifest: MAX_MANIFEST }
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, thiserror::Error)]
|
||||
pub enum FormatError {
|
||||
#[error("not a DeckCraft file: {0}")]
|
||||
NotOurs(String),
|
||||
#[error("damaged file: {0}")]
|
||||
Damaged(String),
|
||||
#[error("write failed: {0}")]
|
||||
Write(String),
|
||||
}
|
||||
|
||||
pub type Result<T> = std::result::Result<T, FormatError>;
|
||||
|
||||
#[derive(serde::Serialize, serde::Deserialize)]
|
||||
struct Manifest {
|
||||
format: String,
|
||||
version: u32,
|
||||
generator: String,
|
||||
presentation: Presentation,
|
||||
}
|
||||
// The package itself (identity, manifest, member names, bounded reads) is shared.
|
||||
pub use craft_deckcraft_format::{Budget, EXTENSION, FormatError, LEGACY_MIMETYPE, MIMETYPE, Result, VERSION, sniff};
|
||||
use craft_deckcraft_format::{Member, Package, media_entry};
|
||||
|
||||
/// Serialize a presentation.
|
||||
pub fn save(p: &Presentation) -> Result<Vec<u8>> {
|
||||
let mut buf = Cursor::new(Vec::new());
|
||||
{
|
||||
let mut z = zip::ZipWriter::new(&mut buf);
|
||||
let stored = zip::write::SimpleFileOptions::default().compression_method(zip::CompressionMethod::Stored);
|
||||
let deflate = zip::write::SimpleFileOptions::default().compression_method(zip::CompressionMethod::Deflated);
|
||||
let w = |e: zip::result::ZipError| FormatError::Write(e.to_string());
|
||||
z.start_file("mimetype", stored).map_err(w)?;
|
||||
z.write_all(MIMETYPE.as_bytes()).map_err(|e| FormatError::Write(e.to_string()))?;
|
||||
let mut presentation = p.clone();
|
||||
let parts = chart_parts::separate(&mut presentation)?;
|
||||
let m =
|
||||
Manifest { format: "deckcraft".into(), version: VERSION, generator: format!("DeckCraft {}", env!("CARGO_PKG_VERSION")), presentation };
|
||||
let json = serde_json::to_vec(&finite::Finite(&m)).map_err(|e| FormatError::Write(e.to_string()))?;
|
||||
z.start_file("presentation.json", deflate).map_err(w)?;
|
||||
z.write_all(&json).map_err(|e| FormatError::Write(e.to_string()))?;
|
||||
for item in &p.media {
|
||||
if item.link.is_some() && item.data.is_empty() {
|
||||
continue;
|
||||
}
|
||||
// Already-compressed media is stored, not deflated again.
|
||||
let opts = if is_compressed(&item.content_type) { stored } else { deflate };
|
||||
z.start_file(format!("media/{}", item.id.0), opts).map_err(w)?;
|
||||
z.write_all(&item.data).map_err(|e| FormatError::Write(e.to_string()))?;
|
||||
}
|
||||
for (name, content_type, bytes) in parts {
|
||||
let opts = if is_compressed(&content_type) { stored } else { deflate };
|
||||
z.start_file(name, opts).map_err(w)?;
|
||||
z.write_all(&bytes).map_err(|e| FormatError::Write(e.to_string()))?;
|
||||
}
|
||||
z.finish().map_err(w)?;
|
||||
}
|
||||
Ok(buf.into_inner())
|
||||
save_as(p, &format!("DeckCraft {}", env!("CARGO_PKG_VERSION")))
|
||||
}
|
||||
|
||||
fn is_compressed(ct: &str) -> bool {
|
||||
ct.starts_with("image/jpeg")
|
||||
|| ct.starts_with("image/png")
|
||||
|| ct.starts_with("video/")
|
||||
|| ct.starts_with("audio/mpeg")
|
||||
|| ct.starts_with("audio/mp4")
|
||||
|| ct.contains("zip")
|
||||
}
|
||||
|
||||
/// Does this look like a `.deckcraft` file?
|
||||
pub fn sniff(bytes: &[u8]) -> bool {
|
||||
bytes.starts_with(b"PK") && [MIMETYPE, LEGACY_MIMETYPE].iter().any(|m| bytes.windows(m.len()).take(200).any(|w| w == m.as_bytes()))
|
||||
/// [`save`] naming `generator` in the manifest.
|
||||
fn save_as(p: &Presentation, generator: &str) -> Result<Vec<u8>> {
|
||||
let mut presentation = p.clone();
|
||||
let parts = chart_parts::separate(&mut presentation)?;
|
||||
// Linked media saved without its bytes has no member.
|
||||
let media: Vec<(String, &deckcraft_model::MediaItem)> =
|
||||
p.media.iter().filter(|item| !(item.link.is_some() && item.data.is_empty())).map(|item| (media_entry(item.id.0), item)).collect();
|
||||
let members: Vec<Member<'_>> = media
|
||||
.iter()
|
||||
.map(|(name, item)| Member { name, content_type: &item.content_type, bytes: &item.data })
|
||||
.chain(parts.iter().map(|(name, content_type, bytes)| Member { name, content_type, bytes }))
|
||||
.collect();
|
||||
craft_deckcraft_format::write(&presentation, generator, &members)
|
||||
}
|
||||
|
||||
/// A member of a package a test built or rewrote with `zip`, within `max` bytes.
|
||||
#[cfg(test)]
|
||||
fn read_entry(z: &mut zip::ZipArchive<Cursor<&[u8]>>, name: &str) -> Result<Vec<u8>> {
|
||||
read_entry_max(z, name, MAX_ENTRY)
|
||||
}
|
||||
|
||||
/// Read one member, refusing it before inflating if it declares more than `max` bytes, and
|
||||
/// stopping at `max` if it inflates further than it declared.
|
||||
fn read_entry_max(z: &mut zip::ZipArchive<Cursor<&[u8]>>, name: &str, max: u64) -> Result<Vec<u8>> {
|
||||
read_entry_counted(z, name, max, &mut 0)
|
||||
}
|
||||
|
||||
/// [`read_entry_max`] within `left` (and [`MAX_ENTRY`]), charging `left` for every byte inflated,
|
||||
/// including those inflated before a decode or CRC error, so a member that fails late still
|
||||
/// spends the shared budget it used.
|
||||
fn read_entry_charged(z: &mut zip::ZipArchive<Cursor<&[u8]>>, name: &str, left: &mut u64) -> Result<Vec<u8>> {
|
||||
let mut spent = 0;
|
||||
let out = read_entry_counted(z, name, (*left).min(MAX_ENTRY), &mut spent);
|
||||
*left = left.saturating_sub(spent);
|
||||
out
|
||||
}
|
||||
|
||||
/// [`read_entry_max`], adding the bytes inflated to `spent` whether or not the read succeeds.
|
||||
fn read_entry_counted(z: &mut zip::ZipArchive<Cursor<&[u8]>>, name: &str, max: u64, spent: &mut u64) -> Result<Vec<u8>> {
|
||||
fn read_entry_max(z: &mut zip::ZipArchive<std::io::Cursor<&[u8]>>, name: &str, max: u64) -> Result<Vec<u8>> {
|
||||
use std::io::Read;
|
||||
let f = z.by_name(name).map_err(|e| FormatError::Damaged(format!("{name}: {e}")))?;
|
||||
if f.size() > max {
|
||||
return Err(FormatError::Damaged(format!("{name} is too large")));
|
||||
}
|
||||
let mut out = Vec::with_capacity(f.size().min(64 << 20) as usize);
|
||||
let mut f = f.take(max.saturating_add(1));
|
||||
let read = f.read_to_end(&mut out);
|
||||
*spent = spent.saturating_add(out.len() as u64);
|
||||
read.map_err(|e| FormatError::Damaged(format!("{name}: {e}")))?;
|
||||
let mut out = vec![];
|
||||
f.take(max.saturating_add(1)).read_to_end(&mut out).map_err(|e| FormatError::Damaged(format!("{name}: {e}")))?;
|
||||
if out.len() as u64 > max {
|
||||
return Err(FormatError::Damaged(format!("{name} is too large")));
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
fn read_entry(z: &mut zip::ZipArchive<std::io::Cursor<&[u8]>>, name: &str) -> Result<Vec<u8>> {
|
||||
read_entry_max(z, name, craft_deckcraft_format::MAX_ENTRY)
|
||||
}
|
||||
|
||||
/// Read a presentation. Missing media/chart parts are left empty; use [`load_checked`] to
|
||||
/// learn which. A damaged chart member refuses the file before further chart inflation.
|
||||
pub fn load(bytes: &[u8]) -> Result<Presentation> {
|
||||
@@ -167,19 +72,11 @@ pub fn load(bytes: &[u8]) -> Result<Presentation> {
|
||||
/// A chart member that is present but fails decoding, CRC or its entry limit refuses the file.
|
||||
/// Linked media saved without its bytes isn't damage.
|
||||
pub fn load_checked(bytes: &[u8]) -> Result<(Presentation, Vec<String>)> {
|
||||
load_within(bytes, Budget { total: MAX_TOTAL_MEDIA, items: MAX_MEDIA_ITEMS, manifest: MAX_MANIFEST })
|
||||
load_within(bytes, Budget::default())
|
||||
}
|
||||
|
||||
fn load_within(bytes: &[u8], budget: Budget) -> Result<(Presentation, Vec<String>)> {
|
||||
let mut z = zip::ZipArchive::new(Cursor::new(bytes)).map_err(|e| FormatError::NotOurs(e.to_string()))?;
|
||||
if z.index_for_name("presentation.json").is_none() {
|
||||
return Err(FormatError::NotOurs("no presentation.json".into()));
|
||||
}
|
||||
let json = read_entry_max(&mut z, "presentation.json", budget.manifest)?;
|
||||
let m = parse_manifest(&json)?;
|
||||
if m.format != "deckcraft" {
|
||||
return Err(FormatError::NotOurs(m.format));
|
||||
}
|
||||
let (m, mut z) = Package::open_manifest::<Presentation>(bytes, budget.manifest)?;
|
||||
let mut p = m.presentation;
|
||||
let mut damaged = vec![];
|
||||
let items = p.media.len();
|
||||
@@ -192,13 +89,13 @@ fn load_within(bytes: &[u8], budget: Budget) -> Result<(Presentation, Vec<String
|
||||
p.media.retain(|m| seen.insert(m.id));
|
||||
let mut left = budget.total;
|
||||
for item in &mut p.media {
|
||||
let name = format!("media/{}", item.id.0);
|
||||
let linked_only = item.link.is_some() && z.index_for_name(&name).is_none();
|
||||
if z.by_name(&name).is_ok_and(|f| f.size() > left) {
|
||||
let name = media_entry(item.id.0);
|
||||
let linked_only = item.link.is_some() && !z.contains(&name);
|
||||
if z.declared_size(&name).is_some_and(|size| size > left) {
|
||||
return Err(FormatError::Damaged("embedded media is larger than DeckCraft can open".into()));
|
||||
}
|
||||
// A failed read is charged for what it inflated, so later members can't reuse that budget.
|
||||
match read_entry_charged(&mut z, &name, &mut left) {
|
||||
match z.read_charged(&name, &mut left) {
|
||||
Ok(data) => item.data = Arc::new(data),
|
||||
Err(_) if linked_only => {}
|
||||
Err(e) => damaged.push(e.to_string()),
|
||||
@@ -346,100 +243,6 @@ fn add_outline_slides(p: &mut Presentation, slides: OutlineSlides) -> usize {
|
||||
made
|
||||
}
|
||||
|
||||
/// Most `null`s standing in for numbers that [`parse_manifest`] patches in one file, and the
|
||||
/// candidates it tries for each.
|
||||
const MAX_NULL_FIXES: usize = 256;
|
||||
const MAX_TRIES_PER_FIX: usize = 32;
|
||||
/// Bytes [`parse_manifest`] may re-parse in all while patching, so a hostile file full of `null`s
|
||||
/// can't keep it busy: past this the file is reported damaged.
|
||||
const MAX_REPARSE_BYTES: usize = 256 * 1024 * 1024;
|
||||
|
||||
/// Where a parse failed, comparable: later is progress.
|
||||
fn failure(src: &[u8]) -> std::result::Result<Manifest, (String, (usize, usize))> {
|
||||
serde_json::from_slice::<Manifest>(src).map_err(|e| (e.to_string(), (e.line(), e.column())))
|
||||
}
|
||||
|
||||
/// Parse `presentation.json`. serde_json writes a NaN or infinite number as `null`, which then
|
||||
/// fails to read back as a number ("invalid type: null, expected f64"), so DeckCraft could save
|
||||
/// a file it couldn't open. Each such `null` is read as 0 instead ([`repair`] then brings the
|
||||
/// value into range); anything else that doesn't parse is damage.
|
||||
///
|
||||
/// serde reports the failing `null` exactly, except inside tagged enums (buffered), where it
|
||||
/// reports the end of the enclosing object: there the `null`s before that point are tried
|
||||
/// nearest first, and a patch is kept only if the parse then gets further. (Files saved since
|
||||
/// [`finite::Finite`] never contain such `null`s; this reads older ones.)
|
||||
fn parse_manifest(json: &[u8]) -> Result<Manifest> {
|
||||
// Parse the inflated text as it is: only a file that fails on a `null` number is copied for
|
||||
// patching (the copy is bounded by `MAX_MANIFEST`).
|
||||
let mut last = match failure(json) {
|
||||
Ok(m) => return Ok(m),
|
||||
Err(f) => f,
|
||||
};
|
||||
if !is_null_number(&last.0) {
|
||||
return Err(FormatError::Damaged(last.0));
|
||||
}
|
||||
let mut src = json.to_vec();
|
||||
let mut budget = MAX_REPARSE_BYTES;
|
||||
'fixes: for _ in 0..MAX_NULL_FIXES {
|
||||
let (msg, pos) = &last;
|
||||
if !is_null_number(msg) {
|
||||
break;
|
||||
}
|
||||
let end = offset(&src, pos.0, pos.1).unwrap_or(src.len());
|
||||
let mut progressed = false;
|
||||
let candidates: Vec<usize> = value_nulls_before(&src, end + 4).take(MAX_TRIES_PER_FIX).collect();
|
||||
for at in candidates {
|
||||
let (Some(head), Some(tail)) = (src.get(..at), src.get(at.saturating_add(4)..)) else { continue };
|
||||
let Some(left) = budget.checked_sub(src.len()) else { break 'fixes };
|
||||
budget = left;
|
||||
let mut next = Vec::with_capacity(src.len());
|
||||
next.extend_from_slice(head);
|
||||
next.push(b'0');
|
||||
next.extend_from_slice(tail);
|
||||
match failure(&next) {
|
||||
Ok(m) => return Ok(m),
|
||||
// The patch shortened the text by 3 bytes before the error: compare positions
|
||||
// allowing for that.
|
||||
Err(f) if f.1 > (pos.0, pos.1.saturating_sub(3)) => {
|
||||
src = next;
|
||||
last = f;
|
||||
progressed = true;
|
||||
break;
|
||||
}
|
||||
Err(_) => {}
|
||||
}
|
||||
}
|
||||
if !progressed {
|
||||
break;
|
||||
}
|
||||
}
|
||||
Err(FormatError::Damaged(last.0))
|
||||
}
|
||||
|
||||
/// Is this parse error a `null` where a number belongs (a NaN or infinity serde_json wrote)?
|
||||
fn is_null_number(msg: &str) -> bool {
|
||||
msg.starts_with("invalid type: null, expected f") || msg.starts_with("invalid type: null, expected a number")
|
||||
}
|
||||
|
||||
/// Byte offset of a 1-based `line`:`column`.
|
||||
fn offset(src: &[u8], line: usize, column: usize) -> Option<usize> {
|
||||
let mut start = 0;
|
||||
for _ in 1..line {
|
||||
start += src.get(start..)?.iter().position(|b| *b == b'\n')? + 1;
|
||||
}
|
||||
Some((start + column).min(src.len()))
|
||||
}
|
||||
|
||||
/// Starts of `null` tokens in value position (after `:`, `[` or `,`) before `end`, nearest first.
|
||||
fn value_nulls_before(src: &[u8], end: usize) -> impl Iterator<Item = usize> + '_ {
|
||||
let end = end.min(src.len());
|
||||
(0..end.saturating_sub(3)).rev().filter(move |&i| {
|
||||
src.get(i..i + 4) == Some(b"null")
|
||||
&& src[..i].iter().rev().find(|b| !b.is_ascii_whitespace()).is_some_and(|b| matches!(b, b':' | b'[' | b','))
|
||||
&& src.get(i + 4).is_none_or(|b| !b.is_ascii_alphanumeric())
|
||||
})
|
||||
}
|
||||
|
||||
/// Largest coordinate or size kept, in points (about 350 m; PowerPoint's own limit is far smaller).
|
||||
const MAX_COORD: f64 = 1.0e6;
|
||||
|
||||
|
||||
+102
-29
@@ -10,24 +10,24 @@ use deckcraft_model::text::{Paragraph, RunKind};
|
||||
|
||||
/// RTF-escape `s` (non-ASCII as `\uN?`, UTF-16, signed as RTF wants).
|
||||
fn escape(out: &mut String, s: &str) {
|
||||
for c in s.chars() {
|
||||
match c {
|
||||
'\\' | '{' | '}' => {
|
||||
out.push('\\');
|
||||
out.push(c);
|
||||
}
|
||||
'\t' => out.push_str("\\tab "),
|
||||
'\u{b}' | '\n' => out.push_str("\\line "),
|
||||
c if c.is_ascii() && !c.is_ascii_control() => out.push(c),
|
||||
c if c.is_ascii() => {}
|
||||
c => {
|
||||
let mut buf = [0u16; 2];
|
||||
for u in c.encode_utf16(&mut buf) {
|
||||
out.push_str(&format!("\\u{}?", *u as i16));
|
||||
}
|
||||
}
|
||||
}
|
||||
// Keep outline text literal: the shared writer also supports page/column breaks and
|
||||
// shorthand controls that this app's deliberately small outline reader does not consume.
|
||||
// Delegate ordinary spans, including UTF-16 escaping, without allocating a second string.
|
||||
let mut start = 0;
|
||||
for (i, c) in s.char_indices() {
|
||||
let replacement = match c {
|
||||
'\u{000C}' | '\u{000E}' => "",
|
||||
'\u{00A0}' => "\\u160?",
|
||||
'\u{00AD}' => "\\u173?",
|
||||
'\u{2011}' => "\\u8209?",
|
||||
'\u{2028}' => "\\u8232?",
|
||||
_ => continue,
|
||||
};
|
||||
craft_rtf::push_esc(out, &s[start..i]);
|
||||
out.push_str(replacement);
|
||||
start = i + c.len_utf8();
|
||||
}
|
||||
craft_rtf::push_esc(out, &s[start..]);
|
||||
}
|
||||
|
||||
fn runs(out: &mut String, p: &Paragraph) {
|
||||
@@ -276,6 +276,9 @@ impl Outline<'_> {
|
||||
while k > 0 && self.i < self.b.len() {
|
||||
if self.b[self.i] == b'\\' && self.b.get(self.i + 1) == Some(&b'\'') {
|
||||
self.i = advance(self.rtf, self.i, 4);
|
||||
} else if self.b[self.i] == b'\\' && self.b.get(self.i + 1).is_some_and(|b| !b.is_ascii_alphabetic()) {
|
||||
// An escaped control symbol counts as one Unicode fallback character.
|
||||
self.i = advance(self.rtf, self.i + 1, 1);
|
||||
} else if matches!(self.b[self.i], b'{' | b'}' | b'\\') {
|
||||
break;
|
||||
} else {
|
||||
@@ -294,7 +297,7 @@ impl Outline<'_> {
|
||||
&& let Some(h) = hex
|
||||
&& h != 0
|
||||
{
|
||||
self.line.push(cp1252(h));
|
||||
self.line.push(craft_rtf::codepage::cp1252(h));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -381,22 +384,75 @@ fn finish_surrogates(s: String) -> String {
|
||||
out
|
||||
}
|
||||
|
||||
fn cp1252(b: u8) -> char {
|
||||
const HIGH: [char; 32] = [
|
||||
'€', '\u{81}', '‚', 'ƒ', '„', '…', '†', '‡', 'ˆ', '‰', 'Š', '‹', 'Œ', '\u{8d}', 'Ž', '\u{8f}', '\u{90}', '‘', '’', '“', '”', '•', '–', '—',
|
||||
'˜', '™', 'š', '›', 'œ', '\u{9d}', 'ž', 'Ÿ',
|
||||
];
|
||||
match b {
|
||||
0x80..=0x9f => HIGH[(b - 0x80) as usize],
|
||||
_ => b as char,
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
#![allow(clippy::unwrap_used)]
|
||||
use super::*;
|
||||
|
||||
// Frozen pre-cutover implementations are test oracles, not production parsers.
|
||||
fn legacy_escape(out: &mut String, s: &str) {
|
||||
for c in s.chars() {
|
||||
match c {
|
||||
'\\' | '{' | '}' => {
|
||||
out.push('\\');
|
||||
out.push(c);
|
||||
}
|
||||
'\t' => out.push_str("\\tab "),
|
||||
'\u{b}' | '\n' => out.push_str("\\line "),
|
||||
c if c.is_ascii() && !c.is_ascii_control() => out.push(c),
|
||||
c if c.is_ascii() => {}
|
||||
c => {
|
||||
let mut buf = [0u16; 2];
|
||||
for u in c.encode_utf16(&mut buf) {
|
||||
out.push_str(&format!("\\u{}?", *u as i16));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn legacy_cp1252(b: u8) -> char {
|
||||
const HIGH: [char; 32] = [
|
||||
'€', '\u{81}', '‚', 'ƒ', '„', '…', '†', '‡', 'ˆ', '‰', 'Š', '‹', 'Œ', '\u{8d}', 'Ž', '\u{8f}', '\u{90}', '‘', '’', '“', '”', '•', '–',
|
||||
'—', '˜', '™', 'š', '›', 'œ', '\u{9d}', 'ž', 'Ÿ',
|
||||
];
|
||||
match b {
|
||||
0x80..=0x9f => HIGH[(b - 0x80) as usize],
|
||||
_ => b as char,
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn shared_escape_preserves_every_unicode_scalar() {
|
||||
for value in 0..=0x10ffff {
|
||||
let Some(c) = char::from_u32(value) else { continue };
|
||||
let mut buf = [0; 4];
|
||||
let text = c.encode_utf8(&mut buf);
|
||||
let mut expected = String::new();
|
||||
let mut actual = String::new();
|
||||
legacy_escape(&mut expected, text);
|
||||
escape(&mut actual, text);
|
||||
assert_eq!(actual, expected, "U+{value:04X}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn shared_escape_preserves_mixed_spans_and_append() {
|
||||
let text = "a\t中\u{a0}b\u{ad}c\u{2011}d\u{2028}e\u{c}f\u{e}g\n😀{}\\";
|
||||
let mut expected = String::from("prefix:");
|
||||
let mut actual = expected.clone();
|
||||
legacy_escape(&mut expected, text);
|
||||
escape(&mut actual, text);
|
||||
assert_eq!(actual, expected);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn shared_cp1252_preserves_all_bytes() {
|
||||
for b in 0..=u8::MAX {
|
||||
assert_eq!(craft_rtf::codepage::cp1252(b), legacy_cp1252(b));
|
||||
}
|
||||
}
|
||||
|
||||
/// A sign in a `\'hh` escape is not a hex digit and must be ignored.
|
||||
#[test]
|
||||
fn hex_escape_rejects_sign() {
|
||||
@@ -422,6 +478,23 @@ mod tests {
|
||||
assert_eq!(rtf_to_outline(r"{\rtf1 x\u-70000?y\par}"), "x\u{ee90}y\n");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unicode_fallback_control_symbols_are_skipped() {
|
||||
for (rtf, expected) in [
|
||||
(r"{\rtf1\uc1 \u92\\X\par}", "\\X\n"),
|
||||
(r"{\rtf1\uc1 \u123\{X\par}", "{X\n"),
|
||||
(r"{\rtf1\uc1 \u125\}X\par}", "}X\n"),
|
||||
(r"{\rtf1\uc2 \u233\{\}X\par}", "éX\n"),
|
||||
(r"{\rtf1\uc0 \u92\\X\par}", "\\\\X\n"),
|
||||
(r"{\rtf1 \\ \{ \}X\par}", "\\ { }X\n"),
|
||||
(r"{\rtf1\uc1 \u233{X}\par}", "éX\n"),
|
||||
(r"{\rtf1\uc1 \u233\éX\par}", "éX\n"),
|
||||
(r"{\rtf1\uc1 \u233\", "é\n"),
|
||||
] {
|
||||
assert_eq!(rtf_to_outline(rtf), expected, "{rtf:?}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn multibyte_control_symbol_keeps_character_and_following_text() {
|
||||
assert_eq!(rtf_to_outline("{\\rtf1 A\\éB\\par}"), "AéB\n");
|
||||
|
||||
@@ -1,4 +1,6 @@
|
||||
use super::*;
|
||||
use craft_deckcraft_format::{Manifest, parse_manifest};
|
||||
use std::io::{Cursor, Read, Write};
|
||||
|
||||
#[test]
|
||||
fn chart_sidecars_are_optional_for_older_native_files() {
|
||||
@@ -364,7 +366,7 @@ fn reflection_transform_survives_two_native_saves_and_absent_fields_stay_absent(
|
||||
assert_eq!(reopened.slides[0].shapes.last().and_then(|s| s.effects.as_ref()).and_then(|e| e.reflection.as_ref()), Some(&absent));
|
||||
}
|
||||
|
||||
/// Files written before [`finite::Finite`] (plain serde_json: NaN as `null`) open too,
|
||||
/// Files written before [`craft_deckcraft_format::Finite`] (plain serde_json: NaN as `null`) open too,
|
||||
/// including a `null` inside a tagged enum, where serde reports only the enclosing object.
|
||||
#[test]
|
||||
fn older_files_with_null_numbers_open() {
|
||||
@@ -387,7 +389,7 @@ fn older_files_with_null_numbers_open() {
|
||||
let m = Manifest { format: "deckcraft".into(), version: VERSION, generator: "old".into(), presentation: p };
|
||||
let json = serde_json::to_vec(&m).unwrap();
|
||||
assert!(json.windows(4).any(|w| w == b"null"));
|
||||
let back = parse_manifest(&json).unwrap_or_else(|e| panic!("case {case}: {e}"));
|
||||
let back = parse_manifest::<Presentation>(&json).unwrap_or_else(|e| panic!("case {case}: {e}"));
|
||||
assert_eq!(back.presentation.slides[0].shapes.len(), m.presentation.slides[0].shapes.len(), "case {case}");
|
||||
}
|
||||
}
|
||||
@@ -419,14 +421,14 @@ fn a_bare_normautofit_body_round_trips() {
|
||||
#[test]
|
||||
fn other_damage_is_still_reported() {
|
||||
let ok = serde_json::to_vec(&serde_json::json!({"format": "deckcraft", "version": 1, "generator": "t", "presentation": {}})).unwrap();
|
||||
assert!(parse_manifest(&ok).is_ok());
|
||||
assert!(parse_manifest::<Presentation>(&ok).is_ok());
|
||||
let bad = br#"{"format": null, "version": 1, "generator": "t", "presentation": {}}"#;
|
||||
assert!(parse_manifest(bad).is_err());
|
||||
assert!(parse_manifest::<Presentation>(bad).is_err());
|
||||
let truncated = &ok[..ok.len() - 3];
|
||||
assert!(parse_manifest(truncated).is_err());
|
||||
assert!(parse_manifest::<Presentation>(truncated).is_err());
|
||||
// A null number on a later line (pretty-printed by another tool) is found too.
|
||||
let pretty = b"{\n \"format\": \"deckcraft\",\n \"version\": 1,\n \"generator\": \"t\",\n \"presentation\": {\"slides\": [{\"shapes\": [{\"xfrm\": {\"x\": null, \"y\": 1, \"w\": 2, \"h\": 3}}]}]}\n}";
|
||||
let m = parse_manifest(pretty).unwrap_or_else(|e| panic!("{e}"));
|
||||
let m = parse_manifest::<Presentation>(pretty).unwrap_or_else(|e| panic!("{e}"));
|
||||
assert_eq!(m.presentation.slides[0].shapes[0].xfrm.unwrap().x, 0.0);
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,2 @@
|
||||
# Golden files are compared byte for byte: no line-ending conversion on checkout.
|
||||
* -text
|
||||
@@ -0,0 +1 @@
|
||||
{"damaged":["damaged file: media/1: specified file not found in archive","chart-parts/1: missing chart part"],"media":[[1,""],[2,"3c73766720786d6c6e733d22687474703a2f2f7777772e77332e6f72672f323030302f737667223e3c726563742077696474683d223422206865696768743d2234222f3e3c2f7376673e3c73766720786d6c6e733d22687474703a2f2f7777772e77332e6f72672f323030302f737667223e3c726563742077696474683d223422206865696768743d2234222f3e3c2f7376673e3c73766720786d6c6e733d22687474703a2f2f7777772e77332e6f72672f323030302f737667223e3c726563742077696474683d223422206865696768743d2234222f3e3c2f7376673e3c73766720786d6c6e733d22687474703a2f2f7777772e77332e6f72672f323030302f737667223e3c726563742077696474683d223422206865696768743d2234222f3e3c2f7376673e"],[3,"0000001866747970"],[4,""]]}
|
||||
Binary file not shown.
File diff suppressed because one or more lines are too long
@@ -9,5 +9,6 @@ description = "DeckCraft geometry: units (EMU/pt), transforms, preset shape gene
|
||||
workspace = true
|
||||
|
||||
[dependencies]
|
||||
craft-drawingml = { workspace = true }
|
||||
kurbo = { workspace = true }
|
||||
serde = { workspace = true }
|
||||
|
||||
+3
-95
@@ -7,39 +7,14 @@
|
||||
#![forbid(unsafe_code)]
|
||||
|
||||
pub mod morph;
|
||||
pub mod preset;
|
||||
pub mod squircle;
|
||||
pub mod warp;
|
||||
|
||||
pub use kurbo::{Affine, BezPath, PathEl, Point, Rect, Shape as KurboShape, Size, Vec2};
|
||||
// Placement, units and preset and warp geometry are DrawingML's, shared in craft-libs
|
||||
// (`craft_drawingml`, craft-libs#778 and #792).
|
||||
pub use craft_drawingml::{EMU_PER_CM, EMU_PER_IN, EMU_PER_PT, Xfrm, emu_to_pt, group_child_affine, preset, pt_to_emu, warp};
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
/// EMU per point.
|
||||
pub const EMU_PER_PT: f64 = 12_700.0;
|
||||
/// EMU per inch.
|
||||
pub const EMU_PER_IN: f64 = 914_400.0;
|
||||
/// EMU per centimetre.
|
||||
pub const EMU_PER_CM: f64 = 360_000.0;
|
||||
|
||||
pub fn emu_to_pt(emu: i64) -> f64 {
|
||||
emu as f64 / EMU_PER_PT
|
||||
}
|
||||
|
||||
/// Points to EMU, rounded. Non-finite input becomes 0; huge values saturate.
|
||||
pub fn pt_to_emu(pt: f64) -> i64 {
|
||||
if !pt.is_finite() {
|
||||
return 0;
|
||||
}
|
||||
let v = (pt * EMU_PER_PT).round();
|
||||
if v >= i64::MAX as f64 {
|
||||
i64::MAX
|
||||
} else if v <= i64::MIN as f64 {
|
||||
i64::MIN
|
||||
} else {
|
||||
v as i64
|
||||
}
|
||||
}
|
||||
|
||||
/// Display units for measurements (inches on US English systems, centimetres elsewhere).
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
@@ -101,73 +76,6 @@ fn split_number(t: &str) -> Option<(f64, &str)> {
|
||||
Some((n, t.get(end..).unwrap_or("")))
|
||||
}
|
||||
|
||||
/// A shape's placement on its slide (or in its group's child space): offset, extent, rotation
|
||||
/// (degrees clockwise) and flips. Rotation and flips are about the centre.
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq, Serialize, Deserialize)]
|
||||
#[serde(default, rename_all = "camelCase")]
|
||||
pub struct Xfrm {
|
||||
pub x: f64,
|
||||
pub y: f64,
|
||||
pub w: f64,
|
||||
pub h: f64,
|
||||
#[serde(skip_serializing_if = "is_zero")]
|
||||
pub rot: f64,
|
||||
#[serde(skip_serializing_if = "std::ops::Not::not")]
|
||||
pub flip_h: bool,
|
||||
#[serde(skip_serializing_if = "std::ops::Not::not")]
|
||||
pub flip_v: bool,
|
||||
}
|
||||
|
||||
fn is_zero(v: &f64) -> bool {
|
||||
*v == 0.0
|
||||
}
|
||||
|
||||
impl Xfrm {
|
||||
pub fn new(x: f64, y: f64, w: f64, h: f64) -> Self {
|
||||
Xfrm { x, y, w, h, ..Default::default() }
|
||||
}
|
||||
pub fn rect(&self) -> Rect {
|
||||
Rect::new(self.x, self.y, self.x + self.w, self.y + self.h)
|
||||
}
|
||||
pub fn center(&self) -> Point {
|
||||
Point::new(self.x + self.w / 2.0, self.y + self.h / 2.0)
|
||||
}
|
||||
/// Local shape space (0..w, 0..h) → parent space, applying flips and rotation about the centre.
|
||||
pub fn affine(&self) -> Affine {
|
||||
let c = Vec2::new(self.w / 2.0, self.h / 2.0);
|
||||
let sx = if self.flip_h { -1.0 } else { 1.0 };
|
||||
let sy = if self.flip_v { -1.0 } else { 1.0 };
|
||||
Affine::translate(Vec2::new(self.x, self.y) + c)
|
||||
* Affine::rotate(self.rot.to_radians())
|
||||
* Affine::scale_non_uniform(sx, sy)
|
||||
* Affine::translate(-c)
|
||||
}
|
||||
/// Axis-aligned bounds of the rotated box in parent space.
|
||||
pub fn bounds(&self) -> Rect {
|
||||
let a = self.affine();
|
||||
let pts = [Point::new(0.0, 0.0), Point::new(self.w, 0.0), Point::new(self.w, self.h), Point::new(0.0, self.h)].map(|p| a * p);
|
||||
let mut r = Rect::from_points(pts[0], pts[1]);
|
||||
r = r.union_pt(pts[2]).union_pt(pts[3]);
|
||||
r
|
||||
}
|
||||
/// True when no dimension is NaN/inf.
|
||||
pub fn is_finite(&self) -> bool {
|
||||
[self.x, self.y, self.w, self.h, self.rot].iter().all(|v| v.is_finite())
|
||||
}
|
||||
/// Rotation normalised to 0..360.
|
||||
pub fn rot_norm(&self) -> f64 {
|
||||
let r = self.rot.rem_euclid(360.0);
|
||||
if r >= 360.0 { 0.0 } else { r }
|
||||
}
|
||||
}
|
||||
|
||||
/// Maps a group's child coordinate space (`ch_off`, `ch_ext`) onto the group's own box.
|
||||
pub fn group_child_affine(group: &Xfrm, ch: Rect) -> Affine {
|
||||
let sx = if ch.width().abs() > 1e-9 { group.w / ch.width() } else { 1.0 };
|
||||
let sy = if ch.height().abs() > 1e-9 { group.h / ch.height() } else { 1.0 };
|
||||
group.affine() * Affine::scale_non_uniform(sx, sy) * Affine::translate(-ch.origin().to_vec2())
|
||||
}
|
||||
|
||||
/// Distance from `p` to the segment `a`–`b`.
|
||||
pub fn dist_to_segment(p: Point, a: Point, b: Point) -> f64 {
|
||||
let ab = b - a;
|
||||
|
||||
@@ -1,24 +0,0 @@
|
||||
//! Preset shape geometry.
|
||||
//!
|
||||
//! Each preset is identified by its Office Open XML name (`rect`, `roundRect`, `rightArrow`…) so
|
||||
//! files round-trip, but every outline here is our own construction in Rust: we re-derive the shapes
|
||||
//! from what they look like and from the meaning of their adjust values, not from any reference
|
||||
//! geometry table. Adjust values use the file convention: ratios in 1/100 000 of the shorter side (or
|
||||
//! of the width/height), angles in 1/60 000 degree.
|
||||
|
||||
use kurbo::{Arc, BezPath, Point, Rect, Vec2};
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
mod build;
|
||||
mod builder;
|
||||
mod catalog;
|
||||
mod shapes;
|
||||
|
||||
pub use build::build;
|
||||
use builder::{Corner, Dir, Pb, corner_rect, fill, fill_eo, fill_only, mid_sites, orient, shade, simple, stroke_only, vis};
|
||||
pub use catalog::{CATALOG, Category, FillMode, Geometry, Handle, PresetInfo, SubPath, info, is_line_like, mitred_by_default};
|
||||
|
||||
mod extra;
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests;
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,344 +0,0 @@
|
||||
use super::catalog::{FillMode, Geometry, Handle, SubPath};
|
||||
use super::{Arc, BezPath, Point, Rect, Vec2};
|
||||
|
||||
// ---------- path builder ----------
|
||||
|
||||
pub(super) struct Pb {
|
||||
pub(super) p: BezPath,
|
||||
pub(super) cur: Point,
|
||||
}
|
||||
|
||||
impl Pb {
|
||||
pub(super) fn new() -> Self {
|
||||
Pb { p: BezPath::new(), cur: Point::ZERO }
|
||||
}
|
||||
pub(super) fn m(&mut self, x: f64, y: f64) -> &mut Self {
|
||||
self.cur = Point::new(x, y);
|
||||
self.p.move_to(self.cur);
|
||||
self
|
||||
}
|
||||
pub(super) fn l(&mut self, x: f64, y: f64) -> &mut Self {
|
||||
self.cur = Point::new(x, y);
|
||||
self.p.line_to(self.cur);
|
||||
self
|
||||
}
|
||||
pub(super) fn c(&mut self, x1: f64, y1: f64, x2: f64, y2: f64, x: f64, y: f64) -> &mut Self {
|
||||
self.cur = Point::new(x, y);
|
||||
self.p.curve_to(Point::new(x1, y1), Point::new(x2, y2), self.cur);
|
||||
self
|
||||
}
|
||||
pub(super) fn q(&mut self, x1: f64, y1: f64, x: f64, y: f64) -> &mut Self {
|
||||
self.cur = Point::new(x, y);
|
||||
self.p.quad_to(Point::new(x1, y1), self.cur);
|
||||
self
|
||||
}
|
||||
/// Elliptic arc continuing from the current point, which lies on the ellipse at parametric
|
||||
/// angle `st` (degrees); sweeps `sw` degrees (positive = clockwise on screen).
|
||||
pub(super) fn arc(&mut self, wr: f64, hr: f64, st: f64, sw: f64) -> &mut Self {
|
||||
let (s, e) = (st.to_radians(), (st + sw).to_radians());
|
||||
let c = Point::new(self.cur.x - wr * s.cos(), self.cur.y - hr * s.sin());
|
||||
let a = Arc::new(c, Vec2::new(wr.abs(), hr.abs()), s, e - s, 0.0);
|
||||
a.to_cubic_beziers(0.05, |p1, p2, p| {
|
||||
self.p.curve_to(p1, p2, p);
|
||||
});
|
||||
self.cur = Point::new(c.x + wr * e.cos(), c.y + hr * e.sin());
|
||||
self
|
||||
}
|
||||
/// A DrawingML `arcTo`: angles are where the ray from the ellipse's centre at that angle
|
||||
/// meets it (not the ellipse's parameter), so elliptical arcs start and end where the
|
||||
/// standard's shapes expect.
|
||||
pub(super) fn arc_spec(&mut self, wr: f64, hr: f64, st: f64, sw: f64) -> &mut Self {
|
||||
let par = |a: f64| {
|
||||
let a = a.to_radians();
|
||||
(wr * a.sin()).atan2(hr * a.cos())
|
||||
};
|
||||
let t0 = par(st);
|
||||
let mut d = par(st + sw) - t0;
|
||||
let tau = std::f64::consts::TAU;
|
||||
if sw.abs() >= 360.0 {
|
||||
d = tau.copysign(sw);
|
||||
} else {
|
||||
while sw > 0.0 && d < 0.0 {
|
||||
d += tau;
|
||||
}
|
||||
while sw < 0.0 && d > 0.0 {
|
||||
d -= tau;
|
||||
}
|
||||
}
|
||||
self.arc(wr, hr, t0.to_degrees(), d.to_degrees())
|
||||
}
|
||||
pub(super) fn z(&mut self) -> &mut Self {
|
||||
self.p.close_path();
|
||||
self
|
||||
}
|
||||
pub(super) fn poly(&mut self, pts: &[(f64, f64)]) -> &mut Self {
|
||||
for (i, (x, y)) in pts.iter().enumerate() {
|
||||
if i == 0 {
|
||||
self.m(*x, *y);
|
||||
} else {
|
||||
self.l(*x, *y);
|
||||
}
|
||||
}
|
||||
self.z()
|
||||
}
|
||||
pub(super) fn ellipse(&mut self, cx: f64, cy: f64, rx: f64, ry: f64) -> &mut Self {
|
||||
self.m(cx + rx, cy);
|
||||
self.arc(rx, ry, 0.0, 360.0);
|
||||
self.z()
|
||||
}
|
||||
pub(super) fn take(&mut self) -> BezPath {
|
||||
std::mem::take(&mut self.p)
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn fill(p: BezPath) -> SubPath {
|
||||
SubPath { path: p, fill: FillMode::Norm, stroke: true, even_odd: false }
|
||||
}
|
||||
|
||||
pub(super) fn fill_eo(p: BezPath) -> SubPath {
|
||||
SubPath { path: p, fill: FillMode::Norm, stroke: true, even_odd: true }
|
||||
}
|
||||
|
||||
pub(super) fn shade(p: BezPath, m: FillMode) -> SubPath {
|
||||
SubPath { path: p, fill: m, stroke: true, even_odd: false }
|
||||
}
|
||||
|
||||
pub(super) fn stroke_only(p: BezPath) -> SubPath {
|
||||
SubPath { path: p, fill: FillMode::None, stroke: true, even_odd: false }
|
||||
}
|
||||
|
||||
pub(super) fn fill_only(p: BezPath) -> SubPath {
|
||||
SubPath { path: p, fill: FillMode::Norm, stroke: false, even_odd: false }
|
||||
}
|
||||
|
||||
/// Parametric angle on an rx×ry ellipse for a visual angle `deg` (file angles are visual).
|
||||
pub(super) fn vis(deg: f64, rx: f64, ry: f64) -> f64 {
|
||||
let t = deg.to_radians();
|
||||
(rx * t.sin()).atan2(ry * t.cos()).to_degrees()
|
||||
}
|
||||
|
||||
pub(super) fn polygon_regular(n: usize, w: f64, h: f64, phase: f64) -> Vec<(f64, f64)> {
|
||||
let pts: Vec<(f64, f64)> = (0..n)
|
||||
.map(|i| {
|
||||
let a = (phase + 360.0 * i as f64 / n as f64).to_radians();
|
||||
(a.cos(), a.sin())
|
||||
})
|
||||
.collect();
|
||||
normalize(&pts, w, h)
|
||||
}
|
||||
|
||||
/// Scale `pts` so their bounding box fills 0..w × 0..h.
|
||||
fn normalize(pts: &[(f64, f64)], w: f64, h: f64) -> Vec<(f64, f64)> {
|
||||
let (mut x0, mut y0, mut x1, mut y1) = (f64::MAX, f64::MAX, f64::MIN, f64::MIN);
|
||||
for (x, y) in pts {
|
||||
x0 = x0.min(*x);
|
||||
y0 = y0.min(*y);
|
||||
x1 = x1.max(*x);
|
||||
y1 = y1.max(*y);
|
||||
}
|
||||
let sx = if x1 - x0 > 1e-12 { w / (x1 - x0) } else { 0.0 };
|
||||
let sy = if y1 - y0 > 1e-12 { h / (y1 - y0) } else { 0.0 };
|
||||
pts.iter().map(|(x, y)| ((x - x0) * sx, (y - y0) * sy)).collect()
|
||||
}
|
||||
|
||||
/// An n-pointed star as ECMA-376 draws it: points on an ellipse around (hc, vc · vf) with radii
|
||||
/// half the box stretched by the preset's `hf` / `vf` (so a five-pointed star fills its box and
|
||||
/// looks regular in a square), the inner corners `inner` of the way out.
|
||||
pub(super) fn star(n: usize, w: f64, h: f64, inner: f64) -> Vec<(f64, f64)> {
|
||||
let (hf, vf) = match n {
|
||||
5 => (1.05146, 1.10557),
|
||||
6 => (1.15470, 1.0),
|
||||
7 => (1.02572, 1.05210),
|
||||
10 => (1.05146, 1.0),
|
||||
_ => (1.0, 1.0),
|
||||
};
|
||||
let (rx, ry, cy) = (w / 2.0 * hf, h / 2.0 * vf, h / 2.0 * vf);
|
||||
let mut pts = Vec::with_capacity(n * 2);
|
||||
for i in 0..n * 2 {
|
||||
let a = (-90.0 + 180.0 * i as f64 / n as f64).to_radians();
|
||||
let r = if i % 2 == 0 { 1.0 } else { inner };
|
||||
pts.push((w / 2.0 + r * rx * a.cos(), cy + r * ry * a.sin()));
|
||||
}
|
||||
pts
|
||||
}
|
||||
|
||||
/// The text rectangle ECMA-376's presetShapeDefinitions give a star (`inner` is the adjust value
|
||||
/// over 50000), where known: star4's is the square inside its inner points, star5's spans the
|
||||
/// inner pentagon from its upper side points to its bottom inner point.
|
||||
pub(super) fn star_text_rect(n: usize, w: f64, h: f64, inner: f64) -> Option<Rect> {
|
||||
let (hc, vc) = (w / 2.0, h / 2.0);
|
||||
match n {
|
||||
4 => {
|
||||
let (dx, dy) = (hc * inner * 45f64.to_radians().cos(), vc * inner * 45f64.to_radians().sin());
|
||||
Some(Rect::new(hc - dx, vc - dy, hc + dx, vc + dy))
|
||||
}
|
||||
5 => {
|
||||
let (swd2, shd2, svc) = (hc * 1.05146, vc * 1.10557, vc * 1.10557);
|
||||
let (iwd2, ihd2) = (swd2 * inner, shd2 * inner);
|
||||
let sdx1 = iwd2 * 18f64.to_radians().cos();
|
||||
let sdy1 = ihd2 * 54f64.to_radians().sin();
|
||||
Some(Rect::new(hc - sdx1, svc - sdy1, hc + sdx1, svc + ihd2))
|
||||
}
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy)]
|
||||
pub(super) enum Corner {
|
||||
Square,
|
||||
Round(f64),
|
||||
Snip(f64),
|
||||
}
|
||||
|
||||
/// A rectangle with each corner (TL, TR, BR, BL) square, rounded or snipped.
|
||||
pub(super) fn corner_rect(w: f64, h: f64, c: [Corner; 4]) -> BezPath {
|
||||
let mut b = Pb::new();
|
||||
let size = |k: Corner| match k {
|
||||
Corner::Square => 0.0,
|
||||
Corner::Round(r) | Corner::Snip(r) => r.max(0.0),
|
||||
};
|
||||
let s0 = size(c[0]);
|
||||
b.m(s0, 0.0);
|
||||
// top edge → TR
|
||||
let s1 = size(c[1]);
|
||||
b.l(w - s1, 0.0);
|
||||
match c[1] {
|
||||
Corner::Round(r) if r > 0.0 => {
|
||||
b.arc(r, r, 270.0, 90.0);
|
||||
}
|
||||
Corner::Snip(_) => {
|
||||
b.l(w, s1);
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
let s2 = size(c[2]);
|
||||
b.l(w, h - s2);
|
||||
match c[2] {
|
||||
Corner::Round(r) if r > 0.0 => {
|
||||
b.arc(r, r, 0.0, 90.0);
|
||||
}
|
||||
Corner::Snip(_) => {
|
||||
b.l(w - s2, h);
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
let s3 = size(c[3]);
|
||||
b.l(s3, h);
|
||||
match c[3] {
|
||||
Corner::Round(r) if r > 0.0 => {
|
||||
b.arc(r, r, 90.0, 90.0);
|
||||
}
|
||||
Corner::Snip(_) => {
|
||||
b.l(0.0, h - s3);
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
b.l(0.0, s0);
|
||||
match c[0] {
|
||||
Corner::Round(r) if r > 0.0 => {
|
||||
b.arc(r, r, 180.0, 90.0);
|
||||
}
|
||||
Corner::Snip(_) => {
|
||||
b.l(s0, 0.0);
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
b.z();
|
||||
b.take()
|
||||
}
|
||||
|
||||
pub(super) fn mid_sites(w: f64, h: f64) -> Vec<Point> {
|
||||
vec![Point::new(w / 2.0, 0.0), Point::new(0.0, h / 2.0), Point::new(w / 2.0, h), Point::new(w, h / 2.0)]
|
||||
}
|
||||
|
||||
/// Orientation for single-axis arrows built along +x.
|
||||
#[derive(Clone, Copy)]
|
||||
pub(super) enum Dir {
|
||||
Right,
|
||||
Left,
|
||||
Up,
|
||||
Down,
|
||||
}
|
||||
|
||||
/// Map canonical (u along the arrow's length L, v across thickness T) to shape space.
|
||||
pub(super) fn orient(d: Dir, w: f64, h: f64, pts: &[(f64, f64)]) -> Vec<(f64, f64)> {
|
||||
pts.iter()
|
||||
.map(|&(u, v)| match d {
|
||||
Dir::Right => (u, v),
|
||||
Dir::Left => (w - u, v),
|
||||
Dir::Up => (v, h - u),
|
||||
Dir::Down => (v, u),
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
pub(super) fn len_thick(d: Dir, w: f64, h: f64) -> (f64, f64) {
|
||||
match d {
|
||||
Dir::Right | Dir::Left => (w, h),
|
||||
Dir::Up | Dir::Down => (h, w),
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn arrow(d: Dir, w: f64, h: f64, a1: f64, a2: f64) -> Geometry {
|
||||
let (l, t) = len_thick(d, w, h);
|
||||
let ss = l.min(t);
|
||||
let a1 = a1.clamp(0.0, 100000.0) / 100000.0;
|
||||
let dx = (ss * a2.clamp(0.0, 100000.0 * l / ss.max(1e-9)) / 100000.0).min(l);
|
||||
let y1 = t / 2.0 - t * a1 / 2.0;
|
||||
let y2 = t / 2.0 + t * a1 / 2.0;
|
||||
let pts = [(0.0, y1), (l - dx, y1), (l - dx, 0.0), (l, t / 2.0), (l - dx, t), (l - dx, y2), (0.0, y2)];
|
||||
let pts = orient(d, w, h, &pts);
|
||||
let tr = orient(d, w, h, &[(0.0, y1), (l - dx + dx * (y1 / (t / 2.0).max(1e-9)), y2)]);
|
||||
let mut text = Rect::from_points(tr[0], tr[1]);
|
||||
text = text.abs();
|
||||
let mut g = Geometry { paths: vec![fill(Pb::new().poly(&pts).take())], text_rect: text, handles: vec![], sites: mid_sites(w, h) };
|
||||
// handle 0: shaft thickness on the head base; handle 1: head length.
|
||||
let o = orient(d, w, h, &[(l - dx, t / 2.0), (l, t / 2.0)]);
|
||||
let (o0, o1) = (Point::new(o[0].0, o[0].1), Point::new(o[1].0, o[1].1));
|
||||
let across = match d {
|
||||
Dir::Right | Dir::Left => Vec2::new(0.0, -t / 2.0 / 100000.0),
|
||||
Dir::Up | Dir::Down => Vec2::new(-t / 2.0 / 100000.0, 0.0),
|
||||
};
|
||||
let along = (o0 - o1) * (ss / 100000.0 / dx.max(1e-9));
|
||||
g.handles.push(Handle::new(0, o0, across, a1 * 100000.0, 0.0, 100000.0));
|
||||
if dx > 1e-9 {
|
||||
g.handles.push(Handle::new(1, o1, along, a2, 0.0, 100000.0 * l / ss.max(1e-9)));
|
||||
}
|
||||
g
|
||||
}
|
||||
|
||||
pub(super) fn double_arrow(vertical: bool, w: f64, h: f64, a1: f64, a2: f64) -> Geometry {
|
||||
let (l, t) = if vertical { (h, w) } else { (w, h) };
|
||||
let ss = l.min(t);
|
||||
let a1 = a1.clamp(0.0, 100000.0) / 100000.0;
|
||||
let dx = (ss * a2.max(0.0) / 100000.0).min(l / 2.0);
|
||||
let y1 = t / 2.0 - t * a1 / 2.0;
|
||||
let y2 = t / 2.0 + t * a1 / 2.0;
|
||||
let pts = [(0.0, t / 2.0), (dx, 0.0), (dx, y1), (l - dx, y1), (l - dx, 0.0), (l, t / 2.0), (l - dx, t), (l - dx, y2), (dx, y2), (dx, t)];
|
||||
let pts = orient(if vertical { Dir::Down } else { Dir::Right }, w, h, &pts);
|
||||
let r = if vertical { Rect::new(y1, dx, y2, h - dx) } else { Rect::new(dx, y1, w - dx, y2) };
|
||||
Geometry { paths: vec![fill(Pb::new().poly(&pts).take())], text_rect: r, handles: vec![], sites: mid_sites(w, h) }
|
||||
}
|
||||
|
||||
/// Points given in 21600ths of the box (as ECMA-376 defines many fixed shapes), scaled to it.
|
||||
pub(super) fn spec_pts(pts: &[(i32, i32)], w: f64, h: f64) -> Vec<(f64, f64)> {
|
||||
pts.iter().map(|(x, y)| (w * *x as f64 / 21600.0, h * *y as f64 / 21600.0)).collect()
|
||||
}
|
||||
|
||||
pub(super) fn simple(path: BezPath, text: Rect, w: f64, h: f64) -> Geometry {
|
||||
Geometry { paths: vec![fill(path)], text_rect: text, handles: vec![], sites: mid_sites(w, h) }
|
||||
}
|
||||
|
||||
pub(super) fn ellipse_sites(w: f64, h: f64) -> Vec<Point> {
|
||||
(0..8)
|
||||
.map(|i| {
|
||||
let a = (-90.0 - 45.0 * i as f64).to_radians();
|
||||
Point::new(w / 2.0 + w / 2.0 * a.cos(), h / 2.0 + h / 2.0 * a.sin())
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
pub(super) fn tip_handle(w: f64, h: f64, tip: Point) -> Handle {
|
||||
// A free 2-D handle is represented as index 0 with zero direction; callers move both values.
|
||||
Handle { index: 0, pos: tip, origin: Point::new(w / 2.0, h / 2.0), dir: Vec2::new(w / 1e5, h / 1e5), min: -1e6, max: 1e6, angle: false }
|
||||
}
|
||||
@@ -1,391 +0,0 @@
|
||||
use super::builder::vis;
|
||||
use super::{BezPath, Deserialize, Point, Rect, Serialize, Vec2};
|
||||
|
||||
/// How a sub-path is filled. `Lighten`/`Darken` variants shade the shape's fill (3-D looking faces).
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum FillMode {
|
||||
Norm,
|
||||
None,
|
||||
Lighten,
|
||||
LightenLess,
|
||||
Darken,
|
||||
DarkenLess,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct SubPath {
|
||||
pub path: BezPath,
|
||||
pub fill: FillMode,
|
||||
pub stroke: bool,
|
||||
/// Even-odd fill (holes in donuts and frames).
|
||||
pub even_odd: bool,
|
||||
}
|
||||
|
||||
/// A draggable adjust handle (the yellow dot). `pos = origin + dir * value`; dragging projects
|
||||
/// the pointer onto `dir`. An `angle` handle instead measures the pointer's angle about `origin`
|
||||
/// (1/60 000 degree, y down, 0° at +x).
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub struct Handle {
|
||||
pub index: usize,
|
||||
pub pos: Point,
|
||||
pub origin: Point,
|
||||
pub dir: Vec2,
|
||||
pub min: f64,
|
||||
pub max: f64,
|
||||
pub angle: bool,
|
||||
}
|
||||
|
||||
impl Handle {
|
||||
pub(super) fn new(index: usize, origin: Point, dir: Vec2, value: f64, min: f64, max: f64) -> Self {
|
||||
Handle { index, pos: origin + dir * value, origin, dir, min, max, angle: false }
|
||||
}
|
||||
/// An angle handle on the `rx`×`ry` ellipse around `center` at visual angle `value`.
|
||||
pub(super) fn angle(index: usize, center: Point, rx: f64, ry: f64, value: f64) -> Self {
|
||||
let t = vis(value / 60000.0, rx, ry).to_radians();
|
||||
let pos = Point::new(center.x + rx * t.cos(), center.y + ry * t.sin());
|
||||
Handle { index, pos, origin: center, dir: Vec2::ZERO, min: 0.0, max: 21600000.0, angle: true }
|
||||
}
|
||||
/// The adjust value for a pointer at `p` (shape-local space).
|
||||
pub fn value_at(&self, p: Point) -> f64 {
|
||||
if self.angle {
|
||||
let d = p - self.origin;
|
||||
if !(d.x.is_finite() && d.y.is_finite()) || d.hypot() < 1e-9 {
|
||||
return self.min;
|
||||
}
|
||||
let v = (d.y.atan2(d.x).to_degrees().rem_euclid(360.0) * 60000.0).round();
|
||||
return if v >= self.max { self.min } else { v };
|
||||
}
|
||||
let l2 = self.dir.hypot2();
|
||||
if l2 < 1e-18 {
|
||||
return self.min;
|
||||
}
|
||||
let v = (p - self.origin).dot(self.dir) / l2;
|
||||
if !v.is_finite() {
|
||||
return self.min;
|
||||
}
|
||||
v.clamp(self.min.min(self.max), self.max.max(self.min)).round()
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct Geometry {
|
||||
pub paths: Vec<SubPath>,
|
||||
/// Where text goes, in shape-local space.
|
||||
pub text_rect: Rect,
|
||||
pub handles: Vec<Handle>,
|
||||
/// Connector glue points, shape-local.
|
||||
pub sites: Vec<Point>,
|
||||
}
|
||||
|
||||
impl Geometry {
|
||||
/// The union outline used for hit testing and selection (all filled or stroked sub-paths).
|
||||
pub fn outline(&self) -> BezPath {
|
||||
let mut p = BezPath::new();
|
||||
for s in &self.paths {
|
||||
p.extend(s.path.iter());
|
||||
}
|
||||
p
|
||||
}
|
||||
/// Whether nothing is filled (lines, connectors, arcs, brackets).
|
||||
pub fn is_open(&self) -> bool {
|
||||
self.paths.iter().all(|s| s.fill == FillMode::None)
|
||||
}
|
||||
}
|
||||
|
||||
/// Gallery category, as in the Shapes menu.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum Category {
|
||||
Lines,
|
||||
Rectangles,
|
||||
BasicShapes,
|
||||
BlockArrows,
|
||||
EquationShapes,
|
||||
Flowchart,
|
||||
StarsAndBanners,
|
||||
Callouts,
|
||||
ActionButtons,
|
||||
}
|
||||
|
||||
impl Category {
|
||||
pub const ALL: [Category; 9] = [
|
||||
Category::Lines,
|
||||
Category::Rectangles,
|
||||
Category::BasicShapes,
|
||||
Category::BlockArrows,
|
||||
Category::EquationShapes,
|
||||
Category::Flowchart,
|
||||
Category::StarsAndBanners,
|
||||
Category::Callouts,
|
||||
Category::ActionButtons,
|
||||
];
|
||||
pub fn label(self) -> &'static str {
|
||||
match self {
|
||||
Category::Lines => "Lines",
|
||||
Category::Rectangles => "Rectangles",
|
||||
Category::BasicShapes => "Basic Shapes",
|
||||
Category::BlockArrows => "Block Arrows",
|
||||
Category::EquationShapes => "Equation Shapes",
|
||||
Category::Flowchart => "Flowchart",
|
||||
Category::StarsAndBanners => "Stars and Banners",
|
||||
Category::Callouts => "Callouts",
|
||||
Category::ActionButtons => "Action Buttons",
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub struct PresetInfo {
|
||||
pub name: &'static str,
|
||||
pub label: &'static str,
|
||||
pub category: Category,
|
||||
/// Default adjust values.
|
||||
pub defaults: &'static [f64],
|
||||
}
|
||||
|
||||
macro_rules! p {
|
||||
($n:literal, $l:literal, $c:ident, [$($d:expr),*]) => {
|
||||
PresetInfo { name: $n, label: $l, category: Category::$c, defaults: &[$($d as f64),*] }
|
||||
};
|
||||
}
|
||||
|
||||
/// Every preset we generate, in gallery order.
|
||||
pub static CATALOG: &[PresetInfo] = &[
|
||||
p!("line", "Line", Lines, []),
|
||||
p!("straightConnector1", "Arrow", Lines, []),
|
||||
p!("bentConnector3", "Connector: Elbow", Lines, [50000]),
|
||||
p!("curvedConnector3", "Connector: Curved", Lines, [50000]),
|
||||
p!("bentConnector2", "Connector: Elbow (one bend)", Lines, []),
|
||||
p!("lineInv", "Line: Rising", Lines, []),
|
||||
p!("rect", "Rectangle", Rectangles, []),
|
||||
p!("roundRect", "Rectangle: Rounded Corners", Rectangles, [16667]),
|
||||
p!("snip1Rect", "Rectangle: Single Corner Snipped", Rectangles, [16667]),
|
||||
p!("snip2SameRect", "Rectangle: Top Corners Snipped", Rectangles, [16667, 0]),
|
||||
p!("snip2DiagRect", "Rectangle: Diagonal Corners Snipped", Rectangles, [0, 16667]),
|
||||
p!("snipRoundRect", "Rectangle: Top Corners One Rounded and One Snipped", Rectangles, [16667, 16667]),
|
||||
p!("round1Rect", "Rectangle: Single Corner Rounded", Rectangles, [16667]),
|
||||
p!("round2SameRect", "Rectangle: Top Corners Rounded", Rectangles, [16667, 0]),
|
||||
p!("round2DiagRect", "Rectangle: Diagonal Corners Rounded", Rectangles, [16667, 0]),
|
||||
p!("textBox", "Text Box", BasicShapes, []),
|
||||
p!("ellipse", "Oval", BasicShapes, []),
|
||||
p!("triangle", "Isosceles Triangle", BasicShapes, [50000]),
|
||||
p!("rtTriangle", "Right Triangle", BasicShapes, []),
|
||||
p!("parallelogram", "Parallelogram", BasicShapes, [25000]),
|
||||
p!("trapezoid", "Trapezoid", BasicShapes, [25000]),
|
||||
p!("nonIsoscelesTrapezoid", "Trapezoid: Uneven Sides", BasicShapes, [25000, 25000]),
|
||||
p!("diamond", "Diamond", BasicShapes, []),
|
||||
p!("pentagon", "Regular Pentagon", BasicShapes, []),
|
||||
p!("hexagon", "Hexagon", BasicShapes, [25000]),
|
||||
p!("heptagon", "Heptagon", BasicShapes, []),
|
||||
p!("octagon", "Octagon", BasicShapes, [29289]),
|
||||
p!("decagon", "Decagon", BasicShapes, []),
|
||||
p!("dodecagon", "Dodecagon", BasicShapes, []),
|
||||
p!("pie", "Partial Circle", BasicShapes, [0, 16200000]),
|
||||
p!("pieWedge", "Quarter Wedge", BasicShapes, []),
|
||||
p!("chord", "Chord", BasicShapes, [2700000, 16200000]),
|
||||
p!("teardrop", "Teardrop", BasicShapes, [100000]),
|
||||
p!("frame", "Frame", BasicShapes, [12500]),
|
||||
p!("cornerTabs", "Corner Tabs: Triangles", BasicShapes, []),
|
||||
p!("squareTabs", "Corner Tabs: Squares", BasicShapes, []),
|
||||
p!("plaqueTabs", "Corner Tabs: Quarter Circles", BasicShapes, []),
|
||||
p!("halfFrame", "Half Frame", BasicShapes, [33333, 33333]),
|
||||
p!("corner", "L-Shape", BasicShapes, [50000, 50000]),
|
||||
p!("diagStripe", "Diagonal Stripe", BasicShapes, [50000]),
|
||||
p!("plus", "Cross", BasicShapes, [25000]),
|
||||
p!("plaque", "Plaque", BasicShapes, [16667]),
|
||||
p!("can", "Cylinder", BasicShapes, [25000]),
|
||||
p!("cube", "Cube", BasicShapes, [25000]),
|
||||
p!("bevel", "Bevel", BasicShapes, [12500]),
|
||||
p!("donut", "Donut", BasicShapes, [25000]),
|
||||
p!("noSmoking", "\"Not Allowed\" Symbol", BasicShapes, [18750]),
|
||||
p!("blockArc", "Block Arc", BasicShapes, [10800000, 0, 25000]),
|
||||
p!("foldedCorner", "Folded Corner", BasicShapes, [16667]),
|
||||
p!("smileyFace", "Smiley Face", BasicShapes, [4653]),
|
||||
p!("heart", "Heart", BasicShapes, []),
|
||||
p!("lightningBolt", "Lightning Bolt", BasicShapes, []),
|
||||
p!("sun", "Sun", BasicShapes, [25000]),
|
||||
p!("moon", "Moon", BasicShapes, [50000]),
|
||||
p!("cloud", "Cloud", BasicShapes, []),
|
||||
p!("gear6", "Gear: 6 Teeth", BasicShapes, [15000, 3526]),
|
||||
p!("gear9", "Gear: 9 Teeth", BasicShapes, [10000, 1763]),
|
||||
p!("funnel", "Funnel", BasicShapes, []),
|
||||
p!("arc", "Arc", BasicShapes, [16200000, 0]),
|
||||
p!("bracketPair", "Double Bracket", BasicShapes, [16667]),
|
||||
p!("bracePair", "Double Brace", BasicShapes, [8333]),
|
||||
p!("leftBracket", "Left Bracket", BasicShapes, [8333]),
|
||||
p!("rightBracket", "Right Bracket", BasicShapes, [8333]),
|
||||
p!("leftBrace", "Left Brace", BasicShapes, [8333, 50000]),
|
||||
p!("rightBrace", "Right Brace", BasicShapes, [8333, 50000]),
|
||||
p!("chartX", "Chart Marker: Cross Lines", BasicShapes, []),
|
||||
p!("chartStar", "Chart Marker: Star Lines", BasicShapes, []),
|
||||
p!("chartPlus", "Chart Marker: Plus Lines", BasicShapes, []),
|
||||
p!("rightArrow", "Arrow: Right", BlockArrows, [50000, 50000]),
|
||||
p!("leftArrow", "Arrow: Left", BlockArrows, [50000, 50000]),
|
||||
p!("upArrow", "Arrow: Up", BlockArrows, [50000, 50000]),
|
||||
p!("downArrow", "Arrow: Down", BlockArrows, [50000, 50000]),
|
||||
p!("leftRightArrow", "Arrow: Left-Right", BlockArrows, [50000, 50000]),
|
||||
p!("upDownArrow", "Arrow: Up-Down", BlockArrows, [50000, 50000]),
|
||||
p!("quadArrow", "Arrow: Quad", BlockArrows, [22500, 22500, 22500]),
|
||||
p!("leftRightUpArrow", "Arrow: Left-Right-Up", BlockArrows, [25000, 25000, 25000]),
|
||||
p!("bentArrow", "Arrow: Bent", BlockArrows, [25000, 25000, 25000, 43750]),
|
||||
p!("uturnArrow", "Arrow: U-Turn", BlockArrows, [25000, 25000, 25000, 43750, 75000]),
|
||||
p!("curvedRightArrow", "Arrow: Curved Right", BlockArrows, [25000, 50000, 25000]),
|
||||
p!("curvedLeftArrow", "Arrow: Curved Left", BlockArrows, [25000, 50000, 25000]),
|
||||
p!("curvedUpArrow", "Arrow: Curved Up", BlockArrows, [25000, 50000, 25000]),
|
||||
p!("curvedDownArrow", "Arrow: Curved Down", BlockArrows, [25000, 50000, 25000]),
|
||||
p!("leftUpArrow", "Arrow: Left-Up", BlockArrows, [25000, 25000, 25000]),
|
||||
p!("bentUpArrow", "Arrow: Bent-Up", BlockArrows, [25000, 25000, 25000]),
|
||||
p!("stripedRightArrow", "Arrow: Striped Right", BlockArrows, [50000, 50000]),
|
||||
p!("notchedRightArrow", "Arrow: Notched Right", BlockArrows, [50000, 50000]),
|
||||
p!("homePlate", "Arrow: Pentagon", BlockArrows, [50000]),
|
||||
p!("chevron", "Arrow: Chevron", BlockArrows, [50000]),
|
||||
p!("circularArrow", "Arrow: Circular", BlockArrows, [12500, 1142319, 20457681, 10800000, 12500]),
|
||||
p!("leftCircularArrow", "Arrow: Circular Counter-clockwise", BlockArrows, [12500, -1142319, 1142319, 10800000, 12500]),
|
||||
p!("leftRightCircularArrow", "Arrow: Circular Two-headed", BlockArrows, [12500, 1142319, 20457681, 11942319, 12500]),
|
||||
p!("swooshArrow", "Arrow: Swoosh", BlockArrows, [25000, 16667]),
|
||||
p!("rightArrowCallout", "Callout: Right Arrow", BlockArrows, [25000, 25000, 25000, 64977]),
|
||||
p!("downArrowCallout", "Callout: Down Arrow", BlockArrows, [25000, 25000, 25000, 64977]),
|
||||
p!("leftArrowCallout", "Callout: Left Arrow", BlockArrows, [25000, 25000, 25000, 64977]),
|
||||
p!("upArrowCallout", "Callout: Up Arrow", BlockArrows, [25000, 25000, 25000, 64977]),
|
||||
p!("leftRightArrowCallout", "Callout: Left-Right Arrow", BlockArrows, [25000, 25000, 25000, 48123]),
|
||||
p!("upDownArrowCallout", "Callout: Up-Down Arrow", BlockArrows, [25000, 25000, 25000, 48123]),
|
||||
p!("quadArrowCallout", "Callout: Quad Arrow", BlockArrows, [18515, 18515, 18515, 48123]),
|
||||
p!("mathPlus", "Plus Sign", EquationShapes, [23520]),
|
||||
p!("mathMinus", "Minus Sign", EquationShapes, [23520]),
|
||||
p!("mathMultiply", "Multiplication Sign", EquationShapes, [23520]),
|
||||
p!("mathDivide", "Division Sign", EquationShapes, [23520, 5880, 11760]),
|
||||
p!("mathEqual", "Equals", EquationShapes, [23520, 11760]),
|
||||
p!("mathNotEqual", "Not Equal", EquationShapes, [23520, 6600000, 11760]),
|
||||
p!("flowChartProcess", "Flowchart: Process", Flowchart, []),
|
||||
p!("flowChartAlternateProcess", "Flowchart: Alternate Process", Flowchart, []),
|
||||
p!("flowChartDecision", "Flowchart: Decision", Flowchart, []),
|
||||
p!("flowChartInputOutput", "Flowchart: Data", Flowchart, []),
|
||||
p!("flowChartPredefinedProcess", "Flowchart: Predefined Process", Flowchart, []),
|
||||
p!("flowChartInternalStorage", "Flowchart: Internal Storage", Flowchart, []),
|
||||
p!("flowChartDocument", "Flowchart: Document", Flowchart, []),
|
||||
p!("flowChartMultidocument", "Flowchart: Multidocument", Flowchart, []),
|
||||
p!("flowChartTerminator", "Flowchart: Terminator", Flowchart, []),
|
||||
p!("flowChartPreparation", "Flowchart: Preparation", Flowchart, []),
|
||||
p!("flowChartManualInput", "Flowchart: Manual Input", Flowchart, []),
|
||||
p!("flowChartManualOperation", "Flowchart: Manual Operation", Flowchart, []),
|
||||
p!("flowChartConnector", "Flowchart: Connector", Flowchart, []),
|
||||
p!("flowChartOffpageConnector", "Flowchart: Off-page Connector", Flowchart, []),
|
||||
p!("flowChartPunchedCard", "Flowchart: Card", Flowchart, []),
|
||||
p!("flowChartPunchedTape", "Flowchart: Punched Tape", Flowchart, []),
|
||||
p!("flowChartSummingJunction", "Flowchart: Summing Junction", Flowchart, []),
|
||||
p!("flowChartOr", "Flowchart: Or", Flowchart, []),
|
||||
p!("flowChartCollate", "Flowchart: Collate", Flowchart, []),
|
||||
p!("flowChartSort", "Flowchart: Sort", Flowchart, []),
|
||||
p!("flowChartExtract", "Flowchart: Extract", Flowchart, []),
|
||||
p!("flowChartMerge", "Flowchart: Merge", Flowchart, []),
|
||||
p!("flowChartOnlineStorage", "Flowchart: Stored Data", Flowchart, []),
|
||||
p!("flowChartDelay", "Flowchart: Delay", Flowchart, []),
|
||||
p!("flowChartMagneticTape", "Flowchart: Sequential Access Storage", Flowchart, []),
|
||||
p!("flowChartMagneticDisk", "Flowchart: Magnetic Disk", Flowchart, []),
|
||||
p!("flowChartMagneticDrum", "Flowchart: Direct Access Storage", Flowchart, []),
|
||||
p!("flowChartDisplay", "Flowchart: Display", Flowchart, []),
|
||||
p!("flowChartOfflineStorage", "Flowchart: Offline Storage", Flowchart, []),
|
||||
p!("irregularSeal1", "Explosion: 8 Points", StarsAndBanners, []),
|
||||
p!("irregularSeal2", "Explosion: 14 Points", StarsAndBanners, []),
|
||||
p!("star4", "Star: 4 Points", StarsAndBanners, [12500]),
|
||||
p!("star5", "Star: 5 Points", StarsAndBanners, [19098]),
|
||||
p!("star6", "Star: 6 Points", StarsAndBanners, [28868]),
|
||||
p!("star7", "Star: 7 Points", StarsAndBanners, [34601]),
|
||||
p!("star8", "Star: 8 Points", StarsAndBanners, [37500]),
|
||||
p!("star10", "Star: 10 Points", StarsAndBanners, [42533]),
|
||||
p!("star12", "Star: 12 Points", StarsAndBanners, [37500]),
|
||||
p!("star16", "Star: 16 Points", StarsAndBanners, [37500]),
|
||||
p!("star24", "Star: 24 Points", StarsAndBanners, [37500]),
|
||||
p!("star32", "Star: 32 Points", StarsAndBanners, [37500]),
|
||||
p!("ribbon2", "Ribbon: Tilted Up", StarsAndBanners, [16667, 50000]),
|
||||
p!("ribbon", "Ribbon: Tilted Down", StarsAndBanners, [16667, 50000]),
|
||||
p!("ellipseRibbon2", "Ribbon: Curved and Tilted Up", StarsAndBanners, [25000, 50000, 12500]),
|
||||
p!("ellipseRibbon", "Ribbon: Curved and Tilted Down", StarsAndBanners, [25000, 50000, 12500]),
|
||||
p!("leftRightRibbon", "Ribbon: Left-Right Fold", StarsAndBanners, [50000, 50000, 16667]),
|
||||
p!("verticalScroll", "Scroll: Vertical", StarsAndBanners, [12500]),
|
||||
p!("horizontalScroll", "Scroll: Horizontal", StarsAndBanners, [12500]),
|
||||
p!("wave", "Wave", StarsAndBanners, [12500, 0]),
|
||||
p!("doubleWave", "Double Wave", StarsAndBanners, [6250, 0]),
|
||||
p!("wedgeRectCallout", "Speech Bubble: Rectangle", Callouts, [-20833, 62500]),
|
||||
p!("wedgeRoundRectCallout", "Speech Bubble: Rectangle with Corners Rounded", Callouts, [-20833, 62500, 16667]),
|
||||
p!("wedgeEllipseCallout", "Speech Bubble: Oval", Callouts, [-20833, 62500]),
|
||||
p!("cloudCallout", "Thought Bubble: Cloud", Callouts, [-20833, 62500]),
|
||||
p!("borderCallout1", "Callout: Line", Callouts, [18750, -8333, 112500, -38333]),
|
||||
p!("borderCallout2", "Callout: Bent Line", Callouts, [18750, -8333, 18750, -16667, 112500, -46667]),
|
||||
p!("borderCallout3", "Callout: Double Bent Line", Callouts, [18750, -8333, 18750, -16667, 100000, -16667, 112963, -8333]),
|
||||
p!("accentCallout1", "Callout: Line with Accent Bar", Callouts, [18750, -8333, 112500, -38333]),
|
||||
p!("accentCallout2", "Callout: Bent Line with Accent Bar", Callouts, [18750, -8333, 18750, -16667, 112500, -46667]),
|
||||
p!("accentCallout3", "Callout: Double Bent Line with Accent Bar", Callouts, [18750, -8333, 18750, -16667, 100000, -16667, 112963, -8333]),
|
||||
p!("callout1", "Callout: Line with No Border", Callouts, [18750, -8333, 112500, -38333]),
|
||||
p!("callout2", "Callout: Bent Line with No Border", Callouts, [18750, -8333, 18750, -16667, 112500, -46667]),
|
||||
p!("callout3", "Callout: Double Bent Line with No Border", Callouts, [18750, -8333, 18750, -16667, 100000, -16667, 112963, -8333]),
|
||||
p!("accentBorderCallout1", "Callout: Line with Border and Accent Bar", Callouts, [18750, -8333, 112500, -38333]),
|
||||
p!("accentBorderCallout2", "Callout: Bent Line with Border and Accent Bar", Callouts, [18750, -8333, 18750, -16667, 112500, -46667]),
|
||||
p!(
|
||||
"accentBorderCallout3",
|
||||
"Callout: Double Bent Line with Border and Accent Bar",
|
||||
Callouts,
|
||||
[18750, -8333, 18750, -16667, 100000, -16667, 112963, -8333]
|
||||
),
|
||||
p!("actionButtonBackPrevious", "Action Button: Go Back or Previous", ActionButtons, []),
|
||||
p!("actionButtonForwardNext", "Action Button: Go Forward or Next", ActionButtons, []),
|
||||
p!("actionButtonBeginning", "Action Button: Go to Beginning", ActionButtons, []),
|
||||
p!("actionButtonEnd", "Action Button: Go to End", ActionButtons, []),
|
||||
p!("actionButtonHome", "Action Button: Go Home", ActionButtons, []),
|
||||
p!("actionButtonInformation", "Action Button: Get Information", ActionButtons, []),
|
||||
p!("actionButtonReturn", "Action Button: Go Back", ActionButtons, []),
|
||||
p!("actionButtonMovie", "Action Button: Video", ActionButtons, []),
|
||||
p!("actionButtonDocument", "Action Button: Document", ActionButtons, []),
|
||||
p!("actionButtonSound", "Action Button: Sound", ActionButtons, []),
|
||||
p!("actionButtonHelp", "Action Button: Help", ActionButtons, []),
|
||||
p!("actionButtonBlank", "Action Button: Custom", ActionButtons, []),
|
||||
];
|
||||
|
||||
pub fn info(name: &str) -> Option<&'static PresetInfo> {
|
||||
CATALOG.iter().find(|p| p.name == name)
|
||||
}
|
||||
|
||||
/// Whether PowerPoint joins this preset's outline with sharp (miter) corners when the line names
|
||||
/// no join (it rounds them otherwise). Observed per preset on its export: the plus, the right,
|
||||
/// up and down block arrows (not the left one), chevrons, stars from five points up, the
|
||||
/// equation shapes, curved ribbons and the action buttons are mitred.
|
||||
pub fn mitred_by_default(name: &str) -> bool {
|
||||
matches!(
|
||||
name,
|
||||
"plus"
|
||||
| "rightArrow"
|
||||
| "upArrow"
|
||||
| "downArrow"
|
||||
| "upDownArrow"
|
||||
| "leftUpArrow"
|
||||
| "bentUpArrow"
|
||||
| "stripedRightArrow"
|
||||
| "notchedRightArrow"
|
||||
| "chevron"
|
||||
| "leftArrowCallout"
|
||||
| "leftRightArrowCallout"
|
||||
| "upDownArrowCallout"
|
||||
| "quadArrowCallout"
|
||||
| "mathPlus"
|
||||
| "mathMinus"
|
||||
| "mathMultiply"
|
||||
| "mathEqual"
|
||||
| "mathNotEqual"
|
||||
| "star5"
|
||||
| "star6"
|
||||
| "star8"
|
||||
| "star10"
|
||||
| "star12"
|
||||
| "star16"
|
||||
| "star24"
|
||||
| "star32"
|
||||
| "ellipseRibbon"
|
||||
| "ellipseRibbon2"
|
||||
) || name.starts_with("actionButton")
|
||||
}
|
||||
|
||||
pub fn is_line_like(name: &str) -> bool {
|
||||
matches!(name, "line" | "straightConnector1" | "bentConnector2" | "bentConnector3" | "curvedConnector3" | "arc")
|
||||
|| name.starts_with("bentConnector")
|
||||
|| name.starts_with("curvedConnector")
|
||||
}
|
||||
@@ -1,799 +0,0 @@
|
||||
//! More preset outlines: line callouts, arrow callouts, curved and circular arrows, curved
|
||||
//! ribbons, gears, tabs and chart markers. Like the rest of `preset`, every outline is our own
|
||||
//! construction, fitted to how the shapes look and to what their adjust values mean.
|
||||
|
||||
use super::{
|
||||
Corner, Dir, FillMode, Geometry, Handle, Pb, Point, Rect, Vec2, corner_rect, fill, fill_eo, fill_only, mid_sites, orient, shade, simple,
|
||||
stroke_only, vis,
|
||||
};
|
||||
|
||||
/// Builds the presets this module knows; `None` for any other name.
|
||||
pub(super) fn build(name: &str, w: f64, h: f64, a: &dyn Fn(usize) -> f64) -> Option<Geometry> {
|
||||
let ss = w.min(h);
|
||||
let full = Rect::new(0.0, 0.0, w, h);
|
||||
let mut b = Pb::new();
|
||||
let g = match name {
|
||||
"lineInv" => {
|
||||
let l = b.m(0.0, h).l(w, 0.0).take();
|
||||
Geometry { paths: vec![stroke_only(l)], text_rect: full, handles: vec![], sites: vec![Point::new(0.0, h), Point::new(w, 0.0)] }
|
||||
}
|
||||
"nonIsoscelesTrapezoid" => {
|
||||
let max = 50000.0 * w / ss.max(1e-9);
|
||||
let (v1, v2) = (a(0).clamp(0.0, max), a(1).clamp(0.0, max));
|
||||
let (d1, d2) = (ss * v1 / 1e5, ss * v2 / 1e5);
|
||||
let mut g = simple(b.poly(&[(0.0, h), (d1, 0.0), (w - d2, 0.0), (w, h)]).take(), Rect::new(d1 * 0.66, h * 0.2, w - d2 * 0.66, h), w, h);
|
||||
g.handles.push(Handle::new(0, Point::ZERO, Vec2::new(ss / 1e5, 0.0), v1, 0.0, max));
|
||||
g.handles.push(Handle::new(1, Point::new(w, 0.0), Vec2::new(-ss / 1e5, 0.0), v2, 0.0, max));
|
||||
g
|
||||
}
|
||||
"pieWedge" => {
|
||||
b.m(0.0, h).arc(w, h, 180.0, 90.0).l(w, h).z();
|
||||
simple(b.take(), Rect::new(w * 0.29289, h * 0.29289, w, h), w, h)
|
||||
}
|
||||
"flowChartOfflineStorage" => {
|
||||
let tri = b.poly(&[(0.0, 0.0), (w, 0.0), (w / 2.0, h)]).take();
|
||||
let bar = Pb::new().m(w * 0.4, h * 0.8).l(w * 0.6, h * 0.8).take();
|
||||
Geometry {
|
||||
paths: vec![fill(tri), stroke_only(bar)],
|
||||
text_rect: Rect::new(w / 4.0, 0.0, w * 0.75, h * 0.8),
|
||||
handles: vec![],
|
||||
sites: vec![Point::new(w / 2.0, 0.0), Point::new(w / 4.0, h / 2.0), Point::new(w / 2.0, h), Point::new(w * 0.75, h / 2.0)],
|
||||
}
|
||||
}
|
||||
"chartX" | "chartStar" | "chartPlus" => {
|
||||
let body = corner_rect(w, h, [Corner::Square; 4]);
|
||||
let mut l = Pb::new();
|
||||
if name != "chartPlus" {
|
||||
l.m(0.0, 0.0).l(w, h).m(0.0, h).l(w, 0.0);
|
||||
}
|
||||
if name != "chartX" {
|
||||
l.m(w / 2.0, 0.0).l(w / 2.0, h);
|
||||
}
|
||||
if name == "chartPlus" {
|
||||
l.m(0.0, h / 2.0).l(w, h / 2.0);
|
||||
}
|
||||
Geometry { paths: vec![fill_only(body), stroke_only(l.take())], text_rect: full, handles: vec![], sites: mid_sites(w, h) }
|
||||
}
|
||||
"cornerTabs" | "squareTabs" | "plaqueTabs" => {
|
||||
// Each tab's size is a twentieth of the diagonal.
|
||||
let d = (w.hypot(h) / 20.0).min(w / 2.0).min(h / 2.0);
|
||||
match name {
|
||||
"cornerTabs" => {
|
||||
b.poly(&[(0.0, 0.0), (d, 0.0), (0.0, d)]);
|
||||
b.poly(&[(w - d, 0.0), (w, 0.0), (w, d)]);
|
||||
b.poly(&[(w, h - d), (w, h), (w - d, h)]);
|
||||
b.poly(&[(0.0, h - d), (d, h), (0.0, h)]);
|
||||
}
|
||||
"squareTabs" => {
|
||||
b.poly(&[(0.0, 0.0), (d, 0.0), (d, d), (0.0, d)]);
|
||||
b.poly(&[(w - d, 0.0), (w, 0.0), (w, d), (w - d, d)]);
|
||||
b.poly(&[(w - d, h - d), (w, h - d), (w, h), (w - d, h)]);
|
||||
b.poly(&[(0.0, h - d), (d, h - d), (d, h), (0.0, h)]);
|
||||
}
|
||||
_ => {
|
||||
if d > 0.0 {
|
||||
b.m(0.0, 0.0).l(d, 0.0).arc(d, d, 0.0, 90.0).z();
|
||||
b.m(w, 0.0).l(w, d).arc(d, d, 90.0, 90.0).z();
|
||||
b.m(w, h).l(w - d, h).arc(d, d, 180.0, 90.0).z();
|
||||
b.m(0.0, h).l(0.0, h - d).arc(d, d, 270.0, 90.0).z();
|
||||
} else {
|
||||
b.m(0.0, 0.0).z();
|
||||
}
|
||||
}
|
||||
}
|
||||
Geometry { paths: vec![fill(b.take())], text_rect: full.inset(-d), handles: vec![], sites: mid_sites(w, h) }
|
||||
}
|
||||
"callout1"
|
||||
| "callout2"
|
||||
| "callout3"
|
||||
| "accentCallout1"
|
||||
| "accentCallout2"
|
||||
| "accentCallout3"
|
||||
| "borderCallout2"
|
||||
| "borderCallout3"
|
||||
| "accentBorderCallout1"
|
||||
| "accentBorderCallout2"
|
||||
| "accentBorderCallout3" => {
|
||||
let n = match name.chars().last() {
|
||||
Some('2') => 2,
|
||||
Some('3') => 3,
|
||||
_ => 1,
|
||||
};
|
||||
line_callout(w, h, a, n + 1, name.starts_with("accent"), name.contains("order"))
|
||||
}
|
||||
"leftRightArrowCallout" | "upDownArrowCallout" => {
|
||||
let vertical = name == "upDownArrowCallout";
|
||||
let (l, t) = if vertical { (h, w) } else { (w, h) };
|
||||
let ss = l.min(t);
|
||||
let head = (ss * a(1).max(0.0) / 1e5).min(t / 2.0);
|
||||
let shaft = (ss * a(0).max(0.0) / 1e5).min(head * 2.0);
|
||||
let hl = (ss * a(2).max(0.0) / 1e5).min(l / 2.0);
|
||||
let boxl = (l * a(3).max(0.0) / 1e5).min(l - 2.0 * hl);
|
||||
let (c, b0, b1) = (t / 2.0, (l - boxl) / 2.0, (l + boxl) / 2.0);
|
||||
let pts = [
|
||||
(0.0, c),
|
||||
(hl, c - head),
|
||||
(hl, c - shaft / 2.0),
|
||||
(b0, c - shaft / 2.0),
|
||||
(b0, 0.0),
|
||||
(b1, 0.0),
|
||||
(b1, c - shaft / 2.0),
|
||||
(l - hl, c - shaft / 2.0),
|
||||
(l - hl, c - head),
|
||||
(l, c),
|
||||
(l - hl, c + head),
|
||||
(l - hl, c + shaft / 2.0),
|
||||
(b1, c + shaft / 2.0),
|
||||
(b1, t),
|
||||
(b0, t),
|
||||
(b0, c + shaft / 2.0),
|
||||
(hl, c + shaft / 2.0),
|
||||
(hl, c + head),
|
||||
];
|
||||
let d = if vertical { Dir::Down } else { Dir::Right };
|
||||
let pts = orient(d, w, h, &pts);
|
||||
let tr = orient(d, w, h, &[(b0, 0.0), (b1, t)]);
|
||||
simple(b.poly(&pts).take(), Rect::from_points(Point::new(tr[0].0, tr[0].1), Point::new(tr[1].0, tr[1].1)).abs(), w, h)
|
||||
}
|
||||
"quadArrowCallout" => {
|
||||
let head = (ss * a(1).max(0.0) / 1e5).min(ss / 2.0);
|
||||
let shaft = (ss * a(0).max(0.0) / 1e5).min(head * 2.0);
|
||||
let hl = (ss * a(2).max(0.0) / 1e5).min(ss / 2.0);
|
||||
let k = a(3).clamp(0.0, 100000.0) / 1e5;
|
||||
let (bw, bh) = ((w * k).min(w - 2.0 * hl).max(shaft), (h * k).min(h - 2.0 * hl).max(shaft));
|
||||
let (cx, cy) = (w / 2.0, h / 2.0);
|
||||
let (bx0, bx1, by0, by1) = (cx - bw / 2.0, cx + bw / 2.0, cy - bh / 2.0, cy + bh / 2.0);
|
||||
let (s2, hd) = (shaft / 2.0, head);
|
||||
let pts = [
|
||||
(0.0, cy),
|
||||
(hl, cy - hd),
|
||||
(hl, cy - s2),
|
||||
(bx0, cy - s2),
|
||||
(bx0, by0),
|
||||
(cx - s2, by0),
|
||||
(cx - s2, hl),
|
||||
(cx - hd, hl),
|
||||
(cx, 0.0),
|
||||
(cx + hd, hl),
|
||||
(cx + s2, hl),
|
||||
(cx + s2, by0),
|
||||
(bx1, by0),
|
||||
(bx1, cy - s2),
|
||||
(w - hl, cy - s2),
|
||||
(w - hl, cy - hd),
|
||||
(w, cy),
|
||||
(w - hl, cy + hd),
|
||||
(w - hl, cy + s2),
|
||||
(bx1, cy + s2),
|
||||
(bx1, by1),
|
||||
(cx + s2, by1),
|
||||
(cx + s2, h - hl),
|
||||
(cx + hd, h - hl),
|
||||
(cx, h),
|
||||
(cx - hd, h - hl),
|
||||
(cx - s2, h - hl),
|
||||
(cx - s2, by1),
|
||||
(bx0, by1),
|
||||
(bx0, cy + s2),
|
||||
(hl, cy + s2),
|
||||
(hl, cy + hd),
|
||||
];
|
||||
simple(b.poly(&pts).take(), Rect::new(bx0, by0, bx1, by1), w, h)
|
||||
}
|
||||
"curvedRightArrow" | "curvedLeftArrow" | "curvedUpArrow" | "curvedDownArrow" => curved_arrow(name, w, h, a(0), a(1), a(2)),
|
||||
"swooshArrow" => swoosh(w, h, a(0), a(1)),
|
||||
"ellipseRibbon" | "ellipseRibbon2" => ellipse_ribbon(name == "ellipseRibbon2", w, h, a(0), a(1), a(2)),
|
||||
"leftRightRibbon" => left_right_ribbon(w, h, a(0), a(1), a(2)),
|
||||
"gear6" | "gear9" => gear(if name == "gear6" { 6 } else { 9 }, w, h, a(0), a(1)),
|
||||
"funnel" => funnel(w, h),
|
||||
"circularArrow" | "leftCircularArrow" | "leftRightCircularArrow" => circular_arrow(name, w, h, [a(0), a(1), a(2), a(3), a(4)]),
|
||||
_ => return None,
|
||||
};
|
||||
Some(g)
|
||||
}
|
||||
|
||||
/// An ellipse-centred frame for the circular arrows: the band's middle runs on the ellipse
|
||||
/// `(rx, ry)`, its edges `th/2` either side.
|
||||
struct Ring {
|
||||
c: Point,
|
||||
rx: f64,
|
||||
ry: f64,
|
||||
th: f64,
|
||||
hw: f64,
|
||||
}
|
||||
|
||||
impl Ring {
|
||||
/// The point at visual angle `deg` on the ellipse grown by `d`.
|
||||
fn at(&self, deg: f64, d: f64) -> Point {
|
||||
let (ax, ay) = ((self.rx + d).max(0.0), (self.ry + d).max(0.0));
|
||||
let t = vis(deg, ax, ay).to_radians();
|
||||
Point::new(self.c.x + ax * t.cos(), self.c.y + ay * t.sin())
|
||||
}
|
||||
/// Parametric angle (degrees) of `p` on the ellipse grown by `d`.
|
||||
fn param(&self, p: Point, d: f64) -> f64 {
|
||||
let (ax, ay) = ((self.rx + d).max(1e-9), (self.ry + d).max(1e-9));
|
||||
((p.y - self.c.y) / ay).atan2((p.x - self.c.x) / ax).to_degrees()
|
||||
}
|
||||
/// Where the line `b + s·u` meets the ellipse grown by `d`, taking the crossing nearest `b`
|
||||
/// on the side `sign` (+1 outwards, −1 inwards).
|
||||
fn cross(&self, b: Point, u: Vec2, d: f64, sign: f64) -> Point {
|
||||
let (ax, ay) = ((self.rx + d).max(1e-9), (self.ry + d).max(1e-9));
|
||||
let (px, py) = ((b.x - self.c.x) / ax, (b.y - self.c.y) / ay);
|
||||
let (ux, uy) = (u.x / ax, u.y / ay);
|
||||
let qa = ux * ux + uy * uy;
|
||||
let qb = 2.0 * (px * ux + py * uy);
|
||||
let qc = px * px + py * py - 1.0;
|
||||
let disc = qb * qb - 4.0 * qa * qc;
|
||||
if qa < 1e-18 || disc < 0.0 {
|
||||
// The line misses (a long head on a thin ring): the edge then carries on from the
|
||||
// base centre itself, as the reference does.
|
||||
return b;
|
||||
}
|
||||
let r = disc.sqrt();
|
||||
let (s0, s1) = ((-qb - r) / (2.0 * qa), (-qb + r) / (2.0 * qa));
|
||||
let s = if sign > 0.0 {
|
||||
if s0 >= 0.0 { s0 } else { s1 }
|
||||
} else if s1 <= 0.0 {
|
||||
s1
|
||||
} else {
|
||||
s0
|
||||
};
|
||||
b + u * s
|
||||
}
|
||||
/// An arrow head whose base centre sits on the middle ellipse at `base` degrees and whose tip
|
||||
/// sits there at `base + sweep`. The base runs along the line from the centre to the tip.
|
||||
/// Returns (band outer edge, outer wing, tip, inner wing, band inner edge).
|
||||
fn head(&self, base: f64, sweep: f64) -> [Point; 5] {
|
||||
let b = self.at(base, 0.0);
|
||||
let tip = self.at(base + sweep, 0.0);
|
||||
let d = tip - self.c;
|
||||
let u = if d.hypot() > 1e-12 { d / d.hypot() } else { Vec2::new(1.0, 0.0) };
|
||||
let half = self.th / 2.0;
|
||||
[self.cross(b, u, half, 1.0), b + u * self.hw, tip, b - u * self.hw, self.cross(b, u, -half, -1.0)]
|
||||
}
|
||||
}
|
||||
|
||||
/// Sweep (degrees) from `a` to `b` turning one way: positive when `dir > 0`.
|
||||
fn turn(a: f64, b: f64, dir: f64) -> f64 {
|
||||
if dir > 0.0 { (b - a).rem_euclid(360.0) } else { -(a - b).rem_euclid(360.0) }
|
||||
}
|
||||
|
||||
/// The circular arrows: a band along an ellipse with one head (`circularArrow` clockwise,
|
||||
/// `leftCircularArrow` anticlockwise) or a head at each end (`leftRightCircularArrow`).
|
||||
/// Adjusts: band thickness, head sweep (degrees), end angle, start angle, head half-width.
|
||||
fn circular_arrow(name: &str, w: f64, h: f64, a: [f64; 5]) -> Geometry {
|
||||
let ss = w.min(h);
|
||||
if ss <= 0.0 {
|
||||
return simple(corner_rect(w, h, [Corner::Square; 4]), Rect::new(0.0, 0.0, w, h), w, h);
|
||||
}
|
||||
let a5 = a[4].clamp(0.0, 25000.0);
|
||||
let hw = ss * a5 / 1e5;
|
||||
let th = ss * a[0].clamp(0.0, 2.0 * a5) / 1e5;
|
||||
let ring = Ring { c: Point::new(w / 2.0, h / 2.0), rx: (w / 2.0 - hw).max(th / 2.0), ry: (h / 2.0 - hw).max(th / 2.0), th, hw };
|
||||
let deg = |v: f64| (v / 60000.0) % 360.0;
|
||||
let (sweep, end, start) = (deg(a[1]), deg(a[2]), deg(a[3]));
|
||||
let half = th / 2.0;
|
||||
let mut b = Pb::new();
|
||||
// Arcs of the ellipse grown by `d`, drawn on from the current point (which is on it except in
|
||||
// the degenerate case above, where the arc shifts with it like the reference's).
|
||||
let edge_arc = |b: &mut Pb, from: Point, to: Point, d: f64, dir: f64| {
|
||||
let (ax, ay) = ((ring.rx + d).max(0.0), (ring.ry + d).max(0.0));
|
||||
let (s, e) = (ring.param(from, d), ring.param(to, d));
|
||||
b.arc(ax, ay, s, turn(s, e, dir));
|
||||
};
|
||||
let outer_arc = |b: &mut Pb, from: Point, to: Point, dir: f64| edge_arc(b, from, to, half, dir);
|
||||
let inner_arc = |b: &mut Pb, from: Point, to: Point, dir: f64| edge_arc(b, from, to, -half, dir);
|
||||
if name == "leftRightCircularArrow" {
|
||||
let hs = ring.head(start, -sweep);
|
||||
let he = ring.head(end, sweep);
|
||||
b.m(hs[0].x, hs[0].y);
|
||||
outer_arc(&mut b, hs[0], he[0], 1.0);
|
||||
b.l(he[1].x, he[1].y).l(he[2].x, he[2].y).l(he[3].x, he[3].y).l(he[4].x, he[4].y);
|
||||
inner_arc(&mut b, he[4], hs[4], -1.0);
|
||||
b.l(hs[3].x, hs[3].y).l(hs[2].x, hs[2].y).l(hs[1].x, hs[1].y).z();
|
||||
} else {
|
||||
let dir = if name == "circularArrow" { 1.0 } else { -1.0 };
|
||||
let he = ring.head(end, sweep);
|
||||
let (o0, i0) = (ring.at(start, half), ring.at(start, -half));
|
||||
b.m(o0.x, o0.y);
|
||||
outer_arc(&mut b, o0, he[0], dir);
|
||||
b.l(he[1].x, he[1].y).l(he[2].x, he[2].y).l(he[3].x, he[3].y).l(he[4].x, he[4].y);
|
||||
inner_arc(&mut b, he[4], i0, -dir);
|
||||
b.z();
|
||||
}
|
||||
simple(b.take(), Rect::new(0.0, 0.0, w, h), w, h)
|
||||
}
|
||||
|
||||
/// A funnel: an elliptical rim (with an open mouth) across the top quarter, and straight sides
|
||||
/// down to a small rounded spout. The side lines leave the rim and meet the spout at fixed
|
||||
/// angles, fitted to the reference look.
|
||||
fn funnel(w: f64, h: f64) -> Geometry {
|
||||
const RIM: f64 = 173.0; // where the left side leaves the rim, degrees on the rim ellipse
|
||||
const SPOUT: f64 = 163.4; // where it meets the spout, degrees on the spout ellipse
|
||||
let ss = w.min(h);
|
||||
let (cx, rim_y) = (w / 2.0, h / 4.0);
|
||||
let (sx, sy) = (w / 8.0, h / 15.0);
|
||||
let spout_y = h - sy;
|
||||
let at = |rx: f64, ry: f64, cy: f64, deg: f64| {
|
||||
let t = deg.to_radians();
|
||||
Point::new(cx + rx * t.cos(), cy + ry * t.sin())
|
||||
};
|
||||
let p0 = at(cx, rim_y, rim_y, RIM);
|
||||
let p1 = at(sx, sy, spout_y, 180.0 - SPOUT);
|
||||
let mut b = Pb::new();
|
||||
b.m(p0.x, p0.y).arc(cx, rim_y, RIM, 540.0 - 2.0 * RIM);
|
||||
b.l(p1.x, p1.y).arc(sx, sy, 180.0 - SPOUT, 2.0 * SPOUT - 180.0).z();
|
||||
let d = ss / 20.0;
|
||||
b.ellipse(cx, rim_y, (cx - d).max(0.0), (rim_y - d).max(0.0));
|
||||
Geometry { paths: vec![fill_eo(b.take())], text_rect: Rect::new(w / 4.0, h / 2.0, w * 0.75, h - sy), handles: vec![], sites: mid_sites(w, h) }
|
||||
}
|
||||
|
||||
/// A gear: an elliptical body with `n` teeth, the first pointing straight up. Each tooth leaves
|
||||
/// the body at two points an equal angle either side of its centre, and its tip corners sit a
|
||||
/// tooth height further out along the body's normal and a flank lean further in.
|
||||
fn gear(n: usize, w: f64, h: f64, a0: f64, a1: f64) -> Geometry {
|
||||
let ss = w.min(h);
|
||||
let th = ss * a0.clamp(0.0, 20000.0) / 1e5; // tooth height
|
||||
let lean_max = if n == 6 { 5380.0 } else { 2730.0 };
|
||||
let l = ss * a1.clamp(0.0, a0.clamp(0.0, 20000.0).min(lean_max)) / 1e5; // flank lean
|
||||
let (cx, cy) = (w / 2.0, h / 2.0);
|
||||
let (rx, ry) = ((cx - th).max(0.0), (cy - th).max(0.0));
|
||||
let r = (ss / 2.0 - th).max(1e-9);
|
||||
let half = ((th + l) / 2.0 / r).atan();
|
||||
let step = std::f64::consts::TAU / n as f64;
|
||||
let on_body = |t: f64| Point::new(cx + rx * t.cos(), cy + ry * t.sin());
|
||||
let mut b = Pb::new();
|
||||
for k in 0..n {
|
||||
let t = -std::f64::consts::FRAC_PI_2 + step * k as f64;
|
||||
// The tooth stands along the body's normal at its centre.
|
||||
let nrm = Vec2::new(t.cos() * ry, t.sin() * rx);
|
||||
let u = if nrm.hypot() > 1e-12 { nrm / nrm.hypot() } else { Vec2::new(t.cos(), t.sin()) };
|
||||
let v = Vec2::new(-u.y, u.x);
|
||||
let (r0, r1) = (on_body(t - half), on_body(t + half));
|
||||
let (c0, c1) = (r0 + u * th + v * l, r1 + u * th - v * l);
|
||||
if k == 0 {
|
||||
b.m(r0.x, r0.y);
|
||||
} else {
|
||||
b.arc(rx, ry, (t - step + half).to_degrees(), (step - 2.0 * half).to_degrees());
|
||||
}
|
||||
b.l(c0.x, c0.y).l(c1.x, c1.y).l(r1.x, r1.y);
|
||||
}
|
||||
let t_last = -std::f64::consts::FRAC_PI_2 + step * (n - 1) as f64;
|
||||
b.arc(rx, ry, (t_last + half).to_degrees(), (step - 2.0 * half).to_degrees()).z();
|
||||
let k = std::f64::consts::FRAC_1_SQRT_2;
|
||||
let text = Rect::new(cx - rx * k, cy - ry * k, cx + rx * k, cy + ry * k);
|
||||
simple(b.take(), text, w, h)
|
||||
}
|
||||
|
||||
/// Two arrows on a band that steps down in the middle: the left arrow sits high, the right one low,
|
||||
/// and the band rolls over between them in a shaded half-ellipse curl.
|
||||
fn left_right_ribbon(w: f64, h: f64, a0: f64, a1: f64, a2: f64) -> Geometry {
|
||||
let ss = w.min(h);
|
||||
let sh = h * a2.clamp(0.0, 33333.0) / 1e5; // step between the two halves
|
||||
let bt = (h * a0.max(0.0) / 1e5).min(h - sh); // band thickness
|
||||
let cx = w / 2.0;
|
||||
let (rx, ry) = (w / 32.0, (sh / 4.0).min(w / 24.0));
|
||||
let hb = (ss * a1.max(0.0) / 1e5).min(cx - rx); // head length
|
||||
let yc = (h - sh) / 2.0;
|
||||
let (lt, lb) = (yc - bt / 2.0, yc + bt / 2.0);
|
||||
let (rt, rb) = (lt + sh, lb + sh);
|
||||
// The left half: filled as a closed outline, stroked only where it can show.
|
||||
let mut edge = Pb::new();
|
||||
edge.m(cx - rx, lb).l(hb, lb).l(hb, h - sh).l(0.0, yc).l(hb, 0.0).l(hb, lt).l(cx, lt);
|
||||
edge.arc(rx, ry, 270.0, 180.0).arc(rx, ry, 270.0, -90.0);
|
||||
let edge = edge.take();
|
||||
let mut left = Pb::new();
|
||||
left.m(0.0, yc).l(hb, 0.0).l(hb, lt).l(cx, lt).arc(rx, ry, 270.0, 180.0).arc(rx, ry, 270.0, -180.0);
|
||||
left.l(cx, lb.max(lt + 4.0 * ry)).l(hb, lb).l(hb, h - sh).z();
|
||||
let left = left.take();
|
||||
let mut curl = Pb::new();
|
||||
curl.m(cx + rx, lt + ry).l(cx + rx, rt).l(cx, lt + 4.0 * ry).arc(rx, ry, 90.0, 180.0).arc(rx, ry, 90.0, -90.0).z();
|
||||
let mut right = Pb::new();
|
||||
right.m(w, yc + sh).l(w - hb, h).l(w - hb, rb).l(cx, rb).arc(rx, ry, 90.0, 90.0).l(cx - rx, rt - ry).arc(rx, ry, 180.0, -90.0);
|
||||
right.l(w - hb, rt).l(w - hb, sh).z();
|
||||
Geometry {
|
||||
paths: vec![fill_only(left), stroke_only(edge), shade(curl.take(), FillMode::DarkenLess), fill(right.take())],
|
||||
text_rect: Rect::new(hb.min(cx - rx), rt, (w - hb).max(cx + rx), lb.max(rt)),
|
||||
handles: vec![],
|
||||
sites: vec![Point::new(0.0, yc), Point::new(cx, rt), Point::new(w, yc + sh), Point::new(cx, lb)],
|
||||
}
|
||||
}
|
||||
|
||||
/// Adds a piece of the parabola `y = y0 + d·(1 − ((x − w/2)/(w/2))²)` from the current point (at
|
||||
/// `xa`) to `xb`, as one quadratic curve.
|
||||
fn sag(b: &mut Pb, w: f64, d: f64, y0: f64, xa: f64, xb: f64) {
|
||||
let hw = (w / 2.0).max(1e-9);
|
||||
let f = |x: f64| y0 + d * (1.0 - ((x - hw) / hw).powi(2));
|
||||
let slope = -2.0 * d * (xa - hw) / (hw * hw);
|
||||
b.q((xa + xb) / 2.0, f(xa) + slope * (xb - xa) / 2.0, xb, f(xb));
|
||||
}
|
||||
|
||||
/// A ribbon whose edges sag along one parabola: a front band in the middle and two notched ends
|
||||
/// behind it, joined by shaded folds. Built sagging downwards; `up` mirrors it vertically.
|
||||
fn ellipse_ribbon(up: bool, w: f64, h: f64, a0: f64, a1: f64, a2: f64) -> Geometry {
|
||||
let th = h * a0.clamp(0.0, 100000.0) / 1e5; // band drop at the centre
|
||||
// Sag of every edge: never more than the drop, never so little that the band would rise
|
||||
// above the ends by more than half their height.
|
||||
let d = (h * a2.max(0.0) / 1e5).max(th - (h - th) / 2.0).clamp(0.0, th);
|
||||
let bw = w * a1.clamp(25000.0, 75000.0) / 1e5;
|
||||
let (x0, x1) = ((w - bw) / 2.0, (w + bw) / 2.0);
|
||||
let ear = w / 8.0;
|
||||
let (xf, xg) = (x0 + ear, x1 - ear);
|
||||
let e = h - th; // band height
|
||||
let off = th - d; // band top below the ends' top
|
||||
let t = |x: f64| {
|
||||
let hw = (w / 2.0).max(1e-9);
|
||||
d * (1.0 - ((x - hw) / hw).powi(2))
|
||||
};
|
||||
let mut ends = Pb::new();
|
||||
ends.m(0.0, 0.0);
|
||||
sag(&mut ends, w, d, 0.0, 0.0, xf);
|
||||
ends.l(xf, t(xf) + off).l(x0, t(x0) + off).l(x0, t(x0) + e);
|
||||
sag(&mut ends, w, d, e, x0, 0.0);
|
||||
ends.l(ear, t(ear) + e / 2.0).z();
|
||||
ends.m(w, 0.0).l(w - ear, t(w - ear) + e / 2.0).l(w, e);
|
||||
sag(&mut ends, w, d, e, w, x1);
|
||||
ends.l(x1, t(x1) + off).l(xg, t(xg) + off).l(xg, t(xg));
|
||||
sag(&mut ends, w, d, 0.0, xg, w);
|
||||
ends.z();
|
||||
let mut folds = Pb::new();
|
||||
folds.poly(&[(x0, t(x0) + off), (xf, t(xf)), (xf, t(xf) + off)]);
|
||||
folds.poly(&[(x1, t(x1) + off), (xg, t(xg)), (xg, t(xg) + off)]);
|
||||
let mut band = Pb::new();
|
||||
band.m(x0, t(x0) + off);
|
||||
sag(&mut band, w, d, off, x0, x1);
|
||||
band.l(x1, t(x1) + off + e);
|
||||
sag(&mut band, w, d, off + e, x1, x0);
|
||||
band.z();
|
||||
let mut paths = vec![fill(ends.take()), shade(folds.take(), FillMode::DarkenLess), fill(band.take())];
|
||||
let mut text = Rect::new(x0, th, x1, t(x0) + off + e);
|
||||
if up {
|
||||
let m = kurbo::Affine::new([1.0, 0.0, 0.0, -1.0, 0.0, h]);
|
||||
for p in &mut paths {
|
||||
p.path.apply_affine(m);
|
||||
}
|
||||
text = m.transform_rect_bbox(text);
|
||||
}
|
||||
Geometry { paths, text_rect: text, handles: vec![], sites: mid_sites(w, h) }
|
||||
}
|
||||
|
||||
/// A sweeping arrow rising from the bottom-left corner. The band's two edges are quadratic curves
|
||||
/// from the corner; the head's base leans slightly forward and reaches one eighth of the shorter
|
||||
/// side above and below the band. The tilt and the tip's lift were fitted to the reference look.
|
||||
fn swoosh(w: f64, h: f64, a0: f64, a1: f64) -> Geometry {
|
||||
const TILT: f64 = 0.1126; // tan of the head base's lean from vertical
|
||||
const LIFT: f64 = 0.051; // tip height above the band's centre, per unit of height
|
||||
let ss = w.min(h);
|
||||
let e = ss / 8.0;
|
||||
let th = (h * a0.max(0.0) / 1e5).min((h - 2.0 * e).max(0.0));
|
||||
// The head is at least long enough to keep its leaning base inside the frame.
|
||||
let hl = (ss * a1.max(0.0) / 1e5).max((e + th) * TILT).min((w - e * TILT).max(0.0));
|
||||
let qx = w - hl;
|
||||
let mut b = Pb::new();
|
||||
b.m(0.0, h)
|
||||
.q(w / 6.0, h / 3.0, qx, e)
|
||||
.l(qx - e * TILT, 0.0)
|
||||
.l(w, (e + th / 2.0 - LIFT * h).clamp(0.0, 2.0 * e + th))
|
||||
.l((qx + (e + th) * TILT).min(w), 2.0 * e + th)
|
||||
.l((qx + th * TILT).min(w), e + th)
|
||||
.q(w / 4.0, (th + h / 12.0 + e).min(h), 0.0, h)
|
||||
.z();
|
||||
simple(b.take(), Rect::new(0.0, 0.0, w, h), w, h)
|
||||
}
|
||||
|
||||
/// A band that sweeps around half an ellipse and ends in an arrow head. Built pointing right
|
||||
/// (`curvedRightArrow`) in a `cw`×`ch` frame, then turned for the other directions.
|
||||
///
|
||||
/// Both halves of the band hang off one ellipse touching the far side: its centre sits on the
|
||||
/// head side's edge, its horizontal radius is the full length, and the band has a constant
|
||||
/// vertical thickness. The back half (shaded) starts flat against the head side; the front half
|
||||
/// runs to the head, centred on the band where it ends.
|
||||
fn curved_arrow(name: &str, w: f64, h: f64, a0: f64, a1: f64, a2: f64) -> Geometry {
|
||||
let along_x = matches!(name, "curvedRightArrow" | "curvedLeftArrow");
|
||||
let (cw, ch) = if along_x { (w, h) } else { (h, w) };
|
||||
let ss = cw.min(ch);
|
||||
let head = (ss * a1.max(0.0) / 1e5).min(ch / 2.0);
|
||||
let th = (ss * a0.max(0.0) / 1e5).min(head);
|
||||
let hl = (ss * a2.max(0.0) / 1e5).min(cw);
|
||||
let hh = head / 2.0;
|
||||
// The band's centre line, carried on to the head side, ends at the tip, which sits half a
|
||||
// head width above the bottom.
|
||||
let r = ((ch - hh - th / 2.0) / 2.0).max(0.0);
|
||||
// Parametric angle where the front band reaches the head base.
|
||||
let te = if cw > 0.0 { (-(hl / cw)).clamp(-1.0, 1.0).acos().to_degrees() } else { 90.0 };
|
||||
let mut back = Pb::new();
|
||||
back.m(cw, 0.0).arc(cw, r, 270.0, -90.0).l(0.0, r + th).arc(cw, r, 180.0, 90.0).z();
|
||||
let mut front = Pb::new();
|
||||
front.m(0.0, r).arc(cw, r, 180.0, te - 180.0);
|
||||
let yb = front.cur.y;
|
||||
let yc = yb + th / 2.0;
|
||||
front.l(cw - hl, yc - hh).l(cw, 2.0 * r + th / 2.0).l(cw - hl, yc + hh).l(cw - hl, yb + th).arc(cw, r, te, 180.0 - te).z();
|
||||
let m = match name {
|
||||
"curvedLeftArrow" => kurbo::Affine::new([-1.0, 0.0, 0.0, 1.0, w, 0.0]),
|
||||
"curvedUpArrow" => kurbo::Affine::new([0.0, -1.0, 1.0, 0.0, 0.0, h]),
|
||||
"curvedDownArrow" => kurbo::Affine::new([0.0, 1.0, 1.0, 0.0, 0.0, 0.0]),
|
||||
_ => kurbo::Affine::IDENTITY,
|
||||
};
|
||||
let (mut back, mut front) = (back.take(), front.take());
|
||||
back.apply_affine(m);
|
||||
front.apply_affine(m);
|
||||
Geometry {
|
||||
paths: vec![shade(back, FillMode::DarkenLess), fill(front)],
|
||||
text_rect: Rect::new(0.0, 0.0, w, h),
|
||||
handles: vec![],
|
||||
sites: mid_sites(w, h),
|
||||
}
|
||||
}
|
||||
|
||||
/// A rectangle with a callout leader through `pts` points (`(y, x)` adjust pairs in 1/100 000 of
|
||||
/// the height and width), optionally with an accent bar at the first point's x and a border.
|
||||
fn line_callout(w: f64, h: f64, a: &dyn Fn(usize) -> f64, pts: usize, accent: bool, border: bool) -> Geometry {
|
||||
let body = corner_rect(w, h, [Corner::Square; 4]);
|
||||
// Leaders may reach well outside the box, but not without bound.
|
||||
let pt = |i: usize| (w * a(2 * i + 1).clamp(-1e7, 1e7) / 1e5, h * a(2 * i).clamp(-1e7, 1e7) / 1e5);
|
||||
let mut l = Pb::new();
|
||||
let (x0, y0) = pt(0);
|
||||
l.m(x0, y0);
|
||||
for i in 1..pts {
|
||||
let (x, y) = pt(i);
|
||||
l.l(x, y);
|
||||
}
|
||||
let mut paths = vec![if border { fill(body) } else { fill_only(body) }];
|
||||
if accent {
|
||||
paths.push(stroke_only(Pb::new().m(x0, 0.0).l(x0, h).take()));
|
||||
}
|
||||
paths.push(stroke_only(l.take()));
|
||||
Geometry { paths, text_rect: Rect::new(0.0, 0.0, w, h), handles: vec![], sites: mid_sites(w, h) }
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::super::{CATALOG, FillMode, build, info};
|
||||
use kurbo::{BezPath, PathEl, Point, Shape};
|
||||
|
||||
const NEW: [&str; 38] = [
|
||||
"lineInv",
|
||||
"nonIsoscelesTrapezoid",
|
||||
"pieWedge",
|
||||
"leftRightArrowCallout",
|
||||
"upDownArrowCallout",
|
||||
"quadArrowCallout",
|
||||
"circularArrow",
|
||||
"leftCircularArrow",
|
||||
"leftRightCircularArrow",
|
||||
"curvedRightArrow",
|
||||
"curvedLeftArrow",
|
||||
"curvedUpArrow",
|
||||
"curvedDownArrow",
|
||||
"swooshArrow",
|
||||
"callout1",
|
||||
"callout2",
|
||||
"callout3",
|
||||
"accentCallout1",
|
||||
"accentCallout2",
|
||||
"accentCallout3",
|
||||
"borderCallout2",
|
||||
"borderCallout3",
|
||||
"accentBorderCallout1",
|
||||
"accentBorderCallout2",
|
||||
"accentBorderCallout3",
|
||||
"ellipseRibbon",
|
||||
"ellipseRibbon2",
|
||||
"leftRightRibbon",
|
||||
"flowChartOfflineStorage",
|
||||
"gear6",
|
||||
"gear9",
|
||||
"funnel",
|
||||
"cornerTabs",
|
||||
"squareTabs",
|
||||
"plaqueTabs",
|
||||
"chartX",
|
||||
"chartStar",
|
||||
"chartPlus",
|
||||
];
|
||||
|
||||
fn outline(name: &str, w: f64, h: f64, adj: &[f64]) -> BezPath {
|
||||
build(name, w, h, adj).map(|g| g.outline()).unwrap_or_default()
|
||||
}
|
||||
|
||||
/// Distance from `p` to the nearest point of the (flattened) outline.
|
||||
fn dist(path: &BezPath, p: Point) -> f64 {
|
||||
let mut best = f64::MAX;
|
||||
let mut prev = Point::ZERO;
|
||||
let mut start = Point::ZERO;
|
||||
kurbo::flatten(path.iter(), 0.01, |el| {
|
||||
let (a, b) = match el {
|
||||
PathEl::MoveTo(q) => {
|
||||
prev = q;
|
||||
start = q;
|
||||
return;
|
||||
}
|
||||
PathEl::LineTo(q) => (prev, q),
|
||||
PathEl::ClosePath => (prev, start),
|
||||
_ => return,
|
||||
};
|
||||
let d = b - a;
|
||||
let t = if d.hypot2() > 0.0 { ((p - a).dot(d) / d.hypot2()).clamp(0.0, 1.0) } else { 0.0 };
|
||||
best = best.min((a + d * t - p).hypot());
|
||||
prev = b;
|
||||
});
|
||||
best
|
||||
}
|
||||
|
||||
/// Asserts every point lies within 1pt of the outline.
|
||||
fn on(name: &str, w: f64, h: f64, adj: &[f64], pts: &[(f64, f64)]) {
|
||||
let path = outline(name, w, h, adj);
|
||||
for &(x, y) in pts {
|
||||
let d = dist(&path, Point::new(x, y));
|
||||
assert!(d < 1.0, "{name} {w}x{h} {adj:?}: ({x}, {y}) is {d:.2} from the outline");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn new_presets_are_in_the_catalog() {
|
||||
for n in NEW {
|
||||
let i = info(n).unwrap_or_else(|| panic!("{n} missing from the catalog"));
|
||||
assert!(!i.label.is_empty());
|
||||
}
|
||||
assert!(CATALOG.len() >= 183);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn new_presets_build_within_bounds_at_many_sizes_and_adjusts() {
|
||||
let sizes = [(480.0, 300.0), (300.0, 300.0), (200.0, 460.0), (100.0, 460.0), (1.0, 1.0), (0.0, 0.0), (0.0, 50.0), (60.0, 0.0)];
|
||||
let adjusts: [&[f64]; 8] = [
|
||||
&[],
|
||||
&[0.0; 8],
|
||||
&[100000.0; 8],
|
||||
&[-50000.0; 8],
|
||||
&[1e12, -1e12, 1e12, -1e12, 1e12, -1e12, 1e12, -1e12],
|
||||
&[f64::MAX, f64::MIN, f64::MAX, f64::MIN, f64::MAX, f64::MIN, f64::MAX, f64::MIN],
|
||||
&[f64::NAN, f64::INFINITY, f64::NEG_INFINITY, f64::NAN, 5.0, 6.0, 7.0, 8.0],
|
||||
&[30000.0, 60000.0, 20000.0, 9000000.0, 20000.0, 40000.0, 120000.0, -30000.0],
|
||||
];
|
||||
for n in NEW {
|
||||
// Line callouts' leaders may reach anywhere, by design.
|
||||
let callout = n.contains("allout") && !n.contains("Arrow");
|
||||
for (w, h) in sizes {
|
||||
for adj in adjusts {
|
||||
let g = build(n, w, h, adj).unwrap_or_else(|| panic!("{n} did not build"));
|
||||
assert!(!g.paths.is_empty(), "{n} has no paths");
|
||||
for s in &g.paths {
|
||||
let bb = s.path.bounding_box();
|
||||
assert!(bb.x0.is_finite() && bb.y0.is_finite() && bb.x1.is_finite() && bb.y1.is_finite(), "{n} {w}x{h} {adj:?}: {bb:?}");
|
||||
if !callout {
|
||||
// Circular arrows with a head longer than their ring can hold carry the
|
||||
// inner edge on from the head, as the reference does, so may spill.
|
||||
let spill = if n.contains("ircular") { 0.5 } else { 0.01 };
|
||||
let tol = 0.5 + w.max(h) * spill;
|
||||
assert!(
|
||||
bb.x0 >= -tol && bb.y0 >= -tol && bb.x1 <= w + tol && bb.y1 <= h + tol,
|
||||
"{n} {w}x{h} {adj:?} out of bounds: {bb:?}"
|
||||
);
|
||||
}
|
||||
}
|
||||
let t = g.text_rect;
|
||||
assert!(t.x0.is_finite() && t.y0.is_finite() && t.x1.is_finite() && t.y1.is_finite(), "{n} text rect {t:?}");
|
||||
}
|
||||
}
|
||||
let g = build(n, 480.0, 300.0, &[]).unwrap_or_else(|| panic!("{n}"));
|
||||
assert!(g.outline().elements().len() >= 2, "{n} default outline is empty");
|
||||
}
|
||||
}
|
||||
|
||||
// The spot checks below are outline points measured on reference renders.
|
||||
|
||||
#[test]
|
||||
fn simple_new_presets_match_reference_points() {
|
||||
on("lineInv", 480.0, 300.0, &[], &[(0.0, 300.0), (480.0, 0.0)]);
|
||||
on("nonIsoscelesTrapezoid", 480.0, 300.0, &[], &[(75.0, 0.0), (405.0, 0.0), (0.0, 300.0)]);
|
||||
on("nonIsoscelesTrapezoid", 200.0, 460.0, &[80000.0, 20000.0], &[(100.0, 0.0), (160.0, 0.0)]);
|
||||
on("pieWedge", 480.0, 300.0, &[], &[(64.3, 150.0), (0.0, 300.0), (480.0, 0.0)]);
|
||||
on("flowChartOfflineStorage", 480.0, 300.0, &[], &[(240.0, 300.0), (192.0, 240.0), (288.0, 240.0)]);
|
||||
on("squareTabs", 480.0, 300.0, &[], &[(28.3, 28.3), (451.7, 271.7)]);
|
||||
on("cornerTabs", 480.0, 300.0, &[], &[(23.3, 5.0)]);
|
||||
on("plaqueTabs", 480.0, 300.0, &[], &[(27.85, 5.0)]);
|
||||
on("chartStar", 480.0, 300.0, &[], &[(240.0, 0.0), (240.0, 300.0), (48.0, 30.0)]);
|
||||
on("chartPlus", 480.0, 300.0, &[], &[(0.0, 150.0), (240.0, 0.0)]);
|
||||
// Chart markers and plain callouts leave the box unstroked.
|
||||
for n in ["chartX", "callout1", "accentCallout2"] {
|
||||
let g = build(n, 100.0, 100.0, &[]).unwrap_or_else(|| panic!("{n}"));
|
||||
assert!(!g.paths[0].stroke, "{n}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn line_callouts_follow_their_adjusts() {
|
||||
on("callout3", 480.0, 300.0, &[], &[(-40.0, 56.25), (-80.0, 56.25), (-80.0, 300.0), (-40.0, 338.9)]);
|
||||
let adj = [50000.0, 110000.0, 20000.0, 120000.0, -20000.0, 80000.0, 30000.0, 40000.0];
|
||||
let g = build("accentBorderCallout3", 480.0, 300.0, &adj).unwrap_or_else(|| panic!("accentBorderCallout3"));
|
||||
assert_eq!(g.paths.len(), 3);
|
||||
assert!(g.paths[0].stroke);
|
||||
let accent = g.paths[1].path.bounding_box();
|
||||
assert!((accent.x0 - 528.0).abs() < 1e-6 && accent.y0 == 0.0 && accent.y1 == 300.0, "{accent:?}");
|
||||
on("accentBorderCallout3", 480.0, 300.0, &adj, &[(576.0, 60.0), (384.0, -60.0), (192.0, 90.0)]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn arrow_callouts_match_reference_points() {
|
||||
on("leftRightArrowCallout", 480.0, 300.0, &[], &[(0.0, 150.0), (75.0, 75.0), (124.5, 0.0), (355.5, 300.0), (480.0, 150.0)]);
|
||||
on("leftRightArrowCallout", 200.0, 460.0, &[], &[(50.0, 180.0), (52.0, 0.0), (148.0, 460.0)]);
|
||||
on("upDownArrowCallout", 480.0, 300.0, &[], &[(240.0, 0.0), (0.0, 77.8), (480.0, 222.2), (240.0, 300.0)]);
|
||||
on("quadArrowCallout", 480.0, 300.0, &[], &[(0.0, 150.0), (124.5, 77.8), (240.0, 0.0), (480.0, 150.0), (240.0, 300.0)]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn curved_arrows_match_reference_points() {
|
||||
on(
|
||||
"curvedRightArrow",
|
||||
480.0,
|
||||
300.0,
|
||||
&[],
|
||||
&[(480.0, 0.0), (480.0, 75.0), (480.0, 225.0), (405.0, 149.0), (405.0, 299.0), (100.0, 151.5), (300.0, 6.7)],
|
||||
);
|
||||
on("curvedRightArrow", 200.0, 460.0, &[30000.0, 60000.0, 40000.0], &[(200.0, 400.0), (120.0, 324.5), (120.0, 443.5), (200.0, 60.0)]);
|
||||
// The band never outgrows the head; the head never outgrows half the frame.
|
||||
on("curvedRightArrow", 200.0, 460.0, &[60000.0, 30000.0, 80000.0], &[(200.0, 60.0)]);
|
||||
on("curvedLeftArrow", 480.0, 300.0, &[], &[(0.0, 225.0), (0.0, 0.0)]);
|
||||
on("curvedUpArrow", 480.0, 300.0, &[], &[(405.0, 0.0), (0.0, 0.0), (75.0, 0.0)]);
|
||||
on("curvedDownArrow", 480.0, 300.0, &[], &[(405.0, 300.0), (0.0, 300.0)]);
|
||||
let g = build("curvedRightArrow", 480.0, 300.0, &[]).unwrap_or_else(|| panic!("curvedRightArrow"));
|
||||
assert_eq!(g.paths[0].fill, FillMode::DarkenLess);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn swoosh_matches_reference_points() {
|
||||
on("swooshArrow", 480.0, 300.0, &[], &[(0.0, 300.0), (425.8, 0.0), (480.0, 59.7), (442.8, 150.0), (202.0, 105.5), (202.0, 159.0)]);
|
||||
on("swooshArrow", 480.0, 300.0, &[40000.0, 16667.0], &[(480.0, 82.2), (447.8, 195.0)]);
|
||||
on("swooshArrow", 200.0, 460.0, &[], &[(163.9, 0.0), (200.0, 59.4)]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ribbons_match_reference_points() {
|
||||
on(
|
||||
"ellipseRibbon",
|
||||
480.0,
|
||||
300.0,
|
||||
&[],
|
||||
&[(0.0, 0.0), (120.0, 28.1), (60.0, 128.9), (240.0, 300.0), (120.0, 66.1), (180.0, 72.2), (180.0, 35.2)],
|
||||
);
|
||||
on("ellipseRibbon", 480.0, 300.0, &[30000.0, 60000.0, 20000.0], &[(120.0, 45.0), (240.0, 300.0), (96.0, 68.4)]);
|
||||
on("ellipseRibbon", 480.0, 300.0, &[80000.0, 20000.0, 60000.0], &[(240.0, 240.0), (1.0, 61.75)]);
|
||||
on("ellipseRibbon2", 480.0, 300.0, &[], &[(0.0, 300.0), (240.0, 0.0)]);
|
||||
on(
|
||||
"leftRightRibbon",
|
||||
480.0,
|
||||
300.0,
|
||||
&[],
|
||||
&[(0.0, 125.0), (150.0, 0.0), (150.0, 50.0), (255.0, 62.5), (225.0, 87.5), (480.0, 175.0), (330.0, 300.0)],
|
||||
);
|
||||
on("leftRightRibbon", 480.0, 300.0, &[90000.0, 10000.0, 60000.0], &[(0.0, 100.0), (480.0, 200.0), (240.0, 300.0)]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn gears_and_funnel_match_reference_points() {
|
||||
// Square gear6: body radius 105, top tooth tip 3.5 inside the frame, tip half-width ~16.3.
|
||||
on("gear6", 300.0, 300.0, &[], &[(150.0, 3.5), (133.7, 3.5), (166.3, 3.5), (45.0, 150.0)]);
|
||||
on("gear9", 300.0, 300.0, &[], &[(150.0, 1.0), (30.0, 150.0)]);
|
||||
on("gear6", 480.0, 300.0, &[], &[(240.0, 3.5), (201.0, 3.5)]);
|
||||
on("funnel", 480.0, 300.0, &[], &[(240.0, 0.0), (0.0, 75.0), (240.0, 15.0), (15.0, 75.0), (240.0, 300.0), (60.5, 150.0)]);
|
||||
let g = build("funnel", 480.0, 300.0, &[]).unwrap_or_else(|| panic!("funnel"));
|
||||
assert!(g.paths[0].even_odd);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn circular_arrows_match_reference_points() {
|
||||
on("circularArrow", 300.0, 300.0, &[], &[(19.0, 150.0), (56.5, 150.0), (150.0, 19.0), (262.4, 150.0), (218.6, 113.4), (293.6, 113.4)]);
|
||||
on(
|
||||
"circularArrow",
|
||||
300.0,
|
||||
300.0,
|
||||
&[20000.0, 1800000.0, 18000000.0, 5400000.0, 20000.0],
|
||||
&[(150.0, 270.0), (150.0, 210.0), (247.0, 42.1), (143.0, 102.1), (227.9, 105.0)],
|
||||
);
|
||||
on("leftCircularArrow", 300.0, 300.0, &[], &[(37.6, 150.0), (262.4, 150.0), (150.0, 281.0)]);
|
||||
on("leftRightCircularArrow", 300.0, 300.0, &[], &[(262.4, 150.0), (37.6, 150.0), (150.0, 19.0)]);
|
||||
// The band never grows past twice the head's half-width.
|
||||
on("circularArrow", 300.0, 300.0, &[25000.0, 1142319.0, 20457681.0, 10800000.0, 5000.0], &[(0.0, 150.0), (30.0, 150.0)]);
|
||||
}
|
||||
}
|
||||
@@ -1,375 +0,0 @@
|
||||
use super::builder::{Corner, Pb, corner_rect, fill, mid_sites, shade, simple, stroke_only, tip_handle};
|
||||
use super::catalog::{FillMode, Geometry};
|
||||
use super::{Point, Rect};
|
||||
|
||||
pub(super) fn wedge_rect(w: f64, h: f64, a0: f64, a1: f64, r: f64) -> Geometry {
|
||||
let tip = Point::new(w / 2.0 + w * a0 / 1e5, h / 2.0 + h * a1 / 1e5);
|
||||
let inside = tip.x > 0.0 && tip.x < w && tip.y > 0.0 && tip.y < h;
|
||||
let (dx, dy) = ((tip.x - w / 2.0) / w.max(1e-9), (tip.y - h / 2.0) / h.max(1e-9));
|
||||
let mut b = Pb::new();
|
||||
let r = r.min(w / 2.0).min(h / 2.0);
|
||||
// Walk clockwise from the top-left; insert the wedge on the edge facing the tip.
|
||||
let horiz = dx.abs() > dy.abs();
|
||||
// The wedge's base: 2..5 twelfths of the edge on the tip's side of the centre when it is
|
||||
// before it, 7..10 twelfths when after (presetShapeDefinitions' xg1/xg2, yg1/yg2).
|
||||
let (bx0, bx1) = if tip.x < w / 2.0 { (w * 2.0 / 12.0, w * 5.0 / 12.0) } else { (w * 7.0 / 12.0, w * 10.0 / 12.0) };
|
||||
let (by0, by1) = if tip.y < h / 2.0 { (h * 2.0 / 12.0, h * 5.0 / 12.0) } else { (h * 7.0 / 12.0, h * 10.0 / 12.0) };
|
||||
b.m(r, 0.0);
|
||||
if !inside && !horiz && dy < 0.0 {
|
||||
b.l(bx0, 0.0).l(tip.x, tip.y).l(bx1, 0.0);
|
||||
}
|
||||
b.l(w - r, 0.0);
|
||||
if r > 0.0 {
|
||||
b.arc(r, r, 270.0, 90.0);
|
||||
}
|
||||
if !inside && horiz && dx > 0.0 {
|
||||
b.l(w, by0).l(tip.x, tip.y).l(w, by1);
|
||||
}
|
||||
b.l(w, h - r);
|
||||
if r > 0.0 {
|
||||
b.arc(r, r, 0.0, 90.0);
|
||||
}
|
||||
if !inside && !horiz && dy > 0.0 {
|
||||
b.l(bx1, h).l(tip.x, tip.y).l(bx0, h);
|
||||
}
|
||||
b.l(r, h);
|
||||
if r > 0.0 {
|
||||
b.arc(r, r, 90.0, 90.0);
|
||||
}
|
||||
if !inside && horiz && dx < 0.0 {
|
||||
b.l(0.0, by1).l(tip.x, tip.y).l(0.0, by0);
|
||||
}
|
||||
b.l(0.0, r);
|
||||
if r > 0.0 {
|
||||
b.arc(r, r, 180.0, 90.0);
|
||||
}
|
||||
b.z();
|
||||
let mut g = simple(b.take(), Rect::new(0.0, 0.0, w, h).inset(-r * 0.29289), w, h);
|
||||
g.handles.push(tip_handle(w, h, tip));
|
||||
g
|
||||
}
|
||||
|
||||
/// ECMA-376 cloud outline arcs (radii in 43200ths of the box, angles in 60000ths of a degree,
|
||||
/// as DrawingML `arcTo` takes them), from the start point (3900, 14370).
|
||||
const CLOUD_ARCS: [(f64, f64, f64, f64); 11] = [
|
||||
(6753.0, 9190.0, -11429249.0, 7426832.0),
|
||||
(5333.0, 7267.0, -8646143.0, 5396714.0),
|
||||
(4365.0, 5945.0, -8748475.0, 5983381.0),
|
||||
(4857.0, 6595.0, -7859164.0, 7034504.0),
|
||||
(5333.0, 7273.0, -4722533.0, 6541615.0),
|
||||
(6775.0, 9220.0, -2776035.0, 7816140.0),
|
||||
(5785.0, 7867.0, 37501.0, 6842000.0),
|
||||
(6752.0, 9215.0, 1347096.0, 6910353.0),
|
||||
(7720.0, 10543.0, 3974558.0, 4542661.0),
|
||||
(4360.0, 5918.0, -16496525.0, 8804134.0),
|
||||
(4345.0, 5945.0, -14809710.0, 9151131.0),
|
||||
];
|
||||
|
||||
/// The cloud's creases: short arcs inside the outline, each from its own start point.
|
||||
const CLOUD_CREASES: [(f64, f64, f64, f64, f64, f64); 11] = [
|
||||
(4693.0, 26177.0, 4345.0, 5945.0, 5204520.0, 1585770.0),
|
||||
(6928.0, 34899.0, 4360.0, 5918.0, 4416628.0, 686848.0),
|
||||
(16478.0, 39090.0, 6752.0, 9215.0, 8257449.0, 844866.0),
|
||||
(28827.0, 34751.0, 6752.0, 9215.0, 387196.0, 959901.0),
|
||||
(34129.0, 22954.0, 5785.0, 7867.0, -4217541.0, 4255042.0),
|
||||
(41798.0, 15354.0, 5333.0, 7273.0, 1819082.0, 1665090.0),
|
||||
(38324.0, 5426.0, 4857.0, 6595.0, -824660.0, 891534.0),
|
||||
(29078.0, 3952.0, 4857.0, 6595.0, -8950887.0, 1091722.0),
|
||||
(22141.0, 4720.0, 4365.0, 5945.0, -9809656.0, 1061181.0),
|
||||
(14000.0, 5192.0, 6753.0, 9190.0, -4002417.0, 739161.0),
|
||||
(4127.0, 15789.0, 6753.0, 9190.0, 9459261.0, 711490.0),
|
||||
];
|
||||
|
||||
pub(super) fn cloud(name: &str, w: f64, h: f64, a0: f64, a1: f64) -> Geometry {
|
||||
// Drawn in the path's own 43200-unit square, then stretched to the box (as DrawingML lays out
|
||||
// a path with its own w and h), so the arcs keep their shape's proportions at any aspect.
|
||||
let to_box = kurbo::Affine::scale_non_uniform(w / 43200.0, h / 43200.0);
|
||||
let deg = |v: f64| v / 60000.0;
|
||||
let mut b = Pb::new();
|
||||
b.m(3900.0, 14370.0);
|
||||
for (wr, hr, st, sw) in CLOUD_ARCS {
|
||||
b.arc_spec(wr, hr, deg(st), deg(sw));
|
||||
}
|
||||
b.z();
|
||||
let mut creases = Pb::new();
|
||||
for (x, y, wr, hr, st, sw) in CLOUD_CREASES {
|
||||
creases.m(x, y).arc_spec(wr, hr, deg(st), deg(sw));
|
||||
}
|
||||
let mut outline = b.take();
|
||||
outline.apply_affine(to_box);
|
||||
let mut paths = vec![fill(outline)];
|
||||
if name == "cloud" {
|
||||
let mut c = creases.take();
|
||||
c.apply_affine(to_box);
|
||||
paths.push(stroke_only(c));
|
||||
}
|
||||
let text_rect = Rect::new(w * 2977.0 / 21600.0, h * 3262.0 / 21600.0, w * 17087.0 / 21600.0, h * 17337.0 / 21600.0);
|
||||
let mut handles = vec![];
|
||||
if name == "cloudCallout" {
|
||||
let tip = Point::new(w / 2.0 + w * a0 / 1e5, h / 2.0 + h * a1 / 1e5);
|
||||
let c = Point::new(w / 2.0, h / 2.0);
|
||||
let mut bubbles = Pb::new();
|
||||
for (k, r) in [(0.55, 0.06), (0.75, 0.045), (0.95, 0.03)] {
|
||||
let p = c + (tip - c) * k;
|
||||
if !(p.x > w * 0.1 && p.x < w * 0.9 && p.y > h * 0.1 && p.y < h * 0.9) || k > 0.9 {
|
||||
bubbles.ellipse(p.x, p.y, w * r, h * r);
|
||||
}
|
||||
}
|
||||
paths.push(fill(bubbles.take()));
|
||||
handles.push(tip_handle(w, h, tip));
|
||||
}
|
||||
Geometry { paths, text_rect, handles, sites: mid_sites(w, h) }
|
||||
}
|
||||
|
||||
/// The equation shapes, by ECMA-376's formulas (checked against PowerPoint's outlines at several
|
||||
/// sizes and adjust values). Their bars span 73.49% of the width; the plus and multiply bars are
|
||||
/// `adj1` of the shorter side thick, the others' `adj1` of the height.
|
||||
pub(super) fn math(name: &str, w: f64, h: f64, a0: f64, a1: f64, a2: f64) -> Geometry {
|
||||
let pin = |lo: f64, v: f64, hi: f64| v.max(lo).min(hi.max(lo));
|
||||
let ss = w.min(h);
|
||||
let (hc, vc) = (w / 2.0, h / 2.0);
|
||||
let dx1 = w * 73490.0 / 200000.0;
|
||||
let (x1, x2) = (hc - dx1, hc + dx1);
|
||||
let mut b = Pb::new();
|
||||
let text = match name {
|
||||
"mathPlus" => {
|
||||
let a = pin(0.0, a0, 73490.0);
|
||||
let dy1 = h * 73490.0 / 200000.0;
|
||||
let dx2 = ss * a / 200000.0;
|
||||
let (y1, y2, y3, y4) = (vc - dy1, vc - dx2, vc + dx2, vc + dy1);
|
||||
let (xa, xb) = (hc - dx2, hc + dx2);
|
||||
b.poly(&[(x1, y2), (xa, y2), (xa, y1), (xb, y1), (xb, y2), (x2, y2), (x2, y3), (xb, y3), (xb, y4), (xa, y4), (xa, y3), (x1, y3)]);
|
||||
Rect::new(x1, y2, x2, y3)
|
||||
}
|
||||
"mathMinus" => {
|
||||
let dy1 = h * pin(0.0, a0, 100000.0) / 200000.0;
|
||||
b.poly(&[(x1, vc - dy1), (x2, vc - dy1), (x2, vc + dy1), (x1, vc + dy1)]);
|
||||
Rect::new(x1, vc - dy1, x2, vc + dy1)
|
||||
}
|
||||
"mathEqual" => {
|
||||
let a = pin(0.0, a0, 36745.0);
|
||||
let g = pin(0.0, a1, 100000.0 - 2.0 * a);
|
||||
let (dy1, dy2) = (h * a / 100000.0, h * g / 200000.0);
|
||||
let (y2, y3) = (vc - dy2, vc + dy2);
|
||||
let (y1, y4) = (y2 - dy1, y3 + dy1);
|
||||
b.poly(&[(x1, y1), (x2, y1), (x2, y2), (x1, y2)]);
|
||||
b.poly(&[(x1, y3), (x2, y3), (x2, y4), (x1, y4)]);
|
||||
Rect::new(x1, y1, x2, y4)
|
||||
}
|
||||
"mathNotEqual" => {
|
||||
let a = pin(0.0, a0, 50000.0);
|
||||
let cr_ang = pin(4200000.0, a1, 6600000.0);
|
||||
let g = pin(0.0, a2, 100000.0 - 2.0 * a);
|
||||
let (dy1, dy2) = (h * a / 100000.0, h * g / 200000.0);
|
||||
let hd2 = (h / 2.0).max(1e-9);
|
||||
let (y2, y3) = (vc - dy2, vc + dy2);
|
||||
let (y1, y4) = (y2 - dy1, y3 + dy1);
|
||||
let cadj2 = cr_ang - 5400000.0;
|
||||
let xadj2 = hd2 * (cadj2 / 60000.0).to_radians().tan();
|
||||
let len = xadj2.hypot(hd2);
|
||||
let bhw = len * dy1 / hd2;
|
||||
let x7 = hc + xadj2 - bhw / 2.0;
|
||||
let at = |y: f64| x7 - xadj2 * y / hd2;
|
||||
let (x6, x5, x4, x3) = (at(y1), at(y2), at(y3), at(y4));
|
||||
let rx7 = x7 + bhw;
|
||||
let dx7 = dy1 * hd2 / len;
|
||||
let dy3 = dy1 * xadj2 / len;
|
||||
let (rx, lx, ry, ly) = if cadj2 > 0.0 { (x7 + dx7, x7, dy3, 0.0) } else { (rx7, rx7 - dx7, 0.0, -dy3) };
|
||||
b.poly(&[
|
||||
(x1, y1),
|
||||
(x6, y1),
|
||||
(lx, ly),
|
||||
(rx, ry),
|
||||
(x6 + bhw, y1),
|
||||
(x2, y1),
|
||||
(x2, y2),
|
||||
(x5 + bhw, y2),
|
||||
(x4 + bhw, y3),
|
||||
(x2, y3),
|
||||
(x2, y4),
|
||||
(x3 + bhw, y4),
|
||||
(w - lx, h - ly),
|
||||
(w - rx, h - ry),
|
||||
(x3, y4),
|
||||
(x1, y4),
|
||||
(x1, y3),
|
||||
(x4, y3),
|
||||
(x5, y2),
|
||||
(x1, y2),
|
||||
]);
|
||||
Rect::new(x1, y1, x2, y4)
|
||||
}
|
||||
"mathDivide" => {
|
||||
let a = pin(1000.0, a0, 36745.0);
|
||||
let max3 = ((73490.0 - a) / 4.0).min(36745.0 * w / h.max(1e-9));
|
||||
let r3 = pin(1000.0, a2, max3);
|
||||
let g = pin(0.0, a1, 73490.0 - 4.0 * r3 - a);
|
||||
let dy1 = h * a / 200000.0;
|
||||
let yg = h * g / 100000.0;
|
||||
let rad = h * r3 / 100000.0;
|
||||
let (y3, y4) = (vc - dy1, vc + dy1);
|
||||
let y2 = y3 - (yg + rad);
|
||||
let y1 = y2 - rad;
|
||||
b.ellipse(hc, y1 + rad, rad, rad);
|
||||
b.ellipse(hc, h - y1 - rad, rad, rad);
|
||||
b.poly(&[(x1, y3), (x2, y3), (x2, y4), (x1, y4)]);
|
||||
Rect::new(x1, y3, x2, y4)
|
||||
}
|
||||
_ => {
|
||||
// mathMultiply: an X whose arms run along the box's diagonals.
|
||||
let th = ss * pin(0.0, a0, 51965.0) / 100000.0;
|
||||
let ang = h.atan2(w);
|
||||
let (sa, ca, ta) = (ang.sin(), ang.cos(), ang.tan().max(1e-9));
|
||||
let lm = w.hypot(h) * (1.0 - 51965.0 / 100000.0);
|
||||
let (xm, ym) = (ca * lm / 2.0, sa * lm / 2.0);
|
||||
let (dxam, dyam) = (sa * th / 2.0, ca * th / 2.0);
|
||||
let (xa, ya, xb, yb) = (xm - dxam, ym + dyam, xm + dxam, ym - dyam);
|
||||
let yc = (hc - xb) * ta + yb;
|
||||
let (xd, xe) = (w - xb, w - xa);
|
||||
let xfe = (vc - ya) / ta;
|
||||
let (xf, xl) = (xe - xfe, xa + xfe);
|
||||
let (yg, yh, yi) = (h - ya, h - yb, h - yc);
|
||||
b.poly(&[(xa, ya), (xb, yb), (hc, yc), (xd, yb), (xe, ya), (xf, vc), (xe, yg), (xd, yh), (hc, yi), (xb, yh), (xa, yg), (xl, vc)]);
|
||||
Rect::new(xa, yb, xe, yh)
|
||||
}
|
||||
};
|
||||
Geometry { paths: vec![fill(b.take())], text_rect: text, handles: vec![], sites: mid_sites(w, h) }
|
||||
}
|
||||
|
||||
pub(super) fn ribbon(up: bool, w: f64, h: f64, a0: f64, a1: f64) -> Geometry {
|
||||
let fold = h * a0.clamp(0.0, 33333.0) / 1e5;
|
||||
let cw = w * a1.clamp(25000.0, 75000.0) / 1e5; // centre band width
|
||||
let x0 = (w - cw) / 2.0;
|
||||
let x1 = w - x0;
|
||||
let ear = w / 8.0;
|
||||
let (top, bot) = (0.0, h);
|
||||
let mut b = Pb::new();
|
||||
let mut shade_p = Pb::new();
|
||||
if up {
|
||||
// centre band sits high; ends hang low.
|
||||
b.poly(&[(x0, top), (x1, top), (x1, bot - fold), (x0, bot - fold)]);
|
||||
let mut ends = Pb::new();
|
||||
ends.poly(&[(0.0, fold), (x0 + ear * 0.5, fold), (x0 + ear * 0.5, bot), (0.0, bot), (ear, (fold + bot) / 2.0)]);
|
||||
ends.poly(&[(w, fold), (x1 - ear * 0.5, fold), (x1 - ear * 0.5, bot), (w, bot), (w - ear, (fold + bot) / 2.0)]);
|
||||
shade_p.poly(&[(x0, bot - fold), (x0 + ear * 0.5, bot - fold), (x0 + ear * 0.5, bot)]);
|
||||
shade_p.poly(&[(x1, bot - fold), (x1 - ear * 0.5, bot - fold), (x1 - ear * 0.5, bot)]);
|
||||
let text = Rect::new(x0, top, x1, bot - fold);
|
||||
return Geometry {
|
||||
paths: vec![fill(ends.take()), shade(shade_p.take(), FillMode::DarkenLess), fill(b.take())],
|
||||
text_rect: text,
|
||||
handles: vec![],
|
||||
sites: mid_sites(w, h),
|
||||
};
|
||||
}
|
||||
b.poly(&[(x0, top + fold), (x1, top + fold), (x1, bot), (x0, bot)]);
|
||||
let mut ends = Pb::new();
|
||||
ends.poly(&[(0.0, top), (x0 + ear * 0.5, top), (x0 + ear * 0.5, bot - fold), (0.0, bot - fold), (ear, (bot - fold) / 2.0)]);
|
||||
ends.poly(&[(w, top), (x1 - ear * 0.5, top), (x1 - ear * 0.5, bot - fold), (w, bot - fold), (w - ear, (bot - fold) / 2.0)]);
|
||||
shade_p.poly(&[(x0, top + fold), (x0 + ear * 0.5, top + fold), (x0 + ear * 0.5, top)]);
|
||||
shade_p.poly(&[(x1, top + fold), (x1 - ear * 0.5, top + fold), (x1 - ear * 0.5, top)]);
|
||||
let text = Rect::new(x0, top + fold, x1, bot);
|
||||
Geometry {
|
||||
paths: vec![fill(ends.take()), shade(shade_p.take(), FillMode::DarkenLess), fill(b.take())],
|
||||
text_rect: text,
|
||||
handles: vec![],
|
||||
sites: mid_sites(w, h),
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn scroll(vertical: bool, w: f64, h: f64, a0: f64) -> Geometry {
|
||||
let ss = w.min(h);
|
||||
let r = ss * a0.clamp(0.0, 25000.0) / 1e5 / 2.0;
|
||||
let mut b = Pb::new();
|
||||
let mut curl = Pb::new();
|
||||
if vertical {
|
||||
b.poly(&[(r, r * 2.0), (w - r, r * 2.0), (w - r, h - r), (r, h - r)]);
|
||||
b.ellipse(w / 2.0, r, w / 2.0 - r * 0.0, r);
|
||||
curl.ellipse(r, h - r, r, r);
|
||||
curl.ellipse(w - r * 2.0, r, r * 0.5, r * 0.5);
|
||||
let text = Rect::new(r, r * 2.0, w - r, h - r);
|
||||
return Geometry {
|
||||
paths: vec![fill(b.take()), shade(curl.take(), FillMode::DarkenLess)],
|
||||
text_rect: text,
|
||||
handles: vec![],
|
||||
sites: mid_sites(w, h),
|
||||
};
|
||||
}
|
||||
b.poly(&[(r * 2.0, r), (w - r, r), (w - r, h - r), (r * 2.0, h - r)]);
|
||||
b.ellipse(r, h / 2.0, r, h / 2.0);
|
||||
curl.ellipse(w - r, r, r, r);
|
||||
curl.ellipse(r, h - r * 2.0, r * 0.5, r * 0.5);
|
||||
let text = Rect::new(r * 2.0, r, w - r, h - r);
|
||||
Geometry { paths: vec![fill(b.take()), shade(curl.take(), FillMode::DarkenLess)], text_rect: text, handles: vec![], sites: mid_sites(w, h) }
|
||||
}
|
||||
|
||||
pub(super) fn action_button(name: &str, w: f64, h: f64) -> Geometry {
|
||||
let body = corner_rect(w, h, [Corner::Square; 4]);
|
||||
let ss = w.min(h);
|
||||
let (cx, cy) = (w / 2.0, h / 2.0);
|
||||
let s = ss * 0.3;
|
||||
let mut g = Pb::new();
|
||||
match name {
|
||||
"actionButtonBackPrevious" => {
|
||||
g.poly(&[(cx + s, cy - s), (cx + s, cy + s), (cx - s, cy)]);
|
||||
}
|
||||
"actionButtonForwardNext" => {
|
||||
g.poly(&[(cx - s, cy - s), (cx - s, cy + s), (cx + s, cy)]);
|
||||
}
|
||||
"actionButtonBeginning" => {
|
||||
g.poly(&[(cx + s, cy - s), (cx + s, cy + s), (cx - s * 0.6, cy)]);
|
||||
g.poly(&[(cx - s, cy - s), (cx - s * 0.7, cy - s), (cx - s * 0.7, cy + s), (cx - s, cy + s)]);
|
||||
}
|
||||
"actionButtonEnd" => {
|
||||
g.poly(&[(cx - s, cy - s), (cx - s, cy + s), (cx + s * 0.6, cy)]);
|
||||
g.poly(&[(cx + s * 0.7, cy - s), (cx + s, cy - s), (cx + s, cy + s), (cx + s * 0.7, cy + s)]);
|
||||
}
|
||||
"actionButtonHome" => {
|
||||
g.poly(&[
|
||||
(cx, cy - s),
|
||||
(cx + s, cy),
|
||||
(cx + s * 0.7, cy),
|
||||
(cx + s * 0.7, cy + s),
|
||||
(cx - s * 0.7, cy + s),
|
||||
(cx - s * 0.7, cy),
|
||||
(cx - s, cy),
|
||||
]);
|
||||
}
|
||||
"actionButtonInformation" | "actionButtonHelp" => {
|
||||
g.ellipse(cx, cy, s, s);
|
||||
}
|
||||
"actionButtonReturn" => {
|
||||
g.m(cx + s, cy - s * 0.6).l(cx + s, cy + s * 0.2).q(cx + s, cy + s * 0.8, cx + s * 0.4, cy + s * 0.8).l(cx - s * 0.5, cy + s * 0.8);
|
||||
g.l(cx - s * 0.5, cy + s * 0.4)
|
||||
.l(cx - s, cy + s * 0.9)
|
||||
.l(cx - s * 0.5, cy + s * 1.4)
|
||||
.l(cx - s * 0.5, cy + s)
|
||||
.l(cx + s * 0.6, cy + s)
|
||||
.l(cx + s * 0.6, cy - s * 0.6)
|
||||
.z();
|
||||
}
|
||||
"actionButtonMovie" => {
|
||||
g.poly(&[(cx - s, cy - s * 0.6), (cx + s * 0.4, cy - s * 0.6), (cx + s * 0.4, cy + s * 0.6), (cx - s, cy + s * 0.6)]);
|
||||
g.poly(&[(cx + s * 0.4, cy), (cx + s, cy - s * 0.5), (cx + s, cy + s * 0.5)]);
|
||||
}
|
||||
"actionButtonDocument" => {
|
||||
g.poly(&[(cx - s * 0.7, cy - s), (cx + s * 0.3, cy - s), (cx + s * 0.7, cy - s * 0.6), (cx + s * 0.7, cy + s), (cx - s * 0.7, cy + s)]);
|
||||
}
|
||||
"actionButtonSound" => {
|
||||
g.poly(&[
|
||||
(cx - s, cy - s * 0.35),
|
||||
(cx - s * 0.5, cy - s * 0.35),
|
||||
(cx, cy - s),
|
||||
(cx, cy + s),
|
||||
(cx - s * 0.5, cy + s * 0.35),
|
||||
(cx - s, cy + s * 0.35),
|
||||
]);
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
Geometry {
|
||||
paths: vec![fill(body), shade(g.take(), FillMode::DarkenLess)],
|
||||
text_rect: Rect::new(0.0, 0.0, w, h),
|
||||
handles: vec![],
|
||||
sites: mid_sites(w, h),
|
||||
}
|
||||
}
|
||||
@@ -1,420 +0,0 @@
|
||||
use super::*;
|
||||
use kurbo::Shape;
|
||||
|
||||
#[test]
|
||||
fn every_catalog_preset_builds_within_bounds() {
|
||||
for p in CATALOG {
|
||||
for (w, h) in [(200.0, 100.0), (100.0, 200.0), (50.0, 50.0), (0.0, 0.0), (1.0, 300.0)] {
|
||||
let g = build(p.name, w, h, &[]).unwrap_or_else(|| panic!("{} did not build", p.name));
|
||||
assert!(!g.paths.is_empty(), "{} has no paths", p.name);
|
||||
for s in &g.paths {
|
||||
let bb = s.path.bounding_box();
|
||||
if w > 0.0 && h > 0.0 && !p.name.contains("Connector") && !p.name.contains("allout") {
|
||||
let tol = w.max(h) * 0.35 + 1.0;
|
||||
assert!(bb.x0 >= -tol && bb.y0 >= -tol && bb.x1 <= w + tol && bb.y1 <= h + tol, "{} {w}x{h} out of bounds: {bb:?}", p.name);
|
||||
}
|
||||
assert!(bb.x0.is_finite() && bb.y1.is_finite(), "{} produced non-finite geometry", p.name);
|
||||
}
|
||||
assert!(g.text_rect.x0.is_finite() && g.text_rect.y1.is_finite(), "{}", p.name);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hostile_adjust_values_never_panic() {
|
||||
for p in CATALOG {
|
||||
for v in [f64::NAN, f64::INFINITY, -1e12, 1e12, -1.0, 0.0] {
|
||||
let adj = vec![v; 6];
|
||||
let g = build(p.name, 120.0, 80.0, &adj);
|
||||
assert!(g.is_some(), "{}", p.name);
|
||||
}
|
||||
}
|
||||
assert!(build("rect", f64::NAN, 10.0, &[]).is_none());
|
||||
assert!(build("noSuchShape", 10.0, 10.0, &[]).is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn catalog_names_are_unique() {
|
||||
let mut names: Vec<&str> = CATALOG.iter().map(|p| p.name).collect();
|
||||
names.sort_unstable();
|
||||
let n = names.len();
|
||||
names.dedup();
|
||||
assert_eq!(n, names.len());
|
||||
assert!(n >= 140, "catalog has {n} presets");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn round_rect_handle_maps_back() {
|
||||
let g = build("roundRect", 200.0, 100.0, &[16667.0]).unwrap();
|
||||
let h = g.handles.first().unwrap();
|
||||
assert!((h.value_at(h.pos) - 16667.0).abs() <= 1.0);
|
||||
assert_eq!(h.value_at(Point::new(-50.0, 0.0)), 0.0);
|
||||
assert_eq!(h.value_at(Point::new(500.0, 0.0)), 50000.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn partial_circle_angle_handles_map_back() {
|
||||
// Start 0° sits at the right of the ellipse, end 270° at its top.
|
||||
for name in ["pie", "chord", "arc"] {
|
||||
let g = build(name, 200.0, 100.0, &[0.0, 16200000.0]).unwrap();
|
||||
assert_eq!(g.handles.iter().map(|h| h.index).collect::<Vec<_>>(), vec![0, 1], "{name}");
|
||||
let (s, e) = (&g.handles[0], &g.handles[1]);
|
||||
assert!((s.pos - Point::new(200.0, 50.0)).hypot() < 1e-6, "{name} {:?}", s.pos);
|
||||
assert!((e.pos - Point::new(100.0, 0.0)).hypot() < 1e-6, "{name} {:?}", e.pos);
|
||||
assert_eq!(s.value_at(s.pos), 0.0, "{name}");
|
||||
assert_eq!(e.value_at(e.pos), 16200000.0, "{name}");
|
||||
// Dragging to the bottom of the ellipse gives 90°.
|
||||
assert_eq!(s.value_at(Point::new(100.0, 100.0)), 5400000.0, "{name}");
|
||||
// Off-axis angles on a non-square ellipse: the visual 45° ray meets the 200×100
|
||||
// ellipse at offset (√2000, √2000) from the centre.
|
||||
let k = 2000f64.sqrt();
|
||||
let g = build(name, 200.0, 100.0, &[2700000.0, 8100000.0]).unwrap();
|
||||
let (s, e) = (&g.handles[0], &g.handles[1]);
|
||||
assert!((s.pos - Point::new(100.0 + k, 50.0 + k)).hypot() < 1e-6, "{name} {:?}", s.pos);
|
||||
assert!((e.pos - Point::new(100.0 - k, 50.0 + k)).hypot() < 1e-6, "{name} {:?}", e.pos);
|
||||
for (deg, h) in [(45.0, s), (135.0, e)] {
|
||||
let on = ((h.pos.x - 100.0) / 100.0).powi(2) + ((h.pos.y - 50.0) / 50.0).powi(2);
|
||||
assert!((on - 1.0).abs() < 1e-9, "{name} {deg}° off ellipse: {:?}", h.pos);
|
||||
assert!((h.value_at(h.pos) - deg * 60000.0).abs() <= 1.0, "{name} {deg}°: {}", h.value_at(h.pos));
|
||||
}
|
||||
}
|
||||
for deg in [45.0, 135.0, 200.0, 315.0] {
|
||||
let g = build("blockArc", 200.0, 100.0, &[deg * 60000.0, 0.0, 25000.0]).unwrap();
|
||||
let start = g.handles.iter().find(|h| h.index == 0).unwrap();
|
||||
// Thickness 25 → the handle runs on the 87.5×37.5 mid-ring ellipse.
|
||||
let on = ((start.pos.x - 100.0) / 87.5).powi(2) + ((start.pos.y - 50.0) / 37.5).powi(2);
|
||||
assert!((on - 1.0).abs() < 1e-9, "blockArc {deg}° off ring: {:?}", start.pos);
|
||||
let d = start.pos - Point::new(100.0, 50.0);
|
||||
assert!((d.y.atan2(d.x).to_degrees().rem_euclid(360.0) - deg).abs() < 1e-6, "blockArc {deg}°: {:?}", start.pos);
|
||||
assert!((start.value_at(start.pos) - deg * 60000.0).abs() <= 1.0, "blockArc {deg}°");
|
||||
}
|
||||
let g = build("blockArc", 200.0, 100.0, &[10800000.0, 0.0, 25000.0]).unwrap();
|
||||
let start = g.handles.iter().find(|h| h.index == 0).unwrap();
|
||||
assert_eq!(start.value_at(start.pos), 10800000.0);
|
||||
let thick = g.handles.iter().find(|h| h.index == 2).unwrap();
|
||||
assert!((thick.value_at(thick.pos) - 25000.0).abs() <= 1.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn presets_with_adjust_values_expose_handles() {
|
||||
// Presets whose adjust values have no handle of their own yet.
|
||||
const NO_HANDLES: &[&str] = &[
|
||||
"curvedConnector3",
|
||||
"snip2SameRect",
|
||||
"snip2DiagRect",
|
||||
"snipRoundRect",
|
||||
"round1Rect",
|
||||
"round2SameRect",
|
||||
"round2DiagRect",
|
||||
"teardrop",
|
||||
"halfFrame",
|
||||
"corner",
|
||||
"diagStripe",
|
||||
"foldedCorner",
|
||||
"smileyFace",
|
||||
"moon",
|
||||
"gear6",
|
||||
"gear9",
|
||||
"bracketPair",
|
||||
"bracePair",
|
||||
"leftBracket",
|
||||
"rightBracket",
|
||||
"leftBrace",
|
||||
"rightBrace",
|
||||
"leftRightArrow",
|
||||
"upDownArrow",
|
||||
"quadArrow",
|
||||
"leftRightUpArrow",
|
||||
"bentArrow",
|
||||
"uturnArrow",
|
||||
"curvedRightArrow",
|
||||
"curvedLeftArrow",
|
||||
"curvedUpArrow",
|
||||
"curvedDownArrow",
|
||||
"leftUpArrow",
|
||||
"bentUpArrow",
|
||||
"circularArrow",
|
||||
"leftCircularArrow",
|
||||
"leftRightCircularArrow",
|
||||
"swooshArrow",
|
||||
"rightArrowCallout",
|
||||
"downArrowCallout",
|
||||
"leftArrowCallout",
|
||||
"upArrowCallout",
|
||||
"leftRightArrowCallout",
|
||||
"upDownArrowCallout",
|
||||
"quadArrowCallout",
|
||||
"mathPlus",
|
||||
"mathMinus",
|
||||
"mathMultiply",
|
||||
"mathDivide",
|
||||
"mathEqual",
|
||||
"mathNotEqual",
|
||||
"ribbon2",
|
||||
"ribbon",
|
||||
"ellipseRibbon2",
|
||||
"ellipseRibbon",
|
||||
"leftRightRibbon",
|
||||
"verticalScroll",
|
||||
"horizontalScroll",
|
||||
"wave",
|
||||
"doubleWave",
|
||||
"borderCallout1",
|
||||
"borderCallout2",
|
||||
"borderCallout3",
|
||||
"accentCallout1",
|
||||
"accentCallout2",
|
||||
"accentCallout3",
|
||||
"callout1",
|
||||
"callout2",
|
||||
"callout3",
|
||||
"accentBorderCallout1",
|
||||
"accentBorderCallout2",
|
||||
"accentBorderCallout3",
|
||||
];
|
||||
for p in CATALOG {
|
||||
if p.defaults.is_empty() || NO_HANDLES.contains(&p.name) {
|
||||
continue;
|
||||
}
|
||||
let g = build(p.name, 200.0, 100.0, &[]).unwrap();
|
||||
assert!(!g.handles.is_empty(), "{} has adjust values but no handles", p.name);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rect_area_and_ellipse_area() {
|
||||
let g = build("rect", 100.0, 50.0, &[]).unwrap();
|
||||
assert!((g.paths[0].path.area().abs() - 5000.0).abs() < 1e-6);
|
||||
let e = build("ellipse", 100.0, 50.0, &[]).unwrap();
|
||||
let expect = std::f64::consts::PI * 50.0 * 25.0;
|
||||
assert!((e.paths[0].path.area().abs() - expect).abs() / expect < 0.01);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn lines_are_open() {
|
||||
assert!(build("line", 10.0, 10.0, &[]).unwrap().is_open());
|
||||
assert!(!build("rect", 10.0, 10.0, &[]).unwrap().is_open());
|
||||
}
|
||||
|
||||
fn on_path(g: &Geometry, p: Point, tol: f64) -> bool {
|
||||
use kurbo::ParamCurveNearest;
|
||||
g.paths.iter().any(|sp| sp.path.segments().any(|seg| seg.nearest(p, 1e-6).distance_sq <= tol * tol))
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fixed_shapes_follow_the_standards_coordinates() {
|
||||
// Points of ECMA-376's definitions (in 21600ths), checked on a 216 × 108 box.
|
||||
let (w, h) = (216.0, 108.0);
|
||||
let at = |x: f64, y: f64| Point::new(w * x / 21600.0, h * y / 21600.0);
|
||||
let g = build("lightningBolt", w, h, &[]).unwrap();
|
||||
for (x, y) in [(8472.0, 0.0), (16577.0, 12007.0), (21600.0, 21600.0), (0.0, 3890.0)] {
|
||||
assert!(on_path(&g, at(x, y), 1e-6), "lightningBolt ({x}, {y})");
|
||||
}
|
||||
let g = build("irregularSeal1", w, h, &[]).unwrap();
|
||||
assert!(on_path(&g, at(14522.0, 0.0), 1e-6) && on_path(&g, at(8485.0, 21600.0), 1e-6));
|
||||
let g = build("irregularSeal2", w, h, &[]).unwrap();
|
||||
assert!(on_path(&g, at(14790.0, 0.0), 1e-6) && on_path(&g, at(4917.0, 21600.0), 1e-6));
|
||||
// The heart's point is the middle of the bottom edge, its notch a quarter down.
|
||||
let g = build("heart", w, h, &[]).unwrap();
|
||||
assert!(on_path(&g, Point::new(w / 2.0, h), 1e-6) && on_path(&g, Point::new(w / 2.0, h / 4.0), 1e-6));
|
||||
let g = build("flowChartDocument", w, h, &[]).unwrap();
|
||||
assert!(on_path(&g, at(21600.0, 17322.0), 1e-6) && on_path(&g, at(0.0, 20172.0), 1e-6));
|
||||
// Punched tape: the top edge dips to a fifth of the height a quarter of the way along.
|
||||
let g = build("flowChartPunchedTape", w, h, &[]).unwrap();
|
||||
assert!(on_path(&g, Point::new(w / 4.0, h / 5.0), 1e-3) && on_path(&g, Point::new(w * 0.75, 0.0), 1e-3));
|
||||
let g = build("flowChartMultidocument", w, h, &[]).unwrap();
|
||||
assert!(on_path(&g, at(2972.0, 0.0), 1e-6) && on_path(&g, at(18595.0, 18022.0), 1e-6));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn notched_arrow_notch_parallels_the_head() {
|
||||
// presetShapeDefinitions: the notch's point is at x1 = dy1 · dx2 / hd2, so its edges run
|
||||
// parallel to the head's (25 on a 200 × 100 arrow at the default adjusts).
|
||||
for (w, h, adj, x1) in [(200.0, 100.0, [50000.0, 50000.0], 25.0), (300.0, 120.0, [80000.0, 30000.0], 28.8)] {
|
||||
let g = build("notchedRightArrow", w, h, &adj).unwrap();
|
||||
let notch = g.paths[0].path.elements().iter().find_map(|e| match e {
|
||||
kurbo::PathEl::MoveTo(p) | kurbo::PathEl::LineTo(p) if (p.y - h / 2.0).abs() < 1e-9 && p.x < w / 2.0 => Some(*p),
|
||||
_ => None,
|
||||
});
|
||||
assert!(notch.is_some_and(|p| (p.x - x1).abs() < 1e-6), "{w}x{h} {adj:?}: notch at {notch:?}, want x = {x1}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn equation_shapes_match_powerpoints_outlines() {
|
||||
// Corners read off PowerPoint's own outlines of the presets at their default adjusts.
|
||||
let g = build("mathMultiply", 216.0, 216.0, &[]).unwrap();
|
||||
for (x, y) in [(0.32333, 0.15702), (0.5, 0.33369), (0.84298, 0.32333), (0.66631, 0.5), (0.33369, 0.5)] {
|
||||
assert!(on_path(&g, Point::new(216.0 * x, 216.0 * y), 0.01), "multiply ({x}, {y})");
|
||||
}
|
||||
let g = build("mathEqual", 300.0, 120.0, &[]).unwrap();
|
||||
for (x, y) in [(0.13255, 0.5588), (0.86745, 0.794), (0.13255, 0.206), (0.86745, 0.4412)] {
|
||||
assert!(on_path(&g, Point::new(300.0 * x, 120.0 * y), 0.01), "equal ({x}, {y})");
|
||||
}
|
||||
let g = build("mathPlus", 216.0, 216.0, &[]).unwrap();
|
||||
assert!(on_path(&g, Point::new(216.0 * 0.3824, 216.0 * 0.13255), 0.01) && on_path(&g, Point::new(216.0 * 0.86745, 216.0 * 0.6176), 0.01));
|
||||
// A tall "not equal": its slash, leaning at the default 110° from top to bottom, reaches
|
||||
// past the box's sides exactly as far as PowerPoint's (-22.242 to 122.242).
|
||||
let g = build("mathNotEqual", 100.0, 260.0, &[]).unwrap();
|
||||
use kurbo::Shape as _;
|
||||
let bb = g.paths[0].path.bounding_box();
|
||||
assert!((bb.x0 + 22.242).abs() < 0.01 && (bb.x1 - 122.242).abs() < 0.01 && bb.y0.abs() < 1e-6 && (bb.y1 - 260.0).abs() < 1e-6, "{bb:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sun_and_waves_match_powerpoints_outlines() {
|
||||
// Points read off PowerPoint's outlines of the presets (216 pt square, default adjusts).
|
||||
let k = 216.0;
|
||||
let g = build("sun", k, k, &[]).unwrap();
|
||||
for (x, y) in [(0.85352, 0.14644), (0.76161, 0.33987), (0.66013, 0.23839), (0.42825, 0.79823), (0.20177, 0.57175), (0.75, 0.5), (0.5, 0.25)] {
|
||||
assert!(on_path(&g, Point::new(k * x, k * y), 0.02), "sun ({x}, {y})");
|
||||
}
|
||||
let g = build("wave", k, k, &[]).unwrap();
|
||||
for (x, y) in [(0.21875, 0.00484), (1.0, 0.125), (1.0, 0.875), (0.0, 0.875)] {
|
||||
assert!(on_path(&g, Point::new(k * x, k * y), 0.05), "wave ({x}, {y})");
|
||||
}
|
||||
// Shifted: a wave of 300 × 120 with adj (20000, 8000) starts 0.16 of the width in.
|
||||
let g = build("wave", 300.0, 120.0, &[20000.0, 8000.0]).unwrap();
|
||||
for (x, y) in [(0.18375, 0.00774), (0.84, 0.2), (1.0, 0.8), (0.16, 0.8)] {
|
||||
assert!(on_path(&g, Point::new(300.0 * x, 120.0 * y), 0.05), "shifted wave ({x}, {y})");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn star_text_rectangles_follow_the_standard() {
|
||||
// star5 at its default 19098 in a 144 pt square: the inner pentagon, about 0.38 of the
|
||||
// width (PowerPoint wraps "Shape 3" at 18 pt there), from y ≈ 55 to ≈ 110.
|
||||
let g = build("star5", 144.0, 144.0, &[]).unwrap();
|
||||
let t = g.text_rect;
|
||||
assert!((t.width() - 55.0).abs() < 1.0, "{t:?}");
|
||||
assert!((t.y0 - 55.0).abs() < 1.0 && (t.y1 - 110.0).abs() < 1.0, "{t:?}");
|
||||
// star4 at 12500: the square through its inner points' 45° corners.
|
||||
let g = build("star4", 144.0, 144.0, &[]).unwrap();
|
||||
assert!((g.text_rect.width() - 72.0 * 0.25 * 2f64.sqrt()).abs() < 0.5, "{:?}", g.text_rect);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn stars_are_stretched_like_the_standards() {
|
||||
// star5 in a 216 pt square: top point at the top middle, side points at 18 degrees on an
|
||||
// ellipse 5.146% wider and 10.557% taller, centred 10.557% below the middle; its bottom
|
||||
// points reach the box's bottom edge.
|
||||
let k = 216.0;
|
||||
let g = build("star5", k, k, &[]).unwrap();
|
||||
let (rx, ry, cy) = (k / 2.0 * 1.05146, k / 2.0 * 1.10557, k / 2.0 * 1.10557);
|
||||
let a = 18f64.to_radians();
|
||||
assert!(on_path(&g, Point::new(k / 2.0, 0.0), 1e-6));
|
||||
assert!(on_path(&g, Point::new(k / 2.0 + rx * a.cos(), cy - ry * a.sin()), 1e-6));
|
||||
use kurbo::Shape as _;
|
||||
let bb = g.paths[0].path.bounding_box();
|
||||
assert!((bb.x0).abs() < 0.5 && (bb.x1 - k).abs() < 0.5 && (bb.y1 - k).abs() < 0.5, "{bb:?}");
|
||||
// star6 is 15.47% wider than its box's half-width allows (its points touch the sides).
|
||||
let g = build("star6", k, k, &[]).unwrap();
|
||||
let bb = g.paths[0].path.bounding_box();
|
||||
assert!((bb.x0).abs() < 0.5 && (bb.x1 - k).abs() < 0.5, "{bb:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn moon_disk_and_drum_match_powerpoints_outlines() {
|
||||
let k = 216.0;
|
||||
// Moon, default: the inner edge runs through (0.5, 0.5) and (0.625, 0.2266) of the box.
|
||||
let g = build("moon", k, k, &[]).unwrap();
|
||||
for (x, y) in [(0.5, 0.5), (0.626, 0.2266), (0.0, 0.5), (1.0, 0.0)] {
|
||||
assert!(on_path(&g, Point::new(k * x, k * y), 0.5), "moon ({x}, {y})");
|
||||
}
|
||||
// 300 × 120 at 30%: its inner edge reaches 30% of the width in.
|
||||
let g = build("moon", 300.0, 120.0, &[30000.0]).unwrap();
|
||||
assert!(on_path(&g, Point::new(90.0, 60.0), 0.5));
|
||||
// Magnetic disk ends are ellipses h/6 high, drum ends w/6 across.
|
||||
let g = build("flowChartMagneticDisk", k, k, &[]).unwrap();
|
||||
assert!(on_path(&g, Point::new(k, k / 6.0), 0.01) && on_path(&g, Point::new(k / 2.0, k / 3.0), 0.5));
|
||||
let g = build("flowChartMagneticDrum", k, k, &[]).unwrap();
|
||||
assert!(on_path(&g, Point::new(k / 6.0, 0.0), 0.01) && on_path(&g, Point::new(0.0, k / 2.0), 0.01));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_cloud_fills_its_box_at_any_aspect_and_has_creases() {
|
||||
use kurbo::Shape as _;
|
||||
for (w, h) in [(200.0, 200.0), (300.0, 100.0), (60.0, 180.0)] {
|
||||
let g = build("cloud", w, h, &[]).unwrap();
|
||||
let bb = g.paths[0].path.bounding_box();
|
||||
assert!(bb.x0.abs() < w * 0.02 && (bb.x1 - w).abs() < w * 0.02, "{w}×{h}: {bb:?}");
|
||||
assert!(bb.y0.abs() < h * 0.02 && (bb.y1 - h).abs() < h * 0.02, "{w}×{h}: {bb:?}");
|
||||
assert_eq!(g.paths.len(), 2, "outline and creases");
|
||||
assert!(g.paths[1].stroke && g.paths[1].fill == FillMode::None);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn spec_arcs_take_angles_as_directions_from_the_centre() {
|
||||
// A DrawingML arc of a 2:1 ellipse from 45° to 90°: 45° is the direction (1, 1) from the
|
||||
// centre, which on that ellipse is the point (r/√5)·(2, 1)… scaled so it lies on it.
|
||||
let mut b = Pb::new();
|
||||
b.m(0.0, 0.0).arc_spec(200.0, 100.0, 45.0, 45.0);
|
||||
let p = b.take();
|
||||
let end = p.elements().last().and_then(|e| match e {
|
||||
kurbo::PathEl::CurveTo(_, _, q) => Some(*q),
|
||||
_ => None,
|
||||
});
|
||||
// Centre: the start sits at direction 45°, i.e. at (k, k) from it with (k/200)² + (k/100)² = 1.
|
||||
let k = 1.0 / (1.0f64 / 40000.0 + 1.0 / 10000.0).sqrt();
|
||||
let c = Point::new(-k, -k);
|
||||
let q = end.unwrap();
|
||||
assert!((q.x - c.x).abs() < 1e-6 && (q.y - (c.y + 100.0)).abs() < 1e-6, "{q:?} vs centre {c:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn brackets_and_braces_fill_out_to_their_straight_side() {
|
||||
// PowerPoint fills a bracket or brace (when it has a fill) between its curve and the
|
||||
// straight side it opens to; only the curve is outlined.
|
||||
for name in ["leftBracket", "rightBracket", "leftBrace", "rightBrace"] {
|
||||
let g = build(name, 40.0, 100.0, &[]).unwrap();
|
||||
let filled: Vec<_> = g.paths.iter().filter(|p| p.fill != FillMode::None).collect();
|
||||
assert_eq!(filled.len(), 1, "{name}");
|
||||
assert!(!filled[0].stroke, "{name}: the filled area is not outlined");
|
||||
let area = filled[0].path.area().abs();
|
||||
assert!(area > 40.0 * 100.0 * 0.4 && area < 40.0 * 100.0, "{name}: {area}");
|
||||
assert!(g.paths.iter().any(|p| p.stroke && p.fill == FillMode::None), "{name}: the curve is outlined");
|
||||
}
|
||||
}
|
||||
|
||||
/// The end points of a path's move/line elements, in order.
|
||||
fn vertices(p: &BezPath) -> Vec<Point> {
|
||||
p.elements()
|
||||
.iter()
|
||||
.filter_map(|e| match e {
|
||||
kurbo::PathEl::MoveTo(q) | kurbo::PathEl::LineTo(q) => Some(*q),
|
||||
_ => None,
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn wedge_callout_mirrors_with_its_tip() {
|
||||
// A tip below and right of the centre draws the mirror image of the same tip on the left;
|
||||
// the same for a tip right of the centre, above or below it. presetShapeDefinitions puts
|
||||
// the wedge's base at 2..5 twelfths of the edge on the near side of the centre and at
|
||||
// 7..10 twelfths on the far side.
|
||||
let (w, h) = (240.0, 120.0);
|
||||
// Sorted and deduplicated: the outline closes on the corner it starts from, which the
|
||||
// mirror moves to the opposite corner.
|
||||
let sorted = |mut v: Vec<Point>| {
|
||||
v.sort_by(|a, b| a.x.total_cmp(&b.x).then(a.y.total_cmp(&b.y)));
|
||||
v.dedup_by(|a, b| (*a - *b).hypot() < 1e-9);
|
||||
v
|
||||
};
|
||||
for (right, left, flip_x) in [([10000.0, 80000.0], [-10000.0, 80000.0], true), ([80000.0, 10000.0], [80000.0, -10000.0], false)] {
|
||||
let a = vertices(&build("wedgeRectCallout", w, h, &right).unwrap().paths[0].path);
|
||||
let b = vertices(&build("wedgeRectCallout", w, h, &left).unwrap().paths[0].path);
|
||||
let b: Vec<Point> = b.iter().map(|p| if flip_x { Point::new(w - p.x, p.y) } else { Point::new(p.x, h - p.y) }).collect();
|
||||
let (a, b) = (sorted(a), sorted(b));
|
||||
assert_eq!(a.len(), b.len(), "{right:?}: {a:?} vs mirrored {left:?}: {b:?}");
|
||||
for (p, q) in a.iter().zip(&b) {
|
||||
assert!((*p - *q).hypot() < 1e-6, "{right:?}: {a:?}\n is not the mirror of {left:?}: {b:?}");
|
||||
}
|
||||
}
|
||||
// The bottom wedge of a tip right of the centre leaves the edge at 7/12 and 10/12 of the width.
|
||||
let a = vertices(&build("wedgeRectCallout", w, h, &[10000.0, 80000.0]).unwrap().paths[0].path);
|
||||
for x in [w * 7.0 / 12.0, w * 10.0 / 12.0] {
|
||||
assert!(a.iter().any(|p| (p.x - x).abs() < 1e-6 && (p.y - h).abs() < 1e-6), "no wedge corner at ({x}, {h}): {a:?}");
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,338 +0,0 @@
|
||||
use super::{
|
||||
Band, BezPath, CATALOG, Guide, Point, Rect, WarpLine, adjust_count, adjust_defaults, band_of_line, handles, is_follow, is_supported, warp,
|
||||
};
|
||||
|
||||
const W: f64 = 420.0;
|
||||
const H: f64 = 200.0;
|
||||
|
||||
fn rect() -> Rect {
|
||||
Rect::new(0.0, 0.0, W, H)
|
||||
}
|
||||
|
||||
/// One line whose ink box is `ink`.
|
||||
fn one_line(ink: Rect) -> Vec<WarpLine> {
|
||||
vec![WarpLine { ink: Some(ink), extent: (ink.x0, ink.x1), ref_y: ink.y1 }]
|
||||
}
|
||||
|
||||
/// Where the unit-square point (u, v) of a single line's ink box lands, in unit coordinates.
|
||||
fn land(name: &str, adj: &[f64], u: f64, v: f64) -> (f64, f64) {
|
||||
let w = warp(name, adj, rect()).unwrap();
|
||||
let ink = Rect::new(100.0, 50.0, 300.0, 90.0);
|
||||
let lines = one_line(ink);
|
||||
let m = w.mapper(&lines, rect().inset(-5.0));
|
||||
let p = m.map(0, Point::new(ink.x0 + u * ink.width(), ink.y0 + v * ink.height()));
|
||||
(p.x / W, p.y / H)
|
||||
}
|
||||
|
||||
fn close(a: (f64, f64), b: (f64, f64), tol: f64) -> bool {
|
||||
(a.0 - b.0).abs() <= tol && (a.1 - b.1).abs() <= tol
|
||||
}
|
||||
|
||||
#[track_caller]
|
||||
fn corners(name: &str, adj: &[f64], tl: (f64, f64), tr: (f64, f64), bl: (f64, f64), br: (f64, f64)) {
|
||||
for ((u, v), want) in [((0.0, 0.0), tl), ((1.0, 0.0), tr), ((0.0, 1.0), bl), ((1.0, 1.0), br)] {
|
||||
let got = land(name, adj, u, v);
|
||||
assert!(close(got, want, 0.004), "{name} corner ({u},{v}): got {got:?}, want {want:?}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn catalog_is_the_forty_drawn_presets() {
|
||||
assert_eq!(CATALOG.len(), 40);
|
||||
let mut seen = std::collections::BTreeSet::new();
|
||||
for p in CATALOG {
|
||||
assert!(seen.insert(p.id), "duplicate {}", p.id);
|
||||
assert!(!p.label.is_empty(), "{}", p.id);
|
||||
assert!(is_supported(p.id), "{}", p.id);
|
||||
assert_eq!(is_follow(p.id), matches!(p.id, "textArchUp" | "textArchDown" | "textCircle" | "textButton"), "{}", p.id);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn every_preset_builds_finite_guides() {
|
||||
for p in CATALOG {
|
||||
let name = p.id;
|
||||
assert!(is_supported(name), "{name}");
|
||||
let w = warp(name, &[], rect()).unwrap_or_else(|| panic!("{name}"));
|
||||
assert!(!w.bands.is_empty(), "{name}");
|
||||
for b in &w.bands {
|
||||
let l = b.length();
|
||||
assert!(l.is_finite() && l > 10.0, "{name}: band length {l}");
|
||||
}
|
||||
assert_eq!(adjust_count(name), adjust_defaults(name).len());
|
||||
}
|
||||
assert!(warp("textNoShape", &[], rect()).is_none());
|
||||
assert!(warp("bogus", &[], rect()).is_none());
|
||||
assert!(!is_supported("textNoShape"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn straight_presets_put_the_ink_corners_on_their_guides() {
|
||||
corners("textPlain", &[], (0.0, 0.0), (1.0, 0.0), (0.0, 1.0), (1.0, 1.0));
|
||||
// A smaller adjust shears the text: the top edge starts 40 % in, the bottom edge ends 60 % in.
|
||||
corners("textPlain", &[30_000.0], (0.4, 0.0), (1.0, 0.0), (0.0, 1.0), (0.6, 1.0));
|
||||
corners("textStop", &[], (0.0, 0.25), (1.0, 0.25), (0.0, 0.75), (1.0, 0.75));
|
||||
corners("textTriangle", &[], (0.0, 0.5), (1.0, 0.5), (0.0, 1.0), (1.0, 1.0));
|
||||
corners("textTriangleInverted", &[25_000.0], (0.0, 0.0), (1.0, 0.0), (0.0, 0.25), (1.0, 0.25));
|
||||
corners("textChevron", &[], (0.0, 0.25), (1.0, 0.25), (0.0, 1.0), (1.0, 1.0));
|
||||
corners("textChevronInverted", &[], (0.0, 0.0), (1.0, 0.0), (0.0, 0.75), (1.0, 0.75));
|
||||
corners("textFadeRight", &[], (0.0, 0.0), (1.0, 0.33333), (0.0, 1.0), (1.0, 0.66667));
|
||||
corners("textFadeLeft", &[], (0.0, 0.33333), (1.0, 0.0), (0.0, 0.66667), (1.0, 1.0));
|
||||
corners("textFadeUp", &[], (0.33333, 0.0), (0.66667, 0.0), (0.0, 1.0), (1.0, 1.0));
|
||||
corners("textFadeDown", &[], (0.0, 0.0), (1.0, 0.0), (0.33333, 1.0), (0.66667, 1.0));
|
||||
corners("textSlantUp", &[], (0.0, 0.55556), (1.0, 0.0), (0.0, 1.0), (1.0, 0.44444));
|
||||
corners("textSlantDown", &[], (0.0, 0.0), (1.0, 0.55556), (0.0, 0.44444), (1.0, 1.0));
|
||||
corners("textCascadeUp", &[], (0.0, 0.13889), (1.0, 0.0), (0.0, 1.0), (1.0, 0.44444));
|
||||
corners("textCascadeDown", &[], (0.0, 0.0), (1.0, 0.13889), (0.0, 0.44444), (1.0, 1.0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn curved_presets_bend_where_powerpoint_bends_them() {
|
||||
corners("textInflate", &[], (0.0, 0.1875), (1.0, 0.1875), (0.0, 0.8125), (1.0, 0.8125));
|
||||
assert!(close(land("textInflate", &[], 0.5, 0.0), (0.5, 0.0), 0.004));
|
||||
assert!(close(land("textInflate", &[], 0.5, 1.0), (0.5, 1.0), 0.004));
|
||||
corners("textDeflate", &[], (0.0, 0.0), (1.0, 0.0), (0.0, 1.0), (1.0, 1.0));
|
||||
assert!(close(land("textDeflate", &[], 0.5, 0.0), (0.5, 0.1875), 0.004));
|
||||
corners("textInflateBottom", &[], (0.0, 0.0), (1.0, 0.0), (0.0, 0.6), (1.0, 0.6));
|
||||
assert!(close(land("textInflateBottom", &[], 0.5, 1.0), (0.5, 0.8), 0.004));
|
||||
assert!(close(land("textDeflateBottom", &[], 0.5, 1.0), (0.5, 0.5), 0.004));
|
||||
assert!(close(land("textInflateTop", &[], 0.5, 0.0), (0.5, 0.2), 0.004));
|
||||
assert!(close(land("textDeflateTop", &[], 0.5, 0.0), (0.5, 0.5), 0.004));
|
||||
// Cans: half ellipses.
|
||||
corners("textCanUp", &[], (0.0, 0.15), (1.0, 0.15), (0.0, 1.0), (1.0, 1.0));
|
||||
assert!(close(land("textCanUp", &[], 0.5, 0.0), (0.5, 0.0), 0.004));
|
||||
assert!(close(land("textCanUp", &[], 0.5, 1.0), (0.5, 0.85), 0.004));
|
||||
assert!(close(land("textCanDown", &[], 0.5, 0.0), (0.5, 0.14286), 0.004));
|
||||
// Curves and waves.
|
||||
let a = 0.45977;
|
||||
corners("textCurveUp", &[], (0.0, a), (1.0, 0.0), (0.0, 1.0 - 3.0 * a / 8.0), (1.0, 1.0 - 3.0 * a / 8.0));
|
||||
assert!(close(land("textCurveUp", &[], 0.5, 1.0), (0.5, 1.0), 0.004));
|
||||
corners("textCurveDown", &[], (0.0, 0.0), (1.0, a), (0.0, 1.0 - 3.0 * a / 8.0), (1.0, 1.0 - 3.0 * a / 8.0));
|
||||
corners("textWave1", &[], (0.0, 0.125), (1.0, 0.125), (0.0, 0.875), (1.0, 0.875));
|
||||
// Wave 1 rises first: its top is near the box top a quarter of the way along.
|
||||
assert!(land("textWave1", &[], 0.25, 0.0).1 < 0.02);
|
||||
assert!(land("textWave2", &[], 0.25, 0.0).1 > 0.23);
|
||||
// A horizontal shift moves the bottom guide right.
|
||||
corners("textWave1", &[12_500.0, 5_000.0], (0.0, 0.125), (0.9, 0.125), (0.1, 0.875), (1.0, 0.875));
|
||||
assert!(land("textDoubleWave1", &[], 0.125, 0.0).1 < 0.02);
|
||||
assert!(land("textWave4", &[], 0.125, 0.0).1 > 0.1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn arc_presets_follow_ellipses() {
|
||||
// Pour arches: the outer arc from the left end over the top; the inner one is scaled by adj2.
|
||||
corners("textArchUpPour", &[], (0.0, 0.5), (1.0, 0.5), (0.25, 0.5), (0.75, 0.5));
|
||||
assert!(close(land("textArchUpPour", &[], 0.5, 0.0), (0.5, 0.0), 0.004));
|
||||
assert!(close(land("textArchUpPour", &[], 0.5, 1.0), (0.5, 0.25), 0.004));
|
||||
assert!(close(land("textArchUpPour", &[10_800_000.0, 30_000.0], 0.5, 1.0), (0.5, 0.35), 0.004));
|
||||
assert!(close(land("textArchDownPour", &[], 0.5, 0.0), (0.5, 0.625), 0.004));
|
||||
assert!(close(land("textArchDownPour", &[], 0.5, 1.0), (0.5, 1.0), 0.004));
|
||||
// Circle pour: once round from the left; the middle of the text is at the right.
|
||||
assert!(close(land("textCirclePour", &[], 0.5, 0.0), (1.0, 0.5), 0.004));
|
||||
// Rings: the text goes round two stacked ellipses.
|
||||
assert!(close(land("textRingInside", &[], 0.0, 0.0), (0.0, 0.3), 0.004));
|
||||
assert!(close(land("textRingInside", &[], 0.0, 1.0), (0.0, 0.7), 0.004));
|
||||
assert!(close(land("textRingInside", &[], 0.25, 0.0), (0.5, 0.0), 0.01));
|
||||
assert!(close(land("textRingOutside", &[], 0.25, 1.0), (0.5, 1.0), 0.01));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn follow_presets_keep_text_size_and_stack_lines_outwards() {
|
||||
let w = warp("textArchUp", &[], rect()).unwrap();
|
||||
// A 40-wide centred line whose reference height is 80.
|
||||
let line = WarpLine { ink: Some(Rect::new(190.0, 50.0, 230.0, 88.0)), extent: (190.0, 230.0), ref_y: 80.0 };
|
||||
let inner = Rect::new(7.2, 3.6, W - 7.2, H - 3.6);
|
||||
let m = w.mapper(&[line], inner);
|
||||
// The middle of the reference line lands on the top of the ellipse; 10 pt above it lands
|
||||
// 10 pt above the top.
|
||||
let p = m.map(0, Point::new(210.0, 80.0));
|
||||
assert!((p.x - 210.0).abs() < 0.05 && p.y.abs() < 0.05, "{p:?}");
|
||||
let q = m.map(0, Point::new(210.0, 70.0));
|
||||
assert!((q.x - 210.0).abs() < 0.15 && (q.y + 10.0).abs() < 0.05, "{q:?}");
|
||||
// Natural size: 40 pt of text spans about 40 pt of arc.
|
||||
let (a, b) = (m.map(0, Point::new(190.0, 80.0)), m.map(0, Point::new(230.0, 80.0)));
|
||||
assert!(((b - a).hypot() - 40.0).abs() < 0.5);
|
||||
// Left-aligned text starts at the very start of the arc: insets don't shorten it.
|
||||
let left = WarpLine { ink: Some(Rect::new(7.2, 50.0, 47.2, 88.0)), extent: (7.2, 47.2), ref_y: 80.0 };
|
||||
let m = w.mapper(&[left], inner);
|
||||
let p = m.map(0, Point::new(7.2, 80.0));
|
||||
assert!(p.x.abs() < 0.01 && (p.y - 100.0).abs() < 0.01, "{p:?}");
|
||||
// Two lines on an arch up: the last sits on the arc, the first stacks outside it.
|
||||
let l1 = WarpLine { ink: Some(Rect::new(190.0, 10.0, 230.0, 40.0)), extent: (190.0, 230.0), ref_y: 34.0 };
|
||||
let l2 = WarpLine { ink: Some(Rect::new(190.0, 50.0, 230.0, 80.0)), extent: (190.0, 230.0), ref_y: 74.0 };
|
||||
let m = w.mapper(&[l1, l2], inner);
|
||||
assert!(m.map(1, Point::new(210.0, 74.0)).y.abs() < 0.05);
|
||||
assert!((m.map(0, Point::new(210.0, 34.0)).y + 40.0).abs() < 0.05);
|
||||
// Arch down: the first line sits on the bottom of the ellipse.
|
||||
let w = warp("textArchDown", &[], rect()).unwrap();
|
||||
let m = w.mapper(&[l1, l2], inner);
|
||||
assert!((m.map(0, Point::new(210.0, 34.0)).y - H).abs() < 0.05);
|
||||
assert!((m.map(1, Point::new(210.0, 74.0)).y - H - 40.0).abs() < 0.05);
|
||||
// Text longer than the arc is shrunk to fit it.
|
||||
let w = warp("textArchUp", &[], rect()).unwrap();
|
||||
let long = WarpLine { ink: Some(Rect::new(-500.0, 50.0, 900.0, 88.0)), extent: (-500.0, 900.0), ref_y: 80.0 };
|
||||
let m = w.mapper(&[long], inner);
|
||||
let (a, b) = (m.map(0, Point::new(-500.0, 80.0)), m.map(0, Point::new(900.0, 80.0)));
|
||||
assert!(a.x < 5.0 && b.x > W - 5.0 && (a.y - 100.0).abs() < 10.0 && (b.y - 100.0).abs() < 10.0, "{a:?} {b:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn lines_share_bands_in_order() {
|
||||
assert_eq!((0..2).map(|i| band_of_line(i, 2, 2)).collect::<Vec<_>>(), [0, 1]);
|
||||
assert_eq!((0..3).map(|i| band_of_line(i, 3, 2)).collect::<Vec<_>>(), [0, 0, 1]);
|
||||
assert_eq!((0..5).map(|i| band_of_line(i, 5, 2)).collect::<Vec<_>>(), [0, 0, 0, 1, 1]);
|
||||
assert_eq!((0..5).map(|i| band_of_line(i, 5, 3)).collect::<Vec<_>>(), [0, 0, 1, 1, 2]);
|
||||
assert_eq!((0..4).map(|i| band_of_line(i, 4, 3)).collect::<Vec<_>>(), [0, 0, 1, 2]);
|
||||
assert_eq!((0..2).map(|i| band_of_line(i, 2, 3)).collect::<Vec<_>>(), [0, 1]);
|
||||
assert_eq!(band_of_line(0, 1, 3), 0);
|
||||
assert_eq!(band_of_line(7, 9, 1), 0);
|
||||
assert_eq!(band_of_line(0, 0, 3), 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn deflate_inflate_maps_each_band_separately() {
|
||||
let w = warp("textDeflateInflate", &[], rect()).unwrap();
|
||||
assert_eq!(w.bands.len(), 2);
|
||||
let l1 = WarpLine { ink: Some(Rect::new(100.0, 10.0, 300.0, 40.0)), extent: (100.0, 300.0), ref_y: 34.0 };
|
||||
let l2 = WarpLine { ink: Some(Rect::new(100.0, 50.0, 300.0, 80.0)), extent: (100.0, 300.0), ref_y: 74.0 };
|
||||
let m = w.mapper(&[l1, l2], rect());
|
||||
// Band 1 ends at 45 % height on the sides, band 2 starts at 55 %.
|
||||
assert!((m.map(0, Point::new(100.0, 40.0)).y / H - 0.45).abs() < 0.004);
|
||||
assert!((m.map(1, Point::new(100.0, 50.0)).y / H - 0.55).abs() < 0.004);
|
||||
assert!((m.map(1, Point::new(300.0, 80.0)).y / H - 1.0).abs() < 0.004);
|
||||
// A band with fewer lines keeps them at the size of the fuller band, centred in its band:
|
||||
// two lines (ink 10..60) in band 1, one line (ink 70..80) in band 2 of three.
|
||||
let a = WarpLine { ink: Some(Rect::new(100.0, 10.0, 300.0, 30.0)), extent: (100.0, 300.0), ref_y: 28.0 };
|
||||
let b = WarpLine { ink: Some(Rect::new(100.0, 40.0, 300.0, 60.0)), extent: (100.0, 300.0), ref_y: 58.0 };
|
||||
let c = WarpLine { ink: Some(Rect::new(100.0, 70.0, 300.0, 80.0)), extent: (100.0, 300.0), ref_y: 78.0 };
|
||||
let m = w.mapper(&[a, b, c], rect());
|
||||
let (top, bot) = (m.map(2, Point::new(200.0, 70.0)).y / H, m.map(2, Point::new(200.0, 80.0)).y / H);
|
||||
// Band 2 runs from 0.4 to 1 at the centre; the line takes the middle fifth of it.
|
||||
assert!((top - 0.64).abs() < 0.005 && (bot - 0.76).abs() < 0.005, "{top} {bot}");
|
||||
// A shorter first line keeps its share of the width.
|
||||
let short = WarpLine { ink: Some(Rect::new(150.0, 10.0, 250.0, 40.0)), extent: (150.0, 250.0), ref_y: 34.0 };
|
||||
let m = w.mapper(&[short, l2], rect());
|
||||
let p = m.map(0, Point::new(150.0, 10.0));
|
||||
assert!((p.x / W - 0.25).abs() < 0.01, "{p:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn guides_extrapolate_and_wrap() {
|
||||
let mut p = BezPath::new();
|
||||
p.move_to((0.0, 0.0));
|
||||
p.line_to((10.0, 0.0));
|
||||
let g = Guide::from_path(&p, false);
|
||||
assert!((g.length() - 10.0).abs() < 1e-9);
|
||||
assert!((g.at(15.0).0.x - 15.0).abs() < 1e-9);
|
||||
assert!((g.at(-5.0).0.x + 5.0).abs() < 1e-9);
|
||||
assert!(g.at(f64::NAN).0.x.is_finite());
|
||||
let w = warp("textCircle", &[], rect()).unwrap();
|
||||
let Some(Band::Follow { path, .. }) = w.bands.first() else { panic!() };
|
||||
assert!(path.is_closed());
|
||||
let l = path.length();
|
||||
let (a, b) = (path.at(5.0).0, path.at(l + 5.0).0);
|
||||
assert!((a - b).hypot() < 1e-6);
|
||||
let empty = Guide::default();
|
||||
assert_eq!(empty.length(), 0.0);
|
||||
assert!(empty.at(3.0).0.x.is_finite());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hostile_adjusts_and_boxes_stay_finite() {
|
||||
let adjs: &[&[f64]] =
|
||||
&[&[], &[f64::NAN, f64::INFINITY], &[f64::NEG_INFINITY, f64::NAN], &[1e300, -1e300], &[-1e9, 1e9], &[0.0, 0.0], &[21_599_999.0, 100_000.0]];
|
||||
let rects = [
|
||||
Rect::new(0.0, 0.0, 0.0, 0.0),
|
||||
Rect::new(10.0, 10.0, 10.0, 200.0),
|
||||
Rect::new(0.0, 0.0, 300.0, 0.0),
|
||||
Rect::new(100.0, 100.0, -50.0, -20.0),
|
||||
Rect::new(0.0, 0.0, 1e7, 1e7),
|
||||
];
|
||||
let lines = [
|
||||
WarpLine { ink: Some(Rect::new(0.0, 0.0, 0.0, 0.0)), extent: (0.0, 0.0), ref_y: 0.0 },
|
||||
WarpLine { ink: None, extent: (5.0, 5.0), ref_y: 3.0 },
|
||||
WarpLine { ink: Some(Rect::new(-1e6, -5.0, 1e6, 5.0)), extent: (-1e6, 1e6), ref_y: 4.0 },
|
||||
];
|
||||
for name in CATALOG.iter().map(|p| p.id) {
|
||||
for adj in adjs {
|
||||
for r in rects {
|
||||
let Some(w) = warp(name, adj, r) else { panic!("{name} {adj:?} {r:?}") };
|
||||
for b in &w.bands {
|
||||
assert!(b.length().is_finite());
|
||||
}
|
||||
let m = w.mapper(&lines, r);
|
||||
assert!(m.zoom().is_finite() && m.zoom() >= 1.0);
|
||||
let probes = [
|
||||
(0, Point::ZERO),
|
||||
(1, Point::new(5.0, 3.0)),
|
||||
(2, Point::new(1e6, -5.0)),
|
||||
(2, Point::new(f64::NAN, 1.0)),
|
||||
(9, Point::new(1.0, 1.0)),
|
||||
];
|
||||
for (i, p) in probes {
|
||||
let q = m.map(i, p);
|
||||
assert!(q.x.is_finite() || !p.x.is_finite(), "{name} {adj:?} {r:?}: {q:?}");
|
||||
assert!(q.y.is_finite(), "{name} {adj:?} {r:?}: {q:?}");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
assert!(warp("textPlain", &[], Rect::new(f64::NAN, 0.0, 1.0, 1.0)).is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn every_preset_has_one_handle_per_adjust() {
|
||||
let r = rect();
|
||||
for name in CATALOG.iter().map(|p| p.id) {
|
||||
let hs = handles(name, &[], r);
|
||||
assert_eq!(hs.len(), adjust_count(name), "{name}");
|
||||
let defaults = adjust_defaults(name);
|
||||
for h in &hs {
|
||||
assert!(h.pos.x.is_finite() && h.pos.y.is_finite(), "{name}");
|
||||
let back = h.value_at(h.pos);
|
||||
let want = defaults[h.index];
|
||||
assert!((back - want).abs() <= 1.0, "{name} handle {}: {back} vs {want}", h.index);
|
||||
}
|
||||
}
|
||||
assert!(handles("textNoShape", &[], r).is_empty());
|
||||
assert!(handles("textArchUp", &[], Rect::new(0.0, 0.0, f64::NAN, 10.0)).is_empty());
|
||||
assert!(handles("textArchUp", &[], Rect::new(0.0, 0.0, 0.0, 0.0)).is_empty());
|
||||
// A hostile adjust still places a finite handle on the clamped default.
|
||||
let hs = handles("textInflate", &[f64::NAN], r);
|
||||
assert_eq!(hs.len(), 1);
|
||||
assert!(hs[0].pos.x.is_finite() && hs[0].pos.y.is_finite());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn arch_and_inflate_handles_follow_the_pointer() {
|
||||
let r = rect();
|
||||
let arch = &handles("textArchUp", &[], r)[0];
|
||||
let deg = arch.value_at(Point::new(r.center().x, r.y0)) / 60_000.0;
|
||||
assert!((deg - 270.0).abs() < 0.5, "{deg}");
|
||||
let down = &handles("textArchDown", &[], r)[0];
|
||||
// The arch-down handle starts on the left; a pointer at the bottom is 90°, which is adjust 90
|
||||
// (guide angle 180 − adj).
|
||||
let deg = down.value_at(Point::new(r.center().x, r.y1)) / 60_000.0;
|
||||
assert!((deg - 90.0).abs() < 0.5, "{deg}");
|
||||
let inf = &handles("textInflate", &[], r)[0];
|
||||
let more = inf.value_at(Point::new(inf.pos.x, r.y0 - 80.0));
|
||||
assert!(more > adjust_defaults("textInflate")[0], "{more}");
|
||||
assert!((more - 20_000.0).abs() < 1.0, "{more}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn many_lines_on_a_follow_band_are_mapped_from_one_measurement() {
|
||||
// 50,000 lines on an arch: each line's scale and anchor come from the band measured once.
|
||||
let w = warp("textArchUp", &[], rect()).unwrap();
|
||||
let inner = Rect::new(7.2, 3.6, W - 7.2, H - 3.6);
|
||||
let lines: Vec<WarpLine> = (0..50_000)
|
||||
.map(|i| {
|
||||
let y = i as f64 * 0.01;
|
||||
WarpLine { ink: Some(Rect::new(190.0, y, 230.0, y + 1.0)), extent: (190.0, 230.0), ref_y: y + 1.0 }
|
||||
})
|
||||
.collect();
|
||||
let m = w.mapper(&lines, inner);
|
||||
// The last line sits on the arc, as with two lines.
|
||||
let last = lines.len() - 1;
|
||||
assert!(m.map(last, Point::new(210.0, lines[last].ref_y)).y.abs() < 0.05);
|
||||
}
|
||||
@@ -10,8 +10,8 @@
|
||||
/// Cyrillic, CJK…) give `false`. Neutral, weak, and whitespace characters are skipped.
|
||||
pub fn first_strong_is_rtl(text: &str) -> bool {
|
||||
for c in text.chars() {
|
||||
if c == '\u{200F}' {
|
||||
// Right-to-Left Mark (RLM)
|
||||
if c == '\u{200F}' || c == '\u{061C}' {
|
||||
// RLM and ALM are strong RTL controls, although neither is alphabetic.
|
||||
return true;
|
||||
}
|
||||
if c == '\u{200E}' {
|
||||
@@ -76,6 +76,10 @@ mod tests {
|
||||
#[test]
|
||||
fn honours_directional_marks() {
|
||||
assert!(first_strong_is_rtl("\u{200F}Hello"));
|
||||
assert!(first_strong_is_rtl("\u{061C}Hello"));
|
||||
assert!(first_strong_is_rtl("\u{061C}"));
|
||||
assert!(!first_strong_is_rtl("Hello\u{061C}"));
|
||||
assert!(!first_strong_is_rtl("\u{200E}\u{061C}"));
|
||||
assert!(!first_strong_is_rtl("\u{200E}مرحبا"));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -528,6 +528,12 @@ pub fn change_case(s: &str, mode: &str) -> String {
|
||||
/// `title` and `sentence` carry their word/sentence state across piece boundaries. Each output
|
||||
/// piece is the changed form of the matching input piece, even where a character changes length.
|
||||
pub fn change_case_parts(parts: &[&str], mode: &str) -> Vec<String> {
|
||||
if mode == "lower" {
|
||||
let lower = parts.concat().to_lowercase();
|
||||
let mut chars = lower.chars();
|
||||
// Context changes sigma's form, while each character's expansion length stays the same.
|
||||
return parts.iter().map(|s| chars.by_ref().take(s.chars().map(|c| c.to_lowercase().count()).sum()).collect()).collect();
|
||||
}
|
||||
let mut start = true;
|
||||
// All characters of all pieces, so word-final sigma sees neighbours across piece boundaries.
|
||||
let all: Vec<char> = parts.iter().flat_map(|s| s.chars()).collect();
|
||||
@@ -536,7 +542,6 @@ pub fn change_case_parts(parts: &[&str], mode: &str) -> Vec<String> {
|
||||
.iter()
|
||||
.map(|s| match mode {
|
||||
"upper" => s.to_uppercase(),
|
||||
"lower" => s.to_lowercase(),
|
||||
"toggle" => s.chars().map(|c| if c.is_uppercase() { c.to_lowercase().collect::<String>() } else { c.to_uppercase().collect() }).collect(),
|
||||
_ => {
|
||||
// `title` restarts after whitespace, sentence case after sentence punctuation.
|
||||
@@ -593,6 +598,18 @@ mod tests {
|
||||
assert_eq!(change_case_parts(&["ΟΔΟΣ", " ΜΟΥ"], "title"), ["Οδος", " Μου"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn lowercase_keeps_context_and_run_boundaries() {
|
||||
assert_eq!(change_case_parts(&["ΟΔΟ", "Σ"], "lower"), ["οδο", "ς"]);
|
||||
assert_eq!(change_case_parts(&["ΟΣ", "Α"], "lower"), ["οσ", "α"]);
|
||||
assert_eq!(change_case_parts(&["", "ΟΔΟ", "", "Σ", ""], "lower"), ["", "οδο", "", "ς", ""]);
|
||||
assert_eq!(change_case_parts(&["İΟΔΟ", "Σ"], "lower"), ["i\u{307}οδο", "ς"]);
|
||||
assert_eq!(change_case_parts(&["Ο", "\u{301}", "Σ"], "lower"), ["ο", "\u{301}", "ς"]);
|
||||
assert_eq!(change_case_parts(&["ΟΣ", "\u{301}", "Α"], "lower"), ["οσ", "\u{301}", "α"]);
|
||||
assert_eq!(change_case_parts(&["", "", ""], "lower"), ["", "", ""]);
|
||||
assert!(change_case_parts(&[], "lower").is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn insert_and_split() {
|
||||
let mut b = body("Hello");
|
||||
|
||||
@@ -234,16 +234,18 @@ fn sci(toks: &[Tok], v: f64, sep: char, dec: char) -> Option<String> {
|
||||
m *= 10.0;
|
||||
exp -= 1;
|
||||
}
|
||||
// Rounding the mantissa to its digits can reach 10 (9.999 as `0.00`).
|
||||
if format!("{m:.mant_frac$}").starts_with("10") {
|
||||
m /= 10.0;
|
||||
exp += 1;
|
||||
}
|
||||
}
|
||||
let step = mant.iter().take_while(|t| **t != Tok::Dot).filter(|t| matches!(t, Tok::Digit(_))).count().max(1) as i32;
|
||||
let shift = exp.rem_euclid(step);
|
||||
exp -= shift;
|
||||
m *= 10f64.powi(shift);
|
||||
// Round after forming the engineering mantissa: 999.94 as `##0.0` stays 999.9.
|
||||
// Carry only when rounding exceeds all of the format's integer placeholders.
|
||||
let carry = 10f64.powi(step);
|
||||
if format!("{m:.mant_frac$}").parse::<f64>().is_ok_and(|rounded| rounded >= carry) {
|
||||
m /= carry;
|
||||
exp += step;
|
||||
}
|
||||
let mantissa = fixed(mant, mfirst, mlast, m, sep, dec);
|
||||
let sign = if exp < 0 {
|
||||
"-"
|
||||
@@ -404,6 +406,21 @@ mod tests {
|
||||
assert_eq!(format("##0.0E+0", 999.96, None), "1.0E+3");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn engineering_formats_round_the_full_mantissa() {
|
||||
for (code, value, expected) in [
|
||||
("##0.0E+00", 999.94, "999.9E+00"),
|
||||
("##0.0E+00", 0.99994, "999.9E-03"),
|
||||
("##0.0E+00", -999.94, "-999.9E+00"),
|
||||
("#0.0E+00", 99.94, "99.9E+00"),
|
||||
("##0.0E+00", 999.96, "1.0E+03"),
|
||||
("#0.0E+00", 99.96, "1.0E+02"),
|
||||
] {
|
||||
assert_eq!(format(code, value, None), expected, "{code}, {value}");
|
||||
}
|
||||
assert_eq!(format("##0.0E+00", 999.94, Some("de-DE")), "999,9E+00");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn never_panics() {
|
||||
for code in ["", ";", ";;;", "\"", "[", "\\", "0.", ".", "#,", "%", "_", "*", "@", "0E+00", "[$", "\"unterminated"] {
|
||||
|
||||
@@ -69,7 +69,7 @@ impl Default for Theme {
|
||||
fn default() -> Self {
|
||||
builtin_themes().into_iter().next().unwrap_or_else(|| Theme {
|
||||
name: "DeckCraft".into(),
|
||||
colors: ColorScheme { name: "DeckCraft".into(), colors: [Rgba::BLACK; 12] },
|
||||
colors: ColorScheme::new("DeckCraft", [Rgba::BLACK; 12]),
|
||||
fonts: FontScheme::default(),
|
||||
format: FormatScheme::default(),
|
||||
raw_extra: None,
|
||||
@@ -97,7 +97,7 @@ fn hex(s: &str) -> Rgba {
|
||||
}
|
||||
|
||||
fn scheme(name: &str, c: [&str; 12]) -> ColorScheme {
|
||||
ColorScheme { name: name.into(), colors: c.map(hex) }
|
||||
ColorScheme::new(name, c.map(hex))
|
||||
}
|
||||
|
||||
fn ph() -> ColorRef {
|
||||
|
||||
@@ -9,6 +9,10 @@ description = "DeckCraft PPTX: Office Open XML (PresentationML/DrawingML) import
|
||||
workspace = true
|
||||
|
||||
[dependencies]
|
||||
craft-opc.workspace = true
|
||||
craft-xml.workspace = true
|
||||
craft-cfb.workspace = true
|
||||
craft-drawingml.workspace = true
|
||||
deckcraft-model = { workspace = true }
|
||||
deckcraft-geom = { workspace = true }
|
||||
deckcraft-color = { workspace = true }
|
||||
|
||||
+16
-94
@@ -1,103 +1,24 @@
|
||||
//! Just enough of the Compound File Binary (CFB/OLE2) container to tell a password-protected
|
||||
//! presentation apart: PowerPoint wraps an encrypted `.pptx` in a CFB holding `EncryptionInfo`
|
||||
//! and `EncryptedPackage` streams (ECMA-376 / [MS-OFFCRYPTO]) instead of a zip. Every read is
|
||||
//! bounds-checked and every loop bounded. Copied from GridCraft's `crates/xlsx/src/cfb.rs`.
|
||||
|
||||
/// The CFB signature at the start of the file.
|
||||
const SIGNATURE: [u8; 8] = [0xD0, 0xCF, 0x11, 0xE0, 0xA1, 0xB1, 0x1A, 0xE1];
|
||||
|
||||
const END_OF_CHAIN: u32 = 0xFFFF_FFFE;
|
||||
/// Sector ids at or above this are markers (free, end of chain, FAT/DIFAT sector), not sectors.
|
||||
const MAX_REG_SECT: u32 = 0xFFFF_FFFA;
|
||||
/// Directory sectors followed at most (4096 entries with 512-byte sectors).
|
||||
const MAX_DIR_SECTORS: usize = 1024;
|
||||
/// DIFAT sectors followed at most.
|
||||
const MAX_DIFAT_SECTORS: usize = 1024;
|
||||
//! Password-protected presentations. PowerPoint wraps an encrypted `.pptx` in a Compound File
|
||||
//! Binary (CFB/OLE2) container holding `EncryptionInfo` and `EncryptedPackage` streams
|
||||
//! (ECMA-376 / [MS-OFFCRYPTO]) instead of a zip. The container's directory is read by the shared
|
||||
//! `craft-cfb` crate, which bounds every chain and falls back to a UTF-16 name search when a
|
||||
//! damaged file's directory cannot be followed.
|
||||
|
||||
/// Stream names that mark an encrypted (password-protected) OOXML package.
|
||||
const ENCRYPTED_STREAMS: [&str; 2] = ["EncryptedPackage", "EncryptionInfo"];
|
||||
|
||||
fn u16_at(b: &[u8], at: usize) -> Option<u16> {
|
||||
let s = b.get(at..at.checked_add(2)?)?;
|
||||
Some(u16::from_le_bytes([*s.first()?, *s.get(1)?]))
|
||||
/// Directory entries read at most: 1024 directory sectors of 512 bytes, as before the move to
|
||||
/// `craft-cfb`, so a hostile directory chain stays cheap.
|
||||
const MAX_DIR_ENTRIES: usize = 4096;
|
||||
|
||||
fn limits() -> craft_cfb::Limits {
|
||||
craft_cfb::Limits { max_dir_entries: MAX_DIR_ENTRIES, ..craft_cfb::Limits::default() }
|
||||
}
|
||||
|
||||
fn u32_at(b: &[u8], at: usize) -> Option<u32> {
|
||||
let s = b.get(at..at.checked_add(4)?)?;
|
||||
Some(u32::from_le_bytes([*s.first()?, *s.get(1)?, *s.get(2)?, *s.get(3)?]))
|
||||
}
|
||||
|
||||
/// Whether `bytes` is a compound file holding an encryption stream. Walks the directory through
|
||||
/// the FAT; when the structure can't be followed (truncated or malformed), falls back to scanning
|
||||
/// the bytes for the UTF-16LE stream names.
|
||||
/// Whether `bytes` is a compound file holding an encryption stream.
|
||||
pub(crate) fn is_encrypted(bytes: &[u8]) -> bool {
|
||||
if !bytes.starts_with(&SIGNATURE) {
|
||||
return false;
|
||||
}
|
||||
match directory_names(bytes) {
|
||||
Some(names) => names.iter().any(|n| ENCRYPTED_STREAMS.iter().any(|e| n.eq_ignore_ascii_case(e))),
|
||||
None => ENCRYPTED_STREAMS.iter().any(|e| contains_utf16(bytes, e)),
|
||||
}
|
||||
}
|
||||
|
||||
fn contains_utf16(hay: &[u8], needle: &str) -> bool {
|
||||
let n: Vec<u8> = needle.encode_utf16().flat_map(u16::to_le_bytes).collect();
|
||||
!n.is_empty() && hay.windows(n.len()).any(|w| w == n.as_slice())
|
||||
}
|
||||
|
||||
/// Names of every directory entry, or `None` when the directory can't be read.
|
||||
fn directory_names(b: &[u8]) -> Option<Vec<String>> {
|
||||
if !b.starts_with(&SIGNATURE) {
|
||||
return None;
|
||||
}
|
||||
let shift = u16_at(b, 30)?;
|
||||
if shift != 9 && shift != 12 {
|
||||
return None;
|
||||
}
|
||||
let size = 1usize << shift;
|
||||
let per = size / 4;
|
||||
let sector = |id: u32| -> Option<&[u8]> {
|
||||
let start = (id as usize).checked_add(1)?.checked_mul(size)?;
|
||||
b.get(start..start.checked_add(size)?)
|
||||
};
|
||||
// The DIFAT: the FAT's sector ids, 109 in the header then chained DIFAT sectors.
|
||||
let mut difat: Vec<u32> = (0..109).filter_map(|i| u32_at(b, 76 + i * 4)).filter(|&s| s < MAX_REG_SECT).collect();
|
||||
let mut next = u32_at(b, 68)?;
|
||||
for _ in 0..MAX_DIFAT_SECTORS {
|
||||
if next >= MAX_REG_SECT {
|
||||
break;
|
||||
}
|
||||
let s = sector(next)?;
|
||||
difat.extend((0..per - 1).filter_map(|i| u32_at(s, i * 4)).filter(|&x| x < MAX_REG_SECT));
|
||||
next = u32_at(s, (per - 1) * 4)?;
|
||||
}
|
||||
let fat_next = |id: u32| -> Option<u32> {
|
||||
let idx = id as usize;
|
||||
let fat_sector = *difat.get(idx / per)?;
|
||||
u32_at(sector(fat_sector)?, (idx % per) * 4)
|
||||
};
|
||||
let mut names = Vec::new();
|
||||
let mut id = u32_at(b, 48)?;
|
||||
for _ in 0..MAX_DIR_SECTORS {
|
||||
if id == END_OF_CHAIN {
|
||||
return Some(names);
|
||||
}
|
||||
if id >= MAX_REG_SECT {
|
||||
return None;
|
||||
}
|
||||
let s = sector(id)?;
|
||||
for e in s.as_chunks::<128>().0 {
|
||||
let len = usize::from(u16_at(e, 64)?);
|
||||
if !(2..=64).contains(&len) {
|
||||
continue;
|
||||
}
|
||||
let units: Vec<u16> = (0..(len - 2) / 2).filter_map(|i| u16_at(e, i * 2)).collect();
|
||||
names.push(String::from_utf16_lossy(&units));
|
||||
}
|
||||
id = fat_next(id)?;
|
||||
}
|
||||
// A directory longer than the bound (or a cyclic chain): report what was read.
|
||||
Some(names)
|
||||
let limits = limits();
|
||||
ENCRYPTED_STREAMS.iter().any(|name| craft_cfb::has_entry_named(bytes, name, &limits))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
@@ -105,6 +26,7 @@ mod tests {
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use super::*;
|
||||
use craft_cfb::{ENDOFCHAIN as END_OF_CHAIN, SIGNATURE};
|
||||
|
||||
/// A minimal valid compound file (512-byte sectors: FAT at sector 0, directory at sector 1)
|
||||
/// whose directory holds a root entry plus the given stream names.
|
||||
@@ -146,7 +68,7 @@ mod tests {
|
||||
#[test]
|
||||
fn reads_directory_names() {
|
||||
let b = build(&["EncryptionInfo", "EncryptedPackage"]);
|
||||
assert_eq!(directory_names(&b), Some(vec!["Root Entry".into(), "EncryptionInfo".into(), "EncryptedPackage".into()]));
|
||||
assert_eq!(craft_cfb::directory_names(&b, &limits()), Some(vec!["Root Entry".into(), "EncryptionInfo".into(), "EncryptedPackage".into()]));
|
||||
assert!(is_encrypted(&b));
|
||||
// A PowerPoint 97-2003 .ppt is a compound file too, without the encryption streams.
|
||||
assert!(!is_encrypted(&build(&["PowerPoint Document", "Current User"])));
|
||||
|
||||
+24
-38
@@ -255,46 +255,11 @@ pub fn sidecar_part(name: &str) -> bool {
|
||||
}
|
||||
|
||||
pub fn dir_of(part: &str) -> String {
|
||||
let p = part.trim_start_matches('/');
|
||||
match p.rfind('/') {
|
||||
Some(i) => p.get(..i).unwrap_or("").to_string(),
|
||||
None => String::new(),
|
||||
}
|
||||
craft_opc::dir_of(part).to_owned()
|
||||
}
|
||||
|
||||
pub fn file_of(part: &str) -> &str {
|
||||
part.rsplit('/').next().unwrap_or(part)
|
||||
}
|
||||
|
||||
pub fn rels_path(part: &str) -> String {
|
||||
let p = part.trim_start_matches('/');
|
||||
let dir = dir_of(p);
|
||||
let file = file_of(p);
|
||||
if dir.is_empty() { format!("_rels/{file}.rels") } else { format!("{dir}/_rels/{file}.rels") }
|
||||
}
|
||||
|
||||
fn percent_decode(s: &str) -> String {
|
||||
let b = s.as_bytes();
|
||||
let mut out = Vec::with_capacity(b.len());
|
||||
let mut i = 0;
|
||||
while i < b.len() {
|
||||
let c = b.get(i).copied().unwrap_or(0);
|
||||
if c == b'%'
|
||||
&& let Some(h) = b
|
||||
.get(i + 1..i + 3)
|
||||
.filter(|h| h.iter().all(u8::is_ascii_hexdigit))
|
||||
.and_then(|h| std::str::from_utf8(h).ok())
|
||||
.and_then(|h| u8::from_str_radix(h, 16).ok())
|
||||
{
|
||||
out.push(h);
|
||||
i += 3;
|
||||
continue;
|
||||
}
|
||||
out.push(c);
|
||||
i += 1;
|
||||
}
|
||||
String::from_utf8_lossy(&out).into_owned()
|
||||
}
|
||||
use craft_opc::percent_decode;
|
||||
pub use craft_opc::{file_of, rels_path};
|
||||
|
||||
/// Resolve a relative target against a base directory into a part name.
|
||||
pub fn resolve(base: &str, target: &str) -> String {
|
||||
@@ -469,6 +434,27 @@ impl PackageOut {
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn shared_names_preserve_relationship_wire_policy() {
|
||||
for (part, dir, file, rels) in [
|
||||
("", "", "", "_rels/.rels"),
|
||||
("/", "", "", "_rels/.rels"),
|
||||
("///ppt/slides/slide1.xml", "ppt/slides", "slide1.xml", "ppt/slides/_rels/slide1.xml.rels"),
|
||||
("ppt/", "ppt", "", "ppt/_rels/.rels"),
|
||||
("é/😀.xml", "é", "😀.xml", "é/_rels/😀.xml.rels"),
|
||||
] {
|
||||
assert_eq!(dir_of(part), dir);
|
||||
assert_eq!(file_of(part), file);
|
||||
assert_eq!(rels_path(part), rels);
|
||||
}
|
||||
assert_eq!(percent_decode("a+b%20c%2Fd%23e"), "a+b c/d#e");
|
||||
assert_eq!(percent_decode("% %1 %zz %+1 %ff"), "% %1 %zz %+1 �");
|
||||
// Keep Deck's policy: strip the raw fragment first, then decode percent escapes once.
|
||||
assert_eq!(resolve("ppt/slides", "../media/a%23b.png#ignored"), "ppt/media/a#b.png");
|
||||
assert_eq!(resolve("ppt/slides", "%252e%252e/a"), "ppt/slides/%2e%2e/a");
|
||||
assert_eq!(resolve("ppt/slides", "%2e%2e/%2e%2e/%2e%2e/a"), "a");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn resolve_keeps_encoded_hash_and_strips_fragment() {
|
||||
assert_eq!(resolve("ppt/slides", "../media/a%23b.png"), "ppt/media/a#b.png");
|
||||
|
||||
+22
-48
@@ -1,59 +1,33 @@
|
||||
//! A minimal PNG encoder for the placeholder image written when a picture's media is missing.
|
||||
//! The placeholder image written when a picture's media is missing: a 1×1 fully transparent RGBA
|
||||
//! PNG, kept as its fixed bytes (signature, IHDR, one stored-deflate IDAT scanline, IEND) so the
|
||||
//! app carries no PNG encoder of its own.
|
||||
|
||||
fn crc32(data: &[u8]) -> u32 {
|
||||
let mut c = 0xFFFF_FFFFu32;
|
||||
for b in data {
|
||||
c ^= *b as u32;
|
||||
for _ in 0..8 {
|
||||
c = if c & 1 != 0 { 0xEDB8_8320 ^ (c >> 1) } else { c >> 1 };
|
||||
}
|
||||
}
|
||||
!c
|
||||
}
|
||||
|
||||
fn adler32(data: &[u8]) -> u32 {
|
||||
let (mut a, mut b) = (1u32, 0u32);
|
||||
for x in data {
|
||||
a = (a + *x as u32) % 65521;
|
||||
b = (b + a) % 65521;
|
||||
}
|
||||
(b << 16) | a
|
||||
}
|
||||
|
||||
fn chunk(out: &mut Vec<u8>, kind: &[u8; 4], data: &[u8]) {
|
||||
out.extend_from_slice(&(data.len() as u32).to_be_bytes());
|
||||
let mut c = Vec::with_capacity(data.len() + 4);
|
||||
c.extend_from_slice(kind);
|
||||
c.extend_from_slice(data);
|
||||
out.extend_from_slice(&c);
|
||||
out.extend_from_slice(&crc32(&c).to_be_bytes());
|
||||
}
|
||||
/// The PNG file, byte for byte what the former local encoder produced.
|
||||
const TRANSPARENT_1X1: [u8; 73] = [
|
||||
0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, 0x00, 0x00, 0x00, 0x0D, 0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
|
||||
0x08, 0x06, 0x00, 0x00, 0x00, 0x1F, 0x15, 0xC4, 0x89, 0x00, 0x00, 0x00, 0x10, 0x49, 0x44, 0x41, 0x54, 0x78, 0x01, 0x01, 0x05, 0x00, 0xFA, 0xFF,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x01, 0x64, 0x78, 0x95, 0x38, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4E, 0x44, 0xAE, 0x42, 0x60,
|
||||
0x82,
|
||||
];
|
||||
|
||||
/// A 1×1 fully transparent RGBA PNG.
|
||||
pub fn transparent_1x1() -> Vec<u8> {
|
||||
let mut out = b"\x89PNG\r\n\x1a\n".to_vec();
|
||||
let mut ihdr = vec![];
|
||||
ihdr.extend_from_slice(&1u32.to_be_bytes());
|
||||
ihdr.extend_from_slice(&1u32.to_be_bytes());
|
||||
ihdr.extend_from_slice(&[8, 6, 0, 0, 0]);
|
||||
chunk(&mut out, b"IHDR", &ihdr);
|
||||
// One scanline: filter byte + RGBA, stored (uncompressed) deflate block.
|
||||
let raw = [0u8, 0, 0, 0, 0];
|
||||
let mut z = vec![0x78, 0x01, 0x01];
|
||||
z.extend_from_slice(&(raw.len() as u16).to_le_bytes());
|
||||
z.extend_from_slice(&(!(raw.len() as u16)).to_le_bytes());
|
||||
z.extend_from_slice(&raw);
|
||||
z.extend_from_slice(&adler32(&raw).to_be_bytes());
|
||||
chunk(&mut out, b"IDAT", &z);
|
||||
chunk(&mut out, b"IEND", &[]);
|
||||
out
|
||||
TRANSPARENT_1X1.to_vec()
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
#[test]
|
||||
fn crc_known() {
|
||||
assert_eq!(super::crc32(b"IEND"), 0xAE42_6082);
|
||||
assert!(super::transparent_1x1().starts_with(b"\x89PNG"));
|
||||
fn placeholder_is_a_transparent_1x1_png() {
|
||||
let png = super::transparent_1x1();
|
||||
assert!(png.starts_with(b"\x89PNG\r\n\x1a\n"));
|
||||
// IHDR: 1×1, 8-bit RGBA, no interlace.
|
||||
assert_eq!(&png[12..16], b"IHDR");
|
||||
assert_eq!(&png[16..29], &[0, 0, 0, 1, 0, 0, 0, 1, 8, 6, 0, 0, 0]);
|
||||
assert!(png.ends_with(b"IEND\xAE\x42\x60\x82"));
|
||||
// The stored scanline: filter byte 0, then one pixel with zero alpha.
|
||||
assert_eq!(&png[49..54], &[0, 0, 0, 0, 0]);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -25,11 +25,24 @@ use crate::PptxError;
|
||||
use crate::opc::{self, Package, Rels};
|
||||
use crate::xml::{Doc, El, Node};
|
||||
|
||||
/// A snapshot of the import state a discarded read rolls back to.
|
||||
pub struct Mark {
|
||||
diagram_xml_bytes: usize,
|
||||
media: usize,
|
||||
media_keys: usize,
|
||||
tag_bytes: usize,
|
||||
tags_capped: bool,
|
||||
kept_sidecar_bytes: usize,
|
||||
kept_chart_keys: usize,
|
||||
}
|
||||
|
||||
/// Import state shared by all parts.
|
||||
pub struct Imp<'a> {
|
||||
pub pkg: &'a Package,
|
||||
pub media: Vec<MediaItem>,
|
||||
pub media_by_part: HashMap<String, MediaId>,
|
||||
/// Keys added to `media_by_part`, in order, so a rollback removes only its own.
|
||||
pub media_keys: Vec<String>,
|
||||
pub next: u32,
|
||||
pub slide_by_part: HashMap<String, SlideId>,
|
||||
pub custom_show_names: HashMap<String, String>,
|
||||
@@ -45,6 +58,8 @@ pub struct Imp<'a> {
|
||||
pub chart_points_cap: usize,
|
||||
/// Cached kept sidecars by normalized chart part name.
|
||||
pub kept_charts: HashMap<String, deckcraft_model::chart::ChartKept>,
|
||||
/// Keys added to `kept_charts`, in order, for rollback.
|
||||
pub kept_chart_keys: Vec<String>,
|
||||
/// Chart parts whose sidecar capture was refused, with the retained-byte total it started from:
|
||||
/// the same start gives the same refusal, so the copy is not repeated.
|
||||
pub rejected_kept: HashMap<String, usize>,
|
||||
@@ -56,6 +71,12 @@ pub struct Imp<'a> {
|
||||
pub tag_bytes: usize,
|
||||
/// The tag budget ran out and the warning was given.
|
||||
pub tags_capped: bool,
|
||||
/// Bytes of preserved theme XML kept by the masters read so far.
|
||||
pub theme_extra_bytes: usize,
|
||||
/// Shapes read from SmartArt drawings so far (see `shapes::MAX_SMARTART_SHAPES`).
|
||||
pub smartart_shapes: usize,
|
||||
/// Bytes of SmartArt layout, style and colour definitions copied into diagrams so far.
|
||||
pub diagram_xml_bytes: usize,
|
||||
/// Whether a part has relationships of its own, by normalized part name: looked up once
|
||||
/// however many embedded objects point at the part.
|
||||
pub has_rels: HashMap<String, bool>,
|
||||
@@ -77,9 +98,41 @@ impl Imp<'_> {
|
||||
let content_type = self.pkg.content_type(part).filter(|c| !c.is_empty()).unwrap_or_else(|| crate::mime_for(&name).to_string());
|
||||
let id = MediaId(self.alloc());
|
||||
self.media.push(MediaItem { id, name, content_type, data: Arc::new(data), link: None });
|
||||
self.media_keys.push(key.clone());
|
||||
self.media_by_part.insert(key, id);
|
||||
Some(id)
|
||||
}
|
||||
/// What a discarded read must give back: the budgets it charged and the media and kept-chart
|
||||
/// entries it added (see [`Imp::rollback`]).
|
||||
pub fn mark(&self) -> Mark {
|
||||
Mark {
|
||||
diagram_xml_bytes: self.diagram_xml_bytes,
|
||||
media: self.media.len(),
|
||||
media_keys: self.media_keys.len(),
|
||||
tag_bytes: self.tag_bytes,
|
||||
tags_capped: self.tags_capped,
|
||||
kept_sidecar_bytes: self.kept_sidecar_bytes,
|
||||
kept_chart_keys: self.kept_chart_keys.len(),
|
||||
}
|
||||
}
|
||||
/// Undo everything since `m`: only the entries added since are removed, so the cost follows
|
||||
/// what the discarded read added, not the size of the caches.
|
||||
pub fn rollback(&mut self, m: &Mark) {
|
||||
self.diagram_xml_bytes = m.diagram_xml_bytes;
|
||||
self.tag_bytes = m.tag_bytes;
|
||||
self.tags_capped = m.tags_capped;
|
||||
self.kept_sidecar_bytes = m.kept_sidecar_bytes;
|
||||
self.media.truncate(m.media);
|
||||
for k in self.media_keys.drain(m.media_keys..) {
|
||||
self.media_by_part.remove(&k);
|
||||
}
|
||||
for k in self.kept_chart_keys.drain(m.kept_chart_keys..) {
|
||||
self.kept_charts.remove(&k);
|
||||
}
|
||||
// Chart decode work (`chart_decode_bytes`, `chart_points`) stays charged: it was done, and
|
||||
// giving it back would let a discarded read repeat it. `rejected_kept` is keyed by the
|
||||
// retained total a refusal started from, so it stays valid after the rollback.
|
||||
}
|
||||
/// Media item for an external link.
|
||||
pub fn media_link(&mut self, url: &str) -> MediaId {
|
||||
if let Some(m) = self.media.iter().find(|m| m.link.as_deref() == Some(url)) {
|
||||
@@ -529,6 +582,7 @@ pub fn import_theme(bytes: &[u8]) -> Result<(deckcraft_model::theme::Theme, Vec<
|
||||
pkg: &pkg,
|
||||
media: vec![],
|
||||
media_by_part: HashMap::new(),
|
||||
media_keys: vec![],
|
||||
next: 0,
|
||||
slide_by_part: HashMap::new(),
|
||||
custom_show_names: HashMap::new(),
|
||||
@@ -538,11 +592,15 @@ pub fn import_theme(bytes: &[u8]) -> Result<(deckcraft_model::theme::Theme, Vec<
|
||||
chart_points: 0,
|
||||
chart_points_cap: chart::MAX_PRESENTATION_CHART_POINTS,
|
||||
kept_charts: HashMap::new(),
|
||||
kept_chart_keys: vec![],
|
||||
rejected_kept: HashMap::new(),
|
||||
chart_decode_bytes: 0,
|
||||
tags_by_part: HashMap::new(),
|
||||
tag_bytes: 0,
|
||||
tags_capped: false,
|
||||
theme_extra_bytes: 0,
|
||||
smartart_shapes: 0,
|
||||
diagram_xml_bytes: 0,
|
||||
has_rels: HashMap::new(),
|
||||
};
|
||||
let part = Part::new(&pkg, &theme_path, &doc);
|
||||
@@ -589,6 +647,7 @@ pub(crate) fn import_with_chart_points(bytes: &[u8], chart_points_cap: usize) ->
|
||||
pkg: &pkg,
|
||||
media: vec![],
|
||||
media_by_part: HashMap::new(),
|
||||
media_keys: vec![],
|
||||
next: max_id.max(1),
|
||||
slide_by_part: HashMap::new(),
|
||||
custom_show_names: HashMap::new(),
|
||||
@@ -598,11 +657,15 @@ pub(crate) fn import_with_chart_points(bytes: &[u8], chart_points_cap: usize) ->
|
||||
chart_points: 0,
|
||||
chart_points_cap,
|
||||
kept_charts: HashMap::new(),
|
||||
kept_chart_keys: vec![],
|
||||
rejected_kept: HashMap::new(),
|
||||
chart_decode_bytes: 0,
|
||||
tags_by_part: HashMap::new(),
|
||||
tag_bytes: 0,
|
||||
tags_capped: false,
|
||||
theme_extra_bytes: 0,
|
||||
smartart_shapes: 0,
|
||||
diagram_xml_bytes: 0,
|
||||
has_rels: HashMap::new(),
|
||||
};
|
||||
// Slide ids first so hyperlinks anywhere can point at slides.
|
||||
@@ -1545,6 +1608,54 @@ fn header_footer(p: &Presentation) -> HeaderFooter {
|
||||
hf
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod rollback_tests {
|
||||
use super::*;
|
||||
|
||||
/// A rolled-back read gives back its budgets and removes only the media and kept-chart entries it added.
|
||||
#[test]
|
||||
fn rollback_restores_budgets_and_removes_only_what_was_added() {
|
||||
let bytes = crate::export(&deckcraft_model::Presentation::default()).expect("export");
|
||||
let pkg = Package::open(&bytes).expect("package");
|
||||
let mut imp = Imp {
|
||||
pkg: &pkg,
|
||||
media: vec![],
|
||||
media_by_part: HashMap::new(),
|
||||
media_keys: vec![],
|
||||
next: 0,
|
||||
slide_by_part: HashMap::new(),
|
||||
custom_show_names: HashMap::new(),
|
||||
table_style_ids: Vec::new(),
|
||||
vml_previews: HashMap::new(),
|
||||
kept_sidecar_bytes: 0,
|
||||
chart_points: 0,
|
||||
chart_points_cap: chart::MAX_PRESENTATION_CHART_POINTS,
|
||||
kept_charts: HashMap::new(),
|
||||
kept_chart_keys: vec![],
|
||||
rejected_kept: HashMap::new(),
|
||||
chart_decode_bytes: 0,
|
||||
tags_by_part: HashMap::new(),
|
||||
tag_bytes: 0,
|
||||
tags_capped: false,
|
||||
theme_extra_bytes: 0,
|
||||
smartart_shapes: 0,
|
||||
diagram_xml_bytes: 0,
|
||||
has_rels: HashMap::new(),
|
||||
};
|
||||
let kept_before = imp.media_for("ppt/presentation.xml").expect("media");
|
||||
let (m, items) = (imp.mark(), imp.media.len());
|
||||
assert!(imp.media_for("ppt/presProps.xml").is_some());
|
||||
imp.kept_chart_keys.push("ppt/charts/chart1.xml".into());
|
||||
imp.kept_charts.insert("ppt/charts/chart1.xml".into(), Default::default());
|
||||
(imp.diagram_xml_bytes, imp.tag_bytes, imp.tags_capped, imp.kept_sidecar_bytes) = (7, 5, true, 9);
|
||||
imp.rollback(&m);
|
||||
assert_eq!(imp.media.len(), items);
|
||||
assert_eq!(imp.media_by_part.get("ppt/presentation.xml"), Some(&kept_before));
|
||||
assert!(!imp.media_by_part.contains_key("ppt/presprops.xml") && imp.kept_charts.is_empty() && imp.kept_chart_keys.is_empty());
|
||||
assert_eq!((imp.diagram_xml_bytes, imp.tag_bytes, imp.tags_capped, imp.kept_sidecar_bytes), (0, 0, false, 0));
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
@@ -600,6 +600,7 @@ pub(crate) fn capture_kept(imp: &mut super::Imp, chart_part: &str) -> deckcraft_
|
||||
return ChartKept::default();
|
||||
}
|
||||
imp.kept_sidecar_bytes += rel_total;
|
||||
imp.kept_chart_keys.push(key.clone());
|
||||
imp.kept_charts.insert(key, kept.clone());
|
||||
kept
|
||||
}
|
||||
|
||||
+115
-22
@@ -177,7 +177,7 @@ fn base(imp: &mut Imp, part: &Part, ctx: &mut IdCtx, nv: Option<&El>) -> Shape {
|
||||
|
||||
fn preset_geom(pg: &El) -> Geom {
|
||||
let name = pg.attr("prst").unwrap_or("rect").to_string();
|
||||
let defaults: Vec<f64> = preset::info(&name).map(|i| i.defaults.to_vec()).unwrap_or_default();
|
||||
let defaults: Vec<f64> = preset::adjust_defaults(&name).to_vec();
|
||||
let mut adj = defaults;
|
||||
let mut any = false;
|
||||
if let Some(av) = pg.child("avLst") {
|
||||
@@ -474,20 +474,54 @@ fn frame(imp: &mut Imp, part: &Part, ctx: &mut IdCtx, e: &El, depth: usize) -> S
|
||||
};
|
||||
// Keep the parts it points to so a save writes it back whole (#203). A part with relationships
|
||||
// of its own, or an external link, can't be carried: the save then falls back to the preview.
|
||||
let parts = super::rel_refs(e)
|
||||
.into_iter()
|
||||
.map(|id| {
|
||||
let rel = part.rels.get(&id).filter(|r| !r.external)?;
|
||||
let pkg = imp.pkg;
|
||||
if *imp.has_rels.entry(crate::opc::norm(&rel.target)).or_insert_with(|| !pkg.rels(&rel.target).items.is_empty()) {
|
||||
return None;
|
||||
// Validate every relationship (and charge the budget) before copying anything, so a fallback
|
||||
// that cannot be kept whole copies no part at all.
|
||||
let mark = imp.mark();
|
||||
let mut planned = Vec::new();
|
||||
let mut spent = imp.diagram_xml_bytes;
|
||||
let mut ok = true;
|
||||
for id in super::rel_refs(e) {
|
||||
let Some(rel) = part.rels.get(&id).filter(|r| !r.external) else {
|
||||
ok = false;
|
||||
break;
|
||||
};
|
||||
let pkg = imp.pkg;
|
||||
if *imp.has_rels.entry(crate::opc::norm(&rel.target)).or_insert_with(|| !pkg.rels(&rel.target).items.is_empty()) {
|
||||
ok = false;
|
||||
break;
|
||||
}
|
||||
// A diagram's definition parts copied here count against the same presentation-wide budget.
|
||||
if rel.kind.starts_with("diagram") && !imp.media_by_part.contains_key(&crate::opc::norm(&rel.target)) {
|
||||
let len = pkg.get(&rel.target).map_or(0, |b| b.len());
|
||||
if len > MAX_DIAGRAM_PART_BYTES || spent.saturating_add(len) > MAX_DIAGRAM_XML_BYTES {
|
||||
ok = false;
|
||||
break;
|
||||
}
|
||||
let (kind, target) = (rel.ty.clone(), rel.target.clone());
|
||||
let media = if rel.kind == "diagramData" { diagram_data(imp, &target) } else { imp.media_for(&target) };
|
||||
Some((id, kind, media?))
|
||||
})
|
||||
.collect::<Option<Vec<_>>>()
|
||||
.unwrap_or_default();
|
||||
spent += len;
|
||||
}
|
||||
if pkg.get(&rel.target).is_none() {
|
||||
ok = false;
|
||||
break;
|
||||
}
|
||||
planned.push((id, rel.ty.clone(), rel.target.clone(), rel.kind == "diagramData"));
|
||||
}
|
||||
let parts = if ok {
|
||||
imp.diagram_xml_bytes = spent;
|
||||
let copied: Option<Vec<_>> = planned
|
||||
.into_iter()
|
||||
.map(|(id, kind, target, data)| {
|
||||
let media = if data { diagram_data(imp, &target) } else { imp.media_for(&target) };
|
||||
Some((id, kind, media?))
|
||||
})
|
||||
.collect();
|
||||
if copied.is_none() {
|
||||
imp.rollback(&mark);
|
||||
}
|
||||
copied
|
||||
} else {
|
||||
None
|
||||
};
|
||||
let parts = parts.unwrap_or_default();
|
||||
s.kind = ShapeKind::Opaque { xml: part.keep(e), preview, label, parts };
|
||||
s
|
||||
}
|
||||
@@ -558,13 +592,28 @@ fn diagram_data(imp: &mut Imp, target: &str) -> Option<deckcraft_model::MediaId>
|
||||
data: std::sync::Arc::new(xml.into_bytes()),
|
||||
link: None,
|
||||
});
|
||||
imp.media_keys.push(norm_target.clone());
|
||||
imp.media_by_part.insert(norm_target, id);
|
||||
Some(id)
|
||||
}
|
||||
|
||||
/// Shapes all SmartArt drawings of one presentation may add; a frame read after that is left as a
|
||||
/// placeholder. Each frame that references a drawing reads it again.
|
||||
const MAX_SMARTART_SHAPES: usize = 250_000;
|
||||
|
||||
/// SmartArt definition XML (layout, style, colours) all diagrams of one presentation may copy.
|
||||
const MAX_DIAGRAM_XML_BYTES: usize = 32 << 20;
|
||||
|
||||
/// The largest single diagram definition part copied.
|
||||
const MAX_DIAGRAM_PART_BYTES: usize = 4 << 20;
|
||||
|
||||
fn count_shapes(shapes: &[Shape]) -> usize {
|
||||
shapes.iter().map(|s| 1 + count_shapes(s.children())).sum()
|
||||
}
|
||||
|
||||
/// SmartArt: read the pre-drawn shapes of its drawing part as a group.
|
||||
fn smartart(imp: &mut Imp, part: &Part, gd: &El, frame: &Shape, depth: usize) -> Option<Shape> {
|
||||
if depth > 8 {
|
||||
if depth > 8 || imp.smartart_shapes >= MAX_SMARTART_SHAPES {
|
||||
return None;
|
||||
}
|
||||
let rel_ids = gd.child("relIds")?;
|
||||
@@ -576,10 +625,21 @@ fn smartart(imp: &mut Imp, part: &Part, gd: &El, frame: &Shape, depth: usize) ->
|
||||
let dpart = Part::new(imp.pkg, &drawing_rel, &d);
|
||||
let tree = d.root.child("spTree")?;
|
||||
let mut sub = IdCtx { fresh: true, ..Default::default() };
|
||||
let before = imp.smartart_shapes;
|
||||
let mark = imp.mark();
|
||||
let children = sp_tree(imp, &dpart, &mut sub, tree, depth + 1);
|
||||
if children.is_empty() {
|
||||
return None;
|
||||
}
|
||||
// Counted once here, nested SmartArt included: a drawing that frames reuse counts every time it is read.
|
||||
let total = before.saturating_add(count_shapes(&children));
|
||||
if total > MAX_SMARTART_SHAPES {
|
||||
// Over the presentation's remaining budget: a placeholder, and nothing charged, nested SmartArt included.
|
||||
imp.smartart_shapes = before;
|
||||
imp.rollback(&mark);
|
||||
return None;
|
||||
}
|
||||
imp.smartart_shapes = total;
|
||||
let children = smartart_text_rects(imp, &mut sub, tree, children, depth + 1);
|
||||
let mut g = frame.clone();
|
||||
let x = frame.xfrm.unwrap_or_default();
|
||||
@@ -668,10 +728,11 @@ fn text_on_rect(imp: &mut Imp, ctx: &mut IdCtx, s: &mut Shape, t: Xfrm) -> Optio
|
||||
return None;
|
||||
}
|
||||
}
|
||||
if ctx.count >= MAX_SHAPES {
|
||||
if ctx.count >= MAX_SHAPES || imp.smartart_shapes >= MAX_SMARTART_SHAPES {
|
||||
return None;
|
||||
}
|
||||
ctx.count += 1;
|
||||
imp.smartart_shapes += 1;
|
||||
let text = s.text.take();
|
||||
// No fill, outline or effects; the style keeps only the text colour and font.
|
||||
let style = s.style.clone().map(|mut st| {
|
||||
@@ -707,15 +768,22 @@ fn text_area(geom: &Geom, w: f64, h: f64) -> deckcraft_geom::Rect {
|
||||
|
||||
/// The outline of a SmartArt graphic (for the Text Pane), with its layout, quick style and colour
|
||||
/// parts kept to be written back.
|
||||
fn diagram_outline(imp: &Imp, part: &Part, rel_ids: &El, data: &El) -> Option<deckcraft_model::Diagram> {
|
||||
fn diagram_outline(imp: &mut Imp, part: &Part, rel_ids: &El, data: &El) -> Option<deckcraft_model::Diagram> {
|
||||
let nodes = crate::dgm::outline(data);
|
||||
if nodes.is_empty() {
|
||||
return None;
|
||||
}
|
||||
let (pkg, spent) = (imp.pkg, std::cell::Cell::new(imp.diagram_xml_bytes));
|
||||
let raw = |attr: &str| -> Option<String> {
|
||||
let rel = part.rels.get(rel_ids.attr(attr)?)?;
|
||||
let bytes = imp.pkg.get(&rel.target)?;
|
||||
(bytes.len() <= 4 << 20).then(|| String::from_utf8(bytes.to_vec()).ok()).flatten()
|
||||
let bytes = pkg.get(&rel.target)?;
|
||||
// Every diagram copies its definitions, so the copies share one presentation-wide budget.
|
||||
if bytes.len() > MAX_DIAGRAM_PART_BYTES || spent.get().saturating_add(bytes.len()) > MAX_DIAGRAM_XML_BYTES {
|
||||
return None;
|
||||
}
|
||||
let xml = String::from_utf8(bytes.to_vec()).ok()?;
|
||||
spent.set(spent.get() + xml.len());
|
||||
Some(xml)
|
||||
};
|
||||
let layout_xml = raw("r:lo");
|
||||
let (layout_id, cat) = layout_xml
|
||||
@@ -736,16 +804,19 @@ fn diagram_outline(imp: &Imp, part: &Part, rel_ids: &El, data: &El) -> Option<de
|
||||
let pr = data.path(&["ptLst"]).and_then(|l| l.children_named("pt").find(|p| p.attr("type") == Some("doc"))).and_then(|p| p.child("prSet"));
|
||||
let style = crate::dgm::style_for(pr.and_then(|p| p.attr("qsTypeId")).unwrap_or("")).to_string();
|
||||
let colors = crate::dgm::colors_for(pr.and_then(|p| p.attr("csTypeId")).unwrap_or(""));
|
||||
let (style_xml, colors_xml) = (raw("r:qs"), raw("r:cs"));
|
||||
imp.diagram_xml_bytes = spent.get();
|
||||
Some(deckcraft_model::Diagram {
|
||||
kind: crate::dgm::kind_for(&id, &cat).to_string(),
|
||||
nodes,
|
||||
style,
|
||||
colors,
|
||||
imported: true,
|
||||
layout_id: id,
|
||||
// Without the layout part the writer generates one for `kind`; empty keeps data's loTypeId in step with it.
|
||||
layout_id: if layout_xml.is_some() { id } else { String::new() },
|
||||
layout_xml,
|
||||
style_xml: raw("r:qs"),
|
||||
colors_xml: raw("r:cs"),
|
||||
style_xml,
|
||||
colors_xml,
|
||||
})
|
||||
}
|
||||
|
||||
@@ -826,3 +897,25 @@ fn cell(imp: &mut Imp, part: &Part, tc: &El) -> Cell {
|
||||
}
|
||||
c
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod preset_geom_tests {
|
||||
use super::*;
|
||||
|
||||
fn geom(xml: &str) -> Geom {
|
||||
let doc = crate::xml::parse(xml.as_bytes()).unwrap();
|
||||
preset_geom(&doc.root)
|
||||
}
|
||||
|
||||
// A file may give some adjust values and rely on the defaults for the rest. A preset outside the
|
||||
// gallery had no defaults, so a missing value read as 0: a bentConnector4 with only adj2 lost
|
||||
// its middle leg.
|
||||
#[test]
|
||||
fn a_missing_adjust_value_takes_the_spec_default() {
|
||||
let a = r#"xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main""#;
|
||||
let g = geom(&format!(r#"<a:prstGeom {a} prst="bentConnector4"><a:avLst><a:gd name="adj2" fmla="val 25000"/></a:avLst></a:prstGeom>"#));
|
||||
assert!(matches!(&g, Geom::Preset { name, adj } if name == "bentConnector4" && adj == &[50000.0, 25000.0]), "{g:?}");
|
||||
let g = geom(&format!(r#"<a:prstGeom {a} prst="bentConnector5"><a:avLst><a:gd name="adj3" fmla="val 10000"/></a:avLst></a:prstGeom>"#));
|
||||
assert!(matches!(&g, Geom::Preset { adj, .. } if adj == &[50000.0, 50000.0, 10000.0]), "{g:?}");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -20,11 +20,15 @@ fn font_set(e: Option<&El>) -> FontSet {
|
||||
FontSet { latin: tf("latin"), ea: tf("ea"), cs: tf("cs"), scripts }
|
||||
}
|
||||
|
||||
/// Bytes of preserved theme XML (object defaults and extra colour schemes) all masters of one
|
||||
/// presentation may keep.
|
||||
const MAX_THEME_EXTRA_BYTES: usize = 16 << 20;
|
||||
|
||||
pub fn read_theme(imp: &mut Imp, part: &Part, root: &El) -> Theme {
|
||||
let mut t = Theme { name: root.attr("name").unwrap_or("Theme").to_string(), ..Default::default() };
|
||||
let Some(te) = root.child("themeElements") else { return t };
|
||||
if let Some(cs) = te.child("clrScheme") {
|
||||
let mut scheme = ColorScheme { name: cs.attr("name").unwrap_or("").to_string(), colors: t.colors.colors };
|
||||
let mut scheme = ColorScheme::new(cs.attr("name").unwrap_or("").to_string(), t.colors.colors);
|
||||
for slot in SchemeSlot::THEME {
|
||||
if let Some(c) = cs.child(slot.xml_name()).and_then(dml::color) {
|
||||
let rgb = match c.base {
|
||||
@@ -89,8 +93,13 @@ pub fn read_theme(imp: &mut Imp, part: &Part, root: &El) -> Theme {
|
||||
.filter(|e| !super::has_rel_refs(e))
|
||||
.map(|e| part.keep(e))
|
||||
.collect();
|
||||
if !extra.is_empty() {
|
||||
// Every master that references this theme keeps its own copy of the preserved XML, so the
|
||||
// copies share one budget for the presentation.
|
||||
if !extra.is_empty() && imp.theme_extra_bytes.saturating_add(extra.len()) <= MAX_THEME_EXTRA_BYTES {
|
||||
imp.theme_extra_bytes += extra.len();
|
||||
t.raw_extra = Some(extra);
|
||||
} else if !extra.is_empty() {
|
||||
log::warn!("pptx: theme object defaults not kept; the preserved-XML budget is spent");
|
||||
}
|
||||
t
|
||||
}
|
||||
|
||||
+20
-72
@@ -4,83 +4,14 @@
|
||||
use crate::opc::NS_A;
|
||||
use crate::xml::{A, W};
|
||||
|
||||
/// Well-known built-in table style GUIDs (format identifiers) and our equivalent ids.
|
||||
const KNOWN: &[(&str, &str)] = &[
|
||||
("{2D5ABB26-0587-4C30-8999-92F81FD0307C}", "none"),
|
||||
("{5940675A-B579-460E-94D1-54222C63F5DA}", "grid"),
|
||||
("{5C22544A-7EE6-4342-B048-85BDC9FD1C3A}", "medium2-accent1"),
|
||||
("{073A0DAA-6AF3-43AB-8588-CEC1D06C72B9}", "medium2-tx1"),
|
||||
("{21E4AEA4-8DFA-4A89-87EB-49C32662AFE8}", "medium2-accent2"),
|
||||
("{F5AB1C69-6EDB-4FF4-983F-18BD219EF322}", "medium2-accent3"),
|
||||
("{00A15C55-8517-42AA-B614-E9B94910E393}", "medium2-accent4"),
|
||||
("{7DF18680-E054-41AD-8BC1-D1AEF772440D}", "medium2-accent5"),
|
||||
("{93296810-A885-4BE3-A3E7-6D5BEEA58F35}", "medium2-accent6"),
|
||||
];
|
||||
|
||||
/// GUIDs we write as built-in references (no definition needed).
|
||||
const BUILTIN_WRITE: [&str; 3] = ["none", "grid", "medium2-accent1"];
|
||||
|
||||
fn fnv(s: &str, seed: u64) -> u64 {
|
||||
let mut h = 0xcbf2_9ce4_8422_2325u64 ^ seed;
|
||||
for b in s.bytes() {
|
||||
h ^= b as u64;
|
||||
h = h.wrapping_mul(0x0100_0000_01b3);
|
||||
}
|
||||
h
|
||||
}
|
||||
|
||||
/// A stable GUID derived from text (version-4 layout).
|
||||
pub fn guid(text: &str) -> String {
|
||||
let a = fnv(text, 0x5163_7261_6674);
|
||||
let b = fnv(text, 0x7461_626c_6573);
|
||||
format!(
|
||||
"{{{:08X}-{:04X}-4{:03X}-8{:03X}-{:012X}}}",
|
||||
(a >> 32) as u32,
|
||||
(a >> 16) as u16,
|
||||
(a & 0x0fff) as u16,
|
||||
(b >> 48) as u16 & 0x0fff,
|
||||
b & 0xffff_ffff_ffff
|
||||
)
|
||||
}
|
||||
// Keep file-format identifiers in the shared DrawingML implementation. The local
|
||||
// writer below still owns DeckCraft's table style definitions and XML policy.
|
||||
pub use craft_drawingml::table::styles::{guid, guid_for_style, is_own_guid, style_from_guid};
|
||||
|
||||
fn own_guid(style: &str) -> String {
|
||||
guid(&format!("deckcraft-table-style:{style}"))
|
||||
}
|
||||
|
||||
/// Is `g` the GUID DeckCraft writes for one of its own styles?
|
||||
pub fn is_own_guid(g: &str) -> bool {
|
||||
let up = g.to_ascii_uppercase();
|
||||
deckcraft_model::table::table_styles().iter().any(|(id, _)| own_guid(id) == up)
|
||||
}
|
||||
|
||||
/// Table style GUID → our style id (or the GUID itself when unknown).
|
||||
pub fn style_from_guid(g: &str) -> String {
|
||||
let up = g.to_ascii_uppercase();
|
||||
if let Some((_, s)) = KNOWN.iter().find(|(k, _)| *k == up) {
|
||||
return s.to_string();
|
||||
}
|
||||
for (id, _) in deckcraft_model::table::table_styles() {
|
||||
if own_guid(&id) == up {
|
||||
return id;
|
||||
}
|
||||
}
|
||||
if g.is_empty() { "none".into() } else { g.to_string() }
|
||||
}
|
||||
|
||||
/// GUID to write for our style id, and whether a definition must be written.
|
||||
pub fn guid_for_style(style: &str) -> (String, bool) {
|
||||
if style.starts_with('{') {
|
||||
return (style.to_string(), false);
|
||||
}
|
||||
if BUILTIN_WRITE.contains(&style)
|
||||
&& let Some((g, _)) = KNOWN.iter().find(|(_, s)| *s == style)
|
||||
{
|
||||
return (g.to_string(), false);
|
||||
}
|
||||
let known = deckcraft_model::table::table_styles().iter().any(|(id, _)| id == style);
|
||||
if known { (own_guid(style), true) } else { ("{5C22544A-7EE6-4342-B048-85BDC9FD1C3A}".into(), false) }
|
||||
}
|
||||
|
||||
fn clr(w: &mut W, slot: &str, mods: &[(&str, i32)]) {
|
||||
if mods.is_empty() {
|
||||
w.val("a:schemeClr", slot);
|
||||
@@ -254,6 +185,23 @@ pub fn table_styles_xml(used: &[String], defs: &[deckcraft_model::table::TableSt
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn shared_style_catalog_matches_deckcraft() {
|
||||
assert_eq!(deckcraft_model::table::table_styles(), craft_drawingml::table::table_styles());
|
||||
assert_eq!(style_from_guid(""), "none");
|
||||
let custom = "{abcdef00-0000-0000-0000-000000000000}";
|
||||
assert_eq!(style_from_guid(custom), custom);
|
||||
assert_eq!(guid_for_style(custom), (custom.to_string(), false));
|
||||
assert_eq!(guid_for_style("unknown"), guid_for_style("medium2-accent1"));
|
||||
for (id, _) in deckcraft_model::table::table_styles() {
|
||||
let generated = own_guid(&id);
|
||||
assert!(is_own_guid(&generated.to_ascii_lowercase()));
|
||||
if guid_for_style(&id).1 {
|
||||
assert_eq!(guid_for_style(&id).0, generated);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn style_parts_follow_schema_order() {
|
||||
const ORDER: [&str; 14] = [
|
||||
|
||||
@@ -94,7 +94,7 @@ pub fn geometry(w: &mut W, g: &Geom) {
|
||||
w.empty0("a:avLst");
|
||||
} else {
|
||||
// PowerPoint wants the complete guide list once any is given.
|
||||
let defaults = deckcraft_geom::preset::info(name).map(|i| i.defaults).unwrap_or(&[]);
|
||||
let defaults = deckcraft_geom::preset::adjust_defaults(name);
|
||||
let mut vals: Vec<f64> = adj.iter().take(16).copied().collect();
|
||||
while vals.len() < defaults.len() {
|
||||
vals.push(defaults.get(vals.len()).copied().unwrap_or(0.0));
|
||||
|
||||
+33
-39
@@ -354,45 +354,8 @@ fn decode_utf16(bytes: &[u8]) -> String {
|
||||
}
|
||||
}
|
||||
|
||||
/// Is `c` allowed in XML 1.0 text?
|
||||
fn xml_char(c: char) -> bool {
|
||||
matches!(c, '\t' | '\n' | '\r') || (c >= ' ' && c != '\u{FFFE}' && c != '\u{FFFF}')
|
||||
}
|
||||
|
||||
/// Escape text content (and drop characters XML 1.0 forbids).
|
||||
pub fn esc(s: &str) -> String {
|
||||
let mut o = String::with_capacity(s.len());
|
||||
for c in s.chars() {
|
||||
match c {
|
||||
'&' => o.push_str("&"),
|
||||
'<' => o.push_str("<"),
|
||||
'>' => o.push_str(">"),
|
||||
'\r' => o.push_str(" "),
|
||||
c if xml_char(c) => o.push(c),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
o
|
||||
}
|
||||
|
||||
/// Escape an attribute value.
|
||||
pub fn esc_attr(s: &str) -> String {
|
||||
let mut o = String::with_capacity(s.len());
|
||||
for c in s.chars() {
|
||||
match c {
|
||||
'&' => o.push_str("&"),
|
||||
'<' => o.push_str("<"),
|
||||
'>' => o.push_str(">"),
|
||||
'"' => o.push_str("""),
|
||||
'\n' => o.push_str(" "),
|
||||
'\r' => o.push_str(" "),
|
||||
'\t' => o.push_str("	"),
|
||||
c if xml_char(c) => o.push(c),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
o
|
||||
}
|
||||
// Preserve the public writer helpers while sharing the XML 1.0 escaping rules.
|
||||
pub use craft_xml::{esc, esc_attr};
|
||||
|
||||
/// A string builder for XML parts.
|
||||
#[derive(Default)]
|
||||
@@ -542,6 +505,37 @@ mod tests {
|
||||
assert_eq!(esc_attr("\"x\"\n"), ""x" ");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn shared_escaping_preserves_xml_wire_bytes() {
|
||||
let text = "&<>\"'\t\n\r\0\u{b}\u{fffe}\u{ffff}é😀 ";
|
||||
assert_eq!(esc(text), "&<>\"'\t\n é😀&#13;");
|
||||
assert_eq!(esc_attr(text), "&<>"'	 é😀&#13;");
|
||||
assert_eq!(esc(""), "");
|
||||
assert_eq!(esc_attr(""), "");
|
||||
for code in 0..32 {
|
||||
let c = char::from_u32(code).unwrap();
|
||||
let text = c.to_string();
|
||||
match c {
|
||||
'\t' => {
|
||||
assert_eq!(esc(&text), "\t");
|
||||
assert_eq!(esc_attr(&text), "	");
|
||||
}
|
||||
'\n' => {
|
||||
assert_eq!(esc(&text), "\n");
|
||||
assert_eq!(esc_attr(&text), " ");
|
||||
}
|
||||
'\r' => {
|
||||
assert_eq!(esc(&text), " ");
|
||||
assert_eq!(esc_attr(&text), " ");
|
||||
}
|
||||
_ => {
|
||||
assert_eq!(esc(&text), "");
|
||||
assert_eq!(esc_attr(&text), "");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn roundtrip_serialize() {
|
||||
let d = parse(b"<p:sp a=\"1\"><p:t>x & y</p:t><e/></p:sp>").unwrap();
|
||||
|
||||
@@ -155,7 +155,7 @@ pub fn draw_layout_with(ctx: &mut RenderContext, l: &deckcraft_text::TextLayout,
|
||||
};
|
||||
let li = lines_of.line_at(run.para, *y);
|
||||
if !grads.iter().any(|(i, _)| *i == li) {
|
||||
let scheme = deckcraft_color::ColorScheme { name: String::new(), colors: [Rgba::BLACK; 12] };
|
||||
let scheme = deckcraft_color::ColorScheme::new(String::new(), [Rgba::BLACK; 12]);
|
||||
let stops = g.stops.iter().map(|s| (s.pos, s.color.resolve(&scheme, None))).collect();
|
||||
let bounds = l.lines.get(li).and_then(line_bounds).unwrap_or(tr);
|
||||
grads.push((li, paint::gradient(&g.shape, stops, bounds, run.alpha * ps.opacity)));
|
||||
|
||||
@@ -32,16 +32,11 @@ Coordinates are slide points (1/72 inch; a 16:9 slide is 960 × 540) unless note
|
||||
| `engine.execute` / `ui.menu.invoke` / `command` | `{command, params}` | Run any command (see `engine.commands`; `deckcraft-cli describe COMMAND` documents one) |
|
||||
| `engine.commands` | — | Every command: id, label, menu path, shortcut, params doc, enabled / disabled reason |
|
||||
| `document.inspect` | — | Slides, sections, layouts, shapes, selection |
|
||||
| `slide.actions` | `{index?}` | Actions on one slide; returns `{index, slideId, actions}`. Each action has an `owner` (shape id/name and group path; text actions also include paragraph/run indexes and run text, plus table row/cell indexes for table text), `event` (`click`, `hover`, `textLink`, or `textHover`), action `type`, `target`, and the full `hyperlink`. Listing is read-only and never executes an action. An empty slide returns `"actions": []`. |
|
||||
| `ui.inspect` | — | UI state, active tool, window/canvas/slide rects, dialog, `home` (the File tab open over a presentation), `backstage` (its page, also the start screen), slide show state (`grid`, `zoomArm`, `zoom`, `blank`, `presenterPaused`, `presenterSecs`, `notesPx`, `custom`, `goto`; `cells` while See All Slides is open), documents, perf (fps, render ms) |
|
||||
| `ui.inspect` | — | UI state, active tool, window/canvas/slide rects, dialog, `home` (the File tab open over a presentation), `backstage` (its page, also the start screen), slide show state, `animPreview` (canvas playback: slide, time, duration), documents, perf (fps, render ms) |
|
||||
| `ui.inspect` | — | UI state, active tool, window/canvas/slide rects, dialog, `home` (the File tab over an open presentation), `backstage` (the current File page, including the start screen), slide show state (`grid`, `zoomArm`, `zoom`, `blank`, `presenterPaused`, `presenterSecs`, `notesPx`, `custom`, `goto`; `cells` when See All Slides is open), `animPreview` (canvas playback: slide, time, duration), documents, perf (fps, render ms) |
|
||||
| `ui.tool.select` | `{tool, preset?}` | `select`, `text`, `shape` + preset, any preset name, `curve`, `freeform`, `scribble`, `pen`, `highlighter`, `eraser` |
|
||||
| `ui.pointer` | `{events: [{kind: down\|drag\|up\|move\|doubleclick\|tripleclick\|contextclick, x, y, mods?}], mods?}` | Drive the active tool in slide points through the same code path as the mouse (`contextclick`: the right-button press that selects before the context menu) |
|
||||
| `ui.key` / `ui.text` | `{key, shift?, alt?, cmd?}` / `{text}` | Keyboard input (also drives a running slide show: digits then Enter go to that slide, G is See All Slides, Z arms zoom, T pauses the presenter timer, R resets it, `[` and `]` change notes size, Esc clears a slide number, the grid and zoom before it leaves the show) |
|
||||
| `ui.pointer` | `{events: [{kind: down\|drag\|up\|move\|doubleclick\|tripleclick, x, y, mods?}], mods?}` | Drive the active tool in slide points through the same code path as the mouse |
|
||||
| `ui.key` / `ui.text` | `{key, shift?, alt?, cmd?}` / `{text}` | Keyboard input (also drives a running slide show; Escape stops the canvas animation preview) |
|
||||
| `ui.pointer` | `{events: [{kind: down\|drag\|up\|move\|doubleclick\|tripleclick, x, y, mods?, pressure?}], mods?}` | Drive the active tool in slide points through the same code path as the mouse. `pressure` is `0..=1` for a pen; omit it for a mouse |
|
||||
| `ui.key` / `ui.text` | `{key, shift?, alt?, cmd?}` / `{text}` | Keyboard input (also drives a running slide show) |
|
||||
| `ui.pointer` | `{events: [{kind: down\|drag\|up\|move\|doubleclick\|tripleclick\|contextclick, x, y, mods?, pressure?}], mods?}` | Send slide-point pointer events through the active tool's mouse path. `contextclick` performs the right-click selection used by context menus; `pressure` is `0..=1` for a pen and can be omitted for a mouse |
|
||||
| `ui.key` | `{key, shift?, alt?, cmd?}` | Send a key press. During an active slide show, digits followed by Enter jump to that slide; G opens See All Slides, Z arms zoom, T toggles the presenter timer's pause, R resets it, and `[` / `]` resize notes. Esc clears a typed slide number or backs out of the grid/zoom before ending the active show. Close See All Slides with Esc or G before using the other listed show shortcuts. Slide-show keys ignore modifier flags; use `show.end` to leave the end-of-show screen. Outside a show, Escape stops canvas animation preview |
|
||||
| `ui.text` | `{text}` | Insert into the current text edit. With one shape selected and no active text edit, begin editing and replace the shape's existing text |
|
||||
| `ui.ime` | `{preedit, active?: [start, end]}` / `{commit}` | An input method's composition through egui, as a real one arrives: shown in place on the slide or in a focused field; `{"preedit": ""}` cancels |
|
||||
| `ui.move` / `ui.click` / `ui.drag` | screen points | Real egui pointer input — reaches every widget, menu and pane |
|
||||
| `ui.set` | `{tab?, view?, pane?, notes?, zoom?, brightness?, ruler?, gridlines?, guides?, …}` | UI state (returns the full state) |
|
||||
@@ -54,3 +49,18 @@ Coordinates are slide points (1/72 inch; a 16:9 slide is 960 × 540) unless note
|
||||
|
||||
The MCP server (`deckcraft-cli mcp`, see [mcp.md](mcp.md)) wraps the same methods for Claude
|
||||
and other agents; `deckcraft-cli app --method METHOD [PARAMS]` sends one request from a shell.
|
||||
|
||||
## Inspecting slide actions
|
||||
|
||||
Run the `slide.actions` engine command through `engine.execute`:
|
||||
|
||||
```json
|
||||
{"id": 2, "method": "engine.execute", "params": {"command": "slide.actions", "params": {"index": 0}}}
|
||||
```
|
||||
|
||||
`index` is zero-based and optional; omitting it inspects the selected slide. The reply's `result`
|
||||
contains `{index, slideId, actions}`. Each action includes an `owner` with the shape id/name and
|
||||
its group path; text actions also identify the paragraph/run and run text, plus the table row/cell
|
||||
for table text. Actions report their `event` (`click`, `hover`, `textLink`, or `textHover`),
|
||||
`type`, `target`, and full `hyperlink`. Inspection never runs an action. A slide without actions
|
||||
returns `"actions": []`.
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# Slide show and presenter view: parity with PowerPoint
|
||||
|
||||
> **Last reviewed:** 2026-10-14 · **Last updated:** 2026-11-02 · **Change:** minor (deleting slides removes them from custom shows; previous: minor, Presenter View only with a second display on Linux and the BSDs, #1156; previous: minor, Set Up Slide Show ▸ Keep mouse cursor visible, #1445; previous: minor, Ctrl+wheel zooms the show around the pointer, #1286; previous: major, community PR wave 2026-10-14: interactive decks, laser pointer, See All Slides and zoom, go-to-slide number, custom show playback, presenter timer, clock, notes size and keyboard, Show Media Controls, swipe; breadth 68%; duplicated rows and headers folded; previous: major, created) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
|
||||
> **Last reviewed:** 2026-10-14 · **Last updated:** 2026-11-14 · **Change:** minor (a slide the show advances to again plays its animations again, #2090; previous: minor, deleting slides removes them from custom shows; previous: minor, Presenter View only with a second display on Linux and the BSDs, #1156; previous: minor, Set Up Slide Show ▸ Keep mouse cursor visible, #1445; previous: minor, Ctrl+wheel zooms the show around the pointer, #1286; previous: major, community PR wave 2026-10-14: interactive decks, laser pointer, See All Slides and zoom, go-to-slide number, custom show playback, presenter timer, clock, notes size and keyboard, Show Media Controls, swipe; breadth 68%; duplicated rows and headers folded; previous: major, created) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
|
||||
|
||||
Presenting is the job PowerPoint is hired for. This doc covers the show window, presenter view,
|
||||
rehearsal and recording. Transition and animation playback are in
|
||||
@@ -23,7 +23,8 @@ ready** (estimated), **10–16 h** to parity.
|
||||
| Hidden slides skipped | yes | yes | |
|
||||
| Hyperlinks and action settings followed (slides, web, mail, End Show, Last Viewed) | yes | yes | Only `http(s)` and `mailto` open outside the show, by design (`safe_url`) |
|
||||
| A shape with a triggered animation plays it when clicked; shapes an animation has hidden cannot be clicked; a shape without an action on top of one with an action blocks it; the pointer is a hand over what can be clicked | yes | yes | Click boxes are bounding boxes; "play sound" actions (`ppaction://media`) do nothing yet |
|
||||
| A slide the show returns to (link, arrow keys) looks as it was left; a triggered animation goes on where it stopped | yes | yes | A main-sequence step still playing when the show leaves is finished |
|
||||
| A slide the show returns to by a link or Back looks as it was left; a triggered animation goes on where it stopped | yes | yes | A main-sequence step still playing when the show leaves is finished |
|
||||
| A slide the show advances to again (click, →, Space, automatic advance, loop) starts over and plays its animations again | yes | yes | Its triggered animations start over too (#2090) |
|
||||
| "Advance on click" off: a click never leaves the slide (animation steps still play, keys still move on) | yes | yes | |
|
||||
| Hyperlinks and action settings followed (slides, web, mail, End Show, Last Viewed, Custom Show) | yes | yes | Only `http(s)` and `mailto` open outside the show, by design (`safe_url`). A Custom Show action plays that show |
|
||||
| Media playback with controls, play across slides, full-screen video, Play/Pause/Stop in the click sequence | yes | yes | WMA/WMV not decodable. Click sequence since #116. Slide Show ▸ Show Media Controls (on by default) hides the playback bar. Seeks and loops preserve new-generation video frames and end-of-stream; queue regression and repeated seeks across H.264/HEVC/VP9/AV1 in `crates/media` |
|
||||
@@ -96,4 +97,5 @@ Reading View in a window with navigation: present (checklist row done).
|
||||
| 2026-10-14 | minor | See All Slides (G) and click-to-zoom (Z) during the show. Presenter view opens that grid and sets black, white and zoom. Checklist breadth stays 66% |
|
||||
| 2026-10-24 | minor | Ctrl+wheel (Cmd+wheel on a Mac) zooms the show in and out around the pointer, up to 4×; the plain wheel still turns the page (#1286) |
|
||||
| 2026-10-23 | trivial | Presenter view draws the notes with their formatting (bullets, numbers, indents, bold/italic) instead of plain text (#1128) |
|
||||
| 2026-11-14 | minor | A slide the show advances to again starts over, so its entrance effects play again; Back and links still show it as it was left (#2090) |
|
||||
| 2026-10-10 | major | Created: show, presenter view, rehearse and record, compared with PowerPoint 16.113's Slide Show tab and menu |
|
||||
|
||||
+24
-3
@@ -45,11 +45,20 @@ pub fn validate(v: &str) -> Result<(), String> {
|
||||
None => (v, None),
|
||||
};
|
||||
let nums: Vec<&str> = core.split('.').collect();
|
||||
if nums.len() != 3 || nums.iter().any(|n| n.is_empty() || !n.bytes().all(|b| b.is_ascii_digit()) || (n.len() > 1 && n.starts_with('0'))) {
|
||||
if nums.len() != 3
|
||||
|| nums
|
||||
.iter()
|
||||
.any(|n| n.is_empty() || !n.bytes().all(|b| b.is_ascii_digit()) || n.parse::<u64>().is_err() || (n.len() > 1 && n.starts_with('0')))
|
||||
{
|
||||
return bad();
|
||||
}
|
||||
if let Some(p) = pre
|
||||
&& (p.is_empty() || p.split('.').any(|id| id.is_empty() || !id.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'-')))
|
||||
&& (p.is_empty()
|
||||
|| p.split('.').any(|id| {
|
||||
id.is_empty()
|
||||
|| !id.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'-')
|
||||
|| (id.len() > 1 && id.starts_with('0') && id.bytes().all(|b| b.is_ascii_digit()))
|
||||
}))
|
||||
{
|
||||
return bad();
|
||||
}
|
||||
@@ -138,12 +147,24 @@ mod tests {
|
||||
for ok in ["0.1.0", "1.20.300", "1.0.0-rc.1", "1.0.0-alpha", "1.0.0-x-y.2"] {
|
||||
assert!(validate(ok).is_ok(), "{ok}");
|
||||
}
|
||||
for bad in ["1.0", "1.0.0.0", "v1.0.0", "01.0.0", "1.0.0-", "1.0.0-a..b", "1.0.0+meta", "1.a.0", ""] {
|
||||
for bad in ["1.0", "1.0.0.0", "v1.0.0", "01.0.0", "1.0.0-", "1.0.0-a..b", "1.0.0+meta", "1.a.0", "18446744073709551616.0.0", ""] {
|
||||
assert!(validate(bad).is_err(), "{bad}");
|
||||
}
|
||||
assert!(replace(MANIFEST, "nope").is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn numeric_prerelease_identifiers_have_no_leading_zeroes() {
|
||||
for bad in ["1.0.0-00", "1.0.0-01", "1.0.0-rc.01"] {
|
||||
assert!(validate(bad).is_err(), "{bad}");
|
||||
assert!(replace(MANIFEST, bad).is_err(), "{bad} must not reach the manifest");
|
||||
}
|
||||
for ok in ["1.0.0-0", "1.0.0-rc.0", "1.0.0-01a", "1.0.0-0-1"] {
|
||||
assert!(validate(ok).is_ok(), "{ok}");
|
||||
assert_eq!(read(&replace(MANIFEST, ok).unwrap()).unwrap(), ok);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_real_manifest_has_a_valid_version() {
|
||||
let text = std::fs::read_to_string(crate::root().join("Cargo.toml")).unwrap();
|
||||
|
||||
Reference in New Issue
Block a user