Compare commits

..
Author SHA1 Message Date
FredApps 5477bcf306 Release: bump deckcraft to v0.19.1 2026-11-20 15:24:03 +01:00
29 changed files with 14287 additions and 3378 deletions
Generated
+65 -48
View File
@@ -943,7 +943,7 @@ dependencies = [
[[package]]
name = "craft-cfb"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=8048f8ef92da80fb3ce5a056d59ca591ee66faf1#8048f8ef92da80fb3ce5a056d59ca591ee66faf1"
source = "git+https://github.com/storytold/craft-libs?rev=ea24422ae9859dc5da398d0462bc87f8e02e0d10#ea24422ae9859dc5da398d0462bc87f8e02e0d10"
[[package]]
name = "craft-codepage"
@@ -970,9 +970,20 @@ dependencies = [
[[package]]
name = "craft-drawingml"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=8048f8ef92da80fb3ce5a056d59ca591ee66faf1#8048f8ef92da80fb3ce5a056d59ca591ee66faf1"
source = "git+https://github.com/storytold/craft-libs?rev=44d83fa8f635333dcb3c231f87381387a1f5631b#44d83fa8f635333dcb3c231f87381387a1f5631b"
dependencies = [
"craft-xml",
"craft-xml 0.1.0 (git+https://github.com/storytold/craft-libs?rev=44d83fa8f635333dcb3c231f87381387a1f5631b)",
"kurbo",
"log",
"serde",
]
[[package]]
name = "craft-drawingml"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=cff5af869dbf6926801c9ac63a927d155202ba3b#cff5af869dbf6926801c9ac63a927d155202ba3b"
dependencies = [
"craft-xml 0.1.0 (git+https://github.com/storytold/craft-libs?rev=cff5af869dbf6926801c9ac63a927d155202ba3b)",
"kurbo",
"log",
"serde",
@@ -1046,10 +1057,10 @@ dependencies = [
[[package]]
name = "craft-opc"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=8048f8ef92da80fb3ce5a056d59ca591ee66faf1#8048f8ef92da80fb3ce5a056d59ca591ee66faf1"
source = "git+https://github.com/storytold/craft-libs?rev=ea24422ae9859dc5da398d0462bc87f8e02e0d10#ea24422ae9859dc5da398d0462bc87f8e02e0d10"
dependencies = [
"craft-xml",
"craft-zip 0.1.0 (git+https://github.com/storytold/craft-libs?rev=8048f8ef92da80fb3ce5a056d59ca591ee66faf1)",
"craft-xml 0.1.0 (git+https://github.com/storytold/craft-libs?rev=ea24422ae9859dc5da398d0462bc87f8e02e0d10)",
"craft-zip 0.1.0 (git+https://github.com/storytold/craft-libs?rev=ea24422ae9859dc5da398d0462bc87f8e02e0d10)",
"log",
"thiserror 2.0.21",
]
@@ -1063,21 +1074,6 @@ 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"
@@ -1168,13 +1164,32 @@ dependencies = [
[[package]]
name = "craft-xml"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=8048f8ef92da80fb3ce5a056d59ca591ee66faf1#8048f8ef92da80fb3ce5a056d59ca591ee66faf1"
source = "git+https://github.com/storytold/craft-libs?rev=44d83fa8f635333dcb3c231f87381387a1f5631b#44d83fa8f635333dcb3c231f87381387a1f5631b"
dependencies = [
"quick-xml 0.41.0",
"serde",
"thiserror 2.0.21",
]
[[package]]
name = "craft-xml"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=cff5af869dbf6926801c9ac63a927d155202ba3b#cff5af869dbf6926801c9ac63a927d155202ba3b"
dependencies = [
"quick-xml 0.41.0",
"serde",
"thiserror 2.0.21",
]
[[package]]
name = "craft-xml"
version = "0.1.0"
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"
@@ -1188,7 +1203,7 @@ dependencies = [
[[package]]
name = "craft-zip"
version = "0.1.0"
source = "git+https://github.com/storytold/craft-libs?rev=8048f8ef92da80fb3ce5a056d59ca591ee66faf1#8048f8ef92da80fb3ce5a056d59ca591ee66faf1"
source = "git+https://github.com/storytold/craft-libs?rev=ea24422ae9859dc5da398d0462bc87f8e02e0d10#ea24422ae9859dc5da398d0462bc87f8e02e0d10"
dependencies = [
"flate2",
"thiserror 2.0.21",
@@ -1268,7 +1283,7 @@ checksum = "0c87e182de0887fd5361989c677c4e8f5000cd9491d6d563161a8f3a5519fc7f"
[[package]]
name = "deckcraft"
version = "0.19.0"
version = "0.19.1"
dependencies = [
"arboard",
"chrono",
@@ -1290,7 +1305,7 @@ dependencies = [
[[package]]
name = "deckcraft-anim"
version = "0.19.0"
version = "0.19.1"
dependencies = [
"deckcraft-geom",
"deckcraft-model",
@@ -1299,7 +1314,7 @@ dependencies = [
[[package]]
name = "deckcraft-cli"
version = "0.19.0"
version = "0.19.1"
dependencies = [
"deckcraft-engine",
"deckcraft-mcp",
@@ -1309,14 +1324,14 @@ dependencies = [
[[package]]
name = "deckcraft-color"
version = "0.19.0"
version = "0.19.1"
dependencies = [
"craft-drawingml",
"craft-drawingml 0.1.0 (git+https://github.com/storytold/craft-libs?rev=44d83fa8f635333dcb3c231f87381387a1f5631b)",
]
[[package]]
name = "deckcraft-engine"
version = "0.19.0"
version = "0.19.1"
dependencies = [
"chrono",
"craft-mime",
@@ -1344,7 +1359,7 @@ dependencies = [
[[package]]
name = "deckcraft-fonts"
version = "0.19.0"
version = "0.19.1"
dependencies = [
"epaint_default_fonts",
"harfrust 0.13.3",
@@ -1356,7 +1371,7 @@ dependencies = [
[[package]]
name = "deckcraft-format"
version = "0.19.0"
version = "0.19.1"
dependencies = [
"craft-deckcraft-format",
"craft-rtf",
@@ -1367,16 +1382,16 @@ dependencies = [
[[package]]
name = "deckcraft-geom"
version = "0.19.0"
version = "0.19.1"
dependencies = [
"craft-drawingml",
"craft-drawingml 0.1.0 (git+https://github.com/storytold/craft-libs?rev=44d83fa8f635333dcb3c231f87381387a1f5631b)",
"kurbo",
"serde",
]
[[package]]
name = "deckcraft-mcp"
version = "0.19.0"
version = "0.19.1"
dependencies = [
"craft-mcp-server",
"deckcraft-engine",
@@ -1387,7 +1402,7 @@ dependencies = [
[[package]]
name = "deckcraft-media"
version = "0.19.0"
version = "0.19.1"
dependencies = [
"craft-audio",
"craft-media",
@@ -1400,9 +1415,9 @@ dependencies = [
[[package]]
name = "deckcraft-model"
version = "0.19.0"
version = "0.19.1"
dependencies = [
"craft-drawingml",
"craft-drawingml 0.1.0 (git+https://github.com/storytold/craft-libs?rev=44d83fa8f635333dcb3c231f87381387a1f5631b)",
"deckcraft-color",
"deckcraft-geom",
"serde",
@@ -1413,7 +1428,7 @@ dependencies = [
[[package]]
name = "deckcraft-pdf"
version = "0.19.0"
version = "0.19.1"
dependencies = [
"craft-pdf",
"deckcraft-fonts",
@@ -1431,7 +1446,7 @@ dependencies = [
[[package]]
name = "deckcraft-ppt"
version = "0.19.0"
version = "0.19.1"
dependencies = [
"deckcraft-color",
"deckcraft-engine",
@@ -1446,18 +1461,20 @@ dependencies = [
[[package]]
name = "deckcraft-pptx"
version = "0.19.0"
version = "0.19.1"
dependencies = [
"craft-cfb",
"craft-drawingml",
"craft-drawingml 0.1.0 (git+https://github.com/storytold/craft-libs?rev=44d83fa8f635333dcb3c231f87381387a1f5631b)",
"craft-drawingml 0.1.0 (git+https://github.com/storytold/craft-libs?rev=cff5af869dbf6926801c9ac63a927d155202ba3b)",
"craft-opc",
"craft-pptx",
"craft-xml",
"craft-xml 0.1.0 (git+https://github.com/storytold/craft-libs?rev=ea24422ae9859dc5da398d0462bc87f8e02e0d10)",
"deckcraft-color",
"deckcraft-engine",
"deckcraft-geom",
"deckcraft-model",
"deckcraft-text",
"image",
"log",
"quick-xml 0.41.0",
"serde_json",
"thiserror 2.0.21",
@@ -1466,7 +1483,7 @@ dependencies = [
[[package]]
name = "deckcraft-render"
version = "0.19.0"
version = "0.19.1"
dependencies = [
"craft-metafile",
"deckcraft-anim",
@@ -1485,7 +1502,7 @@ dependencies = [
[[package]]
name = "deckcraft-text"
version = "0.19.0"
version = "0.19.1"
dependencies = [
"chrono",
"deckcraft-color",
@@ -1499,7 +1516,7 @@ dependencies = [
[[package]]
name = "deckcraft-ui-egui"
version = "0.19.0"
version = "0.19.1"
dependencies = [
"craft-ui",
"craft-update",
@@ -1525,7 +1542,7 @@ dependencies = [
[[package]]
name = "deckcraft-web"
version = "0.19.0"
version = "0.19.1"
dependencies = [
"craft-web-api",
"craft-web-host",
@@ -6738,7 +6755,7 @@ checksum = "9440ea3e5aeabb0ac63af70daf835274065238cdd0cec83418f417eae38bacee"
[[package]]
name = "xtask"
version = "0.19.0"
version = "0.19.1"
dependencies = [
"serde_json",
]
+10 -10
View File
@@ -4,23 +4,23 @@ members = ["crates/*", "apps/*", "xtask"]
default-members = ["crates/*", "apps/deckcraft", "apps/deckcraft-cli"]
[workspace.package]
version = "0.19.0"
version = "0.19.1"
edition = "2024"
license = "MIT OR Apache-2.0"
rust-version = "1.95"
repository = "https://github.com/storytold/deckcraft"
[workspace.dependencies]
# OPC part-name primitives and package reader/writer.
craft-opc = { git = "https://github.com/storytold/craft-libs", rev = "8048f8ef92da80fb3ce5a056d59ca591ee66faf1", version = "0.1.0" }
# OPC part-name primitives; relationship admission stays app-local.
craft-opc = { git = "https://github.com/storytold/craft-libs", rev = "ea24422ae9859dc5da398d0462bc87f8e02e0d10", version = "0.1.0" }
# Compound File Binary directory reads (password-protected deck detection).
craft-cfb = { git = "https://github.com/storytold/craft-libs", rev = "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" }
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" }
# 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
-70
View File
@@ -304,73 +304,3 @@ 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": {}}));
}
+5 -2
View File
@@ -9,15 +9,19 @@ 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 }
@@ -25,5 +29,4 @@ 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
+547
View File
@@ -0,0 +1,547 @@
//! 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])]);
}
}
+910
View File
@@ -0,0 +1,910 @@
//! 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());
}
}
+66 -789
View File
@@ -1,5 +1,5 @@
//! PPTX import and export: Office Open XML PresentationML / DrawingML, delegated to the shared
//! `craft-pptx` crate.
//! PPTX import and export: Office Open XML PresentationML / DrawingML, written from the public
//! ECMA-376 standard.
//!
//! [`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,15 +8,28 @@
#![forbid(unsafe_code)]
mod cfb;
mod convert;
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 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, Shape, ShapeKind, defaults};
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}";
#[derive(Debug, thiserror::Error)]
pub enum PptxError {
@@ -30,50 +43,15 @@ 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 archive's central directory, not in the leading bytes: writers may
/// The part is looked up in the zip'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 {
craft_pptx::sniff(bytes)
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)
}
/// Is this a password-protected presentation (an encrypted package inside a compound file)?
@@ -81,750 +59,81 @@ 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> {
preflight_slides(bytes)?;
let mut pres = craft_pptx::import(bytes, &DeckDefaults).map(convert::pres_from_craft)?;
post_import_timing(bytes, &mut pres);
Ok(pres)
read::import(bytes)
}
/// [`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> {
let (p, lost, _) = import_report(bytes)?;
Ok((p, lost))
read::import_checked(bytes)
}
/// [`import_checked`], plus warnings for content cut to fit a limit (a table past the cell cap
/// keeps its leading rows); the file still opens.
pub fn import_report(bytes: &[u8]) -> Result<(Presentation, Vec<String>, Vec<String>), PptxError> {
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))
read::import_report(bytes)
}
/// [`import`] with a lower presentation-wide chart point budget, so tests reach the over-budget
/// path without a multi-million-point chart.
#[doc(hidden)]
pub fn import_with_chart_budget(bytes: &[u8], points: usize) -> Result<Presentation, PptxError> {
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::import_with_chart_points(bytes, points).map(|(p, _)| p)
}
/// 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> {
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()))
read::import_theme(bytes)
}
/// Write a `.pptx` package.
pub fn export(p: &Presentation) -> Result<Vec<u8>, PptxError> {
check_table_caps(p)?;
let bytes = craft_pptx::export(&convert::pres_to_craft(p), &DeckDefaults)?;
patch_exported_slides(p, bytes)
write::export(p, write::CT_PRES)
}
/// 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> {
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)
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",
}
}
#[cfg(test)]
@@ -919,36 +228,4 @@ 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(_))));
}
}
+449
View File
@@ -0,0 +1,449 @@
//! 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}");
}
}
}
+563
View File
@@ -0,0 +1,563 @@
//! 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"));
}
}
+33
View File
@@ -0,0 +1,33 @@
//! 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
+177
View File
@@ -0,0 +1,177 @@
//! 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)
}
+824
View File
@@ -0,0 +1,824 @@
//! 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"));
}
}
+924
View File
@@ -0,0 +1,924 @@
//! 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:?}");
}
}
+114
View File
@@ -0,0 +1,114 @@
//! 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,
}
}
}
+493
View File
@@ -0,0 +1,493 @@
//! 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()
}
+97
View File
@@ -0,0 +1,97 @@
//! 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=\"&amp;\"/>",
"<notAStyle/>",
"",
"<tblStyle><child/></tblStyle>",
] {
let defs = vec![
TableStyleDef { id: "custom".into(), raw: raw.into(), ..Default::default() },
TableStyleDef { id: "CUSTOM".into(), raw: "<tblStyle second=\"1\"/>".into(), ..Default::default() },
TableStyleDef { id: "unused".into(), raw: "<tblStyle unused=\"1\"/>".into(), ..Default::default() },
];
for selection in [&used[..], &[][..]] {
assert_eq!(table_styles_xml(selection, &defs), legacy::table_styles_xml(selection, &defs), "{raw:?}");
}
}
for depth in [255, 256, 257] {
let raw = format!("{}{}", "<tblStyle>".repeat(depth), "</tblStyle>".repeat(depth));
let defs = [TableStyleDef { id: "custom".into(), raw, ..Default::default() }];
assert_eq!(table_styles_xml(&used, &defs), legacy::table_styles_xml(&used, &defs));
}
}
#[test]
fn shared_style_catalog_matches_deckcraft() {
assert_eq!(deckcraft_model::table::table_styles(), craft_drawingml::table::table_styles());
assert_eq!(style_from_guid(""), "none");
let custom = "{abcdef00-0000-0000-0000-000000000000}";
assert_eq!(style_from_guid(custom), custom);
assert_eq!(guid_for_style(custom), (custom.to_string(), false));
assert_eq!(guid_for_style("unknown"), guid_for_style("medium2-accent1"));
for (id, _) in deckcraft_model::table::table_styles() {
let generated = own_guid(&id);
assert!(is_own_guid(&generated.to_ascii_lowercase()));
if guid_for_style(&id).1 {
assert_eq!(guid_for_style(&id).0, generated);
}
}
}
#[test]
fn style_parts_follow_schema_order() {
const ORDER: [&str; 14] = [
"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}");
}
}
+182
View File
@@ -0,0 +1,182 @@
//! Table styles: our style ids ↔ table style GUIDs, and `tableStyles.xml` definitions for the
//! styles we write (generated from theme accents, matching how DeckCraft draws them).
use crate::opc::NS_A;
use crate::xml::{A, W};
// Keep file-format identifiers in the shared DrawingML implementation. The local
// writer below still owns DeckCraft's table style definitions and XML policy.
pub use craft_drawingml::table::styles::{guid, guid_for_style};
fn own_guid(style: &str) -> String {
guid(&format!("deckcraft-table-style:{style}"))
}
fn clr(w: &mut W, slot: &str, mods: &[(&str, i32)]) {
if mods.is_empty() {
w.val("a:schemeClr", slot);
return;
}
w.open("a:schemeClr", A::new().a("val", slot));
for (n, v) in mods {
w.val(n, v);
}
w.close("a:schemeClr");
}
fn solid(w: &mut W, slot: &str, mods: &[(&str, i32)]) {
w.open0("a:fill");
w.open0("a:solidFill");
clr(w, slot, mods);
w.close("a:solidFill");
w.close("a:fill");
}
fn borders(w: &mut W, b: Option<(&str, &[(&str, i32)], i32)>) {
w.open0("a:tcBdr");
if let Some((slot, mods, width)) = b {
for side in ["a:left", "a:right", "a:top", "a:bottom", "a:insideH", "a:insideV"] {
w.open0(side);
w.open("a:ln", A::new().a("w", width).a("cmpd", "sng"));
w.open0("a:solidFill");
clr(w, slot, mods);
w.close("a:solidFill");
w.close("a:ln");
w.close(side);
}
}
w.close("a:tcBdr");
}
fn txt(w: &mut W, bold: bool, color: Option<&str>) {
w.open("a:tcTxStyle", A::new().o("b", bold.then_some("on")));
w.open("a:fontRef", A::new().a("idx", "minor"));
w.val("a:prstClr", "black");
w.close("a:fontRef");
match color {
Some(c) => w.val("a:schemeClr", c),
None => w.val("a:schemeClr", "dk1"),
}
w.close("a:tcTxStyle");
}
/// Write one `a:tblStyle` for our style id.
fn style_def(w: &mut W, id: &str, name: &str) {
let kind = id.split('-').next().unwrap_or("medium2");
let acc = match id.rsplit('-').next().unwrap_or("accent1") {
"tx1" => "dk1",
a if a.starts_with("accent") => a,
_ => "accent1",
};
let acc: &str = acc;
w.open("a:tblStyle", A::new().a("styleId", own_guid(id)).a("styleName", name));
let part =
|w: &mut W, tag: &str, bold: bool, text: Option<&str>, fill: Option<(&str, &[(&str, i32)])>, bdr: Option<(&str, &[(&str, i32)], i32)>| {
w.open0(tag);
if bold || text.is_some() {
txt(w, bold, text);
}
w.open0("a:tcStyle");
borders(w, bdr);
if let Some((s, m)) = fill {
solid(w, s, m);
}
w.close("a:tcStyle");
w.close(tag);
};
match kind {
"grid" => {
part(w, "a:wholeTbl", false, Some("dk1"), None, Some(("dk1", &[], 9525)));
}
"light1" => {
part(w, "a:wholeTbl", false, Some("dk1"), None, None);
part(w, "a:band1H", false, None, Some((acc, &[("a:tint", 20000)])), None);
part(w, "a:band1V", false, None, Some((acc, &[("a:tint", 20000)])), None);
part(w, "a:lastCol", true, None, None, None);
part(w, "a:firstCol", true, None, None, None);
part(w, "a:lastRow", true, None, None, None);
part(w, "a:firstRow", true, None, None, Some((acc, &[], 12700)));
}
"light2" => {
part(w, "a:wholeTbl", false, Some("dk1"), None, Some((acc, &[], 12700)));
// Schema order: … lastCol, firstCol, lastRow, …, firstRow.
part(w, "a:firstCol", true, None, None, None);
part(w, "a:lastRow", true, None, None, None);
part(w, "a:firstRow", true, Some("lt1"), Some((acc, &[])), Some((acc, &[], 12700)));
}
"dark1" => {
part(w, "a:wholeTbl", false, Some("lt1"), Some((acc, &[("a:shade", 75000)])), Some(("lt1", &[], 12700)));
part(w, "a:band1H", false, None, Some((acc, &[("a:shade", 60000)])), None);
part(w, "a:band1V", false, None, Some((acc, &[("a:shade", 60000)])), None);
part(w, "a:firstCol", true, None, None, None);
part(w, "a:lastRow", true, None, None, None);
part(w, "a:firstRow", true, Some("lt1"), Some(("dk1", &[])), None);
}
"medium4" => {
part(w, "a:wholeTbl", false, Some("dk1"), Some((acc, &[("a:tint", 20000)])), Some((acc, &[], 9525)));
part(w, "a:band1H", false, None, Some((acc, &[("a:tint", 40000)])), None);
part(w, "a:band1V", false, None, Some((acc, &[("a:tint", 40000)])), None);
part(w, "a:lastCol", true, None, None, None);
part(w, "a:firstCol", true, None, None, None);
part(w, "a:lastRow", true, None, None, None);
part(w, "a:firstRow", true, None, Some((acc, &[("a:tint", 40000)])), None);
}
_ => {
// medium2
part(w, "a:wholeTbl", false, Some("dk1"), Some((acc, &[("a:tint", 20000)])), Some(("lt1", &[], 12700)));
part(w, "a:band1H", false, None, Some((acc, &[("a:tint", 40000)])), None);
part(w, "a:band1V", false, None, Some((acc, &[("a:tint", 40000)])), None);
part(w, "a:lastCol", true, Some("lt1"), Some((acc, &[])), None);
part(w, "a:firstCol", true, Some("lt1"), Some((acc, &[])), None);
part(w, "a:lastRow", true, Some("lt1"), Some((acc, &[])), None);
part(w, "a:firstRow", true, Some("lt1"), Some((acc, &[])), None);
}
}
w.close("a:tblStyle");
}
/// `ppt/tableStyles.xml` with definitions for the styles in `used`: ours, generated, and those the
/// opened file defined (`defs`), written back as they were read.
pub fn table_styles_xml(used: &[String], defs: &[deckcraft_model::table::TableStyleDef]) -> Vec<u8> {
let mut w = W::new();
w.open("a:tblStyleLst", A::new().a("xmlns:a", NS_A).a("def", "{5C22544A-7EE6-4342-B048-85BDC9FD1C3A}"));
let names = deckcraft_model::table::table_styles();
// Indexes instead of scans: written ids (as given and ASCII lower-case), and the file's
// definitions by lower-case id (the first wins).
let mut done: std::collections::HashSet<&str> = std::collections::HashSet::new();
let mut done_lower: std::collections::HashSet<String> = std::collections::HashSet::new();
let mut def_of: std::collections::HashMap<String, &deckcraft_model::table::TableStyleDef> = std::collections::HashMap::new();
for d in defs {
def_of.entry(d.id.to_ascii_lowercase()).or_insert(d);
}
for s in used {
if !done.insert(s.as_str()) {
continue;
}
done_lower.insert(s.to_ascii_lowercase());
if let Some(d) = def_of.get(&s.to_ascii_lowercase())
&& crate::xml::parse(d.raw.as_bytes()).is_ok_and(|x| x.root.is("tblStyle"))
{
w.raw(&d.raw);
continue;
}
let (_, define) = guid_for_style(s);
if !define {
continue;
}
let name = names.iter().find(|(id, _)| id == s).map(|(_, n)| format!("DeckCraft {n}")).unwrap_or_else(|| s.clone());
style_def(&mut w, s, &name);
}
// Styles the file defined but no table uses still belong to the deck.
for d in defs {
if done_lower.contains(&d.id.to_ascii_lowercase()) {
continue;
}
if crate::xml::parse(d.raw.as_bytes()).is_ok_and(|x| x.root.is("tblStyle")) {
done_lower.insert(d.id.to_ascii_lowercase());
w.raw(&d.raw);
}
}
w.close("a:tblStyleLst");
w.finish()
}
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
+871
View File
@@ -0,0 +1,871 @@
//! 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
+112
View File
@@ -0,0 +1,112 @@
//! 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()
}
+830
View File
@@ -0,0 +1,830 @@
//! 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);
}
+492 -61
View File
@@ -1,10 +1,23 @@
//! Bounded XML DOM wrapper over [`craft_drawingml::xmlx::parse`] for callers that read kept
//! XML fragments (such as 3-D shape settings).
//! 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;
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>,
@@ -17,97 +30,515 @@ pub enum Node {
}
fn local_of(name: &str) -> &str {
name.rsplit_once(':').map_or(name, |(_, l)| l)
name.rsplit_once(':').map(|(_, l)| l).unwrap_or(name)
}
impl El {
pub fn local(&self) -> &str {
local_of(&self.name)
}
pub fn prefix(&self) -> &str {
self.name.split_once(':').map_or("", |(p, _)| p)
self.name.split_once(':').map(|(p, _)| p).unwrap_or("")
}
pub fn is(&self, local: &str) -> bool {
self.local() == local
}
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('>');
}
/// 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 attr(&self, name: &str) -> Option<&str> {
self.attrs.iter().find(|(k, _)| k == name || local_of(k) == name).map(|(_, v)| v.as_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,
}
}
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.local() == local)
self.elements().find(|e| e.is(local))
}
pub fn children_named<'a>(&'a self, local: &'a str) -> impl Iterator<Item = &'a El> + 'a {
self.elements().filter(move |e| e.local() == local)
self.elements().filter(move |e| e.is(local))
}
pub fn path(&self, path: &[&str]) -> Option<&El> {
path.iter().try_fold(self, |cur, name| cur.child(name))
/// 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
}
}
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,
}
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 }
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()
}
}
/// Parse XML bytes into a DOM. Bounded depth and node count; entity references are resolved.
pub fn parse(bytes: &[u8]) -> Result<Doc, PptxError> {
let root = craft_drawingml::xmlx::parse(bytes).map_err(|e| PptxError::Xml(e.to_string()))?;
Ok(Doc { root: from_craft_el(root) })
// 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 `&#13;` 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&#13;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&#13;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 &amp; B &#x41; &lt;</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&lt;");
assert_eq!(esc_attr("\"x\"\n"), "&quot;x&quot;&#10;");
}
#[test]
fn shared_escaping_preserves_xml_wire_bytes() {
let text = "&<>\"'\t\n\r\0\u{b}\u{fffe}\u{ffff}é😀&#13;";
assert_eq!(esc(text), "&amp;&lt;&gt;\"'\t\n&#13;é😀&amp;#13;");
assert_eq!(esc_attr(text), "&amp;&lt;&gt;&quot;'&#9;&#10;&#13;é😀&amp;#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), "&#9;");
}
'\n' => {
assert_eq!(esc(&text), "\n");
assert_eq!(esc_attr(&text), "&#10;");
}
'\r' => {
assert_eq!(esc(&text), "&#13;");
assert_eq!(esc_attr(&text), "&#13;");
}
_ => {
assert_eq!(esc(&text), "");
assert_eq!(esc_attr(&text), "");
}
}
}
}
#[test]
fn roundtrip_serialize() {
let d = parse(b"<p:sp a=\"1\"><p:t>x &amp; y</p:t><e/></p:sp>").unwrap();
assert_eq!(d.root.to_xml(), "<p:sp a=\"1\"><p:t>x &amp; y</p:t><e/></p:sp>");
}
}
-30
View File
@@ -444,33 +444,3 @@ 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");
}
-47
View File
@@ -2347,50 +2347,3 @@ 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);
}
}