mirror of
https://github.com/storytold/deckcraft.git
synced 2026-11-20 12:54:47 -06:00
Compare commits
4
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
b16257a8b2 | ||
|
|
83d9383c79 | ||
|
|
94e7d0cf93 | ||
|
|
05d9907496 |
Generated
+48
-65
@@ -943,7 +943,7 @@ dependencies = [
|
||||
[[package]]
|
||||
name = "craft-cfb"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=ea24422ae9859dc5da398d0462bc87f8e02e0d10#ea24422ae9859dc5da398d0462bc87f8e02e0d10"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=8048f8ef92da80fb3ce5a056d59ca591ee66faf1#8048f8ef92da80fb3ce5a056d59ca591ee66faf1"
|
||||
|
||||
[[package]]
|
||||
name = "craft-codepage"
|
||||
@@ -970,20 +970,9 @@ dependencies = [
|
||||
[[package]]
|
||||
name = "craft-drawingml"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=44d83fa8f635333dcb3c231f87381387a1f5631b#44d83fa8f635333dcb3c231f87381387a1f5631b"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=8048f8ef92da80fb3ce5a056d59ca591ee66faf1#8048f8ef92da80fb3ce5a056d59ca591ee66faf1"
|
||||
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)",
|
||||
"craft-xml",
|
||||
"kurbo",
|
||||
"log",
|
||||
"serde",
|
||||
@@ -1057,10 +1046,10 @@ dependencies = [
|
||||
[[package]]
|
||||
name = "craft-opc"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=ea24422ae9859dc5da398d0462bc87f8e02e0d10#ea24422ae9859dc5da398d0462bc87f8e02e0d10"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=8048f8ef92da80fb3ce5a056d59ca591ee66faf1#8048f8ef92da80fb3ce5a056d59ca591ee66faf1"
|
||||
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)",
|
||||
"craft-xml",
|
||||
"craft-zip 0.1.0 (git+https://github.com/storytold/craft-libs?rev=8048f8ef92da80fb3ce5a056d59ca591ee66faf1)",
|
||||
"log",
|
||||
"thiserror 2.0.21",
|
||||
]
|
||||
@@ -1074,6 +1063,21 @@ dependencies = [
|
||||
"thiserror 2.0.21",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-pptx"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=8048f8ef92da80fb3ce5a056d59ca591ee66faf1#8048f8ef92da80fb3ce5a056d59ca591ee66faf1"
|
||||
dependencies = [
|
||||
"craft-drawingml",
|
||||
"craft-opc",
|
||||
"craft-xml",
|
||||
"kurbo",
|
||||
"log",
|
||||
"serde",
|
||||
"serde_json",
|
||||
"thiserror 2.0.21",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-rtf"
|
||||
version = "0.1.0"
|
||||
@@ -1164,32 +1168,13 @@ dependencies = [
|
||||
[[package]]
|
||||
name = "craft-xml"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=44d83fa8f635333dcb3c231f87381387a1f5631b#44d83fa8f635333dcb3c231f87381387a1f5631b"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=8048f8ef92da80fb3ce5a056d59ca591ee66faf1#8048f8ef92da80fb3ce5a056d59ca591ee66faf1"
|
||||
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"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=ea24422ae9859dc5da398d0462bc87f8e02e0d10#ea24422ae9859dc5da398d0462bc87f8e02e0d10"
|
||||
dependencies = [
|
||||
"quick-xml 0.41.0",
|
||||
"thiserror 2.0.21",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-zip"
|
||||
version = "0.1.0"
|
||||
@@ -1203,7 +1188,7 @@ dependencies = [
|
||||
[[package]]
|
||||
name = "craft-zip"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=ea24422ae9859dc5da398d0462bc87f8e02e0d10#ea24422ae9859dc5da398d0462bc87f8e02e0d10"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=8048f8ef92da80fb3ce5a056d59ca591ee66faf1#8048f8ef92da80fb3ce5a056d59ca591ee66faf1"
|
||||
dependencies = [
|
||||
"flate2",
|
||||
"thiserror 2.0.21",
|
||||
@@ -1283,7 +1268,7 @@ checksum = "0c87e182de0887fd5361989c677c4e8f5000cd9491d6d563161a8f3a5519fc7f"
|
||||
|
||||
[[package]]
|
||||
name = "deckcraft"
|
||||
version = "0.19.1"
|
||||
version = "0.19.0"
|
||||
dependencies = [
|
||||
"arboard",
|
||||
"chrono",
|
||||
@@ -1305,7 +1290,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "deckcraft-anim"
|
||||
version = "0.19.1"
|
||||
version = "0.19.0"
|
||||
dependencies = [
|
||||
"deckcraft-geom",
|
||||
"deckcraft-model",
|
||||
@@ -1314,7 +1299,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "deckcraft-cli"
|
||||
version = "0.19.1"
|
||||
version = "0.19.0"
|
||||
dependencies = [
|
||||
"deckcraft-engine",
|
||||
"deckcraft-mcp",
|
||||
@@ -1324,14 +1309,14 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "deckcraft-color"
|
||||
version = "0.19.1"
|
||||
version = "0.19.0"
|
||||
dependencies = [
|
||||
"craft-drawingml 0.1.0 (git+https://github.com/storytold/craft-libs?rev=44d83fa8f635333dcb3c231f87381387a1f5631b)",
|
||||
"craft-drawingml",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "deckcraft-engine"
|
||||
version = "0.19.1"
|
||||
version = "0.19.0"
|
||||
dependencies = [
|
||||
"chrono",
|
||||
"craft-mime",
|
||||
@@ -1359,7 +1344,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "deckcraft-fonts"
|
||||
version = "0.19.1"
|
||||
version = "0.19.0"
|
||||
dependencies = [
|
||||
"epaint_default_fonts",
|
||||
"harfrust 0.13.3",
|
||||
@@ -1371,7 +1356,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "deckcraft-format"
|
||||
version = "0.19.1"
|
||||
version = "0.19.0"
|
||||
dependencies = [
|
||||
"craft-deckcraft-format",
|
||||
"craft-rtf",
|
||||
@@ -1382,16 +1367,16 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "deckcraft-geom"
|
||||
version = "0.19.1"
|
||||
version = "0.19.0"
|
||||
dependencies = [
|
||||
"craft-drawingml 0.1.0 (git+https://github.com/storytold/craft-libs?rev=44d83fa8f635333dcb3c231f87381387a1f5631b)",
|
||||
"craft-drawingml",
|
||||
"kurbo",
|
||||
"serde",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "deckcraft-mcp"
|
||||
version = "0.19.1"
|
||||
version = "0.19.0"
|
||||
dependencies = [
|
||||
"craft-mcp-server",
|
||||
"deckcraft-engine",
|
||||
@@ -1402,7 +1387,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "deckcraft-media"
|
||||
version = "0.19.1"
|
||||
version = "0.19.0"
|
||||
dependencies = [
|
||||
"craft-audio",
|
||||
"craft-media",
|
||||
@@ -1415,9 +1400,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "deckcraft-model"
|
||||
version = "0.19.1"
|
||||
version = "0.19.0"
|
||||
dependencies = [
|
||||
"craft-drawingml 0.1.0 (git+https://github.com/storytold/craft-libs?rev=44d83fa8f635333dcb3c231f87381387a1f5631b)",
|
||||
"craft-drawingml",
|
||||
"deckcraft-color",
|
||||
"deckcraft-geom",
|
||||
"serde",
|
||||
@@ -1428,7 +1413,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "deckcraft-pdf"
|
||||
version = "0.19.1"
|
||||
version = "0.19.0"
|
||||
dependencies = [
|
||||
"craft-pdf",
|
||||
"deckcraft-fonts",
|
||||
@@ -1446,7 +1431,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "deckcraft-ppt"
|
||||
version = "0.19.1"
|
||||
version = "0.19.0"
|
||||
dependencies = [
|
||||
"deckcraft-color",
|
||||
"deckcraft-engine",
|
||||
@@ -1461,20 +1446,18 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "deckcraft-pptx"
|
||||
version = "0.19.1"
|
||||
version = "0.19.0"
|
||||
dependencies = [
|
||||
"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-drawingml",
|
||||
"craft-opc",
|
||||
"craft-xml 0.1.0 (git+https://github.com/storytold/craft-libs?rev=ea24422ae9859dc5da398d0462bc87f8e02e0d10)",
|
||||
"craft-pptx",
|
||||
"craft-xml",
|
||||
"deckcraft-color",
|
||||
"deckcraft-engine",
|
||||
"deckcraft-geom",
|
||||
"deckcraft-model",
|
||||
"deckcraft-text",
|
||||
"image",
|
||||
"log",
|
||||
"quick-xml 0.41.0",
|
||||
"serde_json",
|
||||
"thiserror 2.0.21",
|
||||
@@ -1483,7 +1466,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "deckcraft-render"
|
||||
version = "0.19.1"
|
||||
version = "0.19.0"
|
||||
dependencies = [
|
||||
"craft-metafile",
|
||||
"deckcraft-anim",
|
||||
@@ -1502,7 +1485,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "deckcraft-text"
|
||||
version = "0.19.1"
|
||||
version = "0.19.0"
|
||||
dependencies = [
|
||||
"chrono",
|
||||
"deckcraft-color",
|
||||
@@ -1516,7 +1499,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "deckcraft-ui-egui"
|
||||
version = "0.19.1"
|
||||
version = "0.19.0"
|
||||
dependencies = [
|
||||
"craft-ui",
|
||||
"craft-update",
|
||||
@@ -1542,7 +1525,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "deckcraft-web"
|
||||
version = "0.19.1"
|
||||
version = "0.19.0"
|
||||
dependencies = [
|
||||
"craft-web-api",
|
||||
"craft-web-host",
|
||||
@@ -6755,7 +6738,7 @@ checksum = "9440ea3e5aeabb0ac63af70daf835274065238cdd0cec83418f417eae38bacee"
|
||||
|
||||
[[package]]
|
||||
name = "xtask"
|
||||
version = "0.19.1"
|
||||
version = "0.19.0"
|
||||
dependencies = [
|
||||
"serde_json",
|
||||
]
|
||||
|
||||
+10
-10
@@ -4,23 +4,23 @@ members = ["crates/*", "apps/*", "xtask"]
|
||||
default-members = ["crates/*", "apps/deckcraft", "apps/deckcraft-cli"]
|
||||
|
||||
[workspace.package]
|
||||
version = "0.19.1"
|
||||
version = "0.19.0"
|
||||
edition = "2024"
|
||||
license = "MIT OR Apache-2.0"
|
||||
rust-version = "1.95"
|
||||
repository = "https://github.com/storytold/deckcraft"
|
||||
|
||||
[workspace.dependencies]
|
||||
# OPC part-name primitives; relationship admission stays app-local.
|
||||
craft-opc = { git = "https://github.com/storytold/craft-libs", rev = "ea24422ae9859dc5da398d0462bc87f8e02e0d10", version = "0.1.0" }
|
||||
# OPC part-name primitives and package reader/writer.
|
||||
craft-opc = { git = "https://github.com/storytold/craft-libs", rev = "8048f8ef92da80fb3ce5a056d59ca591ee66faf1", 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" }
|
||||
craft-cfb = { git = "https://github.com/storytold/craft-libs", rev = "8048f8ef92da80fb3ce5a056d59ca591ee66faf1", version = "0.1.0" }
|
||||
# Bounded XML reader and writer primitives.
|
||||
craft-xml = { git = "https://github.com/storytold/craft-libs", rev = "8048f8ef92da80fb3ce5a056d59ca591ee66faf1", version = "0.1.0" }
|
||||
# DrawingML colours, themes, charts, tables and text (craft-libs#778, #792).
|
||||
craft-drawingml = { git = "https://github.com/storytold/craft-libs", rev = "8048f8ef92da80fb3ce5a056d59ca591ee66faf1", version = "0.1.0" }
|
||||
# PresentationML PPTX/POTX/PPSX reader and writer (craft-libs#778).
|
||||
craft-pptx = { git = "https://github.com/storytold/craft-libs", rev = "8048f8ef92da80fb3ce5a056d59ca591ee66faf1", version = "0.1.0" }
|
||||
# Shared MCP stdio framing and protocol constants (craft-libs#778).
|
||||
craft-mcp-server = { git = "https://github.com/storytold/craft-libs", rev = "bc186ca719958fcce3b6ee24794277eabed14609", version = "0.1.0" }
|
||||
# internal
|
||||
|
||||
@@ -304,3 +304,73 @@ fn export_tool_lists_gif_and_its_options() {
|
||||
assert_eq!(r["result"]["isError"], true, "{r}");
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn stdio_initialize_negotiation_transcript() {
|
||||
let mut lines: Vec<Value> = craft_mcp_server::SUPPORTED_VERSIONS
|
||||
.iter()
|
||||
.enumerate()
|
||||
.map(|(i, version)| {
|
||||
json!({
|
||||
"jsonrpc": "2.0",
|
||||
"id": i + 1,
|
||||
"method": "initialize",
|
||||
"params": {"protocolVersion": version, "capabilities": {}, "clientInfo": {"name": "parity-client", "version": "1.0"}},
|
||||
})
|
||||
})
|
||||
.collect();
|
||||
lines.push(json!({
|
||||
"jsonrpc": "2.0",
|
||||
"id": 99,
|
||||
"method": "initialize",
|
||||
"params": {"protocolVersion": "1999-01-01", "capabilities": {}, "clientInfo": {"name": "parity-client", "version": "1.0"}},
|
||||
}));
|
||||
lines.push(json!({"jsonrpc": "2.0", "method": "notifications/initialized"}));
|
||||
lines.push(json!({"jsonrpc": "2.0", "id": 100, "method": "ping", "params": {}}));
|
||||
let input: String = lines.iter().map(|v| v.to_string() + "\n").collect();
|
||||
|
||||
let mut s = Server::new(Box::new(Headless::new()));
|
||||
let mut out = Vec::new();
|
||||
s.serve(std::io::Cursor::new(input), &mut out).unwrap();
|
||||
assert!(s.is_initialized());
|
||||
|
||||
let replies: Vec<Value> = std::str::from_utf8(&out).unwrap().lines().map(|l| serde_json::from_str(l).unwrap()).collect();
|
||||
assert_eq!(replies.len(), craft_mcp_server::SUPPORTED_VERSIONS.len() + 2);
|
||||
for (i, version) in craft_mcp_server::SUPPORTED_VERSIONS.iter().enumerate() {
|
||||
assert_eq!(replies[i]["id"], i + 1);
|
||||
assert_eq!(replies[i]["result"]["protocolVersion"], *version);
|
||||
assert_eq!(replies[i]["result"]["serverInfo"]["name"], "deckcraft");
|
||||
}
|
||||
let fallback = &replies[craft_mcp_server::SUPPORTED_VERSIONS.len()];
|
||||
assert_eq!(fallback["id"], 99);
|
||||
assert_eq!(fallback["result"]["protocolVersion"], craft_mcp_server::PROTOCOL_VERSION);
|
||||
let ping = &replies[craft_mcp_server::SUPPORTED_VERSIONS.len() + 1];
|
||||
assert_eq!(ping["id"], 100);
|
||||
assert_eq!(ping["result"], json!({}));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn stdio_cancel_and_batch_transcript() {
|
||||
let input = concat!(
|
||||
"{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"initialize\",\"params\":{\"protocolVersion\":\"2025-06-18\"}}\n",
|
||||
"{\"jsonrpc\":\"2.0\",\"method\":\"notifications/initialized\"}\n",
|
||||
"{\"jsonrpc\":\"2.0\",\"method\":\"notifications/cancelled\",\"params\":{\"requestId\":1,\"reason\":\"client\"}}\n",
|
||||
"[]\n",
|
||||
"[{\"jsonrpc\":\"2.0\",\"method\":\"notifications/cancelled\",\"params\":{\"requestId\":9}}]\n",
|
||||
"[{\"jsonrpc\":\"2.0\",\"id\":2,\"method\":\"ping\"},{\"jsonrpc\":\"2.0\",\"method\":\"notifications/progress\"}]\n",
|
||||
"{\"jsonrpc\":\"2.0\",\"id\":3,\"method\":\"ping\",\"params\":{}}\n"
|
||||
);
|
||||
let mut s = Server::new(Box::new(Headless::new()));
|
||||
let mut out = Vec::new();
|
||||
s.serve(std::io::Cursor::new(input), &mut out).unwrap();
|
||||
assert!(s.is_initialized());
|
||||
|
||||
let replies: Vec<Value> = std::str::from_utf8(&out).unwrap().lines().map(|l| serde_json::from_str(l).unwrap()).collect();
|
||||
assert_eq!(replies.len(), 4, "{replies:?}");
|
||||
assert_eq!(replies[0]["id"], 1);
|
||||
assert_eq!(replies[0]["result"]["serverInfo"]["name"], "deckcraft");
|
||||
assert_eq!(replies[1]["id"], Value::Null);
|
||||
assert_eq!(replies[1]["error"]["code"], -32600);
|
||||
assert_eq!(replies[2], json!([{"jsonrpc": "2.0", "id": 2, "result": {}}]));
|
||||
assert_eq!(replies[3], json!({"jsonrpc": "2.0", "id": 3, "result": {}}));
|
||||
}
|
||||
|
||||
@@ -9,19 +9,15 @@ description = "DeckCraft PPTX: Office Open XML (PresentationML/DrawingML) import
|
||||
workspace = true
|
||||
|
||||
[dependencies]
|
||||
craft-pptx.workspace = true
|
||||
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-text = { workspace = true }
|
||||
deckcraft-geom = { workspace = true }
|
||||
deckcraft-color = { workspace = true }
|
||||
quick-xml = { workspace = true }
|
||||
zip = { workspace = true }
|
||||
thiserror = { workspace = true }
|
||||
log = { workspace = true }
|
||||
|
||||
[dev-dependencies]
|
||||
deckcraft-engine = { workspace = true }
|
||||
@@ -29,4 +25,5 @@ serde_json = { workspace = true }
|
||||
deckcraft-color = { workspace = true }
|
||||
deckcraft-geom = { workspace = true }
|
||||
image = { workspace = true }
|
||||
quick-xml = { workspace = true }
|
||||
zip = { workspace = true }
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,547 +0,0 @@
|
||||
//! DrawingML custom geometry (`a:custGeom`): guide formula evaluation and conversion of
|
||||
//! `a:pathLst` to our `M L C Q Z` path syntax, and back.
|
||||
//!
|
||||
//! Formulas follow the ECMA-376 shape guide semantics (§20.1.9.11): angles are in 1/60 000 degree,
|
||||
//! and every operand is a guide name, a built-in variable or an integer literal.
|
||||
|
||||
use std::collections::HashMap;
|
||||
use std::f64::consts::PI;
|
||||
use std::fmt::Write as _;
|
||||
|
||||
use deckcraft_geom::preset::FillMode;
|
||||
use deckcraft_model::CustomPath;
|
||||
|
||||
use crate::xml::{A, El, W};
|
||||
|
||||
const DEG: f64 = 60_000.0;
|
||||
|
||||
/// Distinct path coordinate spaces whose guides are evaluated for one custom geometry; paths in
|
||||
/// further spaces are left out.
|
||||
const MAX_SPACES: usize = 16;
|
||||
|
||||
/// Guide-name bytes all cached spaces may hold between them; the first space counts towards it but is always kept.
|
||||
/// Every space copies the names, which the XML limits bound only once.
|
||||
const MAX_SPACE_NAME_BYTES: usize = 4 << 20;
|
||||
|
||||
/// Guide variables for one shape.
|
||||
pub struct Guides {
|
||||
vars: HashMap<String, f64>,
|
||||
}
|
||||
|
||||
fn to_rad(a: f64) -> f64 {
|
||||
a / DEG * PI / 180.0
|
||||
}
|
||||
|
||||
fn to_ang(r: f64) -> f64 {
|
||||
r * 180.0 / PI * DEG
|
||||
}
|
||||
|
||||
fn finite(v: f64) -> f64 {
|
||||
if v.is_finite() { v.clamp(-1.0e15, 1.0e15) } else { 0.0 }
|
||||
}
|
||||
|
||||
impl Guides {
|
||||
/// Built-in variables for a shape `w` × `h` (in the shape's coordinate units).
|
||||
pub fn new(w: f64, h: f64) -> Self {
|
||||
let (w, h) = (finite(w), finite(h));
|
||||
let ss = w.min(h);
|
||||
let ls = w.max(h);
|
||||
let mut v = HashMap::new();
|
||||
let mut set = |k: &str, x: f64| {
|
||||
v.insert(k.to_string(), x);
|
||||
};
|
||||
set("w", w);
|
||||
set("h", h);
|
||||
set("l", 0.0);
|
||||
set("t", 0.0);
|
||||
set("r", w);
|
||||
set("b", h);
|
||||
set("hc", w / 2.0);
|
||||
set("vc", h / 2.0);
|
||||
set("ss", ss);
|
||||
set("ls", ls);
|
||||
for d in [2.0, 3.0, 4.0, 5.0, 6.0, 8.0, 10.0, 12.0, 16.0, 32.0] {
|
||||
set(&format!("wd{d}"), w / d);
|
||||
set(&format!("hd{d}"), h / d);
|
||||
set(&format!("ssd{d}"), ss / d);
|
||||
}
|
||||
set("cd2", 10_800_000.0);
|
||||
set("cd4", 5_400_000.0);
|
||||
set("cd8", 2_700_000.0);
|
||||
set("3cd4", 16_200_000.0);
|
||||
set("3cd8", 8_100_000.0);
|
||||
set("5cd8", 13_500_000.0);
|
||||
set("7cd8", 18_900_000.0);
|
||||
Guides { vars: v }
|
||||
}
|
||||
/// Bytes of the guide names held.
|
||||
fn name_bytes(&self) -> usize {
|
||||
self.vars.keys().map(String::len).sum()
|
||||
}
|
||||
pub fn get(&self, name: &str) -> f64 {
|
||||
let name = name.trim();
|
||||
if let Some(v) = self.vars.get(name) {
|
||||
return *v;
|
||||
}
|
||||
name.parse::<f64>().ok().map(finite).unwrap_or(0.0)
|
||||
}
|
||||
pub fn set(&mut self, name: &str, v: f64) {
|
||||
if self.vars.len() < 10_000 {
|
||||
self.vars.insert(name.to_string(), finite(v));
|
||||
}
|
||||
}
|
||||
/// Evaluate one formula (`*/ w 1 2`).
|
||||
pub fn eval(&self, fmla: &str) -> f64 {
|
||||
let mut it = fmla.split_whitespace();
|
||||
let op = it.next().unwrap_or("");
|
||||
let args: Vec<f64> = it.take(3).map(|a| self.get(a)).collect();
|
||||
let a = |i: usize| args.get(i).copied().unwrap_or(0.0);
|
||||
let div = |n: f64, d: f64| if d == 0.0 { 0.0 } else { n / d };
|
||||
let r = match op {
|
||||
"*/" => div(a(0) * a(1), a(2)),
|
||||
"+-" => a(0) + a(1) - a(2),
|
||||
"+/" => div(a(0) + a(1), a(2)),
|
||||
"?:" => {
|
||||
if a(0) > 0.0 {
|
||||
a(1)
|
||||
} else {
|
||||
a(2)
|
||||
}
|
||||
}
|
||||
"abs" => a(0).abs(),
|
||||
"at2" => to_ang(a(1).atan2(a(0))),
|
||||
"cat2" => a(0) * a(2).atan2(a(1)).cos(),
|
||||
"sat2" => a(0) * a(2).atan2(a(1)).sin(),
|
||||
"cos" => a(0) * to_rad(a(1)).cos(),
|
||||
"sin" => a(0) * to_rad(a(1)).sin(),
|
||||
"tan" => a(0) * to_rad(a(1)).tan(),
|
||||
"max" => a(0).max(a(1)),
|
||||
"min" => a(0).min(a(1)),
|
||||
"mod" => (a(0) * a(0) + a(1) * a(1) + a(2) * a(2)).sqrt(),
|
||||
"pin" => {
|
||||
if a(1) < a(0) {
|
||||
a(0)
|
||||
} else if a(1) > a(2) {
|
||||
a(2)
|
||||
} else {
|
||||
a(1)
|
||||
}
|
||||
}
|
||||
"sqrt" => a(0).max(0.0).sqrt(),
|
||||
"val" => a(0),
|
||||
_ => 0.0,
|
||||
};
|
||||
finite(r)
|
||||
}
|
||||
/// Evaluate a list of `a:gd` elements in order.
|
||||
pub fn eval_list(&mut self, list: Option<&El>) {
|
||||
let Some(list) = list else { return };
|
||||
for gd in list.children_named("gd").take(5000) {
|
||||
let (Some(name), Some(f)) = (gd.attr("name"), gd.attr("fmla")) else { continue };
|
||||
let v = self.eval(f);
|
||||
self.set(name, v);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn num(s: &mut String, v: f64) {
|
||||
let v = finite(v);
|
||||
let r = (v * 1000.0).round() / 1000.0;
|
||||
if r == r.trunc() {
|
||||
let _ = write!(s, "{}", r as i64);
|
||||
} else {
|
||||
let _ = write!(s, "{r}");
|
||||
}
|
||||
}
|
||||
|
||||
fn pt(g: &Guides, e: &El) -> (f64, f64) {
|
||||
(g.get(e.attr("x").unwrap_or("0")), g.get(e.attr("y").unwrap_or("0")))
|
||||
}
|
||||
|
||||
/// Convert `a:custGeom` to custom paths. `w`/`h` is the shape size in EMU (used for guides and for
|
||||
/// paths that don't give their own coordinate space).
|
||||
pub fn read_cust_geom(cg: &El, w_emu: f64, h_emu: f64) -> Vec<CustomPath> {
|
||||
read_cust_geom_counting(cg, w_emu, h_emu).0
|
||||
}
|
||||
|
||||
/// [`read_cust_geom`], and how many paths were left out for lack of room in the guide caches
|
||||
/// (`(too many coordinate spaces, too many guide-name bytes)`); each cause is also logged once.
|
||||
fn read_cust_geom_counting(cg: &El, w_emu: f64, h_emu: f64) -> (Vec<CustomPath>, (usize, usize)) {
|
||||
let mut out = vec![];
|
||||
let mut dropped = (0usize, 0usize);
|
||||
let Some(pl) = cg.child("pathLst") else { return (out, dropped) };
|
||||
let mut spaces: HashMap<(u64, u64), Guides> = HashMap::new();
|
||||
let mut name_bytes = 0usize;
|
||||
let mut budget_full = false;
|
||||
// The cap on cached spaces saves guide evaluation: a geometry without guides has none to save.
|
||||
let guided = ["avLst", "gdLst"].iter().any(|n| cg.child(n).is_some_and(|l| l.elements().next().is_some()));
|
||||
for p in pl.children_named("path").take(1000) {
|
||||
let pw = p.f64("w").unwrap_or(0.0);
|
||||
let ph = p.f64("h").unwrap_or(0.0);
|
||||
// Guides are evaluated in the path's own space when it has one.
|
||||
let (gw, gh) = if pw > 0.0 || ph > 0.0 { (pw, ph) } else { (w_emu, h_emu) };
|
||||
// The guide lists are evaluated once per coordinate space, not once per path.
|
||||
let key = (gw.to_bits(), gh.to_bits());
|
||||
if !spaces.contains_key(&key) {
|
||||
if guided && (budget_full || spaces.len() >= MAX_SPACES) {
|
||||
if budget_full {
|
||||
dropped.1 += 1;
|
||||
} else {
|
||||
dropped.0 += 1;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
let mut g = Guides::new(gw, gh);
|
||||
g.eval_list(cg.child("avLst"));
|
||||
g.eval_list(cg.child("gdLst"));
|
||||
// The first space is always kept; later ones only while the cache stays within budget.
|
||||
let bytes = g.name_bytes();
|
||||
if guided && !spaces.is_empty() && name_bytes.saturating_add(bytes) > MAX_SPACE_NAME_BYTES {
|
||||
// Every space holds the same names, so no later space fits either.
|
||||
budget_full = true;
|
||||
dropped.1 += 1;
|
||||
continue;
|
||||
}
|
||||
name_bytes = name_bytes.saturating_add(bytes);
|
||||
spaces.insert(key, g);
|
||||
}
|
||||
let Some(g) = spaces.get(&key) else { continue };
|
||||
let mut d = String::new();
|
||||
let mut cur = (0.0, 0.0);
|
||||
let mut start = (0.0, 0.0);
|
||||
for c in p.elements().take(100_000) {
|
||||
match c.local() {
|
||||
"moveTo" => {
|
||||
if let Some(q) = c.child("pt") {
|
||||
cur = pt(g, q);
|
||||
start = cur;
|
||||
d.push_str("M ");
|
||||
num(&mut d, cur.0);
|
||||
d.push(' ');
|
||||
num(&mut d, cur.1);
|
||||
d.push(' ');
|
||||
}
|
||||
}
|
||||
"lnTo" => {
|
||||
if let Some(q) = c.child("pt") {
|
||||
cur = pt(g, q);
|
||||
d.push_str("L ");
|
||||
num(&mut d, cur.0);
|
||||
d.push(' ');
|
||||
num(&mut d, cur.1);
|
||||
d.push(' ');
|
||||
}
|
||||
}
|
||||
"cubicBezTo" => {
|
||||
let pts: Vec<(f64, f64)> = c.children_named("pt").map(|q| pt(g, q)).collect();
|
||||
if let [a, b, e] = pts.as_slice() {
|
||||
d.push_str("C ");
|
||||
for (x, y) in [a, b, e] {
|
||||
num(&mut d, *x);
|
||||
d.push(' ');
|
||||
num(&mut d, *y);
|
||||
d.push(' ');
|
||||
}
|
||||
cur = *e;
|
||||
}
|
||||
}
|
||||
"quadBezTo" => {
|
||||
let pts: Vec<(f64, f64)> = c.children_named("pt").map(|q| pt(g, q)).collect();
|
||||
if let [a, e] = pts.as_slice() {
|
||||
d.push_str("Q ");
|
||||
for (x, y) in [a, e] {
|
||||
num(&mut d, *x);
|
||||
d.push(' ');
|
||||
num(&mut d, *y);
|
||||
d.push(' ');
|
||||
}
|
||||
cur = *e;
|
||||
}
|
||||
}
|
||||
"arcTo" => {
|
||||
let wr = g.get(c.attr("wR").unwrap_or("0"));
|
||||
let hr = g.get(c.attr("hR").unwrap_or("0"));
|
||||
let st = g.get(c.attr("stAng").unwrap_or("0"));
|
||||
let sw = g.get(c.attr("swAng").unwrap_or("0"));
|
||||
cur = arc_to(&mut d, cur, wr, hr, st, sw);
|
||||
}
|
||||
"close" => {
|
||||
d.push_str("Z ");
|
||||
cur = start;
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
let fill = match p.attr("fill").unwrap_or("norm") {
|
||||
"none" => FillMode::None,
|
||||
"lighten" => FillMode::Lighten,
|
||||
"lightenLess" => FillMode::LightenLess,
|
||||
"darken" => FillMode::Darken,
|
||||
"darkenLess" => FillMode::DarkenLess,
|
||||
_ => FillMode::Norm,
|
||||
};
|
||||
let (ow, oh) = if pw > 0.0 || ph > 0.0 { (pw, ph) } else { (w_emu.max(1.0), h_emu.max(1.0)) };
|
||||
out.push(CustomPath { w: ow, h: oh, d: d.trim_end().to_string(), fill, stroke: p.bool("stroke").unwrap_or(true) });
|
||||
}
|
||||
if dropped.0 > 0 {
|
||||
log::warn!("pptx: a custom geometry uses more than {MAX_SPACES} distinct path coordinate spaces; {} later path(s) are not kept", dropped.0);
|
||||
}
|
||||
if dropped.1 > 0 {
|
||||
log::warn!(
|
||||
"pptx: a custom geometry's guide names pass {MAX_SPACE_NAME_BYTES} bytes across its coordinate spaces; {} later path(s) are not kept",
|
||||
dropped.1
|
||||
);
|
||||
}
|
||||
(out, dropped)
|
||||
}
|
||||
|
||||
/// Ellipse parametric angle for a visual angle `a` (radians).
|
||||
fn param(a: f64, wr: f64, hr: f64) -> f64 {
|
||||
(wr * a.sin()).atan2(hr * a.cos())
|
||||
}
|
||||
|
||||
/// Append an elliptical arc as cubic Béziers; returns the end point.
|
||||
fn arc_to(d: &mut String, cur: (f64, f64), wr: f64, hr: f64, st: f64, sw: f64) -> (f64, f64) {
|
||||
if wr.abs() < 1e-9 || hr.abs() < 1e-9 || sw == 0.0 {
|
||||
return cur;
|
||||
}
|
||||
let st_r = to_rad(st);
|
||||
let sw_r = to_rad(sw).clamp(-4.0 * PI, 4.0 * PI);
|
||||
let t0 = param(st_r, wr, hr);
|
||||
let mut t1 = param(st_r + sw_r, wr, hr);
|
||||
// Keep the sweep direction and size of the visual angle.
|
||||
let full = sw_r.abs() >= 2.0 * PI - 1e-9;
|
||||
if full {
|
||||
t1 = t0 + sw_r.signum() * 2.0 * PI;
|
||||
} else {
|
||||
while sw_r > 0.0 && t1 < t0 {
|
||||
t1 += 2.0 * PI;
|
||||
}
|
||||
while sw_r < 0.0 && t1 > t0 {
|
||||
t1 -= 2.0 * PI;
|
||||
}
|
||||
}
|
||||
let cx = cur.0 - wr * t0.cos();
|
||||
let cy = cur.1 - hr * t0.sin();
|
||||
let total = t1 - t0;
|
||||
let n = ((total.abs() / (PI / 2.0)).ceil() as usize).clamp(1, 16);
|
||||
let step = total / n as f64;
|
||||
let k = 4.0 / 3.0 * (step / 4.0).tan();
|
||||
let mut a = t0;
|
||||
let mut end = cur;
|
||||
for _ in 0..n {
|
||||
let b = a + step;
|
||||
let (ca, sa, cb, sb) = (a.cos(), a.sin(), b.cos(), b.sin());
|
||||
let p1 = (cx + wr * (ca - k * sa), cy + hr * (sa + k * ca));
|
||||
let p2 = (cx + wr * (cb + k * sb), cy + hr * (sb - k * cb));
|
||||
end = (cx + wr * cb, cy + hr * sb);
|
||||
d.push_str("C ");
|
||||
for (x, y) in [p1, p2, end] {
|
||||
num(d, x);
|
||||
d.push(' ');
|
||||
num(d, y);
|
||||
d.push(' ');
|
||||
}
|
||||
a = b;
|
||||
}
|
||||
end
|
||||
}
|
||||
|
||||
/// Parse our path syntax into commands.
|
||||
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.
|
||||
pub fn write_cust_geom(w: &mut W, paths: &[CustomPath]) {
|
||||
w.open0("a:custGeom");
|
||||
w.empty0("a:avLst");
|
||||
w.empty0("a:gdLst");
|
||||
w.empty0("a:ahLst");
|
||||
w.empty0("a:cxnLst");
|
||||
w.empty("a:rect", A::new().a("l", "l").a("t", "t").a("r", "r").a("b", "b"));
|
||||
w.open0("a:pathLst");
|
||||
for p in paths {
|
||||
let (pw, ph) = (finite(p.w).abs(), finite(p.h).abs());
|
||||
let m = pw.max(ph);
|
||||
let k = if m > 0.0 && m < 20_000.0 { 100_000.0 / m } else { 1.0 };
|
||||
let r = |v: f64| (finite(v) * k).round().clamp(-2.0e9, 2.0e9) as i64;
|
||||
let fill = match p.fill {
|
||||
FillMode::Norm => None,
|
||||
FillMode::None => Some("none"),
|
||||
FillMode::Lighten => Some("lighten"),
|
||||
FillMode::LightenLess => Some("lightenLess"),
|
||||
FillMode::Darken => Some("darken"),
|
||||
FillMode::DarkenLess => Some("darkenLess"),
|
||||
};
|
||||
let a = A::new().a("w", r(pw).max(0)).a("h", r(ph).max(0)).o("fill", fill).o("stroke", (!p.stroke).then_some("0"));
|
||||
w.open("a:path", a);
|
||||
for (c, v) in parse_path(&p.d) {
|
||||
let pts: Vec<(i64, i64)> = v
|
||||
.chunks(2)
|
||||
.filter_map(|c| match c {
|
||||
[x, y] => Some((r(*x), r(*y))),
|
||||
_ => None,
|
||||
})
|
||||
.collect();
|
||||
let tag = match c {
|
||||
'M' => "a:moveTo",
|
||||
'L' => "a:lnTo",
|
||||
'C' => "a:cubicBezTo",
|
||||
'Q' => "a:quadBezTo",
|
||||
'Z' => {
|
||||
w.empty0("a:close");
|
||||
continue;
|
||||
}
|
||||
_ => continue,
|
||||
};
|
||||
w.open0(tag);
|
||||
for (x, y) in pts {
|
||||
w.empty("a:pt", A::new().a("x", x).a("y", y));
|
||||
}
|
||||
w.close(tag);
|
||||
}
|
||||
w.close("a:path");
|
||||
}
|
||||
w.close("a:pathLst");
|
||||
w.close("a:custGeom");
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::xml::parse;
|
||||
|
||||
#[test]
|
||||
fn formulas() {
|
||||
let mut g = Guides::new(1000.0, 500.0);
|
||||
assert_eq!(g.eval("*/ w 1 2"), 500.0);
|
||||
assert_eq!(g.eval("+- w h 100"), 1400.0);
|
||||
assert_eq!(g.eval("+/ w h 3"), 500.0);
|
||||
assert_eq!(g.eval("?: -1 5 7"), 7.0);
|
||||
assert_eq!(g.eval("?: 1 5 7"), 5.0);
|
||||
assert_eq!(g.eval("abs -42"), 42.0);
|
||||
assert_eq!(g.eval("max 3 9"), 9.0);
|
||||
assert_eq!(g.eval("min 3 9"), 3.0);
|
||||
assert_eq!(g.eval("mod 3 4 0"), 5.0);
|
||||
assert_eq!(g.eval("pin 0 150 100"), 100.0);
|
||||
assert_eq!(g.eval("pin 0 -5 100"), 0.0);
|
||||
assert_eq!(g.eval("sqrt 16"), 4.0);
|
||||
assert_eq!(g.eval("val ss"), 500.0);
|
||||
assert!((g.eval("at2 1 1") - 2_700_000.0).abs() < 1e-6);
|
||||
assert!((g.eval("cos 100 5400000")).abs() < 1e-9);
|
||||
assert!((g.eval("sin 100 5400000") - 100.0).abs() < 1e-9);
|
||||
assert!((g.eval("tan 100 2700000") - 100.0).abs() < 1e-6);
|
||||
assert!((g.eval("cat2 10 1 0") - 10.0).abs() < 1e-9);
|
||||
assert!((g.eval("sat2 10 0 1") - 10.0).abs() < 1e-9);
|
||||
assert_eq!(g.eval("*/ 1 1 0"), 0.0, "division by zero is 0");
|
||||
assert_eq!(g.eval("bogus 1 2"), 0.0);
|
||||
assert_eq!(g.eval(""), 0.0);
|
||||
g.set("x1", 7.0);
|
||||
assert_eq!(g.eval("+- x1 0 2"), 5.0);
|
||||
assert_eq!(g.get("hc"), 500.0);
|
||||
assert_eq!(g.get("cd4"), 5_400_000.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn custgeom_with_guides_and_arc() {
|
||||
let x = br#"<a:custGeom xmlns:a="x"><a:avLst/><a:gdLst><a:gd name="mid" fmla="*/ w 1 2"/></a:gdLst>
|
||||
<a:pathLst><a:path w="200" h="100"><a:moveTo><a:pt x="0" y="0"/></a:moveTo><a:lnTo><a:pt x="mid" y="h"/></a:lnTo>
|
||||
<a:arcTo wR="50" hR="50" stAng="0" swAng="5400000"/><a:close/></a:path>
|
||||
<a:path w="10" h="10" fill="none" stroke="0"><a:moveTo><a:pt x="1" y="1"/></a:moveTo><a:quadBezTo><a:pt x="2" y="2"/><a:pt x="3" y="1"/></a:quadBezTo></a:path></a:pathLst></a:custGeom>"#;
|
||||
let d = parse(x).unwrap();
|
||||
let paths = read_cust_geom(&d.root, 1000.0, 1000.0);
|
||||
assert_eq!(paths.len(), 2);
|
||||
assert!(paths[0].d.starts_with("M 0 0 L 100 100 C"), "{}", paths[0].d);
|
||||
assert!(paths[0].d.ends_with('Z'));
|
||||
// The quarter arc from (100,100) with centre (50,100) ends at (50,150).
|
||||
assert!(paths[0].d.contains("50 150"), "{}", paths[0].d);
|
||||
assert_eq!(paths[1].fill, FillMode::None);
|
||||
assert!(!paths[1].stroke);
|
||||
assert_eq!(paths[1].d, "M 1 1 Q 2 2 3 1");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn paths_share_guides_and_distinct_spaces_are_capped() {
|
||||
let path = |w: usize| format!(r#"<a:path w="{w}" h="10"><a:moveTo><a:pt x="mid" y="1"/></a:moveTo></a:path>"#);
|
||||
let paths: String = (1..=40).map(|i| path(10 * i)).collect();
|
||||
let x = format!(
|
||||
r#"<a:custGeom xmlns:a="x"><a:gdLst><a:gd name="mid" fmla="*/ w 1 2"/></a:gdLst><a:pathLst>{paths}{}</a:pathLst></a:custGeom>"#,
|
||||
path(10)
|
||||
);
|
||||
let d = parse(x.as_bytes()).unwrap();
|
||||
let (out, dropped) = read_cust_geom_counting(&d.root, 1.0, 1.0);
|
||||
assert_eq!(out.len(), MAX_SPACES + 1, "16 spaces plus the repeat of the first");
|
||||
assert_eq!(dropped, (40 - MAX_SPACES, 0), "the paths of later spaces are counted, to be warned about");
|
||||
assert!(out[0].d.starts_with("M 5 1"), "{}", out[0].d);
|
||||
assert!(out[MAX_SPACES].d.starts_with("M 5 1"), "{}", out[MAX_SPACES].d);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn guide_name_bytes_across_spaces_are_budgeted() {
|
||||
let name = "n".repeat(3 << 20);
|
||||
let path = |w: usize| format!(r#"<a:path w="{w}" h="10"><a:moveTo><a:pt x="{name}" y="1"/></a:moveTo></a:path>"#);
|
||||
let x = format!(
|
||||
r#"<a:custGeom xmlns:a="x"><a:gdLst><a:gd name="{name}" fmla="*/ w 1 2"/></a:gdLst><a:pathLst>{}{}{}</a:pathLst></a:custGeom>"#,
|
||||
path(10),
|
||||
path(20),
|
||||
path(10)
|
||||
);
|
||||
let d = parse(x.as_bytes()).unwrap();
|
||||
let (out, dropped) = read_cust_geom_counting(&d.root, 1.0, 1.0);
|
||||
assert_eq!(out.len(), 2, "the second 3 MiB space is over budget and left out; the first space's repeat stays");
|
||||
assert_eq!(dropped, (0, 1), "the path left out is counted, to be warned about");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn guide_free_geometries_are_not_capped_by_space() {
|
||||
let paths: String = (1..=40).map(|i| format!(r#"<a:path w="{}" h="10"><a:moveTo><a:pt x="1" y="1"/></a:moveTo></a:path>"#, 10 * i)).collect();
|
||||
let x = format!(r#"<a:custGeom xmlns:a="x"><a:avLst/><a:gdLst/><a:pathLst>{paths}</a:pathLst></a:custGeom>"#);
|
||||
let d = parse(x.as_bytes()).unwrap();
|
||||
assert_eq!(read_cust_geom(&d.root, 1.0, 1.0).len(), 40);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn write_then_read_path() {
|
||||
let p = CustomPath { w: 100.0, h: 50.0, d: "M 0 0 L 100 0 C 100 10 90 50 50 50 Q 0 50 0 0 Z".into(), fill: FillMode::Norm, stroke: true };
|
||||
let mut w = W::frag();
|
||||
write_cust_geom(&mut w, std::slice::from_ref(&p));
|
||||
let d = parse(w.s.as_bytes()).unwrap();
|
||||
let back = read_cust_geom(&d.root, 1.0, 1.0);
|
||||
assert_eq!(back.len(), 1);
|
||||
// Scaled by 1000 (100 → 100000).
|
||||
assert_eq!(back[0].w, 100_000.0);
|
||||
assert_eq!(back[0].d, "M 0 0 L 100000 0 C 100000 10000 90000 50000 50000 50000 Q 0 50000 0 0 Z");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parse_path_uppercase_exponent() {
|
||||
assert_eq!(parse_path("M 1E-5 2 L 3 4"), vec![('M', vec![1e-5, 2.0]), ('L', vec![3.0, 4.0])]);
|
||||
assert_eq!(parse_path("M 1.5E3 2"), vec![('M', vec![1500.0, 2.0])]);
|
||||
assert_eq!(parse_path("M 1e-5 2"), vec![('M', vec![1e-5, 2.0])]);
|
||||
// An 'E' right after a number with no exponent digits is the end command.
|
||||
assert_eq!(parse_path("M 0 0E"), vec![('M', vec![0.0, 0.0]), ('E', vec![])]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parse_path_tokens() {
|
||||
let v = parse_path("M0,0 L10-5 Z");
|
||||
assert_eq!(v.len(), 3);
|
||||
assert_eq!(v[1], ('L', vec![10.0, -5.0]));
|
||||
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])]);
|
||||
}
|
||||
}
|
||||
@@ -1,910 +0,0 @@
|
||||
//! SmartArt (DrawingML diagrams): the outline ⇄ the data model, and the layout, quick style and
|
||||
//! colour definitions DeckCraft writes for its own layouts.
|
||||
//!
|
||||
//! A diagram's data part holds its points (`dgm:pt`: the document, one per node, and the
|
||||
//! transitions PowerPoint pairs with each link) and its links (`dgm:cxn` of type `parOf`, parent →
|
||||
//! child, ordered by `srcOrd`). The outline is that tree flattened depth first.
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
use deckcraft_model::{Diagram, DiagramNode};
|
||||
|
||||
use crate::xml::{A, El, W};
|
||||
|
||||
pub const NS_DGM: &str = "http://schemas.openxmlformats.org/drawingml/2006/diagram";
|
||||
pub const NS_DSP: &str = "http://schemas.microsoft.com/office/drawing/2008/diagram";
|
||||
pub const CT_DATA: &str = "application/vnd.openxmlformats-officedocument.drawingml.diagramData+xml";
|
||||
pub const CT_LAYOUT: &str = "application/vnd.openxmlformats-officedocument.drawingml.diagramLayout+xml";
|
||||
pub const CT_STYLE: &str = "application/vnd.openxmlformats-officedocument.drawingml.diagramStyle+xml";
|
||||
pub const CT_COLORS: &str = "application/vnd.openxmlformats-officedocument.drawingml.diagramColors+xml";
|
||||
pub const CT_DRAWING: &str = "application/vnd.ms-office.drawingml.diagramDrawing+xml";
|
||||
pub const RT_DRAWING: &str = "http://schemas.microsoft.com/office/2007/relationships/diagramDrawing";
|
||||
const QS_BASE: &str = "urn:microsoft.com/office/officeart/2005/8/quickstyle/";
|
||||
const CS_BASE: &str = "urn:microsoft.com/office/officeart/2005/8/colors/";
|
||||
|
||||
/// PowerPoint's quick style for a SmartArt Style.
|
||||
pub fn qs_id(style: &str) -> String {
|
||||
let s = match style {
|
||||
"subtle" => "simple3",
|
||||
"intense" => "simple5",
|
||||
"outline" => "simple4",
|
||||
"polished" => "3d1",
|
||||
"inset" => "3d2",
|
||||
"cartoon" => "3d3",
|
||||
"powder" => "3d4",
|
||||
"brick" => "3d5",
|
||||
_ => "simple1",
|
||||
};
|
||||
format!("{QS_BASE}{s}")
|
||||
}
|
||||
|
||||
/// The SmartArt Style closest to a quick style id.
|
||||
pub fn style_for(qs: &str) -> &'static str {
|
||||
match qs.rsplit('/').next().unwrap_or("") {
|
||||
"simple1" | "" => "",
|
||||
"simple4" => "outline",
|
||||
"3d1" => "polished",
|
||||
"3d2" => "inset",
|
||||
"3d3" => "cartoon",
|
||||
"3d4" => "powder",
|
||||
"3d5" => "brick",
|
||||
"simple2" | "simple3" => "subtle",
|
||||
_ => "intense",
|
||||
}
|
||||
}
|
||||
|
||||
/// PowerPoint's colour definition for Change Colors.
|
||||
pub fn cs_id(colors: &str) -> String {
|
||||
if let Some(a @ 2..=5) = colors.strip_prefix("range").and_then(|r| r.get(..1)).and_then(|n| n.parse::<u8>().ok()) {
|
||||
return format!("{CS_BASE}colorful{a}");
|
||||
}
|
||||
let grad = colors.ends_with("Grad");
|
||||
match colors.strip_prefix("accent").and_then(|r| r.get(..1)).and_then(|n| n.parse::<u8>().ok()) {
|
||||
Some(n @ 1..=6) => format!("{CS_BASE}accent{n}_{}", if grad { 3 } else { 2 }),
|
||||
_ => format!("{CS_BASE}colorful1"),
|
||||
}
|
||||
}
|
||||
|
||||
/// The accents a Change Colors choice fills shapes with, in turn.
|
||||
fn fill_accents(colors: &str) -> Vec<String> {
|
||||
if let Some(a @ 2..=5) = colors.strip_prefix("range").and_then(|r| r.get(..1)).and_then(|n| n.parse::<u8>().ok()) {
|
||||
return vec![format!("accent{a}"), format!("accent{}", a + 1)];
|
||||
}
|
||||
match colors.strip_prefix("accent").and_then(|r| r.get(..1)).and_then(|n| n.parse::<u8>().ok()) {
|
||||
Some(n @ 1..=6) => vec![format!("accent{n}")],
|
||||
_ => (1..=6).map(|k| format!("accent{k}")).collect(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Change Colors from a colour definition id: `accentN_…` keeps accent N, anything else is colourful.
|
||||
pub fn colors_for(cs: &str) -> String {
|
||||
let last = cs.rsplit('/').next().unwrap_or("");
|
||||
if let Some(a @ 2..=5) = last.strip_prefix("colorful").and_then(|n| n.parse::<u8>().ok()) {
|
||||
return format!("range{a}{}", a + 1);
|
||||
}
|
||||
let mut parts = last.strip_prefix("accent").unwrap_or("").split('_');
|
||||
match (parts.next().and_then(|n| n.parse::<u8>().ok()), parts.next()) {
|
||||
(Some(n @ 1..=6), Some("3" | "4" | "5")) => format!("accent{n}Grad"),
|
||||
(Some(n @ 1..=6), _) => format!("accent{n}"),
|
||||
_ => String::new(),
|
||||
}
|
||||
}
|
||||
/// Most nodes read from one diagram.
|
||||
const MAX_NODES: usize = 2000;
|
||||
|
||||
/// PowerPoint's built-in layout DeckCraft's layout `kind` is written as.
|
||||
pub fn layout_id(kind: &str) -> &'static str {
|
||||
match kind {
|
||||
"blockList" => "urn:microsoft.com/office/officeart/2005/8/layout/default",
|
||||
"hBulletList" => "urn:microsoft.com/office/officeart/2005/8/layout/hList1",
|
||||
"process" => "urn:microsoft.com/office/officeart/2005/8/layout/process1",
|
||||
"chevron" => "urn:microsoft.com/office/officeart/2005/8/layout/chevron1",
|
||||
"verticalProcess" => "urn:microsoft.com/office/officeart/2005/8/layout/process2",
|
||||
"stepUp" => "urn:microsoft.com/office/officeart/2009/3/layout/StepUpProcess",
|
||||
"cycle" => "urn:microsoft.com/office/officeart/2005/8/layout/cycle2",
|
||||
"blockCycle" => "urn:microsoft.com/office/officeart/2005/8/layout/cycle5",
|
||||
"radial" => "urn:microsoft.com/office/officeart/2005/8/layout/radial1",
|
||||
"hierarchy" => "urn:microsoft.com/office/officeart/2005/8/layout/hierarchy1",
|
||||
"pyramid" => "urn:microsoft.com/office/officeart/2005/8/layout/pyramid1",
|
||||
"invertedPyramid" => "urn:microsoft.com/office/officeart/2005/8/layout/pyramid3",
|
||||
"matrix" => "urn:microsoft.com/office/officeart/2005/8/layout/matrix3",
|
||||
"titledMatrix" => "urn:microsoft.com/office/officeart/2005/8/layout/matrix1",
|
||||
"pictureList" => "urn:microsoft.com/office/officeart/2005/8/layout/vList4",
|
||||
"pictureCaption" => "urn:microsoft.com/office/officeart/2005/8/layout/pList1",
|
||||
"pictureProcess" => "urn:microsoft.com/office/officeart/2005/8/layout/hProcess10",
|
||||
"pictureHList" => "urn:microsoft.com/office/officeart/2005/8/layout/pList2",
|
||||
"timeline" => "urn:microsoft.com/office/officeart/2005/8/layout/hProcess11",
|
||||
"venn" => "urn:microsoft.com/office/officeart/2005/8/layout/venn1",
|
||||
"target" => "urn:microsoft.com/office/officeart/2005/8/layout/target1",
|
||||
"textCycle" => "urn:microsoft.com/office/officeart/2005/8/layout/cycle1",
|
||||
"continuousCycle" => "urn:microsoft.com/office/officeart/2005/8/layout/cycle3",
|
||||
"horizontalHierarchy" => "urn:microsoft.com/office/officeart/2005/8/layout/hierarchy2",
|
||||
"gridMatrix" => "urn:microsoft.com/office/officeart/2005/8/layout/matrix2",
|
||||
"gear" => "urn:microsoft.com/office/officeart/2005/8/layout/gear1",
|
||||
"funnel" => "urn:microsoft.com/office/officeart/2005/8/layout/funnel1",
|
||||
"segmentedCycle" => "urn:microsoft.com/office/officeart/2005/8/layout/cycle8",
|
||||
"multidirectionalCycle" => "urn:microsoft.com/office/officeart/2005/8/layout/cycle7",
|
||||
"orgChart" => "urn:microsoft.com/office/officeart/2005/8/layout/orgChart1",
|
||||
"halfCircleOrgChart" => "urn:microsoft.com/office/officeart/2008/layout/HalfCircleOrganizationChart",
|
||||
"nameTitleOrgChart" => "urn:microsoft.com/office/officeart/2008/layout/NameandTitleOrganizationalChart",
|
||||
"verticalBoxList" => "urn:microsoft.com/office/officeart/2005/8/layout/list1",
|
||||
"trapezoidList" => "urn:microsoft.com/office/officeart/2005/8/layout/hList6",
|
||||
"tableList" => "urn:microsoft.com/office/officeart/2005/8/layout/hList3",
|
||||
"accentProcess" => "urn:microsoft.com/office/officeart/2005/8/layout/process3",
|
||||
"continuousBlockProcess" => "urn:microsoft.com/office/officeart/2005/8/layout/hProcess9",
|
||||
"bendingProcess" => "urn:microsoft.com/office/officeart/2005/8/layout/process5",
|
||||
"linearVenn" => "urn:microsoft.com/office/officeart/2005/8/layout/venn3",
|
||||
"stackedVenn" => "urn:microsoft.com/office/officeart/2005/8/layout/venn2",
|
||||
"nestedTarget" => "urn:microsoft.com/office/officeart/2005/8/layout/target2",
|
||||
"cycleMatrix" => "urn:microsoft.com/office/officeart/2005/8/layout/cycle4",
|
||||
"segmentedPyramid" => "urn:microsoft.com/office/officeart/2005/8/layout/pyramid4",
|
||||
"pie" => "urn:microsoft.com/office/officeart/2005/8/layout/chart3",
|
||||
_ => "urn:microsoft.com/office/officeart/2005/8/layout/vList2",
|
||||
}
|
||||
}
|
||||
|
||||
/// The DeckCraft layout closest to a PowerPoint layout (by its id and category).
|
||||
pub fn kind_for(layout_id: &str, category: &str) -> &'static str {
|
||||
let last = layout_id.rsplit('/').next().unwrap_or("").to_ascii_lowercase();
|
||||
// DeckCraft before Picture Accent Process got its own id wrote it as pList2 (Horizontal
|
||||
// Picture List) with its own layout part in the process category; PowerPoint's pList2 is a list.
|
||||
if last == "plist2" && category.eq_ignore_ascii_case("process") {
|
||||
return "pictureProcess";
|
||||
}
|
||||
// Exact ids first: the layouts DeckCraft writes, and their closest siblings.
|
||||
for k in [
|
||||
"blockList",
|
||||
"hBulletList",
|
||||
"process",
|
||||
"chevron",
|
||||
"verticalProcess",
|
||||
"stepUp",
|
||||
"cycle",
|
||||
"blockCycle",
|
||||
"radial",
|
||||
"hierarchy",
|
||||
"pyramid",
|
||||
"invertedPyramid",
|
||||
"matrix",
|
||||
"titledMatrix",
|
||||
"pictureList",
|
||||
"pictureCaption",
|
||||
"pictureProcess",
|
||||
"pictureHList",
|
||||
"timeline",
|
||||
"venn",
|
||||
"target",
|
||||
"textCycle",
|
||||
"continuousCycle",
|
||||
"horizontalHierarchy",
|
||||
"gridMatrix",
|
||||
"gear",
|
||||
"funnel",
|
||||
"segmentedCycle",
|
||||
"multidirectionalCycle",
|
||||
"orgChart",
|
||||
"halfCircleOrgChart",
|
||||
"nameTitleOrgChart",
|
||||
"verticalBoxList",
|
||||
"trapezoidList",
|
||||
"tableList",
|
||||
"accentProcess",
|
||||
"continuousBlockProcess",
|
||||
"bendingProcess",
|
||||
"linearVenn",
|
||||
"stackedVenn",
|
||||
"nestedTarget",
|
||||
"cycleMatrix",
|
||||
"segmentedPyramid",
|
||||
"pie",
|
||||
"list",
|
||||
] {
|
||||
if layout_id == layout_id_of(k) {
|
||||
return k;
|
||||
}
|
||||
}
|
||||
let s = format!("{last} {}", category.to_ascii_lowercase());
|
||||
if s.contains("gear") {
|
||||
"gear"
|
||||
} else if s.contains("funnel") {
|
||||
"funnel"
|
||||
} else if s.contains("venn") {
|
||||
"venn"
|
||||
} else if s.contains("target") {
|
||||
"target"
|
||||
} else if s.contains("timeline") {
|
||||
"timeline"
|
||||
} else if s.contains("nameandtitle") {
|
||||
"nameTitleOrgChart"
|
||||
} else if s.contains("orgchart") || s.contains("organizationchart") || s.contains("organizationalchart") {
|
||||
"orgChart"
|
||||
} else if s.contains("hierarchy") {
|
||||
"hierarchy"
|
||||
} else if s.contains("radial") {
|
||||
"radial"
|
||||
} else if s.contains("cycle") {
|
||||
"cycle"
|
||||
} else if s.contains("pyramid") {
|
||||
"pyramid"
|
||||
} else if s.contains("matrix") {
|
||||
"matrix"
|
||||
} else if s.contains("chevron") {
|
||||
"chevron"
|
||||
} else if s.contains("process") || s.contains("arrow") {
|
||||
"process"
|
||||
} else if last == "default" {
|
||||
"blockList"
|
||||
} else if last.starts_with("hlist") {
|
||||
"hBulletList"
|
||||
} else {
|
||||
"list"
|
||||
}
|
||||
}
|
||||
|
||||
fn layout_id_of(kind: &str) -> &'static str {
|
||||
layout_id(kind)
|
||||
}
|
||||
|
||||
fn category(kind: &str) -> &'static str {
|
||||
match kind {
|
||||
"process"
|
||||
| "chevron"
|
||||
| "verticalProcess"
|
||||
| "stepUp"
|
||||
| "pictureProcess"
|
||||
| "timeline"
|
||||
| "gear"
|
||||
| "funnel"
|
||||
| "accentProcess"
|
||||
| "continuousBlockProcess"
|
||||
| "bendingProcess" => "process",
|
||||
"venn" | "target" | "linearVenn" | "stackedVenn" | "nestedTarget" => "relationship",
|
||||
"cycle" | "blockCycle" | "radial" | "textCycle" | "continuousCycle" | "segmentedCycle" | "multidirectionalCycle" | "cycleMatrix" | "pie" => {
|
||||
"cycle"
|
||||
}
|
||||
"hierarchy" | "horizontalHierarchy" | "orgChart" | "halfCircleOrgChart" | "nameTitleOrgChart" => "hierarchy",
|
||||
"pyramid" | "invertedPyramid" | "segmentedPyramid" => "pyramid",
|
||||
"matrix" | "titledMatrix" | "gridMatrix" => "matrix",
|
||||
_ => "list",
|
||||
}
|
||||
}
|
||||
|
||||
/// A model id, stable for a given diagram (`seed`) and point number.
|
||||
fn guid(seed: u32, n: usize) -> String {
|
||||
format!("{{{seed:08X}-D1A6-4C0A-9E5B-{n:012X}}}")
|
||||
}
|
||||
|
||||
fn text(w: &mut W, t: &str) {
|
||||
w.open0("dgm:t");
|
||||
w.empty0("a:bodyPr");
|
||||
w.empty0("a:lstStyle");
|
||||
w.open0("a:p");
|
||||
if t.is_empty() {
|
||||
w.empty("a:endParaRPr", A::new().a("lang", "en-US"));
|
||||
} else {
|
||||
w.open0("a:r");
|
||||
w.empty("a:rPr", A::new().a("lang", "en-US"));
|
||||
w.elt("a:t", t);
|
||||
w.close("a:r");
|
||||
}
|
||||
w.close("a:p");
|
||||
w.close("dgm:t");
|
||||
}
|
||||
|
||||
/// `ppt/diagrams/dataN.xml` for the outline. `drawing_rel` is the slide's relationship id of the
|
||||
/// cached drawing; `pics` the data part's relationship ids of node pictures, by node index.
|
||||
pub fn data_xml(d: &Diagram, seed: u32, drawing_rel: &str, pics: &[(usize, String)]) -> Vec<u8> {
|
||||
let lo = if d.layout_id.is_empty() { layout_id(&d.kind).to_string() } else { d.layout_id.clone() };
|
||||
let mut w = W::new();
|
||||
w.open("dgm:dataModel", A::new().a("xmlns:dgm", NS_DGM).a("xmlns:a", crate::opc::NS_A).a("xmlns:r", crate::opc::NS_R));
|
||||
w.open0("dgm:ptLst");
|
||||
let doc = guid(seed, 0);
|
||||
w.open("dgm:pt", A::new().a("modelId", &doc).a("type", "doc"));
|
||||
w.empty(
|
||||
"dgm:prSet",
|
||||
A::new()
|
||||
.a("loTypeId", &lo)
|
||||
.a("loCatId", category(&d.kind))
|
||||
.a("qsTypeId", qs_id(&d.style))
|
||||
.a("qsCatId", "simple")
|
||||
.a("csTypeId", cs_id(&d.colors))
|
||||
.a("csCatId", if d.colors.starts_with("accent") { d.colors.as_str() } else { "colorful" })
|
||||
.a("phldr", "1"),
|
||||
);
|
||||
w.empty0("dgm:spPr");
|
||||
text(&mut w, "");
|
||||
w.close("dgm:pt");
|
||||
// Node k: model id 1 + 3k; its link's parent and sibling transitions 2 + 3k and 3 + 3k.
|
||||
let node = |k: usize| guid(seed, 1 + 3 * k);
|
||||
for (k, n) in d.nodes.iter().enumerate() {
|
||||
let mut a = A::new().a("modelId", node(k));
|
||||
if n.assistant {
|
||||
a = a.a("type", "asst");
|
||||
}
|
||||
w.open("dgm:pt", a);
|
||||
w.empty("dgm:prSet", A::new().a("phldrT", "[Text]"));
|
||||
w.empty0("dgm:spPr");
|
||||
text(&mut w, &n.text);
|
||||
w.close("dgm:pt");
|
||||
let cxn = guid(seed, 0x10_0000 + k);
|
||||
for (i, ty) in [(2, "parTrans"), (3, "sibTrans")] {
|
||||
w.open("dgm:pt", A::new().a("modelId", guid(seed, i + 3 * k)).a("type", ty).a("cxnId", &cxn));
|
||||
w.empty0("dgm:prSet");
|
||||
w.empty0("dgm:spPr");
|
||||
text(&mut w, "");
|
||||
w.close("dgm:pt");
|
||||
}
|
||||
}
|
||||
// A node's picture sits on the presentation point of its picture placeholder, as PowerPoint
|
||||
// stores it (`presAssocID` names the node, the blip is a relationship of the data part).
|
||||
// Name and Title: a node's title is the text of its title box's presentation point.
|
||||
for (k, n) in d.nodes.iter().enumerate() {
|
||||
if n.title.is_empty() {
|
||||
continue;
|
||||
}
|
||||
w.open("dgm:pt", A::new().a("modelId", guid(seed, 0x30_0000 + k)).a("type", "pres"));
|
||||
w.empty("dgm:prSet", A::new().a("presAssocID", node(k)).a("presName", "titleText1").a("presStyleLbl", "fgAcc1").a("custT", "1"));
|
||||
w.empty0("dgm:spPr");
|
||||
text(&mut w, &n.title);
|
||||
w.close("dgm:pt");
|
||||
}
|
||||
for (k, rid) in pics {
|
||||
if *k >= d.nodes.len() {
|
||||
continue;
|
||||
}
|
||||
w.open("dgm:pt", A::new().a("modelId", guid(seed, 0x20_0000 + k)).a("type", "pres"));
|
||||
w.empty("dgm:prSet", A::new().a("presAssocID", node(*k)).a("presName", "Image").a("presStyleLbl", "fgImgPlace1"));
|
||||
w.open0("dgm:spPr");
|
||||
w.open0("a:blipFill");
|
||||
w.empty("a:blip", A::new().a("r:embed", rid.as_str()));
|
||||
w.open0("a:stretch");
|
||||
w.empty0("a:fillRect");
|
||||
w.close("a:stretch");
|
||||
w.close("a:blipFill");
|
||||
w.close("dgm:spPr");
|
||||
w.close("dgm:pt");
|
||||
}
|
||||
w.close("dgm:ptLst");
|
||||
w.open0("dgm:cxnLst");
|
||||
let mut stack: Vec<(u8, String)> = vec![];
|
||||
let mut ords: HashMap<String, usize> = HashMap::new();
|
||||
for (k, n) in d.nodes.iter().enumerate() {
|
||||
while stack.last().is_some_and(|(l, _)| *l >= n.level) {
|
||||
stack.pop();
|
||||
}
|
||||
let parent = stack.last().map(|(_, id)| id.clone()).unwrap_or_else(|| doc.clone());
|
||||
let ord = ords.entry(parent.clone()).or_insert(0);
|
||||
w.empty(
|
||||
"dgm:cxn",
|
||||
A::new()
|
||||
.a("modelId", guid(seed, 0x10_0000 + k))
|
||||
.a("srcId", &parent)
|
||||
.a("destId", node(k))
|
||||
.a("srcOrd", *ord)
|
||||
.a("destOrd", 0)
|
||||
.a("parTransId", guid(seed, 2 + 3 * k))
|
||||
.a("sibTransId", guid(seed, 3 + 3 * k)),
|
||||
);
|
||||
*ord += 1;
|
||||
stack.push((n.level, node(k)));
|
||||
}
|
||||
w.close("dgm:cxnLst");
|
||||
w.empty0("dgm:bg");
|
||||
w.empty0("dgm:whole");
|
||||
w.open0("dgm:extLst");
|
||||
w.open("a:ext", A::new().a("uri", "http://schemas.microsoft.com/office/drawing/2008/diagram"));
|
||||
w.empty(
|
||||
"dsp:dataModelExt",
|
||||
A::new().a("xmlns:dsp", NS_DSP).a("relId", drawing_rel).a("minVer", "http://schemas.openxmlformats.org/drawingml/2006/diagram"),
|
||||
);
|
||||
w.close("a:ext");
|
||||
w.close("dgm:extLst");
|
||||
w.close("dgm:dataModel");
|
||||
w.finish()
|
||||
}
|
||||
|
||||
/// The outline of a data part: the `parOf` tree under the document point, depth first, or the data points in `ptLst` order when no `parOf` connections exist.
|
||||
pub fn outline(data: &El) -> Vec<DiagramNode> {
|
||||
outline_ids(data).into_iter().map(|(_, n)| n).collect()
|
||||
}
|
||||
|
||||
/// The relationship ids (of the data part) of node pictures, by node index in [`outline`]: the
|
||||
/// blip fill of a presentation point associated with the node.
|
||||
pub fn node_pictures(data: &El) -> Vec<(usize, String)> {
|
||||
let ids: HashMap<String, usize> = outline_ids(data).into_iter().enumerate().map(|(k, (id, _))| (id, k)).collect();
|
||||
let Some(pts) = data.child("ptLst") else { return vec![] };
|
||||
let mut out: Vec<(usize, String)> = vec![];
|
||||
for pt in pts.children_named("pt").take(MAX_NODES * 8) {
|
||||
if pt.attr("type") != Some("pres") {
|
||||
continue;
|
||||
}
|
||||
let Some(k) = pt.child("prSet").and_then(|p| p.attr("presAssocID")).and_then(|a| ids.get(a)) else { continue };
|
||||
let Some(rid) = pt.child("spPr").and_then(|s| s.child("blipFill")).and_then(|b| b.child("blip")).and_then(|b| b.attr("r:embed")) else {
|
||||
continue;
|
||||
};
|
||||
if !out.iter().any(|(j, _)| j == k) {
|
||||
out.push((*k, rid.to_string()));
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// Extracts diagram outline `(modelId, DiagramNode)` pairs in tree order from a `dgm:dataModel` element.
|
||||
fn outline_ids(data: &El) -> Vec<(String, DiagramNode)> {
|
||||
let Some(pts) = data.child("ptLst") else { return vec![] };
|
||||
let mut texts: HashMap<&str, String> = HashMap::new();
|
||||
let mut assistants: std::collections::HashSet<&str> = std::collections::HashSet::new();
|
||||
let mut titles: HashMap<&str, String> = HashMap::new();
|
||||
let mut pt_order: Vec<&str> = Vec::new();
|
||||
let mut doc: Option<&str> = None;
|
||||
for pt in pts.children_named("pt").take(MAX_NODES * 4) {
|
||||
let Some(id) = pt.attr("modelId") else { continue };
|
||||
match pt.attr("type").unwrap_or("node") {
|
||||
"doc" => doc = doc.or(Some(id)),
|
||||
ty @ ("node" | "asst") => {
|
||||
let t = pt.child("t").map(paragraphs).unwrap_or_default();
|
||||
texts.insert(id, t);
|
||||
pt_order.push(id);
|
||||
if ty == "asst" {
|
||||
assistants.insert(id);
|
||||
}
|
||||
}
|
||||
"pres" => {
|
||||
// Name and Title: the title box's own text, on its presentation point.
|
||||
let pr = pt.child("prSet");
|
||||
if pr.and_then(|p| p.attr("presName")).is_some_and(|n| n.starts_with("titleText"))
|
||||
&& let Some(node) = pr.and_then(|p| p.attr("presAssocID"))
|
||||
&& let Some(t) = pt.child("t").map(paragraphs).filter(|t| !t.is_empty())
|
||||
{
|
||||
titles.insert(node, t);
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
let mut kids: HashMap<&str, Vec<(i64, &str)>> = HashMap::new();
|
||||
if let Some(cx) = data.child("cxnLst") {
|
||||
for c in cx.children_named("cxn").take(MAX_NODES * 4) {
|
||||
if c.attr("type").unwrap_or("parOf") != "parOf" {
|
||||
continue;
|
||||
}
|
||||
let (Some(src), Some(dst)) = (c.attr("srcId"), c.attr("destId")) else { continue };
|
||||
if texts.contains_key(dst) {
|
||||
kids.entry(src).or_default().push((c.i64("srcOrd").unwrap_or(0), dst));
|
||||
}
|
||||
}
|
||||
}
|
||||
for v in kids.values_mut() {
|
||||
v.sort_by_key(|(o, _)| *o);
|
||||
}
|
||||
let mut out = vec![];
|
||||
let mut seen = std::collections::HashSet::new();
|
||||
// Depth first, iteratively; a node reached twice (a cycle in a hostile file) is skipped.
|
||||
let mut stack: Vec<(&str, u8)> = doc.and_then(|d| kids.get(d)).map(|v| v.iter().rev().map(|(_, id)| (*id, 0u8)).collect()).unwrap_or_default();
|
||||
while let Some((id, level)) = stack.pop() {
|
||||
if out.len() >= MAX_NODES || !seen.insert(id) {
|
||||
continue;
|
||||
}
|
||||
out.push((
|
||||
id.to_string(),
|
||||
DiagramNode {
|
||||
text: texts.get(id).cloned().unwrap_or_default(),
|
||||
level: level.min(8),
|
||||
picture: None,
|
||||
assistant: assistants.contains(id),
|
||||
title: titles.get(id).cloned().unwrap_or_default(),
|
||||
},
|
||||
));
|
||||
if let Some(v) = kids.get(id) {
|
||||
stack.extend(v.iter().rev().map(|(_, c)| (*c, level.saturating_add(1))));
|
||||
}
|
||||
}
|
||||
if out.is_empty() && kids.is_empty() {
|
||||
for id in pt_order {
|
||||
if out.len() >= MAX_NODES || !seen.insert(id) {
|
||||
continue;
|
||||
}
|
||||
out.push((
|
||||
id.to_string(),
|
||||
DiagramNode {
|
||||
text: texts.get(id).cloned().unwrap_or_default(),
|
||||
level: 0,
|
||||
picture: None,
|
||||
assistant: assistants.contains(id),
|
||||
title: titles.get(id).cloned().unwrap_or_default(),
|
||||
},
|
||||
));
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// A text body's paragraphs joined by spaces.
|
||||
fn paragraphs(t: &El) -> String {
|
||||
t.children_named("p")
|
||||
.map(|p| {
|
||||
let mut v = vec![];
|
||||
p.find_all("t", &mut v);
|
||||
v.iter().map(|e| e.text()).collect::<String>()
|
||||
})
|
||||
.filter(|s| !s.trim().is_empty())
|
||||
.collect::<Vec<_>>()
|
||||
.join(" ")
|
||||
}
|
||||
|
||||
/// The layout algorithm and node shape of a DeckCraft layout.
|
||||
fn alg(kind: &str) -> (&'static str, Vec<(&'static str, &'static str)>, &'static str) {
|
||||
match kind {
|
||||
"process" | "stepUp" | "pictureProcess" | "pictureCaption" | "pictureHList" | "timeline" => {
|
||||
("lin", vec![("linDir", "fromL"), ("nodeVertAlign", "mid")], "roundRect")
|
||||
}
|
||||
"chevron" => ("lin", vec![("linDir", "fromL"), ("nodeVertAlign", "mid")], "chevron"),
|
||||
"verticalProcess" => ("lin", vec![("linDir", "fromT"), ("nodeHorzAlign", "ctr")], "roundRect"),
|
||||
"cycle"
|
||||
| "radial"
|
||||
| "venn"
|
||||
| "target"
|
||||
| "textCycle"
|
||||
| "continuousCycle"
|
||||
| "gear"
|
||||
| "segmentedCycle"
|
||||
| "multidirectionalCycle"
|
||||
| "cycleMatrix"
|
||||
| "pie" => ("cycle", vec![("stAng", "0"), ("spanAng", "360")], "ellipse"),
|
||||
"blockCycle" => ("cycle", vec![("stAng", "0"), ("spanAng", "360")], "roundRect"),
|
||||
"pyramid" | "invertedPyramid" | "segmentedPyramid" => {
|
||||
("pyra", vec![("linDir", if kind == "pyramid" { "fromT" } else { "fromB" }), ("txDir", "fromT"), ("pyraAcctPos", "bef")], "trapezoid")
|
||||
}
|
||||
"matrix" | "titledMatrix" | "gridMatrix" | "blockList" => (
|
||||
"snake",
|
||||
vec![("grDir", "tL"), ("flowDir", "row"), ("contDir", "sameDir"), ("off", "ctr")],
|
||||
if kind == "blockList" { "rect" } else { "roundRect" },
|
||||
),
|
||||
"hBulletList" => ("lin", vec![("linDir", "fromL"), ("nodeVertAlign", "t")], "roundRect"),
|
||||
_ => ("lin", vec![("linDir", "fromT"), ("vertAlign", "mid")], "roundRect"),
|
||||
}
|
||||
}
|
||||
|
||||
fn node_layout(w: &mut W, shape: &str, bullets: bool) {
|
||||
w.open("dgm:layoutNode", A::new().a("name", "node"));
|
||||
w.open0("dgm:varLst");
|
||||
w.empty("dgm:bulletEnabled", A::new().a("val", if bullets { "1" } else { "0" }));
|
||||
w.close("dgm:varLst");
|
||||
w.empty("dgm:alg", A::new().a("type", "tx"));
|
||||
w.open("dgm:shape", A::new().a("type", shape).a("r:blip", ""));
|
||||
w.empty0("dgm:adjLst");
|
||||
w.close("dgm:shape");
|
||||
w.empty("dgm:presOf", A::new().a("axis", if bullets { "desOrSelf" } else { "self" }).a("ptType", "node"));
|
||||
w.open0("dgm:constrLst");
|
||||
for side in ["tMarg", "bMarg", "lMarg", "rMarg"] {
|
||||
w.empty("dgm:constr", A::new().a("type", side).a("refType", "primFontSz").a("fact", "0.3"));
|
||||
}
|
||||
w.close("dgm:constrLst");
|
||||
w.open0("dgm:ruleLst");
|
||||
w.empty("dgm:rule", A::new().a("type", "primFontSz").a("val", "5").a("fact", "NaN").a("max", "NaN"));
|
||||
w.close("dgm:ruleLst");
|
||||
w.close("dgm:layoutNode");
|
||||
}
|
||||
|
||||
fn space(w: &mut W) {
|
||||
w.open("dgm:forEach", A::new().a("name", "sibling").a("axis", "followSib").a("ptType", "sibTrans").a("cnt", "1"));
|
||||
w.open("dgm:layoutNode", A::new().a("name", "space"));
|
||||
w.empty("dgm:alg", A::new().a("type", "sp"));
|
||||
w.open("dgm:shape", A::new().a("r:blip", ""));
|
||||
w.empty0("dgm:adjLst");
|
||||
w.close("dgm:shape");
|
||||
w.empty0("dgm:presOf");
|
||||
w.empty0("dgm:constrLst");
|
||||
w.empty0("dgm:ruleLst");
|
||||
w.close("dgm:layoutNode");
|
||||
w.close("dgm:forEach");
|
||||
}
|
||||
|
||||
/// `ppt/diagrams/layoutN.xml`: a layout definition for DeckCraft's layout `kind`, under the id of
|
||||
/// the closest built-in PowerPoint layout.
|
||||
pub fn layout_xml(kind: &str) -> Vec<u8> {
|
||||
let mut w = W::new();
|
||||
w.open(
|
||||
"dgm:layoutDef",
|
||||
A::new().a("xmlns:dgm", NS_DGM).a("xmlns:a", crate::opc::NS_A).a("xmlns:r", crate::opc::NS_R).a("uniqueId", layout_id(kind)),
|
||||
);
|
||||
w.empty("dgm:title", A::new().a("val", ""));
|
||||
w.empty("dgm:desc", A::new().a("val", ""));
|
||||
w.open0("dgm:catLst");
|
||||
w.empty("dgm:cat", A::new().a("type", category(kind)).a("pri", "1000"));
|
||||
w.close("dgm:catLst");
|
||||
w.open("dgm:layoutNode", A::new().a("name", "diagram"));
|
||||
w.open0("dgm:varLst");
|
||||
w.empty0("dgm:dir");
|
||||
w.empty("dgm:resizeHandles", A::new().a("val", "exact"));
|
||||
w.close("dgm:varLst");
|
||||
if matches!(kind, "hierarchy" | "horizontalHierarchy" | "orgChart" | "halfCircleOrgChart" | "nameTitleOrgChart") {
|
||||
// Each node over the row of its children, recursively.
|
||||
w.empty("dgm:alg", A::new().a("type", "hierChild"));
|
||||
w.open("dgm:shape", A::new().a("r:blip", ""));
|
||||
w.empty0("dgm:adjLst");
|
||||
w.close("dgm:shape");
|
||||
w.empty0("dgm:presOf");
|
||||
w.empty0("dgm:constrLst");
|
||||
w.empty0("dgm:ruleLst");
|
||||
w.open("dgm:forEach", A::new().a("name", "level").a("axis", "ch").a("ptType", "node"));
|
||||
w.open("dgm:layoutNode", A::new().a("name", "hierRoot"));
|
||||
w.empty("dgm:alg", A::new().a("type", "hierRoot"));
|
||||
w.open("dgm:shape", A::new().a("r:blip", ""));
|
||||
w.empty0("dgm:adjLst");
|
||||
w.close("dgm:shape");
|
||||
w.empty0("dgm:presOf");
|
||||
w.empty0("dgm:constrLst");
|
||||
w.empty0("dgm:ruleLst");
|
||||
node_layout(&mut w, "roundRect", false);
|
||||
w.open("dgm:layoutNode", A::new().a("name", "hierChild"));
|
||||
w.empty("dgm:alg", A::new().a("type", "hierChild"));
|
||||
w.open("dgm:shape", A::new().a("r:blip", ""));
|
||||
w.empty0("dgm:adjLst");
|
||||
w.close("dgm:shape");
|
||||
w.empty0("dgm:presOf");
|
||||
w.empty0("dgm:constrLst");
|
||||
w.empty0("dgm:ruleLst");
|
||||
w.empty("dgm:forEach", A::new().a("name", "repeat").a("ref", "level"));
|
||||
w.close("dgm:layoutNode");
|
||||
w.close("dgm:layoutNode");
|
||||
w.close("dgm:forEach");
|
||||
} else {
|
||||
let (ty, params, shape) = alg(kind);
|
||||
w.open("dgm:alg", A::new().a("type", ty));
|
||||
for (k, v) in params {
|
||||
w.empty("dgm:param", A::new().a("type", k).a("val", v));
|
||||
}
|
||||
w.close("dgm:alg");
|
||||
w.open("dgm:shape", A::new().a("r:blip", ""));
|
||||
w.empty0("dgm:adjLst");
|
||||
w.close("dgm:shape");
|
||||
w.empty0("dgm:presOf");
|
||||
w.open0("dgm:constrLst");
|
||||
w.empty("dgm:constr", A::new().a("type", "w").a("for", "ch").a("forName", "node").a("refType", "w"));
|
||||
w.empty(
|
||||
"dgm:constr",
|
||||
A::new().a("type", "h").a("for", "ch").a("forName", "node").a("refType", "w").a("refFor", "ch").a("refForName", "node").a("fact", "0.6"),
|
||||
);
|
||||
w.empty(
|
||||
"dgm:constr",
|
||||
A::new().a("type", "w").a("for", "ch").a("forName", "space").a("refType", "w").a("refFor", "ch").a("refForName", "node").a("fact", "0.1"),
|
||||
);
|
||||
w.empty("dgm:constr", A::new().a("type", "primFontSz").a("for", "ch").a("forName", "node").a("op", "equ").a("val", "65"));
|
||||
w.close("dgm:constrLst");
|
||||
w.empty0("dgm:ruleLst");
|
||||
w.open("dgm:forEach", A::new().a("name", "nodes").a("axis", "ch").a("ptType", "node"));
|
||||
node_layout(&mut w, shape, true);
|
||||
if !matches!(kind, "cycle" | "blockCycle" | "radial") {
|
||||
space(&mut w);
|
||||
}
|
||||
w.close("dgm:forEach");
|
||||
}
|
||||
w.close("dgm:layoutNode");
|
||||
w.close("dgm:layoutDef");
|
||||
w.finish()
|
||||
}
|
||||
|
||||
/// The top bevel (preset, width in EMU) of a 3-D SmartArt Style.
|
||||
fn bevel(style: &str) -> Option<(&'static str, i64)> {
|
||||
Some(match style {
|
||||
"polished" => ("circle", 76200),
|
||||
"inset" => ("relaxedInset", 63500),
|
||||
"cartoon" => ("softRound", 50800),
|
||||
"powder" => ("convex", 101600),
|
||||
"brick" => ("slope", 50800),
|
||||
_ => return None,
|
||||
})
|
||||
}
|
||||
|
||||
/// `ppt/diagrams/quickStyleN.xml`: flat shapes drawn from the theme's first styles.
|
||||
pub fn style_xml(style: &str) -> Vec<u8> {
|
||||
// Brick Scene looks at the diagram from above and to the side.
|
||||
let camera = if style == "brick" { "isometricOffAxis2Top" } else { "orthographicFront" };
|
||||
let mut w = W::new();
|
||||
w.open("dgm:styleDef", A::new().a("xmlns:dgm", NS_DGM).a("xmlns:a", crate::opc::NS_A).a("uniqueId", qs_id(style)));
|
||||
w.empty("dgm:title", A::new().a("val", ""));
|
||||
w.empty("dgm:desc", A::new().a("val", ""));
|
||||
w.open0("dgm:catLst");
|
||||
w.empty("dgm:cat", A::new().a("type", if bevel(style).is_some() { "3D" } else { "simple" }).a("pri", "10100"));
|
||||
w.close("dgm:catLst");
|
||||
w.open0("dgm:scene3d");
|
||||
w.empty("a:camera", A::new().a("prst", camera));
|
||||
w.empty("a:lightRig", A::new().a("rig", "threePt").a("dir", "t"));
|
||||
w.close("dgm:scene3d");
|
||||
w.open("dgm:styleLbl", A::new().a("name", "node1"));
|
||||
w.open0("dgm:scene3d");
|
||||
w.empty("a:camera", A::new().a("prst", camera));
|
||||
w.empty("a:lightRig", A::new().a("rig", "threePt").a("dir", "t"));
|
||||
w.close("dgm:scene3d");
|
||||
match bevel(style) {
|
||||
Some((prst, w_emu)) => {
|
||||
w.open0("dgm:sp3d");
|
||||
w.empty("a:bevelT", A::new().a("w", w_emu.to_string()).a("h", (w_emu * 3 / 5).to_string()).a("prst", prst));
|
||||
w.close("dgm:sp3d");
|
||||
}
|
||||
None => w.empty0("dgm:sp3d"),
|
||||
}
|
||||
w.empty("dgm:txPr", A::new());
|
||||
w.open0("dgm:style");
|
||||
for (tag, idx) in [("a:lnRef", "2"), ("a:fillRef", "1"), ("a:effectRef", "0")] {
|
||||
w.open(tag, A::new().a("idx", idx));
|
||||
w.empty("a:scrgbClr", A::new().a("r", "0").a("g", "0").a("b", "0"));
|
||||
w.close(tag);
|
||||
}
|
||||
w.open("a:fontRef", A::new().a("idx", "minor"));
|
||||
w.empty("a:schemeClr", A::new().a("val", "lt1"));
|
||||
w.close("a:fontRef");
|
||||
w.close("dgm:style");
|
||||
w.close("dgm:styleLbl");
|
||||
w.close("dgm:styleDef");
|
||||
w.finish()
|
||||
}
|
||||
|
||||
/// `ppt/diagrams/colorsN.xml`: accent 1 fills with light text.
|
||||
pub fn colors_xml(colors: &str) -> Vec<u8> {
|
||||
let mut w = W::new();
|
||||
w.open("dgm:colorsDef", A::new().a("xmlns:dgm", NS_DGM).a("xmlns:a", crate::opc::NS_A).a("uniqueId", cs_id(colors)));
|
||||
w.empty("dgm:title", A::new().a("val", ""));
|
||||
w.empty("dgm:desc", A::new().a("val", ""));
|
||||
let accents = fill_accents(colors);
|
||||
let single = accents.len() == 1;
|
||||
let cat = if single { accents.first().map(String::as_str).unwrap_or("accent1") } else { "colorful" };
|
||||
w.open0("dgm:catLst");
|
||||
w.empty("dgm:cat", A::new().a("type", cat).a("pri", "11200"));
|
||||
w.close("dgm:catLst");
|
||||
w.open("dgm:styleLbl", A::new().a("name", "node1"));
|
||||
if colors.ends_with("Grad") {
|
||||
// Gradient Range: the accent shaded darker across the shapes.
|
||||
w.open("dgm:fillClrLst", A::new().a("meth", "repeat"));
|
||||
for k in 0..4 {
|
||||
w.open("a:schemeClr", A::new().a("val", cat));
|
||||
w.empty("a:lumMod", A::new().a("val", (100_000 - k * 15_000).to_string()));
|
||||
w.close("a:schemeClr");
|
||||
}
|
||||
w.close("dgm:fillClrLst");
|
||||
} else {
|
||||
w.open("dgm:fillClrLst", A::new().a("meth", "repeat"));
|
||||
for a in &accents {
|
||||
w.empty("a:schemeClr", A::new().a("val", a.as_str()));
|
||||
}
|
||||
w.close("dgm:fillClrLst");
|
||||
}
|
||||
w.open("dgm:linClrLst", A::new().a("meth", "repeat"));
|
||||
w.empty("a:schemeClr", A::new().a("val", "lt1"));
|
||||
w.close("dgm:linClrLst");
|
||||
w.empty0("dgm:effectClrLst");
|
||||
w.empty0("dgm:txLinClrLst");
|
||||
w.empty0("dgm:txFillClrLst");
|
||||
w.empty0("dgm:txEffectClrLst");
|
||||
w.close("dgm:styleLbl");
|
||||
w.close("dgm:colorsDef");
|
||||
w.finish()
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn nodes(v: &[(&str, u8)]) -> Vec<DiagramNode> {
|
||||
v.iter().map(|(t, l)| DiagramNode { text: (*t).into(), level: *l, picture: None, assistant: false, title: String::new() }).collect()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn outline_survives_the_data_model() {
|
||||
let d =
|
||||
Diagram { kind: "hierarchy".into(), nodes: nodes(&[("CEO", 0), ("CTO", 1), ("Dev", 2), ("CFO", 1), ("Board", 0)]), ..Default::default() };
|
||||
let xml = data_xml(&d, 7, "rId9", &[]);
|
||||
let doc = crate::xml::parse(&xml).unwrap();
|
||||
assert_eq!(outline(&doc.root), d.nodes);
|
||||
let s = String::from_utf8(xml).unwrap();
|
||||
assert!(s.contains("hierarchy1") && s.contains("relId=\"rId9\""));
|
||||
for x in [
|
||||
layout_xml("hierarchy"),
|
||||
layout_xml("cycle"),
|
||||
style_xml("subtle"),
|
||||
colors_xml(""),
|
||||
colors_xml("accent3"),
|
||||
style_xml("polished"),
|
||||
colors_xml("range23"),
|
||||
colors_xml("accent6Grad"),
|
||||
layout_xml("pictureList"),
|
||||
] {
|
||||
assert!(crate::xml::parse(&x).is_ok());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn assistants_survive_the_data_model() {
|
||||
let mut v = nodes(&[("CEO", 0), ("Aide", 1), ("CTO", 1)]);
|
||||
v[1].assistant = true;
|
||||
v[0].title = "Chief Executive".into();
|
||||
let d = Diagram { kind: "orgChart".into(), nodes: v, ..Default::default() };
|
||||
let xml = data_xml(&d, 5, "rId1", &[]);
|
||||
assert!(String::from_utf8(xml.clone()).unwrap().contains("type=\"asst\""));
|
||||
let doc = crate::xml::parse(&xml).unwrap();
|
||||
assert_eq!(outline(&doc.root), d.nodes);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn node_pictures_come_from_presentation_points() {
|
||||
let d = Diagram { kind: "pictureList".into(), nodes: nodes(&[("A", 0), ("a", 1), ("B", 0)]), ..Default::default() };
|
||||
let xml = data_xml(&d, 3, "rId1", &[(2, "rId7".into()), (9, "rId8".into())]);
|
||||
let doc = crate::xml::parse(&xml).unwrap();
|
||||
assert_eq!(node_pictures(&doc.root), vec![(2, "rId7".to_string())]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn style_and_colour_ids_round_trip() {
|
||||
for st in ["", "subtle", "intense", "outline", "polished", "inset", "cartoon", "powder", "brick"] {
|
||||
assert_eq!(style_for(&qs_id(st)), st);
|
||||
}
|
||||
for c in ["", "range23", "range56", "accent1", "accent4Grad"] {
|
||||
assert_eq!(colors_for(&cs_id(c)), c);
|
||||
}
|
||||
assert!(String::from_utf8(style_xml("cartoon")).unwrap().contains("bevelT"));
|
||||
assert!(layout_id("pictureProcess").ends_with("/hProcess10"), "Picture Accent Process");
|
||||
assert!(layout_id("pictureHList").ends_with("/pList2"), "Horizontal Picture List");
|
||||
// Picture Accent Process as an earlier DeckCraft wrote it (pList2, process category).
|
||||
assert_eq!(kind_for("urn:microsoft.com/office/officeart/2005/8/layout/pList2", "process"), "pictureProcess");
|
||||
assert_eq!(kind_for("urn:microsoft.com/office/officeart/2005/8/layout/pList2", "list"), "pictureHList");
|
||||
for k in [
|
||||
"pictureList",
|
||||
"pictureCaption",
|
||||
"pictureProcess",
|
||||
"pictureHList",
|
||||
"timeline",
|
||||
"venn",
|
||||
"target",
|
||||
"textCycle",
|
||||
"continuousCycle",
|
||||
"horizontalHierarchy",
|
||||
"gridMatrix",
|
||||
"gear",
|
||||
"funnel",
|
||||
"segmentedCycle",
|
||||
"multidirectionalCycle",
|
||||
"orgChart",
|
||||
"halfCircleOrgChart",
|
||||
"cycleMatrix",
|
||||
"segmentedPyramid",
|
||||
"pie",
|
||||
"nameTitleOrgChart",
|
||||
"verticalBoxList",
|
||||
"trapezoidList",
|
||||
"tableList",
|
||||
"accentProcess",
|
||||
"continuousBlockProcess",
|
||||
"bendingProcess",
|
||||
"linearVenn",
|
||||
"stackedVenn",
|
||||
"nestedTarget",
|
||||
] {
|
||||
assert_eq!(kind_for(layout_id(k), ""), k);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hostile_links_are_bounded() {
|
||||
let xml = br#"<dgm:dataModel xmlns:dgm="d"><dgm:ptLst><dgm:pt modelId="0" type="doc"/><dgm:pt modelId="1"><dgm:t><a:p xmlns:a="a"><a:r><a:t>A</a:t></a:r></a:p></dgm:t></dgm:pt><dgm:pt modelId="2"/></dgm:ptLst><dgm:cxnLst><dgm:cxn srcId="0" destId="1"/><dgm:cxn srcId="1" destId="2"/><dgm:cxn srcId="2" destId="1"/><dgm:cxn type="presOf" srcId="0" destId="2"/></dgm:cxnLst></dgm:dataModel>"#;
|
||||
let doc = crate::xml::parse(xml).unwrap();
|
||||
assert_eq!(outline(&doc.root), nodes(&[("A", 0), ("", 1)]));
|
||||
assert_eq!(kind_for("urn:microsoft.com/office/officeart/2005/8/layout/orgChart1", ""), "orgChart");
|
||||
assert_eq!(kind_for("urn:x/layout/NameandTitleOrganizationalChart", ""), "nameTitleOrgChart");
|
||||
assert_eq!(kind_for("urn:x/layout/chevron2", "process"), "chevron");
|
||||
assert_eq!(kind_for("urn:x/layout/hProcess9", "process"), "process");
|
||||
assert_eq!(kind_for("urn:x/layout/default", "list"), "blockList");
|
||||
assert_eq!(colors_for(&cs_id("accent4")), "accent4");
|
||||
assert_eq!(colors_for(&cs_id("")), "");
|
||||
assert_eq!(style_for(&qs_id("outline")), "outline");
|
||||
|
||||
let unconnected = br#"<dgm:dataModel xmlns:dgm="d"><dgm:ptLst><dgm:pt modelId="0" type="doc"/><dgm:pt modelId="1" type="node"><dgm:t><a:p xmlns:a="a"><a:r><a:t>Alpha</a:t></a:r></a:p></dgm:t></dgm:pt><dgm:pt modelId="2" type="node"><dgm:t><a:p xmlns:a="a"><a:r><a:t>Beta</a:t></a:r></a:p></dgm:t></dgm:pt></dgm:ptLst><dgm:cxnLst/></dgm:dataModel>"#;
|
||||
let unconnected_doc = crate::xml::parse(unconnected).unwrap();
|
||||
assert_eq!(outline(&unconnected_doc.root), nodes(&[("Alpha", 0), ("Beta", 0)]));
|
||||
|
||||
// When parOf connections exist but no root (type="doc") reaches them, do not flatten the hierarchy to level 0.
|
||||
let unrooted_hierarchy = br#"<dgm:dataModel xmlns:dgm="d"><dgm:ptLst><dgm:pt modelId="1" type="node"><dgm:t><a:p xmlns:a="a"><a:r><a:t>Parent</a:t></a:r></a:p></dgm:t></dgm:pt><dgm:pt modelId="2" type="node"><dgm:t><a:p xmlns:a="a"><a:r><a:t>Child</a:t></a:r></a:p></dgm:t></dgm:pt></dgm:ptLst><dgm:cxnLst><dgm:cxn srcId="1" destId="2"/></dgm:cxnLst></dgm:dataModel>"#;
|
||||
let unrooted_doc = crate::xml::parse(unrooted_hierarchy).unwrap();
|
||||
assert!(outline(&unrooted_doc.root).is_empty());
|
||||
}
|
||||
}
|
||||
+789
-66
@@ -1,5 +1,5 @@
|
||||
//! PPTX import and export: Office Open XML PresentationML / DrawingML, written from the public
|
||||
//! ECMA-376 standard.
|
||||
//! PPTX import and export: Office Open XML PresentationML / DrawingML, delegated to the shared
|
||||
//! `craft-pptx` crate.
|
||||
//!
|
||||
//! [`import`] reads a package leniently (unknown parts are skipped, malformed parts are logged and
|
||||
//! ignored, every size and depth is bounded) into the DeckCraft model; [`export`] writes a valid
|
||||
@@ -8,28 +8,15 @@
|
||||
#![forbid(unsafe_code)]
|
||||
|
||||
mod cfb;
|
||||
mod custgeom;
|
||||
mod dgm;
|
||||
mod maps;
|
||||
mod opc;
|
||||
mod png;
|
||||
pub(crate) mod read;
|
||||
pub use read::MAX_TAG_BYTES;
|
||||
mod tables;
|
||||
mod write;
|
||||
mod convert;
|
||||
mod xml;
|
||||
|
||||
pub use craft_pptx::MAX_TAG_BYTES;
|
||||
/// The bounded XML reader the importer uses, for callers that read kept fragments (a shape's
|
||||
/// 3-D settings) instead of scanning strings.
|
||||
pub use xml::{Doc as XmlDoc, El as XmlEl, parse as parse_xml};
|
||||
|
||||
use deckcraft_model::Presentation;
|
||||
|
||||
/// Extension URI of the PowerPoint 2010 section list in `presentation.xml`.
|
||||
pub(crate) const SECTION_EXT_URI: &str = "{521415D9-36F7-43E2-AB2F-B90AF26B5E84}";
|
||||
|
||||
/// Extension URI of the modern-comments anchor in a slide (names the threaded comment part).
|
||||
pub(crate) const COMMENTS_EXT_URI: &str = "{6950BFC3-D8DA-4A85-94F7-54DA5524770B}";
|
||||
use deckcraft_model::{Presentation, Shape, ShapeKind, defaults};
|
||||
|
||||
#[derive(Debug, thiserror::Error)]
|
||||
pub enum PptxError {
|
||||
@@ -43,15 +30,50 @@ pub enum PptxError {
|
||||
Xml(String),
|
||||
}
|
||||
|
||||
impl From<craft_pptx::Error> for PptxError {
|
||||
fn from(e: craft_pptx::Error) -> Self {
|
||||
match e {
|
||||
craft_pptx::Error::NotPptx(m) => PptxError::NotPptx(m),
|
||||
craft_pptx::Error::Unsupported(m) => PptxError::Unsupported(m),
|
||||
craft_pptx::Error::Write(m) => PptxError::Write(m),
|
||||
craft_pptx::Error::Xml(m) => PptxError::Xml(m),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
struct DeckDefaults;
|
||||
|
||||
impl craft_pptx::Defaults for DeckDefaults {
|
||||
fn master(&self, size: deckcraft_geom::Size, after: u32) -> (craft_pptx::Master, u32) {
|
||||
let (m, last) = defaults::build_master(size, Default::default(), after);
|
||||
(convert::master_to_craft(&m), last)
|
||||
}
|
||||
|
||||
fn theme(&self) -> craft_drawingml::theme::Theme {
|
||||
convert::theme_to_craft(&deckcraft_model::theme::Theme::default())
|
||||
}
|
||||
|
||||
fn master_styles(&self) -> (craft_drawingml::text::ListStyle, craft_drawingml::text::ListStyle, craft_drawingml::text::ListStyle) {
|
||||
// An imported empty master style must stay empty on save; new decks already carry their
|
||||
// populated master styles in the model.
|
||||
Default::default()
|
||||
}
|
||||
|
||||
fn default_text_style(&self) -> craft_drawingml::text::ListStyle {
|
||||
convert::list_style_to_craft(&defaults::default_text_style())
|
||||
}
|
||||
|
||||
fn application(&self) -> &str {
|
||||
"DeckCraft"
|
||||
}
|
||||
}
|
||||
|
||||
/// Does this look like an OOXML package (zip with `[Content_Types].xml`)?
|
||||
///
|
||||
/// The part is looked up in the zip's central directory, not in the leading bytes: writers may
|
||||
/// The part is looked up in the archive's central directory, not in the leading bytes: writers may
|
||||
/// store it anywhere in the archive (recent PowerPoint builds put it last, megabytes in).
|
||||
pub fn sniff(bytes: &[u8]) -> bool {
|
||||
if !bytes.starts_with(b"PK") {
|
||||
return false;
|
||||
}
|
||||
zip::ZipArchive::new(std::io::Cursor::new(bytes)).map(|z| z.index_for_name("[Content_Types].xml").is_some()).unwrap_or(false)
|
||||
craft_pptx::sniff(bytes)
|
||||
}
|
||||
|
||||
/// Is this a password-protected presentation (an encrypted package inside a compound file)?
|
||||
@@ -59,81 +81,750 @@ pub fn is_encrypted(bytes: &[u8]) -> bool {
|
||||
cfb::is_encrypted(bytes)
|
||||
}
|
||||
|
||||
const MAX_SLIDE_ENTRIES: usize = 10_000;
|
||||
|
||||
/// Checks `ppt/presentation.xml` for > 10,000 slide-list entries (refused instead of truncated)
|
||||
/// and collects any `sldId` entries whose relationship is missing so `import_checked` /
|
||||
/// `import_report` report them as lost slides.
|
||||
fn preflight_slides(bytes: &[u8]) -> Result<Vec<String>, PptxError> {
|
||||
let Ok(mut pkg) = craft_opc::LazyPackage::open(bytes, &craft_pptx::LIMITS) else {
|
||||
return Ok(vec![]);
|
||||
};
|
||||
let root_rels = pkg.rels("").unwrap_or_default();
|
||||
let pres_path = root_rels.first("officeDocument").map(|r| r.target.clone()).unwrap_or_else(|| "ppt/presentation.xml".into());
|
||||
let Ok(Some(pres_bytes)) = pkg.read_limited(&pres_path, craft_pptx::MAX_XML_PART as u64) else {
|
||||
return Ok(vec![]);
|
||||
};
|
||||
let Ok(pres_el) = craft_drawingml::xmlx::parse(&pres_bytes) else {
|
||||
return Ok(vec![]);
|
||||
};
|
||||
let pres_rels = pkg.rels(&pres_path).unwrap_or_default();
|
||||
let mut lost = Vec::new();
|
||||
if let Some(list) = pres_el.child(craft_xml::Local("sldIdLst")) {
|
||||
let mut count = 0usize;
|
||||
for s in list.children(craft_xml::Local("sldId")) {
|
||||
count += 1;
|
||||
if count > MAX_SLIDE_ENTRIES {
|
||||
return Err(PptxError::Unsupported(format!("presentation has more than {MAX_SLIDE_ENTRIES} slides")));
|
||||
}
|
||||
let rid = s.attr_local("r:id").unwrap_or("");
|
||||
if pres_rels.target(rid).is_none() {
|
||||
let id = s.attr_local("id").and_then(craft_xml::value::to_u32_lossy).unwrap_or(0);
|
||||
lost.push(format!("slide {id} (missing relationship {rid})"));
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(lost)
|
||||
}
|
||||
|
||||
fn has_unfolded_paragraph_builds(p: &Presentation) -> bool {
|
||||
p.slides.iter().any(|s| s.animations.windows(2).any(|w| w[0].paragraph.is_some() && w[1].paragraph.is_some() && w[0].shape == w[1].shape))
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
struct SlideTimingInfo {
|
||||
opt_out: std::collections::HashSet<u32>,
|
||||
offsets: std::collections::HashMap<(u32, u32), u32>,
|
||||
}
|
||||
|
||||
fn timing_ms(e: &craft_xml::El, name: &str) -> Option<u32> {
|
||||
let v = e.attr_local(name)?.trim();
|
||||
if v == "indefinite" {
|
||||
return None;
|
||||
}
|
||||
v.parse::<f64>().ok().filter(|n| n.is_finite() && *n >= 0.0).map(|n| n.min(u32::MAX as f64) as u32)
|
||||
}
|
||||
|
||||
fn collect_timing_offsets(e: &craft_xml::El, offset: u32, out: &mut std::collections::HashMap<(u32, u32), u32>, depth: usize) {
|
||||
if depth > 64 {
|
||||
return;
|
||||
}
|
||||
for c in e.elements() {
|
||||
if c.is(craft_xml::Local("cTn")) && c.attr_local("presetClass").is_some() {
|
||||
if let Some(sp) = c.find(craft_xml::Local("spTgt"))
|
||||
&& let Some(spid) = sp.attr_local("spid").and_then(craft_xml::value::to_u32_lossy)
|
||||
&& let Some(p) = sp
|
||||
.path(&[craft_xml::Local("txEl"), craft_xml::Local("pRg")])
|
||||
.and_then(|r| r.attr_local("st"))
|
||||
.and_then(craft_xml::value::to_u32_lossy)
|
||||
{
|
||||
out.entry((spid, p)).or_insert(offset);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
let mut next_offset = offset;
|
||||
if c.is(craft_xml::Local("cTn"))
|
||||
&& let Some(cond) = c.path(&[craft_xml::Local("stCondLst"), craft_xml::Local("cond")])
|
||||
{
|
||||
if cond.attr_local("delay").map(str::trim) == Some("indefinite") {
|
||||
next_offset = 0;
|
||||
} else {
|
||||
next_offset = next_offset.saturating_add(timing_ms(cond, "delay").unwrap_or(0));
|
||||
}
|
||||
}
|
||||
collect_timing_offsets(c, next_offset, out, depth + 1);
|
||||
}
|
||||
}
|
||||
|
||||
fn defers_start(st: &craft_xml::El) -> bool {
|
||||
let is_auto_begin = |c: &craft_xml::El| {
|
||||
c.attr_local("evt") == Some("onBegin")
|
||||
&& c.attr_local("delay").map(str::trim) == Some("0")
|
||||
&& c.child(craft_xml::Local("tgtEl")).is_none()
|
||||
&& c.child(craft_xml::Local("tn")).is_none()
|
||||
&& c.child(craft_xml::Local("rtn")).is_none()
|
||||
};
|
||||
let has_on_begin = st.children(craft_xml::Local("cond")).any(is_auto_begin);
|
||||
st.children(craft_xml::Local("cond"))
|
||||
.any(|c| (c.attr_local("evt").is_some() && !is_auto_begin(c)) || (!has_on_begin && c.attr_local("delay").map(str::trim) != Some("0")))
|
||||
}
|
||||
|
||||
fn is_main_seq_auto(st: &craft_xml::El, main_seq_id: Option<u32>) -> bool {
|
||||
let Some(ms_id) = main_seq_id else {
|
||||
return false;
|
||||
};
|
||||
let is_indefinite = |d: &craft_xml::El| {
|
||||
d.attr_local("evt").is_none()
|
||||
&& d.attr_local("delay").map(str::trim) == Some("indefinite")
|
||||
&& d.child(craft_xml::Local("tgtEl")).is_none()
|
||||
&& d.child(craft_xml::Local("tn")).is_none()
|
||||
&& d.child(craft_xml::Local("rtn")).is_none()
|
||||
};
|
||||
let is_main_seq_on_begin = |d: &craft_xml::El| {
|
||||
d.attr_local("evt") == Some("onBegin")
|
||||
&& d.attr_local("delay").map(str::trim) == Some("0")
|
||||
&& d.child(craft_xml::Local("tgtEl")).is_none()
|
||||
&& d.child(craft_xml::Local("rtn")).is_none()
|
||||
&& d.child(craft_xml::Local("tn")).and_then(|tn| tn.attr_local("val")).and_then(craft_xml::value::to_u32_lossy) == Some(ms_id)
|
||||
};
|
||||
st.children(craft_xml::Local("cond")).any(is_indefinite)
|
||||
&& st.children(craft_xml::Local("cond")).any(is_main_seq_on_begin)
|
||||
&& st.children(craft_xml::Local("cond")).all(|d| is_indefinite(d) || is_main_seq_on_begin(d))
|
||||
}
|
||||
|
||||
fn collect_media_nodes<'a>(e: &'a craft_xml::El, deferred: bool, out: &mut Vec<(&'a craft_xml::El, bool)>, depth: usize) {
|
||||
if depth > 64 || out.len() >= 10_000 {
|
||||
return;
|
||||
}
|
||||
let mut deferred = deferred;
|
||||
if e.is(craft_xml::Local("cTn"))
|
||||
&& let Some(st) = e.child(craft_xml::Local("stCondLst"))
|
||||
&& defers_start(st)
|
||||
{
|
||||
deferred = true;
|
||||
}
|
||||
if e.is(craft_xml::Local("video")) || e.is(craft_xml::Local("audio")) {
|
||||
out.push((e, deferred));
|
||||
return;
|
||||
}
|
||||
for c in e.elements() {
|
||||
collect_media_nodes(c, deferred, out, depth + 1);
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy)]
|
||||
struct MediaPlayAt {
|
||||
trigger: Option<u32>,
|
||||
main_seq_id: Option<u32>,
|
||||
offset: u32,
|
||||
deferred: bool,
|
||||
}
|
||||
|
||||
fn collect_media_plays<'a>(e: &'a craft_xml::El, at: MediaPlayAt, out: &mut Vec<(&'a craft_xml::El, MediaPlayAt)>, depth: usize) {
|
||||
if depth > 64 || out.len() > 10_000 {
|
||||
return;
|
||||
}
|
||||
for c in e.elements() {
|
||||
if c.is(craft_xml::Local("cTn")) && c.attr_local("presetClass").is_some() {
|
||||
let deferred = at.deferred || c.child(craft_xml::Local("stCondLst")).is_some_and(defers_start);
|
||||
out.push((c, MediaPlayAt { deferred, ..at }));
|
||||
continue;
|
||||
}
|
||||
let mut next = at;
|
||||
if c.is(craft_xml::Local("seq"))
|
||||
&& let Some(ctn) = c.child(craft_xml::Local("cTn"))
|
||||
&& ctn.attr_local("nodeType") == Some("interactiveSeq")
|
||||
{
|
||||
next.trigger = ctn
|
||||
.path(&[craft_xml::Local("stCondLst"), craft_xml::Local("cond"), craft_xml::Local("tgtEl"), craft_xml::Local("spTgt")])
|
||||
.and_then(|s| s.attr_local("spid"))
|
||||
.and_then(craft_xml::value::to_u32_lossy);
|
||||
next.main_seq_id = None;
|
||||
}
|
||||
if c.is(craft_xml::Local("cTn")) {
|
||||
let is_main_seq = c.attr_local("nodeType") == Some("mainSeq");
|
||||
if let Some(st) = c.child(craft_xml::Local("stCondLst")) {
|
||||
if !(!is_main_seq && !next.deferred && is_main_seq_auto(st, next.main_seq_id)) && defers_start(st) {
|
||||
next.deferred = true;
|
||||
}
|
||||
if let Some(cond) = st.child(craft_xml::Local("cond")) {
|
||||
if cond.attr_local("delay").map(str::trim) == Some("indefinite") {
|
||||
next.offset = 0;
|
||||
} else {
|
||||
next.offset = next.offset.saturating_add(timing_ms(cond, "delay").unwrap_or(0));
|
||||
}
|
||||
}
|
||||
}
|
||||
next.main_seq_id = if is_main_seq && !next.deferred { c.attr_local("id").and_then(craft_xml::value::to_u32_lossy) } else { None };
|
||||
}
|
||||
collect_media_plays(c, next, out, depth + 1);
|
||||
}
|
||||
}
|
||||
|
||||
fn apply_media_timing(timing: &craft_xml::El, shapes: &mut [Shape]) {
|
||||
let mut nodes = Vec::new();
|
||||
collect_media_nodes(timing, false, &mut nodes, 0);
|
||||
for (node, deferred) in nodes {
|
||||
let Some(cm) = node.child(craft_xml::Local("cMediaNode")) else { continue };
|
||||
let Some(spid) = cm
|
||||
.path(&[craft_xml::Local("tgtEl"), craft_xml::Local("spTgt")])
|
||||
.and_then(|t| t.attr_local("spid"))
|
||||
.and_then(craft_xml::value::to_u32_lossy)
|
||||
else {
|
||||
continue;
|
||||
};
|
||||
let Some(ShapeKind::Media(clip)) = deckcraft_model::find_shape_mut(shapes, deckcraft_model::ShapeId(spid)).map(|s| &mut s.kind) else {
|
||||
continue;
|
||||
};
|
||||
if cm.child(craft_xml::Local("cTn")).and_then(|c| c.attr_local("fill")) == Some("remove") {
|
||||
clip.rewind = true;
|
||||
}
|
||||
if cm.attr_local("numSld").and_then(craft_xml::value::to_u32_lossy).is_some_and(|n| n > 1) {
|
||||
clip.play_across_slides = true;
|
||||
}
|
||||
if !deferred
|
||||
&& cm
|
||||
.path(&[craft_xml::Local("cTn"), craft_xml::Local("stCondLst"), craft_xml::Local("cond")])
|
||||
.is_some_and(|c| c.attr_local("evt").is_none() && c.attr_local("delay").map(str::trim) == Some("0"))
|
||||
{
|
||||
clip.autoplay = true;
|
||||
}
|
||||
}
|
||||
let root_deferred = timing
|
||||
.path(&[craft_xml::Local("tnLst"), craft_xml::Local("par"), craft_xml::Local("cTn"), craft_xml::Local("stCondLst")])
|
||||
.is_some_and(defers_start);
|
||||
if !root_deferred && let Some(tn) = timing.child(craft_xml::Local("tnLst")) {
|
||||
let mut found = Vec::new();
|
||||
collect_media_plays(tn, MediaPlayAt { trigger: None, main_seq_id: None, offset: 0, deferred: false }, &mut found, 0);
|
||||
for (c, f) in found.into_iter().filter(|(_, f)| f.trigger.is_none()) {
|
||||
if c.attr_local("nodeType") == Some("clickEffect") || f.deferred {
|
||||
break;
|
||||
}
|
||||
let delay = c.path(&[craft_xml::Local("stCondLst"), craft_xml::Local("cond")]).and_then(|d| timing_ms(d, "delay")).unwrap_or(0);
|
||||
if c.attr_local("presetClass") == Some("mediacall")
|
||||
&& c.attr_local("presetID").and_then(craft_xml::value::to_u32_lossy) == Some(1)
|
||||
&& f.offset == 0
|
||||
&& delay == 0
|
||||
&& let Some(spid) = c.find(craft_xml::Local("spTgt")).and_then(|t| t.attr_local("spid")).and_then(craft_xml::value::to_u32_lossy)
|
||||
&& let Some(ShapeKind::Media(clip)) = deckcraft_model::find_shape_mut(shapes, deckcraft_model::ShapeId(spid)).map(|s| &mut s.kind)
|
||||
{
|
||||
clip.autoplay = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn has_media_shapes(shapes: &[Shape]) -> bool {
|
||||
shapes.iter().any(|s| match &s.kind {
|
||||
ShapeKind::Media(_) => true,
|
||||
ShapeKind::Group { children, .. } => has_media_shapes(children),
|
||||
_ => false,
|
||||
})
|
||||
}
|
||||
|
||||
fn post_import_timing(bytes: &[u8], pres: &mut Presentation) {
|
||||
let need_builds = has_unfolded_paragraph_builds(pres);
|
||||
let need_media = pres.slides.iter().any(|s| has_media_shapes(&s.shapes));
|
||||
if !need_builds && !need_media {
|
||||
return;
|
||||
}
|
||||
let Ok(mut pkg) = craft_opc::LazyPackage::open(bytes, &craft_pptx::LIMITS) else {
|
||||
return;
|
||||
};
|
||||
let root_rels = pkg.rels("").unwrap_or_default();
|
||||
let pres_path = root_rels.first("officeDocument").map(|r| r.target.clone()).unwrap_or_else(|| "ppt/presentation.xml".into());
|
||||
let Ok(Some(pres_bytes)) = pkg.read_limited(&pres_path, craft_pptx::MAX_XML_PART as u64) else {
|
||||
return;
|
||||
};
|
||||
let Ok(pres_el) = craft_drawingml::xmlx::parse(&pres_bytes) else {
|
||||
return;
|
||||
};
|
||||
let pres_rels = pkg.rels(&pres_path).unwrap_or_default();
|
||||
let Some(list) = pres_el.child(craft_xml::Local("sldIdLst")) else {
|
||||
return;
|
||||
};
|
||||
for (i, s) in list.children(craft_xml::Local("sldId")).take(MAX_SLIDE_ENTRIES).enumerate() {
|
||||
let Some(slide_arc) = pres.slides.get_mut(i) else { break };
|
||||
let Some(target) = s.attr_local("r:id").and_then(|rid| pres_rels.target(rid)) else { continue };
|
||||
let Ok(Some(sb)) = pkg.read_limited(target, craft_pptx::MAX_XML_PART as u64) else { continue };
|
||||
let Ok(se) = craft_drawingml::xmlx::parse(&sb) else { continue };
|
||||
let Some(timing) = se.child(craft_xml::Local("timing")) else { continue };
|
||||
if need_media && has_media_shapes(&slide_arc.shapes) {
|
||||
apply_media_timing(timing, &mut std::sync::Arc::make_mut(slide_arc).shapes);
|
||||
}
|
||||
if need_builds {
|
||||
let mut info = SlideTimingInfo::default();
|
||||
collect_timing_offsets(timing, 0, &mut info.offsets, 0);
|
||||
if let Some(bld_lst) = timing.child(craft_xml::Local("bldLst")) {
|
||||
for b in bld_lst.children(craft_xml::Local("bldP")) {
|
||||
if b.attr_local("build").unwrap_or("") != "p"
|
||||
&& let Some(spid) = b.attr_local("spid").and_then(craft_xml::value::to_u32_lossy)
|
||||
{
|
||||
info.opt_out.insert(spid);
|
||||
}
|
||||
}
|
||||
}
|
||||
fold_slide_paragraph_builds(std::sync::Arc::make_mut(slide_arc), &info);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn span_ms(a: &deckcraft_model::anim::Animation) -> u32 {
|
||||
let iterations = if a.repeat == u32::MAX || a.repeat <= 1 { 1 } else { a.repeat.min(1_000) };
|
||||
a.duration_ms.saturating_mul(if a.auto_reverse { 2 } else { 1 }).saturating_mul(iterations)
|
||||
}
|
||||
|
||||
fn flat_starts(anims: &[&deckcraft_model::anim::Animation]) -> Vec<u32> {
|
||||
let (mut begin, mut end) = (0u32, 0u32);
|
||||
anims
|
||||
.iter()
|
||||
.map(|a| {
|
||||
if a.start == deckcraft_model::anim::AnimStart::AfterPrevious {
|
||||
begin = end;
|
||||
}
|
||||
let start = begin.saturating_add(a.delay_ms);
|
||||
end = end.max(start.saturating_add(span_ms(a)));
|
||||
start
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
fn plays_as_build(effects: &[&deckcraft_model::anim::Animation], offsets: &[u32], text: &deckcraft_model::text::TextBody) -> bool {
|
||||
use deckcraft_model::anim::{AnimStart, Animation, BuildRole, build_filled, paragraph_build_roles};
|
||||
let Some(first) = effects.first() else { return false };
|
||||
let off0 = offsets.first().copied().unwrap_or(0);
|
||||
let flat = flat_starts(effects);
|
||||
let parent_starts_match = offsets
|
||||
.iter()
|
||||
.zip(effects.iter())
|
||||
.zip(flat.iter())
|
||||
.all(|((&off, a), &ft)| off == off0 || off.saturating_add(a.delay_ms) == off0.saturating_add(ft));
|
||||
if !parent_starts_match || (first.start != AnimStart::OnClick && (span_ms(first) != 500 || first.delay_ms != 0 || off0 != 0)) {
|
||||
return false;
|
||||
}
|
||||
let roles = paragraph_build_roles(text);
|
||||
let expected = roles.iter().enumerate().filter(|(i, r)| match r {
|
||||
BuildRole::Top => true,
|
||||
BuildRole::Member(_) => text.paragraphs.get(*i).is_some_and(build_filled),
|
||||
BuildRole::Unowned => false,
|
||||
});
|
||||
let settings = |a: &Animation| Animation { start: AnimStart::OnClick, paragraph: None, ..a.clone() };
|
||||
let base = settings(first);
|
||||
let mut matched = 0;
|
||||
for (k, (i, role)) in expected.enumerate() {
|
||||
let Some(a) = effects.get(k) else { return false };
|
||||
let start_ok = match role {
|
||||
BuildRole::Top if k == 0 => true,
|
||||
BuildRole::Top if first.start == AnimStart::OnClick => a.start == AnimStart::OnClick,
|
||||
BuildRole::Top => a.start == AnimStart::AfterPrevious,
|
||||
_ => a.start == AnimStart::WithPrevious,
|
||||
};
|
||||
if a.paragraph != u32::try_from(i).ok() || !start_ok || settings(a) != base {
|
||||
return false;
|
||||
}
|
||||
matched = k + 1;
|
||||
}
|
||||
matched == effects.len()
|
||||
}
|
||||
|
||||
fn fold_slide_paragraph_builds(slide: &mut deckcraft_model::Slide, info: &SlideTimingInfo) {
|
||||
use deckcraft_model::anim::{Animation, TextBuild};
|
||||
let same = |x: &Animation, y: &Animation| {
|
||||
x.paragraph.is_some()
|
||||
&& y.paragraph.is_some()
|
||||
&& x.text_build == TextBuild::AsOne
|
||||
&& y.text_build == TextBuild::AsOne
|
||||
&& x.shape == y.shape
|
||||
&& x.trigger == y.trigger
|
||||
&& !info.opt_out.contains(&x.shape.0)
|
||||
};
|
||||
let mut folded = Vec::with_capacity(slide.animations.len());
|
||||
for run in slide.animations.chunk_by(same) {
|
||||
let effects: Vec<&Animation> = run.iter().collect();
|
||||
let offsets: Vec<u32> = run.iter().map(|a| a.paragraph.and_then(|p| info.offsets.get(&(a.shape.0, p)).copied()).unwrap_or(0)).collect();
|
||||
let text = effects.first().and_then(|a| deckcraft_model::find_shape(&slide.shapes, a.shape)).and_then(|s| s.text.as_ref());
|
||||
if run.len() > 1
|
||||
&& let (Some(first), Some(text)) = (effects.first(), text)
|
||||
&& !info.opt_out.contains(&first.shape.0)
|
||||
&& plays_as_build(&effects, &offsets, text)
|
||||
{
|
||||
folded.push(Animation { text_build: TextBuild::ByParagraph, paragraph: None, ..(*first).clone() });
|
||||
} else {
|
||||
folded.extend(run.iter().cloned());
|
||||
}
|
||||
}
|
||||
slide.animations = folded;
|
||||
}
|
||||
|
||||
/// Read a `.pptx` / `.potx` / `.ppsx` package.
|
||||
pub fn import(bytes: &[u8]) -> Result<Presentation, PptxError> {
|
||||
read::import(bytes)
|
||||
preflight_slides(bytes)?;
|
||||
let mut pres = craft_pptx::import(bytes, &DeckDefaults).map(convert::pres_from_craft)?;
|
||||
post_import_timing(bytes, &mut pres);
|
||||
Ok(pres)
|
||||
}
|
||||
|
||||
/// [`import`], plus the part names of slides the file lists but that couldn't be read and were
|
||||
/// left out.
|
||||
/// Files with more than 10,000 slide-list entries return [`PptxError::Unsupported`] instead of a truncated presentation.
|
||||
pub fn import_checked(bytes: &[u8]) -> Result<(Presentation, Vec<String>), PptxError> {
|
||||
read::import_checked(bytes)
|
||||
let (p, lost, _) = import_report(bytes)?;
|
||||
Ok((p, lost))
|
||||
}
|
||||
|
||||
/// [`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)
|
||||
let mut missing = preflight_slides(bytes)?;
|
||||
let (p, lost, warnings) = craft_pptx::import_report(bytes, &DeckDefaults)?;
|
||||
missing.extend(lost);
|
||||
let mut pres = convert::pres_from_craft(p);
|
||||
post_import_timing(bytes, &mut pres);
|
||||
Ok((pres, missing, warnings))
|
||||
}
|
||||
|
||||
/// [`import`] with a lower presentation-wide chart point budget, so tests reach the over-budget
|
||||
/// path without a multi-million-point chart.
|
||||
#[doc(hidden)]
|
||||
pub fn import_with_chart_budget(bytes: &[u8], points: usize) -> Result<Presentation, PptxError> {
|
||||
read::import_with_chart_points(bytes, points).map(|(p, _)| p)
|
||||
preflight_slides(bytes)?;
|
||||
let mut pres = craft_pptx::import_with_chart_budget(bytes, &DeckDefaults, points).map(convert::pres_from_craft)?;
|
||||
post_import_timing(bytes, &mut pres);
|
||||
Ok(pres)
|
||||
}
|
||||
|
||||
/// Read the theme of a `.thmx` file, or of a `.pptx` / `.potx`'s first master, with its media.
|
||||
pub fn import_theme(bytes: &[u8]) -> Result<(deckcraft_model::theme::Theme, Vec<deckcraft_model::MediaItem>), PptxError> {
|
||||
read::import_theme(bytes)
|
||||
let (theme, media) = craft_pptx::import_theme(bytes)?;
|
||||
Ok((convert::theme_from_craft(theme), media.into_iter().map(convert::media_item_from_craft).collect()))
|
||||
}
|
||||
|
||||
fn shapes_have_over_cap_table(shapes: &[Shape]) -> bool {
|
||||
shapes.iter().any(|s| match &s.kind {
|
||||
ShapeKind::Table(t) => t.over_cap(),
|
||||
ShapeKind::Group { children, .. } => shapes_have_over_cap_table(children),
|
||||
_ => false,
|
||||
})
|
||||
}
|
||||
|
||||
fn check_table_caps(p: &Presentation) -> Result<(), PptxError> {
|
||||
let over = p.slides.iter().any(|s| shapes_have_over_cap_table(&s.shapes))
|
||||
|| p.masters.iter().any(|m| shapes_have_over_cap_table(&m.shapes) || m.layouts.iter().any(|l| shapes_have_over_cap_table(&l.shapes)))
|
||||
|| p.notes_master.as_ref().is_some_and(|m| shapes_have_over_cap_table(&m.shapes))
|
||||
|| p.handout_master.as_ref().is_some_and(|m| shapes_have_over_cap_table(&m.shapes));
|
||||
if over {
|
||||
return Err(PptxError::Unsupported(format!(
|
||||
"a table has more than {} cells; export refused rather than drop rows",
|
||||
deckcraft_model::table::MAX_CELLS
|
||||
)));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn media_needs_timing(clip: &deckcraft_model::MediaClip) -> bool {
|
||||
clip.autoplay
|
||||
|| (clip.volume - 1.0).abs() > 1e-6
|
||||
|| clip.hide_while_not_playing
|
||||
|| clip.loop_play
|
||||
|| clip.rewind
|
||||
|| clip.play_across_slides
|
||||
|| (clip.video && clip.full_screen)
|
||||
}
|
||||
|
||||
fn assign_spids<'a>(shapes: &'a [Shape], mut visit: impl FnMut(u32, &'a Shape)) {
|
||||
let mut used = std::collections::HashSet::new();
|
||||
let mut max = 1u32;
|
||||
deckcraft_model::walk(shapes, &mut |s, _| {
|
||||
if s.id.0 >= 2 && s.id.0 < i32::MAX as u32 {
|
||||
max = max.max(s.id.0);
|
||||
}
|
||||
});
|
||||
let mut next = max;
|
||||
deckcraft_model::walk(shapes, &mut |s, _| {
|
||||
let spid = if s.id.0 >= 2 && s.id.0 < i32::MAX as u32 && !used.contains(&s.id.0) {
|
||||
s.id.0
|
||||
} else {
|
||||
next = next.saturating_add(1);
|
||||
next
|
||||
};
|
||||
used.insert(spid);
|
||||
visit(spid, s);
|
||||
});
|
||||
}
|
||||
|
||||
fn collect_export_media(shapes: &[Shape]) -> Vec<(u32, &deckcraft_model::MediaClip)> {
|
||||
let mut media = Vec::new();
|
||||
assign_spids(shapes, |spid, s| {
|
||||
if let ShapeKind::Media(clip) = &s.kind
|
||||
&& media_needs_timing(clip)
|
||||
{
|
||||
media.push((spid, clip));
|
||||
}
|
||||
});
|
||||
media
|
||||
}
|
||||
|
||||
fn collect_grp_fill_pic_spids(shapes: &[Shape]) -> std::collections::HashSet<u32> {
|
||||
let mut spids = std::collections::HashSet::new();
|
||||
assign_spids(shapes, |spid, s| {
|
||||
if s.fill == Some(deckcraft_model::style::Fill::Group)
|
||||
&& matches!(s.kind, ShapeKind::Picture { .. } | ShapeKind::Opaque { preview: Some(_), .. })
|
||||
{
|
||||
spids.insert(spid);
|
||||
}
|
||||
});
|
||||
spids
|
||||
}
|
||||
|
||||
fn write_media_node(w: &mut craft_xml::Writer, id: &mut u32, spid: u32, clip: &deckcraft_model::MediaClip) {
|
||||
let tag = if clip.video { "p:video" } else { "p:audio" };
|
||||
let mut t = w.tag(tag);
|
||||
if clip.video && clip.full_screen {
|
||||
t = t.attr("fullScrn", "1");
|
||||
}
|
||||
t.open();
|
||||
let vol = (clip.volume.clamp(0.0, 1.0) * 100_000.0).round() as u32;
|
||||
let mut cm = w.tag("p:cMediaNode").attr("vol", vol);
|
||||
if clip.volume <= 1e-6 {
|
||||
cm = cm.attr("mute", "1");
|
||||
}
|
||||
if clip.hide_while_not_playing {
|
||||
cm = cm.attr("showWhenStopped", "0");
|
||||
}
|
||||
if clip.play_across_slides {
|
||||
cm = cm.attr("numSld", "999");
|
||||
}
|
||||
cm.open();
|
||||
*id = id.saturating_add(1);
|
||||
let mut ctn = w.tag("p:cTn").attr("id", *id).attr("fill", if clip.rewind { "remove" } else { "hold" }).attr("display", "0");
|
||||
if clip.loop_play {
|
||||
ctn = ctn.attr("repeatCount", "indefinite");
|
||||
}
|
||||
ctn.open();
|
||||
w.open("p:stCondLst", &[]);
|
||||
w.tag("p:cond").attr("delay", if clip.autoplay { "0" } else { "indefinite" }).empty();
|
||||
w.close();
|
||||
w.close();
|
||||
w.open("p:tgtEl", &[]);
|
||||
w.tag("p:spTgt").attr("spid", spid).empty();
|
||||
w.close();
|
||||
w.close();
|
||||
w.close();
|
||||
}
|
||||
|
||||
fn max_ctn_id(e: &craft_xml::El, max_id: &mut u32, depth: usize) {
|
||||
if depth > 64 {
|
||||
return;
|
||||
}
|
||||
if e.is(craft_xml::Local("cTn"))
|
||||
&& let Some(id) = e.attr_local("id").and_then(craft_xml::value::to_u32_lossy)
|
||||
{
|
||||
*max_id = (*max_id).max(id);
|
||||
}
|
||||
for c in e.elements() {
|
||||
max_ctn_id(c, max_id, depth + 1);
|
||||
}
|
||||
}
|
||||
|
||||
fn patch_slide_media_timing(xml_bytes: &[u8], media: &[(u32, &deckcraft_model::MediaClip)]) -> Vec<u8> {
|
||||
let Ok(mut xml) = String::from_utf8(xml_bytes.to_vec()) else {
|
||||
return xml_bytes.to_vec();
|
||||
};
|
||||
let mut next_id = 1u32;
|
||||
if let Ok(el) = craft_drawingml::xmlx::parse(xml_bytes) {
|
||||
max_ctn_id(&el, &mut next_id, 0);
|
||||
}
|
||||
let mut w = craft_xml::Writer::new();
|
||||
for &(spid, clip) in media {
|
||||
write_media_node(&mut w, &mut next_id, spid, clip);
|
||||
}
|
||||
let nodes = w.finish();
|
||||
if let Some(tn_end) = xml.rfind("</p:tnLst>")
|
||||
&& let Some(pos) = xml[..tn_end].rfind("</p:childTnLst>")
|
||||
{
|
||||
xml.insert_str(pos, &nodes);
|
||||
} else if let Some(pos) = xml.rfind("</p:sld>") {
|
||||
let timing = format!(
|
||||
r#"<p:timing><p:tnLst><p:par><p:cTn id="1" dur="indefinite" restart="never" nodeType="tmRoot"><p:childTnLst>{nodes}</p:childTnLst></p:cTn></p:par></p:tnLst></p:timing>"#
|
||||
);
|
||||
xml.insert_str(pos, &timing);
|
||||
}
|
||||
xml.into_bytes()
|
||||
}
|
||||
|
||||
fn patch_pic_grp_fill(xml_bytes: &[u8], spids: &std::collections::HashSet<u32>) -> Vec<u8> {
|
||||
let Ok(mut xml) = String::from_utf8(xml_bytes.to_vec()) else {
|
||||
return xml_bytes.to_vec();
|
||||
};
|
||||
for &spid in spids {
|
||||
let needle = format!(r#"<p:cNvPr id="{spid}""#);
|
||||
let mut search_from = 0;
|
||||
while let Some(rel) = xml[search_from..].find(&needle) {
|
||||
let start = search_from + rel;
|
||||
let after = start + needle.len();
|
||||
let boundary_ok = xml.as_bytes().get(after).is_some_and(|b| matches!(b, b' ' | b'/' | b'>'));
|
||||
if boundary_ok
|
||||
&& let Some(pic_end_rel) = xml[after..].find("</p:pic>")
|
||||
&& let Some(sp_pr_rel) = xml[after..after + pic_end_rel].find("<p:spPr>")
|
||||
{
|
||||
let sp_pr_start = after + sp_pr_rel + "<p:spPr>".len();
|
||||
if let Some(sp_pr_end_rel) = xml[sp_pr_start..after + pic_end_rel].find("</p:spPr>") {
|
||||
let sp_pr_end = sp_pr_start + sp_pr_end_rel;
|
||||
let inner = &xml[sp_pr_start..sp_pr_end];
|
||||
if !inner.contains("<a:grpFill") {
|
||||
let insert_rel = ["<a:ln", "<a:effectLst", "<a:effectDag", "<a:scene3d", "<a:sp3d", "<a:extLst"]
|
||||
.iter()
|
||||
.filter_map(|tag| inner.find(tag))
|
||||
.min()
|
||||
.unwrap_or(sp_pr_end_rel);
|
||||
xml.insert_str(sp_pr_start + insert_rel, "<a:grpFill/>");
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
search_from = after;
|
||||
}
|
||||
}
|
||||
xml.into_bytes()
|
||||
}
|
||||
|
||||
fn collect_large_geom_adjs(shapes: &[Shape]) -> Vec<(u32, &[f64])> {
|
||||
let mut out = Vec::new();
|
||||
assign_spids(shapes, |spid, s| {
|
||||
if let deckcraft_model::Geom::Preset { adj, .. } = &s.geom
|
||||
&& adj.iter().any(|v| v.is_finite() && (v.round() < -2.0e9 || v.round() > 2.0e9))
|
||||
{
|
||||
out.push((spid, adj.as_slice()));
|
||||
}
|
||||
});
|
||||
out
|
||||
}
|
||||
|
||||
fn patch_shape_av_lst(xml: &mut String, after: usize, adj: &[f64]) {
|
||||
let shape_end_rel = ["</p:sp>", "</p:cxnSp>", "</p:pic>"].iter().filter_map(|t| xml[after..].find(t)).min();
|
||||
let Some(shape_end_rel) = shape_end_rel else { return };
|
||||
let Some(av_rel) = xml[after..after + shape_end_rel].find("<a:avLst>") else { return };
|
||||
let av_start = after + av_rel + "<a:avLst>".len();
|
||||
let Some(av_end_rel) = xml[av_start..after + shape_end_rel].find("</a:avLst>") else { return };
|
||||
let mut av_end = av_start + av_end_rel;
|
||||
for (i, &v) in adj.iter().take(16).enumerate() {
|
||||
if !v.is_finite() || (v.round() >= -2.0e9 && v.round() <= 2.0e9) {
|
||||
continue;
|
||||
}
|
||||
let clamped = v.round().clamp(-2.0e9, 2.0e9) as i64;
|
||||
let actual = v.round() as i64;
|
||||
let single_name = format!(r#"<a:gd name="adj" fmla="val {clamped}"/>"#);
|
||||
let idx_name = format!(r#"<a:gd name="adj{}" fmla="val {clamped}"/>"#, i + 1);
|
||||
let (target, repl) = if i == 0 && xml[av_start..av_end].contains(&single_name) {
|
||||
(single_name, format!(r#"<a:gd name="adj" fmla="val {actual}"/>"#))
|
||||
} else {
|
||||
(idx_name, format!(r#"<a:gd name="adj{}" fmla="val {actual}"/>"#, i + 1))
|
||||
};
|
||||
if let Some(rel) = xml[av_start..av_end].find(&target) {
|
||||
let pos = av_start + rel;
|
||||
xml.replace_range(pos..pos + target.len(), &repl);
|
||||
av_end = av_end + repl.len() - target.len();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn patch_large_geom_adjs(xml_bytes: &[u8], adjs: &[(u32, &[f64])]) -> Vec<u8> {
|
||||
let Ok(mut xml) = String::from_utf8(xml_bytes.to_vec()) else {
|
||||
return xml_bytes.to_vec();
|
||||
};
|
||||
for &(spid, adj) in adjs {
|
||||
let needle = format!(r#"<p:cNvPr id="{spid}""#);
|
||||
let mut search_from = 0;
|
||||
while let Some(rel) = xml[search_from..].find(&needle) {
|
||||
let after = search_from + rel + needle.len();
|
||||
if xml.as_bytes().get(after).is_some_and(|b| matches!(b, b' ' | b'/' | b'>')) {
|
||||
patch_shape_av_lst(&mut xml, after, adj);
|
||||
break;
|
||||
}
|
||||
search_from = after;
|
||||
}
|
||||
}
|
||||
xml.into_bytes()
|
||||
}
|
||||
|
||||
fn patch_exported_slides(p: &Presentation, bytes: Vec<u8>) -> Result<Vec<u8>, PptxError> {
|
||||
let slide_media: Vec<Vec<(u32, &deckcraft_model::MediaClip)>> = p.slides.iter().map(|s| collect_export_media(&s.shapes)).collect();
|
||||
let slide_grp_pics: Vec<std::collections::HashSet<u32>> = p.slides.iter().map(|s| collect_grp_fill_pic_spids(&s.shapes)).collect();
|
||||
let slide_adjs: Vec<Vec<(u32, &[f64])>> = p.slides.iter().map(|s| collect_large_geom_adjs(&s.shapes)).collect();
|
||||
if slide_media.iter().all(Vec::is_empty) && slide_grp_pics.iter().all(std::collections::HashSet::is_empty) && slide_adjs.iter().all(Vec::is_empty)
|
||||
{
|
||||
return Ok(bytes);
|
||||
}
|
||||
let pkg = craft_opc::Package::open(&bytes, &craft_pptx::LIMITS).map_err(|e| PptxError::Write(e.to_string()))?;
|
||||
let root_rels = pkg.rels("");
|
||||
let pres_path = root_rels.first("officeDocument").map(|r| r.target.clone()).unwrap_or_else(|| "ppt/presentation.xml".into());
|
||||
let pres_rels = pkg.rels(&pres_path);
|
||||
let mut patches: std::collections::HashMap<String, Vec<u8>> = std::collections::HashMap::new();
|
||||
if let Some(pres_bytes) = pkg.get(&pres_path)
|
||||
&& let Ok(pres_el) = craft_drawingml::xmlx::parse(pres_bytes)
|
||||
&& let Some(list) = pres_el.child(craft_xml::Local("sldIdLst"))
|
||||
{
|
||||
for (i, s) in list.children(craft_xml::Local("sldId")).enumerate() {
|
||||
let media = slide_media.get(i).map(Vec::as_slice).unwrap_or(&[]);
|
||||
let grp_pics = slide_grp_pics.get(i);
|
||||
let adjs = slide_adjs.get(i).map(Vec::as_slice).unwrap_or(&[]);
|
||||
let need_grp = grp_pics.is_some_and(|g| !g.is_empty());
|
||||
if media.is_empty() && !need_grp && adjs.is_empty() {
|
||||
continue;
|
||||
}
|
||||
if let Some(target) = s.attr_local("r:id").and_then(|rid| pres_rels.target(rid))
|
||||
&& let Some(sb) = pkg.get(target)
|
||||
{
|
||||
let mut patched = if media.is_empty() { sb.to_vec() } else { patch_slide_media_timing(sb, media) };
|
||||
if let Some(g) = grp_pics
|
||||
&& !g.is_empty()
|
||||
{
|
||||
patched = patch_pic_grp_fill(&patched, g);
|
||||
}
|
||||
if !adjs.is_empty() {
|
||||
patched = patch_large_geom_adjs(&patched, adjs);
|
||||
}
|
||||
patches.insert(target.to_string(), patched);
|
||||
}
|
||||
}
|
||||
}
|
||||
if patches.is_empty() {
|
||||
return Ok(bytes);
|
||||
}
|
||||
let entries: Vec<(String, Vec<u8>)> = pkg
|
||||
.names()
|
||||
.filter_map(|name| {
|
||||
let data = patches.remove(name).or_else(|| pkg.get(name).map(<[u8]>::to_vec))?;
|
||||
Some((name.to_string(), data))
|
||||
})
|
||||
.collect();
|
||||
craft_opc::zip_entries(&entries).map_err(|e| PptxError::Write(e.to_string()))
|
||||
}
|
||||
|
||||
/// Write a `.pptx` package.
|
||||
pub fn export(p: &Presentation) -> Result<Vec<u8>, PptxError> {
|
||||
write::export(p, write::CT_PRES)
|
||||
check_table_caps(p)?;
|
||||
let bytes = craft_pptx::export(&convert::pres_to_craft(p), &DeckDefaults)?;
|
||||
patch_exported_slides(p, bytes)
|
||||
}
|
||||
|
||||
/// Write a package for `ext`: `potx` (template) and `ppsx` (slide show) differ from `pptx` only in
|
||||
/// the main part's content type.
|
||||
pub fn export_as(p: &Presentation, ext: &str) -> Result<Vec<u8>, PptxError> {
|
||||
let ct = match ext {
|
||||
"potx" => write::CT_TEMPLATE,
|
||||
"ppsx" => write::CT_SHOW,
|
||||
_ => write::CT_PRES,
|
||||
};
|
||||
write::export(p, ct)
|
||||
}
|
||||
|
||||
/// Content type for a file name's extension.
|
||||
pub(crate) fn mime_for(name: &str) -> &'static str {
|
||||
let ext = name.rsplit_once('.').map(|(_, e)| e.to_ascii_lowercase()).unwrap_or_default();
|
||||
match ext.as_str() {
|
||||
"png" => "image/png",
|
||||
"jpg" | "jpeg" | "jpe" => "image/jpeg",
|
||||
"gif" => "image/gif",
|
||||
"bmp" => "image/bmp",
|
||||
"tif" | "tiff" => "image/tiff",
|
||||
"svg" => "image/svg+xml",
|
||||
"emf" => "image/x-emf",
|
||||
"wmf" => "image/x-wmf",
|
||||
"webp" => "image/webp",
|
||||
"mp4" | "m4v" => "video/mp4",
|
||||
"mov" => "video/quicktime",
|
||||
"wmv" => "video/x-ms-wmv",
|
||||
"avi" => "video/x-msvideo",
|
||||
"webm" => "video/webm",
|
||||
"mp3" => "audio/mpeg",
|
||||
"wav" => "audio/wav",
|
||||
"m4a" => "audio/mp4",
|
||||
"wma" => "audio/x-ms-wma",
|
||||
"ogg" => "audio/ogg",
|
||||
"flac" => "audio/flac",
|
||||
"glb" => "model/gltf-binary",
|
||||
"xlsx" => "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
|
||||
"fntdata" => "application/x-fontdata",
|
||||
_ => "application/octet-stream",
|
||||
}
|
||||
check_table_caps(p)?;
|
||||
let ext = ext.trim_start_matches('.').to_ascii_lowercase();
|
||||
let bytes = craft_pptx::export_as(&convert::pres_to_craft(p), &DeckDefaults, &ext)?;
|
||||
patch_exported_slides(p, bytes)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
@@ -228,4 +919,36 @@ mod table_direction_tests {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn over_cap_table_export_is_refused() {
|
||||
let mut p = defaults::new_presentation(None);
|
||||
let mut t = Table::new(1, 2, 200.0, 30.0);
|
||||
t.rows.resize_with(deckcraft_model::table::MAX_CELLS / 2 + 1, || deckcraft_model::table::Row {
|
||||
height: 20.0,
|
||||
cells: vec![Cell::new("x"), Cell::new("y")],
|
||||
});
|
||||
let shape = Shape { id: ShapeId(p.alloc_id().expect("id")), kind: ShapeKind::Table(t), ..Default::default() };
|
||||
Arc::make_mut(&mut p.slides[0]).shapes.push(shape);
|
||||
let err = crate::export(&p).expect_err("over-cap table must be refused");
|
||||
assert!(matches!(err, crate::PptxError::Unsupported(_)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn over_cap_table_on_notes_and_handout_master_is_refused() {
|
||||
let mut t = Table::new(1, 2, 200.0, 30.0);
|
||||
t.rows.resize_with(deckcraft_model::table::MAX_CELLS / 2 + 1, || deckcraft_model::table::Row {
|
||||
height: 20.0,
|
||||
cells: vec![Cell::new("x"), Cell::new("y")],
|
||||
});
|
||||
let mut p_notes = defaults::new_presentation(None);
|
||||
let shape = Shape { id: ShapeId(p_notes.alloc_id().expect("id")), kind: ShapeKind::Table(t.clone()), ..Default::default() };
|
||||
p_notes.notes_master = Some(Arc::new(deckcraft_model::Master { name: "Notes".into(), shapes: vec![shape], ..Default::default() }));
|
||||
assert!(matches!(crate::export(&p_notes), Err(crate::PptxError::Unsupported(_))));
|
||||
|
||||
let mut p_handout = defaults::new_presentation(None);
|
||||
let shape = Shape { id: ShapeId(p_handout.alloc_id().expect("id")), kind: ShapeKind::Table(t), ..Default::default() };
|
||||
p_handout.handout_master = Some(Arc::new(deckcraft_model::Master { name: "Handout".into(), shapes: vec![shape], ..Default::default() }));
|
||||
assert!(matches!(crate::export(&p_handout), Err(crate::PptxError::Unsupported(_))));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,449 +0,0 @@
|
||||
//! Mappings between our transition / animation ids and PresentationML elements and preset
|
||||
//! numbers, shared by the reader and the writer.
|
||||
|
||||
use deckcraft_model::anim::{ANIMATIONS, AnimClass};
|
||||
|
||||
use crate::xml::{A, El, W};
|
||||
|
||||
/// (our kind, namespace prefix, element) for transitions that map one-to-one.
|
||||
const SIMPLE: &[(&str, &str, &str)] =
|
||||
&[("dissolve", "p", "dissolve"), ("random", "p", "random"), ("honeycomb", "p14", "honeycomb"), ("flash", "p14", "flash")];
|
||||
|
||||
/// Read a transition effect element → (kind, option). `None` for effects we don't model.
|
||||
pub fn transition_from_xml(e: &El) -> Option<(String, String)> {
|
||||
let (k, o) = transition_from_xml_raw(e)?;
|
||||
// Kinds without options keep none.
|
||||
let has_opts = deckcraft_model::anim::TRANSITIONS.iter().find(|t| t.0 == k).is_none_or(|t| !t.4.is_empty());
|
||||
Some((k, if has_opts { o } else { String::new() }))
|
||||
}
|
||||
|
||||
/// Preset transitions (`p15:prstTrans`) whose "Left" option PowerPoint writes with `invX="1"`
|
||||
/// (the others write it for "Right"), as observed on PowerPoint's own files.
|
||||
const INVX_LEFT: &[&str] = &["wind", "airplane", "origami"];
|
||||
|
||||
fn transition_from_xml_raw(e: &El) -> Option<(String, String)> {
|
||||
// Defaults are what PowerPoint leaves out: e.g. it writes Push Left as `<p:push/>`.
|
||||
let dir = |d: &str| e.attr("dir").unwrap_or(d).to_string();
|
||||
let k = |s: &str| s.to_string();
|
||||
Some(match e.local() {
|
||||
"fade" => (k("fade"), if e.bool("thruBlk") == Some(true) { k("throughBlack") } else { k("smoothly") }),
|
||||
"cut" => (k("cut"), if e.bool("thruBlk") == Some(true) { k("throughBlack") } else { String::new() }),
|
||||
"push" => (k("push"), dir("l")),
|
||||
"wipe" => (k("wipe"), dir("l")),
|
||||
// Diagonal wipes.
|
||||
"strips" => (k("wipe"), dir("lu")),
|
||||
"split" => {
|
||||
let o = e.attr("orient").unwrap_or("horz");
|
||||
let d = e.attr("dir").unwrap_or("out");
|
||||
(k("split"), format!("{o}{}", if d == "in" { "In" } else { "Out" }))
|
||||
}
|
||||
"randomBar" => (k("randomBar"), dir("horz")),
|
||||
"circle" => (k("shape"), k("circle")),
|
||||
"diamond" => (k("shape"), k("diamond")),
|
||||
"plus" => (k("shape"), k("plus")),
|
||||
// Shape In / Out (the slide zooming in a box).
|
||||
"zoom" => (k("shape"), if e.attr("dir") == Some("in") { k("in") } else { k("out") }),
|
||||
// The Zoom transition, and its Zoom and Rotate option.
|
||||
"warp" => (k("zoom"), if e.attr("dir") == Some("in") { k("in") } else { k("out") }),
|
||||
"newsflash" => (k("zoom"), k("rotate")),
|
||||
"pull" => (k("uncover"), dir("l")),
|
||||
"cover" => (k("cover"), dir("l")),
|
||||
"checker" => (k("checker"), dir("horz")),
|
||||
"blinds" => (k("blinds"), dir("horz")),
|
||||
"comb" => (k("comb"), dir("horz")),
|
||||
"wheel" => (k("clock"), k("clockwise")),
|
||||
"wheelReverse" => (k("clock"), k("counterClockwise")),
|
||||
"wedge" => (k("clock"), k("wedge")),
|
||||
"vortex" => (k("vortex"), dir("l")),
|
||||
"switch" => (k("switch"), dir("r")),
|
||||
"flip" => (k("flip"), dir("r")),
|
||||
"ripple" => (k("ripple"), dir("center")),
|
||||
"doors" => (k("doors"), dir("horz")),
|
||||
"window" => (k("window"), dir("horz")),
|
||||
"ferris" => (k("ferris"), dir("l")),
|
||||
"gallery" => (k("gallery"), dir("l")),
|
||||
"conveyor" => (k("conveyor"), dir("l")),
|
||||
"pan" => (k("pan"), dir("l")),
|
||||
"glitter" => {
|
||||
let d = dir("l");
|
||||
if e.attr("pattern") == Some("hexagon") { (k("glitter"), format!("hex{}", d.to_ascii_uppercase())) } else { (k("glitter"), d) }
|
||||
}
|
||||
"shred" => {
|
||||
// `crush` is what DeckCraft wrote before it knew PowerPoint's `rectangle`.
|
||||
let particles = matches!(e.attr("pattern"), Some("rectangle" | "crush"));
|
||||
let out = e.attr("dir") == Some("out");
|
||||
(k("shred"), format!("{}{}", if particles { "particles" } else { "strips" }, if out { "Out" } else { "In" }))
|
||||
}
|
||||
"reveal" => {
|
||||
let black = e.bool("thruBlk") == Some(true);
|
||||
let right = e.attr("dir") == Some("r");
|
||||
(k("reveal"), format!("{}{}", if black { "black" } else { "smoothly" }, if right { "Right" } else { "Left" }))
|
||||
}
|
||||
"flythrough" => {
|
||||
let out = e.attr("dir") == Some("out");
|
||||
let b = e.bool("hasBounce") == Some(true);
|
||||
(k("flythrough"), format!("{}{}", if out { "out" } else { "in" }, if b { "Bounce" } else { "" }))
|
||||
}
|
||||
"prism" => {
|
||||
let content = e.bool("isContent") == Some(true);
|
||||
let inv = e.bool("isInverted") == Some(true);
|
||||
let kind = match (content, inv) {
|
||||
(false, false) => "cube",
|
||||
(false, true) => "box",
|
||||
(true, false) => "rotate",
|
||||
(true, true) => "orbit",
|
||||
};
|
||||
(k(kind), dir("l"))
|
||||
}
|
||||
"prstTrans" => {
|
||||
let prst = e.attr("prst").unwrap_or("fallOver");
|
||||
let inv = e.bool("invX") == Some(true);
|
||||
if prst == "pageCurlSingle" {
|
||||
return Some((k("pageCurlDouble"), if inv { k("singleR") } else { k("singleL") }));
|
||||
}
|
||||
let known = deckcraft_model::anim::TRANSITIONS.iter().any(|t| t.0 == prst);
|
||||
if !known {
|
||||
return None;
|
||||
}
|
||||
let left = if INVX_LEFT.contains(&prst) { inv } else { !inv };
|
||||
(k(prst), if left { k("l") } else { k("r") })
|
||||
}
|
||||
"morph" => (
|
||||
k("morph"),
|
||||
match e.attr("option") {
|
||||
Some("byWord") => k("words"),
|
||||
Some("byChar") => k("characters"),
|
||||
_ => k("objects"),
|
||||
},
|
||||
),
|
||||
other => (k(SIMPLE.iter().find(|s| s.2 == other)?.0), String::new()),
|
||||
})
|
||||
}
|
||||
|
||||
/// Write the effect element for a transition. Returns the namespace prefix it needs
|
||||
/// (`p`, `p14`, `p15`, `p159`), or `None` when the kind is unknown.
|
||||
pub fn transition_to_xml(w: &mut W, kind: &str, option: &str) -> Option<&'static str> {
|
||||
let lr = |d: &'static str| match option {
|
||||
"l" | "r" => option.to_string(),
|
||||
_ => d.to_string(),
|
||||
};
|
||||
let lrud = |d: &'static str| match option {
|
||||
"l" | "r" | "u" | "d" => option.to_string(),
|
||||
_ => d.to_string(),
|
||||
};
|
||||
let hv = |d: &'static str| match option {
|
||||
"horz" | "vert" => option.to_string(),
|
||||
_ => d.to_string(),
|
||||
};
|
||||
let eight = |d: &'static str| match option {
|
||||
"l" | "r" | "u" | "d" | "lu" | "ru" | "ld" | "rd" => option.to_string(),
|
||||
_ => d.to_string(),
|
||||
};
|
||||
match kind {
|
||||
"fade" => w.empty("p:fade", A::new().t("thruBlk", option == "throughBlack")),
|
||||
"cut" => w.empty("p:cut", A::new().t("thruBlk", option == "throughBlack")),
|
||||
"push" => w.empty("p:push", A::new().a("dir", lrud("u"))),
|
||||
"wipe" => match option {
|
||||
"lu" | "ru" | "ld" | "rd" => w.empty("p:strips", A::new().a("dir", option)),
|
||||
_ => w.empty("p:wipe", A::new().a("dir", lrud("r"))),
|
||||
},
|
||||
"split" => {
|
||||
let (o, d) = match option {
|
||||
"vertIn" => ("vert", "in"),
|
||||
"vertOut" => ("vert", "out"),
|
||||
"horzIn" => ("horz", "in"),
|
||||
_ => ("horz", "out"),
|
||||
};
|
||||
w.empty("p:split", A::new().a("orient", o).a("dir", d));
|
||||
}
|
||||
"randomBar" => w.empty("p:randomBar", A::new().a("dir", hv("vert"))),
|
||||
"shape" => match option {
|
||||
"diamond" => w.empty0("p:diamond"),
|
||||
"plus" => w.empty0("p:plus"),
|
||||
"in" | "out" => w.empty("p:zoom", A::new().a("dir", option)),
|
||||
_ => w.empty0("p:circle"),
|
||||
},
|
||||
"zoom" => match option {
|
||||
"rotate" => w.empty0("p:newsflash"),
|
||||
_ => {
|
||||
w.empty("p14:warp", A::new().a("dir", if option == "out" { "out" } else { "in" }));
|
||||
return Some("p14");
|
||||
}
|
||||
},
|
||||
"uncover" => w.empty("p:pull", A::new().a("dir", eight("l"))),
|
||||
"cover" => w.empty("p:cover", A::new().a("dir", eight("l"))),
|
||||
"checker" => w.empty("p:checker", A::new().a("dir", hv("horz"))),
|
||||
"blinds" => w.empty("p:blinds", A::new().a("dir", hv("horz"))),
|
||||
"comb" => w.empty("p:comb", A::new().a("dir", hv("horz"))),
|
||||
"clock" => match option {
|
||||
"counterClockwise" => {
|
||||
w.empty("p14:wheelReverse", A::new().a("spokes", 1));
|
||||
return Some("p14");
|
||||
}
|
||||
"wedge" => w.empty0("p:wedge"),
|
||||
_ => w.empty("p:wheel", A::new().a("spokes", 1)),
|
||||
},
|
||||
"dissolve" => w.empty0("p:dissolve"),
|
||||
"random" => w.empty0("p:random"),
|
||||
"honeycomb" => {
|
||||
w.empty0("p14:honeycomb");
|
||||
return Some("p14");
|
||||
}
|
||||
"flash" => {
|
||||
w.empty0("p14:flash");
|
||||
return Some("p14");
|
||||
}
|
||||
"vortex" => {
|
||||
w.empty("p14:vortex", A::new().a("dir", lrud("l")));
|
||||
return Some("p14");
|
||||
}
|
||||
"glitter" => {
|
||||
let hex = option.starts_with("hex");
|
||||
let d = option.trim_start_matches("hex").to_ascii_lowercase();
|
||||
let d = if matches!(d.as_str(), "l" | "r" | "u" | "d") { d } else { "l".to_string() };
|
||||
w.empty("p14:glitter", A::new().a("dir", d).o("pattern", hex.then_some("hexagon")));
|
||||
return Some("p14");
|
||||
}
|
||||
"switch" | "flip" | "gallery" | "conveyor" | "ferris" => {
|
||||
let name = match kind {
|
||||
"switch" => "p14:switch",
|
||||
"flip" => "p14:flip",
|
||||
"gallery" => "p14:gallery",
|
||||
"conveyor" => "p14:conveyor",
|
||||
_ => "p14:ferris",
|
||||
};
|
||||
w.empty(name, A::new().a("dir", lr("l")));
|
||||
return Some("p14");
|
||||
}
|
||||
"ripple" => {
|
||||
let d = match option {
|
||||
"lu" | "ru" | "ld" | "rd" => option,
|
||||
_ => "center",
|
||||
};
|
||||
w.empty("p14:ripple", A::new().a("dir", d));
|
||||
return Some("p14");
|
||||
}
|
||||
"doors" | "window" => {
|
||||
let name = if kind == "doors" { "p14:doors" } else { "p14:window" };
|
||||
w.empty(name, A::new().a("dir", hv("vert")));
|
||||
return Some("p14");
|
||||
}
|
||||
"pan" => {
|
||||
w.empty("p14:pan", A::new().a("dir", lrud("d")));
|
||||
return Some("p14");
|
||||
}
|
||||
"shred" => {
|
||||
let particles = option.starts_with("particles");
|
||||
w.empty(
|
||||
"p14:shred",
|
||||
A::new().a("pattern", if particles { "rectangle" } else { "strip" }).a("dir", if option.ends_with("Out") { "out" } else { "in" }),
|
||||
);
|
||||
return Some("p14");
|
||||
}
|
||||
"reveal" => {
|
||||
w.empty("p14:reveal", A::new().t("thruBlk", option.starts_with("black")).a("dir", if option.ends_with("Right") { "r" } else { "l" }));
|
||||
return Some("p14");
|
||||
}
|
||||
"flythrough" => {
|
||||
w.empty(
|
||||
"p14:flythrough",
|
||||
A::new().a("dir", if option.starts_with("out") { "out" } else { "in" }).t("hasBounce", option.ends_with("Bounce")),
|
||||
);
|
||||
return Some("p14");
|
||||
}
|
||||
"cube" | "box" | "rotate" | "orbit" => {
|
||||
w.empty(
|
||||
"p14:prism",
|
||||
A::new().a("dir", lrud("l")).t("isContent", matches!(kind, "rotate" | "orbit")).t("isInverted", matches!(kind, "box" | "orbit")),
|
||||
);
|
||||
return Some("p14");
|
||||
}
|
||||
"pageCurlDouble" if option.starts_with("single") => {
|
||||
w.empty("p15:prstTrans", A::new().a("prst", "pageCurlSingle").t("invX", option == "singleR"));
|
||||
return Some("p15");
|
||||
}
|
||||
"fallOver" | "drape" | "curtains" | "wind" | "prestige" | "fracture" | "crush" | "peelOff" | "pageCurlDouble" | "airplane" | "origami" => {
|
||||
let inv = if INVX_LEFT.contains(&kind) { option == "l" } else { option == "r" };
|
||||
w.empty("p15:prstTrans", A::new().a("prst", kind).t("invX", inv));
|
||||
return Some("p15");
|
||||
}
|
||||
"morph" => {
|
||||
let o = match option {
|
||||
"words" => "byWord",
|
||||
"characters" => "byChar",
|
||||
_ => "byObject",
|
||||
};
|
||||
w.empty("p159:morph", A::new().a("option", o));
|
||||
return Some("p159");
|
||||
}
|
||||
_ => return None,
|
||||
}
|
||||
Some("p")
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------------------------
|
||||
// Animations
|
||||
|
||||
/// Effect options ↔ preset subtypes.
|
||||
const SUBTYPES: &[(&str, &[(&str, u32)])] = &[
|
||||
("fly", DIR8),
|
||||
("flyOut", DIR8),
|
||||
("peek", DIR4),
|
||||
("wipe", DIR4),
|
||||
("wipeOut", DIR4),
|
||||
("strips", &[("lu", 9), ("ru", 3), ("ld", 12), ("rd", 6)]),
|
||||
("split", SPLIT),
|
||||
("splitOut", SPLIT),
|
||||
("zoom", INOUT),
|
||||
("zoomOut", INOUT),
|
||||
("box", INOUT),
|
||||
("circle", INOUT),
|
||||
("diamond", INOUT),
|
||||
("randomBars", HV),
|
||||
("randomBarsOut", HV),
|
||||
("blinds", HV),
|
||||
("swivel", HV),
|
||||
("swivelOut", HV),
|
||||
("blindsOut", HV),
|
||||
("boxOut", INOUT),
|
||||
("checkerboardOut", &[("across", 10), ("down", 5)]),
|
||||
("diamondOut", INOUT),
|
||||
("peekOut", DIR4),
|
||||
("stripsOut", &[("lu", 9), ("ru", 3), ("ld", 12), ("rd", 6)]),
|
||||
("checkerboard", &[("across", 10), ("down", 5)]),
|
||||
("wheel", WHEEL),
|
||||
("wheelOut", WHEEL),
|
||||
("float", &[("u", 0), ("d", 4)]),
|
||||
("floatOut", &[("u", 0), ("d", 4)]),
|
||||
(
|
||||
"shape",
|
||||
&[("circleIn", 16), ("circleOut", 32), ("boxIn", 16), ("boxOut", 32), ("diamondIn", 16), ("diamondOut", 32), ("plusIn", 16), ("plusOut", 32)],
|
||||
),
|
||||
("shapeOut", INOUT_SHAPE),
|
||||
("lines", &[("down", 4), ("up", 1), ("right", 2), ("left", 8)]),
|
||||
("arcs", &[("down", 4), ("up", 1), ("right", 2), ("left", 8)]),
|
||||
("turns", &[("down", 4), ("up", 1), ("right", 2), ("left", 8)]),
|
||||
];
|
||||
const DIR8: &[(&str, u32)] = &[("b", 4), ("lb", 12), ("l", 8), ("lt", 9), ("t", 1), ("rt", 3), ("r", 2), ("rb", 6)];
|
||||
const DIR4: &[(&str, u32)] = &[("b", 4), ("l", 8), ("t", 1), ("r", 2)];
|
||||
const SPLIT: &[(&str, u32)] = &[("horzIn", 21), ("horzOut", 42), ("vertIn", 26), ("vertOut", 37)];
|
||||
const INOUT: &[(&str, u32)] = &[("in", 16), ("out", 32)];
|
||||
const INOUT_SHAPE: &[(&str, u32)] = &[("circleIn", 16), ("circleOut", 32)];
|
||||
const HV: &[(&str, u32)] = &[("horz", 10), ("vert", 5)];
|
||||
const WHEEL: &[(&str, u32)] = &[("1", 1), ("2", 2), ("3", 3), ("4", 4), ("8", 8)];
|
||||
|
||||
pub fn option_from_subtype(effect: &str, sub: u32) -> String {
|
||||
SUBTYPES.iter().find(|(e, _)| *e == effect).and_then(|(_, m)| m.iter().find(|(_, s)| *s == sub)).map(|(o, _)| o.to_string()).unwrap_or_default()
|
||||
}
|
||||
|
||||
pub fn subtype_from_option(effect: &str, option: &str) -> Option<u32> {
|
||||
SUBTYPES.iter().find(|(e, _)| *e == effect).and_then(|(_, m)| m.iter().find(|(o, _)| *o == option)).map(|(_, s)| *s)
|
||||
}
|
||||
|
||||
/// Our effect id for a preset (first match in [`ANIMATIONS`]).
|
||||
pub fn effect_for_preset(class: AnimClass, preset: u32) -> Option<&'static str> {
|
||||
ANIMATIONS.iter().find(|a| a.2 == class && a.3 == preset && a.0 != "customPath").map(|a| a.0)
|
||||
}
|
||||
|
||||
/// Effect used for presets we don't know.
|
||||
pub fn fallback_effect(class: AnimClass) -> &'static str {
|
||||
match class {
|
||||
AnimClass::Entrance => "fade",
|
||||
AnimClass::Exit => "fadeOut",
|
||||
AnimClass::Emphasis => "pulse",
|
||||
AnimClass::Path => "customPath",
|
||||
AnimClass::Media => "play",
|
||||
}
|
||||
}
|
||||
|
||||
/// The preset id to write for an animation.
|
||||
pub fn preset_for(a: &deckcraft_model::Animation) -> u32 {
|
||||
// Float Down is PowerPoint's preset 47 (Float Up is 42).
|
||||
if matches!(a.effect.as_str(), "float" | "floatOut") && a.option == "d" {
|
||||
return 47;
|
||||
}
|
||||
if let Some(p) = a.preset_id {
|
||||
let consistent = match effect_for_preset(a.class, p) {
|
||||
Some(e) => e == a.effect,
|
||||
None => a.effect == fallback_effect(a.class),
|
||||
};
|
||||
if consistent {
|
||||
return p;
|
||||
}
|
||||
}
|
||||
match deckcraft_model::anim::animation_info(&a.effect, a.class) {
|
||||
Some(info) if info.2 == a.class => info.3,
|
||||
_ => match a.class {
|
||||
AnimClass::Entrance | AnimClass::Exit => 10,
|
||||
AnimClass::Emphasis => 26,
|
||||
AnimClass::Path => 0,
|
||||
AnimClass::Media => 1,
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::xml::parse;
|
||||
|
||||
/// #147: these exits, with their directions, fell back to a plain fade (PowerPoint's ids).
|
||||
#[test]
|
||||
fn exit_presets_import_as_their_own_effects() {
|
||||
for (preset, sub, effect, option) in [
|
||||
(3, 10, "blindsOut", "horz"),
|
||||
(4, 32, "boxOut", "out"),
|
||||
(5, 5, "checkerboardOut", "down"),
|
||||
(8, 16, "diamondOut", "in"),
|
||||
(12, 4, "peekOut", "b"),
|
||||
(18, 6, "stripsOut", "rd"),
|
||||
(37, 0, "sinkDown", ""),
|
||||
(49, 0, "spinnerOut", ""),
|
||||
(55, 0, "contract", ""),
|
||||
] {
|
||||
let e = effect_for_preset(AnimClass::Exit, preset).expect("known exit");
|
||||
assert_eq!((e, option_from_subtype(e, sub).as_str()), (effect, option), "preset {preset}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn every_transition_kind_round_trips() {
|
||||
for (kind, _, _, _, opts) in deckcraft_model::anim::TRANSITIONS {
|
||||
if *kind == "none" {
|
||||
continue;
|
||||
}
|
||||
let opts: Vec<&str> = if opts.is_empty() { vec![""] } else { opts.to_vec() };
|
||||
for o in opts {
|
||||
let mut w = W::frag();
|
||||
let ns = transition_to_xml(&mut w, kind, o).unwrap_or_else(|| panic!("no xml for {kind}"));
|
||||
assert!(!ns.is_empty());
|
||||
let d = parse(w.s.as_bytes()).unwrap();
|
||||
let (k, opt) = transition_from_xml(&d.root).unwrap_or_else(|| panic!("no read for {kind}"));
|
||||
assert_eq!(k, *kind, "kind for {kind}/{o}");
|
||||
if !o.is_empty() {
|
||||
assert_eq!(opt, o, "option for {kind}");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn subtypes() {
|
||||
assert_eq!(subtype_from_option("fly", "b"), Some(4));
|
||||
assert_eq!(option_from_subtype("fly", 8), "l");
|
||||
assert_eq!(option_from_subtype("fade", 0), "");
|
||||
assert_eq!(effect_for_preset(AnimClass::Entrance, 2), Some("fly"));
|
||||
assert_eq!(effect_for_preset(AnimClass::Emphasis, 8), Some("spin"));
|
||||
}
|
||||
|
||||
/// PowerPoint's own ids: Darken is 24 and Desaturate 25 (read back from its saved file).
|
||||
#[test]
|
||||
fn darken_and_desaturate_use_powerpoints_ids() {
|
||||
assert_eq!(effect_for_preset(AnimClass::Emphasis, 24), Some("darken"));
|
||||
assert_eq!(effect_for_preset(AnimClass::Emphasis, 25), Some("desaturate"));
|
||||
for (effect, id) in [("darken", 24), ("desaturate", 25)] {
|
||||
let a = deckcraft_model::Animation { class: AnimClass::Emphasis, effect: effect.into(), ..Default::default() };
|
||||
assert_eq!(preset_for(&a), id, "{effect}");
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,563 +0,0 @@
|
||||
//! Open Packaging Conventions: the zip container, part names, relationships and content types.
|
||||
|
||||
use std::collections::HashMap;
|
||||
use std::io::{Cursor, Read, Write};
|
||||
|
||||
use crate::PptxError;
|
||||
use crate::xml::{self, A, W};
|
||||
|
||||
/// Largest single part we decompress (media included).
|
||||
pub const MAX_PART: u64 = 512 * 1024 * 1024;
|
||||
/// Largest XML part we parse.
|
||||
pub const MAX_XML_PART: usize = 96 * 1024 * 1024;
|
||||
/// Total decompressed bytes accepted for one package.
|
||||
pub const MAX_TOTAL: u64 = 2 * 1024 * 1024 * 1024;
|
||||
/// Total bytes we are willing to decompress for one package, counting parts we then discard
|
||||
/// (too large, or failing part-way): bounds inflate work, not just what is kept.
|
||||
pub const MAX_INFLATE_WORK: u64 = 2 * MAX_TOTAL;
|
||||
/// Maximum number of zip entries.
|
||||
pub const MAX_ENTRIES: usize = 50_000;
|
||||
|
||||
pub const NS_A: &str = "http://schemas.openxmlformats.org/drawingml/2006/main";
|
||||
pub const NS_R: &str = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
|
||||
pub const NS_P: &str = "http://schemas.openxmlformats.org/presentationml/2006/main";
|
||||
pub const NS_C: &str = "http://schemas.openxmlformats.org/drawingml/2006/chart";
|
||||
pub const NS_MC: &str = "http://schemas.openxmlformats.org/markup-compatibility/2006";
|
||||
pub const NS_P14: &str = "http://schemas.microsoft.com/office/powerpoint/2010/main";
|
||||
pub const NS_P15: &str = "http://schemas.microsoft.com/office/powerpoint/2012/main";
|
||||
pub const NS_P159: &str = "http://schemas.microsoft.com/office/powerpoint/2015/09/main";
|
||||
pub const NS_A14: &str = "http://schemas.microsoft.com/office/drawing/2010/main";
|
||||
/// Modern (threaded) comments, Office 2018/8 schema.
|
||||
pub const NS_P188: &str = "http://schemas.microsoft.com/office/powerpoint/2018/8/main";
|
||||
|
||||
pub const RT_BASE: &str = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/";
|
||||
pub const RT_MEDIA: &str = "http://schemas.microsoft.com/office/2007/relationships/media";
|
||||
/// A 3-D model part (`.glb`). Office relationship, not an ECMA-376 base type.
|
||||
pub const RT_MODEL3D: &str = "http://schemas.microsoft.com/office/2017/06/relationships/model3d";
|
||||
pub const RT_CORE: &str = "http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties";
|
||||
|
||||
/// The files of a package, keyed by normalised part name (no leading slash, lowercase).
|
||||
pub struct Package {
|
||||
parts: HashMap<String, (String, Vec<u8>)>,
|
||||
ct_cache: std::sync::OnceLock<(HashMap<String, String>, HashMap<String, String>)>,
|
||||
}
|
||||
|
||||
impl Package {
|
||||
pub fn open(bytes: &[u8]) -> Result<Self, PptxError> {
|
||||
Self::open_within(bytes, MAX_PART, MAX_TOTAL, MAX_INFLATE_WORK)
|
||||
}
|
||||
/// [`Package::open`] with explicit limits: per part, kept in total, and inflated in total.
|
||||
fn open_within(bytes: &[u8], max_part: u64, max_total: u64, max_work: u64) -> Result<Self, PptxError> {
|
||||
let mut zip = zip::ZipArchive::new(Cursor::new(bytes)).map_err(|e| PptxError::NotPptx(format!("{e}")))?;
|
||||
if zip.len() > MAX_ENTRIES {
|
||||
return Err(PptxError::NotPptx(format!("too many entries ({})", zip.len())));
|
||||
}
|
||||
let mut parts = HashMap::new();
|
||||
let mut total: u64 = 0;
|
||||
let mut work: u64 = 0;
|
||||
for i in 0..zip.len() {
|
||||
if work >= max_work {
|
||||
log::warn!("pptx: decompression budget spent; skipping the remaining {} entries", zip.len() - i);
|
||||
break;
|
||||
}
|
||||
let mut f = match zip.by_index(i) {
|
||||
Ok(f) => f,
|
||||
Err(e) => {
|
||||
log::warn!("pptx: skipping unreadable zip entry {i}: {e}");
|
||||
continue;
|
||||
}
|
||||
};
|
||||
if f.is_dir() {
|
||||
continue;
|
||||
}
|
||||
let name = f.name().trim_start_matches('/').to_string();
|
||||
let declared = f.size();
|
||||
if declared > max_part {
|
||||
log::warn!("pptx: skipping oversized part {name} ({declared} bytes)");
|
||||
continue;
|
||||
}
|
||||
let mut data = Vec::with_capacity(declared.min(16 * 1024 * 1024) as usize);
|
||||
let cap = max_part.min(max_total.saturating_sub(total)).min(max_work.saturating_sub(work));
|
||||
let read = (&mut f).take(cap.saturating_add(1)).read_to_end(&mut data);
|
||||
// Charge what was inflated whether or not the part is kept.
|
||||
work = work.saturating_add(data.len() as u64);
|
||||
match read {
|
||||
Ok(_) if data.len() as u64 > cap => {
|
||||
log::warn!("pptx: part {name} exceeds size limits; skipped");
|
||||
continue;
|
||||
}
|
||||
Ok(_) => {}
|
||||
Err(e) => {
|
||||
log::warn!("pptx: could not read {name}: {e}");
|
||||
continue;
|
||||
}
|
||||
}
|
||||
total = total.saturating_add(data.len() as u64);
|
||||
// A name kept with `\` would reach code that splits paths on `/`.
|
||||
parts.insert(norm(&name), (name.replace('\\', "/"), data));
|
||||
}
|
||||
Ok(Package { parts, ct_cache: std::sync::OnceLock::new() })
|
||||
}
|
||||
pub fn get(&self, name: &str) -> Option<&[u8]> {
|
||||
self.parts.get(&norm(name)).map(|(_, d)| d.as_slice())
|
||||
}
|
||||
/// An XML part's bytes, when it is within the XML size limit.
|
||||
pub fn xml_bytes(&self, name: &str) -> Option<&[u8]> {
|
||||
let b = self.get(name)?;
|
||||
if b.len() > MAX_XML_PART {
|
||||
log::warn!("pptx: XML part {name} too large");
|
||||
return None;
|
||||
}
|
||||
Some(b)
|
||||
}
|
||||
/// Parse an XML part.
|
||||
pub fn xml(&self, name: &str) -> Option<xml::Doc> {
|
||||
let b = self.get(name)?;
|
||||
if b.len() > MAX_XML_PART {
|
||||
log::warn!("pptx: XML part {name} too large");
|
||||
return None;
|
||||
}
|
||||
match xml::parse(b) {
|
||||
Ok(d) => Some(d),
|
||||
Err(e) => {
|
||||
log::warn!("pptx: {name}: {e}");
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
/// Relationships of a part (`ppt/slides/slide1.xml` → `ppt/slides/_rels/slide1.xml.rels`).
|
||||
pub fn rels(&self, part: &str) -> Rels {
|
||||
let rp = rels_path(part);
|
||||
let Some(doc) = self.xml(&rp) else { return Rels::default() };
|
||||
rels_of(&doc, part)
|
||||
}
|
||||
/// Content types: (extension defaults, part overrides).
|
||||
pub fn content_type(&self, part: &str) -> Option<String> {
|
||||
let (overrides, defaults) = self.ct_cache.get_or_init(|| {
|
||||
let mut ov = HashMap::new();
|
||||
let mut def = HashMap::new();
|
||||
if let Some(doc) = self.xml("[Content_Types].xml") {
|
||||
for o in doc.root.children_named("Override") {
|
||||
if let (Some(n), Some(ct)) = (o.attr("PartName"), o.attr("ContentType")) {
|
||||
ov.insert(n.to_ascii_lowercase(), ct.to_string());
|
||||
}
|
||||
}
|
||||
for d in doc.root.children_named("Default") {
|
||||
if let (Some(e), Some(ct)) = (d.attr("Extension"), d.attr("ContentType")) {
|
||||
def.insert(e.to_ascii_lowercase(), ct.to_string());
|
||||
}
|
||||
}
|
||||
}
|
||||
(ov, def)
|
||||
});
|
||||
let p = format!("/{}", norm(part));
|
||||
if let Some(ct) = overrides.get(&p) {
|
||||
return Some(ct.clone());
|
||||
}
|
||||
let ext = part.rsplit('.').next().unwrap_or("").to_ascii_lowercase();
|
||||
defaults.get(&ext).cloned()
|
||||
}
|
||||
pub fn original_name(&self, name: &str) -> Option<&str> {
|
||||
self.parts.get(&norm(name)).map(|(n, _)| n.as_str())
|
||||
}
|
||||
}
|
||||
|
||||
/// The relationships in a parsed rels part, with internal targets resolved against `part`'s folder.
|
||||
fn rels_of(doc: &xml::Doc, part: &str) -> Rels {
|
||||
let base = dir_of(part);
|
||||
let mut out = Rels::default();
|
||||
for r in doc.root.children_named("Relationship") {
|
||||
let (Some(id), Some(ty), Some(target)) = (r.attr("Id"), r.attr("Type"), r.attr("Target")) else { continue };
|
||||
let external = r.attr("TargetMode").is_some_and(|m| m.eq_ignore_ascii_case("external"));
|
||||
let target_raw = target.to_string();
|
||||
let target = if external { target_raw.clone() } else { resolve(&base, target) };
|
||||
out.by_id.entry(id.to_string()).or_insert(out.items.len());
|
||||
out.items.push(Rel {
|
||||
id: id.to_string(),
|
||||
kind: ty.rsplit('/').next().unwrap_or(ty).to_string(),
|
||||
ty: ty.to_string(),
|
||||
target_raw,
|
||||
target,
|
||||
external,
|
||||
});
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// The relationships of `part` from the bytes of its rels part (kept parts carried by a chart).
|
||||
pub fn rels_from_bytes(bytes: &[u8], part: &str) -> Rels {
|
||||
match xml::parse(bytes) {
|
||||
Ok(doc) => rels_of(&doc, part),
|
||||
Err(e) => {
|
||||
log::warn!("pptx: relationships of {part}: {e}");
|
||||
Rels::default()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Default)]
|
||||
pub struct Rel {
|
||||
pub id: String,
|
||||
/// Last segment of the relationship type (`slide`, `image`, `media`…).
|
||||
pub kind: String,
|
||||
/// Full relationship type URI.
|
||||
pub ty: String,
|
||||
/// `Target` as written in the rels part (relative path or URL).
|
||||
pub target_raw: String,
|
||||
/// Absolute part name for internal targets; the URL for external ones.
|
||||
pub target: String,
|
||||
pub external: bool,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Default)]
|
||||
pub struct Rels {
|
||||
pub items: Vec<Rel>,
|
||||
/// Id → index of its first relationship in `items`.
|
||||
by_id: HashMap<String, usize>,
|
||||
}
|
||||
|
||||
impl Rels {
|
||||
pub fn get(&self, id: &str) -> Option<&Rel> {
|
||||
self.by_id.get(id).and_then(|&i| self.items.get(i))
|
||||
}
|
||||
pub fn target(&self, id: &str) -> Option<&str> {
|
||||
self.get(id).map(|r| r.target.as_str())
|
||||
}
|
||||
pub fn first_of(&self, kind: &str) -> Option<&Rel> {
|
||||
self.items.iter().find(|r| r.kind == kind)
|
||||
}
|
||||
pub fn all_of<'a>(&'a self, kind: &'a str) -> impl Iterator<Item = &'a Rel> + 'a {
|
||||
self.items.iter().filter(move |r| r.kind == kind)
|
||||
}
|
||||
}
|
||||
|
||||
pub fn norm(name: &str) -> String {
|
||||
name.trim_start_matches('/').replace('\\', "/").to_ascii_lowercase()
|
||||
}
|
||||
|
||||
/// A part a chart may carry along beside its own `chartN.xml` (workbook, style, drawing, picture).
|
||||
/// Chart documents themselves are rewritten, and nothing outside these folders is copied: a relationship
|
||||
/// must not be able to replace `ppt/slides/slide1.xml` on save.
|
||||
pub fn sidecar_part(name: &str) -> bool {
|
||||
let n = norm(name);
|
||||
let segs: Vec<&str> = n.split('/').filter(|s| !s.is_empty()).collect();
|
||||
if segs.iter().any(|s| *s == "." || *s == "..") {
|
||||
return false;
|
||||
}
|
||||
let (Some(root), Some(area)) = (segs.first().copied(), segs.get(1).copied()) else { return false };
|
||||
if root != "ppt" || !matches!(area, "embeddings" | "charts" | "drawings" | "media") {
|
||||
return false;
|
||||
}
|
||||
let file = segs.last().copied().unwrap_or("");
|
||||
let stem = file.strip_prefix("chart").unwrap_or("");
|
||||
let num = stem.strip_suffix(".xml.rels").or_else(|| stem.strip_suffix(".xml")).unwrap_or("");
|
||||
!(stem != file && !num.is_empty() && num.chars().all(|c| c.is_ascii_digit()))
|
||||
}
|
||||
|
||||
pub fn dir_of(part: &str) -> String {
|
||||
craft_opc::dir_of(part).to_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 {
|
||||
let target = percent_decode(target.split('#').next().unwrap_or("")).replace('\\', "/");
|
||||
let target = target.as_str();
|
||||
let mut segs: Vec<&str> = if target.starts_with('/') { vec![] } else { base.split('/').filter(|s| !s.is_empty()).collect() };
|
||||
for s in target.split('/') {
|
||||
match s {
|
||||
"" | "." => {}
|
||||
".." => {
|
||||
segs.pop();
|
||||
}
|
||||
s => segs.push(s),
|
||||
}
|
||||
}
|
||||
segs.join("/")
|
||||
}
|
||||
|
||||
/// Relative target from the directory of `from` to part `to` (both absolute part names).
|
||||
pub fn relative(from: &str, to: &str) -> String {
|
||||
let fd_s = dir_of(from);
|
||||
let fd: Vec<&str> = fd_s.split('/').filter(|s| !s.is_empty()).collect();
|
||||
let td_s = dir_of(to);
|
||||
let td: Vec<&str> = td_s.split('/').filter(|s| !s.is_empty()).collect();
|
||||
let common = fd.iter().zip(td.iter()).take_while(|(a, b)| a == b).count();
|
||||
let mut out = String::new();
|
||||
for _ in common..fd.len() {
|
||||
out.push_str("../");
|
||||
}
|
||||
for s in td.iter().skip(common) {
|
||||
out.push_str(s);
|
||||
out.push('/');
|
||||
}
|
||||
out.push_str(file_of(to));
|
||||
out
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------------------------
|
||||
// Writing
|
||||
|
||||
/// Relationships being built for one part.
|
||||
#[derive(Default)]
|
||||
pub struct RelsOut {
|
||||
pub items: Vec<(String, String, String, bool)>,
|
||||
/// (type, target, external) → id of the relationship [`RelsOut::add`] made for it.
|
||||
added: HashMap<(String, String, bool), String>,
|
||||
}
|
||||
|
||||
impl RelsOut {
|
||||
/// Add (or reuse) a relationship; `kind` is a full type URI or a suffix of the standard base.
|
||||
pub fn add(&mut self, kind: &str, target: &str, external: bool) -> String {
|
||||
let ty = if kind.starts_with("http") { kind.to_string() } else { format!("{RT_BASE}{kind}") };
|
||||
let key = (ty, target.to_string(), external);
|
||||
if let Some(id) = self.added.get(&key) {
|
||||
return id.clone();
|
||||
}
|
||||
let id = format!("rId{}", self.items.len() + 1);
|
||||
self.items.push((id.clone(), key.0.clone(), key.1.clone(), external));
|
||||
self.added.insert(key, id.clone());
|
||||
id
|
||||
}
|
||||
/// Always add a new relationship even if an identical one exists.
|
||||
pub fn add_new(&mut self, kind: &str, target: &str, external: bool) -> String {
|
||||
let ty = if kind.starts_with("http") { kind.to_string() } else { format!("{RT_BASE}{kind}") };
|
||||
let id = format!("rId{}", self.items.len() + 1);
|
||||
// `add` reuses the first relationship for a target, whichever call made it.
|
||||
self.added.entry((ty.clone(), target.to_string(), external)).or_insert_with(|| id.clone());
|
||||
self.items.push((id.clone(), ty, target.to_string(), external));
|
||||
id
|
||||
}
|
||||
pub fn to_xml(&self) -> Vec<u8> {
|
||||
let mut w = W::new();
|
||||
w.open("Relationships", A::new().a("xmlns", "http://schemas.openxmlformats.org/package/2006/relationships"));
|
||||
for (id, ty, target, ext) in &self.items {
|
||||
let mut a = A::new().a("Id", id).a("Type", ty).a("Target", target);
|
||||
if *ext {
|
||||
a = a.a("TargetMode", "External");
|
||||
}
|
||||
w.empty("Relationship", a);
|
||||
}
|
||||
w.close("Relationships");
|
||||
w.finish()
|
||||
}
|
||||
}
|
||||
|
||||
/// A package being written.
|
||||
pub struct PackageOut {
|
||||
files: Vec<(String, Vec<u8>, bool)>,
|
||||
defaults: Vec<(String, String)>,
|
||||
overrides: Vec<(String, String)>,
|
||||
}
|
||||
|
||||
impl Default for PackageOut {
|
||||
fn default() -> Self {
|
||||
PackageOut {
|
||||
files: vec![],
|
||||
defaults: vec![
|
||||
("rels".into(), "application/vnd.openxmlformats-package.relationships+xml".into()),
|
||||
("xml".into(), "application/xml".into()),
|
||||
],
|
||||
overrides: vec![],
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl PackageOut {
|
||||
/// Add an XML part with its content type override.
|
||||
pub fn xml_part(&mut self, name: &str, content_type: &str, data: Vec<u8>) {
|
||||
self.overrides.push((format!("/{name}"), content_type.to_string()));
|
||||
self.files.push((name.to_string(), data, true));
|
||||
}
|
||||
pub fn rels(&mut self, part: &str, rels: &RelsOut) {
|
||||
if rels.items.is_empty() {
|
||||
return;
|
||||
}
|
||||
let path = rels_path(part);
|
||||
if let Some(existing) = self.files.iter_mut().find(|(name, ..)| *name == path) {
|
||||
existing.1 = rels.to_xml();
|
||||
} else {
|
||||
self.files.push((path, rels.to_xml(), true));
|
||||
}
|
||||
}
|
||||
/// Add a part with no content type of its own (a relationships part).
|
||||
pub fn raw(&mut self, name: &str, data: Vec<u8>) {
|
||||
self.files.push((name.to_string(), data, true));
|
||||
}
|
||||
/// Add a binary part; its extension gets a Default content type.
|
||||
pub fn binary(&mut self, name: &str, content_type: &str, data: Vec<u8>) {
|
||||
let ext = name.rsplit('.').next().unwrap_or("bin").to_ascii_lowercase();
|
||||
if !self.defaults.iter().any(|(e, _)| *e == ext) {
|
||||
self.defaults.push((ext, content_type.to_string()));
|
||||
} else if !self.defaults.iter().any(|(e, c)| *e == ext && c == content_type) {
|
||||
self.overrides.push((format!("/{name}"), content_type.to_string()));
|
||||
}
|
||||
self.files.push((name.to_string(), data, false));
|
||||
}
|
||||
pub fn finish(self) -> Result<Vec<u8>, PptxError> {
|
||||
let mut ct = W::new();
|
||||
ct.open("Types", A::new().a("xmlns", "http://schemas.openxmlformats.org/package/2006/content-types"));
|
||||
for (e, c) in &self.defaults {
|
||||
ct.empty("Default", A::new().a("Extension", e).a("ContentType", c));
|
||||
}
|
||||
for (p, c) in &self.overrides {
|
||||
ct.empty("Override", A::new().a("PartName", p).a("ContentType", c));
|
||||
}
|
||||
ct.close("Types");
|
||||
let mut zw = zip::ZipWriter::new(Cursor::new(Vec::new()));
|
||||
let deflate = zip::write::SimpleFileOptions::default().compression_method(zip::CompressionMethod::Deflated);
|
||||
let stored = zip::write::SimpleFileOptions::default().compression_method(zip::CompressionMethod::Stored);
|
||||
let err = |e: &dyn std::fmt::Display| PptxError::Write(e.to_string());
|
||||
zw.start_file("[Content_Types].xml", deflate).map_err(|e| err(&e))?;
|
||||
zw.write_all(&ct.finish()).map_err(|e| err(&e))?;
|
||||
let mut written = std::collections::HashSet::new();
|
||||
for (name, data, compress) in &self.files {
|
||||
// Zip entry names must be unique: a second part under a name already written is
|
||||
// dropped rather than producing a package readers reject or resolve differently.
|
||||
if !written.insert(norm(name)) {
|
||||
log::warn!("pptx: part {name} written twice; keeping the first");
|
||||
continue;
|
||||
}
|
||||
let large = data.len() as u64 >= u32::MAX as u64 / 2;
|
||||
let opts = if *compress { deflate } else { stored }.large_file(large);
|
||||
zw.start_file(name.as_str(), opts).map_err(|e| err(&e))?;
|
||||
zw.write_all(data).map_err(|e| err(&e))?;
|
||||
}
|
||||
let cur = zw.finish().map_err(|e| err(&e))?;
|
||||
Ok(cur.into_inner())
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
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");
|
||||
assert_eq!(resolve("ppt/slides", "../media/a.png#frag"), "ppt/media/a.png");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn resolve_percent_decode_requires_two_hex_digits() {
|
||||
assert_eq!(resolve("ppt/slides", "../media/a%+5b.png"), "ppt/media/a%+5b.png");
|
||||
assert_eq!(resolve("ppt/slides", "../media/a%20b.png"), "ppt/media/a b.png");
|
||||
}
|
||||
|
||||
fn zip_of(entries: &[(&str, usize)]) -> Vec<u8> {
|
||||
let mut zw = zip::ZipWriter::new(Cursor::new(Vec::new()));
|
||||
let o = zip::write::SimpleFileOptions::default().compression_method(zip::CompressionMethod::Deflated);
|
||||
for (name, len) in entries {
|
||||
zw.start_file(*name, o).unwrap();
|
||||
zw.write_all(&vec![b'x'; *len]).unwrap();
|
||||
}
|
||||
zw.finish().unwrap().into_inner()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn discarded_parts_count_against_the_inflate_budget() {
|
||||
// Kept bytes cap at 100: b, c and d are inflated past what's left and discarded. That
|
||||
// work is charged, so after d the budget (130) is spent and e is not read, although it
|
||||
// would have fit.
|
||||
let z = zip_of(&[("a", 80), ("b", 80), ("c", 80), ("d", 80), ("e", 5)]);
|
||||
let p = Package::open_within(&z, 1000, 100, 130).unwrap();
|
||||
assert!(p.get("a").is_some());
|
||||
assert!(p.get("b").is_none() && p.get("d").is_none());
|
||||
assert!(p.get("e").is_none(), "the inflate budget stops reading");
|
||||
// With room to spare the same small part is kept.
|
||||
let p = Package::open_within(&z, 1000, 100, 10_000).unwrap();
|
||||
assert!(p.get("e").is_some());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn many_relationships_are_found_by_index_and_first_id_wins() {
|
||||
let n = 50_000;
|
||||
let mut x = String::from(r#"<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">"#);
|
||||
for i in 0..n {
|
||||
x.push_str(&format!(r#"<Relationship Id="rId{i}" Type="{RT_BASE}image" Target="../media/image{i}.png"/>"#));
|
||||
}
|
||||
x.push_str(&format!(r#"<Relationship Id="rId0" Type="{RT_BASE}image" Target="../media/dup.png"/></Relationships>"#));
|
||||
let rels = rels_from_bytes(x.as_bytes(), "ppt/slides/slide1.xml");
|
||||
assert_eq!(rels.target("rId0"), Some("ppt/media/image0.png"), "the first of a repeated id wins");
|
||||
assert!((0..n).all(|i| rels.target(&format!("rId{i}")) == Some(&*format!("ppt/media/image{i}.png"))));
|
||||
|
||||
let mut out = RelsOut::default();
|
||||
let ids: Vec<String> = (0..n).map(|i| out.add("hyperlink", &format!("https://example.com/{i}"), true)).collect();
|
||||
assert_eq!(out.add("hyperlink", "https://example.com/7", true), ids[7], "an identical target reuses its id");
|
||||
assert_eq!(out.add("hyperlink", "https://example.com/7", false), format!("rId{}", n + 1), "internal is distinct");
|
||||
let fresh = out.add_new("image", "../media/a.png", false);
|
||||
assert_ne!(out.add_new("image", "../media/a.png", false), fresh);
|
||||
assert_eq!(out.add("image", "../media/a.png", false), fresh, "add reuses the first add_new made");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn backslash_zip_entry_names_are_found() {
|
||||
let z = zip_of(&[("PPT\\Slides\\Slide1.xml", 3)]);
|
||||
let p = Package::open(&z).unwrap();
|
||||
assert!(p.get("ppt/slides/slide1.xml").is_some());
|
||||
assert_eq!(p.original_name("ppt/slides/slide1.xml"), Some("PPT/Slides/Slide1.xml"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn xml_bytes_applies_the_xml_limit() {
|
||||
let z = zip_of(&[("small.xml", 10)]);
|
||||
let p = Package::open(&z).unwrap();
|
||||
assert_eq!(p.xml_bytes("small.xml").map(<[u8]>::len), Some(10));
|
||||
assert!(p.xml_bytes("missing.xml").is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn resolve_backslash_target() {
|
||||
assert_eq!(resolve("ppt/slides", "..\\media\\image1.png"), "ppt/media/image1.png");
|
||||
assert_eq!(resolve("ppt/slides", "\\ppt\\media\\a.png"), "ppt/media/a.png");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn path_resolution() {
|
||||
assert_eq!(resolve("ppt/slides", "../media/image1.png"), "ppt/media/image1.png");
|
||||
assert_eq!(resolve("ppt", "slides/slide1.xml"), "ppt/slides/slide1.xml");
|
||||
assert_eq!(resolve("ppt/slides", "/ppt/media/a%20b.png"), "ppt/media/a b.png");
|
||||
assert_eq!(resolve("", "../../../x.xml"), "x.xml");
|
||||
assert_eq!(rels_path("ppt/presentation.xml"), "ppt/_rels/presentation.xml.rels");
|
||||
assert_eq!(rels_path("[Content_Types].xml"), "_rels/[Content_Types].xml.rels");
|
||||
assert_eq!(relative("ppt/slides/slide1.xml", "ppt/media/image1.png"), "../media/image1.png");
|
||||
assert_eq!(relative("ppt/presentation.xml", "ppt/slides/slide1.xml"), "slides/slide1.xml");
|
||||
assert_eq!(relative("ppt/slides/slide1.xml", "ppt/slides/slide2.xml"), "slide2.xml");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sidecar_parts_stay_inside_chart_folders() {
|
||||
assert!(sidecar_part("ppt/embeddings/Microsoft_Excel_Worksheet1.xlsx"));
|
||||
assert!(sidecar_part("ppt/charts/style1.xml"));
|
||||
assert!(sidecar_part("ppt/drawings/chartDrawing1.xml"));
|
||||
assert!(sidecar_part("ppt/media/image1.png"));
|
||||
assert!(!sidecar_part("ppt/charts/chart1.xml"));
|
||||
assert!(!sidecar_part("ppt/charts/_rels/chart1.xml.rels"));
|
||||
assert!(!sidecar_part("ppt/slides/slide1.xml"));
|
||||
assert!(!sidecar_part("ppt/embeddings/../../ppt/slides/slide1.xml"));
|
||||
assert!(!sidecar_part("/etc/passwd"));
|
||||
}
|
||||
}
|
||||
@@ -1,33 +0,0 @@
|
||||
//! 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.
|
||||
|
||||
/// 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> {
|
||||
TRANSPARENT_1X1.to_vec()
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
#[test]
|
||||
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]);
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -1,177 +0,0 @@
|
||||
//! Office 2016 charts (`cx:chartSpace`, the `chartEx` part): waterfall, funnel, treemap,
|
||||
//! sunburst, histogram, Pareto and box & whisker. Their data sits in `cx:chartData` as levels of
|
||||
//! points, and each series names its layout (`layoutId`).
|
||||
|
||||
use super::chart::rich_text;
|
||||
use crate::xml::El;
|
||||
use deckcraft_model::chart::{Chart, ChartType, Series};
|
||||
use std::collections::HashMap;
|
||||
|
||||
/// Points per level and levels per dimension we keep (guards against hostile parts).
|
||||
const MAX_POINTS: usize = 100_000;
|
||||
const MAX_CHARTEX_POINTS: usize = 1_000_000;
|
||||
|
||||
/// One `cx:data`: its categories (the innermost level) and named numeric dimensions.
|
||||
#[derive(Default)]
|
||||
struct Data {
|
||||
categories: Vec<String>,
|
||||
/// Outer category levels, innermost first.
|
||||
levels: Vec<Vec<String>>,
|
||||
numbers: HashMap<String, (Vec<Option<f64>>, Option<String>)>,
|
||||
}
|
||||
|
||||
/// A level's points, by `idx`.
|
||||
fn points(lvl: &El, budget: &mut usize) -> Vec<String> {
|
||||
if *budget == 0 {
|
||||
return Vec::new();
|
||||
}
|
||||
let cap = MAX_POINTS.min(*budget);
|
||||
let mut pts = Vec::new();
|
||||
let mut max_idx = 0;
|
||||
for pt in lvl.children_named("pt").take(cap) {
|
||||
let i = pt.u32("idx").unwrap_or(0) as usize;
|
||||
if i >= cap {
|
||||
continue;
|
||||
}
|
||||
max_idx = max_idx.max(i + 1);
|
||||
pts.push((i, pt.text()));
|
||||
}
|
||||
if pts.is_empty() {
|
||||
return Vec::new();
|
||||
}
|
||||
let n = max_idx.min(cap);
|
||||
let mut out = vec![String::new(); n];
|
||||
for (i, s) in pts {
|
||||
if let Some(target) = out.get_mut(i) {
|
||||
*target = s;
|
||||
}
|
||||
}
|
||||
*budget = budget.saturating_sub(out.len());
|
||||
out
|
||||
}
|
||||
|
||||
fn data(d: &El, budget: &mut usize) -> Data {
|
||||
let mut out = Data::default();
|
||||
for dim in d.elements().take(64) {
|
||||
if *budget == 0 {
|
||||
break;
|
||||
}
|
||||
// The first level is the innermost: a treemap's leaves, a waterfall's categories.
|
||||
let Some(lvl) = dim.child("lvl") else { continue };
|
||||
let ty = dim.attr("type").unwrap_or("");
|
||||
if dim.is("strDim") || (dim.is("numDim") && ty == "cat") {
|
||||
if ty == "cat" || out.categories.is_empty() {
|
||||
out.categories = points(lvl, budget);
|
||||
// Further levels are the hierarchy's parents, innermost first.
|
||||
out.levels = dim.children_named("lvl").skip(1).take(deckcraft_model::chart::MAX_LEVELS).map(|l| points(l, budget)).collect();
|
||||
}
|
||||
} else if dim.is("numDim") {
|
||||
let vals = points(lvl, budget).into_iter().map(|s| s.trim().parse::<f64>().ok().filter(|v| v.is_finite())).collect();
|
||||
out.numbers.insert(ty.to_string(), (vals, lvl.attr("formatCode").map(str::to_string)));
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
fn kind_of(layout: &str) -> Option<ChartType> {
|
||||
Some(match layout {
|
||||
"waterfall" => ChartType::Waterfall,
|
||||
"funnel" => ChartType::Funnel,
|
||||
"treemap" => ChartType::Treemap,
|
||||
"sunburst" => ChartType::Sunburst,
|
||||
"clusteredColumn" => ChartType::Histogram,
|
||||
"boxWhisker" => ChartType::BoxWhisker,
|
||||
"regionMap" => ChartType::RegionMap,
|
||||
_ => return None,
|
||||
})
|
||||
}
|
||||
|
||||
/// Parse a `chartEx` part. `None` for anything else, and for layouts DeckCraft has no type for.
|
||||
pub fn read_chartex_xml(bytes: &[u8]) -> Option<Chart> {
|
||||
let doc = crate::xml::parse(bytes).ok()?;
|
||||
let mut root = doc.root;
|
||||
super::resolve_mc(&mut root, 0);
|
||||
let mut c = chartex_from(&root)?;
|
||||
c.raw = Some(String::from_utf8_lossy(bytes).into_owned());
|
||||
Some(c)
|
||||
}
|
||||
|
||||
pub(crate) fn chartex_from(root: &El) -> Option<Chart> {
|
||||
if !root.is("chartSpace") {
|
||||
return None;
|
||||
}
|
||||
let mut decode_budget = MAX_CHARTEX_POINTS;
|
||||
let datas: HashMap<String, Data> = root
|
||||
.child("chartData")?
|
||||
.children_named("data")
|
||||
.take(64)
|
||||
.map(|d| (d.attr("id").unwrap_or("0").to_string(), data(d, &mut decode_budget)))
|
||||
.collect();
|
||||
let ch = root.child("chart")?;
|
||||
let region = ch.child("plotArea")?.child("plotAreaRegion")?;
|
||||
let mut c = Chart { categories: vec![], series: vec![], title: None, legend: None, gridlines: false, ..Default::default() };
|
||||
c.title = ch.child("title").map(|t| rich_text(t).filter(|s| !s.is_empty()).unwrap_or_else(|| "Chart Title".into()));
|
||||
c.legend = ch.child("legend").map(|l| l.attr("pos").unwrap_or("t").to_string());
|
||||
let mut kind = None;
|
||||
let mut output_budget = MAX_CHARTEX_POINTS;
|
||||
let mut categories_set = false;
|
||||
for s in region.children_named("series").take(1000) {
|
||||
let layout = s.attr("layoutId").unwrap_or("");
|
||||
if layout == "paretoLine" {
|
||||
// The cumulative line PowerPoint adds to a Pareto histogram.
|
||||
kind = Some(ChartType::Pareto);
|
||||
continue;
|
||||
}
|
||||
let k = kind_of(layout)?;
|
||||
if s.bool("hidden") == Some(true) {
|
||||
continue;
|
||||
}
|
||||
kind = Some(match kind {
|
||||
Some(ChartType::Pareto) => ChartType::Pareto,
|
||||
_ => k,
|
||||
});
|
||||
let d = datas.get(s.child("dataId").and_then(|i| i.attr("val")).unwrap_or("0"))?;
|
||||
let (values_src, format) = ["val", "size", "colorVal"]
|
||||
.iter()
|
||||
.find_map(|t| d.numbers.get(*t))
|
||||
.or_else(|| d.numbers.values().next())
|
||||
.map(|(v, f)| (v.as_slice(), f.clone()))
|
||||
.unwrap_or((&[], None));
|
||||
let take_len = values_src.len().min(output_budget);
|
||||
let values = values_src[..take_len].to_vec();
|
||||
output_budget = output_budget.saturating_sub(values.len());
|
||||
if !categories_set && (!d.categories.is_empty() || !d.levels.is_empty()) {
|
||||
categories_set = true;
|
||||
c.categories = d.categories.clone();
|
||||
c.category_levels = d.levels.clone();
|
||||
output_budget = output_budget.saturating_sub(c.categories.len());
|
||||
for lvl in &c.category_levels {
|
||||
output_budget = output_budget.saturating_sub(lvl.len());
|
||||
}
|
||||
}
|
||||
if let Some(st) = s.child("layoutPr").and_then(|l| l.child("statistics")) {
|
||||
c.inclusive_quartiles = st.attr("quartileMethod") == Some("inclusive");
|
||||
}
|
||||
if let Some(b) = s.child("layoutPr").and_then(|l| l.child("binning")) {
|
||||
c.bin_count = b.child("binCount").and_then(|n| n.u32("val")).filter(|n| *n > 0);
|
||||
c.bin_size = b.child("binSize").and_then(|n| n.attr("val")).and_then(|v| v.parse::<f64>().ok()).filter(|v| v.is_finite() && *v > 0.0);
|
||||
}
|
||||
if let Some(st) = s.child("layoutPr").and_then(|l| l.child("subtotals")) {
|
||||
c.subtotals = st.children_named("idx").filter_map(|i| i.u32("val")).map(|i| i as usize).take(MAX_POINTS).collect();
|
||||
}
|
||||
let name = s.child("tx").and_then(|t| t.find("v")).map(|v| v.text()).unwrap_or_default();
|
||||
c.series.push(Series {
|
||||
name,
|
||||
values,
|
||||
data_labels: s.child("dataLabels").map(|l| l.bool("hidden") != Some(true)),
|
||||
number_format: format,
|
||||
..Default::default()
|
||||
});
|
||||
}
|
||||
c.kind = kind?;
|
||||
c.data_labels = c.series.iter().any(|s| s.data_labels == Some(true));
|
||||
c.vary_colors = matches!(c.kind, ChartType::Funnel | ChartType::Treemap | ChartType::Sunburst | ChartType::Waterfall);
|
||||
// Waterfall, histogram and box charts have a value axis with gridlines by default.
|
||||
c.gridlines = matches!(c.kind, ChartType::Waterfall | ChartType::Histogram | ChartType::Pareto | ChartType::BoxWhisker);
|
||||
Some(c)
|
||||
}
|
||||
@@ -1,824 +0,0 @@
|
||||
//! DrawingML reading: colours, fills, lines, effects, transforms and text.
|
||||
|
||||
use deckcraft_color::{ColorTransform, Rgba, SchemeSlot};
|
||||
use deckcraft_geom::{Xfrm, emu_to_pt};
|
||||
use deckcraft_model::style::{
|
||||
ColorBase, ColorRef, Compound, Dash, Effects, Fill, Glow, Gradient, GradientFlip, GradientShape, GradientStop, Line, LineAlign, LineCap, LineEnd,
|
||||
LineJoin, PatternFill, PictureFill, PictureMode, Reflection, Shadow,
|
||||
};
|
||||
use deckcraft_model::text::{
|
||||
Action, Align, Anchor, AutoFit, BodyProps, Bullet, Caps, Hyperlink, LevelStyle, ListStyle, ParaProps, Paragraph, Run, RunKind, RunProps, Spacing,
|
||||
Strike, TabStop, TextBody, TextDir,
|
||||
};
|
||||
|
||||
use super::{Imp, Part};
|
||||
use crate::xml::El;
|
||||
|
||||
pub fn pt(e: &El, name: &str) -> Option<f64> {
|
||||
e.i64(name).map(emu_to_pt)
|
||||
}
|
||||
|
||||
/// 1/100 000 → fraction.
|
||||
pub fn pct(e: &El, name: &str) -> Option<f64> {
|
||||
e.f64(name).map(|v| v / 100_000.0)
|
||||
}
|
||||
|
||||
fn bullet_size_points(value: Option<&str>) -> Option<f64> {
|
||||
value.and_then(|v| v.trim().parse::<u32>().ok()).filter(|v| (100..=400_000).contains(v)).map(|v| v as f64 / 100.0)
|
||||
}
|
||||
|
||||
fn bullet_size_percent(value: Option<&str>) -> Option<f64> {
|
||||
let value = value?.trim();
|
||||
let (value, scale) = if let Some(value) = value.strip_suffix('%') { (value.trim(), 100.0) } else { (value, 100_000.0) };
|
||||
value.parse::<f64>().ok().filter(|v| v.is_finite()).map(|v| v / scale)
|
||||
}
|
||||
|
||||
/// 1/60 000 degree → degrees.
|
||||
pub fn ang(e: &El, name: &str) -> Option<f64> {
|
||||
e.f64(name).map(|v| v / 60_000.0)
|
||||
}
|
||||
|
||||
fn lin_to_srgb(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 }
|
||||
}
|
||||
|
||||
/// A colour element (`srgbClr`, `schemeClr`, …) with its transforms.
|
||||
pub fn color_el(c: &El) -> Option<ColorRef> {
|
||||
let base = match c.local() {
|
||||
"srgbClr" => ColorBase::Rgb { rgb: Rgba::from_hex(c.attr("val").unwrap_or("000000")).unwrap_or(Rgba::BLACK) },
|
||||
"schemeClr" => ColorBase::Scheme { slot: c.attr("val").and_then(SchemeSlot::from_xml).unwrap_or(SchemeSlot::Tx1) },
|
||||
"sysClr" => ColorBase::System {
|
||||
name: c.attr("val").unwrap_or("windowText").to_string(),
|
||||
last: c.attr("lastClr").and_then(Rgba::from_hex).unwrap_or(if c.attr("val") == Some("window") { Rgba::WHITE } else { Rgba::BLACK }),
|
||||
},
|
||||
"prstClr" => ColorBase::Preset { name: c.attr("val").unwrap_or("black").to_string() },
|
||||
"scrgbClr" => {
|
||||
let f = |n: &str| lin_to_srgb(c.f64(n).unwrap_or(0.0) / 100_000.0);
|
||||
ColorBase::Rgb { rgb: Rgba::from_f64(f("r"), f("g"), f("b"), 1.0) }
|
||||
}
|
||||
"hslClr" => {
|
||||
let h = c.f64("hue").unwrap_or(0.0) / 60_000.0;
|
||||
let s = c.f64("sat").unwrap_or(0.0) / 100_000.0;
|
||||
let l = c.f64("lum").unwrap_or(0.0) / 100_000.0;
|
||||
ColorBase::Rgb { rgb: Rgba::from_hsl(h, s, l, 255) }
|
||||
}
|
||||
_ => return None,
|
||||
};
|
||||
let mods = c.elements().take(32).filter_map(|m| ColorTransform::from_xml(m.local(), m.i32("val"))).collect();
|
||||
Some(ColorRef { base, mods })
|
||||
}
|
||||
|
||||
/// The first colour child of a container (`solidFill`, `fgClr`, `lnRef`…).
|
||||
pub fn color(container: &El) -> Option<ColorRef> {
|
||||
container.elements().find_map(color_el)
|
||||
}
|
||||
|
||||
const FILL_NAMES: [&str; 6] = ["noFill", "solidFill", "gradFill", "blipFill", "pattFill", "grpFill"];
|
||||
|
||||
/// The fill child of `parent`, if any.
|
||||
pub fn fill_of(imp: &mut Imp, part: &Part, parent: &El) -> Option<Fill> {
|
||||
parent.elements().find(|e| FILL_NAMES.contains(&e.local())).and_then(|f| fill_el(imp, part, f))
|
||||
}
|
||||
|
||||
pub fn fill_el(imp: &mut Imp, part: &Part, f: &El) -> Option<Fill> {
|
||||
Some(match f.local() {
|
||||
"noFill" => Fill::None,
|
||||
"solidFill" => Fill::Solid { color: color(f).unwrap_or(ColorRef::rgb(Rgba::BLACK)) },
|
||||
"gradFill" => Fill::Gradient(gradient(f)),
|
||||
"blipFill" => match blip_fill(imp, part, f) {
|
||||
// A picture filling a shape or background with neither `a:stretch` nor `a:tile` is
|
||||
// tiled at its own size, as PowerPoint draws it.
|
||||
Some(mut p) if f.child("stretch").is_none() && f.child("tile").is_none() => {
|
||||
p.mode = PictureMode::Tile { tx: 0.0, ty: 0.0, sx: 1.0, sy: 1.0, flip: "none".into(), align: "tl".into() };
|
||||
Fill::Picture(p)
|
||||
}
|
||||
Some(p) => Fill::Picture(p),
|
||||
None => Fill::None,
|
||||
},
|
||||
"pattFill" => Fill::Pattern(pattern(f)),
|
||||
"grpFill" => Fill::Group,
|
||||
_ => return None,
|
||||
})
|
||||
}
|
||||
|
||||
/// An `a:pattFill`: its preset (5 % dots when unset), foreground (black) and background (white).
|
||||
pub fn pattern(f: &El) -> PatternFill {
|
||||
PatternFill {
|
||||
preset: f.attr("prst").unwrap_or("pct5").to_string(),
|
||||
fg: f.child("fgClr").and_then(color).unwrap_or(ColorRef::rgb(Rgba::BLACK)),
|
||||
bg: f.child("bgClr").and_then(color).unwrap_or(ColorRef::rgb(Rgba::WHITE)),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn gradient(f: &El) -> Gradient {
|
||||
let mut stops: Vec<GradientStop> = f
|
||||
.child("gsLst")
|
||||
.map(|l| {
|
||||
l.children_named("gs")
|
||||
.take(256)
|
||||
.map(|g| GradientStop { pos: pct(g, "pos").unwrap_or(0.0).clamp(0.0, 1.0), color: color(g).unwrap_or(ColorRef::rgb(Rgba::BLACK)) })
|
||||
.collect()
|
||||
})
|
||||
.unwrap_or_default();
|
||||
stops.sort_by(|a, b| a.pos.total_cmp(&b.pos));
|
||||
let shape = if let Some(l) = f.child("lin") {
|
||||
GradientShape::Linear { angle: ang(l, "ang").unwrap_or(0.0), scaled: l.bool("scaled").unwrap_or(false) }
|
||||
} else if let Some(p) = f.child("path") {
|
||||
let r = p.child("fillToRect");
|
||||
let g = |n: &str| r.and_then(|r| pct(r, n)).unwrap_or(0.0);
|
||||
GradientShape::Path { path: p.attr("path").unwrap_or("circle").to_string(), focus: [g("l"), g("t"), g("r"), g("b")] }
|
||||
} else {
|
||||
GradientShape::Linear { angle: 90.0, scaled: false }
|
||||
};
|
||||
let tile = f.child("tileRect").map(|r| [pct(r, "l"), pct(r, "t"), pct(r, "r"), pct(r, "b")].map(|v| v.unwrap_or(0.0).clamp(-10.0, 10.0)));
|
||||
Gradient {
|
||||
tile: tile.unwrap_or_default(),
|
||||
stops,
|
||||
shape,
|
||||
flip: f.attr("flip").and_then(GradientFlip::from_xml),
|
||||
rotate_with_shape: f.bool("rotWithShape").unwrap_or(true),
|
||||
}
|
||||
}
|
||||
|
||||
/// `blipFill` (either `a:` or `p:`) → picture fill, registering the image as media.
|
||||
pub fn blip_fill(imp: &mut Imp, part: &Part, bf: &El) -> Option<PictureFill> {
|
||||
let blip = bf.child("blip");
|
||||
let media = blip.and_then(|b| media_ref(imp, part, b));
|
||||
let media = media?;
|
||||
let mut pf = PictureFill { media, upright: !bf.bool("rotWithShape").unwrap_or(true), ..Default::default() };
|
||||
if let Some(layer) = blip.and_then(|b| b.child("extLst")).and_then(|x| x.find("imgLayer"))
|
||||
&& let Some(effect) = layer
|
||||
.elements()
|
||||
.filter(|e| e.local() == "imgEffect")
|
||||
.flat_map(|e| e.elements())
|
||||
.map(|e| e.local().to_string())
|
||||
.find(|n| n.starts_with("artistic"))
|
||||
&& let Some(original) = media_ref(imp, part, layer)
|
||||
{
|
||||
pf.artistic = Some(deckcraft_model::style::Artistic { effect, original });
|
||||
}
|
||||
if let Some(b) = blip {
|
||||
for e in b.elements() {
|
||||
match e.local() {
|
||||
"alphaModFix" => pf.alpha = Some(pct(e, "amt").unwrap_or(1.0).clamp(0.0, 1.0)),
|
||||
"lum" => {
|
||||
pf.adjust.brightness = pct(e, "bright").unwrap_or(0.0).clamp(-1.0, 1.0);
|
||||
pf.adjust.contrast = pct(e, "contrast").unwrap_or(0.0).clamp(-1.0, 1.0);
|
||||
}
|
||||
"grayscl" => pf.adjust.grayscale = true,
|
||||
"biLevel" => pf.adjust.bilevel = Some(pct(e, "thresh").unwrap_or(0.5).clamp(0.0, 1.0)),
|
||||
"alphaInv" => pf.adjust.alpha_inv = true,
|
||||
"duotone" => {
|
||||
let cs: Vec<ColorRef> = e.elements().filter_map(color_el).collect();
|
||||
if let [a, b] = cs.as_slice() {
|
||||
pf.adjust.duotone = Some((a.clone(), b.clone()));
|
||||
}
|
||||
}
|
||||
"clrChange" => {
|
||||
if let Some(ColorRef { base: ColorBase::Rgb { rgb }, .. }) = e.child("clrFrom").and_then(color) {
|
||||
pf.adjust.clear_color = Some(rgb);
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
if let Some(r) = bf.child("srcRect") {
|
||||
pf.crop = [pct(r, "l").unwrap_or(0.0), pct(r, "t").unwrap_or(0.0), pct(r, "r").unwrap_or(0.0), pct(r, "b").unwrap_or(0.0)]
|
||||
.map(|v| v.clamp(-10.0, 1.0));
|
||||
}
|
||||
if let Some(t) = bf.child("tile") {
|
||||
pf.mode = PictureMode::Tile {
|
||||
tx: pt(t, "tx").unwrap_or(0.0),
|
||||
ty: pt(t, "ty").unwrap_or(0.0),
|
||||
sx: pct(t, "sx").unwrap_or(1.0),
|
||||
sy: pct(t, "sy").unwrap_or(1.0),
|
||||
flip: t.attr("flip").unwrap_or("none").to_string(),
|
||||
align: t.attr("algn").unwrap_or("tl").to_string(),
|
||||
};
|
||||
} else {
|
||||
let r = bf.path(&["stretch", "fillRect"]);
|
||||
let g = |n: &str| r.and_then(|r| pct(r, n)).unwrap_or(0.0).clamp(-10.0, 1.0);
|
||||
pf.mode = PictureMode::Stretch { fill_rect: [g("l"), g("t"), g("r"), g("b")] };
|
||||
}
|
||||
Some(pf)
|
||||
}
|
||||
|
||||
/// Media for an element with `r:embed` (or `r:link`).
|
||||
pub fn media_ref(imp: &mut Imp, part: &Part, b: &El) -> Option<deckcraft_model::MediaId> {
|
||||
if let Some(id) = b.attr("r:embed").filter(|s| !s.is_empty())
|
||||
&& let Some(r) = part.rels.get(id)
|
||||
{
|
||||
if r.external {
|
||||
return Some(imp.media_link(&r.target));
|
||||
}
|
||||
let t = r.target.clone();
|
||||
if let Some(m) = imp.media_for(&t) {
|
||||
return Some(m);
|
||||
}
|
||||
}
|
||||
if let Some(id) = b.attr("r:link").filter(|s| !s.is_empty())
|
||||
&& let Some(r) = part.rels.get(id)
|
||||
{
|
||||
if r.external {
|
||||
return Some(imp.media_link(&r.target));
|
||||
}
|
||||
let t = r.target.clone();
|
||||
return imp.media_for(&t);
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
pub fn line(imp: &mut Imp, part: &Part, ln: &El) -> Line {
|
||||
let mut l = Line { width: pt(ln, "w").map(|w| w.clamp(0.0, 2000.0)), ..Default::default() };
|
||||
l.cap = ln.attr("cap").map(|c| match c {
|
||||
"rnd" => LineCap::Round,
|
||||
"sq" => LineCap::Square,
|
||||
_ => LineCap::Flat,
|
||||
});
|
||||
l.compound = ln.attr("cmpd").map(Compound::from_xml);
|
||||
l.align = ln.attr("algn").and_then(LineAlign::from_xml);
|
||||
l.fill = fill_of(imp, part, ln);
|
||||
for e in ln.elements() {
|
||||
match e.local() {
|
||||
"prstDash" => l.dash = Some(Dash::Preset { name: e.attr("val").unwrap_or("solid").to_string() }),
|
||||
"custDash" => {
|
||||
let pattern = e.children_named("ds").take(64).map(|d| (pct(d, "d").unwrap_or(1.0), pct(d, "sp").unwrap_or(1.0))).collect();
|
||||
l.dash = Some(Dash::Custom { pattern });
|
||||
}
|
||||
"round" => l.join = Some(LineJoin::Round),
|
||||
"bevel" => l.join = Some(LineJoin::Bevel),
|
||||
"miter" => {
|
||||
l.join = Some(LineJoin::Miter);
|
||||
l.miter_limit = e.attr("lim").and_then(parse_miter_limit);
|
||||
}
|
||||
"headEnd" => l.head = line_end(e),
|
||||
"tailEnd" => l.tail = line_end(e),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
l
|
||||
}
|
||||
|
||||
fn parse_miter_limit(value: &str) -> Option<u32> {
|
||||
const MAX: u32 = i32::MAX as u32;
|
||||
let value = value.trim();
|
||||
if let Some(percent) = value.strip_suffix('%') {
|
||||
let units = percent.trim().parse::<f64>().ok()? * 1000.0;
|
||||
(units.is_finite() && (0.0..=MAX as f64).contains(&units)).then(|| units.round() as u32)
|
||||
} else {
|
||||
value.parse::<u32>().ok().filter(|limit| *limit <= MAX)
|
||||
}
|
||||
}
|
||||
|
||||
fn line_end(e: &El) -> Option<LineEnd> {
|
||||
let kind = e.attr("type").unwrap_or("none");
|
||||
Some(LineEnd { kind: kind.to_string(), w: e.attr("w").unwrap_or("med").to_string(), len: e.attr("len").unwrap_or("med").to_string() })
|
||||
}
|
||||
|
||||
fn shadow(e: &El, inner: bool) -> Shadow {
|
||||
Shadow {
|
||||
color: color(e).unwrap_or(ColorRef::rgb(Rgba::BLACK)),
|
||||
blur: pt(e, "blurRad").unwrap_or(0.0).max(0.0),
|
||||
dist: pt(e, "dist").unwrap_or(0.0),
|
||||
dir: ang(e, "dir").unwrap_or(0.0),
|
||||
inner,
|
||||
sx: pct(e, "sx").unwrap_or(1.0),
|
||||
sy: pct(e, "sy").unwrap_or(1.0),
|
||||
kx: ang(e, "kx").unwrap_or(0.0),
|
||||
ky: ang(e, "ky").unwrap_or(0.0),
|
||||
align: e.attr("algn").unwrap_or(if inner { "" } else { "b" }).to_string(),
|
||||
rotate_with_shape: e.bool("rotWithShape").unwrap_or(true),
|
||||
}
|
||||
}
|
||||
|
||||
/// `effectLst` → effects.
|
||||
pub fn effects(el: &El) -> Effects {
|
||||
let mut fx = Effects::default();
|
||||
for e in el.elements() {
|
||||
match e.local() {
|
||||
"outerShdw" => fx.outer_shadow = Some(shadow(e, false)),
|
||||
"prstShdw" => {
|
||||
let mut s = shadow(e, false);
|
||||
s.align = "b".into();
|
||||
fx.outer_shadow = Some(s);
|
||||
}
|
||||
"innerShdw" => fx.inner_shadow = Some(shadow(e, true)),
|
||||
"glow" => fx.glow = Some(Glow { color: color(e).unwrap_or(ColorRef::rgb(Rgba::BLACK)), radius: pt(e, "rad").unwrap_or(0.0).max(0.0) }),
|
||||
"softEdge" => fx.soft_edge = Some(pt(e, "rad").unwrap_or(0.0).max(0.0)),
|
||||
"fillOverlay" => {
|
||||
let fill = e.elements().find_map(|f| match f.local() {
|
||||
"solidFill" => color(f).map(|c| Fill::Solid { color: c }),
|
||||
"gradFill" => Some(Fill::Gradient(gradient(f))),
|
||||
_ => None,
|
||||
});
|
||||
fx.fill_overlay = fill.map(|fill| deckcraft_model::style::FillOverlay { blend: e.attr("blend").unwrap_or("over").to_string(), fill });
|
||||
}
|
||||
"reflection" => {
|
||||
fx.reflection = Some(Reflection {
|
||||
blur: pt(e, "blurRad").unwrap_or(0.0),
|
||||
start_alpha: pct(e, "stA").unwrap_or(1.0),
|
||||
end_alpha: pct(e, "endA").unwrap_or(0.0),
|
||||
end_pos: pct(e, "endPos").unwrap_or(1.0),
|
||||
dist: pt(e, "dist").unwrap_or(0.0),
|
||||
st_pos: e.i64("stPos").and_then(|v| i32::try_from(v).ok()),
|
||||
dir: e.i64("dir").and_then(|v| i32::try_from(v).ok()),
|
||||
fade_dir: e.i64("fadeDir").and_then(|v| i32::try_from(v).ok()),
|
||||
sx: e.i64("sx").and_then(|v| i32::try_from(v).ok()),
|
||||
sy: e.i64("sy").and_then(|v| i32::try_from(v).ok()),
|
||||
kx: e.i64("kx").and_then(|v| i32::try_from(v).ok()),
|
||||
ky: e.i64("ky").and_then(|v| i32::try_from(v).ok()),
|
||||
align: e.attr("algn").filter(|v| matches!(*v, "tl" | "t" | "tr" | "l" | "ctr" | "r" | "bl" | "b" | "br")).map(str::to_owned),
|
||||
rotate_with_shape: e.bool("rotWithShape"),
|
||||
})
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
fx
|
||||
}
|
||||
|
||||
/// `a:xfrm` → (box, child box for groups).
|
||||
pub fn xfrm(x: &El) -> (Xfrm, Option<Xfrm>) {
|
||||
let off = x.child("off");
|
||||
let ext = x.child("ext");
|
||||
let g = |e: Option<&El>, n: &str| e.and_then(|e| pt(e, n)).unwrap_or(0.0);
|
||||
let mut xf = Xfrm::new(g(off, "x"), g(off, "y"), g(ext, "cx").max(0.0), g(ext, "cy").max(0.0));
|
||||
xf.rot = ang(x, "rot").unwrap_or(0.0);
|
||||
if !xf.rot.is_finite() {
|
||||
xf.rot = 0.0;
|
||||
}
|
||||
xf.flip_h = x.bool("flipH").unwrap_or(false);
|
||||
xf.flip_v = x.bool("flipV").unwrap_or(false);
|
||||
let child = match (x.child("chOff"), x.child("chExt")) {
|
||||
(Some(o), Some(e)) => Some(Xfrm::new(g(Some(o), "x"), g(Some(o), "y"), g(Some(e), "cx").max(0.0), g(Some(e), "cy").max(0.0))),
|
||||
_ => None,
|
||||
};
|
||||
(xf, child)
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------------------------
|
||||
// Text
|
||||
|
||||
pub fn body_pr(b: &El) -> BodyProps {
|
||||
let mut p = BodyProps {
|
||||
inset_l: pt(b, "lIns"),
|
||||
inset_t: pt(b, "tIns"),
|
||||
inset_r: pt(b, "rIns"),
|
||||
inset_b: pt(b, "bIns"),
|
||||
anchor: b.attr("anchor").and_then(Anchor::from_xml),
|
||||
anchor_ctr: b.bool("anchorCtr"),
|
||||
wrap: b.attr("wrap").map(|w| w != "none"),
|
||||
vert: b.attr("vert").and_then(TextDir::from_xml),
|
||||
rot: ang(b, "rot"),
|
||||
columns: b.u32("numCol").map(|n| n.clamp(1, 16)),
|
||||
col_spacing: pt(b, "spcCol"),
|
||||
rtl_col: b.bool("rtlCol"),
|
||||
upright: b.bool("upright"),
|
||||
space_first_last: b.bool("spcFirstLastPara"),
|
||||
compat_ln_spc: b.bool("compatLnSpc"),
|
||||
vert_overflow: b.attr("vertOverflow").and_then(deckcraft_model::text::TextOverflow::from_xml),
|
||||
horz_overflow: b.attr("horzOverflow").and_then(deckcraft_model::text::TextOverflow::from_horz_xml),
|
||||
..Default::default()
|
||||
};
|
||||
for e in b.elements() {
|
||||
match e.local() {
|
||||
"normAutofit" => {
|
||||
p.autofit = Some(AutoFit::Shrink {
|
||||
font_scale: pct(e, "fontScale").map(|v| v.clamp(0.01, 1.0)),
|
||||
line_reduction: pct(e, "lnSpcReduction").unwrap_or(0.0).clamp(0.0, 1.0),
|
||||
})
|
||||
}
|
||||
"spAutoFit" => p.autofit = Some(AutoFit::Shape),
|
||||
"noAutofit" => p.autofit = Some(AutoFit::None),
|
||||
"prstTxWarp" => {
|
||||
p.warp = e.attr("prst").filter(|w| *w != "textNoShape" && !w.is_empty()).map(String::from);
|
||||
p.warp_adj = p.warp.as_deref().map(|w| warp_adjusts(w, e)).unwrap_or_default();
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
p
|
||||
}
|
||||
|
||||
/// `prstTxWarp/avLst` guides `adj` / `adj1`… as raw values by index (empty when none is given);
|
||||
/// slots the file leaves out keep the preset's default.
|
||||
fn warp_adjusts(preset: &str, e: &El) -> Vec<f64> {
|
||||
let mut adj: Vec<f64> = Vec::new();
|
||||
let Some(av) = e.child("avLst") else { return adj };
|
||||
let defaults = deckcraft_geom::warp::adjust_defaults(preset);
|
||||
for gd in av.children_named("gd").take(16) {
|
||||
let n = gd.attr("name").unwrap_or("");
|
||||
let idx = if n == "adj" {
|
||||
0
|
||||
} else if let Some(k) = n.strip_prefix("adj").and_then(|k| k.parse::<usize>().ok()).filter(|k| (1..=8).contains(k)) {
|
||||
k - 1
|
||||
} else {
|
||||
continue;
|
||||
};
|
||||
let Some(v) = gd.attr("fmla").and_then(|f| f.trim().strip_prefix("val")).and_then(|v| v.trim().parse::<f64>().ok()).filter(|v| v.is_finite())
|
||||
else {
|
||||
continue;
|
||||
};
|
||||
while adj.len() <= idx {
|
||||
adj.push(defaults.get(adj.len()).copied().unwrap_or(0.0));
|
||||
}
|
||||
if let Some(slot) = adj.get_mut(idx) {
|
||||
*slot = v.clamp(-1.0e9, 1.0e9);
|
||||
}
|
||||
}
|
||||
adj
|
||||
}
|
||||
|
||||
fn spacing(e: &El) -> Option<Spacing> {
|
||||
if let Some(p) = e.child("spcPct") {
|
||||
return Some(Spacing::Pct(pct(p, "val").unwrap_or(1.0).clamp(0.0, 100.0)));
|
||||
}
|
||||
e.child("spcPts").map(|p| Spacing::Pts(p.f64("val").unwrap_or(0.0).clamp(0.0, 1_000_000.0) / 100.0))
|
||||
}
|
||||
|
||||
/// `a:pPr` / `a:lvlNpPr` → (level, paragraph props, default run props).
|
||||
pub fn ppr(imp: &mut Imp, part: &Part, p: &El) -> (Option<u8>, ParaProps, Option<RunProps>) {
|
||||
let mut pp = ParaProps {
|
||||
align: p.attr("algn").and_then(Align::from_xml),
|
||||
margin_left: pt(p, "marL"),
|
||||
margin_right: pt(p, "marR"),
|
||||
indent: pt(p, "indent"),
|
||||
rtl: p.bool("rtl"),
|
||||
font_align: p.attr("fontAlgn").map(String::from),
|
||||
east_asian_line_break: p.bool("eaLnBrk"),
|
||||
latin_line_break: p.bool("latinLnBrk"),
|
||||
hanging_punct: p.bool("hangingPunct"),
|
||||
default_tab: pt(p, "defTabSz"),
|
||||
..Default::default()
|
||||
};
|
||||
let lvl = p.u32("lvl").map(|l| l.min(8) as u8);
|
||||
let mut def = None;
|
||||
for e in p.elements() {
|
||||
match e.local() {
|
||||
"lnSpc" => pp.line_spacing = spacing(e),
|
||||
"spcBef" => pp.space_before = spacing(e),
|
||||
"spcAft" => pp.space_after = spacing(e),
|
||||
"buNone" => pp.bullet = Some(Bullet::None),
|
||||
"buChar" => pp.bullet = Some(Bullet::Char { char: e.attr("char").unwrap_or("•").chars().take(4).collect() }),
|
||||
"buAutoNum" => {
|
||||
pp.bullet = Some(Bullet::AutoNum {
|
||||
scheme: e.attr("type").unwrap_or("arabicPeriod").to_string(),
|
||||
start_at: e.u32("startAt").unwrap_or(1).clamp(1, 32767),
|
||||
})
|
||||
}
|
||||
"buBlip" => {
|
||||
if let Some(m) = e.child("blip").and_then(|b| media_ref(imp, part, b)) {
|
||||
pp.bullet = Some(Bullet::Picture { media: m });
|
||||
}
|
||||
}
|
||||
"buFont" => pp.bullet_font = e.attr("typeface").map(String::from),
|
||||
"buFontTx" => pp.bullet_font_follow_text = Some(true),
|
||||
"buClr" => pp.bullet_color = color(e),
|
||||
"buSzPct" => {
|
||||
pp.bullet_size_points = None;
|
||||
pp.bullet_size_follow_text = None;
|
||||
pp.bullet_size = bullet_size_percent(e.attr("val")).map(|v| v.clamp(0.25, 4.0));
|
||||
}
|
||||
"buSzPts" => {
|
||||
pp.bullet_size = None;
|
||||
pp.bullet_size_follow_text = None;
|
||||
pp.bullet_size_points = bullet_size_points(e.attr("val"));
|
||||
}
|
||||
"buClrTx" => pp.bullet_color_follow_text = Some(true),
|
||||
"buSzTx" => {
|
||||
pp.bullet_size = None;
|
||||
pp.bullet_size_points = None;
|
||||
pp.bullet_size_follow_text = Some(true);
|
||||
}
|
||||
"tabLst" => {
|
||||
pp.tabs = Some(
|
||||
e.children_named("tab")
|
||||
.take(64)
|
||||
.map(|t| TabStop { pos: pt(t, "pos").unwrap_or(0.0), align: t.attr("algn").unwrap_or("l").to_string() })
|
||||
.collect(),
|
||||
)
|
||||
}
|
||||
"defRPr" => def = Some(rpr(imp, part, e)),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
(lvl, pp, def)
|
||||
}
|
||||
|
||||
pub fn hyperlink(imp: &mut Imp, part: &Part, h: &El) -> Option<Hyperlink> {
|
||||
let rid = h.attr("r:id").unwrap_or("");
|
||||
let rel = part.rels.get(rid);
|
||||
let action = h.attr("action").unwrap_or("");
|
||||
let a = if let Some(rest) = action.strip_prefix("ppaction://hlinkshowjump?jump=") {
|
||||
match rest {
|
||||
"nextslide" => Action::NextSlide,
|
||||
"previousslide" => Action::PreviousSlide,
|
||||
"firstslide" => Action::FirstSlide,
|
||||
"lastslide" => Action::LastSlide,
|
||||
"endshow" => Action::EndShow,
|
||||
"lastslideviewed" => Action::LastViewed,
|
||||
_ => return None,
|
||||
}
|
||||
} else if action.starts_with("ppaction://hlinksldjump") {
|
||||
let slide = rel.and_then(|r| imp.slide_by_part.get(&crate::opc::norm(&r.target)).copied())?;
|
||||
Action::Slide { slide }
|
||||
} else if let Some(q) = action.strip_prefix("ppaction://customshow?") {
|
||||
let id = q.split('&').find_map(|kv| kv.strip_prefix("id=")).unwrap_or("0");
|
||||
let returns = !matches!(q.split('&').find_map(|kv| kv.strip_prefix("return=")), Some("false" | "0"));
|
||||
Action::CustomShow { name: imp.custom_show_names.get(id).cloned().unwrap_or_else(|| id.to_string()), returns }
|
||||
} else if action.starts_with("ppaction://program") {
|
||||
Action::Program { path: rel.map(|r| r.target.clone()).unwrap_or_default() }
|
||||
} else if action.starts_with("ppaction://media") {
|
||||
Action::PlayMedia
|
||||
} else if action.is_empty() || action.starts_with("ppaction://hlinkfile") {
|
||||
let r = rel?;
|
||||
if r.target.is_empty() {
|
||||
return None;
|
||||
}
|
||||
if !r.external
|
||||
&& let Some(s) = imp.slide_by_part.get(&crate::opc::norm(&r.target))
|
||||
{
|
||||
Action::Slide { slide: *s }
|
||||
} else {
|
||||
Action::Url { url: r.target.clone() }
|
||||
}
|
||||
} else {
|
||||
return None;
|
||||
};
|
||||
Some(Hyperlink {
|
||||
action: a,
|
||||
tooltip: h.attr("tooltip").unwrap_or("").to_string(),
|
||||
highlight_click: h.bool("highlightClick").unwrap_or(false),
|
||||
stop_sound: h.bool("endSnd").unwrap_or(false),
|
||||
sound: h.child("snd").and_then(|s| media_ref(imp, part, s)),
|
||||
zoom_return: None,
|
||||
})
|
||||
}
|
||||
|
||||
fn typeface(e: &El) -> Option<String> {
|
||||
let t = e.attr("typeface").filter(|t| !t.is_empty())?;
|
||||
Some(t.chars().take(256).collect())
|
||||
}
|
||||
|
||||
pub fn rpr(imp: &mut Imp, part: &Part, r: &El) -> RunProps {
|
||||
let mut p = RunProps {
|
||||
lang: r.attr("lang").map(String::from),
|
||||
alt_lang: r.attr("altLang").map(|lang| lang.chars().take(256).collect()),
|
||||
size: r.f64("sz").map(|s| (s / 100.0).clamp(1.0, 4000.0)),
|
||||
bold: r.bool("b"),
|
||||
italic: r.bool("i"),
|
||||
underline: r.attr("u").map(String::from),
|
||||
strike: r.attr("strike").map(|s| match s {
|
||||
"sngStrike" => Strike::Single,
|
||||
"dblStrike" => Strike::Double,
|
||||
_ => Strike::None,
|
||||
}),
|
||||
baseline: pct(r, "baseline").map(|b| b.clamp(-10.0, 10.0)),
|
||||
caps: r.attr("cap").map(|c| match c {
|
||||
"small" => Caps::Small,
|
||||
"all" => Caps::All,
|
||||
_ => Caps::None,
|
||||
}),
|
||||
spacing: r.f64("spc").map(|s| (s / 100.0).clamp(-4000.0, 4000.0)),
|
||||
kern: r.f64("kern").map(|k| (k / 100.0).clamp(0.0, 4000.0)),
|
||||
no_proof: r.bool("noProof"),
|
||||
normalize_height: r.bool("normalizeH"),
|
||||
..Default::default()
|
||||
};
|
||||
for e in r.elements() {
|
||||
match e.local() {
|
||||
"ln" => p.outline = Some(line(imp, part, e)),
|
||||
n if FILL_NAMES.contains(&n) => p.fill = fill_el(imp, part, e),
|
||||
"effectLst" => {
|
||||
let fx = effects(e);
|
||||
p.shadow = fx.outer_shadow;
|
||||
p.inner_shadow = fx.inner_shadow;
|
||||
p.glow = fx.glow;
|
||||
p.reflection = fx.reflection;
|
||||
p.soft_edge = fx.soft_edge;
|
||||
}
|
||||
"highlight" => p.highlight = color(e),
|
||||
"uFill" => p.underline_color = e.child("solidFill").and_then(color),
|
||||
"latin" => p.font = typeface(e),
|
||||
"ea" => p.font_ea = typeface(e),
|
||||
"cs" => p.font_cs = typeface(e),
|
||||
"sym" => p.font_sym = typeface(e),
|
||||
"hlinkClick" => p.link = hyperlink(imp, part, e),
|
||||
"hlinkMouseOver" => p.hover = hyperlink(imp, part, e),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
p
|
||||
}
|
||||
|
||||
/// `a:lstStyle`, `p:titleStyle`, `a:defaultTextStyle`… → list style.
|
||||
pub fn list_style(imp: &mut Imp, part: &Part, ls: &El) -> ListStyle {
|
||||
let mut out = ListStyle::default();
|
||||
for e in ls.elements() {
|
||||
let n = e.local();
|
||||
let Some(l) = n.strip_prefix("lvl").and_then(|r| r.strip_suffix("pPr")).and_then(|d| d.parse::<u8>().ok()) else { continue };
|
||||
if !(1..=9).contains(&l) {
|
||||
continue;
|
||||
}
|
||||
let (_, para, run) = ppr(imp, part, e);
|
||||
out.set(l - 1, LevelStyle { para, run: run.unwrap_or_default() });
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
pub fn text_body(imp: &mut Imp, part: &Part, tx: &El) -> TextBody {
|
||||
let mut body = tx.child("bodyPr").map(body_pr).unwrap_or_default();
|
||||
if let Some(b) = tx.child("bodyPr") {
|
||||
let mut raw3d = String::new();
|
||||
if let Some(sc) = b.child("scene3d") {
|
||||
raw3d.push_str(&part.keep_inner(sc));
|
||||
}
|
||||
if let Some(sp) = b.child("sp3d").or_else(|| b.child("flatTx")) {
|
||||
raw3d.push_str(&part.keep_inner(sp));
|
||||
}
|
||||
if !raw3d.is_empty() && raw3d.len() <= 64 * 1024 {
|
||||
body.raw3d = Some(raw3d);
|
||||
}
|
||||
}
|
||||
let list_style = tx.child("lstStyle").map(|l| list_style(imp, part, l)).unwrap_or_default();
|
||||
let paragraphs = tx.children_named("p").take(100_000).map(|p| paragraph(imp, part, p)).collect();
|
||||
TextBody { body, list_style, paragraphs }
|
||||
}
|
||||
|
||||
const MAX_PARAGRAPH_RUNS: usize = 10_000;
|
||||
|
||||
/// The run properties of `e`'s `rPr` child, or the defaults.
|
||||
fn run_props(imp: &mut Imp, part: &Part, e: &El) -> RunProps {
|
||||
e.child("rPr").map(|r| rpr(imp, part, r)).unwrap_or_default()
|
||||
}
|
||||
|
||||
/// Appends the runs of an `a:r` text, where a vertical tab or line feed is a line break, as it
|
||||
/// lays out and as export writes it.
|
||||
fn push_text_runs(para: &mut Paragraph, props: RunProps, text: &str) {
|
||||
for (i, piece) in text.split(['\u{b}', '\n']).enumerate() {
|
||||
if para.runs.len() >= MAX_PARAGRAPH_RUNS {
|
||||
break;
|
||||
}
|
||||
if i > 0 {
|
||||
para.runs.push(Run { text: String::new(), props: props.clone(), kind: RunKind::Break });
|
||||
}
|
||||
if !piece.is_empty() {
|
||||
if para.runs.len() >= MAX_PARAGRAPH_RUNS {
|
||||
break;
|
||||
}
|
||||
para.runs.push(Run { text: piece.to_string(), props: props.clone(), kind: RunKind::Text });
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Appends an Office Math (a14:m) run: its plain text and its OMML.
|
||||
fn push_math_run(para: &mut Paragraph, part: &Part, e: &El) {
|
||||
if para.runs.len() < MAX_PARAGRAPH_RUNS {
|
||||
// The text of the outermost `t` elements: a `t` nested in another is already part of
|
||||
// the outer one's text, and taking it again would copy it once per nesting level.
|
||||
fn outer_t(e: &El, depth: usize, text: &mut String) {
|
||||
if depth > crate::xml::MAX_DEPTH {
|
||||
return;
|
||||
}
|
||||
for c in e.elements() {
|
||||
if c.is("t") {
|
||||
text.push_str(&c.text());
|
||||
} else {
|
||||
outer_t(c, depth + 1, text);
|
||||
}
|
||||
}
|
||||
}
|
||||
let mut text = String::new();
|
||||
outer_t(e, 0, &mut text);
|
||||
let omml = e.elements().map(|c| part.keep_inner(c)).collect::<String>();
|
||||
para.runs.push(Run { text, props: RunProps::default(), kind: RunKind::Math { omml } });
|
||||
}
|
||||
}
|
||||
|
||||
pub fn paragraph(imp: &mut Imp, part: &Part, p: &El) -> Paragraph {
|
||||
let mut para = Paragraph::default();
|
||||
for e in p.elements() {
|
||||
match e.local() {
|
||||
"pPr" => {
|
||||
let (lvl, pp, def) = ppr(imp, part, e);
|
||||
para.level = lvl.unwrap_or(0);
|
||||
para.props = pp;
|
||||
if let Some(d) = def {
|
||||
para.def_props = d;
|
||||
}
|
||||
}
|
||||
"r" => {
|
||||
let props = run_props(imp, part, e);
|
||||
let text: String = e.child("t").map(|t| t.text()).unwrap_or_default();
|
||||
push_text_runs(&mut para, props, &text);
|
||||
}
|
||||
"br" if para.runs.len() < MAX_PARAGRAPH_RUNS => {
|
||||
let props = run_props(imp, part, e);
|
||||
para.runs.push(Run { text: String::new(), props, kind: RunKind::Break });
|
||||
}
|
||||
"fld" if para.runs.len() < MAX_PARAGRAPH_RUNS => {
|
||||
let props = run_props(imp, part, e);
|
||||
let text = e.child("t").map(|t| t.text()).unwrap_or_default();
|
||||
para.runs.push(Run { text, props, kind: RunKind::Field { field: e.attr("type").unwrap_or("").to_string() } });
|
||||
}
|
||||
"m" => push_math_run(&mut para, part, e),
|
||||
"endParaRPr" => para.end_props = rpr(imp, part, e),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
para
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::xml::parse;
|
||||
|
||||
#[test]
|
||||
fn nested_math_text_is_taken_once() {
|
||||
// 200 `m:t` nested in each other around one word: the word, not 200 copies of it.
|
||||
let x = format!(r#"<a14:m xmlns:a14="a" xmlns:m="m"><m:oMath>{}word{}</m:oMath></a14:m>"#, "<m:t>".repeat(200), "</m:t>".repeat(200));
|
||||
let d = parse(x.as_bytes()).unwrap();
|
||||
let part = Part {
|
||||
name: "ppt/slides/slide1.xml".into(),
|
||||
rels: Default::default(),
|
||||
ns: vec![],
|
||||
inner_ns: vec![],
|
||||
ns_budget: std::cell::Cell::new(1 << 20),
|
||||
};
|
||||
let mut para = Paragraph::default();
|
||||
push_math_run(&mut para, &part, &d.root);
|
||||
assert_eq!(para.runs[0].text, "word");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn colors_and_transforms() {
|
||||
let d = parse(
|
||||
br#"<a:solidFill xmlns:a="x"><a:schemeClr val="accent2"><a:lumMod val="75000"/><a:alpha val="50000"/></a:schemeClr></a:solidFill>"#,
|
||||
)
|
||||
.unwrap();
|
||||
let c = color(&d.root).unwrap();
|
||||
assert_eq!(c.base, ColorBase::Scheme { slot: SchemeSlot::Accent2 });
|
||||
assert_eq!(c.mods, vec![ColorTransform::LumMod(75000), ColorTransform::Alpha(50000)]);
|
||||
let d = parse(br#"<x><a:sysClr val="window" lastClr="FFFFFF"/></x>"#).unwrap();
|
||||
assert!(matches!(color(&d.root).unwrap().base, ColorBase::System { last: Rgba::WHITE, .. }));
|
||||
let d = parse(br#"<x><a:scrgbClr r="100000" g="0" b="0"/></x>"#).unwrap();
|
||||
assert_eq!(color(&d.root).unwrap().base, ColorBase::Rgb { rgb: Rgba::rgb(255, 0, 0) });
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bullet_point_size_trims_schema_whitespace() {
|
||||
let d = parse(br#"<a:buSzPts xmlns:a="x" val=" 1400 "/>"#).unwrap();
|
||||
assert_eq!(bullet_size_points(d.root.attr("val")), Some(14.0));
|
||||
assert_eq!(bullet_size_points(Some("1400")), Some(14.0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bullet_percentage_size_accepts_numeric_and_percent_forms() {
|
||||
assert_eq!(bullet_size_percent(Some("100000")), Some(1.0));
|
||||
assert_eq!(bullet_size_percent(Some("100%")), Some(1.0));
|
||||
assert_eq!(bullet_size_percent(Some(" 125% ")), Some(1.25));
|
||||
assert_eq!(bullet_size_percent(Some("invalid")), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn miter_limit_accepts_both_percentage_forms_with_schema_bounds() {
|
||||
assert_eq!(parse_miter_limit("200000"), Some(200_000));
|
||||
assert_eq!(parse_miter_limit("200%"), Some(200_000));
|
||||
assert_eq!(parse_miter_limit("1000001"), Some(1_000_001));
|
||||
assert_eq!(parse_miter_limit("malformed"), None);
|
||||
assert_eq!(parse_miter_limit("2147483648"), None);
|
||||
assert_eq!(parse_miter_limit("2147483.648%"), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn body_props() {
|
||||
let d = parse(br#"<a:bodyPr lIns="91440" anchor="ctr" wrap="none" vert="vert270" numCol="2"><a:normAutofit fontScale="62500" lnSpcReduction="20000"/></a:bodyPr>"#).unwrap();
|
||||
let b = body_pr(&d.root);
|
||||
assert_eq!(b.inset_l, Some(7.2));
|
||||
assert_eq!(b.anchor, Some(Anchor::Middle));
|
||||
assert_eq!(b.wrap, Some(false));
|
||||
assert_eq!(b.vert, Some(TextDir::Vertical270));
|
||||
assert_eq!(b.columns, Some(2));
|
||||
assert_eq!(b.autofit, Some(AutoFit::Shrink { font_scale: Some(0.625), line_reduction: 0.2 }));
|
||||
assert_eq!(b.space_first_last, None);
|
||||
// A bare `<a:normAutofit/>` keeps no scale: the schema default 100 % is drawn as it is,
|
||||
// not the same as a saved 100 % (`fontScale="100000"`) (#724).
|
||||
let d = parse(br#"<a:bodyPr><a:normAutofit/></a:bodyPr>"#).unwrap();
|
||||
assert_eq!(body_pr(&d.root).autofit, Some(AutoFit::Shrink { font_scale: None, line_reduction: 0.0 }));
|
||||
let d = parse(br#"<a:bodyPr><a:normAutofit fontScale="100000"/></a:bodyPr>"#).unwrap();
|
||||
assert_eq!(body_pr(&d.root).autofit, Some(AutoFit::Shrink { font_scale: Some(1.0), line_reduction: 0.0 }));
|
||||
let d = parse(br#"<a:bodyPr spcFirstLastPara="1"/>"#).unwrap();
|
||||
assert_eq!(body_pr(&d.root).space_first_last, Some(true));
|
||||
// mongolianVert is its own direction (PowerPoint runs its lines left to right) and is
|
||||
// written back as it was read.
|
||||
let d = parse(br#"<a:bodyPr vert="mongolianVert"/>"#).unwrap();
|
||||
let b = body_pr(&d.root);
|
||||
assert_eq!(b.vert, Some(TextDir::MongolianVertical));
|
||||
assert_eq!(b.vert.map(|v| v.xml()), Some("mongolianVert"));
|
||||
let d = parse(br#"<a:bodyPr vert="wordArtVertRtl"/>"#).unwrap();
|
||||
assert_eq!(body_pr(&d.root).vert.map(|v| v.xml()), Some("wordArtVertRtl"));
|
||||
}
|
||||
}
|
||||
@@ -1,924 +0,0 @@
|
||||
//! Shape trees: `p:sp`, `p:pic`, `p:grpSp`, `p:cxnSp`, `p:graphicFrame` (tables, charts, SmartArt,
|
||||
//! OLE and other objects) and `p:contentPart` (3-D models).
|
||||
|
||||
use std::collections::{HashMap, HashSet};
|
||||
|
||||
use deckcraft_color::SchemeSlot;
|
||||
use deckcraft_geom::{Xfrm, preset};
|
||||
use deckcraft_model::style::{ColorRef, Effects, Fill};
|
||||
use deckcraft_model::table::{Cell, Row, Table};
|
||||
use deckcraft_model::text::{Anchor, TextDir};
|
||||
use deckcraft_model::{Geom, MediaClip, PhType, Placeholder, Shape, ShapeId, ShapeKind, ShapeStyle};
|
||||
|
||||
use super::{Imp, Part, dml};
|
||||
use crate::xml::El;
|
||||
|
||||
/// File shape ids at or above this are reassigned.
|
||||
pub const MAX_KEPT_ID: u32 = 1 << 30;
|
||||
const MAX_TREE_DEPTH: usize = 32;
|
||||
const MAX_SHAPES: usize = 20_000;
|
||||
|
||||
/// Shape id bookkeeping for one part.
|
||||
#[derive(Default)]
|
||||
pub struct IdCtx {
|
||||
pub used: HashSet<u32>,
|
||||
/// File id → model id.
|
||||
pub map: HashMap<u32, ShapeId>,
|
||||
/// Always allocate new ids (shapes pulled in from other parts).
|
||||
pub fresh: bool,
|
||||
pub count: usize,
|
||||
}
|
||||
|
||||
impl IdCtx {
|
||||
fn assign(&mut self, imp: &mut Imp, file_id: Option<u32>) -> ShapeId {
|
||||
if !self.fresh
|
||||
&& let Some(i) = file_id
|
||||
&& (2..MAX_KEPT_ID).contains(&i)
|
||||
&& !self.used.contains(&i)
|
||||
{
|
||||
self.used.insert(i);
|
||||
self.map.insert(i, ShapeId(i));
|
||||
return ShapeId(i);
|
||||
}
|
||||
let n = imp.alloc();
|
||||
self.used.insert(n);
|
||||
if let Some(i) = file_id {
|
||||
self.map.entry(i).or_insert(ShapeId(n));
|
||||
}
|
||||
ShapeId(n)
|
||||
}
|
||||
pub fn lookup(&self, file_id: u32) -> Option<ShapeId> {
|
||||
self.map.get(&file_id).copied()
|
||||
}
|
||||
}
|
||||
|
||||
/// Read the children of an `spTree` / `grpSp`.
|
||||
pub fn sp_tree(imp: &mut Imp, part: &Part, ctx: &mut IdCtx, tree: &El, depth: usize) -> Vec<Shape> {
|
||||
let mut out = vec![];
|
||||
if depth > MAX_TREE_DEPTH {
|
||||
log::warn!("pptx: group nesting too deep in {}", part.name);
|
||||
return out;
|
||||
}
|
||||
for e in tree.elements() {
|
||||
if ctx.count >= MAX_SHAPES {
|
||||
log::warn!("pptx: too many shapes in {}", part.name);
|
||||
break;
|
||||
}
|
||||
let s = match e.local() {
|
||||
"sp" => Some(sp(imp, part, ctx, e)),
|
||||
"pic" => Some(pic(imp, part, ctx, e)),
|
||||
"grpSp" => Some(grp(imp, part, ctx, e, depth)),
|
||||
"cxnSp" => Some(cxn(imp, part, ctx, e)),
|
||||
"graphicFrame" => Some(frame(imp, part, ctx, e, depth)),
|
||||
"contentPart" => content_part(imp, part, ctx, e).or_else(|| {
|
||||
log::warn!("pptx: content part in {} not imported", part.name);
|
||||
None
|
||||
}),
|
||||
"AlternateContent" => read_model_alternate(imp, part, ctx, e),
|
||||
_ => None,
|
||||
};
|
||||
if let Some(s) = s {
|
||||
ctx.count += 1;
|
||||
out.push(s);
|
||||
}
|
||||
}
|
||||
if depth == 0 {
|
||||
remap_connectors(&mut out, ctx, 0);
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// ActiveX controls (`p:controls`): each control's picture (`p:pic`), the image PowerPoint shows
|
||||
/// for it, as a picture above the slide's shapes. Controls without one are left out.
|
||||
pub fn controls(imp: &mut Imp, part: &Part, ctx: &mut IdCtx, controls: &El) -> Vec<Shape> {
|
||||
let mut out = vec![];
|
||||
for c in controls.children_named("control") {
|
||||
if ctx.count >= MAX_SHAPES {
|
||||
break;
|
||||
}
|
||||
if let Some(p) = c.child("pic") {
|
||||
ctx.count += 1;
|
||||
out.push(pic(imp, part, ctx, p));
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
fn remap_connectors(shapes: &mut [Shape], ctx: &IdCtx, depth: usize) {
|
||||
if depth > MAX_TREE_DEPTH {
|
||||
return;
|
||||
}
|
||||
for s in shapes.iter_mut() {
|
||||
match &mut s.kind {
|
||||
ShapeKind::Connector { start, end } => {
|
||||
for e in [start, end] {
|
||||
*e = e.and_then(|(id, site)| ctx.lookup(id.0).map(|m| (m, site)));
|
||||
}
|
||||
}
|
||||
ShapeKind::Group { children, .. } => remap_connectors(children, ctx, depth + 1),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// PowerPoint's Lock (right-click > Lock, the Selection pane padlock) writes a full set of locking
|
||||
/// attributes; it reads an object as locked only when the whole set for its kind is there, so a
|
||||
/// lone `noMove` or `noResize` (other tools' partial locks) isn't Lock.
|
||||
fn is_locked(l: &El) -> bool {
|
||||
let set: &[&str] = match l.local() {
|
||||
"grpSpLocks" => &["noGrp", "noUngrp", "noRot", "noMove", "noResize"],
|
||||
"graphicFrameLocks" => &["noGrp", "noDrilldown", "noMove", "noResize"],
|
||||
_ => &["noGrp", "noRot", "noMove", "noResize", "noEditPoints", "noAdjustHandles", "noChangeArrowheads", "noChangeShapeType"],
|
||||
};
|
||||
set.iter().all(|a| l.bool(a) == Some(true))
|
||||
}
|
||||
|
||||
/// Common non-visual properties (`p:nvSpPr`, `p:nvPicPr`…).
|
||||
fn base(imp: &mut Imp, part: &Part, ctx: &mut IdCtx, nv: Option<&El>) -> Shape {
|
||||
let c = nv.and_then(|n| n.child("cNvPr"));
|
||||
let mut s = Shape { id: ctx.assign(imp, c.and_then(|c| c.u32("id"))), ..Default::default() };
|
||||
if let Some(c) = c {
|
||||
s.name = c.attr("name").unwrap_or("").to_string();
|
||||
s.descr = c.attr("descr").unwrap_or("").to_string();
|
||||
s.title = c.attr("title").unwrap_or("").to_string();
|
||||
s.hidden = c.bool("hidden").unwrap_or(false);
|
||||
s.click = c.child("hlinkClick").and_then(|h| dml::hyperlink(imp, part, h));
|
||||
s.hover = c.child("hlinkHover").and_then(|h| dml::hyperlink(imp, part, h));
|
||||
s.decorative = c.find("decorative").and_then(|d| d.bool("val")).unwrap_or(false);
|
||||
}
|
||||
if let Some(nv) = nv {
|
||||
for e in nv.elements() {
|
||||
match e.local() {
|
||||
"cNvSpPr" => {
|
||||
s.text_box = e.bool("txBox").unwrap_or(false);
|
||||
s.locked = e.child("spLocks").is_some_and(is_locked);
|
||||
}
|
||||
"cNvPicPr" | "cNvGrpSpPr" | "cNvCxnSpPr" | "cNvGraphicFramePr" => {
|
||||
s.locked = e.elements().find(|l| l.local().ends_with("Locks")).is_some_and(is_locked);
|
||||
}
|
||||
"nvPr" => {
|
||||
if let Some(ph) = e.child("ph") {
|
||||
s.ph = Some(Placeholder {
|
||||
kind: ph.attr("type").map(PhType::from_xml).unwrap_or(PhType::Obj),
|
||||
idx: ph.u32("idx").unwrap_or(0),
|
||||
vertical: ph.attr("orient") == Some("vert"),
|
||||
size: ph.attr("sz").map(String::from),
|
||||
has_custom_prompt: ph.bool("hasCustomPrompt").unwrap_or(false),
|
||||
});
|
||||
}
|
||||
s.tags = super::tags(imp, part, e);
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
s
|
||||
}
|
||||
|
||||
fn preset_geom(pg: &El) -> Geom {
|
||||
let name = pg.attr("prst").unwrap_or("rect").to_string();
|
||||
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") {
|
||||
for gd in av.children_named("gd").take(16) {
|
||||
let n = gd.attr("name").unwrap_or("");
|
||||
let idx = if n == "adj" {
|
||||
0
|
||||
} else if let Some(k) = n.strip_prefix("adj").and_then(|k| k.parse::<usize>().ok()).filter(|k| (1..=16).contains(k)) {
|
||||
k - 1
|
||||
} else {
|
||||
continue;
|
||||
};
|
||||
let Some(v) =
|
||||
gd.attr("fmla").and_then(|f| f.trim().strip_prefix("val")).and_then(|v| v.trim().parse::<f64>().ok()).filter(|v| v.is_finite())
|
||||
else {
|
||||
continue;
|
||||
};
|
||||
if adj.len() <= idx {
|
||||
adj.resize(idx + 1, 0.0);
|
||||
}
|
||||
if let Some(slot) = adj.get_mut(idx) {
|
||||
*slot = v;
|
||||
any = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
if !any {
|
||||
adj.clear();
|
||||
}
|
||||
Geom::Preset { name, adj }
|
||||
}
|
||||
|
||||
/// A placeholder whose `spPr` names no geometry takes its layout's (or master's) placeholder's:
|
||||
/// marked here with an empty custom geometry, filled in once the layouts are read
|
||||
/// (`inherit_placeholder_geometry`).
|
||||
fn mark_inherited_geometry(s: &mut Shape, pr: Option<&El>) {
|
||||
if s.ph.is_some() && pr.is_none_or(|pr| pr.child("prstGeom").is_none() && pr.child("custGeom").is_none()) {
|
||||
s.geom = Geom::Custom { paths: vec![] };
|
||||
}
|
||||
}
|
||||
|
||||
/// `spPr` → transform, geometry, fill, line, effects.
|
||||
fn sp_pr(imp: &mut Imp, part: &Part, s: &mut Shape, pr: &El) {
|
||||
if let Some(x) = pr.child("xfrm") {
|
||||
s.xfrm = Some(dml::xfrm(x).0);
|
||||
}
|
||||
if let Some(pg) = pr.child("prstGeom") {
|
||||
s.geom = preset_geom(pg);
|
||||
} else if let Some(cg) = pr.child("custGeom") {
|
||||
let (w, h) = s.xfrm.map(|x| (deckcraft_geom::pt_to_emu(x.w) as f64, deckcraft_geom::pt_to_emu(x.h) as f64)).unwrap_or((21600.0, 21600.0));
|
||||
let paths = crate::custgeom::read_cust_geom(cg, w, h);
|
||||
if !paths.is_empty() {
|
||||
s.geom = Geom::Custom { paths };
|
||||
}
|
||||
}
|
||||
s.fill = dml::fill_of(imp, part, pr);
|
||||
if let Some(ln) = pr.child("ln") {
|
||||
s.line = Some(dml::line(imp, part, ln));
|
||||
}
|
||||
if let Some(fx) = pr.child("effectLst") {
|
||||
s.effects = Some(dml::effects(fx));
|
||||
}
|
||||
let raw: String = pr.elements().filter(|c| c.is("scene3d") || c.is("sp3d")).map(|c| part.keep(c)).collect();
|
||||
if !raw.is_empty() {
|
||||
let fx = s.effects.get_or_insert_with(Effects::default);
|
||||
fx.bevel = pr.path(&["sp3d", "bevelT"]).map(|b| b.attr("prst").unwrap_or("circle").to_string());
|
||||
fx.raw3d = Some(raw);
|
||||
}
|
||||
}
|
||||
|
||||
fn style(st: &El) -> ShapeStyle {
|
||||
let r = |n: &str| {
|
||||
st.child(n)
|
||||
.map(|e| (e.u32("idx").unwrap_or(0).min(1003), dml::color(e).unwrap_or(ColorRef::scheme(SchemeSlot::Accent1))))
|
||||
.unwrap_or((0, ColorRef::scheme(SchemeSlot::Accent1)))
|
||||
};
|
||||
let font = st.child("fontRef");
|
||||
ShapeStyle {
|
||||
line_ref: r("lnRef"),
|
||||
fill_ref: r("fillRef"),
|
||||
effect_ref: r("effectRef"),
|
||||
font_ref: (font.and_then(|f| f.attr("idx")).unwrap_or("minor").to_string(), font.and_then(dml::color)),
|
||||
}
|
||||
}
|
||||
|
||||
fn sp(imp: &mut Imp, part: &Part, ctx: &mut IdCtx, e: &El) -> Shape {
|
||||
let mut s = base(imp, part, ctx, e.child("nvSpPr"));
|
||||
if let Some(pr) = e.child("spPr") {
|
||||
sp_pr(imp, part, &mut s, pr);
|
||||
}
|
||||
mark_inherited_geometry(&mut s, e.child("spPr"));
|
||||
if e.bool("useBgFill") == Some(true) {
|
||||
s.fill = Some(Fill::Background);
|
||||
}
|
||||
s.style = e.child("style").map(style);
|
||||
s.text = e.child("txBody").map(|t| dml::text_body(imp, part, t));
|
||||
s
|
||||
}
|
||||
|
||||
fn ms(v: Option<&str>) -> u32 {
|
||||
v.and_then(|v| v.trim().parse::<f64>().ok()).filter(|v| v.is_finite()).map(|v| v.clamp(0.0, u32::MAX as f64) as u32).unwrap_or(0)
|
||||
}
|
||||
|
||||
fn find_content_part(el: &El) -> Option<&El> {
|
||||
fn rec(el: &El, depth: usize) -> Option<&El> {
|
||||
if depth > 16 {
|
||||
return None;
|
||||
}
|
||||
if el.is("contentPart") {
|
||||
return Some(el);
|
||||
}
|
||||
el.elements().find_map(|c| rec(c, depth + 1))
|
||||
}
|
||||
rec(el, 0)
|
||||
}
|
||||
|
||||
/// `p:contentPart` whose relationship is a 3-D model. Other content parts (ink) are left out.
|
||||
fn content_part(imp: &mut Imp, part: &Part, ctx: &mut IdCtx, e: &El) -> Option<Shape> {
|
||||
let id = e.attr("r:id").filter(|s| !s.is_empty())?;
|
||||
let rel = part.rels.get(id)?;
|
||||
if !super::is_model3d(rel) {
|
||||
return None;
|
||||
}
|
||||
let target = rel.target.clone();
|
||||
let media = imp.media_for(&target).or_else(|| {
|
||||
log::warn!("pptx: 3-D model part missing in {}", part.name);
|
||||
None
|
||||
})?;
|
||||
let mut s = base(imp, part, ctx, e.child("nvContentPartPr"));
|
||||
if let Some(x) = e.child("xfrm") {
|
||||
s.xfrm = Some(dml::xfrm(x).0);
|
||||
}
|
||||
s.kind = ShapeKind::Model3d { media, poster: None };
|
||||
Some(s)
|
||||
}
|
||||
|
||||
/// A 3-D model wrapped in `mc:AlternateContent`: the model choice, plus the fallback picture.
|
||||
/// If the model part is missing, the fallback picture is the shape.
|
||||
fn read_model_alternate(imp: &mut Imp, part: &Part, ctx: &mut IdCtx, e: &El) -> Option<Shape> {
|
||||
if let Some(content) = e.children_named("Choice").find_map(find_content_part)
|
||||
&& let Some(mut s) = content_part(imp, part, ctx, content)
|
||||
{
|
||||
let poster = e.child("Fallback").and_then(|fb| {
|
||||
let mut pics = vec![];
|
||||
fb.find_all("blip", &mut pics);
|
||||
pics.into_iter().find_map(|b| dml::media_ref(imp, part, b))
|
||||
});
|
||||
if let ShapeKind::Model3d { media, .. } = s.kind {
|
||||
s.kind = ShapeKind::Model3d { media, poster };
|
||||
}
|
||||
return Some(s);
|
||||
}
|
||||
e.child("Fallback").and_then(|fb| fb.elements().find(|c| c.is("pic")).map(|p| pic(imp, part, ctx, p)))
|
||||
}
|
||||
|
||||
fn pic(imp: &mut Imp, part: &Part, ctx: &mut IdCtx, e: &El) -> Shape {
|
||||
let mut s = base(imp, part, ctx, e.child("nvPicPr"));
|
||||
if let Some(pr) = e.child("spPr") {
|
||||
sp_pr(imp, part, &mut s, pr);
|
||||
}
|
||||
// A picture in a picture placeholder is cut into the layout's shape (a circle, say).
|
||||
mark_inherited_geometry(&mut s, e.child("spPr"));
|
||||
s.style = e.child("style").map(style);
|
||||
let pf = e.child("blipFill").and_then(|b| dml::blip_fill(imp, part, b));
|
||||
let nvpr = e.path(&["nvPicPr", "nvPr"]);
|
||||
let vf = nvpr.and_then(|n| n.child("videoFile"));
|
||||
let af = nvpr.and_then(|n| n.child("audioFile"));
|
||||
let p14 = nvpr.and_then(|n| n.child("extLst")).and_then(|x| x.find("media"));
|
||||
if vf.is_some() || af.is_some() || p14.is_some() {
|
||||
let media = p14.and_then(|m| dml::media_ref(imp, part, m)).or_else(|| vf.or(af).and_then(|f| dml::media_ref(imp, part, f)));
|
||||
if let Some(media) = media {
|
||||
let mut clip = MediaClip {
|
||||
media,
|
||||
video: vf.is_some() || af.is_none(),
|
||||
poster: pf.as_ref().map(|p| p.media),
|
||||
crop: pf.as_ref().map(|p| p.crop).unwrap_or_default(),
|
||||
volume: 1.0,
|
||||
..Default::default()
|
||||
};
|
||||
if let Some(m) = p14 {
|
||||
if let Some(t) = m.child("trim") {
|
||||
clip.trim_start_ms = ms(t.attr("st"));
|
||||
clip.trim_end_ms = ms(t.attr("end"));
|
||||
}
|
||||
if let Some(f) = m.child("fade") {
|
||||
clip.fade_in_ms = ms(f.attr("in"));
|
||||
clip.fade_out_ms = ms(f.attr("out"));
|
||||
}
|
||||
if let Some(l) = m.child("bmkLst") {
|
||||
clip.bookmarks =
|
||||
l.children_named("bmk").take(1000).map(|b| (b.attr("name").unwrap_or("").to_string(), ms(b.attr("time")))).collect();
|
||||
}
|
||||
}
|
||||
s.kind = ShapeKind::Media(clip);
|
||||
return s;
|
||||
}
|
||||
}
|
||||
match pf {
|
||||
Some(fill) => s.kind = ShapeKind::Picture { fill },
|
||||
None => log::warn!("pptx: picture {} in {} has no readable image", s.name, part.name),
|
||||
}
|
||||
s
|
||||
}
|
||||
|
||||
fn grp(imp: &mut Imp, part: &Part, ctx: &mut IdCtx, e: &El, depth: usize) -> Shape {
|
||||
let mut s = base(imp, part, ctx, e.child("nvGrpSpPr"));
|
||||
let mut child = None;
|
||||
if let Some(pr) = e.child("grpSpPr") {
|
||||
if let Some(x) = pr.child("xfrm") {
|
||||
let (xf, ch) = dml::xfrm(x);
|
||||
s.xfrm = Some(xf);
|
||||
child = ch;
|
||||
}
|
||||
s.fill = dml::fill_of(imp, part, pr);
|
||||
if let Some(fx) = pr.child("effectLst") {
|
||||
s.effects = Some(dml::effects(fx));
|
||||
}
|
||||
if let Some(sc) = pr.child("scene3d") {
|
||||
let raw = part.keep_inner(sc);
|
||||
if !raw.is_empty() && raw.len() <= 64 * 1024 {
|
||||
s.effects.get_or_insert_with(Effects::default).raw3d = Some(raw);
|
||||
}
|
||||
}
|
||||
}
|
||||
let children = sp_tree(imp, part, ctx, e, depth + 1);
|
||||
let child = child.or_else(|| s.xfrm.map(|x| Xfrm::new(x.x, x.y, x.w, x.h))).unwrap_or_default();
|
||||
s.kind = ShapeKind::Group { children, child };
|
||||
s
|
||||
}
|
||||
|
||||
fn cxn(imp: &mut Imp, part: &Part, ctx: &mut IdCtx, e: &El) -> Shape {
|
||||
let nv = e.child("nvCxnSpPr");
|
||||
let mut s = base(imp, part, ctx, nv);
|
||||
if let Some(pr) = e.child("spPr") {
|
||||
sp_pr(imp, part, &mut s, pr);
|
||||
}
|
||||
s.style = e.child("style").map(style);
|
||||
let c = nv.and_then(|n| n.child("cNvCxnSpPr"));
|
||||
let end = |n: &str| c.and_then(|c| c.child(n)).and_then(|x| Some((ShapeId(x.u32("id")?), x.u32("idx").unwrap_or(0))));
|
||||
s.kind = ShapeKind::Connector { start: end("stCxn"), end: end("endCxn") };
|
||||
s
|
||||
}
|
||||
|
||||
fn frame(imp: &mut Imp, part: &Part, ctx: &mut IdCtx, e: &El, depth: usize) -> Shape {
|
||||
let mut s = base(imp, part, ctx, e.child("nvGraphicFramePr"));
|
||||
if let Some(x) = e.child("xfrm") {
|
||||
s.xfrm = Some(dml::xfrm(x).0);
|
||||
}
|
||||
let gd = e.path(&["graphic", "graphicData"]);
|
||||
let uri = gd.and_then(|g| g.attr("uri")).unwrap_or("");
|
||||
if let Some(gd) = gd {
|
||||
if let Some(tbl) = gd.child("tbl") {
|
||||
s.kind = ShapeKind::Table(table(imp, part, tbl));
|
||||
return s;
|
||||
}
|
||||
if let Some(c) = gd.child("chart")
|
||||
&& let Some(chart) = super::chart::frame_chart(imp, part, c.attr("r:id").unwrap_or(""), uri)
|
||||
{
|
||||
s.kind = ShapeKind::Chart(Box::new(chart));
|
||||
return s;
|
||||
}
|
||||
if uri.ends_with("/diagram")
|
||||
&& let Some(g) = smartart(imp, part, gd, &s, depth)
|
||||
{
|
||||
return g;
|
||||
}
|
||||
}
|
||||
// Something we don't model: keep its XML and show a preview picture when it has one.
|
||||
let preview = {
|
||||
let mut pics = vec![];
|
||||
e.find_all("blip", &mut pics);
|
||||
pics.into_iter().find_map(|b| dml::media_ref(imp, part, b))
|
||||
}
|
||||
.or_else(|| gd.and_then(|g| g.find("oleObj")).and_then(|o| vml_preview(imp, part, o.attr("spid")?)));
|
||||
// An embedded object's fallback picture (`p:oleObj/p:pic`) can carry a fill and an outline,
|
||||
// which PowerPoint draws behind and around the preview (old equation objects on coloured
|
||||
// boxes). The frame's own position stays.
|
||||
if let Some(pr) = gd.and_then(|g| g.find("oleObj")).and_then(|o| o.find("pic")).and_then(|p| p.child("spPr")) {
|
||||
if s.fill.is_none() {
|
||||
s.fill = dml::fill_of(imp, part, pr);
|
||||
}
|
||||
if s.line.is_none() {
|
||||
s.line = pr.child("ln").map(|ln| dml::line(imp, part, ln));
|
||||
}
|
||||
}
|
||||
let label = if let Some(o) = gd.and_then(|g| g.find("oleObj")) {
|
||||
o.attr("progId").or(o.attr("name")).unwrap_or("Object").to_string()
|
||||
} else if uri.ends_with("/diagram") {
|
||||
"SmartArt".to_string()
|
||||
} else if uri.contains("chart") {
|
||||
"Chart".to_string()
|
||||
} else {
|
||||
uri.rsplit('/').next().unwrap_or("Object").to_string()
|
||||
};
|
||||
// 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.
|
||||
// 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;
|
||||
}
|
||||
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
|
||||
}
|
||||
|
||||
/// The preview picture of an old-style embedded object (`p:oleObj spid` with no `p:pic`): the
|
||||
/// `v:imagedata` of the legacy VML drawing shape with that id, as PowerPoint 2007 wrote them.
|
||||
fn vml_preview(imp: &mut Imp, part: &Part, spid: &str) -> Option<deckcraft_model::MediaId> {
|
||||
for rel in part.rels.items.iter().filter(|r| r.kind == "vmlDrawing" && !r.external) {
|
||||
let key = crate::opc::norm(&rel.target);
|
||||
if !imp.vml_previews.contains_key(&key) {
|
||||
let index = vml_index(imp.pkg, &rel.target);
|
||||
imp.vml_previews.insert(key.clone(), index);
|
||||
}
|
||||
let Some(target) = imp.vml_previews.get(&key).and_then(|m| m.get(spid)).cloned() else { continue };
|
||||
return imp.media_for(&target);
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
/// Every shape id in a VML drawing with a picture, mapped to that picture's part: parsed once per
|
||||
/// drawing however many objects look it up.
|
||||
fn vml_index(pkg: &crate::opc::Package, vml: &str) -> std::collections::HashMap<String, String> {
|
||||
let mut out = std::collections::HashMap::new();
|
||||
let Some(doc) = pkg.xml(vml) else { return out };
|
||||
let rels = pkg.rels(vml);
|
||||
let mut shapes = vec![];
|
||||
doc.root.find_all("shape", &mut shapes);
|
||||
for s in shapes {
|
||||
let Some(id) = s.attr("id") else { continue };
|
||||
if out.contains_key(id) {
|
||||
continue; // the first shape with an id wins, as the old lookup did
|
||||
}
|
||||
let Some(img) = s.find("imagedata") else { continue };
|
||||
let Some(rid) = img.attr("o:relid").or(img.attr("r:id")) else { continue };
|
||||
if let Some(r) = rels.get(rid).filter(|r| !r.external) {
|
||||
out.insert(id.to_string(), r.target.clone());
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// A diagram's data part, without the link to its cached drawing: that link is a slide
|
||||
/// relationship id, which a save renumbers. Only diagrams whose drawing is missing or empty get
|
||||
/// here, and those are drawn from their data.
|
||||
fn diagram_data(imp: &mut Imp, target: &str) -> Option<deckcraft_model::MediaId> {
|
||||
let norm_target = crate::opc::norm(target);
|
||||
if let Some(&id) = imp.media_by_part.get(&norm_target) {
|
||||
return Some(id);
|
||||
}
|
||||
fn strip(e: &mut El, depth: usize) {
|
||||
if depth > crate::xml::MAX_DEPTH {
|
||||
return;
|
||||
}
|
||||
e.children.retain(|n| !matches!(n, crate::xml::Node::El(c) if c.is("ext") && c.find("dataModelExt").is_some()));
|
||||
for c in e.elements_mut() {
|
||||
strip(c, depth + 1);
|
||||
}
|
||||
}
|
||||
let mut doc = imp.pkg.xml(target)?;
|
||||
strip(&mut doc.root, 0);
|
||||
let xml = format!("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n{}", doc.root.to_xml());
|
||||
let id = deckcraft_model::MediaId(imp.alloc());
|
||||
let content_type = imp.pkg.content_type(target)?;
|
||||
imp.media.push(deckcraft_model::MediaItem {
|
||||
id,
|
||||
name: crate::opc::file_of(target).to_string(),
|
||||
content_type,
|
||||
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 || imp.smartart_shapes >= MAX_SMARTART_SHAPES {
|
||||
return None;
|
||||
}
|
||||
let rel_ids = gd.child("relIds")?;
|
||||
let dm = part.rels.get(rel_ids.attr("r:dm").unwrap_or(""))?;
|
||||
let data = imp.pkg.xml(&dm.target)?;
|
||||
let drawing_rel = data.root.find("dataModelExt").and_then(|x| x.attr("relId")).and_then(|id| part.rels.get(id)).map(|r| r.target.clone())?;
|
||||
let mut d = imp.pkg.xml(&drawing_rel)?;
|
||||
super::resolve_mc(&mut d.root, 0);
|
||||
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();
|
||||
g.kind = ShapeKind::Group { children, child: Xfrm::new(0.0, 0.0, x.w, x.h) };
|
||||
g.diagram = diagram_outline(imp, part, rel_ids, &data.root);
|
||||
// Node pictures, from the blips of the data model's presentation points.
|
||||
if let Some(d) = &mut g.diagram {
|
||||
let rels = imp.pkg.rels(&dm.target);
|
||||
for (k, rid) in crate::dgm::node_pictures(&data.root) {
|
||||
let Some(target) = rels.get(&rid).filter(|r| !r.external).map(|r| r.target.clone()) else { continue };
|
||||
let media = imp.media_for(&target);
|
||||
if let Some(n) = d.nodes.get_mut(k) {
|
||||
n.picture = media;
|
||||
}
|
||||
}
|
||||
}
|
||||
Some(g)
|
||||
}
|
||||
|
||||
/// A SmartArt drawing shape (`dsp:sp`) keeps its text rectangle in `dsp:txXfrm`, apart from the
|
||||
/// shape's own box: the text of a narrow shape turned by 90° is often laid out across it. Put each
|
||||
/// shape's text on that rectangle. `shapes` are what [`sp_tree`] read from `tree`, in order.
|
||||
fn smartart_text_rects(imp: &mut Imp, ctx: &mut IdCtx, tree: &El, shapes: Vec<Shape>, depth: usize) -> Vec<Shape> {
|
||||
if depth > MAX_TREE_DEPTH {
|
||||
return shapes;
|
||||
}
|
||||
let mut out = Vec::with_capacity(shapes.len());
|
||||
let mut shapes = shapes.into_iter();
|
||||
// The same elements `sp_tree` turns into shapes.
|
||||
for e in tree.elements().filter(|e| matches!(e.local(), "sp" | "pic" | "grpSp" | "cxnSp" | "graphicFrame")) {
|
||||
let Some(mut s) = shapes.next() else { break };
|
||||
let mut text_box = None;
|
||||
match (e.local(), &mut s.kind) {
|
||||
("grpSp", ShapeKind::Group { children, .. }) => {
|
||||
let kids = std::mem::take(children);
|
||||
*children = smartart_text_rects(imp, ctx, e, kids, depth + 1);
|
||||
}
|
||||
("sp", ShapeKind::Shape) => {
|
||||
if let Some(t) = e.child("txXfrm") {
|
||||
text_box = text_on_rect(imp, ctx, &mut s, dml::xfrm(t).0);
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
out.push(s);
|
||||
out.extend(text_box);
|
||||
}
|
||||
out.extend(shapes);
|
||||
out
|
||||
}
|
||||
|
||||
/// Lay out the text of `s` on `t`, a text rectangle in the same space as the shape's box, turned by
|
||||
/// the shape's rotation plus its own. When that is the shape's text area shrunk by some margin, the
|
||||
/// shape keeps its text with wider insets. Otherwise (a rectangle reaching outside the shape, or
|
||||
/// turned against it) the text moves to a new frameless text shape over `s`, which is returned:
|
||||
/// both export as plain DrawingML that any reader lays out the same way.
|
||||
fn text_on_rect(imp: &mut Imp, ctx: &mut IdCtx, s: &mut Shape, t: Xfrm) -> Option<Shape> {
|
||||
const EPS: f64 = 0.01;
|
||||
let x = s.xfrm?;
|
||||
if !x.is_finite() || !t.is_finite() || t.w <= EPS || t.h <= EPS {
|
||||
return None;
|
||||
}
|
||||
let body = s.text.as_mut().filter(|b| !b.is_empty())?;
|
||||
let turn = |a: f64| a.rem_euclid(360.0);
|
||||
let upright = |a: f64| turn(a + EPS) < 2.0 * EPS;
|
||||
let bp = &mut body.body;
|
||||
if !x.flip_h
|
||||
&& !x.flip_v
|
||||
&& upright(t.rot)
|
||||
&& bp.rot.is_none_or(upright)
|
||||
&& bp.vert.is_none_or(|v| v == TextDir::Horizontal)
|
||||
&& bp.upright != Some(true)
|
||||
{
|
||||
// Same orientation as the shape: express the rectangle as insets from the shape's text area.
|
||||
let c = x.affine().inverse() * t.center();
|
||||
let (l, top) = (c.x - t.w / 2.0, c.y - t.h / 2.0);
|
||||
let (r, b) = (l + t.w, top + t.h);
|
||||
let area = text_area(&s.geom, x.w, x.h);
|
||||
let extra = [l - area.x0, top - area.y0, area.x1 - r, area.y1 - b];
|
||||
if extra.iter().all(|v| v.is_finite() && *v >= -EPS) {
|
||||
let [el, et, er, eb] = extra.map(|v| v.max(0.0));
|
||||
bp.inset_l = Some(bp.inset_l.unwrap_or(7.2) + el);
|
||||
bp.inset_t = Some(bp.inset_t.unwrap_or(3.6) + et);
|
||||
bp.inset_r = Some(bp.inset_r.unwrap_or(7.2) + er);
|
||||
bp.inset_b = Some(bp.inset_b.unwrap_or(3.6) + eb);
|
||||
return None;
|
||||
}
|
||||
}
|
||||
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| {
|
||||
st.fill_ref.0 = 0;
|
||||
st.line_ref.0 = 0;
|
||||
st.effect_ref.0 = 0;
|
||||
st
|
||||
});
|
||||
Some(Shape {
|
||||
id: ctx.assign(imp, None),
|
||||
name: s.name.clone(),
|
||||
xfrm: Some(Xfrm { rot: turn(x.rot + t.rot), flip_h: false, flip_v: false, ..t }),
|
||||
fill: Some(Fill::None),
|
||||
line: Some(deckcraft_model::style::Line { fill: Some(Fill::None), ..Default::default() }),
|
||||
style,
|
||||
text,
|
||||
click: s.click.clone(),
|
||||
hover: s.hover.clone(),
|
||||
..Default::default()
|
||||
})
|
||||
}
|
||||
|
||||
/// Where a shape's geometry puts its text, in shape-local points (as the renderer computes it).
|
||||
fn text_area(geom: &Geom, w: f64, h: f64) -> deckcraft_geom::Rect {
|
||||
let full = deckcraft_geom::Rect::new(0.0, 0.0, w, h);
|
||||
match geom {
|
||||
Geom::Preset { name, adj } => {
|
||||
preset::build(name, w, h, adj).or_else(|| preset::build("rect", w, h, &[])).map(|g| g.text_rect).unwrap_or(full)
|
||||
}
|
||||
Geom::Custom { .. } => full,
|
||||
}
|
||||
}
|
||||
|
||||
/// 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: &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 = 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
|
||||
.as_deref()
|
||||
.and_then(|x| crate::xml::parse(x.as_bytes()).ok())
|
||||
.map(|d| {
|
||||
let cat = d.root.child("catLst").and_then(|c| c.child("cat")).and_then(|c| c.attr("type")).unwrap_or("").to_string();
|
||||
(d.root.attr("uniqueId").unwrap_or("").to_string(), cat)
|
||||
})
|
||||
.unwrap_or_default();
|
||||
let lo_type = data
|
||||
.path(&["ptLst"])
|
||||
.and_then(|l| l.children_named("pt").find(|p| p.attr("type") == Some("doc")))
|
||||
.and_then(|p| p.child("prSet"))
|
||||
.and_then(|p| p.attr("loTypeId"))
|
||||
.unwrap_or("");
|
||||
let id = if layout_id.is_empty() { lo_type.to_string() } else { layout_id };
|
||||
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,
|
||||
// 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,
|
||||
colors_xml,
|
||||
})
|
||||
}
|
||||
|
||||
fn table(imp: &mut Imp, part: &Part, tbl: &El) -> Table {
|
||||
// A table naming no style is drawn by PowerPoint with thin dark grid lines ("No Style, Table
|
||||
// Grid"), not without lines.
|
||||
let mut t = Table { style: "grid".into(), first_row: false, band_row: false, ..Default::default() };
|
||||
if let Some(pr) = tbl.child("tblPr") {
|
||||
t.background = pr.elements().find(|e| e.local().ends_with("Fill") && e.local() != "noFill").and_then(|f| dml::fill_el(imp, part, f));
|
||||
t.first_row = pr.bool("firstRow").unwrap_or(false);
|
||||
t.first_col = pr.bool("firstCol").unwrap_or(false);
|
||||
t.last_row = pr.bool("lastRow").unwrap_or(false);
|
||||
t.last_col = pr.bool("lastCol").unwrap_or(false);
|
||||
t.band_row = pr.bool("bandRow").unwrap_or(false);
|
||||
t.band_col = pr.bool("bandCol").unwrap_or(false);
|
||||
t.rtl = pr.bool("rtl");
|
||||
if let Some(id) = pr.child("tableStyleId").map(|e| e.text()) {
|
||||
// A style the file defines is drawn from its definition (by its GUID).
|
||||
// DeckCraft's own styles (written with GUIDs derived from their ids) map back to them.
|
||||
let up = id.trim().to_ascii_uppercase();
|
||||
t.style =
|
||||
if imp.table_style_ids.contains(&up) && !crate::tables::is_own_guid(&up) { up } else { crate::tables::style_from_guid(id.trim()) };
|
||||
}
|
||||
}
|
||||
t.cols = tbl
|
||||
.child("tblGrid")
|
||||
.map(|g| g.children_named("gridCol").take(1000).map(|c| dml::pt(c, "w").unwrap_or(72.0).clamp(0.0, 20_000.0)).collect())
|
||||
.unwrap_or_default();
|
||||
for tr in tbl.children_named("tr").take(1000) {
|
||||
let mut row = Row { height: dml::pt(tr, "h").unwrap_or(0.0).clamp(0.0, 20_000.0), cells: vec![] };
|
||||
for tc in tr.children_named("tc").take(1000) {
|
||||
row.cells.push(cell(imp, part, tc));
|
||||
}
|
||||
t.rows.push(row);
|
||||
}
|
||||
if t.cols.is_empty() {
|
||||
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
|
||||
}
|
||||
|
||||
fn cell(imp: &mut Imp, part: &Part, tc: &El) -> Cell {
|
||||
let mut c = Cell {
|
||||
grid_span: tc.u32("gridSpan").unwrap_or(1).clamp(1, 1000),
|
||||
row_span: tc.u32("rowSpan").unwrap_or(1).clamp(1, 1000),
|
||||
h_merge: tc.bool("hMerge").unwrap_or(false),
|
||||
v_merge: tc.bool("vMerge").unwrap_or(false),
|
||||
..Default::default()
|
||||
};
|
||||
if let Some(tx) = tc.child("txBody") {
|
||||
c.text = dml::text_body(imp, part, tx);
|
||||
}
|
||||
if let Some(pr) = tc.child("tcPr") {
|
||||
if ["marL", "marR", "marT", "marB"].iter().any(|n| pr.has_attr(n)) {
|
||||
c.margins = Some([
|
||||
dml::pt(pr, "marL").unwrap_or(7.2),
|
||||
dml::pt(pr, "marR").unwrap_or(7.2),
|
||||
dml::pt(pr, "marT").unwrap_or(3.6),
|
||||
dml::pt(pr, "marB").unwrap_or(3.6),
|
||||
]);
|
||||
}
|
||||
c.anchor = pr.attr("anchor").and_then(Anchor::from_xml);
|
||||
c.anchor_ctr = pr.bool("anchorCtr");
|
||||
c.horz_overflow = pr.attr("horzOverflow").and_then(deckcraft_model::text::TextOverflow::from_horz_xml);
|
||||
c.vertical = pr.attr("vert").and_then(TextDir::from_xml);
|
||||
for (i, n) in ["lnL", "lnR", "lnT", "lnB"].iter().enumerate() {
|
||||
if let Some(ln) = pr.child(n)
|
||||
&& let Some(b) = c.borders.get_mut(i)
|
||||
{
|
||||
*b = Some(dml::line(imp, part, ln));
|
||||
}
|
||||
}
|
||||
c.diag_down = pr.child("lnTlToBr").map(|l| dml::line(imp, part, l));
|
||||
c.diag_up = pr.child("lnBlToTr").map(|l| dml::line(imp, part, l));
|
||||
c.fill = dml::fill_of(imp, part, pr);
|
||||
}
|
||||
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:?}");
|
||||
}
|
||||
}
|
||||
@@ -1,114 +0,0 @@
|
||||
//! Theme parts (`a:theme`).
|
||||
|
||||
use deckcraft_color::{ColorScheme, Rgba, SchemeSlot};
|
||||
use deckcraft_model::style::{ColorBase, Effects};
|
||||
use deckcraft_model::theme::{FontScheme, FontSet, FormatScheme, ScriptFont, Theme, default_format};
|
||||
|
||||
use super::{Imp, Part, dml};
|
||||
use crate::xml::El;
|
||||
|
||||
fn font_set(e: Option<&El>) -> FontSet {
|
||||
let tf = |n: &str| e.and_then(|e| e.child(n)).and_then(|c| c.attr("typeface")).unwrap_or("").to_string();
|
||||
let scripts = e
|
||||
.map(|e| {
|
||||
e.children_named("font")
|
||||
.filter_map(|f| Some(ScriptFont { script: f.attr("script")?.to_string(), typeface: f.attr("typeface").unwrap_or("").to_string() }))
|
||||
.take(256)
|
||||
.collect()
|
||||
})
|
||||
.unwrap_or_default();
|
||||
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::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 {
|
||||
ColorBase::Rgb { rgb } => rgb,
|
||||
ColorBase::System { last, .. } => last,
|
||||
ColorBase::Preset { name } => deckcraft_color::preset(&name).unwrap_or(Rgba::BLACK),
|
||||
ColorBase::Scheme { .. } => continue,
|
||||
};
|
||||
scheme.set(slot, rgb);
|
||||
}
|
||||
}
|
||||
t.colors = scheme;
|
||||
}
|
||||
if let Some(fs) = te.child("fontScheme") {
|
||||
t.fonts = FontScheme {
|
||||
name: fs.attr("name").unwrap_or("").to_string(),
|
||||
major: font_set(fs.child("majorFont")),
|
||||
minor: font_set(fs.child("minorFont")),
|
||||
};
|
||||
}
|
||||
if let Some(fm) = te.child("fmtScheme") {
|
||||
let dflt = default_format();
|
||||
let mut f = FormatScheme { name: fm.attr("name").unwrap_or("").to_string(), ..Default::default() };
|
||||
if let Some(l) = fm.child("fillStyleLst") {
|
||||
f.fills = l.elements().take(16).filter_map(|e| dml::fill_el(imp, part, e)).collect();
|
||||
}
|
||||
if let Some(l) = fm.child("lnStyleLst") {
|
||||
f.lines = l.children_named("ln").take(16).map(|e| dml::line(imp, part, e)).collect();
|
||||
}
|
||||
if let Some(l) = fm.child("effectStyleLst") {
|
||||
f.effects = l
|
||||
.children_named("effectStyle")
|
||||
.take(16)
|
||||
.map(|e| {
|
||||
let mut fx = e.child("effectLst").map(dml::effects).unwrap_or_default();
|
||||
if let Some(b) = e.path(&["sp3d", "bevelT"]) {
|
||||
fx.bevel = Some(b.attr("prst").unwrap_or("circle").to_string());
|
||||
}
|
||||
let raw: String = e.elements().filter(|c| c.is("scene3d") || c.is("sp3d")).map(|c| part.keep(c)).collect();
|
||||
if !raw.is_empty() {
|
||||
fx.raw3d = Some(raw);
|
||||
}
|
||||
fx
|
||||
})
|
||||
.collect();
|
||||
}
|
||||
if let Some(l) = fm.child("bgFillStyleLst") {
|
||||
f.bg_fills = l.elements().take(16).filter_map(|e| dml::fill_el(imp, part, e)).collect();
|
||||
}
|
||||
// The style matrix needs three entries of each kind.
|
||||
pad(&mut f.fills, &dflt.fills);
|
||||
pad(&mut f.lines, &dflt.lines);
|
||||
pad(&mut f.bg_fills, &dflt.bg_fills);
|
||||
while f.effects.len() < 3 {
|
||||
f.effects.push(Effects::default());
|
||||
}
|
||||
t.format = f;
|
||||
}
|
||||
let extra: String = root
|
||||
.elements()
|
||||
.filter(|e| e.is("objectDefaults") || e.is("extraClrSchemeLst"))
|
||||
.filter(|e| !super::has_rel_refs(e))
|
||||
.map(|e| part.keep(e))
|
||||
.collect();
|
||||
// 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
|
||||
}
|
||||
|
||||
fn pad<T: Clone>(v: &mut Vec<T>, d: &[T]) {
|
||||
while v.len() < 3 {
|
||||
match d.get(v.len()) {
|
||||
Some(x) => v.push(x.clone()),
|
||||
None => break,
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,493 +0,0 @@
|
||||
//! Slide transitions (`p:transition`) and animations (`p:timing`).
|
||||
|
||||
use deckcraft_model::anim::{AnimClass, AnimStart, Animation, BuildRole, TextBuild, Transition, build_filled, paragraph_build_roles};
|
||||
use deckcraft_model::{Shape, ShapeKind, TextBody, find_shape, find_shape_mut};
|
||||
|
||||
use super::shapes::IdCtx;
|
||||
use super::{Imp, Part, dml};
|
||||
use crate::maps;
|
||||
use crate::xml::El;
|
||||
|
||||
fn ms_attr(e: &El, name: &str) -> Option<u32> {
|
||||
let v = e.attr(name)?.trim();
|
||||
if v == "indefinite" {
|
||||
return None;
|
||||
}
|
||||
v.parse::<f64>().ok().filter(|v| v.is_finite()).map(|v| v.clamp(0.0, 86_400_000.0) as u32)
|
||||
}
|
||||
|
||||
pub fn transition(imp: &mut Imp, part: &Part, t: &El) -> Option<Transition> {
|
||||
let effect = t.elements().find(|e| !matches!(e.local(), "sndAc" | "extLst"));
|
||||
let mut tr = Transition { advance_on_click: t.bool("advClick").unwrap_or(true), advance_after_ms: ms_attr(t, "advTm"), ..Default::default() };
|
||||
match effect.and_then(maps::transition_from_xml) {
|
||||
Some((k, o)) => {
|
||||
tr.kind = k;
|
||||
tr.option = o;
|
||||
}
|
||||
None => match effect {
|
||||
Some(e) => {
|
||||
tr.kind = e.local().to_string();
|
||||
tr.raw = Some(part.keep(t));
|
||||
}
|
||||
None => tr.kind = "none".into(),
|
||||
},
|
||||
}
|
||||
let default_dur = deckcraft_model::anim::TRANSITIONS.iter().find(|x| x.0 == tr.kind).map(|x| x.3).unwrap_or(1000);
|
||||
// `spd` defaults to "fast" in the schema; PowerPoint omits both attributes for 0.5 s.
|
||||
tr.duration_ms = ms_attr(t, "dur").unwrap_or(match t.attr("spd") {
|
||||
Some("med") => 750,
|
||||
Some("slow") => default_dur.max(1000),
|
||||
_ => 500,
|
||||
});
|
||||
if let Some(snd) = t.path(&["sndAc", "stSnd", "snd"]) {
|
||||
tr.sound = dml::media_ref(imp, part, snd);
|
||||
tr.sound_loop = t.path(&["sndAc", "stSnd"]).and_then(|s| s.attr("loop")).is_some_and(|v| v == "1" || v == "true");
|
||||
}
|
||||
tr.stop_sound = t.path(&["sndAc", "endSnd"]).is_some();
|
||||
if tr.kind == "none" && tr.advance_on_click && tr.advance_after_ms.is_none() && tr.sound.is_none() && !tr.stop_sound {
|
||||
return None;
|
||||
}
|
||||
Some(tr)
|
||||
}
|
||||
|
||||
struct Found<'a> {
|
||||
ctn: &'a El,
|
||||
trigger: Option<u32>,
|
||||
/// Click group the effect sits in: a new one starts at every time node whose start is `indefinite`.
|
||||
group: usize,
|
||||
/// Sum of the start delays of the time nodes between the click group and the effect, in ms.
|
||||
offset: u32,
|
||||
/// Whether any ancestor time node defers start until an event (`onClick`, `onEnd`, targeted `onBegin`) or nonzero delay.
|
||||
deferred: bool,
|
||||
}
|
||||
|
||||
/// Where `collect` is in the time tree: the click group and the delay accumulated inside it.
|
||||
#[derive(Clone, Copy)]
|
||||
struct At {
|
||||
trigger: Option<u32>,
|
||||
main_seq_id: Option<u32>,
|
||||
group: usize,
|
||||
offset: u32,
|
||||
deferred: bool,
|
||||
}
|
||||
|
||||
/// Returns whether `st` (`p:stCondLst`) is PowerPoint's automatic main-sequence step wrapper:
|
||||
/// `<p:cond delay="indefinite"/>` paired only with `<p:cond evt="onBegin" delay="0"><p:tn val="{main_seq_id}"/></p:cond>`
|
||||
/// referencing the immediate enclosing `mainSeq` `<p:cTn>`.
|
||||
fn is_main_seq_auto(st: &El, main_seq_id: Option<u32>) -> bool {
|
||||
let Some(ms_id) = main_seq_id else {
|
||||
return false;
|
||||
};
|
||||
let is_indefinite = |d: &El| {
|
||||
d.attr("evt").is_none()
|
||||
&& d.attr("delay").map(str::trim) == Some("indefinite")
|
||||
&& d.child("tgtEl").is_none()
|
||||
&& d.child("tn").is_none()
|
||||
&& d.child("rtn").is_none()
|
||||
};
|
||||
let is_main_seq_on_begin = |d: &El| {
|
||||
d.attr("evt") == Some("onBegin")
|
||||
&& d.attr("delay").map(str::trim) == Some("0")
|
||||
&& d.child("tgtEl").is_none()
|
||||
&& d.child("rtn").is_none()
|
||||
&& d.child("tn").and_then(|tn| tn.u32("val")) == Some(ms_id)
|
||||
};
|
||||
st.children_named("cond").any(is_indefinite)
|
||||
&& st.children_named("cond").any(is_main_seq_on_begin)
|
||||
&& st.children_named("cond").all(|d| is_indefinite(d) || is_main_seq_on_begin(d))
|
||||
}
|
||||
|
||||
fn collect<'a>(e: &'a El, at: At, groups: &mut usize, out: &mut Vec<Found<'a>>, depth: usize) {
|
||||
if depth > 64 || out.len() > 10_000 {
|
||||
return;
|
||||
}
|
||||
for c in e.elements() {
|
||||
if c.is("cTn") && c.has_attr("presetClass") {
|
||||
let deferred = at.deferred || c.child("stCondLst").is_some_and(defers_start);
|
||||
out.push(Found { ctn: c, trigger: at.trigger, group: at.group, offset: at.offset, deferred });
|
||||
continue;
|
||||
}
|
||||
let mut at = at;
|
||||
if c.is("seq")
|
||||
&& let Some(ctn) = c.child("cTn")
|
||||
&& ctn.attr("nodeType") == Some("interactiveSeq")
|
||||
{
|
||||
at.trigger = ctn.path(&["stCondLst", "cond", "tgtEl", "spTgt"]).and_then(|s| s.u32("spid"));
|
||||
at.main_seq_id = None;
|
||||
}
|
||||
if c.is("cTn") {
|
||||
let is_main_seq = c.attr("nodeType") == Some("mainSeq");
|
||||
if let Some(st) = c.child("stCondLst") {
|
||||
if !(!is_main_seq && !at.deferred && is_main_seq_auto(st, at.main_seq_id)) && defers_start(st) {
|
||||
at.deferred = true;
|
||||
}
|
||||
if let Some(cond) = st.child("cond") {
|
||||
if cond.attr("delay").map(str::trim) == Some("indefinite") {
|
||||
*groups += 1;
|
||||
at.group = *groups;
|
||||
at.offset = 0;
|
||||
} else {
|
||||
at.offset = at.offset.saturating_add(ms_attr(cond, "delay").unwrap_or(0));
|
||||
}
|
||||
}
|
||||
}
|
||||
at.main_seq_id = if is_main_seq && !at.deferred { c.u32("id") } else { None };
|
||||
}
|
||||
collect(c, at, groups, out, depth + 1);
|
||||
}
|
||||
}
|
||||
|
||||
/// How long an effect holds back an After Previous one, as the show timeline counts it.
|
||||
fn span_ms(a: &Animation) -> u32 {
|
||||
let iterations = if a.repeat == u32::MAX || a.repeat <= 1 { 1 } else { a.repeat.min(1_000) };
|
||||
a.duration_ms.saturating_mul(if a.auto_reverse { 2 } else { 1 }).saturating_mul(iterations)
|
||||
}
|
||||
|
||||
/// Start times (ms after the click) that the flat effect list plays at, effect after effect.
|
||||
fn flat_starts(anims: &[&Animation]) -> Vec<u32> {
|
||||
let (mut begin, mut end) = (0u32, 0u32);
|
||||
anims
|
||||
.iter()
|
||||
.map(|a| {
|
||||
if a.start == AnimStart::AfterPrevious {
|
||||
begin = end;
|
||||
}
|
||||
let start = begin.saturating_add(a.delay_ms);
|
||||
end = end.max(start.saturating_add(span_ms(a)));
|
||||
start
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// PowerPoint places each effect at the delays of all its enclosing time nodes, so a file may list
|
||||
/// effects out of time order (a countdown written first, then effects at 5 s placed only by their
|
||||
/// parent's delay). The flat list only knows "after/with previous" plus the effect's own delay, so
|
||||
/// a click group listed out of time order, whose flat reading disagrees with the file, is sorted by
|
||||
/// start time and its starts and delays rewritten to land every effect where PowerPoint plays it.
|
||||
/// Every other group is left untouched.
|
||||
fn place_by_parent_delays(out: &mut [(Animation, u32, String, bool, usize, u32)], at: &[(Option<u32>, usize, u32)]) {
|
||||
let mut groups: Vec<Vec<usize>> = vec![];
|
||||
let mut slot: std::collections::HashMap<(Option<u32>, usize), usize> = std::collections::HashMap::new();
|
||||
for (i, &(t, g, _)) in at.iter().enumerate() {
|
||||
let n = *slot.entry((t, g)).or_insert_with(|| {
|
||||
groups.push(vec![]);
|
||||
groups.len() - 1
|
||||
});
|
||||
groups[n].push(i);
|
||||
}
|
||||
for idx in groups {
|
||||
// More than one click in a group means the tree isn't one click per group: leave it.
|
||||
if idx.iter().skip(1).any(|&i| out[i].0.start == AnimStart::OnClick) {
|
||||
continue;
|
||||
}
|
||||
let abs: Vec<u32> = idx.iter().map(|&i| at[i].2.saturating_add(out[i].0.delay_ms)).collect();
|
||||
// Only a file that lists effects out of time order needs this: files PowerPoint or DeckCraft
|
||||
// save are in order, and their reading stays exactly as before.
|
||||
if abs.is_sorted() {
|
||||
continue;
|
||||
}
|
||||
let flat = flat_starts(&idx.iter().map(|&i| &out[i].0).collect::<Vec<_>>());
|
||||
if flat == abs {
|
||||
continue;
|
||||
}
|
||||
// The group's click stays on whichever effect now plays first.
|
||||
let had_click = out[idx[0]].0.start == AnimStart::OnClick;
|
||||
let mut order: Vec<usize> = (0..idx.len()).collect();
|
||||
order.sort_by_key(|&k| abs[k]);
|
||||
let mut sorted: Vec<(Animation, u32, String, bool, usize, u32)> = order.iter().map(|&k| out[idx[k]].clone()).collect();
|
||||
let (mut begin, mut end) = (0u32, 0u32);
|
||||
for (n, (&k, item)) in order.iter().zip(sorted.iter_mut()).enumerate() {
|
||||
let a = &mut item.0;
|
||||
let t = abs[k];
|
||||
if n == 0 && had_click {
|
||||
a.start = AnimStart::OnClick;
|
||||
a.delay_ms = t;
|
||||
} else if a.start == AnimStart::AfterPrevious && t >= end {
|
||||
begin = end;
|
||||
a.delay_ms = t - end;
|
||||
} else {
|
||||
a.start = AnimStart::WithPrevious;
|
||||
a.delay_ms = t.saturating_sub(begin);
|
||||
}
|
||||
item.5 = 0;
|
||||
end = end.max(t.saturating_add(span_ms(a)));
|
||||
}
|
||||
for (&i, item) in idx.iter().zip(sorted) {
|
||||
out[i] = item;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn max_dur(e: &El, depth: usize) -> Option<u32> {
|
||||
if depth > 64 {
|
||||
return None;
|
||||
}
|
||||
let mut best: Option<u32> = None;
|
||||
for c in e.elements() {
|
||||
if c.is("cTn")
|
||||
&& let Some(d) = ms_attr(c, "dur")
|
||||
&& d > 1
|
||||
{
|
||||
best = Some(best.map_or(d, |b: u32| b.max(d)));
|
||||
}
|
||||
if let Some(d) = max_dur(c, depth + 1) {
|
||||
best = Some(best.map_or(d, |b| b.max(d)));
|
||||
}
|
||||
}
|
||||
best
|
||||
}
|
||||
|
||||
/// Does every behaviour time node (`p:cBhvr/p:cTn`) under the effect node `c` carry `autoRev`?
|
||||
fn behaviour_auto_reverses(c: &El) -> bool {
|
||||
let mut behaviours = vec![];
|
||||
c.find_all("cBhvr", &mut behaviours);
|
||||
!behaviours.is_empty() && behaviours.iter().all(|b| b.child("cTn").and_then(|t| t.bool("autoRev")).unwrap_or(false))
|
||||
}
|
||||
|
||||
/// Volume, mute, Loop until Stopped, Hide While Not Playing and Play Full Screen live in the timing tree
|
||||
/// (`p:video`/`p:audio` > `p:cMediaNode`), not on the picture: copy them onto the target's `MediaClip`.
|
||||
/// Returns whether `st` (`p:stCondLst`) defers playback instead of starting immediately on slide entry.
|
||||
fn defers_start(st: &El) -> bool {
|
||||
let is_auto_begin = |c: &El| {
|
||||
c.attr("evt") == Some("onBegin")
|
||||
&& c.attr("delay").map(str::trim) == Some("0")
|
||||
&& c.child("tgtEl").is_none()
|
||||
&& c.child("tn").is_none()
|
||||
&& c.child("rtn").is_none()
|
||||
};
|
||||
let has_on_begin = st.children_named("cond").any(is_auto_begin);
|
||||
st.children_named("cond")
|
||||
.any(|c| (c.attr("evt").is_some() && !is_auto_begin(c)) || (!has_on_begin && c.attr("delay").map(str::trim) != Some("0")))
|
||||
}
|
||||
|
||||
/// Applies `p:video`/`p:audio` timing node settings and main-sequence autoplay triggers to media shapes.
|
||||
pub fn media_settings(timing: &El, ctx: &IdCtx, shapes: &mut [Shape]) {
|
||||
fn collect_media<'a>(e: &'a El, deferred: bool, out: &mut Vec<(&'a El, bool)>, depth: usize) {
|
||||
if depth > 64 || out.len() >= 10_000 {
|
||||
return;
|
||||
}
|
||||
let mut deferred = deferred;
|
||||
if e.is("cTn")
|
||||
&& let Some(st) = e.child("stCondLst")
|
||||
&& defers_start(st)
|
||||
{
|
||||
deferred = true;
|
||||
}
|
||||
if e.is("video") || e.is("audio") {
|
||||
out.push((e, deferred));
|
||||
return;
|
||||
}
|
||||
for c in e.elements() {
|
||||
collect_media(c, deferred, out, depth + 1);
|
||||
}
|
||||
}
|
||||
let mut nodes = vec![];
|
||||
collect_media(timing, false, &mut nodes, 0);
|
||||
for (node, deferred) in nodes {
|
||||
let Some(cm) = node.child("cMediaNode") else { continue };
|
||||
let Some(id) = cm.path(&["tgtEl", "spTgt"]).and_then(|t| t.u32("spid")).and_then(|f| ctx.lookup(f)) else { continue };
|
||||
let Some(ShapeKind::Media(clip)) = find_shape_mut(shapes, id).map(|s| &mut s.kind) else { continue };
|
||||
if let Some(v) = cm.attr("vol").and_then(|v| v.trim().parse::<f64>().ok()).filter(|v| v.is_finite()) {
|
||||
clip.volume = (v / 100_000.0).clamp(0.0, 1.0);
|
||||
}
|
||||
if cm.bool("mute") == Some(true) {
|
||||
clip.volume = 0.0;
|
||||
}
|
||||
if cm.bool("showWhenStopped") == Some(false) {
|
||||
clip.hide_while_not_playing = true;
|
||||
}
|
||||
if cm.child("cTn").and_then(|c| c.attr("repeatCount")) == Some("indefinite") {
|
||||
clip.loop_play = true;
|
||||
}
|
||||
if cm.child("cTn").and_then(|c| c.attr("fill")) == Some("remove") {
|
||||
clip.rewind = true;
|
||||
}
|
||||
if cm.u32("numSld").is_some_and(|n| n > 1) {
|
||||
clip.play_across_slides = true;
|
||||
}
|
||||
if !deferred && cm.path(&["cTn", "stCondLst", "cond"]).is_some_and(|c| c.attr("evt").is_none() && c.attr("delay").map(str::trim) == Some("0"))
|
||||
{
|
||||
clip.autoplay = true;
|
||||
}
|
||||
if node.bool("fullScrn") == Some(true) {
|
||||
clip.full_screen = true;
|
||||
}
|
||||
}
|
||||
let root_deferred = timing.path(&["tnLst", "par", "cTn", "stCondLst"]).is_some_and(defers_start);
|
||||
if !root_deferred && let Some(tn) = timing.child("tnLst") {
|
||||
let mut found = vec![];
|
||||
collect(tn, At { trigger: None, main_seq_id: None, group: 0, offset: 0, deferred: false }, &mut 0, &mut found, 0);
|
||||
for f in found.into_iter().filter(|f| f.trigger.is_none()) {
|
||||
let c = f.ctn;
|
||||
if c.attr("nodeType") == Some("clickEffect") || f.deferred {
|
||||
break;
|
||||
}
|
||||
let class = AnimClass::from_xml(c.attr("presetClass").unwrap_or("entr"));
|
||||
let preset = c.u32("presetID").unwrap_or(0);
|
||||
let effect = maps::effect_for_preset(class, preset).unwrap_or_else(|| maps::fallback_effect(class));
|
||||
let delay = c.path(&["stCondLst", "cond"]).and_then(|d| ms_attr(d, "delay")).unwrap_or(0);
|
||||
if class == AnimClass::Media
|
||||
&& effect == "play"
|
||||
&& f.offset == 0
|
||||
&& delay == 0
|
||||
&& let Some(id) = c.find("spTgt").and_then(|t| t.u32("spid")).and_then(|s| ctx.lookup(s))
|
||||
&& let Some(ShapeKind::Media(clip)) = find_shape_mut(shapes, id).map(|s| &mut s.kind)
|
||||
{
|
||||
clip.autoplay = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Flatten the timing tree into the Animation Pane list.
|
||||
pub fn animations(imp: &mut Imp, part: &Part, ctx: &IdCtx, timing: &El, shapes: &[Shape]) -> Vec<Animation> {
|
||||
let _ = (imp, part);
|
||||
let Some(tn) = timing.child("tnLst") else { return vec![] };
|
||||
let mut found = vec![];
|
||||
collect(tn, At { trigger: None, main_seq_id: None, group: 0, offset: 0, deferred: false }, &mut 0, &mut found, 0);
|
||||
// Paragraph builds (`bldP`) by (spid, grpId) -> whether `build="p"`.
|
||||
let bld_p: std::collections::HashMap<(u32, String), bool> = timing
|
||||
.child("bldLst")
|
||||
.map(|b| {
|
||||
b.children_named("bldP")
|
||||
.filter_map(|p| Some(((p.u32("spid")?, p.attr("grpId").unwrap_or("0").to_string()), p.attr("build") == Some("p"))))
|
||||
.fold(std::collections::HashMap::new(), |mut m, (k, v)| {
|
||||
m.entry(k).and_modify(|e| *e |= v).or_insert(v);
|
||||
m
|
||||
})
|
||||
})
|
||||
.unwrap_or_default();
|
||||
let mut out: Vec<(Animation, u32, String, bool, usize, u32)> = vec![];
|
||||
let mut at: Vec<(Option<u32>, usize, u32)> = vec![];
|
||||
for f in found {
|
||||
let c = f.ctn;
|
||||
let class = AnimClass::from_xml(c.attr("presetClass").unwrap_or("entr"));
|
||||
let preset = c.u32("presetID").unwrap_or(0);
|
||||
let sub = c.u32("presetSubtype").unwrap_or(0);
|
||||
let Some(tgt) = c.find("spTgt") else { continue };
|
||||
let Some(file_id) = tgt.u32("spid") else { continue };
|
||||
let Some(shape) = ctx.lookup(file_id) else { continue };
|
||||
let paragraph = tgt.path(&["txEl", "pRg"]).and_then(|p| p.u32("st"));
|
||||
let effect = maps::effect_for_preset(class, preset).unwrap_or_else(|| maps::fallback_effect(class));
|
||||
// PowerPoint writes Float Down as its own preset (47), not as Float with a direction.
|
||||
let (effect, option) = match (class, preset) {
|
||||
(AnimClass::Entrance, 47) => ("float", "d".to_string()),
|
||||
(AnimClass::Exit, 47) => ("floatOut", "d".to_string()),
|
||||
_ => (effect, maps::option_from_subtype(effect, sub)),
|
||||
};
|
||||
let start = match c.attr("nodeType") {
|
||||
Some("clickEffect") => AnimStart::OnClick,
|
||||
Some("afterEffect") => AnimStart::AfterPrevious,
|
||||
_ => AnimStart::WithPrevious,
|
||||
};
|
||||
let mut a = Animation {
|
||||
shape,
|
||||
class,
|
||||
effect: effect.to_string(),
|
||||
option,
|
||||
start,
|
||||
duration_ms: max_dur(c, 0).unwrap_or(0),
|
||||
delay_ms: c.path(&["stCondLst", "cond"]).and_then(|d| ms_attr(d, "delay")).unwrap_or(0),
|
||||
paragraph,
|
||||
trigger: f.trigger.and_then(|t| ctx.lookup(t)),
|
||||
preset_id: Some(preset),
|
||||
preset_subtype: Some(sub),
|
||||
// PowerPoint's "Auto-reverse" is `autoRev` on the behaviour nodes (`p:cBhvr/p:cTn`); Color Pulse
|
||||
// always writes it there and plays back and forth on its own, so it isn't read as the option.
|
||||
auto_reverse: c.bool("autoRev").unwrap_or(false) || (effect != "colorPulse" && behaviour_auto_reverses(c)),
|
||||
// PowerPoint's "Rewind when done playing" is `fill="remove"` on the effect node.
|
||||
rewind: c.attr("fill") == Some("remove"),
|
||||
smooth_start: c.f64("accel").map(|v| v / 100_000.0).unwrap_or(0.0),
|
||||
smooth_end: c.f64("decel").map(|v| v / 100_000.0).unwrap_or(0.0),
|
||||
bounce_end: c.f64("bounceEnd").map(|v| (v / 100_000.0).clamp(0.0, 1.0)).unwrap_or(0.0),
|
||||
..Default::default()
|
||||
};
|
||||
a.repeat = match c.attr("repeatCount") {
|
||||
Some("indefinite") => u32::MAX,
|
||||
Some(v) => v.parse::<f64>().ok().filter(|v| v.is_finite()).map(|v| (v / 1000.0).round().clamp(1.0, 10_000.0) as u32).unwrap_or(1),
|
||||
None => 1,
|
||||
};
|
||||
if let Some(m) = c.find("animMotion") {
|
||||
a.path = m.attr("path").map(String::from);
|
||||
}
|
||||
if let Some(r) = c.find("animRot") {
|
||||
a.amount = r.f64("by").map(|v| v / 60_000.0);
|
||||
if a.effect == "spin" && a.amount.is_some_and(|v| v < 0.0) {
|
||||
a.option = "counterClockwise".into();
|
||||
}
|
||||
} else if let Some(s) = c.find("animScale").and_then(|s| s.child("by")) {
|
||||
a.amount = s.f64("x").map(|v| v / 100_000.0);
|
||||
}
|
||||
if let Some(clr) = c.find("animClr").and_then(|x| x.child("to")) {
|
||||
a.color = dml::color(clr);
|
||||
}
|
||||
let grp = c.attr("grpId").unwrap_or("0").to_string();
|
||||
let build = paragraph.is_some() && bld_p.get(&(file_id, grp.clone())) != Some(&false);
|
||||
out.push((a, file_id, grp, build, f.group, f.offset));
|
||||
at.push((f.trigger, f.group, f.offset));
|
||||
}
|
||||
place_by_parent_delays(&mut out, &at);
|
||||
// A paragraph build's effects, one per paragraph, become one by-paragraph animation only when
|
||||
// the timeline plays that back exactly: PowerPoint lets each paragraph keep its own start and
|
||||
// effect, and other shapes' effects can sit between them (#844).
|
||||
let same_build = |x: &(Animation, u32, String, bool, usize, u32), y: &(Animation, u32, String, bool, usize, u32)| {
|
||||
x.3 && y.3 && x.1 == y.1 && x.2 == y.2 && x.0.trigger == y.0.trigger
|
||||
};
|
||||
let mut anims = Vec::with_capacity(out.len());
|
||||
for run in out.chunk_by(same_build) {
|
||||
let effects: Vec<&Animation> = run.iter().map(|(a, ..)| a).collect();
|
||||
let offsets: Vec<u32> = run.iter().map(|r| r.5).collect();
|
||||
let build = run.first().is_some_and(|r| r.3);
|
||||
let explicit_bld = run.first().is_some_and(|r| bld_p.get(&(r.1, r.2.clone())) == Some(&true));
|
||||
let same_click_group = run.first().is_some_and(|first| first.0.start == AnimStart::OnClick || run.iter().all(|r| r.4 == first.4));
|
||||
let text = effects.first().and_then(|a| find_shape(shapes, a.shape)).and_then(|s| s.text.as_ref());
|
||||
match (effects.first(), text) {
|
||||
(Some(first), Some(text)) if build && (explicit_bld || same_click_group) && plays_as_build(&effects, &offsets, text, explicit_bld) => {
|
||||
anims.push(Animation { text_build: TextBuild::ByParagraph, paragraph: None, ..(*first).clone() });
|
||||
}
|
||||
_ => anims.extend(effects.into_iter().cloned()),
|
||||
}
|
||||
}
|
||||
anims
|
||||
}
|
||||
|
||||
/// Are `effects` (paragraph effects of one shape, in file order) what a by-paragraph build of the
|
||||
/// first one plays: one effect per paragraph the build animates, in paragraph order, later top
|
||||
/// paragraphs on click (after previous when the build doesn't start on click), deeper ones with
|
||||
/// their parent, all with the same settings?
|
||||
fn plays_as_build(effects: &[&Animation], offsets: &[u32], text: &TextBody, explicit_bld: bool) -> bool {
|
||||
let roles = paragraph_build_roles(text);
|
||||
let expected = roles.iter().enumerate().filter(|(i, r)| match r {
|
||||
BuildRole::Top => true,
|
||||
BuildRole::Member(_) => text.paragraphs.get(*i).is_some_and(build_filled),
|
||||
BuildRole::Unowned => false,
|
||||
});
|
||||
let Some(first) = effects.first() else { return false };
|
||||
let off0 = offsets.first().copied().unwrap_or(0);
|
||||
let flat = flat_starts(effects);
|
||||
let parent_starts_match = offsets
|
||||
.iter()
|
||||
.zip(effects.iter())
|
||||
.zip(flat.iter())
|
||||
.all(|((&off, a), &ft)| off == off0 || off.saturating_add(a.delay_ms) == off0.saturating_add(ft));
|
||||
if !explicit_bld && (!parent_starts_match || (first.start != AnimStart::OnClick && (span_ms(first) != 500 || first.delay_ms != 0 || off0 != 0))) {
|
||||
return false;
|
||||
}
|
||||
let settings = |a: &Animation| Animation { start: AnimStart::OnClick, paragraph: None, ..a.clone() };
|
||||
let base = settings(first);
|
||||
let mut matched = 0;
|
||||
for (k, (i, role)) in expected.enumerate() {
|
||||
let Some(a) = effects.get(k) else { return false };
|
||||
let start_ok = match role {
|
||||
BuildRole::Top if k == 0 => true,
|
||||
BuildRole::Top if first.start == AnimStart::OnClick => a.start == AnimStart::OnClick,
|
||||
BuildRole::Top => a.start == AnimStart::AfterPrevious,
|
||||
_ => a.start == AnimStart::WithPrevious,
|
||||
};
|
||||
if a.paragraph != u32::try_from(i).ok() || !start_ok || settings(a) != base {
|
||||
return false;
|
||||
}
|
||||
matched = k + 1;
|
||||
}
|
||||
matched == effects.len()
|
||||
}
|
||||
@@ -1,97 +0,0 @@
|
||||
//! 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};
|
||||
|
||||
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"))
|
||||
})
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
#[path = "tables_legacy.rs"]
|
||||
mod legacy;
|
||||
|
||||
#[cfg(test)]
|
||||
fn own_guid(style: &str) -> String {
|
||||
guid(&format!("deckcraft-table-style:{style}"))
|
||||
}
|
||||
|
||||
#[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=\"&\"/>",
|
||||
"<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] = [
|
||||
"tblBg", "wholeTbl", "band1H", "band2H", "band1V", "band2V", "lastCol", "firstCol", "lastRow", "seCell", "swCell", "firstRow", "neCell",
|
||||
"nwCell",
|
||||
];
|
||||
let used: Vec<String> = deckcraft_model::table::table_styles().into_iter().map(|(id, _)| id).collect();
|
||||
let d = crate::xml::parse(&table_styles_xml(&used, &[])).unwrap();
|
||||
let mut n = 0;
|
||||
for st in d.root.children_named("tblStyle") {
|
||||
n += 1;
|
||||
let pos: Vec<usize> = st.elements().map(|e| ORDER.iter().position(|o| *o == e.local()).unwrap()).collect();
|
||||
assert!(pos.windows(2).all(|w| w[0] < w[1]), "{:?}: {pos:?}", st.attr("styleName"));
|
||||
}
|
||||
assert!(n > 30);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn guids_round_trip() {
|
||||
for (id, _) in deckcraft_model::table::table_styles() {
|
||||
let (g, _) = guid_for_style(&id);
|
||||
assert_eq!(style_from_guid(&g), id, "{id} via {g}");
|
||||
assert_eq!(g.len(), 38);
|
||||
}
|
||||
assert_eq!(style_from_guid("{5C22544A-7EE6-4342-B048-85BDC9FD1C3A}"), "medium2-accent1");
|
||||
assert_eq!(style_from_guid("{ABCDEF00-0000-0000-0000-000000000000}"), "{ABCDEF00-0000-0000-0000-000000000000}");
|
||||
}
|
||||
}
|
||||
@@ -1,182 +0,0 @@
|
||||
//! 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()
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -1,871 +0,0 @@
|
||||
//! DrawingML writing: colours, fills, lines, effects, transforms and text.
|
||||
|
||||
use deckcraft_geom::{Xfrm, pt_to_emu};
|
||||
use deckcraft_model::style::{
|
||||
ColorBase, ColorRef, Compound, Dash, Effects, Fill, GradientFlip, GradientShape, Line, LineAlign, LineCap, LineJoin, PictureFill, PictureMode,
|
||||
};
|
||||
use deckcraft_model::text::{
|
||||
Action, AutoFit, BodyProps, Bullet, Caps, Hyperlink, ListStyle, ParaProps, Paragraph, RunKind, RunProps, Spacing, Strike, TextBody,
|
||||
};
|
||||
|
||||
use super::{Exp, Out};
|
||||
use crate::xml::{A, W};
|
||||
|
||||
pub fn emu(pt: f64) -> i64 {
|
||||
pt_to_emu(pt).clamp(-27_273_042_316_900, 27_273_042_316_900)
|
||||
}
|
||||
|
||||
/// Positive coordinate extent (ST_PositiveCoordinate).
|
||||
pub fn emu_pos(pt: f64) -> i64 {
|
||||
emu(pt).max(0)
|
||||
}
|
||||
|
||||
/// Fraction → 1/100 000.
|
||||
pub fn pct(v: f64) -> i64 {
|
||||
if v.is_finite() { (v * 100_000.0).round().clamp(-2.0e9, 2.0e9) as i64 } else { 0 }
|
||||
}
|
||||
|
||||
/// Degrees → 1/60 000 degree, normalised to 0..360.
|
||||
pub fn ang(deg: f64) -> i64 {
|
||||
if !deg.is_finite() {
|
||||
return 0;
|
||||
}
|
||||
let d = deg.rem_euclid(360.0);
|
||||
((d * 60_000.0).round() as i64).clamp(0, 21_599_999)
|
||||
}
|
||||
|
||||
pub fn color(w: &mut W, c: &ColorRef) {
|
||||
let (tag, a) = match &c.base {
|
||||
ColorBase::Rgb { rgb } => ("a:srgbClr", A::new().a("val", rgb.hex())),
|
||||
ColorBase::Scheme { slot } => ("a:schemeClr", A::new().a("val", slot.xml_name())),
|
||||
// The reader keeps any name a file has; only names the schema allows are written.
|
||||
ColorBase::Preset { name } => ("a:prstClr", A::new().a("val", if deckcraft_color::is_preset_name(name) { name } else { "black" })),
|
||||
ColorBase::System { name, last } => {
|
||||
("a:sysClr", A::new().a("val", if deckcraft_color::is_system_name(name) { name } else { "windowText" }).a("lastClr", last.hex()))
|
||||
}
|
||||
};
|
||||
let rgb_alpha = match &c.base {
|
||||
ColorBase::Rgb { rgb } if rgb.a < 255 && !c.mods.iter().any(|m| matches!(m, deckcraft_color::ColorTransform::Alpha(_))) => {
|
||||
Some((rgb.a as i64 * 100_000 / 255) as i32)
|
||||
}
|
||||
_ => None,
|
||||
};
|
||||
if c.mods.is_empty() && rgb_alpha.is_none() {
|
||||
w.empty(tag, a);
|
||||
return;
|
||||
}
|
||||
w.open(tag, a);
|
||||
for m in &c.mods {
|
||||
let name = format!("a:{}", m.xml_name());
|
||||
match m.value() {
|
||||
Some(v) => w.val(&name, v),
|
||||
None => w.empty0(&name),
|
||||
}
|
||||
}
|
||||
if let Some(al) = rgb_alpha {
|
||||
w.val("a:alpha", al);
|
||||
}
|
||||
w.close(tag);
|
||||
}
|
||||
|
||||
pub fn solid(w: &mut W, c: &ColorRef) {
|
||||
w.open0("a:solidFill");
|
||||
color(w, c);
|
||||
w.close("a:solidFill");
|
||||
}
|
||||
|
||||
/// Write a fill. `Fill::Background` (only meaningful on `p:sp`) writes nothing.
|
||||
pub fn fill(w: &mut W, x: &mut Exp, o: &mut Out, f: &Fill) {
|
||||
match f {
|
||||
Fill::None => w.empty0("a:noFill"),
|
||||
Fill::Solid { color: c } => solid(w, c),
|
||||
Fill::Gradient(g) => gradient(w, g),
|
||||
Fill::Picture(pf) => blip_fill(w, x, o, "a:blipFill", pf),
|
||||
Fill::Pattern(p) => {
|
||||
w.open("a:pattFill", A::new().a("prst", if p.preset.is_empty() { "pct5" } else { &p.preset }));
|
||||
w.open0("a:fgClr");
|
||||
color(w, &p.fg);
|
||||
w.close("a:fgClr");
|
||||
w.open0("a:bgClr");
|
||||
color(w, &p.bg);
|
||||
w.close("a:bgClr");
|
||||
w.close("a:pattFill");
|
||||
}
|
||||
Fill::Group => w.empty0("a:grpFill"),
|
||||
Fill::Background => {}
|
||||
}
|
||||
}
|
||||
|
||||
/// `a:blipFill` / `p:blipFill`.
|
||||
pub fn blip_fill(w: &mut W, x: &mut Exp, o: &mut Out, tag: &str, pf: &PictureFill) {
|
||||
// An image that lives outside the package is a linked picture: `a:blip` names it through
|
||||
// `r:link`; `r:embed` may only reference a part inside the package.
|
||||
let linked = x.media(pf.media).is_some_and(|m| m.data.is_empty() && m.link.is_some());
|
||||
let rid = x.media_rel(o, pf.media, "image").unwrap_or_else(|| x.placeholder_rel(o));
|
||||
w.open(tag, A::new().a("rotWithShape", if pf.upright { "0" } else { "1" }));
|
||||
let adj = &pf.adjust;
|
||||
let has_kids = pf.alpha.is_some()
|
||||
|| adj.brightness != 0.0
|
||||
|| adj.contrast != 0.0
|
||||
|| adj.grayscale
|
||||
|| adj.duotone.is_some()
|
||||
|| adj.clear_color.is_some()
|
||||
|| adj.bilevel.is_some()
|
||||
|| adj.alpha_inv
|
||||
|| pf.artistic.is_some();
|
||||
let a = if linked { A::new().a("r:link", &rid) } else { A::new().a("r:embed", &rid) };
|
||||
if has_kids {
|
||||
w.open("a:blip", a);
|
||||
if let Some(c) = adj.clear_color {
|
||||
w.open0("a:clrChange");
|
||||
w.open0("a:clrFrom");
|
||||
color(w, &ColorRef::rgb(c));
|
||||
w.close("a:clrFrom");
|
||||
w.open0("a:clrTo");
|
||||
color(w, &ColorRef::rgb(c).with(deckcraft_color::ColorTransform::Alpha(0)));
|
||||
w.close("a:clrTo");
|
||||
w.close("a:clrChange");
|
||||
}
|
||||
if let Some(al) = pf.alpha {
|
||||
w.empty("a:alphaModFix", A::new().a("amt", pct(al.clamp(0.0, 1.0))));
|
||||
}
|
||||
if adj.alpha_inv {
|
||||
w.empty0("a:alphaInv");
|
||||
}
|
||||
if let Some(t) = adj.bilevel {
|
||||
w.empty("a:biLevel", A::new().a("thresh", pct(t.clamp(0.0, 1.0))));
|
||||
}
|
||||
if let Some((d, l)) = &adj.duotone {
|
||||
w.open0("a:duotone");
|
||||
color(w, d);
|
||||
color(w, l);
|
||||
w.close("a:duotone");
|
||||
}
|
||||
if adj.grayscale {
|
||||
w.empty0("a:grayscl");
|
||||
}
|
||||
if adj.brightness != 0.0 || adj.contrast != 0.0 {
|
||||
w.empty("a:lum", A::new().a("bright", pct(adj.brightness.clamp(-1.0, 1.0))).a("contrast", pct(adj.contrast.clamp(-1.0, 1.0))));
|
||||
}
|
||||
// Artistic effect: the blip is the processed picture; the original rides in an
|
||||
// `a14:imgLayer` with the effect's name, as PowerPoint writes it.
|
||||
if let Some(art) = &pf.artistic
|
||||
&& art.effect.starts_with("artistic")
|
||||
&& art.effect.chars().all(|c| c.is_ascii_alphanumeric())
|
||||
&& let Some(orig) = x.media_rel(o, art.original, "image")
|
||||
{
|
||||
w.open0("a:extLst");
|
||||
w.open("a:ext", A::new().a("uri", "{BEBA8EAE-BF5A-486C-A8C5-ECC9F3942E4B}"));
|
||||
w.open("a14:imgProps", A::new().a("xmlns:a14", crate::opc::NS_A14));
|
||||
w.open("a14:imgLayer", A::new().a("r:embed", &orig));
|
||||
w.open0("a14:imgEffect");
|
||||
w.empty0(&format!("a14:{}", art.effect));
|
||||
w.close("a14:imgEffect");
|
||||
w.close("a14:imgLayer");
|
||||
w.close("a14:imgProps");
|
||||
w.close("a:ext");
|
||||
w.close("a:extLst");
|
||||
}
|
||||
w.close("a:blip");
|
||||
} else {
|
||||
w.empty("a:blip", a);
|
||||
}
|
||||
let c = pf.crop;
|
||||
if c.iter().any(|v| *v != 0.0) {
|
||||
w.empty("a:srcRect", A::new().a("l", pct(c[0])).a("t", pct(c[1])).a("r", pct(c[2])).a("b", pct(c[3])));
|
||||
}
|
||||
match &pf.mode {
|
||||
PictureMode::Stretch { fill_rect: r } => {
|
||||
w.open0("a:stretch");
|
||||
if r.iter().any(|v| *v != 0.0) {
|
||||
w.empty("a:fillRect", A::new().a("l", pct(r[0])).a("t", pct(r[1])).a("r", pct(r[2])).a("b", pct(r[3])));
|
||||
} else {
|
||||
w.empty0("a:fillRect");
|
||||
}
|
||||
w.close("a:stretch");
|
||||
}
|
||||
PictureMode::Tile { tx, ty, sx, sy, flip, align } => {
|
||||
let flip = match flip.as_str() {
|
||||
"x" | "y" | "xy" => flip.as_str(),
|
||||
_ => "none",
|
||||
};
|
||||
let algn = match align.as_str() {
|
||||
"tl" | "t" | "tr" | "l" | "ctr" | "r" | "bl" | "b" | "br" => align.as_str(),
|
||||
_ => "tl",
|
||||
};
|
||||
w.empty("a:tile", A::new().a("tx", emu(*tx)).a("ty", emu(*ty)).a("sx", pct(*sx)).a("sy", pct(*sy)).a("flip", flip).a("algn", algn));
|
||||
}
|
||||
}
|
||||
w.close(tag);
|
||||
}
|
||||
|
||||
pub fn line(w: &mut W, x: &mut Exp, o: &mut Out, tag: &str, l: &Line) {
|
||||
let a = A::new()
|
||||
.o("w", l.width.map(|v| emu(v.clamp(0.0, 1584.0))))
|
||||
.o(
|
||||
"cap",
|
||||
l.cap.map(|c| match c {
|
||||
LineCap::Round => "rnd",
|
||||
LineCap::Square => "sq",
|
||||
LineCap::Flat => "flat",
|
||||
}),
|
||||
)
|
||||
.o("algn", l.align.map(LineAlign::xml))
|
||||
.o("cmpd", l.compound.map(Compound::xml));
|
||||
w.open(tag, a);
|
||||
if let Some(f) = &l.fill {
|
||||
match f {
|
||||
Fill::None | Fill::Solid { .. } | Fill::Gradient(_) | Fill::Pattern(_) => fill(w, x, o, f),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
match &l.dash {
|
||||
Some(Dash::Preset { name }) => {
|
||||
let n = if Dash::PRESETS.contains(&name.as_str()) { name.as_str() } else { "solid" };
|
||||
w.val("a:prstDash", n);
|
||||
}
|
||||
Some(Dash::Custom { pattern }) if !pattern.is_empty() => {
|
||||
w.open0("a:custDash");
|
||||
for (d, s) in pattern.iter().take(64) {
|
||||
w.empty("a:ds", A::new().a("d", pct(*d).max(0)).a("sp", pct(*s).max(0)));
|
||||
}
|
||||
w.close("a:custDash");
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
match l.join {
|
||||
Some(LineJoin::Round) => w.empty0("a:round"),
|
||||
Some(LineJoin::Bevel) => w.empty0("a:bevel"),
|
||||
Some(LineJoin::Miter) => {
|
||||
let limit = l.miter_limit.filter(|limit| *limit <= i32::MAX as u32);
|
||||
w.empty("a:miter", A::new().o("lim", limit));
|
||||
}
|
||||
None => {}
|
||||
}
|
||||
for (t, e) in [("a:headEnd", &l.head), ("a:tailEnd", &l.tail)] {
|
||||
if let Some(e) = e {
|
||||
let kind = match e.kind.as_str() {
|
||||
"triangle" | "stealth" | "diamond" | "oval" | "arrow" => e.kind.as_str(),
|
||||
_ => "none",
|
||||
};
|
||||
let sz = |s: &str| match s {
|
||||
"sm" | "lg" => s.to_string(),
|
||||
_ => "med".to_string(),
|
||||
};
|
||||
w.empty(t, A::new().a("type", kind).a("w", sz(&e.w)).a("len", sz(&e.len)));
|
||||
}
|
||||
}
|
||||
w.close(tag);
|
||||
}
|
||||
|
||||
fn shadow(w: &mut W, tag: &str, s: &deckcraft_model::style::Shadow) {
|
||||
let mut a = A::new().a("blurRad", emu(s.blur).max(0)).a("dist", emu(s.dist).max(0)).a("dir", ang(s.dir));
|
||||
if tag == "a:outerShdw" {
|
||||
if s.sx != 1.0 {
|
||||
a = a.a("sx", pct(s.sx));
|
||||
}
|
||||
if s.sy != 1.0 {
|
||||
a = a.a("sy", pct(s.sy));
|
||||
}
|
||||
if s.kx != 0.0 {
|
||||
a = a.a("kx", (s.kx.clamp(-89.0, 89.0) * 60_000.0).round() as i64);
|
||||
}
|
||||
if s.ky != 0.0 {
|
||||
a = a.a("ky", (s.ky.clamp(-89.0, 89.0) * 60_000.0).round() as i64);
|
||||
}
|
||||
let algn = match s.align.as_str() {
|
||||
"tl" | "t" | "tr" | "l" | "ctr" | "r" | "bl" | "b" | "br" => s.align.as_str(),
|
||||
_ => "b",
|
||||
};
|
||||
a = a.a("algn", algn).a("rotWithShape", if s.rotate_with_shape { "1" } else { "0" });
|
||||
}
|
||||
w.open(tag, a);
|
||||
color(w, &s.color);
|
||||
w.close(tag);
|
||||
}
|
||||
|
||||
fn gradient(w: &mut W, g: &deckcraft_model::style::Gradient) {
|
||||
w.open("a:gradFill", A::new().o("flip", g.flip.map(GradientFlip::xml)).a("rotWithShape", if g.rotate_with_shape { "1" } else { "0" }));
|
||||
// No stops: no `a:gsLst`, so the gradient keeps taking them from its style's fill.
|
||||
let mut stops = g.stops.clone();
|
||||
if stops.len() == 1 {
|
||||
let mut s = stops[0].clone();
|
||||
s.pos = 1.0;
|
||||
stops.push(s);
|
||||
}
|
||||
if !stops.is_empty() {
|
||||
w.open0("a:gsLst");
|
||||
for s in &stops {
|
||||
w.open("a:gs", A::new().a("pos", pct(s.pos.clamp(0.0, 1.0))));
|
||||
color(w, &s.color);
|
||||
w.close("a:gs");
|
||||
}
|
||||
w.close("a:gsLst");
|
||||
}
|
||||
match &g.shape {
|
||||
GradientShape::Linear { angle, scaled } => w.empty("a:lin", A::new().a("ang", ang(*angle)).a("scaled", if *scaled { "1" } else { "0" })),
|
||||
GradientShape::Path { path, focus } => {
|
||||
let p = match path.as_str() {
|
||||
"rect" | "shape" | "circle" => path.as_str(),
|
||||
_ => "circle",
|
||||
};
|
||||
w.open("a:path", A::new().a("path", p));
|
||||
w.empty("a:fillToRect", A::new().a("l", pct(focus[0])).a("t", pct(focus[1])).a("r", pct(focus[2])).a("b", pct(focus[3])));
|
||||
w.close("a:path");
|
||||
}
|
||||
}
|
||||
if g.tile.iter().any(|v| *v != 0.0) {
|
||||
let [l, t, r, b] = g.tile;
|
||||
w.empty("a:tileRect", A::new().a("l", pct(l)).a("t", pct(t)).a("r", pct(r)).a("b", pct(b)));
|
||||
}
|
||||
w.close("a:gradFill");
|
||||
}
|
||||
|
||||
pub fn effects(w: &mut W, fx: &Effects) {
|
||||
w.open0("a:effectLst");
|
||||
// Schema order: blur, fillOverlay, glow, innerShdw, outerShdw, prstShdw, reflection, softEdge.
|
||||
if let Some(ov) = &fx.fill_overlay {
|
||||
let blend = match ov.blend.as_str() {
|
||||
b @ ("over" | "mult" | "screen" | "darken" | "lighten") => b,
|
||||
_ => "over",
|
||||
};
|
||||
w.open("a:fillOverlay", A::new().a("blend", blend));
|
||||
match &ov.fill {
|
||||
Fill::Solid { color: c } => solid(w, c),
|
||||
Fill::Gradient(g) => gradient(w, g),
|
||||
_ => w.empty0("a:noFill"),
|
||||
}
|
||||
w.close("a:fillOverlay");
|
||||
}
|
||||
if let Some(g) = &fx.glow {
|
||||
w.open("a:glow", A::new().a("rad", emu(g.radius).max(0)));
|
||||
color(w, &g.color);
|
||||
w.close("a:glow");
|
||||
}
|
||||
if let Some(s) = &fx.inner_shadow {
|
||||
shadow(w, "a:innerShdw", s);
|
||||
}
|
||||
if let Some(s) = &fx.outer_shadow {
|
||||
shadow(w, "a:outerShdw", s);
|
||||
}
|
||||
if let Some(r) = &fx.reflection {
|
||||
w.empty(
|
||||
"a:reflection",
|
||||
A::new()
|
||||
.a("blurRad", emu(r.blur).max(0))
|
||||
.a("stA", pct(r.start_alpha.clamp(0.0, 1.0)))
|
||||
.a("endA", pct(r.end_alpha.clamp(0.0, 1.0)))
|
||||
.a("endPos", pct(r.end_pos.clamp(0.0, 1.0)))
|
||||
.a("dist", emu(r.dist).max(0))
|
||||
// Kept from a file as read: held to the schema's ranges so a stray value can't
|
||||
// make PowerPoint repair the file (ST_PositiveFixedAngle, ST_FixedAngle,
|
||||
// ST_PositiveFixedPercentage).
|
||||
.o("stPos", r.st_pos.map(|v| v.clamp(0, 100_000)))
|
||||
.o("dir", r.dir.map(|v| v.rem_euclid(21_600_000)))
|
||||
.o("fadeDir", r.fade_dir.map(|v| v.rem_euclid(21_600_000)))
|
||||
.o("sx", r.sx)
|
||||
.o("sy", r.sy)
|
||||
.o("kx", r.kx.map(|v| v.clamp(-5_399_999, 5_399_999)))
|
||||
.o("ky", r.ky.map(|v| v.clamp(-5_399_999, 5_399_999)))
|
||||
.o("algn", r.align.as_deref())
|
||||
.b("rotWithShape", r.rotate_with_shape),
|
||||
);
|
||||
}
|
||||
if let Some(r) = fx.soft_edge {
|
||||
w.empty("a:softEdge", A::new().a("rad", emu(r).max(0)));
|
||||
}
|
||||
w.close("a:effectLst");
|
||||
}
|
||||
|
||||
/// `a:sp3d` for a bevel preset when the shape or theme style has no kept 3-D XML.
|
||||
/// The preset name is limited to ASCII letters and digits so it cannot break the markup.
|
||||
pub fn bevel_sp3d(preset: &str) -> Option<String> {
|
||||
if preset.is_empty() || preset.len() > 32 || !preset.chars().all(|c| c.is_ascii_alphanumeric()) {
|
||||
return None;
|
||||
}
|
||||
Some(format!("<a:sp3d><a:bevelT prst=\"{preset}\"/></a:sp3d>"))
|
||||
}
|
||||
|
||||
pub fn xfrm(w: &mut W, tag: &str, x: &Xfrm, child: Option<&Xfrm>) {
|
||||
let x = if x.is_finite() { *x } else { Xfrm::default() };
|
||||
let rot = ang(x.rot);
|
||||
w.open(tag, A::new().o("rot", (rot != 0).then_some(rot)).t("flipH", x.flip_h).t("flipV", x.flip_v));
|
||||
w.empty("a:off", A::new().a("x", emu(x.x)).a("y", emu(x.y)));
|
||||
w.empty("a:ext", A::new().a("cx", emu_pos(x.w)).a("cy", emu_pos(x.h)));
|
||||
if let Some(c) = child {
|
||||
let c = if c.is_finite() { *c } else { Xfrm::default() };
|
||||
w.empty("a:chOff", A::new().a("x", emu(c.x)).a("y", emu(c.y)));
|
||||
w.empty("a:chExt", A::new().a("cx", emu_pos(c.w)).a("cy", emu_pos(c.h)));
|
||||
}
|
||||
w.close(tag);
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------------------------
|
||||
// Text
|
||||
|
||||
pub fn hyperlink(w: &mut W, x: &mut Exp, o: &mut Out, tag: &str, h: &Hyperlink) {
|
||||
let (rid, action) = match &h.action {
|
||||
Action::Url { url } => {
|
||||
if url.is_empty() {
|
||||
return;
|
||||
}
|
||||
(o.rels.add("hyperlink", url, true), None)
|
||||
}
|
||||
Action::Slide { slide } => match x.slide_parts.get(slide) {
|
||||
Some(target) => {
|
||||
let rel = crate::opc::relative(&o.name, target);
|
||||
(o.rels.add("slide", &rel, false), Some("ppaction://hlinksldjump".to_string()))
|
||||
}
|
||||
None => return,
|
||||
},
|
||||
Action::NextSlide => (String::new(), Some("ppaction://hlinkshowjump?jump=nextslide".into())),
|
||||
Action::PreviousSlide => (String::new(), Some("ppaction://hlinkshowjump?jump=previousslide".into())),
|
||||
Action::FirstSlide => (String::new(), Some("ppaction://hlinkshowjump?jump=firstslide".into())),
|
||||
Action::LastSlide => (String::new(), Some("ppaction://hlinkshowjump?jump=lastslide".into())),
|
||||
Action::EndShow => (String::new(), Some("ppaction://hlinkshowjump?jump=endshow".into())),
|
||||
Action::LastViewed => (String::new(), Some("ppaction://hlinkshowjump?jump=lastslideviewed".into())),
|
||||
Action::CustomShow { name, returns } => {
|
||||
let id = x.p.custom_shows.iter().position(|c| c.name == *name).unwrap_or(0);
|
||||
let ret = if *returns { "true" } else { "false" };
|
||||
(String::new(), Some(format!("ppaction://customshow?id={id}&return={ret}")))
|
||||
}
|
||||
Action::Program { path } => {
|
||||
if path.is_empty() {
|
||||
return;
|
||||
}
|
||||
(o.rels.add("hyperlink", path, true), Some("ppaction://program".into()))
|
||||
}
|
||||
Action::PlayMedia => (String::new(), Some("ppaction://media".into())),
|
||||
};
|
||||
let attrs = A::new()
|
||||
.a("r:id", rid)
|
||||
.o("action", action)
|
||||
.o("tooltip", (!h.tooltip.is_empty()).then_some(h.tooltip.as_str()))
|
||||
.t("highlightClick", h.highlight_click)
|
||||
.t("endSnd", h.stop_sound);
|
||||
let sound = h.sound.and_then(|id| x.media_rel(o, id, "audio").map(|rid| (rid, id)));
|
||||
let Some((sound_rid, sound_id)) = sound else {
|
||||
w.empty(tag, attrs);
|
||||
return;
|
||||
};
|
||||
w.open(tag, attrs);
|
||||
let name = x.media(sound_id).map(|m| sound_label(&m.name)).unwrap_or_else(|| "sound.wav".into());
|
||||
w.empty("a:snd", A::new().a("r:embed", sound_rid).a("name", name));
|
||||
w.close(tag);
|
||||
}
|
||||
|
||||
/// Display name PowerPoint stores on `a:snd`.
|
||||
fn sound_label(name: &str) -> String {
|
||||
let file = name.rsplit(['/', '\\']).next().unwrap_or(name);
|
||||
let label: String = file.chars().filter(|c| c.is_ascii() && !c.is_control() && *c != '"' && *c != '<' && *c != '>').take(80).collect();
|
||||
if label.is_empty() { "sound.wav".into() } else { label }
|
||||
}
|
||||
|
||||
/// Validate an unmodelled 3-D fragment (`a:scene3d`, `a:sp3d`, `a:flatTx`) before writing raw XML.
|
||||
pub fn valid_raw3d<'a>(raw: &'a str, allowed: &[&str]) -> Option<&'a str> {
|
||||
if raw.is_empty() || raw.len() > 64 * 1024 {
|
||||
return None;
|
||||
}
|
||||
let wrap = format!("<r xmlns:a=\"{}\">{raw}</r>", crate::opc::NS_A);
|
||||
let doc = crate::xml::parse(wrap.as_bytes()).ok()?;
|
||||
let els: Vec<_> = doc.root.elements().collect();
|
||||
(!els.is_empty()
|
||||
&& els.len() <= allowed.len()
|
||||
&& doc.root.children.len() == els.len()
|
||||
&& els.iter().all(|e| e.prefix() == "a" && allowed.contains(&e.local()) && !crate::read::has_rel_refs(e)))
|
||||
.then_some(raw)
|
||||
}
|
||||
|
||||
pub fn body_pr(w: &mut W, b: &BodyProps) {
|
||||
let a = A::new()
|
||||
.o("rot", b.rot.map(|r| (r * 60_000.0).round().clamp(-21_600_000.0, 21_600_000.0) as i64))
|
||||
.o("vert", b.vert.map(|v| v.xml()))
|
||||
.o("wrap", b.wrap.map(|v| if v { "square" } else { "none" }))
|
||||
.o("lIns", b.inset_l.map(emu))
|
||||
.o("tIns", b.inset_t.map(emu))
|
||||
.o("rIns", b.inset_r.map(emu))
|
||||
.o("bIns", b.inset_b.map(emu))
|
||||
.o("numCol", b.columns.map(|c| c.clamp(1, 16)))
|
||||
.o("spcCol", b.col_spacing.map(|v| emu(v).max(0)))
|
||||
.b("rtlCol", b.rtl_col)
|
||||
.o("anchor", b.anchor.map(|a| a.xml()))
|
||||
.b("anchorCtr", b.anchor_ctr)
|
||||
.b("upright", b.upright)
|
||||
.b("spcFirstLastPara", b.space_first_last)
|
||||
.b("compatLnSpc", b.compat_ln_spc)
|
||||
.o("vertOverflow", b.vert_overflow.map(|v| v.xml()))
|
||||
.o("horzOverflow", deckcraft_model::text::TextOverflow::horz_xml(b.horz_overflow));
|
||||
let warp = b.warp.as_deref().filter(|s| !s.is_empty() && s.chars().all(|c| c.is_ascii_alphanumeric()));
|
||||
let raw3d = b.raw3d.as_deref().and_then(|s| valid_raw3d(s, &["scene3d", "sp3d", "flatTx"]));
|
||||
if warp.is_none() && b.autofit.is_none() && raw3d.is_none() {
|
||||
w.empty("a:bodyPr", a);
|
||||
return;
|
||||
}
|
||||
w.open("a:bodyPr", a);
|
||||
if let Some(p) = warp {
|
||||
w.open("a:prstTxWarp", A::new().a("prst", p));
|
||||
let adj: Vec<(usize, i64)> =
|
||||
b.warp_adj.iter().take(8).enumerate().filter(|(_, v)| v.is_finite()).map(|(i, v)| (i, v.round().clamp(-2.0e9, 2.0e9) as i64)).collect();
|
||||
if adj.is_empty() {
|
||||
w.empty0("a:avLst");
|
||||
} else {
|
||||
let single = deckcraft_geom::warp::adjust_count(p) <= 1 && b.warp_adj.len() == 1;
|
||||
w.open0("a:avLst");
|
||||
for (i, v) in adj {
|
||||
let n = if single { "adj".to_string() } else { format!("adj{}", i + 1) };
|
||||
w.empty("a:gd", A::new().a("name", n).a("fmla", format!("val {v}")));
|
||||
}
|
||||
w.close("a:avLst");
|
||||
}
|
||||
w.close("a:prstTxWarp");
|
||||
}
|
||||
match b.autofit {
|
||||
Some(AutoFit::None) => w.empty0("a:noAutofit"),
|
||||
Some(AutoFit::Shape) => w.empty0("a:spAutoFit"),
|
||||
Some(AutoFit::Shrink { font_scale, line_reduction }) => {
|
||||
// A scale the model holds is written, 100 % included: reopening then keeps the same
|
||||
// "draw the saved scale" state instead of becoming a bare `<a:normAutofit/>` (#724).
|
||||
let fs = font_scale.map(|s| pct(s.clamp(0.01, 1.0)));
|
||||
let lr = pct(line_reduction.clamp(0.0, 1.0));
|
||||
w.empty("a:normAutofit", A::new().o("fontScale", fs).o("lnSpcReduction", (lr != 0).then_some(lr)));
|
||||
}
|
||||
None => {}
|
||||
}
|
||||
if let Some(raw) = raw3d {
|
||||
w.raw(raw);
|
||||
}
|
||||
w.close("a:bodyPr");
|
||||
}
|
||||
|
||||
fn spacing(w: &mut W, tag: &str, s: &Spacing) {
|
||||
w.open0(tag);
|
||||
match s {
|
||||
Spacing::Pct(v) => w.val("a:spcPct", pct(v.clamp(0.0, 132.0))),
|
||||
Spacing::Pts(v) => w.val("a:spcPts", (v.clamp(0.0, 1584.0) * 100.0).round() as i64),
|
||||
}
|
||||
w.close(tag);
|
||||
}
|
||||
|
||||
pub fn is_default_ppr(p: &ParaProps) -> bool {
|
||||
*p == ParaProps::default()
|
||||
}
|
||||
|
||||
/// `a:pPr` / `a:lvlNpPr`.
|
||||
pub fn ppr(w: &mut W, x: &mut Exp, o: &mut Out, tag: &str, level: Option<u8>, p: &ParaProps, def: Option<&RunProps>) {
|
||||
let a = A::new()
|
||||
.o("marL", p.margin_left.map(|v| emu(v.clamp(0.0, 4032.0))))
|
||||
.o("marR", p.margin_right.map(|v| emu(v.clamp(0.0, 4032.0))))
|
||||
.o("lvl", level.filter(|l| *l > 0).map(|l| l.min(8)))
|
||||
.o("indent", p.indent.map(|v| emu(v.clamp(-4032.0, 4032.0))))
|
||||
.o("algn", p.align.map(|a| a.xml()))
|
||||
.o("defTabSz", p.default_tab.map(|v| emu(v).max(0)))
|
||||
.b("rtl", p.rtl)
|
||||
.b("eaLnBrk", p.east_asian_line_break)
|
||||
.b("latinLnBrk", p.latin_line_break)
|
||||
.b("hangingPunct", p.hanging_punct)
|
||||
.o("fontAlgn", p.font_align.as_deref().filter(|f| matches!(*f, "auto" | "t" | "ctr" | "base" | "b")));
|
||||
let has_kids = p.line_spacing.is_some()
|
||||
|| p.space_before.is_some()
|
||||
|| p.space_after.is_some()
|
||||
|| p.bullet.is_some()
|
||||
|| p.bullet_font.is_some()
|
||||
|| p.bullet_font_follow_text.is_some()
|
||||
|| p.bullet_color.is_some()
|
||||
|| p.bullet_color_follow_text.is_some()
|
||||
|| p.bullet_size.is_some()
|
||||
|| p.bullet_size_points.is_some()
|
||||
|| p.bullet_size_follow_text.is_some()
|
||||
|| p.tabs.is_some()
|
||||
|| def.is_some();
|
||||
if !has_kids {
|
||||
w.empty(tag, a);
|
||||
return;
|
||||
}
|
||||
w.open(tag, a);
|
||||
if let Some(s) = &p.line_spacing {
|
||||
spacing(w, "a:lnSpc", s);
|
||||
}
|
||||
if let Some(s) = &p.space_before {
|
||||
spacing(w, "a:spcBef", s);
|
||||
}
|
||||
if let Some(s) = &p.space_after {
|
||||
spacing(w, "a:spcAft", s);
|
||||
}
|
||||
if p.bullet_color.is_none() && p.bullet_color_follow_text == Some(true) {
|
||||
w.empty0("a:buClrTx");
|
||||
} else if let Some(c) = &p.bullet_color {
|
||||
w.open0("a:buClr");
|
||||
color(w, c);
|
||||
w.close("a:buClr");
|
||||
}
|
||||
if p.bullet_size.is_none() && p.bullet_size_points.is_none() && p.bullet_size_follow_text == Some(true) {
|
||||
w.empty0("a:buSzTx");
|
||||
} else if let Some(s) = p.bullet_size_points.filter(|s| s.is_finite() && (1.0..=4000.0).contains(s)) {
|
||||
w.val("a:buSzPts", ((s * 100.0).round() as u32).to_string());
|
||||
} else if let Some(s) = p.bullet_size {
|
||||
w.val("a:buSzPct", pct(s.clamp(0.25, 4.0)));
|
||||
}
|
||||
if p.bullet_font.is_none() && p.bullet_font_follow_text == Some(true) {
|
||||
w.empty0("a:buFontTx");
|
||||
} else if let Some(f) = &p.bullet_font {
|
||||
w.empty("a:buFont", A::new().a("typeface", f));
|
||||
}
|
||||
match &p.bullet {
|
||||
Some(Bullet::None) => w.empty0("a:buNone"),
|
||||
Some(Bullet::Char { char }) => w.empty("a:buChar", A::new().a("char", if char.is_empty() { "•" } else { char })),
|
||||
Some(Bullet::AutoNum { scheme, start_at }) => {
|
||||
let s = if scheme.is_empty() || !scheme.chars().all(|c| c.is_ascii_alphanumeric()) { "arabicPeriod" } else { scheme };
|
||||
w.empty("a:buAutoNum", A::new().a("type", s).o("startAt", (*start_at != 1).then_some((*start_at).clamp(1, 32767))));
|
||||
}
|
||||
Some(Bullet::Picture { media }) => match x.media_rel(o, *media, "image") {
|
||||
Some(rid) => {
|
||||
w.open0("a:buBlip");
|
||||
let a = if x.media(*media).is_some_and(|m| m.data.is_empty() && m.link.is_some()) {
|
||||
A::new().a("r:link", &rid)
|
||||
} else {
|
||||
A::new().a("r:embed", &rid)
|
||||
};
|
||||
w.empty("a:blip", a);
|
||||
w.close("a:buBlip");
|
||||
}
|
||||
None => w.empty("a:buChar", A::new().a("char", "•")),
|
||||
},
|
||||
None => {}
|
||||
}
|
||||
if let Some(t) = &p.tabs {
|
||||
w.open0("a:tabLst");
|
||||
for tab in t.iter().take(32) {
|
||||
let al = match tab.align.as_str() {
|
||||
"ctr" | "r" | "dec" => tab.align.as_str(),
|
||||
_ => "l",
|
||||
};
|
||||
w.empty("a:tab", A::new().a("pos", emu(tab.pos)).a("algn", al));
|
||||
}
|
||||
w.close("a:tabLst");
|
||||
}
|
||||
if let Some(d) = def {
|
||||
rpr(w, x, o, "a:defRPr", d);
|
||||
}
|
||||
w.close(tag);
|
||||
}
|
||||
|
||||
fn typeface(w: &mut W, tag: &str, f: &Option<String>) {
|
||||
if let Some(f) = f {
|
||||
w.empty(tag, A::new().a("typeface", f));
|
||||
}
|
||||
}
|
||||
|
||||
/// `a:rPr`, `a:defRPr`, `a:endParaRPr`.
|
||||
pub fn rpr(w: &mut W, x: &mut Exp, o: &mut Out, tag: &str, r: &RunProps) {
|
||||
let a = A::new()
|
||||
.o("lang", r.lang.as_deref().filter(|l| !l.is_empty()))
|
||||
.o("altLang", r.alt_lang.as_deref().filter(|l| !l.is_empty()))
|
||||
.o("sz", r.size.map(|s| (s.clamp(1.0, 4000.0) * 100.0).round() as i64))
|
||||
.b("b", r.bold)
|
||||
.b("i", r.italic)
|
||||
.o("u", r.underline.as_deref().filter(|u| !u.is_empty() && u.chars().all(|c| c.is_ascii_alphanumeric())))
|
||||
.o(
|
||||
"strike",
|
||||
r.strike.map(|s| match s {
|
||||
Strike::None => "noStrike",
|
||||
Strike::Single => "sngStrike",
|
||||
Strike::Double => "dblStrike",
|
||||
}),
|
||||
)
|
||||
.o("kern", r.kern.map(|k| (k.clamp(0.0, 4000.0) * 100.0).round() as i64))
|
||||
.o(
|
||||
"cap",
|
||||
r.caps.map(|c| match c {
|
||||
Caps::None => "none",
|
||||
Caps::Small => "small",
|
||||
Caps::All => "all",
|
||||
}),
|
||||
)
|
||||
.o("spc", r.spacing.map(|s| (s.clamp(-4000.0, 4000.0) * 100.0).round() as i64))
|
||||
.o("baseline", r.baseline.map(|b| pct(b.clamp(-10.0, 10.0))))
|
||||
.b("noProof", r.no_proof)
|
||||
.b("normalizeH", r.normalize_height);
|
||||
let has_fx = r.shadow.is_some() || r.inner_shadow.is_some() || r.glow.is_some() || r.reflection.is_some() || r.soft_edge.is_some();
|
||||
let has_kids = r.outline.is_some()
|
||||
|| r.fill.is_some()
|
||||
|| has_fx
|
||||
|| r.highlight.is_some()
|
||||
|| r.underline_color.is_some()
|
||||
|| r.font.is_some()
|
||||
|| r.font_ea.is_some()
|
||||
|| r.font_cs.is_some()
|
||||
|| r.font_sym.is_some()
|
||||
|| r.link.is_some()
|
||||
|| r.hover.is_some();
|
||||
if !has_kids {
|
||||
w.empty(tag, a);
|
||||
return;
|
||||
}
|
||||
w.open(tag, a);
|
||||
if let Some(l) = &r.outline {
|
||||
line(w, x, o, "a:ln", l);
|
||||
}
|
||||
if let Some(f) = &r.fill {
|
||||
match f {
|
||||
Fill::Background => {}
|
||||
f => fill(w, x, o, f),
|
||||
}
|
||||
}
|
||||
if has_fx {
|
||||
// Same child order as a shape's effect list: glow, inner shadow, outer shadow, reflection, soft edge.
|
||||
effects(
|
||||
w,
|
||||
&Effects {
|
||||
outer_shadow: r.shadow.clone(),
|
||||
inner_shadow: r.inner_shadow.clone(),
|
||||
glow: r.glow.clone(),
|
||||
reflection: r.reflection.clone(),
|
||||
soft_edge: r.soft_edge,
|
||||
..Default::default()
|
||||
},
|
||||
);
|
||||
}
|
||||
if let Some(h) = &r.highlight {
|
||||
w.open0("a:highlight");
|
||||
color(w, h);
|
||||
w.close("a:highlight");
|
||||
}
|
||||
if let Some(c) = &r.underline_color {
|
||||
w.open0("a:uFill");
|
||||
solid(w, c);
|
||||
w.close("a:uFill");
|
||||
}
|
||||
typeface(w, "a:latin", &r.font);
|
||||
typeface(w, "a:ea", &r.font_ea);
|
||||
typeface(w, "a:cs", &r.font_cs);
|
||||
typeface(w, "a:sym", &r.font_sym);
|
||||
if let Some(h) = &r.link {
|
||||
hyperlink(w, x, o, "a:hlinkClick", h);
|
||||
}
|
||||
// Schema order: hlinkClick, hlinkMouseOver.
|
||||
if let Some(h) = &r.hover {
|
||||
hyperlink(w, x, o, "a:hlinkMouseOver", h);
|
||||
}
|
||||
w.close(tag);
|
||||
}
|
||||
|
||||
/// `a:lstStyle`-like element (`a:lstStyle`, `p:titleStyle`, `p:defaultTextStyle`…).
|
||||
pub fn list_style(w: &mut W, x: &mut Exp, o: &mut Out, tag: &str, ls: &ListStyle) {
|
||||
if ls.is_empty() {
|
||||
w.empty0(tag);
|
||||
return;
|
||||
}
|
||||
w.open0(tag);
|
||||
for (i, l) in ls.levels.iter().enumerate().take(9) {
|
||||
if let Some(l) = l {
|
||||
let t = format!("a:lvl{}pPr", i + 1);
|
||||
let def = (l.run != RunProps::default()).then_some(&l.run);
|
||||
ppr(w, x, o, &t, None, &l.para, def);
|
||||
}
|
||||
}
|
||||
w.close(tag);
|
||||
}
|
||||
|
||||
/// Write `<tag>` text body (`p:txBody`, `a:txBody`). `math` selects the OMML form of equations.
|
||||
pub fn text_body(w: &mut W, x: &mut Exp, o: &mut Out, tag: &str, tb: &TextBody, math: bool) {
|
||||
w.open0(tag);
|
||||
body_pr(w, &tb.body);
|
||||
list_style(w, x, o, "a:lstStyle", &tb.list_style);
|
||||
if tb.paragraphs.is_empty() {
|
||||
w.empty0("a:p");
|
||||
}
|
||||
for (pi, p) in tb.paragraphs.iter().enumerate() {
|
||||
paragraph(w, x, o, p, math, pi);
|
||||
}
|
||||
w.close(tag);
|
||||
}
|
||||
|
||||
fn run_text(w: &mut W, x: &mut Exp, o: &mut Out, text: &str, props: &RunProps) {
|
||||
// The run's properties are the same for every piece and line break: serialize them once.
|
||||
let mut rpr_xml: Option<String> = None;
|
||||
let mut put_rpr = |w: &mut W| match &rpr_xml {
|
||||
Some(xml) => w.s.push_str(xml),
|
||||
None => {
|
||||
let start = w.s.len();
|
||||
rpr(w, x, o, "a:rPr", props);
|
||||
rpr_xml = Some(w.s[start..].to_string());
|
||||
}
|
||||
};
|
||||
for (i, piece) in text.split(['\n', '\u{b}']).enumerate() {
|
||||
if i > 0 {
|
||||
w.open0("a:br");
|
||||
put_rpr(w);
|
||||
w.close("a:br");
|
||||
}
|
||||
if piece.is_empty() && i > 0 {
|
||||
continue;
|
||||
}
|
||||
w.open0("a:r");
|
||||
put_rpr(w);
|
||||
w.elt("a:t", piece);
|
||||
w.close("a:r");
|
||||
}
|
||||
}
|
||||
|
||||
pub fn paragraph(w: &mut W, x: &mut Exp, o: &mut Out, p: &Paragraph, math: bool, index: usize) {
|
||||
w.open0("a:p");
|
||||
let def = (p.def_props != RunProps::default()).then_some(&p.def_props);
|
||||
if p.level > 0 || !is_default_ppr(&p.props) || def.is_some() {
|
||||
ppr(w, x, o, "a:pPr", Some(p.level), &p.props, def);
|
||||
}
|
||||
for (ri, r) in p.runs.iter().enumerate() {
|
||||
match &r.kind {
|
||||
RunKind::Text => run_text(w, x, o, &r.text, &r.props),
|
||||
RunKind::Break => {
|
||||
w.open0("a:br");
|
||||
rpr(w, x, o, "a:rPr", &r.props);
|
||||
w.close("a:br");
|
||||
}
|
||||
RunKind::Field { field } => {
|
||||
let id = crate::tables::guid(&format!("{}:{index}:{ri}:{field}", o.name));
|
||||
let ty = (!field.is_empty() && field.chars().all(|c| c.is_ascii_alphanumeric() || c == '-')).then_some(field.as_str());
|
||||
w.open("a:fld", A::new().a("id", id).o("type", ty));
|
||||
rpr(w, x, o, "a:rPr", &r.props);
|
||||
w.elt("a:t", &r.text);
|
||||
w.close("a:fld");
|
||||
}
|
||||
RunKind::Math { omml } => {
|
||||
if math && !omml.is_empty() {
|
||||
w.open("a14:m", A::new().a("xmlns:a14", crate::opc::NS_A14));
|
||||
w.raw(omml);
|
||||
w.close("a14:m");
|
||||
} else {
|
||||
run_text(w, x, o, &r.text, &r.props);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if p.end_props != RunProps::default() {
|
||||
rpr(w, x, o, "a:endParaRPr", &p.end_props);
|
||||
}
|
||||
w.close("a:p");
|
||||
}
|
||||
|
||||
pub fn has_math(tb: &TextBody) -> bool {
|
||||
tb.paragraphs.iter().flat_map(|p| &p.runs).any(|r| matches!(&r.kind, RunKind::Math { omml } if !omml.is_empty()))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use deckcraft_color::Rgba;
|
||||
|
||||
#[test]
|
||||
fn unknown_preset_and_system_names_save_as_black_and_window_text() {
|
||||
let write = |base: ColorBase| {
|
||||
let mut w = W::frag();
|
||||
color(&mut w, &ColorRef { base, mods: vec![] });
|
||||
w.s
|
||||
};
|
||||
assert_eq!(write(ColorBase::Preset { name: "notAColor".into() }), r#"<a:prstClr val="black"/>"#);
|
||||
assert_eq!(write(ColorBase::Preset { name: "darkBlue".into() }), r#"<a:prstClr val="darkBlue"/>"#);
|
||||
let last = Rgba::rgb(0x12, 0x34, 0x56);
|
||||
assert_eq!(write(ColorBase::System { name: "notAColor".into(), last }), r#"<a:sysClr val="windowText" lastClr="123456"/>"#);
|
||||
assert_eq!(write(ColorBase::System { name: "3dLight".into(), last }), r#"<a:sysClr val="3dLight" lastClr="123456"/>"#);
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,112 +0,0 @@
|
||||
//! Theme parts.
|
||||
|
||||
use deckcraft_color::SchemeSlot;
|
||||
use deckcraft_model::style::{ColorRef, Effects, Fill};
|
||||
use deckcraft_model::theme::{FontSet, Theme, default_format};
|
||||
|
||||
use super::{Exp, Out, dml};
|
||||
use crate::opc::{NS_A, NS_R};
|
||||
use crate::xml::{A, W};
|
||||
|
||||
fn font_set(w: &mut W, tag: &str, f: &FontSet) {
|
||||
w.open0(tag);
|
||||
w.empty("a:latin", A::new().a("typeface", if f.latin.is_empty() { "Arial" } else { &f.latin }));
|
||||
w.empty("a:ea", A::new().a("typeface", &f.ea));
|
||||
w.empty("a:cs", A::new().a("typeface", &f.cs));
|
||||
for sf in &f.scripts {
|
||||
w.empty("a:font", A::new().a("script", &sf.script).a("typeface", &sf.typeface));
|
||||
}
|
||||
w.close(tag);
|
||||
}
|
||||
|
||||
fn style_fill(f: &Fill) -> Fill {
|
||||
match f {
|
||||
Fill::Background | Fill::Group => Fill::solid(ColorRef::scheme(SchemeSlot::PhClr)),
|
||||
f => f.clone(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn theme_xml(x: &mut Exp, o: &mut Out, t: &Theme) -> Vec<u8> {
|
||||
let mut w = W::new();
|
||||
w.open("a:theme", A::new().a("xmlns:a", NS_A).a("xmlns:r", NS_R).a("name", if t.name.is_empty() { "Theme" } else { &t.name }));
|
||||
w.open0("a:themeElements");
|
||||
w.open("a:clrScheme", A::new().a("name", if t.colors.name.is_empty() { &t.name } else { &t.colors.name }));
|
||||
for slot in SchemeSlot::THEME {
|
||||
let tag = format!("a:{}", slot.xml_name());
|
||||
w.open0(&tag);
|
||||
w.val("a:srgbClr", t.colors.get(slot).hex());
|
||||
w.close(&tag);
|
||||
}
|
||||
w.close("a:clrScheme");
|
||||
w.open("a:fontScheme", A::new().a("name", if t.fonts.name.is_empty() { &t.name } else { &t.fonts.name }));
|
||||
font_set(&mut w, "a:majorFont", &t.fonts.major);
|
||||
font_set(&mut w, "a:minorFont", &t.fonts.minor);
|
||||
w.close("a:fontScheme");
|
||||
let d = default_format();
|
||||
let f = &t.format;
|
||||
w.open("a:fmtScheme", A::new().a("name", if f.name.is_empty() { &t.name } else { &f.name }));
|
||||
let three = |v: &[Fill], d: &[Fill]| -> Vec<Fill> {
|
||||
let mut out: Vec<Fill> = v.iter().map(style_fill).collect();
|
||||
while out.len() < 3 {
|
||||
out.push(d.get(out.len()).cloned().unwrap_or(Fill::solid(ColorRef::scheme(SchemeSlot::PhClr))));
|
||||
}
|
||||
out
|
||||
};
|
||||
w.open0("a:fillStyleLst");
|
||||
for fl in three(&f.fills, &d.fills) {
|
||||
dml::fill(&mut w, x, o, &fl);
|
||||
}
|
||||
w.close("a:fillStyleLst");
|
||||
w.open0("a:lnStyleLst");
|
||||
let mut lines = f.lines.clone();
|
||||
while lines.len() < 3 {
|
||||
lines.push(d.lines.get(lines.len()).cloned().unwrap_or_default());
|
||||
}
|
||||
for l in &lines {
|
||||
let mut l = l.clone();
|
||||
if l.fill.is_none() {
|
||||
l.fill = Some(Fill::solid(ColorRef::scheme(SchemeSlot::PhClr)));
|
||||
}
|
||||
if let Some(fl) = &l.fill {
|
||||
l.fill = Some(style_fill(fl));
|
||||
}
|
||||
dml::line(&mut w, x, o, "a:ln", &l);
|
||||
}
|
||||
w.close("a:lnStyleLst");
|
||||
w.open0("a:effectStyleLst");
|
||||
let mut fx = f.effects.clone();
|
||||
while fx.len() < 3 {
|
||||
fx.push(Effects::default());
|
||||
}
|
||||
for e in &fx {
|
||||
w.open0("a:effectStyle");
|
||||
dml::effects(&mut w, e);
|
||||
if let Some(raw) = &e.raw3d {
|
||||
w.raw(raw);
|
||||
} else if let Some(xml) = e.bevel.as_deref().and_then(dml::bevel_sp3d) {
|
||||
w.raw(&xml);
|
||||
}
|
||||
w.close("a:effectStyle");
|
||||
}
|
||||
w.close("a:effectStyleLst");
|
||||
w.open0("a:bgFillStyleLst");
|
||||
for fl in three(&f.bg_fills, &d.bg_fills) {
|
||||
dml::fill(&mut w, x, o, &fl);
|
||||
}
|
||||
w.close("a:bgFillStyleLst");
|
||||
w.close("a:fmtScheme");
|
||||
w.close("a:themeElements");
|
||||
match &t.raw_extra {
|
||||
Some(raw) if raw.contains("objectDefaults") => w.raw(raw),
|
||||
Some(raw) => {
|
||||
w.empty0("a:objectDefaults");
|
||||
w.raw(raw);
|
||||
}
|
||||
None => {
|
||||
w.empty0("a:objectDefaults");
|
||||
w.empty0("a:extraClrSchemeLst");
|
||||
}
|
||||
}
|
||||
w.close("a:theme");
|
||||
w.finish()
|
||||
}
|
||||
@@ -1,830 +0,0 @@
|
||||
//! Transitions and the animation timing tree.
|
||||
|
||||
use deckcraft_model::anim::{AnimClass, AnimStart, Animation, BuildRole, TextBuild, Transition, build_filled, paragraph_build_roles};
|
||||
use deckcraft_model::{Shape, ShapeId, ShapeKind};
|
||||
|
||||
use super::shapes::IdMap;
|
||||
use super::{Exp, Out};
|
||||
use crate::opc::{NS_MC, NS_P14, NS_P15, NS_P159};
|
||||
use crate::xml::{A, W};
|
||||
|
||||
pub fn transition(w: &mut W, x: &mut Exp, o: &mut Out, t: &Transition) {
|
||||
let adv_click = (!t.advance_on_click).then_some("0");
|
||||
let adv_tm = t.advance_after_ms.map(|v| v.min(86_400_000));
|
||||
let spd = match t.duration_ms {
|
||||
0..=600 => "fast",
|
||||
601..=900 => "med",
|
||||
_ => "slow",
|
||||
};
|
||||
let sound = t.sound.and_then(|m| x.media_rel(o, m, "audio").map(|r| (r, x.media(m).map(|i| i.name.clone()).unwrap_or_default())));
|
||||
let snd = |w: &mut W| {
|
||||
if let Some((r, name)) = &sound {
|
||||
w.open0("p:sndAc");
|
||||
w.open("p:stSnd", A::new().t("loop", t.sound_loop));
|
||||
let name = if name.is_empty() { "sound.wav" } else { name.as_str() };
|
||||
w.empty("p:snd", A::new().a("r:embed", r).a("name", name));
|
||||
w.close("p:stSnd");
|
||||
w.close("p:sndAc");
|
||||
} else if t.stop_sound {
|
||||
w.open0("p:sndAc");
|
||||
w.empty0("p:endSnd");
|
||||
w.close("p:sndAc");
|
||||
}
|
||||
};
|
||||
let mut effect = W::frag();
|
||||
let ns = if t.kind == "none" { Some("p") } else { super::super::maps::transition_to_xml(&mut effect, &t.kind, &t.option) };
|
||||
let ns = match ns {
|
||||
Some(ns) => ns,
|
||||
None => {
|
||||
// Unknown kind: write the kept element if there is one, else a fade.
|
||||
if let Some(raw) = &t.raw
|
||||
&& let Ok(d) = crate::xml::parse(raw.as_bytes())
|
||||
&& let Some(e) = d.root.elements().find(|e| !matches!(e.local(), "sndAc" | "extLst"))
|
||||
&& !crate::read::has_rel_refs(e)
|
||||
{
|
||||
let prefix = e.prefix().to_string();
|
||||
let mut ns_decl = d.ns_decls();
|
||||
ns_decl.retain(|(k, _)| k == &format!("xmlns:{prefix}"));
|
||||
let mut e2 = e.clone();
|
||||
for (k, v) in ns_decl {
|
||||
e2.attrs.push((k, v));
|
||||
}
|
||||
effect.raw(&e2.to_xml());
|
||||
match prefix.as_str() {
|
||||
"p14" => "p14",
|
||||
"p15" => "p15",
|
||||
"p159" => "p159",
|
||||
"p" => "p",
|
||||
_ => {
|
||||
effect = W::frag();
|
||||
effect.empty0("p:fade");
|
||||
"p"
|
||||
}
|
||||
}
|
||||
} else {
|
||||
effect.empty0("p:fade");
|
||||
"p"
|
||||
}
|
||||
}
|
||||
};
|
||||
let is_none = t.kind == "none";
|
||||
let dur = t.duration_ms.min(60_000);
|
||||
w.open("mc:AlternateContent", A::new().a("xmlns:mc", NS_MC));
|
||||
let mut ch = A::new().a("xmlns:p14", NS_P14);
|
||||
let req = match ns {
|
||||
"p15" => {
|
||||
ch = ch.a("xmlns:p15", NS_P15);
|
||||
"p15"
|
||||
}
|
||||
"p159" => {
|
||||
ch = ch.a("xmlns:p159", NS_P159);
|
||||
"p159"
|
||||
}
|
||||
_ => "p14",
|
||||
};
|
||||
w.open("mc:Choice", ch.a("Requires", req));
|
||||
w.open("p:transition", A::new().a("spd", spd).o("p14:dur", (!is_none).then_some(dur)).o("advClick", adv_click).o("advTm", adv_tm));
|
||||
if !is_none {
|
||||
w.raw(&effect.s);
|
||||
}
|
||||
snd(w);
|
||||
w.close("p:transition");
|
||||
w.close("mc:Choice");
|
||||
w.open0("mc:Fallback");
|
||||
w.open("p:transition", A::new().a("spd", spd).o("advClick", adv_click).o("advTm", adv_tm));
|
||||
if !is_none {
|
||||
if ns == "p" {
|
||||
w.raw(&effect.s);
|
||||
} else {
|
||||
w.empty0("p:fade");
|
||||
}
|
||||
}
|
||||
snd(w);
|
||||
w.close("p:transition");
|
||||
w.close("mc:Fallback");
|
||||
w.close("mc:AlternateContent");
|
||||
}
|
||||
|
||||
/// One effect to write (an animation, or one paragraph of a by-paragraph build).
|
||||
struct Eff<'a> {
|
||||
a: &'a Animation,
|
||||
spid: u32,
|
||||
start: AnimStart,
|
||||
paragraph: Option<u32>,
|
||||
grp: u32,
|
||||
}
|
||||
|
||||
struct Ids(u32);
|
||||
|
||||
impl Ids {
|
||||
fn next(&mut self) -> u32 {
|
||||
self.0 = self.0.saturating_add(1);
|
||||
self.0
|
||||
}
|
||||
}
|
||||
|
||||
fn tgt(w: &mut W, spid: u32, para: Option<u32>) {
|
||||
w.open0("p:tgtEl");
|
||||
match para {
|
||||
Some(p) => {
|
||||
w.open("p:spTgt", A::new().a("spid", spid));
|
||||
w.open0("p:txEl");
|
||||
w.empty("p:pRg", A::new().a("st", p).a("end", p));
|
||||
w.close("p:txEl");
|
||||
w.close("p:spTgt");
|
||||
}
|
||||
None => w.empty("p:spTgt", A::new().a("spid", spid)),
|
||||
}
|
||||
w.close("p:tgtEl");
|
||||
}
|
||||
|
||||
fn cbhvr(w: &mut W, ids: &mut Ids, e: &Eff, dur: u32, delay: Option<u32>, attrs: &[&str], additive: Option<&str>) {
|
||||
w.open("p:cBhvr", A::new().o("additive", additive));
|
||||
let a = A::new().a("id", ids.next()).a("dur", dur.max(1)).a("fill", "hold");
|
||||
match delay {
|
||||
Some(d) => {
|
||||
w.open("p:cTn", a);
|
||||
w.open0("p:stCondLst");
|
||||
w.empty("p:cond", A::new().a("delay", d));
|
||||
w.close("p:stCondLst");
|
||||
w.close("p:cTn");
|
||||
}
|
||||
None => w.empty("p:cTn", a),
|
||||
}
|
||||
tgt(w, e.spid, e.paragraph);
|
||||
if !attrs.is_empty() {
|
||||
w.open0("p:attrNameLst");
|
||||
for n in attrs {
|
||||
w.elt("p:attrName", n);
|
||||
}
|
||||
w.close("p:attrNameLst");
|
||||
}
|
||||
w.close("p:cBhvr");
|
||||
}
|
||||
|
||||
fn set_vis(w: &mut W, ids: &mut Ids, e: &Eff, delay: u32, visible: bool) {
|
||||
w.open0("p:set");
|
||||
cbhvr(w, ids, e, 1, Some(delay), &["style.visibility"], None);
|
||||
w.open0("p:to");
|
||||
w.val("p:strVal", if visible { "visible" } else { "hidden" });
|
||||
w.close("p:to");
|
||||
w.close("p:set");
|
||||
}
|
||||
|
||||
fn anim_effect(w: &mut W, ids: &mut Ids, e: &Eff, dur: u32, filter: &str, out: bool) {
|
||||
w.open("p:animEffect", A::new().a("transition", if out { "out" } else { "in" }).a("filter", filter));
|
||||
cbhvr(w, ids, e, dur, None, &[], None);
|
||||
w.close("p:animEffect");
|
||||
}
|
||||
|
||||
fn anim_prop(w: &mut W, ids: &mut Ids, e: &Eff, dur: u32, attr: &str, from: &str, to: &str) {
|
||||
w.open("p:anim", A::new().a("calcmode", "lin").a("valueType", "num"));
|
||||
cbhvr(w, ids, e, dur, None, &[attr], Some("base"));
|
||||
w.open0("p:tavLst");
|
||||
for (tm, v) in [(0, from), (100_000, to)] {
|
||||
w.open("p:tav", A::new().a("tm", tm));
|
||||
w.open0("p:val");
|
||||
w.val("p:strVal", v);
|
||||
w.close("p:val");
|
||||
w.close("p:tav");
|
||||
}
|
||||
w.close("p:tavLst");
|
||||
w.close("p:anim");
|
||||
}
|
||||
|
||||
fn filter_for(effect: &str, option: &str) -> &'static str {
|
||||
match effect {
|
||||
"wipe" | "wipeOut" => match option {
|
||||
"t" => "wipe(down)",
|
||||
"l" => "wipe(right)",
|
||||
"r" => "wipe(left)",
|
||||
_ => "wipe(up)",
|
||||
},
|
||||
"split" | "splitOut" => match option {
|
||||
"horzOut" => "barn(outHorizontal)",
|
||||
"vertIn" => "barn(inVertical)",
|
||||
"vertOut" => "barn(outVertical)",
|
||||
_ => "barn(inHorizontal)",
|
||||
},
|
||||
"randomBars" | "randomBarsOut" => {
|
||||
if option == "vert" {
|
||||
"randombar(vertical)"
|
||||
} else {
|
||||
"randombar(horizontal)"
|
||||
}
|
||||
}
|
||||
"blinds" | "blindsOut" => {
|
||||
if option == "vert" {
|
||||
"blinds(vertical)"
|
||||
} else {
|
||||
"blinds(horizontal)"
|
||||
}
|
||||
}
|
||||
"box" | "boxOut" => {
|
||||
if option == "out" {
|
||||
"box(out)"
|
||||
} else {
|
||||
"box(in)"
|
||||
}
|
||||
}
|
||||
"circle" => {
|
||||
if option == "out" {
|
||||
"circle(out)"
|
||||
} else {
|
||||
"circle(in)"
|
||||
}
|
||||
}
|
||||
"diamond" | "diamondOut" => {
|
||||
if option == "out" {
|
||||
"diamond(out)"
|
||||
} else {
|
||||
"diamond(in)"
|
||||
}
|
||||
}
|
||||
"shape" | "shapeOut" => match option {
|
||||
"circleOut" => "circle(out)",
|
||||
"boxIn" => "box(in)",
|
||||
"boxOut" => "box(out)",
|
||||
"diamondIn" => "diamond(in)",
|
||||
"diamondOut" => "diamond(out)",
|
||||
"plusIn" => "plus(in)",
|
||||
"plusOut" => "plus(out)",
|
||||
_ => "circle(in)",
|
||||
},
|
||||
"checkerboard" | "checkerboardOut" => {
|
||||
if option == "down" {
|
||||
"checkerboard(down)"
|
||||
} else {
|
||||
"checkerboard(across)"
|
||||
}
|
||||
}
|
||||
"dissolve" | "dissolveOut" => "dissolve",
|
||||
"wheel" | "wheelOut" => match option {
|
||||
"2" => "wheel(2)",
|
||||
"3" => "wheel(3)",
|
||||
"4" => "wheel(4)",
|
||||
"8" => "wheel(8)",
|
||||
_ => "wheel(1)",
|
||||
},
|
||||
"strips" | "stripsOut" => match option {
|
||||
"ru" => "strips(upRight)",
|
||||
"ld" => "strips(downLeft)",
|
||||
"rd" => "strips(downRight)",
|
||||
_ => "strips(upLeft)",
|
||||
},
|
||||
"peek" | "peekOut" => match option {
|
||||
"t" => "slide(fromTop)",
|
||||
"l" => "slide(fromLeft)",
|
||||
"r" => "slide(fromRight)",
|
||||
_ => "slide(fromBottom)",
|
||||
},
|
||||
_ => "fade",
|
||||
}
|
||||
}
|
||||
|
||||
fn fly_from(option: &str) -> (&'static str, &'static str) {
|
||||
let x = if option.contains('l') {
|
||||
"0-#ppt_w/2"
|
||||
} else if option.contains('r') {
|
||||
"1+#ppt_w/2"
|
||||
} else {
|
||||
"#ppt_x"
|
||||
};
|
||||
let y = if option.contains('t') {
|
||||
"0-#ppt_h/2"
|
||||
} else if option.contains('b') || option.is_empty() {
|
||||
"1+#ppt_h/2"
|
||||
} else {
|
||||
"#ppt_y"
|
||||
};
|
||||
(x, y)
|
||||
}
|
||||
|
||||
fn behaviors(w: &mut W, x: &mut Exp, ids: &mut Ids, e: &Eff) {
|
||||
let a = e.a;
|
||||
let dur = a.duration_ms.clamp(1, 3_600_000);
|
||||
match a.class {
|
||||
AnimClass::Entrance => {
|
||||
set_vis(w, ids, e, 0, true);
|
||||
match a.effect.as_str() {
|
||||
"appear" => {}
|
||||
"fly" => {
|
||||
let (fx, fy) = fly_from(&a.option);
|
||||
anim_prop(w, ids, e, dur, "ppt_x", fx, "#ppt_x");
|
||||
anim_prop(w, ids, e, dur, "ppt_y", fy, "#ppt_y");
|
||||
}
|
||||
"zoom" | "grow" | "expand" | "spinner" => {
|
||||
anim_prop(w, ids, e, dur, "ppt_w", "0", "#ppt_w");
|
||||
anim_prop(w, ids, e, dur, "ppt_h", "0", "#ppt_h");
|
||||
anim_effect(w, ids, e, dur, "fade", false);
|
||||
}
|
||||
"float" | "rise" => {
|
||||
anim_prop(w, ids, e, dur, "ppt_y", if a.option == "d" { "#ppt_y-.1" } else { "#ppt_y+.1" }, "#ppt_y");
|
||||
anim_effect(w, ids, e, dur, "fade", false);
|
||||
}
|
||||
other => anim_effect(w, ids, e, dur, filter_for(other, &a.option), false),
|
||||
}
|
||||
}
|
||||
AnimClass::Exit => {
|
||||
match a.effect.as_str() {
|
||||
"disappear" => {}
|
||||
"flyOut" => {
|
||||
let (fx, fy) = fly_from(&a.option);
|
||||
anim_prop(w, ids, e, dur, "ppt_x", "#ppt_x", fx);
|
||||
anim_prop(w, ids, e, dur, "ppt_y", "#ppt_y", fy);
|
||||
}
|
||||
"floatOut" | "sinkDown" => {
|
||||
let to = if a.effect == "sinkDown" || a.option == "d" { "#ppt_y+.1" } else { "#ppt_y-.1" };
|
||||
anim_prop(w, ids, e, dur, "ppt_y", "#ppt_y", to);
|
||||
anim_effect(w, ids, e, dur, "fade", true);
|
||||
}
|
||||
"zoomOut" | "shrinkTurn" | "spinnerOut" | "contract" => {
|
||||
anim_prop(w, ids, e, dur, "ppt_w", "#ppt_w", "0");
|
||||
anim_prop(w, ids, e, dur, "ppt_h", "#ppt_h", "0");
|
||||
anim_effect(w, ids, e, dur, "fade", true);
|
||||
}
|
||||
other => anim_effect(w, ids, e, dur, filter_for(other, &a.option), true),
|
||||
}
|
||||
set_vis(w, ids, e, if a.effect == "disappear" { 0 } else { dur.saturating_sub(1) }, false);
|
||||
}
|
||||
AnimClass::Emphasis => match a.effect.as_str() {
|
||||
"spin" | "teeter" => {
|
||||
let deg = a.amount.unwrap_or(if a.effect == "teeter" { 4.0 } else { 360.0 });
|
||||
let deg = if a.option == "counterClockwise" { -deg.abs() } else { deg };
|
||||
let by = (deg.clamp(-36_000.0, 36_000.0) * 60_000.0).round() as i64;
|
||||
w.open("p:animRot", A::new().a("by", by));
|
||||
cbhvr(w, ids, e, dur, None, &["r"], None);
|
||||
w.close("p:animRot");
|
||||
}
|
||||
"transparency" => {
|
||||
w.open0("p:set");
|
||||
cbhvr(w, ids, e, dur, None, &["style.opacity"], None);
|
||||
w.open0("p:to");
|
||||
w.val("p:strVal", format!("{:.2}", (1.0 - a.amount.unwrap_or(0.5)).clamp(0.0, 1.0)));
|
||||
w.close("p:to");
|
||||
w.close("p:set");
|
||||
}
|
||||
"colorPulse" => {
|
||||
// As PowerPoint writes it: text and fill go to the colour and back (autoRev). The behaviour
|
||||
// duration is the one import reads as the effect duration.
|
||||
let c = a.color.clone().unwrap_or(deckcraft_model::ColorRef::rgb(deckcraft_color::Rgba::rgb(0xC0, 0x00, 0x00)));
|
||||
for (attr, child) in [("style.color", true), ("fillcolor", false)] {
|
||||
w.open("p:animClr", A::new().a("clrSpc", "rgb").a("dir", "cw"));
|
||||
w.open("p:cBhvr", A::new().o("override", child.then_some("childStyle")));
|
||||
w.empty("p:cTn", A::new().a("id", ids.next()).a("dur", dur.max(1)).a("autoRev", "1").a("fill", "remove"));
|
||||
tgt(w, e.spid, e.paragraph);
|
||||
w.open0("p:attrNameLst");
|
||||
w.elt("p:attrName", attr);
|
||||
w.close("p:attrNameLst");
|
||||
w.close("p:cBhvr");
|
||||
w.open0("p:to");
|
||||
super::dml::color(w, &c);
|
||||
w.close("p:to");
|
||||
w.close("p:animClr");
|
||||
}
|
||||
}
|
||||
// As PowerPoint writes them: a relative HSL shift of text, fill and line colour.
|
||||
"darken" | "desaturate" => {
|
||||
let (s, l) = if a.effect == "darken" { (0, -25_098) } else { (-70_588, 0) };
|
||||
for attr in ["style.color", "fillcolor", "stroke.color"] {
|
||||
w.open("p:animClr", A::new().a("clrSpc", "hsl").a("dir", "cw"));
|
||||
cbhvr(w, ids, e, dur, None, &[attr], None);
|
||||
w.open0("p:by");
|
||||
w.empty("p:hsl", A::new().a("h", 0).a("s", s).a("l", l));
|
||||
w.close("p:by");
|
||||
w.close("p:animClr");
|
||||
}
|
||||
}
|
||||
"fillColor" | "objectColor" | "fontColor" | "lineColor" | "complementaryColor" | "lighten" => {
|
||||
let attr = match a.effect.as_str() {
|
||||
"fontColor" => "style.color",
|
||||
"lineColor" => "stroke.color",
|
||||
_ => "fillcolor",
|
||||
};
|
||||
let c = a.color.clone().unwrap_or(deckcraft_model::ColorRef::scheme(deckcraft_color::SchemeSlot::Accent2));
|
||||
w.open("p:animClr", A::new().a("clrSpc", "rgb").a("dir", "cw"));
|
||||
cbhvr(w, ids, e, dur, None, &[attr], None);
|
||||
w.open0("p:to");
|
||||
super::dml::color(w, &c);
|
||||
w.close("p:to");
|
||||
w.close("p:animClr");
|
||||
}
|
||||
_ => {
|
||||
let s = a.amount.filter(|v| v.is_finite() && *v > 0.0).unwrap_or(if a.effect == "growShrink" { 1.5 } else { 1.1 });
|
||||
let (sx, sy) = match a.option.as_str() {
|
||||
"horz" => (s, 1.0),
|
||||
"vert" => (1.0, s),
|
||||
_ => (s, s),
|
||||
};
|
||||
w.open0("p:animScale");
|
||||
cbhvr(w, ids, e, dur, None, &[], None);
|
||||
w.empty(
|
||||
"p:by",
|
||||
A::new().a("x", (sx.clamp(0.01, 100.0) * 100_000.0).round() as i64).a("y", (sy.clamp(0.01, 100.0) * 100_000.0).round() as i64),
|
||||
);
|
||||
w.close("p:animScale");
|
||||
}
|
||||
},
|
||||
AnimClass::Path => {
|
||||
let path = a
|
||||
.path
|
||||
.clone()
|
||||
.filter(|p| !p.trim().is_empty() && p.chars().all(|c| c.is_ascii() && c != '"' && c != '<' && c != '&'))
|
||||
.unwrap_or_else(|| {
|
||||
match a.option.as_str() {
|
||||
"up" => "M 0 0 L 0 -0.25 E",
|
||||
"right" => "M 0 0 L 0.25 0 E",
|
||||
"left" => "M 0 0 L -0.25 0 E",
|
||||
_ => "M 0 0 L 0 0.25 E",
|
||||
}
|
||||
.to_string()
|
||||
});
|
||||
w.open("p:animMotion", A::new().a("origin", "layout").a("path", path).a("pathEditMode", "relative").a("ptsTypes", ""));
|
||||
cbhvr(w, ids, e, dur, None, &["ppt_x", "ppt_y"], None);
|
||||
w.close("p:animMotion");
|
||||
}
|
||||
AnimClass::Media => {
|
||||
let cmd = match a.effect.as_str() {
|
||||
"pause" => "togglePause",
|
||||
"stop" => "stop",
|
||||
_ => "playFrom(0.0)",
|
||||
};
|
||||
w.open("p:cmd", A::new().a("type", "call").a("cmd", cmd));
|
||||
cbhvr(w, ids, e, 1, None, &[], None);
|
||||
w.close("p:cmd");
|
||||
}
|
||||
}
|
||||
let _ = x;
|
||||
}
|
||||
|
||||
fn effect_par(w: &mut W, x: &mut Exp, ids: &mut Ids, e: &Eff, first_in_click: bool) {
|
||||
let a = e.a;
|
||||
let node = match e.start {
|
||||
AnimStart::OnClick => "clickEffect",
|
||||
AnimStart::WithPrevious => "withEffect",
|
||||
AnimStart::AfterPrevious => "afterEffect",
|
||||
};
|
||||
let _ = first_in_click;
|
||||
let preset = crate::maps::preset_for(a);
|
||||
let sub = if preset == 47 {
|
||||
0
|
||||
} else {
|
||||
crate::maps::subtype_from_option(&a.effect, &a.option).or(a.preset_subtype.filter(|_| a.preset_id == Some(preset))).unwrap_or(0)
|
||||
};
|
||||
let repeat = match a.repeat {
|
||||
u32::MAX => Some("indefinite".to_string()),
|
||||
0 | 1 => None,
|
||||
n => Some((n.min(10_000) * 1000).to_string()),
|
||||
};
|
||||
let accel = (a.smooth_start > 0.0).then(|| (a.smooth_start.clamp(0.0, 1.0) * 100_000.0).round() as i64);
|
||||
let decel = (a.smooth_end > 0.0).then(|| (a.smooth_end.clamp(0.0, 1.0) * 100_000.0).round() as i64);
|
||||
// `bounceEnd` is a positive percentage (100000 = 100%), same scale as accel/decel. The model stores 0–1.
|
||||
let bounce =
|
||||
(a.bounce_end.is_finite() && a.bounce_end > 0.0).then(|| (a.bounce_end.clamp(0.0, 1.0) * 100_000.0).round() as i64).filter(|n| *n > 0);
|
||||
w.open0("p:par");
|
||||
w.open(
|
||||
"p:cTn",
|
||||
A::new()
|
||||
.a("id", ids.next())
|
||||
.a("presetID", preset)
|
||||
.a("presetClass", a.class.xml())
|
||||
.a("presetSubtype", sub)
|
||||
.o("repeatCount", repeat)
|
||||
.o("accel", accel)
|
||||
.o("decel", decel)
|
||||
.o("bounceEnd", bounce)
|
||||
.t("autoRev", a.auto_reverse)
|
||||
.a("fill", if a.rewind { "remove" } else { "hold" })
|
||||
.a("grpId", e.grp)
|
||||
.a("nodeType", node),
|
||||
);
|
||||
w.open0("p:stCondLst");
|
||||
w.empty("p:cond", A::new().a("delay", a.delay_ms.min(3_600_000)));
|
||||
w.close("p:stCondLst");
|
||||
w.open0("p:childTnLst");
|
||||
behaviors(w, x, ids, e);
|
||||
w.close("p:childTnLst");
|
||||
w.close("p:cTn");
|
||||
w.close("p:par");
|
||||
}
|
||||
|
||||
fn end_time(e: &Eff) -> u32 {
|
||||
let rep = match e.a.repeat {
|
||||
0 | 1 => 1,
|
||||
u32::MAX => 1,
|
||||
n => n.min(100),
|
||||
};
|
||||
e.a.delay_ms.saturating_add(e.a.duration_ms.saturating_mul(rep)).min(3_600_000)
|
||||
}
|
||||
|
||||
/// click groups → after-groups → effects
|
||||
type Groups<'a> = Vec<(bool, Vec<Vec<Eff<'a>>>)>;
|
||||
|
||||
fn group<'a>(effects: Vec<Eff<'a>>) -> Groups<'a> {
|
||||
let mut clicks: Groups = vec![];
|
||||
for e in effects {
|
||||
match e.start {
|
||||
AnimStart::OnClick => clicks.push((false, vec![vec![e]])),
|
||||
AnimStart::WithPrevious => match clicks.last_mut().and_then(|c| c.1.last_mut()) {
|
||||
Some(g) => g.push(e),
|
||||
None => clicks.push((true, vec![vec![e]])),
|
||||
},
|
||||
AnimStart::AfterPrevious => match clicks.last_mut() {
|
||||
Some(c) => c.1.push(vec![e]),
|
||||
None => clicks.push((true, vec![vec![e]])),
|
||||
},
|
||||
}
|
||||
}
|
||||
clicks
|
||||
}
|
||||
|
||||
fn click_pars(w: &mut W, x: &mut Exp, ids: &mut Ids, clicks: &Groups, interactive: bool) {
|
||||
for (ci, (auto, afters)) in clicks.iter().enumerate() {
|
||||
w.open0("p:par");
|
||||
w.open("p:cTn", A::new().a("id", ids.next()).a("fill", "hold"));
|
||||
w.open0("p:stCondLst");
|
||||
if interactive && ci == 0 {
|
||||
w.empty("p:cond", A::new().a("delay", 0));
|
||||
} else {
|
||||
w.empty("p:cond", A::new().a("delay", "indefinite"));
|
||||
if *auto {
|
||||
w.open("p:cond", A::new().a("evt", "onBegin").a("delay", 0));
|
||||
w.val("p:tn", 2);
|
||||
w.close("p:cond");
|
||||
}
|
||||
}
|
||||
w.close("p:stCondLst");
|
||||
w.open0("p:childTnLst");
|
||||
let mut t = 0u32;
|
||||
for g in afters {
|
||||
w.open0("p:par");
|
||||
w.open("p:cTn", A::new().a("id", ids.next()).a("fill", "hold"));
|
||||
w.open0("p:stCondLst");
|
||||
w.empty("p:cond", A::new().a("delay", t));
|
||||
w.close("p:stCondLst");
|
||||
w.open0("p:childTnLst");
|
||||
for (i, e) in g.iter().enumerate() {
|
||||
effect_par(w, x, ids, e, i == 0);
|
||||
}
|
||||
w.close("p:childTnLst");
|
||||
w.close("p:cTn");
|
||||
w.close("p:par");
|
||||
t = t.saturating_add(g.iter().map(end_time).max().unwrap_or(0));
|
||||
}
|
||||
w.close("p:childTnLst");
|
||||
w.close("p:cTn");
|
||||
w.close("p:par");
|
||||
}
|
||||
}
|
||||
|
||||
/// Most effects one slide's timing writes; animations past it are left out.
|
||||
const MAX_EFFECTS: usize = 100_000;
|
||||
|
||||
/// The shapes of the tree by id, the first in document order for a repeated id (as `find_shape`
|
||||
/// finds it), so each animation resolves its shape without a tree walk.
|
||||
fn shape_index<'a>(shapes: &'a [Shape], depth: usize, out: &mut std::collections::HashMap<ShapeId, &'a Shape>) {
|
||||
if depth > 64 {
|
||||
return;
|
||||
}
|
||||
for s in shapes {
|
||||
out.entry(s.id).or_insert(s);
|
||||
shape_index(s.children(), depth + 1, out);
|
||||
}
|
||||
}
|
||||
|
||||
/// Write `p:timing` for a slide's animations and media settings.
|
||||
pub fn timing(w: &mut W, x: &mut Exp, anims: &[Animation], shapes: &[Shape], idmap: &IdMap) {
|
||||
let mut grp_count: std::collections::HashMap<u32, u32> = Default::default();
|
||||
let mut main: Vec<Eff> = vec![];
|
||||
let mut triggered: Vec<(u32, Vec<Eff>)> = vec![];
|
||||
let mut bld: Vec<(u32, u32, bool)> = vec![];
|
||||
// The last paragraph effect written: (shape, class, trigger, grpId).
|
||||
let mut prev_para: Option<(ShapeId, AnimClass, Option<ShapeId>, u32)> = None;
|
||||
let mut by_id = std::collections::HashMap::new();
|
||||
shape_index(shapes, 0, &mut by_id);
|
||||
let mut roles_of: std::collections::HashMap<ShapeId, Vec<BuildRole>> = Default::default();
|
||||
let mut effect_count = 0usize;
|
||||
let mut warned = false;
|
||||
for a in anims.iter().take(10_000) {
|
||||
if effect_count >= MAX_EFFECTS {
|
||||
if !warned {
|
||||
log::warn!("pptx: more than {MAX_EFFECTS} animation effects; the rest are left out");
|
||||
}
|
||||
break;
|
||||
}
|
||||
let Some(spid) = idmap.get(a.shape) else {
|
||||
log::warn!("pptx: animation on missing shape {} skipped", a.shape);
|
||||
continue;
|
||||
};
|
||||
let Some(&shape) = by_id.get(&a.shape) else { continue };
|
||||
let text_sp = matches!(shape.kind, ShapeKind::Shape) && shape.text.is_some();
|
||||
let is_text_sp = matches!(shape.kind, ShapeKind::Shape) && shape.text.as_ref().is_some_and(|t| !t.is_empty());
|
||||
let text = shape.text.as_ref().filter(|_| a.text_build == TextBuild::ByParagraph && is_text_sp);
|
||||
let no_roles = Vec::new();
|
||||
let roles = match text {
|
||||
Some(t) => roles_of.entry(a.shape).or_insert_with(|| paragraph_build_roles(t)),
|
||||
None => &no_roles,
|
||||
};
|
||||
let by_para = roles.contains(&BuildRole::Top);
|
||||
// PowerPoint keeps a shape's consecutive paragraph effects in one build (`grpId`) marked
|
||||
// `build="p"`; the reader turns them back into a by-paragraph build only if that plays them
|
||||
// the same way.
|
||||
let para_effect = !by_para && text_sp && a.paragraph.is_some();
|
||||
let joins = para_effect && prev_para.is_some_and(|(s, c, t, _)| s == a.shape && c == a.class && t == a.trigger);
|
||||
let grp = match prev_para {
|
||||
Some((.., g)) if joins => g,
|
||||
_ => {
|
||||
let c = grp_count.entry(spid).or_insert(0);
|
||||
let g = *c;
|
||||
*c += 1;
|
||||
g
|
||||
}
|
||||
};
|
||||
prev_para = para_effect.then_some((a.shape, a.class, a.trigger, grp));
|
||||
let mut effs = vec![];
|
||||
if by_para {
|
||||
// One effect per paragraph the build animates on its own, deeper ones with their
|
||||
// parent; indices in the file count empty paragraphs too.
|
||||
let mut tops = 0;
|
||||
for (i, role) in roles.iter().enumerate() {
|
||||
let start = match role {
|
||||
BuildRole::Top => {
|
||||
tops += 1;
|
||||
if tops == 1 {
|
||||
a.start
|
||||
} else if a.start == AnimStart::OnClick {
|
||||
AnimStart::OnClick
|
||||
} else {
|
||||
AnimStart::AfterPrevious
|
||||
}
|
||||
}
|
||||
BuildRole::Member(_) if text.and_then(|t| t.paragraphs.get(i)).is_some_and(build_filled) => AnimStart::WithPrevious,
|
||||
_ => continue,
|
||||
};
|
||||
let Ok(pi) = u32::try_from(i) else { break };
|
||||
if effect_count + effs.len() >= MAX_EFFECTS {
|
||||
if !warned {
|
||||
log::warn!("pptx: more than {MAX_EFFECTS} animation effects; the rest are left out");
|
||||
warned = true;
|
||||
}
|
||||
break;
|
||||
}
|
||||
effs.push(Eff { a, spid, start, paragraph: Some(pi), grp });
|
||||
}
|
||||
} else {
|
||||
effs.push(Eff { a, spid, start: a.start, paragraph: a.paragraph, grp });
|
||||
}
|
||||
effect_count += effs.len();
|
||||
if text_sp && !joins {
|
||||
bld.push((spid, grp, by_para || para_effect));
|
||||
}
|
||||
match a.trigger.and_then(|t| idmap.get(t)) {
|
||||
Some(t) => match triggered.iter_mut().find(|(s, _)| *s == t) {
|
||||
Some((_, v)) => v.extend(effs),
|
||||
None => triggered.push((t, effs)),
|
||||
},
|
||||
None => main.extend(effs),
|
||||
}
|
||||
}
|
||||
let media = collect_media(shapes, idmap);
|
||||
if main.is_empty() && triggered.is_empty() && media.is_empty() {
|
||||
return;
|
||||
}
|
||||
let mut ids = Ids(0);
|
||||
w.open0("p:timing");
|
||||
w.open0("p:tnLst");
|
||||
w.open0("p:par");
|
||||
w.open("p:cTn", A::new().a("id", ids.next()).a("dur", "indefinite").a("restart", "never").a("nodeType", "tmRoot"));
|
||||
w.open0("p:childTnLst");
|
||||
if !main.is_empty() {
|
||||
let clicks = group(main);
|
||||
w.open("p:seq", A::new().a("concurrent", 1).a("nextAc", "seek"));
|
||||
w.open("p:cTn", A::new().a("id", ids.next()).a("dur", "indefinite").a("nodeType", "mainSeq"));
|
||||
w.open0("p:childTnLst");
|
||||
click_pars(w, x, &mut ids, &clicks, false);
|
||||
w.close("p:childTnLst");
|
||||
w.close("p:cTn");
|
||||
w.open0("p:prevCondLst");
|
||||
w.open("p:cond", A::new().a("evt", "onPrev").a("delay", 0));
|
||||
w.open0("p:tgtEl");
|
||||
w.empty0("p:sldTgt");
|
||||
w.close("p:tgtEl");
|
||||
w.close("p:cond");
|
||||
w.close("p:prevCondLst");
|
||||
w.open0("p:nextCondLst");
|
||||
w.open("p:cond", A::new().a("evt", "onNext").a("delay", 0));
|
||||
w.open0("p:tgtEl");
|
||||
w.empty0("p:sldTgt");
|
||||
w.close("p:tgtEl");
|
||||
w.close("p:cond");
|
||||
w.close("p:nextCondLst");
|
||||
w.close("p:seq");
|
||||
}
|
||||
for (trig, effs) in triggered {
|
||||
// The first step starts with the button's click. Later On Click effects must remain
|
||||
// separate steps; With/After Previous effects still belong to their preceding step.
|
||||
let effs: Vec<Eff> =
|
||||
effs.into_iter().enumerate().map(|(i, e)| Eff { start: if i == 0 { AnimStart::OnClick } else { e.start }, ..e }).collect();
|
||||
let clicks = group(effs);
|
||||
let trig_cond = |w: &mut W| {
|
||||
w.open("p:cond", A::new().a("evt", "onClick").a("delay", 0));
|
||||
w.open0("p:tgtEl");
|
||||
w.empty("p:spTgt", A::new().a("spid", trig));
|
||||
w.close("p:tgtEl");
|
||||
w.close("p:cond");
|
||||
};
|
||||
w.open("p:seq", A::new().a("concurrent", 1).a("nextAc", "seek"));
|
||||
w.open(
|
||||
"p:cTn",
|
||||
A::new()
|
||||
.a("id", ids.next())
|
||||
.a("restart", "whenNotActive")
|
||||
.a("fill", "hold")
|
||||
.a("evtFilter", "cancelBubble")
|
||||
.a("nodeType", "interactiveSeq"),
|
||||
);
|
||||
w.open0("p:stCondLst");
|
||||
trig_cond(w);
|
||||
w.close("p:stCondLst");
|
||||
w.open("p:endSync", A::new().a("evt", "end").a("delay", 0));
|
||||
w.empty("p:rtn", A::new().a("val", "all"));
|
||||
w.close("p:endSync");
|
||||
w.open0("p:childTnLst");
|
||||
click_pars(w, x, &mut ids, &clicks, true);
|
||||
w.close("p:childTnLst");
|
||||
w.close("p:cTn");
|
||||
w.open0("p:nextCondLst");
|
||||
trig_cond(w);
|
||||
w.close("p:nextCondLst");
|
||||
w.close("p:seq");
|
||||
}
|
||||
for (spid, clip) in &media {
|
||||
write_media_node(w, &mut ids, *spid, clip);
|
||||
}
|
||||
w.close("p:childTnLst");
|
||||
w.close("p:cTn");
|
||||
w.close("p:par");
|
||||
w.close("p:tnLst");
|
||||
if !bld.is_empty() {
|
||||
w.open0("p:bldLst");
|
||||
for (spid, grp, build_p) in bld {
|
||||
w.empty("p:bldP", A::new().a("spid", spid).a("grpId", grp).o("build", build_p.then_some("p")).t("animBg", !build_p));
|
||||
}
|
||||
w.close("p:bldLst");
|
||||
}
|
||||
w.close("p:timing");
|
||||
}
|
||||
|
||||
/// Collects media shapes on the slide that have non-default playback settings requiring a `p:video`/`p:audio` timing node.
|
||||
fn collect_media<'a>(shapes: &'a [Shape], idmap: &IdMap) -> Vec<(u32, &'a deckcraft_model::MediaClip)> {
|
||||
let mut media = Vec::new();
|
||||
deckcraft_model::walk(shapes, &mut |shape, _| {
|
||||
if let ShapeKind::Media(clip) = &shape.kind
|
||||
&& (clip.autoplay
|
||||
|| (clip.volume - 1.0).abs() > 1e-6
|
||||
|| clip.hide_while_not_playing
|
||||
|| clip.loop_play
|
||||
|| clip.rewind
|
||||
|| clip.play_across_slides
|
||||
|| (clip.video && clip.full_screen))
|
||||
&& let Some(spid) = idmap.get(shape.id)
|
||||
{
|
||||
media.push((spid, clip));
|
||||
}
|
||||
});
|
||||
media
|
||||
}
|
||||
|
||||
/// Writes a `p:video` or `p:audio` media timing node (`p:cMediaNode`) for a media shape.
|
||||
fn write_media_node(w: &mut W, ids: &mut Ids, spid: u32, clip: &deckcraft_model::MediaClip) {
|
||||
let tag = if clip.video { "p:video" } else { "p:audio" };
|
||||
w.open(tag, A::new().t("fullScrn", clip.video && clip.full_screen));
|
||||
let mut cm = A::new().a("vol", (clip.volume.clamp(0.0, 1.0) * 100_000.0).round() as u32);
|
||||
if clip.volume <= 1e-6 {
|
||||
cm = cm.t("mute", true);
|
||||
}
|
||||
if clip.hide_while_not_playing {
|
||||
cm = cm.a("showWhenStopped", 0);
|
||||
}
|
||||
if clip.play_across_slides {
|
||||
cm = cm.a("numSld", 999);
|
||||
}
|
||||
w.open("p:cMediaNode", cm);
|
||||
w.open(
|
||||
"p:cTn",
|
||||
A::new()
|
||||
.a("id", ids.next())
|
||||
.a("fill", if clip.rewind { "remove" } else { "hold" })
|
||||
.a("display", 0)
|
||||
.o("repeatCount", clip.loop_play.then_some("indefinite")),
|
||||
);
|
||||
w.open0("p:stCondLst");
|
||||
w.empty("p:cond", A::new().a("delay", if clip.autoplay { "0" } else { "indefinite" }));
|
||||
w.close("p:stCondLst");
|
||||
w.close("p:cTn");
|
||||
w.open0("p:tgtEl");
|
||||
w.empty("p:spTgt", A::new().a("spid", spid));
|
||||
w.close("p:tgtEl");
|
||||
w.close("p:cMediaNode");
|
||||
w.close(tag);
|
||||
}
|
||||
+61
-492
@@ -1,23 +1,10 @@
|
||||
//! A small, bounded XML DOM over quick-xml for reading parts, plus an escaping string builder for
|
||||
//! writing them.
|
||||
//!
|
||||
//! Reading is lenient about namespaces: elements and attributes are matched by local name, which is
|
||||
//! how real-world files are best understood (prefixes are conventional and stable in practice).
|
||||
|
||||
use std::fmt::Write as _;
|
||||
|
||||
use quick_xml::events::Event;
|
||||
//! Bounded XML DOM wrapper over [`craft_drawingml::xmlx::parse`] for callers that read kept
|
||||
//! XML fragments (such as 3-D shape settings).
|
||||
|
||||
use crate::PptxError;
|
||||
|
||||
/// Maximum element nesting accepted when parsing.
|
||||
pub const MAX_DEPTH: usize = 256;
|
||||
/// Maximum number of elements in one part.
|
||||
pub const MAX_NODES: usize = 4_000_000;
|
||||
|
||||
#[derive(Clone, Debug, Default, PartialEq)]
|
||||
pub struct El {
|
||||
/// Qualified name as written (`p:sp`).
|
||||
pub name: String,
|
||||
pub attrs: Vec<(String, String)>,
|
||||
pub children: Vec<Node>,
|
||||
@@ -30,515 +17,97 @@ pub enum Node {
|
||||
}
|
||||
|
||||
fn local_of(name: &str) -> &str {
|
||||
name.rsplit_once(':').map(|(_, l)| l).unwrap_or(name)
|
||||
name.rsplit_once(':').map_or(name, |(_, l)| l)
|
||||
}
|
||||
|
||||
impl El {
|
||||
pub fn local(&self) -> &str {
|
||||
local_of(&self.name)
|
||||
}
|
||||
|
||||
pub fn prefix(&self) -> &str {
|
||||
self.name.split_once(':').map(|(p, _)| p).unwrap_or("")
|
||||
self.name.split_once(':').map_or("", |(p, _)| p)
|
||||
}
|
||||
|
||||
pub fn is(&self, local: &str) -> bool {
|
||||
self.local() == local
|
||||
}
|
||||
/// Attribute by local name (`id` matches `id`; `r:id` matches `id` only when no plain `id`
|
||||
/// exists). Pass a qualified name (`r:id`) to require that prefix's local name with any prefix.
|
||||
|
||||
pub fn to_xml(&self) -> String {
|
||||
let mut out = String::new();
|
||||
self.write_xml(&mut out);
|
||||
out
|
||||
}
|
||||
|
||||
fn write_xml(&self, out: &mut String) {
|
||||
out.push('<');
|
||||
out.push_str(&self.name);
|
||||
for (k, v) in &self.attrs {
|
||||
out.push(' ');
|
||||
out.push_str(k);
|
||||
out.push_str("=\"");
|
||||
craft_xml::push_esc_attr(out, v);
|
||||
out.push('"');
|
||||
}
|
||||
if self.children.is_empty() {
|
||||
out.push_str("/>");
|
||||
return;
|
||||
}
|
||||
out.push('>');
|
||||
for c in &self.children {
|
||||
match c {
|
||||
Node::El(e) => e.write_xml(out),
|
||||
Node::Text(t) => craft_xml::push_esc(out, t),
|
||||
}
|
||||
}
|
||||
out.push_str("</");
|
||||
out.push_str(&self.name);
|
||||
out.push('>');
|
||||
}
|
||||
|
||||
pub fn attr(&self, name: &str) -> Option<&str> {
|
||||
if let Some((_, l)) = name.split_once(':') {
|
||||
return self.attrs.iter().find(|(k, _)| k.contains(':') && !k.starts_with("xmlns") && local_of(k) == l).map(|(_, v)| v.as_str());
|
||||
}
|
||||
self.attrs
|
||||
.iter()
|
||||
.find(|(k, _)| k == name)
|
||||
.or_else(|| self.attrs.iter().find(|(k, _)| !k.starts_with("xmlns") && local_of(k) == name))
|
||||
.map(|(_, v)| v.as_str())
|
||||
}
|
||||
pub fn has_attr(&self, name: &str) -> bool {
|
||||
self.attr(name).is_some()
|
||||
}
|
||||
pub fn set_attr(&mut self, name: &str, value: &str) {
|
||||
if let Some(a) = self.attrs.iter_mut().find(|(k, _)| k == name) {
|
||||
a.1 = value.to_string();
|
||||
} else {
|
||||
self.attrs.push((name.to_string(), value.to_string()));
|
||||
}
|
||||
}
|
||||
pub fn i64(&self, name: &str) -> Option<i64> {
|
||||
let v = self.attr(name)?.trim();
|
||||
v.parse::<i64>().ok().or_else(|| v.parse::<f64>().ok().filter(|f| f.is_finite()).map(|f| f.clamp(-9.0e18, 9.0e18) as i64))
|
||||
}
|
||||
pub fn i32(&self, name: &str) -> Option<i32> {
|
||||
self.i64(name).map(|v| v.clamp(i32::MIN as i64, i32::MAX as i64) as i32)
|
||||
}
|
||||
pub fn u32(&self, name: &str) -> Option<u32> {
|
||||
self.i64(name).map(|v| v.clamp(0, u32::MAX as i64) as u32)
|
||||
}
|
||||
pub fn f64(&self, name: &str) -> Option<f64> {
|
||||
self.attr(name)?.trim().parse::<f64>().ok().filter(|f| f.is_finite())
|
||||
}
|
||||
pub fn bool(&self, name: &str) -> Option<bool> {
|
||||
match self.attr(name)?.trim() {
|
||||
"1" | "true" | "on" => Some(true),
|
||||
"0" | "false" | "off" => Some(false),
|
||||
_ => None,
|
||||
}
|
||||
self.attrs.iter().find(|(k, _)| k == name || local_of(k) == name).map(|(_, v)| v.as_str())
|
||||
}
|
||||
|
||||
pub fn elements(&self) -> impl Iterator<Item = &El> {
|
||||
self.children.iter().filter_map(|n| match n {
|
||||
Node::El(e) => Some(e),
|
||||
Node::Text(_) => None,
|
||||
})
|
||||
}
|
||||
pub fn elements_mut(&mut self) -> impl Iterator<Item = &mut El> {
|
||||
self.children.iter_mut().filter_map(|n| match n {
|
||||
Node::El(e) => Some(e),
|
||||
Node::Text(_) => None,
|
||||
})
|
||||
}
|
||||
|
||||
pub fn child(&self, local: &str) -> Option<&El> {
|
||||
self.elements().find(|e| e.is(local))
|
||||
self.elements().find(|e| e.local() == local)
|
||||
}
|
||||
|
||||
pub fn children_named<'a>(&'a self, local: &'a str) -> impl Iterator<Item = &'a El> + 'a {
|
||||
self.elements().filter(move |e| e.is(local))
|
||||
self.elements().filter(move |e| e.local() == local)
|
||||
}
|
||||
/// Follow a chain of child local names.
|
||||
pub fn path(&self, names: &[&str]) -> Option<&El> {
|
||||
let mut cur = self;
|
||||
for n in names {
|
||||
cur = cur.child(n)?;
|
||||
}
|
||||
Some(cur)
|
||||
}
|
||||
/// First descendant (depth-first, bounded) with this local name.
|
||||
pub fn find(&self, local: &str) -> Option<&El> {
|
||||
fn rec<'a>(e: &'a El, local: &str, depth: usize) -> Option<&'a El> {
|
||||
if depth > MAX_DEPTH {
|
||||
return None;
|
||||
}
|
||||
for c in e.elements() {
|
||||
if c.is(local) {
|
||||
return Some(c);
|
||||
}
|
||||
if let Some(f) = rec(c, local, depth + 1) {
|
||||
return Some(f);
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
rec(self, local, 0)
|
||||
}
|
||||
/// All descendants with this local name (bounded depth).
|
||||
pub fn find_all<'a>(&'a self, local: &str, out: &mut Vec<&'a El>) {
|
||||
fn rec<'a>(e: &'a El, local: &str, depth: usize, out: &mut Vec<&'a El>) {
|
||||
if depth > MAX_DEPTH {
|
||||
return;
|
||||
}
|
||||
for c in e.elements() {
|
||||
if c.is(local) {
|
||||
out.push(c);
|
||||
}
|
||||
rec(c, local, depth + 1, out);
|
||||
}
|
||||
}
|
||||
rec(self, local, 0, out)
|
||||
}
|
||||
/// Concatenated text content of this element and its descendants.
|
||||
pub fn text(&self) -> String {
|
||||
let mut s = String::new();
|
||||
fn rec(e: &El, s: &mut String, depth: usize) {
|
||||
if depth > MAX_DEPTH {
|
||||
return;
|
||||
}
|
||||
for c in &e.children {
|
||||
match c {
|
||||
Node::Text(t) => s.push_str(t),
|
||||
Node::El(e) => rec(e, s, depth + 1),
|
||||
}
|
||||
}
|
||||
}
|
||||
rec(self, &mut s, 0);
|
||||
s
|
||||
}
|
||||
/// Value of `<x val="…"/>` child.
|
||||
pub fn child_val(&self, local: &str) -> Option<&str> {
|
||||
self.child(local).and_then(|c| c.attr("val"))
|
||||
}
|
||||
/// Serialize to a string (no XML declaration).
|
||||
pub fn to_xml(&self) -> String {
|
||||
let mut s = String::new();
|
||||
write_el(self, &mut s, 0);
|
||||
s
|
||||
|
||||
pub fn path(&self, path: &[&str]) -> Option<&El> {
|
||||
path.iter().try_fold(self, |cur, name| cur.child(name))
|
||||
}
|
||||
}
|
||||
|
||||
fn write_el(e: &El, s: &mut String, depth: usize) {
|
||||
if depth > MAX_DEPTH {
|
||||
return;
|
||||
}
|
||||
s.push('<');
|
||||
s.push_str(&e.name);
|
||||
for (k, v) in &e.attrs {
|
||||
let _ = write!(s, " {}=\"{}\"", k, esc_attr(v));
|
||||
}
|
||||
if e.children.is_empty() {
|
||||
s.push_str("/>");
|
||||
return;
|
||||
}
|
||||
s.push('>');
|
||||
for c in &e.children {
|
||||
match c {
|
||||
Node::Text(t) => s.push_str(&esc(t)),
|
||||
Node::El(c) => write_el(c, s, depth + 1),
|
||||
}
|
||||
}
|
||||
s.push_str("</");
|
||||
s.push_str(&e.name);
|
||||
s.push('>');
|
||||
}
|
||||
|
||||
/// A parsed document: its root element and the namespace declarations on the root.
|
||||
#[derive(Clone, Debug, Default)]
|
||||
pub struct Doc {
|
||||
pub root: El,
|
||||
}
|
||||
|
||||
impl Doc {
|
||||
/// Namespace declarations (`xmlns:x`, `xmlns`) on the root element.
|
||||
pub fn ns_decls(&self) -> Vec<(String, String)> {
|
||||
self.root.attrs.iter().filter(|(k, _)| k == "xmlns" || k.starts_with("xmlns:")).cloned().collect()
|
||||
}
|
||||
fn from_craft_el(el: craft_xml::El) -> El {
|
||||
let children = el
|
||||
.children
|
||||
.into_iter()
|
||||
.filter_map(|n| match n {
|
||||
craft_xml::Node::El(c) => Some(Node::El(from_craft_el(c))),
|
||||
craft_xml::Node::Text(t) | craft_xml::Node::CData(t) => Some(Node::Text(t)),
|
||||
craft_xml::Node::Pi { .. } | craft_xml::Node::Comment(_) => None,
|
||||
})
|
||||
.collect();
|
||||
El { name: el.name, attrs: el.attrs, children }
|
||||
}
|
||||
|
||||
/// Parse XML bytes into a DOM. Bounded depth and node count; entity references are resolved.
|
||||
pub fn parse(bytes: &[u8]) -> Result<Doc, PptxError> {
|
||||
// Skip a UTF-8 BOM; UTF-16 parts (rare) are decoded first.
|
||||
let owned;
|
||||
let bytes = if bytes.starts_with(&[0xFF, 0xFE]) || bytes.starts_with(&[0xFE, 0xFF]) {
|
||||
owned = decode_utf16(bytes);
|
||||
owned.as_bytes()
|
||||
} else {
|
||||
bytes.strip_prefix(&[0xEF, 0xBB, 0xBF]).unwrap_or(bytes)
|
||||
};
|
||||
let mut reader = quick_xml::Reader::from_reader(bytes);
|
||||
{
|
||||
let c = reader.config_mut();
|
||||
c.trim_text(false);
|
||||
c.check_end_names = false;
|
||||
c.allow_unmatched_ends = true;
|
||||
c.expand_empty_elements = false;
|
||||
}
|
||||
let mut stack: Vec<El> = vec![];
|
||||
let mut root: Option<El> = None;
|
||||
let mut nodes = 0usize;
|
||||
let mut buf = Vec::new();
|
||||
loop {
|
||||
let ev = reader.read_event_into(&mut buf).map_err(|e| PptxError::Xml(format!("{e}")))?;
|
||||
match ev {
|
||||
Event::Start(b) | Event::Empty(b) if root.is_some() => {
|
||||
// Content after the root element: ignore.
|
||||
let _ = b;
|
||||
}
|
||||
Event::Start(b) => {
|
||||
nodes += 1;
|
||||
if nodes > MAX_NODES || stack.len() >= MAX_DEPTH {
|
||||
return Err(PptxError::Xml("document too large or too deeply nested".into()));
|
||||
}
|
||||
stack.push(start_el(&b, &reader));
|
||||
}
|
||||
Event::Empty(b) => {
|
||||
nodes += 1;
|
||||
if nodes > MAX_NODES {
|
||||
return Err(PptxError::Xml("document too large".into()));
|
||||
}
|
||||
let el = start_el(&b, &reader);
|
||||
match stack.last_mut() {
|
||||
Some(p) => p.children.push(Node::El(el)),
|
||||
None => root = Some(el),
|
||||
}
|
||||
}
|
||||
Event::End(_) => {
|
||||
if let Some(el) = stack.pop() {
|
||||
match stack.last_mut() {
|
||||
Some(p) => p.children.push(Node::El(el)),
|
||||
None => root = Some(el),
|
||||
}
|
||||
}
|
||||
}
|
||||
Event::Text(t) => {
|
||||
if let Some(p) = stack.last_mut() {
|
||||
let s = t.decode().map(|c| c.into_owned()).unwrap_or_default();
|
||||
push_text(p, &line_ends(s));
|
||||
}
|
||||
}
|
||||
Event::CData(t) => {
|
||||
if let Some(p) = stack.last_mut() {
|
||||
let s = String::from_utf8_lossy(&t).into_owned();
|
||||
push_text(p, &line_ends(s));
|
||||
}
|
||||
}
|
||||
Event::GeneralRef(r) => {
|
||||
if let Some(p) = stack.last_mut() {
|
||||
let s = if r.is_char_ref() {
|
||||
r.resolve_char_ref().ok().flatten().map(String::from).unwrap_or_default()
|
||||
} else {
|
||||
match r.decode().map(|c| c.into_owned()).unwrap_or_default().as_str() {
|
||||
"amp" => "&".into(),
|
||||
"lt" => "<".into(),
|
||||
"gt" => ">".into(),
|
||||
"quot" => "\"".into(),
|
||||
"apos" => "'".into(),
|
||||
_ => String::new(),
|
||||
}
|
||||
};
|
||||
push_text(p, &s);
|
||||
}
|
||||
}
|
||||
Event::Eof => break,
|
||||
_ => {}
|
||||
}
|
||||
buf.clear();
|
||||
}
|
||||
// Unclosed elements (truncated document): fold them up so partial content is still usable.
|
||||
while let Some(el) = stack.pop() {
|
||||
match stack.last_mut() {
|
||||
Some(p) => p.children.push(Node::El(el)),
|
||||
None => root = Some(el),
|
||||
}
|
||||
}
|
||||
let root = root.ok_or_else(|| PptxError::Xml("no root element".into()))?;
|
||||
Ok(Doc { root })
|
||||
}
|
||||
|
||||
/// XML 1.0 §2.11: a literal CR LF or lone CR in the document reads as LF. A ` ` reference is
|
||||
/// not literal and reaches `push_text` through `GeneralRef`, so it stays a CR.
|
||||
fn line_ends(s: String) -> String {
|
||||
if s.contains('\r') { s.replace("\r\n", "\n").replace('\r', "\n") } else { s }
|
||||
}
|
||||
|
||||
fn push_text(p: &mut El, s: &str) {
|
||||
if s.is_empty() {
|
||||
return;
|
||||
}
|
||||
if let Some(Node::Text(t)) = p.children.last_mut() {
|
||||
t.push_str(s);
|
||||
} else {
|
||||
p.children.push(Node::Text(s.to_string()));
|
||||
}
|
||||
}
|
||||
|
||||
fn start_el(b: &quick_xml::events::BytesStart, reader: &quick_xml::Reader<&[u8]>) -> El {
|
||||
let name = String::from_utf8_lossy(b.name().as_ref()).into_owned();
|
||||
let mut attrs = vec![];
|
||||
for a in b.attributes().with_checks(false).flatten() {
|
||||
let k = String::from_utf8_lossy(a.key.as_ref()).into_owned();
|
||||
let v = a
|
||||
.decoded_and_normalized_value(quick_xml::XmlVersion::Implicit1_0, reader.decoder())
|
||||
.map(|c| c.into_owned())
|
||||
.unwrap_or_else(|_| String::from_utf8_lossy(&a.value).into_owned());
|
||||
attrs.push((k, v));
|
||||
}
|
||||
El { name, attrs, children: vec![] }
|
||||
}
|
||||
|
||||
fn decode_utf16(bytes: &[u8]) -> String {
|
||||
let le = bytes.starts_with(&[0xFF, 0xFE]);
|
||||
let units: Vec<u16> =
|
||||
bytes.get(2..).unwrap_or(&[]).as_chunks::<2>().0.iter().map(|c| if le { u16::from_le_bytes(*c) } else { u16::from_be_bytes(*c) }).collect();
|
||||
let s = String::from_utf16_lossy(&units);
|
||||
// Drop the encoding declaration so quick-xml reads it as UTF-8.
|
||||
match s.strip_prefix("<?xml").and_then(|r| r.find("?>").map(|i| i + 7)) {
|
||||
Some(end) => s.get(end..).unwrap_or("").to_string(),
|
||||
None => s,
|
||||
}
|
||||
}
|
||||
|
||||
// Preserve the public writer helpers while sharing the XML 1.0 escaping rules.
|
||||
pub use craft_xml::{esc, esc_attr};
|
||||
|
||||
/// A string builder for XML parts.
|
||||
#[derive(Default)]
|
||||
pub struct W {
|
||||
pub s: String,
|
||||
}
|
||||
|
||||
/// Attribute list builder.
|
||||
#[derive(Default)]
|
||||
pub struct A {
|
||||
pub v: Vec<(&'static str, String)>,
|
||||
}
|
||||
|
||||
impl A {
|
||||
pub fn new() -> Self {
|
||||
A { v: vec![] }
|
||||
}
|
||||
pub fn a(mut self, k: &'static str, v: impl ToString) -> Self {
|
||||
self.v.push((k, v.to_string()));
|
||||
self
|
||||
}
|
||||
pub fn o<T: ToString>(mut self, k: &'static str, v: Option<T>) -> Self {
|
||||
if let Some(v) = v {
|
||||
self.v.push((k, v.to_string()));
|
||||
}
|
||||
self
|
||||
}
|
||||
/// Boolean attribute written as `1`/`0` when `Some`.
|
||||
pub fn b(mut self, k: &'static str, v: Option<bool>) -> Self {
|
||||
if let Some(v) = v {
|
||||
self.v.push((k, if v { "1" } else { "0" }.to_string()));
|
||||
}
|
||||
self
|
||||
}
|
||||
/// Boolean attribute written only when true.
|
||||
pub fn t(mut self, k: &'static str, v: bool) -> Self {
|
||||
if v {
|
||||
self.v.push((k, "1".to_string()));
|
||||
}
|
||||
self
|
||||
}
|
||||
}
|
||||
|
||||
impl W {
|
||||
pub fn new() -> Self {
|
||||
W { s: String::from("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n") }
|
||||
}
|
||||
pub fn frag() -> Self {
|
||||
W { s: String::new() }
|
||||
}
|
||||
fn attrs(&mut self, a: &A) {
|
||||
for (k, v) in &a.v {
|
||||
let _ = write!(self.s, " {}=\"{}\"", k, esc_attr(v));
|
||||
}
|
||||
}
|
||||
pub fn open(&mut self, name: &str, a: A) {
|
||||
self.s.push('<');
|
||||
self.s.push_str(name);
|
||||
self.attrs(&a);
|
||||
self.s.push('>');
|
||||
}
|
||||
pub fn open0(&mut self, name: &str) {
|
||||
self.s.push('<');
|
||||
self.s.push_str(name);
|
||||
self.s.push('>');
|
||||
}
|
||||
pub fn close(&mut self, name: &str) {
|
||||
self.s.push_str("</");
|
||||
self.s.push_str(name);
|
||||
self.s.push('>');
|
||||
}
|
||||
pub fn empty(&mut self, name: &str, a: A) {
|
||||
self.s.push('<');
|
||||
self.s.push_str(name);
|
||||
self.attrs(&a);
|
||||
self.s.push_str("/>");
|
||||
}
|
||||
pub fn empty0(&mut self, name: &str) {
|
||||
self.s.push('<');
|
||||
self.s.push_str(name);
|
||||
self.s.push_str("/>");
|
||||
}
|
||||
/// `<name val="v"/>`
|
||||
pub fn val(&mut self, name: &str, v: impl ToString) {
|
||||
self.empty(name, A::new().a("val", v));
|
||||
}
|
||||
pub fn text(&mut self, t: &str) {
|
||||
self.s.push_str(&esc(t));
|
||||
}
|
||||
/// `<name>text</name>`
|
||||
pub fn elt(&mut self, name: &str, t: &str) {
|
||||
self.open0(name);
|
||||
self.text(t);
|
||||
self.close(name);
|
||||
}
|
||||
pub fn raw(&mut self, xml: &str) {
|
||||
self.s.push_str(xml);
|
||||
}
|
||||
pub fn finish(self) -> Vec<u8> {
|
||||
self.s.into_bytes()
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn literal_cr_lf_and_lone_cr_read_as_lf_but_char_ref_stays() {
|
||||
let d = parse(b"<a:p><a:t>one\r\ntwo\rthree four</a:t><a:t><![CDATA[x\r\ny]]></a:t></a:p>").expect("parse");
|
||||
let t: Vec<String> = d.root.children_named("t").map(|t| t.text()).collect();
|
||||
assert_eq!(t, vec!["one\ntwo\nthree\rfour".to_string(), "x\ny".to_string()]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cr_in_text_survives_write_read() {
|
||||
assert_eq!(esc("a\rb"), "a b");
|
||||
let mut w = W::default();
|
||||
w.elt("a:t", "one\rtwo\r\nthree");
|
||||
let d = parse(w.s.as_bytes()).expect("parse");
|
||||
assert_eq!(d.root.text(), "one\rtwo\r\nthree");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parse_basic_and_entities() {
|
||||
let d = parse(b"<?xml version=\"1.0\"?><a:p xmlns:a=\"x\"><a:r><a:t>A & B A <</a:t></a:r><a:x r:id=\"rId1\" id=\"5\"/></a:p>")
|
||||
.unwrap();
|
||||
assert_eq!(d.root.local(), "p");
|
||||
assert_eq!(d.root.find("t").map(|t| t.text()), Some("A & B A <".to_string()));
|
||||
let x = d.root.child("x").unwrap();
|
||||
assert_eq!(x.attr("id"), Some("5"));
|
||||
assert_eq!(x.attr("r:id"), Some("rId1"));
|
||||
assert_eq!(d.ns_decls().len(), 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn truncated_and_garbage() {
|
||||
assert!(parse(b"<a><b><c>text").is_ok());
|
||||
assert!(parse(b"").is_err());
|
||||
let deep = "<a>".repeat(MAX_DEPTH + 10);
|
||||
assert!(parse(deep.as_bytes()).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn escape_drops_control_chars() {
|
||||
assert_eq!(esc("a\u{b}b<\u{0}"), "ab<");
|
||||
assert_eq!(esc_attr("\"x\"\n"), ""x" ");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn shared_escaping_preserves_xml_wire_bytes() {
|
||||
let text = "&<>\"'\t\n\r\0\u{b}\u{fffe}\u{ffff}é😀 ";
|
||||
assert_eq!(esc(text), "&<>\"'\t\n é😀&#13;");
|
||||
assert_eq!(esc_attr(text), "&<>"'	 é😀&#13;");
|
||||
assert_eq!(esc(""), "");
|
||||
assert_eq!(esc_attr(""), "");
|
||||
for code in 0..32 {
|
||||
let c = char::from_u32(code).unwrap();
|
||||
let text = c.to_string();
|
||||
match c {
|
||||
'\t' => {
|
||||
assert_eq!(esc(&text), "\t");
|
||||
assert_eq!(esc_attr(&text), "	");
|
||||
}
|
||||
'\n' => {
|
||||
assert_eq!(esc(&text), "\n");
|
||||
assert_eq!(esc_attr(&text), " ");
|
||||
}
|
||||
'\r' => {
|
||||
assert_eq!(esc(&text), " ");
|
||||
assert_eq!(esc_attr(&text), " ");
|
||||
}
|
||||
_ => {
|
||||
assert_eq!(esc(&text), "");
|
||||
assert_eq!(esc_attr(&text), "");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn roundtrip_serialize() {
|
||||
let d = parse(b"<p:sp a=\"1\"><p:t>x & y</p:t><e/></p:sp>").unwrap();
|
||||
assert_eq!(d.root.to_xml(), "<p:sp a=\"1\"><p:t>x & y</p:t><e/></p:sp>");
|
||||
}
|
||||
let root = craft_drawingml::xmlx::parse(bytes).map_err(|e| PptxError::Xml(e.to_string()))?;
|
||||
Ok(Doc { root: from_craft_el(root) })
|
||||
}
|
||||
|
||||
@@ -444,3 +444,33 @@ fn a_shared_notes_part_is_read_once() {
|
||||
assert_eq!(q.slides[0].notes.text(), "notes 0");
|
||||
assert!(q.slides[1..].iter().all(|s| s.notes.text().is_empty()), "a shared notes part is not copied");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn notes_master_and_handout_master_shape_count_bounds() {
|
||||
use std::fmt::Write as _;
|
||||
use std::sync::Arc;
|
||||
let mut p = defaults::new_presentation(None);
|
||||
Arc::make_mut(&mut p.slides[0]).notes = deckcraft_model::text::TextBody::from_text("note");
|
||||
p.handout_master = Some(Arc::new(deckcraft_model::Master { name: "Handouts".into(), ..Default::default() }));
|
||||
let mut es = entries(&deckcraft_pptx::export(&p).expect("export"));
|
||||
let mut many = String::new();
|
||||
for i in 2..=20_050 {
|
||||
let _ = write!(many, r#"<p:sp><p:nvSpPr><p:cNvPr id="{i}" name="S{i}"/><p:cNvSpPr/><p:nvPr/></p:nvSpPr><p:spPr/></p:sp>"#);
|
||||
}
|
||||
for (n, d) in es.iter_mut() {
|
||||
if n == "ppt/notesMasters/notesMaster1.xml" || n == "ppt/handoutMasters/handoutMaster1.xml" {
|
||||
let xml = String::from_utf8(d.clone()).expect("utf8");
|
||||
if let Some(pos) = xml.rfind("</p:spTree>") {
|
||||
let mut patched = String::with_capacity(xml.len() + many.len());
|
||||
patched.push_str(&xml[..pos]);
|
||||
patched.push_str(&many);
|
||||
patched.push_str(&xml[pos..]);
|
||||
*d = patched.into_bytes();
|
||||
}
|
||||
}
|
||||
}
|
||||
let q = deckcraft_pptx::import(&rezip(&es)).expect("bounded import");
|
||||
assert_eq!(q.notes_master.as_ref().expect("notes_master").shapes.len(), 20_000);
|
||||
assert_eq!(q.handout_master.as_ref().expect("handout_master").shapes.len(), 20_000);
|
||||
deckcraft_pptx::export(&q).expect("re-export");
|
||||
}
|
||||
|
||||
@@ -2347,3 +2347,50 @@ fn reflection_angles_and_skews_out_of_range_are_written_inside_the_schema() {
|
||||
let r = round(&p).slides.last().and_then(|sl| by_name(sl, "Reflected").effects.clone()).and_then(|fx| fx.reflection).expect("reflection");
|
||||
assert_eq!((r.st_pos, r.dir, r.fade_dir, r.kx, r.ky), (Some(100_000), Some(21_599_995), Some(0), Some(5_399_999), Some(-5_399_999)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pptx_potx_ppsx_export_parity_preserves_masters_charts_themes_and_timing() {
|
||||
let mut p = rich_deck();
|
||||
let m0 = Arc::make_mut(&mut p.masters[0]);
|
||||
m0.theme.name = "ParityTheme".into();
|
||||
m0.theme.colors.set(deckcraft_color::SchemeSlot::Accent1, deckcraft_color::Rgba::rgb(0x11, 0x22, 0x33));
|
||||
p.notes_master = Some(Arc::new(deckcraft_model::Master { name: "NotesParity".into(), ..Default::default() }));
|
||||
p.handout_master = Some(Arc::new(deckcraft_model::Master { name: "HandoutParity".into(), ..Default::default() }));
|
||||
|
||||
let audio = p.add_media("cue.m4a", "audio/mp4", b"audio-bytes".to_vec()).expect("media");
|
||||
let aud_id = ShapeId(p.alloc_id().expect("id"));
|
||||
Arc::make_mut(&mut p.slides[0]).shapes.push(Shape {
|
||||
id: aud_id,
|
||||
name: "Cue".into(),
|
||||
xfrm: Some(Xfrm::new(20.0, 20.0, 40.0, 40.0)),
|
||||
kind: ShapeKind::Media(deckcraft_model::MediaClip {
|
||||
media: audio,
|
||||
video: false,
|
||||
autoplay: true,
|
||||
loop_play: true,
|
||||
volume: 0.5,
|
||||
..Default::default()
|
||||
}),
|
||||
..Default::default()
|
||||
});
|
||||
|
||||
for (ext, expected_ct) in [
|
||||
("pptx", "presentationml.presentation.main+xml"),
|
||||
("potx", "presentationml.template.main+xml"),
|
||||
("POTX", "presentationml.template.main+xml"),
|
||||
(".ppsx", "presentationml.slideshow.main+xml"),
|
||||
] {
|
||||
let bytes = deckcraft_pptx::export_as(&p, ext).expect("export_as");
|
||||
let mut z = zip::ZipArchive::new(std::io::Cursor::new(&bytes)).expect("zip");
|
||||
let ct = std::io::read_to_string(z.by_name("[Content_Types].xml").expect("content types")).expect("read");
|
||||
assert!(ct.contains(expected_ct), "{ext}: {ct}");
|
||||
let reopened = deckcraft_pptx::import(&bytes).expect("reopen");
|
||||
assert_eq!(reopened.masters[0].theme.name, "ParityTheme");
|
||||
assert_eq!(reopened.masters[0].theme.colors.get(deckcraft_color::SchemeSlot::Accent1), deckcraft_color::Rgba::rgb(0x11, 0x22, 0x33));
|
||||
assert!(reopened.notes_master.is_some());
|
||||
assert_eq!(reopened.handout_master.as_ref().map(|m| m.name.as_str()), Some("HandoutParity"));
|
||||
let cue = reopened.slides[0].shapes.iter().find(|s| s.name == "Cue").expect("cue");
|
||||
let ShapeKind::Media(clip) = &cue.kind else { panic!("expected media") };
|
||||
assert!(clip.autoplay && clip.loop_play && (clip.volume - 0.5).abs() < 1e-3);
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user