Compare commits

..
Author SHA1 Message Date
Dylan M. Taylor 2c135484c1 Drop unused test-oracle GUID reexports 2026-11-17 11:50:07 -05:00
Dylan M. Taylor 352b1ee170 Pin table-style writer to merged shared implementation 2026-11-17 11:31:14 -05:00
Dylan M. Taylor 82fddc8ffd Use shared DrawingML table style XML writer
Preserve the former writer as a test-only byte oracle, including the original Brandon Thomas and Nikita Rakitin implementation history. Keep app XML admission and all existing table tests unchanged.
2026-11-17 08:37:55 -05:00
Dylan M. Taylor 1629e4d953 Tables: cap the grid and merge area before edits allocate or walk them (#1742) 2026-11-17 08:13:56 -05:00
Luis 497582406d Gradient stops: double-clicking a stop opens its colour menu (#2175) (#2196)
Double-clicking a stop marker in the Format pane's gradient editor did nothing. It now selects the stop and opens the colour menu of the selected stop, as in PowerPoint. The menu button is also named for screen readers.
2026-11-17 08:36:53 +00:00
Luis e1ca71495c Slide show: a slide's animations wait for its transition (#2089) (#2197)
A first step that starts With or After Previous began with the slide, so its effects played under the transition. Its clock now starts when the transition has finished, as in PowerPoint. Slides without a transition, and Show without animation, start the step at once as before.
2026-11-17 08:35:55 +00:00
Dylan M. Taylor 5c698493bc ci: lock workflow actions through an actions.lock lockfile (#2078) 2026-11-16 21:58:00 -05:00
Dylan M. Taylor f964d06cc5 docs: prefer shared Craft libraries for reusable features (#2178) 2026-11-16 21:57:57 -05:00
Dylan M. Taylor ac73229ef4 pptx: reuse shared custom-geometry path tokenization (#2192) 2026-11-16 21:57:53 -05:00
Dylan M. Taylor 1ec01a091a refactor(pptx): reuse shared table style identifiers (#792) (#2189) 2026-11-16 19:31:55 +00:00
Hamza Naveed f9bc097b4e Shapes: the 3- and 4-bend elbow and curved connectors follow presetShapeDefinitions (#1851)
* Shapes: the 3- and 4-bend elbow and curved connectors follow presetShapeDefinitions

PowerPoint routes connectors around shapes with bentConnector4 and 5 and
their curved counterparts. They were drawn as bentConnector3 and
curvedConnector3, using adj1 alone, and curvedConnector2 as a two-cubic
S where the spec has one cubic. Each now draws the spec's path, and the
elbows get a handle per adjust value where the spec puts it.

None of these is in the gallery, so their adjust values had no defaults:
a file giving none, or only adj2, drew them at 0. adjust_defaults() adds
the spec's 50000s for presets outside the gallery, and the reader, writer,
Adjust command and handle drag use it.

* Shapes: elbow handles take the spec's whole adjust range

The handles clamped a dragged value to ±1000000, so dragging one on an
imported route with a value beyond that moved the route. They now take
presetShapeDefinitions' ±2147483647 (noted in review).
2026-11-16 14:39:49 +00:00
FredApps 6c52db0172 Merge pull request #2180 from storytold/onee/792-geom-reexport
geom: placement, preset and warp geometry come from craft-drawingml (craft-libs#778, #792)
2026-11-16 12:58:46 +01:00
FredApps c3bce89b2d Merge remote-tracking branch 'origin/main' into onee/792-geom-reexport 2026-11-16 12:46:16 +01:00
FredApps 62af9fa114 Merge pull request #2179 from storytold/onee/792-color-reexport
color: DrawingML colours come from craft-drawingml (craft-libs#778, #792)
2026-11-16 12:45:45 +01:00
FredApps 7e1d6925ec geom: placement, preset and warp geometry come from craft-drawingml (craft-libs#778, #792)
deckcraft-geom re-exports craft_drawingml's Xfrm, EMU units,
group_child_affine, preset and warp, and deletes its copies (preset/,
warp.rs). The shared versions add Xfrm::from_affine, preset text rectangles,
separate bentConnector4/5 and curvedConnector4/5 outlines with their own
default adjustments, and smoother follow-path warps. App-only geometry (Unit,
morph, squircle, hit testing, snapping) stays.
2026-11-16 12:45:15 +01:00
FredApps dea0af6ceb color: DrawingML colours come from craft-drawingml (craft-libs#778, #792)
deckcraft-color re-exports craft_drawingml::color (Rgba, SchemeSlot,
ColorScheme, ColorTransform, presets and transforms) and its own copy is
deleted. The existing colour tests run unchanged against the shared module.
ColorScheme literals use ColorScheme::new, since the shared scheme also keeps
extra colours and tint rows.
2026-11-16 12:33:00 +01:00
FredApps 3b6f9e7cb8 Merge pull request #2176 from storytold/onee/792-pptx-shared-cfb
#792: read password-protected decks with craft-cfb and drop the local PNG encoder
2026-11-16 11:03:41 +01:00
FredApps 5f58c3c208 #792: read password-protected decks with craft-cfb and drop the local PNG encoder
DeckCraft's pptx crate carried a copy of GridCraft's CFB directory walk to tell an
encrypted package from other compound files. It now asks the shared craft-cfb
(has_entry_named, same UTF-16 fallback for damaged directories, directory entries
capped at 4096 as before). The placeholder for missing picture media keeps its
exact bytes, written as a constant instead of through a hand-rolled CRC/Adler/PNG
encoder.

Part of storytold/craft-libs#778 and storytold/craft-libs#792.
2026-11-16 10:52:29 +01:00
Zinadin Zidan 596ec54b59 Slide show: play a slide's animations again when the show advances to it (#2090) (#2126)
ShowState remembers what was played on each visited slide, so a slide
reached again by a link or by Back looks as it was left. Going forward
used the same path: next() entered a visited slide at the step it was
left at, so after Back and forward again its entrance effects did not
play and the shapes were already in place.

next() now forgets the slide's run before entering it, when it moves
to the next slide and when a looping show comes round to the first
one. The slide starts over: its automatic first step plays, an On
Click build starts at its first step, and its triggered animations
start over. Back, links, Go to slide and Return to Zoom are unchanged.
2026-11-16 10:22:24 +01:00
scks1 9e975b0049 engine: arrange.align and arrange.distribute refuse values they do not name (#1974)
* engine: arrange.align and arrange.distribute refuse values they do not name

arrange.align took an `edge` it did not know as a no-op that still
reported its shapes as edited, aligned left when `edge` was left out
(the spec does not mark it optional), and read any `to` other than
exactly "slide" as the selection. arrange.distribute distributed
vertically for any `dir` starting with "v" and horizontally for any
other, and also read any `to` other than "slide" as the selection.

`edge` must now be left, center, right, top, middle or bottom, `to`
slide or selection, and `dir` horizontal or vertical. Anything else, or
a missing `edge`, is refused with the accepted values and nothing moves.
A missing `to` or `dir` keeps its default.

Test: align_and_distribute_refuse_values_they_do_not_name.

* engine: arrange.align and arrange.distribute refuse a dir or to that is not a string

`align_to` and `distribute` read `to` and `dir` through `str_param`, which
returns None for a value that is present but not a string, the same as for a
missing one. So `{"dir": 123}` distributed horizontally, and
`{"edge": "left", "to": false}` aligned to each command's default reference,
moving the selected shapes instead of failing.

Both now match on `p.get(..).map(Value::as_str)`: a missing field keeps its
default (horizontal for `dir`, each command's own rule for `to`), the named
strings work as before, and anything else, null included, is refused with the
accepted values.

The new test `align_and_distribute_refuse_dir_and_to_that_are_not_strings`
sends null, 123, false, {} and [] as `dir` to arrange.distribute and as `to`
to both commands, in a fresh three-shape session each time, and checks the
error, the revision and every shape's box.
2026-11-16 07:46:28 +00:00
FredApps 4c844f9332 Merge pull request #2165 from storytold/extract/shared-opc-names
Reuse shared OPC part-name primitives
2026-11-16 07:57:56 +01:00
FredApps 5cf7f5f20a Merge main into extract/shared-opc-names 2026-11-16 07:29:45 +01:00
FredApps fb7755717b Merge pull request #1803 from storytold/fix/sec-pptx-theme-budget
PPTX import: budget preserved theme XML, SmartArt drawing shapes and diagram definitions across the presentation
2026-11-16 07:28:46 +01:00
FredApps d04db56f3b Merge pull request #2167 from storytold/cutover/shared-base64-decoder
Reuse shared Base64 decoder with command transport guards
2026-11-16 07:15:16 +01:00
FredApps ea1b4c5539 Merge main into fix/sec-pptx-theme-budget
Keep both sets of import state: the rollback's kept-chart key log and main's
chart decode budget (rejected_kept, chart_decode_bytes). A capture refused by
the retained-byte check records no key; chart decode work stays charged across
a rollback.
2026-11-16 07:14:36 +01:00
FredApps e6574eb39e Merge pull request #2160 from storytold/cutover/shared-base64
Use shared Base64 encoding for command payloads
2026-11-16 07:04:13 +01:00
FredApps 48de308315 Merge main into extract/shared-opc-names
# Conflicts:
#	Cargo.lock
#	Cargo.toml
#	crates/pptx/Cargo.toml
2026-11-16 07:03:32 +01:00
FredApps 1d30834cca Merge cutover/shared-base64 into cutover/shared-base64-decoder
Pin craft-mime to 254e9a40, the craft-libs main revision craft-deckcraft-format
already uses; craft-mime and craft-codepage are unchanged since 0325b2d7.
2026-11-16 06:55:02 +01:00
Dylan M. Taylor 349d3d1c24 Integrate refreshed encoder and RTF cutovers 2026-11-15 15:02:44 -05:00
Dylan M. Taylor d842a0cc2a Delegate Base64 decoding while preserving command input guards 2026-11-15 14:54:50 -05:00
Dylan M. Taylor 455a3fdc35 Reuse shared OPC part-name primitives 2026-11-15 14:14:46 -05:00
Dylan M. Taylor 3746f259a0 test: rollback restores budgets and removes only what the discarded read added 2026-11-11 19:22:48 +00:00
Dylan M. Taylor 175fa54642 address review: roll back by journal, preflight fallback parts, restore tag and chart sidecar accounting on a rejected drawing 2026-11-11 18:50:18 +00:00
Dylan M. Taylor 64c89064ea address review: drop media copied by a rolled-back diagram fallback or parent drawing 2026-11-11 15:11:54 +00:00
Dylan M. Taylor 96c6b5da4c address review: refund the diagram XML budget when a fallback or a parent drawing is dropped 2026-11-11 10:20:58 +00:00
Dylan M. Taylor 40052f4b09 address review: budget diagram definition parts copied by the opaque fallback, refuse a SmartArt drawing over the remaining shape budget 2026-11-11 02:07:46 +00:00
Dylan M. Taylor 8ecb818f81 address review: layout id follows generated layout, charge text-rect shapes to smartart budget 2026-11-10 22:21:47 +00:00
aiongg 953ae8d060 Apply review fixes
- crates/pptx/src/read/shapes.rs
2026-11-04 23:44:51 +00:00
aiongg 1b2b48c0d7 Merge main into fix/sec-pptx-theme-budget 2026-11-04 23:24:41 +00:00
Dylan M. Taylor 9e7fab1038 PPTX import: budget preserved theme XML, SmartArt drawing shapes and diagram definitions across the presentation 2026-11-03 21:05:30 +00:00
57 changed files with 1480 additions and 6378 deletions
+31
View File
@@ -0,0 +1,31 @@
# This file is machine-generated by `gh actions-lock`.
# Do not edit by hand; run `gh actions-lock` to update.
# Docs: https://gh.io/actions-lockfile
version: 'v0.0.3'
workflows:
'.github/workflows/ci.yml':
- 'actions/checkout@v7.0.1'
- 'step-security/harden-runner@v2.22.4'
'.github/workflows/freebsd.yml': []
'.github/workflows/house-rules.yml': []
'.github/workflows/lockfile.yml':
- 'actions/checkout@v7.0.1'
- 'step-security/harden-runner@v2.22.4'
'.github/workflows/nix.yml': []
'.github/workflows/packaging-lint.yml':
- 'actions/checkout@v7.0.1'
- 'step-security/harden-runner@v2.22.4'
'.github/workflows/release.yml': []
'.github/workflows/sonarcloud.yml': []
'.github/workflows/windows-arm64.yml': []
dependencies:
'actions/checkout@v7.0.1':
ref: 'v7.0.1'
commit: 'sha1-3d3c42e5aac5ba805825da76410c181273ba90b1'
owner_id: 44036562
repo_id: 197814629
'step-security/harden-runner@v2.22.4':
ref: 'v2.22.4'
commit: 'sha1-1d88384fd173af6ecb012dfd0264a306b711241a'
owner_id: 88700172
repo_id: 422287306
+2 -2
View File
@@ -27,11 +27,11 @@ jobs:
CRAFT_FONTS_REF: 37827adc41fd165f9a9234ac40f94dbad353aa69
steps:
- name: Harden runner
uses: step-security/harden-runner@1d88384fd173af6ecb012dfd0264a306b711241a # v2.22.4
uses: step-security/harden-runner@v2.22.4
with:
egress-policy: audit
- name: Check out craft-fonts
uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
uses: actions/checkout@v7.0.1
with:
repository: storytold/craft-fonts
ref: ${{ env.CRAFT_FONTS_REF }}
+34
View File
@@ -0,0 +1,34 @@
name: Lockfile
# Fails when .github/workflows/actions.lock is out of sync with the workflows, or when a locked pin
# no longer verifies upstream, so a moved tag cannot slip a different commit into a run.
# Docs: https://gh.io/actions-lockfile
on:
pull_request:
push:
branches: [main]
workflow_dispatch:
permissions:
contents: read
env:
GH_TOKEN: ${{ github.token }}
jobs:
lockfile:
name: Lockfile is in sync
runs-on: ubuntu-24.04
timeout-minutes: 10
steps:
- name: Harden runner
uses: step-security/harden-runner@v2.22.4
with:
egress-policy: audit
- uses: actions/checkout@v7.0.1
with:
persist-credentials: false
- name: Install gh-actions-lock
run: gh extension install github/gh-actions-lock --pin v0.4.1
- name: Verify the lockfile
run: gh actions-lock --verify
+2 -2
View File
@@ -28,10 +28,10 @@ jobs:
runs-on: windows-latest
steps:
- name: Harden runner
uses: step-security/harden-runner@1d88384fd173af6ecb012dfd0264a306b711241a # v2.22.4
uses: step-security/harden-runner@v2.22.4
with:
egress-policy: audit
- uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
- uses: actions/checkout@v7.0.1
with:
persist-credentials: false
- name: Install the pinned packaging toolchain
+4
View File
@@ -239,3 +239,7 @@ the `ROADMAP.md` progress log, and update each touched doc's status line and rev
- Workflows in `.github/workflows/` call the shared workflows in [`storytold/craft-common-actions`](https://github.com/storytold/craft-common-actions) at `@main`, with their inputs and secrets. No other jobs: if no shared workflow does what's needed, it doesn't go here.
- Don't add or change CI in a feature or fix PR. If the existing workflows can't build or test a change, link an existing craft-common-actions issue or PR, or open a new issue, or a PR only for a small fix that is safe for every app and does not increase CI time.
- Some workflow files here still run their own jobs. Don't add to them. Moving a job into craft-common-actions is its own task, never part of another PR, and the job stays here until a shared workflow runs it.
## Shared libraries
Before adding or changing file-format, codec, protocol, or reusable UI code, check `storytold/craft-libs` and its open PRs first; reuse or extend the shared library rather than duplicating it locally, keep app-specific policy and model mapping in the app, and preserve behavior, security/resource limits, attribution, and regression coverage during cutovers.
Generated
+84 -6
View File
@@ -853,6 +853,16 @@ 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"
@@ -863,13 +873,35 @@ name = "craft-deckcraft-format"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=254e9a409b410dc93c0e06ff66cd1e767893ac32#254e9a409b410dc93c0e06ff66cd1e767893ac32"
dependencies = [
"craft-zip",
"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-drawingml"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=cff5af869dbf6926801c9ac63a927d155202ba3b#cff5af869dbf6926801c9ac63a927d155202ba3b"
dependencies = [
"craft-xml 0.1.0 (git+https://github.com/storytold/craft-libs?rev=cff5af869dbf6926801c9ac63a927d155202ba3b)",
"kurbo",
"log",
"serde",
]
[[package]]
name = "craft-fonts-build"
version = "0.1.0"
@@ -920,13 +952,24 @@ dependencies = [
[[package]]
name = "craft-mime"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=63196e66f3033a6623eb629af95a104d26986725#63196e66f3033a6623eb629af95a104d26986725"
source = "git+https://github.com/storytold/craft-libs?rev=254e9a409b410dc93c0e06ff66cd1e767893ac32#254e9a409b410dc93c0e06ff66cd1e767893ac32"
dependencies = [
"chrono",
"craft-codepage",
"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"
@@ -941,7 +984,7 @@ name = "craft-rtf"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=63196e66f3033a6623eb629af95a104d26986725#63196e66f3033a6623eb629af95a104d26986725"
dependencies = [
"craft-codepage",
"craft-codepage 0.1.0 (git+https://github.com/storytold/craft-libs?rev=63196e66f3033a6623eb629af95a104d26986725)",
"encoding_rs",
]
@@ -1022,6 +1065,26 @@ 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=cff5af869dbf6926801c9ac63a927d155202ba3b#cff5af869dbf6926801c9ac63a927d155202ba3b"
dependencies = [
"quick-xml 0.41.0",
"serde",
"thiserror 2.0.21",
]
[[package]]
name = "craft-xml"
version = "0.1.0"
@@ -1041,6 +1104,16 @@ dependencies = [
"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"
@@ -1157,7 +1230,7 @@ dependencies = [
name = "deckcraft-color"
version = "0.19.0"
dependencies = [
"serde",
"craft-drawingml 0.1.0 (git+https://github.com/storytold/craft-libs?rev=44d83fa8f635333dcb3c231f87381387a1f5631b)",
]
[[package]]
@@ -1214,6 +1287,7 @@ dependencies = [
name = "deckcraft-geom"
version = "0.19.0"
dependencies = [
"craft-drawingml 0.1.0 (git+https://github.com/storytold/craft-libs?rev=44d83fa8f635333dcb3c231f87381387a1f5631b)",
"kurbo",
"serde",
]
@@ -1275,7 +1349,11 @@ dependencies = [
name = "deckcraft-pptx"
version = "0.19.0"
dependencies = [
"craft-xml",
"craft-cfb",
"craft-drawingml 0.1.0 (git+https://github.com/storytold/craft-libs?rev=44d83fa8f635333dcb3c231f87381387a1f5631b)",
"craft-drawingml 0.1.0 (git+https://github.com/storytold/craft-libs?rev=cff5af869dbf6926801c9ac63a927d155202ba3b)",
"craft-opc",
"craft-xml 0.1.0 (git+https://github.com/storytold/craft-libs?rev=ea24422ae9859dc5da398d0462bc87f8e02e0d10)",
"deckcraft-color",
"deckcraft-engine",
"deckcraft-geom",
+10 -2
View File
@@ -11,8 +11,16 @@ 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.
# Isolated table XML writer; existing DrawingML model/readers keep their revision.
craft-drawingml-table = { package = "craft-drawingml", git = "https://github.com/storytold/craft-libs", rev = "cff5af869dbf6926801c9ac63a927d155202ba3b" }
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" }
@@ -50,8 +58,8 @@ 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).
craft-mime = { git = "https://github.com/storytold/craft-libs", rev = "63196e66f3033a6623eb629af95a104d26986725", version = "=0.1.0" }
# 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" }
+3 -1
View File
@@ -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 |
+3
View File
@@ -148,6 +148,9 @@ fn warn_if_damaged(path: &str, opened: &serde_json::Value) {
if slides > 0 {
eprintln!("deckcraft-cli: warning: {path}: {slides} slide{} couldn't be read and left out", if slides == 1 { "" } else { "s" });
}
for w in opened.get("importWarnings").and_then(|v| v.as_array()).into_iter().flatten().filter_map(|w| w.as_str()) {
eprintln!("deckcraft-cli: warning: {path}: {w}");
}
if media > 0 {
eprintln!("deckcraft-cli: warning: {path}: {media} picture or media file{} couldn't be read", if media == 1 { "" } else { "s" });
}
+2 -1
View File
@@ -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
View File
@@ -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 => {
+52
View File
@@ -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);
+17
View File
@@ -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() };
+1 -1
View File
@@ -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
View File
@@ -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);
+74 -26
View File
@@ -433,6 +433,15 @@ pub(crate) fn shape_of(s: &Session, id: ShapeId) -> Result<deckcraft_model::Shap
pub fn xfrm_of(doc: &deckcraft_model::Presentation, sel: &crate::Selection, shape: &deckcraft_model::Shape) -> Xfrm {
let mut x = shape.xfrm.unwrap_or_else(|| ctx_xfrm(doc, sel, shape));
if let deckcraft_model::ShapeKind::Table(t) = &shape.kind {
// A loaded table may not be normalized yet: measure the bounded grid an edit will
// leave, not every cell the file stored.
let normalized;
let t = if t.is_normalized() {
t
} else {
normalized = t.normalized();
&normalized
};
let drawn: f64 = table_drawn_heights(doc, sel, t).iter().sum();
if drawn.is_finite() && drawn > x.h {
x.h = drawn;
@@ -612,43 +621,82 @@ pub fn base64_encode(data: &[u8]) -> String {
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;
let mut padded = false;
// 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'=' => {
padded = true;
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;
}
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)
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
+24 -8
View File
@@ -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();
}
+17 -9
View File
@@ -139,11 +139,13 @@ pub struct Damage {
pub media: Vec<String>,
/// Slides a `.pptx` lists but that couldn't be read, so they are not in the presentation.
pub slides: Vec<String>,
/// Content a `.pptx` had that was cut to fit a limit; the file still opened.
pub warnings: Vec<String>,
}
impl Damage {
pub fn is_empty(&self) -> bool {
self.media.is_empty() && self.slides.is_empty()
self.media.is_empty() && self.slides.is_empty() && self.warnings.is_empty()
}
}
@@ -151,17 +153,17 @@ impl Damage {
pub fn open_checked(name: &str, bytes: &[u8]) -> Result<(Presentation, Damage)> {
if deckcraft_format::sniff(bytes) {
let (p, media) = deckcraft_format::load_checked(bytes).map_err(|e| EngineError::Other(e.to_string()))?;
return Ok((p, Damage { media, slides: vec![] }));
return Ok((p, Damage { media, ..Default::default() }));
}
open_other(name, bytes).map(|(p, slides)| (p, Damage { media: vec![], slides }))
open_other(name, bytes).map(|(p, slides, warnings)| (p, Damage { slides, warnings, ..Default::default() }))
}
fn open_other(name: &str, bytes: &[u8]) -> Result<(Presentation, Vec<String>)> {
fn open_other(name: &str, bytes: &[u8]) -> Result<(Presentation, Vec<String>, Vec<String>)> {
if deckcraft_pptx::sniff(bytes) {
let (mut p, lost_slides) = deckcraft_pptx::import_checked(bytes).map_err(|e| EngineError::Other(e.to_string()))?;
let (mut p, lost_slides, warnings) = deckcraft_pptx::import_report(bytes).map_err(|e| EngineError::Other(e.to_string()))?;
deckcraft_format::repair(&mut p);
probe_clips(&mut p);
return Ok((p, lost_slides));
return Ok((p, lost_slides, warnings));
}
if deckcraft_pptx::is_encrypted(bytes) {
return Err(EngineError::Other(format!("{name} is password-protected. DeckCraft can't open password-protected presentations yet.")));
@@ -180,7 +182,7 @@ fn open_other(name: &str, bytes: &[u8]) -> Result<(Presentation, Vec<String>)> {
if p.slides.is_empty() {
p = defaults::new_presentation(None);
}
return Ok((p, vec![]));
return Ok((p, vec![], vec![]));
}
Err(EngineError::Other(format!("{name}: not a presentation DeckCraft can read")))
}
@@ -276,7 +278,7 @@ fn adopt_loaded(s: &mut Session, f: LoadedFile) -> Result<Value> {
let st = s.doc()?;
Ok(json!({
"document": i, "slides": st.doc.slides.len(), "missingFonts": st.missing_fonts,
"damagedMedia": damaged.media, "lostSlides": damaged.slides,
"damagedMedia": damaged.media, "lostSlides": damaged.slides, "importWarnings": damaged.warnings,
}))
}
@@ -311,7 +313,9 @@ fn open_bytes(s: &mut Session, p: &Value) -> Result<Value> {
let (doc, damaged) = open_checked(name, &data)?;
let i = add_opened(s, name, None, doc);
report_damage(s, &damaged)?;
Ok(json!({"document": i, "missingFonts": s.doc()?.missing_fonts, "damagedMedia": damaged.media, "lostSlides": damaged.slides}))
Ok(
json!({"document": i, "missingFonts": s.doc()?.missing_fonts, "damagedMedia": damaged.media, "lostSlides": damaged.slides, "importWarnings": damaged.warnings}),
)
}
/// Tell the user which pictures, media and slides a damaged file lost, and mark the copy repaired.
@@ -339,6 +343,10 @@ fn report_damage(s: &mut Session, damaged: &Damage) -> Result<()> {
if n == 1 { "was" } else { "were" },
));
}
for w in &damaged.warnings {
text.push_str(w);
text.push_str(". ");
}
text.push_str("It was opened as a repaired copy; save it under a new name to keep the original file.");
s.ui_requests.push(crate::UiRequest::Message { text });
Ok(())
+1 -1
View File
@@ -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));
+17 -4
View File
@@ -286,6 +286,12 @@ fn with_table(s: &mut Session, p: &Value, cmd: &str, f: impl Fn(&mut Table) -> R
};
let r = edit_shapes(s, &json!({"id": id}), cmd, |sh| match &mut sh.kind {
ShapeKind::Table(t) => {
// Edits walk the grid: bound it first (a loaded table need not be normalized yet).
// An over-cap table is refused, not trimmed: a trim would delete rows while reporting success.
if t.over_cap() {
return Err(bad(cmd, format!("the table is larger than {} cells; edit refused", deckcraft_model::table::MAX_CELLS)));
}
t.normalize();
f(t)?;
t.normalize();
let (w, h) = (t.width(), t.height());
@@ -319,10 +325,17 @@ fn rows_cols(s: &mut Session, p: &Value, op: &str, name: &'static str) -> Result
let op = op.to_string();
with_table(s, p, name, move |t| {
match op.as_str() {
"rowAbove" => t.insert_row(r),
"rowBelow" => t.insert_row(r.saturating_add(1)),
"colLeft" => t.insert_col(c),
"colRight" => t.insert_col(c.saturating_add(1)),
"rowAbove" | "rowBelow" | "colLeft" | "colRight" => {
let ok = match op.as_str() {
"rowAbove" => t.insert_row(r),
"rowBelow" => t.insert_row(r.saturating_add(1)),
"colLeft" => t.insert_col(c),
_ => t.insert_col(c.saturating_add(1)),
};
if !ok {
return Err(bad(name, format!("the table is at its {}-cell limit", deckcraft_model::table::MAX_CELLS)));
}
}
"delRow" => {
if !t.delete_row(r) {
return Err(bad(name, "can't delete the last row"));
+14 -1
View File
@@ -115,7 +115,7 @@ fn split_rows(t: &mut Table, y: f64, x0: f64, x1: f64) -> bool {
let b = match ys.iter().position(|e| (e - y).abs() <= SNAP) {
Some(b) => b,
None => {
if t.rows.len() >= MAX_GRID {
if t.rows.len() >= MAX_GRID || t.cols.len().saturating_mul(t.rows.len().saturating_add(1)) > deckcraft_model::table::MAX_CELLS {
return false;
}
let Some(k) = ys.windows(2).position(|w| w[0] < y && y < w[1]) else { return false };
@@ -273,4 +273,17 @@ mod tests {
}
assert!(t.rows.len() <= MAX_GRID && n > 100, "{} rows", t.rows.len());
}
#[test]
fn pencil_refuses_a_row_past_the_cell_cap() {
let cols = 1000;
let rows = deckcraft_model::table::MAX_CELLS / cols;
let mut t = Table {
cols: vec![10.0; cols],
rows: vec![deckcraft_model::table::Row { height: 50.0, cells: vec![Cell::new(""); cols] }; rows],
..Default::default()
};
assert!(!draw_line(&mut t, (0.0, 25.0), (10_000.0, 25.0)));
assert_eq!((t.n_rows(), t.n_cols()), (rows, cols));
}
}
+115
View File
@@ -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, &params).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, &params) {
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();
@@ -7221,6 +7297,45 @@ fn master_body_placeholder_format_keeps_per_level_formatting() {
assert_eq!(shown(&s), vec![Some(28.0), Some(24.0)]);
}
#[test]
fn table_edits_past_the_cell_cap_are_refused_not_trimmed() {
use deckcraft_model::table::{MAX_CELLS, Row};
let mut s = session();
let id = table_at(&mut s, &[100.0, 100.0], json!([["a", "b"], ["c", "d"]]));
let cols = 200;
let rows = MAX_CELLS / cols;
let big = deckcraft_model::Table {
cols: vec![1.0; cols],
rows: vec![Row { height: 1.0, cells: vec![Default::default(); cols] }; rows],
..Default::default()
};
for sl in std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().doc).slides.iter_mut() {
for sh in std::sync::Arc::make_mut(sl).shapes.iter_mut() {
if sh.id == id {
sh.kind = deckcraft_model::ShapeKind::Table(big.clone());
}
}
}
for cmd in ["table.insertRowAbove", "table.insertRowBelow"] {
let e = s.execute(cmd, &json!({"id": id.0, "row": 0})).unwrap_err().to_string();
assert!(e.contains("cell limit"), "{cmd}: {e}");
}
let e = s.execute("table.insertColumnLeft", &json!({"id": id.0, "col": 0})).unwrap_err().to_string();
assert!(e.contains("cell limit"), "{e}");
assert_eq!(table_of(&s, id), big, "a refused insert leaves every row in place");
// A table already over the cap is refused too, not trimmed behind a success.
let huge = deckcraft_model::Table { rows: vec![Row { height: 1.0, cells: vec![Default::default(); cols] }; rows + 1], ..big.clone() };
for sl in std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().doc).slides.iter_mut() {
for sh in std::sync::Arc::make_mut(sl).shapes.iter_mut() {
if sh.id == id {
sh.kind = deckcraft_model::ShapeKind::Table(huge.clone());
}
}
}
assert!(s.execute("table.deleteRow", &json!({"id": id.0, "row": 0})).is_err());
assert_eq!(table_of(&s, id).n_rows(), rows + 1);
}
/// #2059: Decrease Font Size (Ctrl+[, Cmd+Shift+,) steps down one size at a time from any size:
/// PowerPoint's list up to 96, then 8 points at a time above it, as Increase Font Size steps up.
/// A size above 66 used to shrink straight to 66.
+1 -1
View File
@@ -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();
+1
View File
@@ -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
View File
@@ -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;
-24
View File
@@ -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
-344
View File
@@ -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 }
}
-391
View File
@@ -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")
}
-799
View File
@@ -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)]);
}
}
-375
View File
@@ -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),
}
}
-420
View File
@@ -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
-338
View File
@@ -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);
}
+186 -16
View File
@@ -83,6 +83,12 @@ impl Default for Table {
}
}
/// Cells a table may hold after [`Table::normalize`] (PowerPoint's own limit is 75 x 75).
pub const MAX_CELLS: usize = 100_000;
/// Cell visits [`Table::merge`] may spend growing its rectangle over existing merges: a few
/// passes over the largest grid, where a real table needs one or two.
const MAX_MERGE_WORK: usize = 16 * MAX_CELLS;
impl Table {
pub fn new(rows: usize, cols: usize, width: f64, row_height: f64) -> Self {
let rows = rows.clamp(1, 1000);
@@ -113,15 +119,24 @@ impl Table {
self.rows.iter().map(|r| r.height).sum()
}
/// Insert an empty row before `at`. A merge the new row falls inside grows to cover it.
pub fn insert_row(&mut self, at: usize) {
/// Returns false, leaving the table as it was, when the row would take it past [`MAX_CELLS`].
pub fn insert_row(&mut self, at: usize) -> bool {
if self.cols.len().saturating_mul(self.rows.len().saturating_add(1)) > MAX_CELLS {
return false;
}
let at = at.min(self.rows.len());
let merges = self.merges();
let h = self.rows.get(at.saturating_sub(1)).map(|r| r.height).unwrap_or(30.0);
self.rows.insert(at, Row { height: h, cells: (0..self.cols.len()).map(|_| Cell::new("")).collect() });
self.set_merges(merges.into_iter().map(|m| m.insert_row(at)));
true
}
/// Insert an empty column before `at`. A merge the new column falls inside grows to cover it.
pub fn insert_col(&mut self, at: usize) {
/// Returns false, leaving the table as it was, when the column would take it past [`MAX_CELLS`].
pub fn insert_col(&mut self, at: usize) -> bool {
if self.cols.len().saturating_add(1).saturating_mul(self.rows.len()) > MAX_CELLS {
return false;
}
let at = at.min(self.cols.len());
let merges = self.merges();
let w = self.cols.get(at.saturating_sub(1)).copied().unwrap_or(80.0);
@@ -131,6 +146,7 @@ impl Table {
r.cells.insert(i, Cell::new(""));
}
self.set_merges(merges.into_iter().map(|m| m.insert_col(at)));
true
}
/// Delete row `at`. Merges through it shrink; a merge anchored on it moves its anchor (and
/// text) to the next row it covers.
@@ -170,8 +186,12 @@ impl Table {
true
}
/// The merged areas: every uncovered cell spanning more than one cell, clipped to the grid.
/// Merges of a well-formed table do not overlap, so together they cover at most the grid; a
/// file's overlapping spans past that are dropped, so rebuilding them cannot revisit cells
/// without bound.
fn merges(&self) -> Vec<Merge> {
let (nr, nc) = (self.rows.len(), self.cols.len());
let mut area = nr.saturating_mul(nc);
let mut out = vec![];
for (r, row) in self.rows.iter().enumerate() {
for (c, cell) in row.cells.iter().enumerate().take(nc) {
@@ -180,7 +200,10 @@ impl Table {
}
let rs = (cell.row_span.max(1) as usize).min(nr - r);
let gs = (cell.grid_span.max(1) as usize).min(nc - c);
if rs > 1 || gs > 1 {
if (rs > 1 || gs > 1)
&& let Some(left) = area.checked_sub(rs.saturating_mul(gs))
{
area = left;
out.push(Merge { r, c, rs, gs });
}
}
@@ -233,9 +256,17 @@ impl Table {
if r1 >= self.rows.len() || c1 >= self.cols.len() || (r0 == r1 && c0 == c1) {
return false;
}
// Grow the rectangle until no existing merge sticks out of it.
// Grow the rectangle until no existing merge sticks out of it. Each pass reads the whole
// grid and may grow it by one row, so the passes are charged against
// [`MAX_MERGE_WORK`]: past it the merge is refused, before anything changed.
let (mut r0, mut c0, mut r1, mut c1) = (r0, c0, r1, c1);
let pass = self.rows.len().saturating_mul(self.cols.len()).max(1);
let mut work = 0usize;
loop {
work = work.saturating_add(pass);
if work > MAX_MERGE_WORK {
return false;
}
let before = (r0, c0, r1, c1);
for (r, row) in self.rows.iter().enumerate() {
for (c, cell) in row.cells.iter().enumerate().take(self.cols.len()) {
@@ -289,21 +320,50 @@ impl Table {
return false;
}
// Spans come from the file and may reach past the table; only walk the cells that exist.
for rr in r..r.saturating_add(rs).min(self.rows.len()) {
for cc in c..c.saturating_add(gs).min(self.cols.len()) {
if let Some(x) = self.cell_mut(rr, cc) {
x.h_merge = false;
x.v_merge = false;
x.grid_span = 1;
x.row_span = 1;
}
let end = r.saturating_add(rs).min(self.rows.len());
let gs = gs.min(self.cols.len().saturating_sub(c));
for row in self.rows.get_mut(r..end).unwrap_or_default() {
for x in row.cells.iter_mut().skip(c).take(gs) {
x.h_merge = false;
x.v_merge = false;
x.grid_span = 1;
x.row_span = 1;
}
}
true
}
/// Make every row have exactly `cols.len()` cells (repair after loading).
pub fn normalize(&mut self) {
/// Whether the grid is as [`Table::normalize`] leaves it: within [`MAX_CELLS`], every row
/// exactly `cols.len()` cells wide.
pub fn is_normalized(&self) -> bool {
let n = self.cols.len();
n <= MAX_CELLS && self.rows.len() <= (MAX_CELLS / n.max(1)).max(1) && self.rows.iter().all(|r| r.cells.len() == n)
}
/// Whether [`Table::normalize`] would drop rows or columns to fit [`MAX_CELLS`].
pub fn over_cap(&self) -> bool {
let n = self.cols.len();
n > MAX_CELLS || self.rows.len() > (MAX_CELLS / n.max(1)).max(1)
}
/// What [`Table::normalize`] would leave of this table, cloning only the rows and cells that
/// survive (an oversized table is not copied whole first).
pub fn normalized(&self) -> Table {
let n = self.cols.len().min(MAX_CELLS);
let keep = (MAX_CELLS / n.max(1)).max(1);
let rows = self.rows.iter().take(keep).map(|r| Row { height: r.height, cells: r.cells.iter().take(n).cloned().collect() }).collect();
let mut t = Table { cols: self.cols[..n].to_vec(), rows, background: self.background.clone(), style: self.style.clone(), ..*self };
t.normalize();
if self.over_cap() {
t.clip_spans();
}
t
}
/// Make every row have exactly `cols.len()` cells (repair after loading). A grid over
/// [`MAX_CELLS`] loses its last rows (and columns) first, so a file naming many rows and many
/// columns but few cells cannot make this allocate their product.
pub fn normalize(&mut self) {
let truncated = self.over_cap();
self.cols.truncate(MAX_CELLS);
let n = self.cols.len();
self.rows.truncate((MAX_CELLS / n.max(1)).max(1));
for r in &mut self.rows {
r.cells.resize_with(n, || Cell::new(""));
for c in &mut r.cells {
@@ -311,6 +371,20 @@ impl Table {
c.row_span = c.row_span.max(1);
}
}
if truncated {
self.clip_spans();
}
}
/// Cut every merge span to the rows and columns that remain, so no merge reaches past a
/// table that lost rows or columns to the cell cap.
fn clip_spans(&mut self) {
let (nr, nc) = (self.rows.len(), self.cols.len());
for (ri, r) in self.rows.iter_mut().enumerate() {
for (ci, c) in r.cells.iter_mut().enumerate() {
c.row_span = c.row_span.min((nr - ri) as u32).max(1);
c.grid_span = c.grid_span.min((nc - ci) as u32).max(1);
}
}
}
}
@@ -519,6 +593,102 @@ mod tests {
}
}
/// Each cell spans two rows, uncovered: merging the last two rows would grow the rectangle a
/// row per pass over the whole grid, 10,000 passes. The merge is refused at its work bound
/// instead, leaving the table as it was; a small merge still works.
#[test]
fn merge_expansion_stops_at_its_work_bound() {
let mut t = Table::new(1_000, 10, 400.0, 30.0);
for row in &mut t.rows {
for c in &mut row.cells {
c.row_span = 2;
}
}
let before = t.clone();
assert!(!t.merge(998, 0, 999, 9));
assert_eq!(t, before);
let mut small = Table::new(4, 4, 400.0, 30.0);
assert!(small.merge(0, 0, 1, 1));
assert!(small.is_normalized() && !Table { cols: vec![1.0; 3], rows: vec![Row::default(); 2], ..Default::default() }.is_normalized());
}
#[test]
fn normalize_caps_a_sparse_grid_at_max_cells() {
// 1,000 columns and 1,000 empty rows would be a million cells.
let mut t = Table { cols: vec![10.0; 1000], rows: vec![Row::default(); 1000], ..Default::default() };
t.normalize();
assert_eq!(t.cols.len(), 1000);
assert_eq!(t.rows.len(), MAX_CELLS / 1000);
assert!(t.rows.iter().all(|r| r.cells.len() == 1000));
// Columns alone past the cap keep one row of MAX_CELLS cells.
let mut t = Table { cols: vec![1.0; MAX_CELLS + 5], rows: vec![Row::default(); 3], ..Default::default() };
t.normalize();
assert_eq!((t.cols.len(), t.rows.len()), (MAX_CELLS, 1));
// `normalized` leaves what `normalize` does.
let wide = Table { cols: vec![10.0; 1000], rows: vec![Row { height: 1.0, cells: vec![Cell::new("x"); 1500] }; 150], ..Default::default() };
let mut n = wide.clone();
n.normalize();
assert_eq!(wide.normalized(), n);
// A normal table is untouched.
let mut t = Table::new(4, 4, 400.0, 30.0);
t.normalize();
assert_eq!((t.n_rows(), t.n_cols()), (4, 4));
}
#[test]
fn overlapping_file_spans_rebuild_in_bounded_work() {
// Every cell an uncovered anchor spanning to the far corner: their areas add up to about
// n^4 / 4, but only what fits the grid is kept, so an edit's rebuild stays near n^2.
let n = 200;
let mut t = Table::new(n, n, 400.0, 30.0);
for row in &mut t.rows {
for c in &mut row.cells {
c.grid_span = u32::MAX;
c.row_span = u32::MAX;
}
}
assert_eq!(t.merges().len(), 1, "the first anchor already covers the whole grid");
assert!(t.insert_row(n));
assert_eq!(t.n_rows(), n + 1);
assert!(t.split(0, 0));
}
/// A table at the cell cap refuses another row or column instead of losing rows to
/// normalization, and the cap sits above PowerPoint's own 75 x 75.
#[test]
fn insert_past_the_cap_is_refused() {
const { assert!(MAX_CELLS >= 75 * 75) };
let mut t =
Table { cols: vec![1.0; 200], rows: vec![Row { height: 1.0, cells: vec![Cell::new(""); 200] }; MAX_CELLS / 200], ..Default::default() };
assert!(!t.over_cap());
let before = t.clone();
assert!(!t.insert_row(0));
assert!(!t.insert_col(0));
assert_eq!(t, before);
assert!(Table::new(75, 75, 100.0, 10.0).insert_row(0));
}
/// A merge that crosses the truncation boundary is clipped to the rows and columns that remain.
#[test]
fn merges_are_clipped_when_the_cap_drops_rows() {
let cols = 1000;
let rows = MAX_CELLS / cols + 1;
let mut t = Table { cols: vec![1.0; cols], rows: vec![Row { height: 1.0, cells: vec![Cell::new(""); cols] }; rows], ..Default::default() };
t.rows[0].cells[0].row_span = rows as u32;
t.rows[0].cells[cols - 1].grid_span = 5;
let n = t.normalized();
assert_eq!(n.rows.len(), rows - 1);
assert_eq!(n.rows[0].cells[0].row_span as usize, rows - 1);
assert_eq!(n.rows[0].cells[cols - 1].grid_span, 1);
t.normalize();
assert_eq!(t.rows[0].cells[0].row_span as usize, rows - 1);
// Within the cap, spans are left as the file wrote them.
let mut small = Table::new(3, 3, 30.0, 10.0);
small.rows[2].cells[2].grid_span = 4;
small.normalize();
assert_eq!(small.rows[2].cells[2].grid_span, 4);
}
fn merged() -> Table {
// 4x4 with a 2x2 merge at (1,1) holding "M".
let mut t = Table::new(4, 4, 400.0, 30.0);
@@ -552,10 +722,10 @@ mod tests {
fn row_and_column_edits_keep_merges_consistent() {
for at in 0..=4 {
let mut t = merged();
t.insert_row(at);
assert!(t.insert_row(at));
assert_topology(&t);
let mut t = merged();
t.insert_col(at);
assert!(t.insert_col(at));
assert_topology(&t);
}
for at in 0..4 {
+2 -2
View File
@@ -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 {
+4
View File
@@ -9,7 +9,11 @@ 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
craft-drawingml-table.workspace = true
deckcraft-model = { workspace = true }
deckcraft-geom = { workspace = true }
deckcraft-color = { workspace = true }
+16 -94
View File
@@ -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"])));
+16 -67
View File
@@ -348,73 +348,7 @@ fn arc_to(d: &mut String, cur: (f64, f64), wr: f64, hr: f64, st: f64, sw: f64) -
}
/// Parse our path syntax into commands.
pub fn parse_path(d: &str) -> Vec<(char, Vec<f64>)> {
let mut out = vec![];
let mut cmd: Option<char> = None;
let mut nums: Vec<f64> = vec![];
let flush = |cmd: Option<char>, nums: &mut Vec<f64>, out: &mut Vec<(char, Vec<f64>)>| {
if let Some(c) = cmd {
let n = match c {
'M' | 'L' => 2,
'C' => 6,
'Q' => 4,
_ => 0,
};
if n == 0 {
out.push((c, vec![]));
} else {
for (i, chunk) in nums.chunks(n).enumerate() {
if chunk.len() == n && out.len() < 1_000_000 {
// Repeated coordinates after M continue as L.
let c2 = if c == 'M' && i > 0 { 'L' } else { c };
out.push((c2, chunk.to_vec()));
}
}
}
}
nums.clear();
};
let mut token = String::new();
let push_tok = |token: &mut String, nums: &mut Vec<f64>| {
if !token.is_empty() {
if let Ok(v) = token.parse::<f64>()
&& v.is_finite()
{
nums.push(v);
}
token.clear();
}
};
let cs: Vec<char> = d.chars().collect();
for (i, &ch) in cs.iter().enumerate() {
match ch {
// An 'E' inside a number followed by a digit (or a sign and a digit) is an exponent,
// not the end command.
'E' if !token.is_empty() && {
let n1 = cs.get(i + 1).copied().unwrap_or(' ');
let n2 = cs.get(i + 2).copied().unwrap_or(' ');
n1.is_ascii_digit() || ((n1 == '-' || n1 == '+') && n2.is_ascii_digit())
} =>
{
token.push(ch)
}
'M' | 'L' | 'C' | 'Q' | 'Z' | 'm' | 'l' | 'c' | 'q' | 'z' | 'E' => {
push_tok(&mut token, &mut nums);
flush(cmd, &mut nums, &mut out);
cmd = Some(ch.to_ascii_uppercase());
}
' ' | ',' | '\t' | '\n' => push_tok(&mut token, &mut nums),
'-' if !token.is_empty() && !token.ends_with(['e', 'E']) => {
push_tok(&mut token, &mut nums);
token.push(ch);
}
c => token.push(c),
}
}
push_tok(&mut token, &mut nums);
flush(cmd, &mut nums, &mut out);
out
}
pub use craft_drawingml::custgeom::parse_path;
/// Write custom paths as `a:custGeom`. Coordinates are integers in the file, so small path spaces
/// are scaled up.
@@ -596,3 +530,18 @@ mod tests {
assert!(parse_path("garbage ### C 1").is_empty() || parse_path("garbage").is_empty());
}
}
#[cfg(test)]
mod shared_path_tests {
use super::parse_path;
#[test]
fn shared_path_tokens_preserve_exponents_repeats_and_dropped_tails() {
assert_eq!(
parse_path("M1E2 -3E-1 4 5 L6-7 Q8 9 10 11 Z"),
vec![('M', vec![100.0, -0.3]), ('L', vec![4.0, 5.0]), ('L', vec![6.0, -7.0]), ('Q', vec![8.0, 9.0, 10.0, 11.0]), ('Z', vec![]),]
);
assert_eq!(parse_path("M0 0 L1"), vec![('M', vec![0.0, 0.0])]);
assert_eq!(parse_path("MNaN 0 1 2"), vec![('M', vec![0.0, 1.0])]);
}
}
+6
View File
@@ -71,6 +71,12 @@ pub fn import_checked(bytes: &[u8]) -> Result<(Presentation, Vec<String>), PptxE
read::import_checked(bytes)
}
/// [`import_checked`], plus warnings for content cut to fit a limit (a table past the cell cap
/// keeps its leading rows); the file still opens.
pub fn import_report(bytes: &[u8]) -> Result<(Presentation, Vec<String>, Vec<String>), PptxError> {
read::import_report(bytes)
}
/// [`import`] with a lower presentation-wide chart point budget, so tests reach the over-budget
/// path without a multi-million-point chart.
#[doc(hidden)]
+24 -38
View File
@@ -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
View File
@@ -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]);
}
}
+139 -2
View File
@@ -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,12 +71,30 @@ pub struct Imp<'a> {
pub tag_bytes: usize,
/// The tag budget ran out and the warning was given.
pub tags_capped: bool,
/// What the file lost that the reader kept going past (see [`MAX_IMPORT_WARNINGS`]).
pub warnings: Vec<String>,
/// 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>,
}
/// Import warnings kept; a hostile file with many oversized tables adds no more than this.
const MAX_IMPORT_WARNINGS: usize = 32;
impl Imp<'_> {
/// Record something the file lost, and log it.
pub fn warn(&mut self, msg: String) {
log::warn!("pptx: {msg}");
if self.warnings.len() < MAX_IMPORT_WARNINGS {
self.warnings.push(msg);
}
}
pub fn alloc(&mut self) -> u32 {
self.next = self.next.saturating_add(1);
self.next
@@ -77,9 +110,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 +594,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 +604,16 @@ 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,
warnings: vec![],
theme_extra_bytes: 0,
smartart_shapes: 0,
diagram_xml_bytes: 0,
has_rels: HashMap::new(),
};
let part = Part::new(&pkg, &theme_path, &doc);
@@ -558,13 +629,24 @@ pub fn import(bytes: &[u8]) -> Result<Presentation, PptxError> {
/// or truncated slide part, or an entry whose relationship is missing): those slides are left
/// out, so a caller can say so (#203).
pub fn import_checked(bytes: &[u8]) -> Result<(Presentation, Vec<String>), PptxError> {
import_with_chart_points(bytes, chart::MAX_PRESENTATION_CHART_POINTS)
import_report(bytes).map(|(p, lost, _)| (p, lost))
}
/// [`import_checked`], plus warnings for content the file had that was cut to fit a limit (a
/// table past the cell cap keeps its leading rows).
pub fn import_report(bytes: &[u8]) -> Result<(Presentation, Vec<String>, Vec<String>), PptxError> {
import_report_with_chart_points(bytes, chart::MAX_PRESENTATION_CHART_POINTS)
}
const MAX_SLIDE_ENTRIES: usize = 10_000;
/// [`import_checked`] with the presentation's chart point budget set (tests lower it).
pub(crate) fn import_with_chart_points(bytes: &[u8], chart_points_cap: usize) -> Result<(Presentation, Vec<String>), PptxError> {
import_report_with_chart_points(bytes, chart_points_cap).map(|(p, lost, _)| (p, lost))
}
/// [`import_report`] with the presentation's chart point budget set.
fn import_report_with_chart_points(bytes: &[u8], chart_points_cap: usize) -> Result<(Presentation, Vec<String>, Vec<String>), PptxError> {
let mut lost_slides: Vec<String> = vec![];
let pkg = Package::open(bytes)?;
let root_rels = pkg.rels("");
@@ -589,6 +671,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 +681,16 @@ 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,
warnings: vec![],
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.
@@ -634,7 +722,7 @@ pub(crate) fn import_with_chart_points(bytes: &[u8], chart_points_cap: usize) ->
p.media = std::mem::take(&mut imp.media);
p.next_id = imp.next;
p.fix_next_id();
Ok((p, lost_slides))
Ok((p, lost_slides, std::mem::take(&mut imp.warnings)))
}
/// Masters, layouts and slides to read, in file order and without duplicates: (master paths,
@@ -1545,6 +1633,55 @@ 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,
warnings: vec![],
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::*;
+1
View File
@@ -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
}
+118 -22
View File
@@ -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,
})
}
@@ -785,6 +856,9 @@ fn table(imp: &mut Imp, part: &Part, tbl: &El) -> Table {
let n = t.rows.iter().map(|r| r.cells.len()).max().unwrap_or(0);
t.cols = vec![72.0; n];
}
if t.over_cap() {
imp.warn(format!("a table in {} is over {} cells; its last rows were left out", part.name, deckcraft_model::table::MAX_CELLS));
}
t.normalize();
t
}
@@ -826,3 +900,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:?}");
}
}
+11 -2
View File
@@ -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
}
+57 -244
View File
@@ -1,259 +1,72 @@
//! Table styles: our style ids ↔ table style GUIDs, and `tableStyles.xml` definitions for the
//! styles we write (generated from theme accents, matching how DeckCraft draws them).
//! Table style XML uses the shared writer; app XML admission remains unchanged.
pub use craft_drawingml::table::styles::{guid, guid_for_style, is_own_guid, style_from_guid};
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
pub fn table_styles_xml(used: &[String], defs: &[deckcraft_model::table::TableStyleDef]) -> Vec<u8> {
craft_drawingml_table::table::styles::table_styles_xml_with(used, defs.iter().map(|d| (d.id.as_str(), d.raw.as_str())), "DeckCraft", |raw| {
crate::xml::parse(raw.as_bytes()).is_ok_and(|x| x.root.is("tblStyle"))
})
}
/// 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
)
}
#[cfg(test)]
#[path = "tables_legacy.rs"]
mod legacy;
#[cfg(test)]
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);
return;
}
w.open("a:schemeClr", A::new().a("val", slot));
for (n, v) in mods {
w.val(n, v);
}
w.close("a:schemeClr");
}
fn solid(w: &mut W, slot: &str, mods: &[(&str, i32)]) {
w.open0("a:fill");
w.open0("a:solidFill");
clr(w, slot, mods);
w.close("a:solidFill");
w.close("a:fill");
}
fn borders(w: &mut W, b: Option<(&str, &[(&str, i32)], i32)>) {
w.open0("a:tcBdr");
if let Some((slot, mods, width)) = b {
for side in ["a:left", "a:right", "a:top", "a:bottom", "a:insideH", "a:insideV"] {
w.open0(side);
w.open("a:ln", A::new().a("w", width).a("cmpd", "sng"));
w.open0("a:solidFill");
clr(w, slot, mods);
w.close("a:solidFill");
w.close("a:ln");
w.close(side);
}
}
w.close("a:tcBdr");
}
fn txt(w: &mut W, bold: bool, color: Option<&str>) {
w.open("a:tcTxStyle", A::new().o("b", bold.then_some("on")));
w.open("a:fontRef", A::new().a("idx", "minor"));
w.val("a:prstClr", "black");
w.close("a:fontRef");
match color {
Some(c) => w.val("a:schemeClr", c),
None => w.val("a:schemeClr", "dk1"),
}
w.close("a:tcTxStyle");
}
/// Write one `a:tblStyle` for our style id.
fn style_def(w: &mut W, id: &str, name: &str) {
let kind = id.split('-').next().unwrap_or("medium2");
let acc = match id.rsplit('-').next().unwrap_or("accent1") {
"tx1" => "dk1",
a if a.starts_with("accent") => a,
_ => "accent1",
};
let acc: &str = acc;
w.open("a:tblStyle", A::new().a("styleId", own_guid(id)).a("styleName", name));
let part =
|w: &mut W, tag: &str, bold: bool, text: Option<&str>, fill: Option<(&str, &[(&str, i32)])>, bdr: Option<(&str, &[(&str, i32)], i32)>| {
w.open0(tag);
if bold || text.is_some() {
txt(w, bold, text);
}
w.open0("a:tcStyle");
borders(w, bdr);
if let Some((s, m)) = fill {
solid(w, s, m);
}
w.close("a:tcStyle");
w.close(tag);
};
match kind {
"grid" => {
part(w, "a:wholeTbl", false, Some("dk1"), None, Some(("dk1", &[], 9525)));
}
"light1" => {
part(w, "a:wholeTbl", false, Some("dk1"), None, None);
part(w, "a:band1H", false, None, Some((acc, &[("a:tint", 20000)])), None);
part(w, "a:band1V", false, None, Some((acc, &[("a:tint", 20000)])), None);
part(w, "a:lastCol", true, None, None, None);
part(w, "a:firstCol", true, None, None, None);
part(w, "a:lastRow", true, None, None, None);
part(w, "a:firstRow", true, None, None, Some((acc, &[], 12700)));
}
"light2" => {
part(w, "a:wholeTbl", false, Some("dk1"), None, Some((acc, &[], 12700)));
// Schema order: … lastCol, firstCol, lastRow, …, firstRow.
part(w, "a:firstCol", true, None, None, None);
part(w, "a:lastRow", true, None, None, None);
part(w, "a:firstRow", true, Some("lt1"), Some((acc, &[])), Some((acc, &[], 12700)));
}
"dark1" => {
part(w, "a:wholeTbl", false, Some("lt1"), Some((acc, &[("a:shade", 75000)])), Some(("lt1", &[], 12700)));
part(w, "a:band1H", false, None, Some((acc, &[("a:shade", 60000)])), None);
part(w, "a:band1V", false, None, Some((acc, &[("a:shade", 60000)])), None);
part(w, "a:firstCol", true, None, None, None);
part(w, "a:lastRow", true, None, None, None);
part(w, "a:firstRow", true, Some("lt1"), Some(("dk1", &[])), None);
}
"medium4" => {
part(w, "a:wholeTbl", false, Some("dk1"), Some((acc, &[("a:tint", 20000)])), Some((acc, &[], 9525)));
part(w, "a:band1H", false, None, Some((acc, &[("a:tint", 40000)])), None);
part(w, "a:band1V", false, None, Some((acc, &[("a:tint", 40000)])), None);
part(w, "a:lastCol", true, None, None, None);
part(w, "a:firstCol", true, None, None, None);
part(w, "a:lastRow", true, None, None, None);
part(w, "a:firstRow", true, None, Some((acc, &[("a:tint", 40000)])), None);
}
_ => {
// medium2
part(w, "a:wholeTbl", false, Some("dk1"), Some((acc, &[("a:tint", 20000)])), Some(("lt1", &[], 12700)));
part(w, "a:band1H", false, None, Some((acc, &[("a:tint", 40000)])), None);
part(w, "a:band1V", false, None, Some((acc, &[("a:tint", 40000)])), None);
part(w, "a:lastCol", true, Some("lt1"), Some((acc, &[])), None);
part(w, "a:firstCol", true, Some("lt1"), Some((acc, &[])), None);
part(w, "a:lastRow", true, Some("lt1"), Some((acc, &[])), None);
part(w, "a:firstRow", true, Some("lt1"), Some((acc, &[])), None);
}
}
w.close("a:tblStyle");
}
/// `ppt/tableStyles.xml` with definitions for the styles in `used`: ours, generated, and those the
/// opened file defined (`defs`), written back as they were read.
pub fn table_styles_xml(used: &[String], defs: &[deckcraft_model::table::TableStyleDef]) -> Vec<u8> {
let mut w = W::new();
w.open("a:tblStyleLst", A::new().a("xmlns:a", NS_A).a("def", "{5C22544A-7EE6-4342-B048-85BDC9FD1C3A}"));
let names = deckcraft_model::table::table_styles();
// Indexes instead of scans: written ids (as given and ASCII lower-case), and the file's
// definitions by lower-case id (the first wins).
let mut done: std::collections::HashSet<&str> = std::collections::HashSet::new();
let mut done_lower: std::collections::HashSet<String> = std::collections::HashSet::new();
let mut def_of: std::collections::HashMap<String, &deckcraft_model::table::TableStyleDef> = std::collections::HashMap::new();
for d in defs {
def_of.entry(d.id.to_ascii_lowercase()).or_insert(d);
}
for s in used {
if !done.insert(s.as_str()) {
continue;
}
done_lower.insert(s.to_ascii_lowercase());
if let Some(d) = def_of.get(&s.to_ascii_lowercase())
&& crate::xml::parse(d.raw.as_bytes()).is_ok_and(|x| x.root.is("tblStyle"))
{
w.raw(&d.raw);
continue;
}
let (_, define) = guid_for_style(s);
if !define {
continue;
}
let name = names.iter().find(|(id, _)| id == s).map(|(_, n)| format!("DeckCraft {n}")).unwrap_or_else(|| s.clone());
style_def(&mut w, s, &name);
}
// Styles the file defined but no table uses still belong to the deck.
for d in defs {
if done_lower.contains(&d.id.to_ascii_lowercase()) {
continue;
}
if crate::xml::parse(d.raw.as_bytes()).is_ok_and(|x| x.root.is("tblStyle")) {
done_lower.insert(d.id.to_ascii_lowercase());
w.raw(&d.raw);
}
}
w.close("a:tblStyleLst");
w.finish()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn shared_writer_matches_legacy_bytes_and_admission() {
use deckcraft_model::table::TableStyleDef;
let mut used: Vec<String> = deckcraft_model::table::table_styles().into_iter().map(|(id, _)| id).collect();
used.extend(["unknown<&\"".into(), "Custom".into(), "Custom".into(), "CUSTOM".into()]);
for raw in [
"<a:tblStyle xmlns:a=\"urn:test\"/>",
"<tblStyle>", // Existing lenient partial-root policy.
"<tblStyle></other><trailing/>",
"<!--prefix--><tblStyle name=\"&amp;\"/>",
"<notAStyle/>",
"",
"<tblStyle><child/></tblStyle>",
] {
let defs = vec![
TableStyleDef { id: "custom".into(), raw: raw.into(), ..Default::default() },
TableStyleDef { id: "CUSTOM".into(), raw: "<tblStyle second=\"1\"/>".into(), ..Default::default() },
TableStyleDef { id: "unused".into(), raw: "<tblStyle unused=\"1\"/>".into(), ..Default::default() },
];
for selection in [&used[..], &[][..]] {
assert_eq!(table_styles_xml(selection, &defs), legacy::table_styles_xml(selection, &defs), "{raw:?}");
}
}
for depth in [255, 256, 257] {
let raw = format!("{}{}", "<tblStyle>".repeat(depth), "</tblStyle>".repeat(depth));
let defs = [TableStyleDef { id: "custom".into(), raw, ..Default::default() }];
assert_eq!(table_styles_xml(&used, &defs), legacy::table_styles_xml(&used, &defs));
}
}
#[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] = [
+182
View File
@@ -0,0 +1,182 @@
//! Table styles: our style ids ↔ table style GUIDs, and `tableStyles.xml` definitions for the
//! styles we write (generated from theme accents, matching how DeckCraft draws them).
use crate::opc::NS_A;
use crate::xml::{A, W};
// 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};
fn own_guid(style: &str) -> String {
guid(&format!("deckcraft-table-style:{style}"))
}
fn clr(w: &mut W, slot: &str, mods: &[(&str, i32)]) {
if mods.is_empty() {
w.val("a:schemeClr", slot);
return;
}
w.open("a:schemeClr", A::new().a("val", slot));
for (n, v) in mods {
w.val(n, v);
}
w.close("a:schemeClr");
}
fn solid(w: &mut W, slot: &str, mods: &[(&str, i32)]) {
w.open0("a:fill");
w.open0("a:solidFill");
clr(w, slot, mods);
w.close("a:solidFill");
w.close("a:fill");
}
fn borders(w: &mut W, b: Option<(&str, &[(&str, i32)], i32)>) {
w.open0("a:tcBdr");
if let Some((slot, mods, width)) = b {
for side in ["a:left", "a:right", "a:top", "a:bottom", "a:insideH", "a:insideV"] {
w.open0(side);
w.open("a:ln", A::new().a("w", width).a("cmpd", "sng"));
w.open0("a:solidFill");
clr(w, slot, mods);
w.close("a:solidFill");
w.close("a:ln");
w.close(side);
}
}
w.close("a:tcBdr");
}
fn txt(w: &mut W, bold: bool, color: Option<&str>) {
w.open("a:tcTxStyle", A::new().o("b", bold.then_some("on")));
w.open("a:fontRef", A::new().a("idx", "minor"));
w.val("a:prstClr", "black");
w.close("a:fontRef");
match color {
Some(c) => w.val("a:schemeClr", c),
None => w.val("a:schemeClr", "dk1"),
}
w.close("a:tcTxStyle");
}
/// Write one `a:tblStyle` for our style id.
fn style_def(w: &mut W, id: &str, name: &str) {
let kind = id.split('-').next().unwrap_or("medium2");
let acc = match id.rsplit('-').next().unwrap_or("accent1") {
"tx1" => "dk1",
a if a.starts_with("accent") => a,
_ => "accent1",
};
let acc: &str = acc;
w.open("a:tblStyle", A::new().a("styleId", own_guid(id)).a("styleName", name));
let part =
|w: &mut W, tag: &str, bold: bool, text: Option<&str>, fill: Option<(&str, &[(&str, i32)])>, bdr: Option<(&str, &[(&str, i32)], i32)>| {
w.open0(tag);
if bold || text.is_some() {
txt(w, bold, text);
}
w.open0("a:tcStyle");
borders(w, bdr);
if let Some((s, m)) = fill {
solid(w, s, m);
}
w.close("a:tcStyle");
w.close(tag);
};
match kind {
"grid" => {
part(w, "a:wholeTbl", false, Some("dk1"), None, Some(("dk1", &[], 9525)));
}
"light1" => {
part(w, "a:wholeTbl", false, Some("dk1"), None, None);
part(w, "a:band1H", false, None, Some((acc, &[("a:tint", 20000)])), None);
part(w, "a:band1V", false, None, Some((acc, &[("a:tint", 20000)])), None);
part(w, "a:lastCol", true, None, None, None);
part(w, "a:firstCol", true, None, None, None);
part(w, "a:lastRow", true, None, None, None);
part(w, "a:firstRow", true, None, None, Some((acc, &[], 12700)));
}
"light2" => {
part(w, "a:wholeTbl", false, Some("dk1"), None, Some((acc, &[], 12700)));
// Schema order: … lastCol, firstCol, lastRow, …, firstRow.
part(w, "a:firstCol", true, None, None, None);
part(w, "a:lastRow", true, None, None, None);
part(w, "a:firstRow", true, Some("lt1"), Some((acc, &[])), Some((acc, &[], 12700)));
}
"dark1" => {
part(w, "a:wholeTbl", false, Some("lt1"), Some((acc, &[("a:shade", 75000)])), Some(("lt1", &[], 12700)));
part(w, "a:band1H", false, None, Some((acc, &[("a:shade", 60000)])), None);
part(w, "a:band1V", false, None, Some((acc, &[("a:shade", 60000)])), None);
part(w, "a:firstCol", true, None, None, None);
part(w, "a:lastRow", true, None, None, None);
part(w, "a:firstRow", true, Some("lt1"), Some(("dk1", &[])), None);
}
"medium4" => {
part(w, "a:wholeTbl", false, Some("dk1"), Some((acc, &[("a:tint", 20000)])), Some((acc, &[], 9525)));
part(w, "a:band1H", false, None, Some((acc, &[("a:tint", 40000)])), None);
part(w, "a:band1V", false, None, Some((acc, &[("a:tint", 40000)])), None);
part(w, "a:lastCol", true, None, None, None);
part(w, "a:firstCol", true, None, None, None);
part(w, "a:lastRow", true, None, None, None);
part(w, "a:firstRow", true, None, Some((acc, &[("a:tint", 40000)])), None);
}
_ => {
// medium2
part(w, "a:wholeTbl", false, Some("dk1"), Some((acc, &[("a:tint", 20000)])), Some(("lt1", &[], 12700)));
part(w, "a:band1H", false, None, Some((acc, &[("a:tint", 40000)])), None);
part(w, "a:band1V", false, None, Some((acc, &[("a:tint", 40000)])), None);
part(w, "a:lastCol", true, Some("lt1"), Some((acc, &[])), None);
part(w, "a:firstCol", true, Some("lt1"), Some((acc, &[])), None);
part(w, "a:lastRow", true, Some("lt1"), Some((acc, &[])), None);
part(w, "a:firstRow", true, Some("lt1"), Some((acc, &[])), None);
}
}
w.close("a:tblStyle");
}
/// `ppt/tableStyles.xml` with definitions for the styles in `used`: ours, generated, and those the
/// opened file defined (`defs`), written back as they were read.
pub fn table_styles_xml(used: &[String], defs: &[deckcraft_model::table::TableStyleDef]) -> Vec<u8> {
let mut w = W::new();
w.open("a:tblStyleLst", A::new().a("xmlns:a", NS_A).a("def", "{5C22544A-7EE6-4342-B048-85BDC9FD1C3A}"));
let names = deckcraft_model::table::table_styles();
// Indexes instead of scans: written ids (as given and ASCII lower-case), and the file's
// definitions by lower-case id (the first wins).
let mut done: std::collections::HashSet<&str> = std::collections::HashSet::new();
let mut done_lower: std::collections::HashSet<String> = std::collections::HashSet::new();
let mut def_of: std::collections::HashMap<String, &deckcraft_model::table::TableStyleDef> = std::collections::HashMap::new();
for d in defs {
def_of.entry(d.id.to_ascii_lowercase()).or_insert(d);
}
for s in used {
if !done.insert(s.as_str()) {
continue;
}
done_lower.insert(s.to_ascii_lowercase());
if let Some(d) = def_of.get(&s.to_ascii_lowercase())
&& crate::xml::parse(d.raw.as_bytes()).is_ok_and(|x| x.root.is("tblStyle"))
{
w.raw(&d.raw);
continue;
}
let (_, define) = guid_for_style(s);
if !define {
continue;
}
let name = names.iter().find(|(id, _)| id == s).map(|(_, n)| format!("DeckCraft {n}")).unwrap_or_else(|| s.clone());
style_def(&mut w, s, &name);
}
// Styles the file defined but no table uses still belong to the deck.
for d in defs {
if done_lower.contains(&d.id.to_ascii_lowercase()) {
continue;
}
if crate::xml::parse(d.raw.as_bytes()).is_ok_and(|x| x.root.is("tblStyle")) {
done_lower.insert(d.id.to_ascii_lowercase());
w.raw(&d.raw);
}
}
w.close("a:tblStyleLst");
w.finish()
}
+9
View File
@@ -65,6 +65,8 @@ pub struct Exp<'a> {
n_kept: u32,
pub slide_parts: HashMap<SlideId, String>,
pub table_styles: Vec<String>,
/// A table past the cell cap was met; export fails rather than write a trimmed one.
pub table_over_cap: bool,
/// The ids in `table_styles`, for checking membership without a scan.
pub table_style_set: std::collections::HashSet<String>,
placeholder: Option<String>,
@@ -558,6 +560,7 @@ pub fn export(p: &Presentation, main_ct: &str) -> Result<Vec<u8>, PptxError> {
n_kept: 0,
slide_parts: HashMap::new(),
table_styles: vec![],
table_over_cap: false,
table_style_set: Default::default(),
placeholder: None,
};
@@ -766,6 +769,12 @@ pub fn export(p: &Presentation, main_ct: &str) -> Result<Vec<u8>, PptxError> {
root.add_new(&k.rel_type, &k.name, false);
}
x.pkg.rels("", &root);
if x.table_over_cap {
return Err(PptxError::Unsupported(format!(
"a table has more than {} cells; export refused rather than drop rows",
deckcraft_model::table::MAX_CELLS
)));
}
x.pkg.finish()
}
+3 -3
View File
@@ -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));
@@ -724,8 +724,8 @@ fn frame_close(w: &mut W) {
}
fn table(w: &mut W, x: &mut Exp, o: &mut Out, t: &Table) {
let mut t = t.clone();
t.normalize();
x.table_over_cap |= t.over_cap();
let t = t.normalized();
w.open0("a:tbl");
let (guid, _) = crate::tables::guid_for_style(&t.style);
if x.table_style_set.insert(t.style.clone()) {
+38
View File
@@ -288,6 +288,44 @@ fn unreadable_slide_is_reported() {
assert_eq!(deckcraft_pptx::import(&broken).expect("import").slides.len(), 1);
}
fn table_deck(rows: usize, cols: usize) -> deckcraft_model::Presentation {
use deckcraft_model::table::Row;
use deckcraft_model::{Shape, ShapeId, ShapeKind, Table, Xfrm};
let mut p = defaults::new_presentation(None);
let id = ShapeId(p.alloc_id().expect("ids"));
let t = Table { cols: vec![1.0; cols], rows: vec![Row { height: 1.0, cells: vec![Default::default(); cols] }; rows], ..Default::default() };
let slide = std::sync::Arc::make_mut(&mut p.slides[0]);
slide.shapes.push(Shape { id, name: "T".into(), xfrm: Some(Xfrm::new(0.0, 0.0, 10.0, 10.0)), kind: ShapeKind::Table(t), ..Default::default() });
p
}
/// A table past the cell cap opens with its leading rows and an import warning; saving one that
/// is over the cap is an error, never a silent trim.
#[test]
fn oversized_table_warns_on_import_and_refuses_export() {
let max = deckcraft_model::table::MAX_CELLS;
let cols = 1000;
let rows = max / cols;
// A table exactly at the cap round-trips with no warning.
let bytes = deckcraft_pptx::export(&table_deck(rows, cols)).expect("export at the cap");
let (_, _, warnings) = deckcraft_pptx::import_report(&bytes).expect("import");
assert!(warnings.is_empty(), "{warnings:?}");
// One more row in the file: kept truncated, and reported.
let mut es = entries(&bytes);
let slide = es.iter_mut().find(|(n, _)| n == "ppt/slides/slide1.xml").expect("slide1");
let xml = String::from_utf8(std::mem::take(&mut slide.1)).expect("utf8");
let start = xml.rfind("<a:tr ").expect("row");
let end = xml.rfind("</a:tr>").expect("row end") + "</a:tr>".len();
slide.1 = format!("{}{}{}", &xml[..end], &xml[start..end], &xml[end..]).into_bytes();
let (q, _, warnings) = deckcraft_pptx::import_report(&rezip(&es)).expect("import");
assert_eq!(warnings.len(), 1, "{warnings:?}");
let t = q.slides[0].shapes.iter().find_map(|s| if let deckcraft_model::ShapeKind::Table(t) = &s.kind { Some(t) } else { None }).expect("table");
assert_eq!((t.rows.len(), t.cols.len()), (rows, cols));
// A model table past the cap is refused on export.
let err = deckcraft_pptx::export(&table_deck(rows + 1, cols)).expect_err("over the cap");
assert!(err.to_string().contains("table"), "{err}");
}
/// Missing slide relationships must not turn a damaged deck into a clean partial load (#1910).
#[test]
fn missing_slide_relationships_are_reported() {
+1 -1
View File
@@ -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)));
+63 -1
View File
@@ -232,6 +232,8 @@ pub fn gradient_editor(ui: &mut Ui, id: &str, g: &Gradient, sc: &ColorScheme) ->
let (marks, _) = ui.allocate_exact_size(vec2(bar.width(), 14.0), Sense::hover());
let drag_id = ui.scope_id().with((id, "drag"));
let mut dragging: Option<(usize, f64)> = ui.data_mut(|d| d.get_temp(drag_id));
// A double-clicked stop opens its colour menu, as in PowerPoint (#2175).
let mut open_color = false;
for (i, s) in g.stops.iter().enumerate() {
let pos = dragging.filter(|d| d.0 == i).map_or(s.pos, |d| d.1);
let x = bar.min.x + pos as f32 * bar.width();
@@ -245,6 +247,10 @@ pub fn gradient_editor(ui: &mut Ui, id: &str, g: &Gradient, sc: &ColorScheme) ->
if resp.clicked() || resp.drag_started() {
sel = i;
}
if resp.double_clicked() {
sel = i;
open_color = true;
}
if resp.dragged()
&& let Some(p) = resp.interact_pointer_pos()
{
@@ -287,7 +293,12 @@ pub fn gradient_editor(ui: &mut Ui, id: &str, g: &Gradient, sc: &ColorScheme) ->
let (sw, _) = ui.allocate_exact_size(vec2(18.0, 18.0), Sense::hover());
ui.painter().rect(sw, CornerRadius::same(3), c32(&s.color, sc), Stroke::new(1.0, t.border), egui::StrokeKind::Inside);
let r = widgets::drop_button(ui, "", vec2(24.0, 20.0), true);
widgets::color_popup(&r).show(|ui| {
r.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, true, "Stop color"));
let mut popup = widgets::color_popup(&r);
if open_color {
popup = popup.open_memory(egui::SetOpenCommand::Bool(true));
}
popup.show(|ui| {
if let Some(Some(c)) = widgets::color_grid(ui, sc, None) {
let mut ng = g.clone();
ng.stops[sel].color = with_alpha(c, alpha_of(&s.color));
@@ -516,7 +527,58 @@ pub fn pattern_editor(ui: &mut Ui, pt: &PatternFill, sc: &ColorScheme) -> Option
#[cfg(test)]
mod tests {
#![allow(clippy::unwrap_used, clippy::expect_used)]
use super::*;
use egui_kittest::Harness;
use egui_kittest::kittest::Queryable;
/// #2175: double-clicking a gradient stop selects it and opens its colour menu; a colour
/// picked there colours that stop.
#[test]
fn double_clicking_a_stop_opens_its_color_menu() {
let sc = deckcraft_model::Theme::default().colors;
let start = Gradient {
stops: vec![
GradientStop { pos: 0.0, color: ColorRef::scheme(SchemeSlot::Accent1) },
GradientStop { pos: 1.0, color: ColorRef::scheme(SchemeSlot::Accent2) },
],
..default_gradient(ColorRef::scheme(SchemeSlot::Accent1), 90.0)
};
// The gradient, and whether the interface fonts are in (they apply from the next frame).
let mut h = Harness::builder().with_size(vec2(400.0, 700.0)).with_step_dt(1.0 / 60.0).build_ui_state(
move |ui, (g, fonts): &mut (Gradient, bool)| {
if !*fonts {
theme::install_fonts(ui.ctx());
*fonts = true;
return;
}
if let Some(ng) = gradient_editor(ui, "test-grad", &g.clone(), &sc) {
*g = ng;
}
},
(start, false),
);
h.run_steps(3);
assert!(h.query_by_label("Theme Colors").is_none(), "the menu starts closed");
let stop = h.get_by_label("Gradient stop 2").rect().center();
h.hover_at(stop);
h.run_steps(1);
for _ in 0..2 {
for pressed in [true, false] {
h.event(egui::Event::PointerButton { pos: stop, button: egui::PointerButton::Primary, pressed, modifiers: egui::Modifiers::NONE });
h.run_steps(1);
}
}
h.run_steps(2);
assert!(h.query_by_label("Theme Colors").is_some(), "the colour menu opened");
h.get_by_label(SchemeSlot::Accent6.label()).click();
h.run_steps(2);
let g = &h.state().0;
assert_eq!(g.stops.len(), 2, "no stop was added");
assert_eq!(g.stops[1].color, ColorRef::scheme(SchemeSlot::Accent6), "the double-clicked stop took the colour");
assert_eq!(g.stops[0].color, ColorRef::scheme(SchemeSlot::Accent1));
}
#[test]
fn gradient_json_retains_flip_mode() {
+5 -2
View File
@@ -552,7 +552,8 @@ impl Show {
true
}
/// On entering a slide: auto-play its first step when it begins With/After Previous.
/// On entering a slide: auto-play its first step when it begins With/After Previous, once the
/// slide's transition is over.
/// `ShowState` already starts such a step when it enters the slide (#631: asking it for the
/// next step again finished the step at once, so the slide appeared fully built), so only
/// its clock starts here. Autoplay previews start an On Click first step themselves.
@@ -568,7 +569,9 @@ impl Show {
None
};
if let Some(k) = started {
self.step_start = now;
// The slide's transition plays first; its animations start when it has finished, as
// in PowerPoint (#2089).
self.step_start = self.trans.as_ref().map_or(now, |t| now.max(t.start + t.dur));
self.media_clock = Some((k, f64::NEG_INFINITY));
}
}
+35
View File
@@ -516,6 +516,41 @@ fn a_transition_keeps_the_old_slide_in_its_own_texture() {
assert!(show.tex.is_none(), "the new slide gets a texture of its own instead of overwriting the old one");
}
/// #2089: a slide's With Previous entrance waits for the slide's transition to finish, as in
/// PowerPoint, instead of playing under it.
#[test]
fn animations_start_after_the_slides_transition() {
let mut s = deckcraft_engine::Session::with_new();
s.execute("slide.new", &json!({})).unwrap();
s.execute("transition.set", &json!({"kind": "fade", "index": 1, "duration": 400})).unwrap();
let id = s.active().unwrap().doc.slides[1].shapes[0].id;
s.execute("animation.add", &json!({"effect": "fade", "class": "entrance", "ids": [id.0], "start": "withPrevious", "duration": 500})).unwrap();
let doc = s.active().unwrap().doc.clone();
let mut show = Show::new(&doc, 0, false, false);
let a = show.state.next(&doc);
assert_eq!(a, ShowAction::Slide(1));
assert!(show.apply(a, &doc, 10.0));
assert!(show.trans.is_some(), "the fade plays");
assert!(show.state.playing, "the With Previous step is under way");
assert!((show.clock_snapshot().step_start - 10.4).abs() < 1e-9, "its clock starts when the 0.4 s fade ends");
let tl = ShowState::timeline(&doc, 1);
let at = |now: f64| state_for(&tl, id, show.state.step, now - show.clock_snapshot().step_start, &[], &[]);
assert!(!at(10.3).visible, "hidden while the transition plays");
assert!(at(10.6).visible && at(10.6).opacity < 1.0, "fading in after it");
// The step is not cut short by the time the transition took.
let mut actions = Vec::new();
assert!(show.queue_clock_actions(&doc, 10.8, &mut actions));
assert!(actions.is_empty(), "0.4 s into a 0.5 s step: still playing");
// Without a transition the step starts at once, as before.
s.execute("transition.set", &json!({"kind": "none", "index": 1})).unwrap();
let doc = s.active().unwrap().doc.clone();
let mut show = Show::new(&doc, 0, false, false);
let a = show.state.next(&doc);
assert!(show.apply(a, &doc, 10.0));
assert_eq!(show.clock_snapshot().step_start, 10.0);
}
#[test]
fn going_back_plays_the_left_slides_transition_reversed() {
// #1531: Back from B to A played A's own entrance transition. PowerPoint plays the one B came
+4 -2
View File
@@ -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 |
+9
View File
@@ -1,2 +1,11 @@
sonar.projectKey=storytold_deckcraft
sonar.organization=storytold
# githubactions:S7637 asks for every action to be pinned to a commit SHA. A workflow covered by
# .github/workflows/actions.lock runs the commit the lockfile records, so its tag refs are pinned
# and the lockfile covers the actions those actions use too. Sonar does not read lockfiles yet, so
# the rule flags the tag refs anyway:
# https://community.sonarsource.com/t/githubactions-s7637-false-positives-for-actions-pinned-through-native-actions-lock/190814
sonar.issue.ignore.multicriteria=gha-lockfile
sonar.issue.ignore.multicriteria.gha-lockfile.ruleKey=githubactions:S7637
sonar.issue.ignore.multicriteria.gha-lockfile.resourceKey=.github/workflows/**