aleleba/deckcraft
1
0
Fork 0
mirror of https://github.com/storytold/deckcraft.git synced 2026-10-31 05:56:55 -06:00
Code Issues Packages Projects Releases Wiki Activity
Files
0efd6f1b853395ee753dd2848aab96db08643bba
deckcraft/crates/pptx/src/write.rs
T

1279 lines
51 KiB
Rust
Raw Blame History

//! PPTX export: [`Presentation`] → package.
pub(crate) mod chart;
pub(crate) mod dml;
mod shapes;
mod theme;
mod timing;
use std::collections::HashMap;
use std::sync::Arc;
use deckcraft_geom::Xfrm;
use deckcraft_model::text::{ListStyle, Paragraph, TextBody};
use deckcraft_model::theme::Theme;
use deckcraft_model::{
Background, Comment, Layout, LayoutId, Master, MediaId, PhType, Placeholder, Presentation, Shape, ShapeId, Slide, SlideId, defaults,
};
use crate::PptxError;
use crate::opc::{self, NS_A, NS_P, NS_P14, NS_P188, NS_R, PackageOut, RelsOut};
use crate::xml::{A, W};
pub(crate) const CT_PRES: &str = "application/vnd.openxmlformats-officedocument.presentationml.presentation.main+xml";
pub(crate) const CT_TEMPLATE: &str = "application/vnd.openxmlformats-officedocument.presentationml.template.main+xml";
pub(crate) const CT_SHOW: &str = "application/vnd.openxmlformats-officedocument.presentationml.slideshow.main+xml";
const CT_SLIDE: &str = "application/vnd.openxmlformats-officedocument.presentationml.slide+xml";
const CT_LAYOUT: &str = "application/vnd.openxmlformats-officedocument.presentationml.slideLayout+xml";
const CT_MASTER: &str = "application/vnd.openxmlformats-officedocument.presentationml.slideMaster+xml";
const CT_NOTES_MASTER: &str = "application/vnd.openxmlformats-officedocument.presentationml.notesMaster+xml";
const CT_HANDOUT_MASTER: &str = "application/vnd.openxmlformats-officedocument.presentationml.handoutMaster+xml";
const CT_NOTES: &str = "application/vnd.openxmlformats-officedocument.presentationml.notesSlide+xml";
const CT_THEME: &str = "application/vnd.openxmlformats-officedocument.theme+xml";
const CT_PRES_PROPS: &str = "application/vnd.openxmlformats-officedocument.presentationml.presProps+xml";
const CT_VIEW_PROPS: &str = "application/vnd.openxmlformats-officedocument.presentationml.viewProps+xml";
const CT_TABLE_STYLES: &str = "application/vnd.openxmlformats-officedocument.presentationml.tableStyles+xml";
const CT_TAGS: &str = "application/vnd.openxmlformats-officedocument.presentationml.tags+xml";
const CT_CHART: &str = "application/vnd.openxmlformats-officedocument.drawingml.chart+xml";
const CT_CHARTEX: &str = "application/vnd.ms-office.chartex+xml";
const RT_CHARTEX: &str = "http://schemas.microsoft.com/office/2014/relationships/chartEx";
const CT_COMMENTS: &str = "application/vnd.openxmlformats-officedocument.presentationml.comments+xml";
const CT_AUTHORS: &str = "application/vnd.openxmlformats-officedocument.presentationml.commentAuthors+xml";
/// Modern threaded comments (read by PowerPoint 2021+ and DeckCraft; the flattened legacy
/// part next to it serves older readers).
pub(crate) const CT_COMMENTS_MODERN: &str = "application/vnd.ms-powerpoint.comments+xml";
const CT_AUTHORS_MODERN: &str = "application/vnd.ms-powerpoint.authors+xml";
const RT_COMMENTS_MODERN: &str = "http://schemas.microsoft.com/office/2018/10/relationships/comments";
const RT_AUTHORS_MODERN: &str = "http://schemas.microsoft.com/office/2018/10/relationships/authors";
const CT_CORE: &str = "application/vnd.openxmlformats-package.core-properties+xml";
const CT_APP: &str = "application/vnd.openxmlformats-officedocument.extended-properties+xml";
/// Export state.
pub struct Exp<'a> {
pub p: &'a Presentation,
pub pkg: PackageOut,
media_parts: HashMap<MediaId, String>,
n_image: u32,
n_media: u32,
n_chart: u32,
n_diagram: u32,
n_tags: u32,
n_chartex: u32,
/// Parts kept from an unchanged chart (`ppt/…/keptN.ext`).
n_kept: u32,
pub slide_parts: HashMap<SlideId, String>,
pub table_styles: Vec<String>,
placeholder: Option<String>,
}
/// A part being written: its name and relationships.
pub struct Out {
pub name: String,
pub rels: RelsOut,
}
impl Out {
fn new(name: &str) -> Self {
Out { name: name.to_string(), rels: RelsOut::default() }
}
}
fn ext_for(content_type: &str, name: &str, data: &[u8]) -> String {
let by_ct = match content_type {
"image/png" => "png",
"image/jpeg" | "image/jpg" => "jpeg",
"image/gif" => "gif",
"image/bmp" => "bmp",
"image/tiff" => "tiff",
"image/svg+xml" => "svg",
"image/x-emf" | "image/emf" => "emf",
"image/x-wmf" | "image/wmf" => "wmf",
"image/webp" => "webp",
"video/mp4" => "mp4",
"video/quicktime" => "mov",
"video/x-ms-wmv" => "wmv",
"video/x-msvideo" => "avi",
"video/webm" => "webm",
"audio/mpeg" => "mp3",
"audio/wav" | "audio/x-wav" | "audio/wave" => "wav",
"audio/mp4" | "audio/x-m4a" => "m4a",
"audio/x-ms-wma" => "wma",
"audio/ogg" => "ogg",
"audio/flac" => "flac",
"model/gltf-binary" => "glb",
_ => "",
};
if !by_ct.is_empty() {
return by_ct.to_string();
}
if data.starts_with(b"\x89PNG") {
return "png".into();
}
if data.starts_with(&[0xFF, 0xD8]) {
return "jpeg".into();
}
if data.starts_with(b"GIF8") {
return "gif".into();
}
let e = name.rsplit_once('.').map(|(_, e)| e.to_ascii_lowercase()).unwrap_or_default();
if !e.is_empty() && e.len() <= 5 && e.chars().all(|c| c.is_ascii_alphanumeric()) { e } else { "bin".into() }
}
impl Exp<'_> {
fn media_part(&mut self, id: MediaId) -> Option<String> {
if let Some(p) = self.media_parts.get(&id) {
return Some(p.clone());
}
let m = self.p.media(id)?;
if m.data.is_empty() {
return None;
}
let ext = ext_for(&m.content_type, &m.name, &m.data);
let ct = if m.content_type.is_empty() || !m.content_type.contains('/') {
crate::mime_for(&format!("x.{ext}")).to_string()
} else {
m.content_type.clone()
};
let name = if ct.starts_with("image/") {
self.n_image += 1;
format!("ppt/media/image{}.{ext}", self.n_image)
} else {
self.n_media += 1;
format!("ppt/media/media{}.{ext}", self.n_media)
};
self.pkg.binary(&name, &ct, m.data.as_ref().clone());
self.media_parts.insert(id, name.clone());
Some(name)
}
/// A relationship from `o` to a media item (embedded part, or external link).
pub fn media_rel(&mut self, o: &mut Out, id: MediaId, kind: &str) -> Option<String> {
let m = self.p.media(id)?;
if m.data.is_empty() {
let link = m.link.clone()?;
return Some(o.rels.add(kind, &link, true));
}
let part = self.media_part(id)?;
Some(o.rels.add(kind, &opc::relative(&o.name, &part), false))
}
pub fn media_rel_new(&mut self, o: &mut Out, id: MediaId, kind: &str) -> Option<String> {
let m = self.p.media(id)?;
if m.data.is_empty() {
return None;
}
let part = self.media_part(id)?;
Some(o.rels.add(kind, &opc::relative(&o.name, &part), false))
}
/// A tiny transparent PNG for pictures whose image is missing.
pub fn placeholder_rel(&mut self, o: &mut Out) -> String {
let part = match &self.placeholder {
Some(p) => p.clone(),
None => {
self.n_image += 1;
let name = format!("ppt/media/image{}.png", self.n_image);
self.pkg.binary(&name, "image/png", crate::png::transparent_1x1());
self.placeholder = Some(name.clone());
name
}
};
o.rels.add("image", &opc::relative(&o.name, &part), false)
}
/// The number of the next SmartArt graphic's parts.
pub fn next_diagram(&mut self) -> u32 {
self.n_diagram += 1;
self.n_diagram
}
/// A new `ppt/tags/tagN.xml` part holding `tags`, related from `o`.
pub fn tags_rel(&mut self, o: &mut Out, tags: &Tags) -> String {
self.n_tags += 1;
let name = format!("ppt/tags/tag{}.xml", self.n_tags);
let mut w = W::new();
root_open(&mut w, "p:tagLst", A::new());
for (n, v) in tags.iter().take(10_000) {
w.empty("p:tag", A::new().a("name", n).a("val", v));
}
w.close("p:tagLst");
self.pkg.xml_part(&name, CT_TAGS, w.finish());
o.rels.add_new("tags", &opc::relative(&o.name, &name), false)
}
/// An unchanged Office 2016 chart's `chartEx` part and its relationship id.
pub fn chartex_rel(&mut self, o: &mut Out, c: &deckcraft_model::Chart) -> Option<String> {
let (xml, preserved) = chart::chartex_part(c)?;
self.n_chartex += 1;
let name = format!("ppt/charts/chartEx{}.xml", self.n_chartex);
self.pkg.xml_part(&name, CT_CHARTEX, xml);
if preserved {
chart::write_kept(&mut self.pkg, &name, c, &mut self.n_kept);
} else if !c.kept.parts.is_empty() {
log::warn!("pptx: chart data changed; the embedded workbook was not written back");
}
Some(o.rels.add_new(RT_CHARTEX, &opc::relative(&o.name, &name), false))
}
pub fn chart_rel(&mut self, o: &mut Out, c: &deckcraft_model::Chart) -> String {
self.n_chart += 1;
let name = format!("ppt/charts/chart{}.xml", self.n_chart);
let (xml, preserved) = chart::chart_xml(c);
self.pkg.xml_part(&name, CT_CHART, xml);
if preserved {
chart::write_kept(&mut self.pkg, &name, c, &mut self.n_kept);
} else if !c.kept.parts.is_empty() {
log::warn!("pptx: chart data changed; the embedded workbook was not written back");
}
o.rels.add_new("chart", &opc::relative(&o.name, &name), false)
}
}
/// `p:custDataLst` pointing at a tags part, when there are tags.
pub fn cust_data(w: &mut W, x: &mut Exp, o: &mut Out, tags: &Tags) {
if tags.is_empty() {
return;
}
let id = x.tags_rel(o, tags);
w.open0("p:custDataLst");
w.empty("p:tags", A::new().a("r:id", id));
w.close("p:custDataLst");
}
fn root_open(w: &mut W, tag: &str, extra: A) {
let mut a = A::new().a("xmlns:a", NS_A).a("xmlns:r", NS_R).a("xmlns:p", NS_P);
a.v.extend(extra.v);
w.open(tag, a);
}
fn background(w: &mut W, x: &mut Exp, o: &mut Out, bg: &Background) {
w.open0("p:bg");
match bg {
Background::Fill { fill } => {
w.open0("p:bgPr");
match fill {
deckcraft_model::Fill::Background | deckcraft_model::Fill::Group => w.empty0("a:noFill"),
f => dml::fill(w, x, o, f),
}
w.empty0("a:effectLst");
w.close("p:bgPr");
}
Background::Ref { idx, color } => {
let idx = if (1..=3).contains(idx) || (1001..=1003).contains(idx) { *idx } else { 1001 };
w.open("p:bgRef", A::new().a("idx", idx));
dml::color(w, color);
w.close("p:bgRef");
}
}
w.close("p:bg");
}
type Tags = [(String, String)];
fn csld(w: &mut W, x: &mut Exp, o: &mut Out, name: &str, bg: Option<&Background>, list: &[Shape], tags: &Tags) -> shapes::IdMap {
w.open("p:cSld", A::new().o("name", (!name.is_empty()).then_some(name)));
if let Some(bg) = bg {
background(w, x, o, bg);
}
w.open0("p:spTree");
shapes::tree_header(w);
let mut ids = shapes::IdMap::build(list);
{
let mut cx = shapes::Ctx { ids: &mut ids, written: Default::default() };
shapes::shapes(w, x, o, &mut cx, list, 0);
}
w.close("p:spTree");
cust_data(w, x, o, tags);
w.close("p:cSld");
ids
}
const CLR_KEYS: [(&str, &str); 12] = [
("bg1", "lt1"),
("tx1", "dk1"),
("bg2", "lt2"),
("tx2", "dk2"),
("accent1", "accent1"),
("accent2", "accent2"),
("accent3", "accent3"),
("accent4", "accent4"),
("accent5", "accent5"),
("accent6", "accent6"),
("hlink", "hlink"),
("folHlink", "folHlink"),
];
fn clr_map(w: &mut W, map: &[(String, String)]) {
w.empty("p:clrMap", clr_map_attrs(map));
}
/// `p:clrMapOvr`: the layout's or slide's own colour map, else `a:masterClrMapping`.
fn clr_map_ovr(w: &mut W, map: Option<&[(String, String)]>) {
w.open0("p:clrMapOvr");
match map {
Some(m) => w.empty("a:overrideClrMapping", clr_map_attrs(m)),
None => w.empty0("a:masterClrMapping"),
}
w.close("p:clrMapOvr");
}
/// The twelve colour map attributes, each a theme slot (the default for anything else).
fn clr_map_attrs(map: &[(String, String)]) -> A {
let mut a = A::new();
for (k, d) in CLR_KEYS {
let v = map
.iter()
.find(|(mk, _)| mk == k)
.map(|(_, v)| v.as_str())
.filter(|v| deckcraft_color::SchemeSlot::from_xml(v).is_some_and(|s| deckcraft_color::SchemeSlot::THEME.contains(&s)))
.unwrap_or(d);
a = a.a(k, v);
}
a
}
fn ext_list(w: &mut W, raw: Option<&str>) {
let Some(raw) = raw.filter(|r| !r.trim().is_empty()) else { return };
// Only keep well-formed extension elements.
let Ok(d) = crate::xml::parse(format!("<x>{raw}</x>").as_bytes()) else { return };
let exts: Vec<String> = d.root.elements().filter(|e| e.is("ext") && e.has_attr("uri")).map(|e| e.to_xml()).collect();
if exts.is_empty() {
return;
}
w.open0("p:extLst");
for e in exts {
w.raw(&e);
}
w.close("p:extLst");
}
/// Strip an `<p:extLst>` wrapper (masters/layouts keep the whole element).
fn ext_children(raw: Option<&str>) -> Option<String> {
let raw = raw?;
let d = crate::xml::parse(raw.as_bytes()).ok()?;
if d.root.is("extLst") {
let ns = d.ns_decls();
return Some(d.root.elements().map(|e| crate::read::keep_xml(e, &ns)).collect());
}
Some(raw.to_string())
}
/// The slide's extension list, plus the modern-comments anchor when the slide has a threaded
/// comment part: the rel reference is how PowerPoint finds it.
fn slide_ext_list(w: &mut W, raw: Option<&str>, comment_rel: Option<&str>) {
let mut exts: Vec<String> = raw
.filter(|r| !r.trim().is_empty())
.and_then(|raw| crate::xml::parse(format!("<x>{raw}</x>").as_bytes()).ok())
.map(|d| d.root.elements().filter(|e| e.is("ext") && e.has_attr("uri")).map(|e| e.to_xml()).collect())
.unwrap_or_default();
if let Some(rid) = comment_rel {
let mut e = W::frag();
e.open("p:ext", A::new().a("uri", crate::COMMENTS_EXT_URI));
e.empty("p188:commentRel", A::new().a("xmlns:p188", NS_P188).a("r:id", rid));
e.close("p:ext");
exts.push(e.s);
}
if exts.is_empty() {
return;
}
w.open0("p:extLst");
for e in exts {
w.raw(&e);
}
w.close("p:extLst");
}
fn notes_master_shapes(size: deckcraft_geom::Size) -> Vec<Shape> {
let (w, h) = (size.width, size.height);
let mk = |id: u32, name: &str, kind: PhType, idx: u32, x: f64, y: f64, ww: f64, hh: f64| Shape {
id: ShapeId(id),
name: name.into(),
xfrm: Some(Xfrm::new(x, y, ww, hh)),
ph: Some(Placeholder { kind, idx, size: (kind != PhType::SlideImage).then(|| "quarter".to_string()), ..Default::default() }),
text: (kind != PhType::SlideImage).then(TextBody::default),
..Default::default()
};
let mut img = mk(4, "Slide Image Placeholder 3", PhType::SlideImage, 2, w * 0.125, h * 0.125, w * 0.75, h * 0.375);
img.fill = Some(deckcraft_model::Fill::None);
img.line = Some(deckcraft_model::Line::solid(deckcraft_model::ColorRef::rgb(deckcraft_color::Rgba::BLACK), 1.0));
let mut body = mk(5, "Notes Placeholder 4", PhType::Body, 3, w * 0.1, h * 0.53, w * 0.8, h * 0.36);
if let Some(t) = body.text.as_mut() {
t.paragraphs = vec![Paragraph::new("Click to edit Master text styles")];
}
vec![
mk(2, "Header Placeholder 1", PhType::Header, 0, 0.0, 0.0, w * 0.43, h * 0.05),
mk(3, "Date Placeholder 2", PhType::Date, 1, w * 0.57, 0.0, w * 0.43, h * 0.05),
img,
body,
mk(6, "Footer Placeholder 5", PhType::Footer, 4, 0.0, h * 0.95, w * 0.43, h * 0.05),
mk(7, "Slide Number Placeholder 6", PhType::SlideNum, 5, w * 0.57, h * 0.95, w * 0.43, h * 0.05),
]
}
/// What the notes master should be on save. A master we read is written back, including its
/// header, footer, date and slide-number text. A deck that has never had one gets the placeholders
/// we generate.
struct NotesMasterWrite {
shapes: Vec<Shape>,
background: Option<Background>,
color_map: Vec<(String, String)>,
style: ListStyle,
theme: Option<Theme>,
}
fn notes_master_write(p: &Presentation) -> Option<NotesMasterWrite> {
let nm = p.notes_master.as_deref();
let kept = nm.filter(|m| !m.shapes.is_empty());
let has_notes = p.slides.iter().any(|s| !s.notes.is_empty());
if !has_notes && nm.is_none() {
return None;
}
let default_bg = || Background::Ref { idx: 1001, color: deckcraft_model::ColorRef::scheme(deckcraft_color::SchemeSlot::Bg1) };
Some(match kept {
Some(m) => NotesMasterWrite {
shapes: m.shapes.clone(),
background: Some(m.background.clone().unwrap_or_else(default_bg)),
color_map: m.color_map.clone(),
style: if m.body_style.is_empty() { notes_style() } else { m.body_style.clone() },
theme: Some(m.theme.clone()),
},
// A master without placeholders of its own gets PowerPoint's defaults, keeping its
// background and colour map.
None => NotesMasterWrite {
shapes: notes_master_shapes(p.notes_size),
background: Some(nm.and_then(|m| m.background.clone()).unwrap_or_else(default_bg)),
color_map: nm.map(|m| m.color_map.clone()).unwrap_or_default(),
style: notes_style(),
theme: None,
},
})
}
fn notes_style() -> ListStyle {
let mut ls = deckcraft_model::text::ListStyle::default();
for i in 0..9u8 {
ls.set(
i,
deckcraft_model::text::LevelStyle {
para: deckcraft_model::text::ParaProps {
margin_left: Some(36.0 * i as f64),
align: Some(deckcraft_model::text::Align::Left),
..Default::default()
},
run: deckcraft_model::text::RunProps {
size: Some(12.0),
font: Some("+mn-lt".into()),
fill: Some(deckcraft_model::Fill::solid(deckcraft_model::ColorRef::scheme(deckcraft_color::SchemeSlot::Tx1))),
..Default::default()
},
},
);
}
ls
}
/// A plausible xsd:dateTime (`YYYY-MM-DD[THH:MM:SS(.frac)?(Z|±HH:MM)?]`): the ranges are
/// checked, so a model value like `2025-13-45T99:99` falls back to the default instead of
/// reaching a required `dt`/`created` attribute.
fn valid_date(s: &str) -> bool {
let b = s.as_bytes();
let n = |r: std::ops::Range<usize>| s.get(r).and_then(|v| v.parse::<u32>().ok());
let (Some(_), Some(mo), Some(d)) = (n(0..4), n(5..7), n(8..10)) else { return false };
if b.get(4) != Some(&b'-') || b.get(7) != Some(&b'-') || !(1..=12).contains(&mo) || !(1..=31).contains(&d) {
return false;
}
match b.get(10) {
None => true,
Some(b'T') => match (n(11..13), n(14..16), n(17..19)) {
(Some(h), Some(mi), Some(sec)) => h <= 23 && mi <= 59 && sec <= 60 && b.get(13) == Some(&b':') && b.get(16) == Some(&b':'),
_ => false,
},
Some(_) => false,
}
}
/// A copy of the presentation with every slide pointing at a layout that exists.
fn sanitized(p: &Presentation) -> std::borrow::Cow<'_, Presentation> {
let mut need = p.masters.is_empty() || p.masters.iter().any(|m| m.layouts.is_empty());
need |= p.slides.iter().any(|s| p.layout(s.layout).is_none());
if !need {
return std::borrow::Cow::Borrowed(p);
}
let mut q = p.clone();
if q.masters.is_empty() {
let (m, next) = defaults::build_master(q.slide_size, Default::default(), q.next_id.max(1));
q.next_id = next;
q.masters.push(Arc::new(m));
}
for m in q.masters.iter_mut() {
if m.layouts.is_empty() {
// An exhausted id space exports without the synthesized layout rather than with a
// duplicated one (#407).
let Some(raw) = q.next_id.max(1).checked_add(1) else { continue };
let id = LayoutId(raw);
q.next_id = raw;
Arc::make_mut(m).layouts.push(Layout {
id,
name: "Blank".into(),
kind: deckcraft_model::LayoutType::Blank,
show_master_shapes: true,
..Default::default()
});
}
}
let first = q.masters.first().and_then(|m| m.layouts.first()).map(|l| l.id).unwrap_or_default();
let ok: Vec<LayoutId> = q.masters.iter().flat_map(|m| m.layouts.iter().map(|l| l.id)).collect();
for s in q.slides.iter_mut() {
if !ok.contains(&s.layout) {
Arc::make_mut(s).layout = first;
}
}
std::borrow::Cow::Owned(q)
}
pub fn export(p: &Presentation, main_ct: &str) -> Result<Vec<u8>, PptxError> {
let p = sanitized(p);
let p: &Presentation = &p;
let mut x = Exp {
p,
pkg: PackageOut::default(),
media_parts: HashMap::new(),
n_image: 0,
n_media: 0,
n_chart: 0,
n_diagram: 0,
n_tags: 0,
n_chartex: 0,
n_kept: 0,
slide_parts: HashMap::new(),
table_styles: vec![],
placeholder: None,
};
for (i, s) in p.slides.iter().enumerate() {
x.slide_parts.insert(s.id, format!("ppt/slides/slide{}.xml", i + 1));
}
let mut pres = Out::new("ppt/presentation.xml");
// Masters, themes and layouts.
let mut master_rids = vec![];
let mut layout_parts: HashMap<LayoutId, String> = HashMap::new();
let mut n_layout = 0u32;
let mut big_id: u64 = 2_147_483_648;
for (mi, m) in p.masters.iter().enumerate() {
let mname = format!("ppt/slideMasters/slideMaster{}.xml", mi + 1);
let tname = format!("ppt/theme/theme{}.xml", mi + 1);
let mut mo = Out::new(&mname);
let mut lrids = vec![];
for l in &m.layouts {
n_layout += 1;
let lname = format!("ppt/slideLayouts/slideLayout{n_layout}.xml");
layout_parts.insert(l.id, lname.clone());
let rid = mo.rels.add("slideLayout", &opc::relative(&mname, &lname), false);
lrids.push(rid);
let mut lo = Out::new(&lname);
lo.rels.add("slideMaster", &opc::relative(&lname, &mname), false);
let xml = layout_xml(&mut x, &mut lo, l);
x.pkg.xml_part(&lname, CT_LAYOUT, xml);
x.pkg.rels(&lname, &lo.rels);
}
mo.rels.add("theme", &opc::relative(&mname, &tname), false);
let mut to = Out::new(&tname);
let txml = theme::theme_xml(&mut x, &mut to, &m.theme);
x.pkg.xml_part(&tname, CT_THEME, txml);
x.pkg.rels(&tname, &to.rels);
let master_id = big_id;
big_id += 1;
let mut layout_ids = vec![];
for rid in lrids {
layout_ids.push((big_id, rid));
big_id += 1;
}
let xml = master_xml(&mut x, &mut mo, m, &layout_ids);
x.pkg.xml_part(&mname, CT_MASTER, xml);
x.pkg.rels(&mname, &mo.rels);
master_rids.push((master_id, pres.rels.add("slideMaster", &opc::relative("ppt/presentation.xml", &mname), false)));
}
// Notes master when a slide has notes, or the file already has one (its header and footer
// live on the master, not on the notes slides).
let notes_master = "ppt/notesMasters/notesMaster1.xml";
let mut notes_master_rid = None;
if let Some(nm) = notes_master_write(p) {
let tname = format!("ppt/theme/theme{}.xml", p.masters.len() + 1);
let mut no = Out::new(notes_master);
no.rels.add("theme", &opc::relative(notes_master, &tname), false);
let theme = nm.theme.or_else(|| p.masters.first().map(|m| m.theme.clone())).unwrap_or_default();
let mut to = Out::new(&tname);
let txml = theme::theme_xml(&mut x, &mut to, &theme);
x.pkg.xml_part(&tname, CT_THEME, txml);
x.pkg.rels(&tname, &to.rels);
let mut w = W::new();
root_open(&mut w, "p:notesMaster", A::new());
csld(&mut w, &mut x, &mut no, "", nm.background.as_ref(), &nm.shapes, &[]);
clr_map(&mut w, &nm.color_map);
dml::list_style(&mut w, &mut x, &mut no, "p:notesStyle", &nm.style);
w.close("p:notesMaster");
x.pkg.xml_part(notes_master, CT_NOTES_MASTER, w.finish());
x.pkg.rels(notes_master, &no.rels);
notes_master_rid = Some(pres.rels.add("notesMaster", &opc::relative("ppt/presentation.xml", notes_master), false));
}
// Handout master. Its header, footer, date and slide-number text live on this part; a deck
// that has never had one does not gain an empty master on save.
let handout_path = "ppt/handoutMasters/handoutMaster1.xml";
let mut handout_rid = None;
if let Some(hm) = p.handout_master.as_ref() {
let tindex = p.masters.len() + 1 + usize::from(notes_master_rid.is_some());
let tname = format!("ppt/theme/theme{tindex}.xml");
let mut ho = Out::new(handout_path);
ho.rels.add("theme", &opc::relative(handout_path, &tname), false);
let mut to = Out::new(&tname);
let txml = theme::theme_xml(&mut x, &mut to, &hm.theme);
x.pkg.xml_part(&tname, CT_THEME, txml);
x.pkg.rels(&tname, &to.rels);
let mut w = W::new();
root_open(&mut w, "p:handoutMaster", A::new());
csld(&mut w, &mut x, &mut ho, &hm.name, hm.background.as_ref(), &hm.shapes, &[]);
clr_map(&mut w, &hm.color_map);
w.close("p:handoutMaster");
x.pkg.xml_part(handout_path, CT_HANDOUT_MASTER, w.finish());
x.pkg.rels(handout_path, &ho.rels);
handout_rid = Some(pres.rels.add("handoutMaster", &opc::relative("ppt/presentation.xml", handout_path), false));
}
// Comment authors.
let mut authors: Vec<(String, String, u32)> = vec![];
let mut author_map: std::collections::HashMap<String, usize> = std::collections::HashMap::new();
let mut n_comments = 0u32;
// Slides.
let mut slide_rids = vec![];
for (i, s) in p.slides.iter().enumerate() {
let sname = format!("ppt/slides/slide{}.xml", i + 1);
let mut so = Out::new(&sname);
if let Some(lp) = layout_parts.get(&s.layout) {
so.rels.add("slideLayout", &opc::relative(&sname, lp), false);
}
if !s.notes.is_empty() {
let nname = format!("ppt/notesSlides/notesSlide{}.xml", i + 1);
so.rels.add("notesSlide", &opc::relative(&sname, &nname), false);
let mut no = Out::new(&nname);
no.rels.add("notesMaster", &opc::relative(&nname, notes_master), false);
no.rels.add("slide", &opc::relative(&nname, &sname), false);
let xml = notes_xml(&mut x, &mut no, &s.notes);
x.pkg.xml_part(&nname, CT_NOTES, xml);
x.pkg.rels(&nname, &no.rels);
}
let mut comment_rel = None;
if !s.comments.is_empty() {
n_comments += 1;
let cname = format!("ppt/comments/comment{n_comments}.xml");
so.rels.add("comments", &opc::relative(&sname, &cname), false);
x.pkg.xml_part(&cname, CT_COMMENTS, comments_xml(&s.comments, &mut authors, &mut author_map));
// The modern threaded part next to the flattened legacy one (issue #70):
// PowerPoint 2021+ and DeckCraft read replies and resolved state from it,
// older readers keep the legacy part.
let mname = format!("ppt/comments/modernComment{n_comments}.xml");
let rid = so.rels.add(RT_COMMENTS_MODERN, &opc::relative(&sname, &mname), false);
x.pkg.xml_part(&mname, CT_COMMENTS_MODERN, modern_comments_xml(&s.comments, &cname, &mut authors, &mut author_map));
comment_rel = Some(rid);
}
let xml = slide_xml(&mut x, &mut so, s, comment_rel.as_deref());
x.pkg.xml_part(&sname, CT_SLIDE, xml);
x.pkg.rels(&sname, &so.rels);
slide_rids.push(pres.rels.add("slide", &opc::relative("ppt/presentation.xml", &sname), false));
}
if !authors.is_empty() {
let name = "ppt/commentAuthors.xml";
let mut w = W::new();
root_open(&mut w, "p:cmAuthorLst", A::new());
for (i, (n, ini, last)) in authors.iter().enumerate() {
w.empty("p:cmAuthor", A::new().a("id", i).a("name", n).a("initials", ini).a("lastIdx", last).a("clrIdx", i % 8));
}
w.close("p:cmAuthorLst");
x.pkg.xml_part(name, CT_AUTHORS, w.finish());
pres.rels.add("commentAuthors", "commentAuthors.xml", false);
// The modern authors part the threaded comments' authorId GUIDs point at.
let mut w = W::new();
w.open("p188:authorLst", A::new().a("xmlns:p188", NS_P188));
for (n, ini, _) in authors.iter() {
w.empty("p188:author", A::new().a("id", author_guid(n)).a("name", n).a("initials", ini).a("userId", "").a("providerId", "None"));
}
w.close("p188:authorLst");
x.pkg.xml_part("ppt/authors.xml", CT_AUTHORS_MODERN, w.finish());
pres.rels.add(RT_AUTHORS_MODERN, "authors.xml", false);
}
// Presentation-level parts.
let theme1 = "theme/theme1.xml";
pres.rels.add("theme", theme1, false);
pres.rels.add("presProps", "presProps.xml", false);
pres.rels.add("viewProps", "viewProps.xml", false);
pres.rels.add("tableStyles", "tableStyles.xml", false);
x.pkg.xml_part("ppt/presProps.xml", CT_PRES_PROPS, pres_props_xml(p));
x.pkg.xml_part("ppt/viewProps.xml", CT_VIEW_PROPS, view_props_xml(p));
let ts = crate::tables::table_styles_xml(&x.table_styles, &p.table_styles);
x.pkg.xml_part("ppt/tableStyles.xml", CT_TABLE_STYLES, ts);
let pxml = presentation_xml(&mut x, &mut pres, &master_rids, notes_master_rid.as_deref(), handout_rid.as_deref(), &slide_rids);
x.pkg.xml_part("ppt/presentation.xml", main_ct, pxml);
// Kept parts never replace a part the writer makes.
let kept: Vec<_> = p
.kept_parts
.iter()
.filter(|k| {
let n = k.name.to_ascii_lowercase();
!n.is_empty()
&& !n.contains("..")
&& !n.starts_with("ppt/")
&& !n.starts_with("docprops/core")
&& !n.starts_with("docprops/app")
&& !n.starts_with("[content_types]")
&& n != "_rels/.rels"
})
.collect();
for k in kept.iter().filter(|k| !k.rel_type.is_empty() && !k.from_root) {
pres.rels.add_new(&k.rel_type, &opc::relative("ppt/presentation.xml", &k.name), false);
}
x.pkg.rels("ppt/presentation.xml", &pres.rels);
for k in &kept {
if k.content_type.is_empty() {
x.pkg.raw(&k.name, k.xml.clone().into_bytes());
} else {
x.pkg.xml_part(&k.name, &k.content_type, k.xml.clone().into_bytes());
}
}
// Document properties and package relationships.
x.pkg.xml_part("docProps/core.xml", CT_CORE, core_xml(p));
x.pkg.xml_part("docProps/app.xml", CT_APP, app_xml(p));
let mut root = RelsOut::default();
root.add("officeDocument", "ppt/presentation.xml", false);
root.add(opc::RT_CORE, "docProps/core.xml", false);
root.add("extended-properties", "docProps/app.xml", false);
for k in kept.iter().filter(|k| !k.rel_type.is_empty() && k.from_root) {
root.add_new(&k.rel_type, &k.name, false);
}
x.pkg.rels("", &root);
x.pkg.finish()
}
fn layout_xml(x: &mut Exp, o: &mut Out, l: &Layout) -> Vec<u8> {
let mut w = W::new();
root_open(
&mut w,
"p:sldLayout",
A::new().o("showMasterSp", (!l.show_master_shapes).then_some("0")).a("type", l.kind.xml()).t("preserve", l.preserve),
);
csld(&mut w, x, o, &l.name, l.background.as_ref(), &l.shapes, &[]);
clr_map_ovr(&mut w, l.color_map.as_deref());
ext_list(&mut w, ext_children(l.raw_ext.as_deref()).as_deref());
w.close("p:sldLayout");
w.finish()
}
fn master_xml(x: &mut Exp, o: &mut Out, m: &Master, layouts: &[(u64, String)]) -> Vec<u8> {
let mut w = W::new();
root_open(&mut w, "p:sldMaster", A::new().t("preserve", m.preserve));
csld(&mut w, x, o, &m.name, m.background.as_ref(), &m.shapes, &[]);
clr_map(&mut w, &m.color_map);
w.open0("p:sldLayoutIdLst");
for (id, rid) in layouts {
w.empty("p:sldLayoutId", A::new().a("id", id).a("r:id", rid));
}
w.close("p:sldLayoutIdLst");
w.open0("p:txStyles");
let (dt, db, dother) = defaults::master_styles();
let pick = |s: &deckcraft_model::text::ListStyle, d: deckcraft_model::text::ListStyle| if s.is_empty() { d } else { s.clone() };
dml::list_style(&mut w, x, o, "p:titleStyle", &pick(&m.title_style, dt));
dml::list_style(&mut w, x, o, "p:bodyStyle", &pick(&m.body_style, db));
dml::list_style(&mut w, x, o, "p:otherStyle", &pick(&m.other_style, dother));
w.close("p:txStyles");
ext_list(&mut w, ext_children(m.raw_ext.as_deref()).as_deref());
w.close("p:sldMaster");
w.finish()
}
fn slide_xml(x: &mut Exp, o: &mut Out, s: &Slide, comment_rel: Option<&str>) -> Vec<u8> {
let mut w = W::new();
root_open(&mut w, "p:sld", A::new().o("showMasterSp", (!s.show_master_shapes).then_some("0")).o("show", s.hidden.then_some("0")));
let ids = csld(&mut w, x, o, &s.name, s.background.as_ref(), &s.shapes, &s.tags);
clr_map_ovr(&mut w, s.color_map.as_deref());
if let Some(t) = &s.transition {
timing::transition(&mut w, x, o, t);
}
if !s.animations.is_empty() {
timing::timing(&mut w, x, &s.animations, &s.shapes, &ids);
}
slide_ext_list(&mut w, s.raw_ext.as_deref(), comment_rel);
w.close("p:sld");
w.finish()
}
fn notes_xml(x: &mut Exp, o: &mut Out, notes: &TextBody) -> Vec<u8> {
let mut w = W::new();
root_open(&mut w, "p:notes", A::new());
let img = Shape {
id: ShapeId(2),
name: "Slide Image Placeholder 1".into(),
ph: Some(Placeholder { kind: PhType::SlideImage, ..Default::default() }),
..Default::default()
};
let mut tb = notes.clone();
tb.body = Default::default();
let body = Shape {
id: ShapeId(3),
name: "Notes Placeholder 2".into(),
ph: Some(Placeholder { kind: PhType::Body, idx: 1, ..Default::default() }),
text: Some(tb),
..Default::default()
};
csld(&mut w, x, o, "", None, &[img, body], &[]);
w.open0("p:clrMapOvr");
w.empty0("a:masterClrMapping");
w.close("p:clrMapOvr");
w.close("p:notes");
w.finish()
}
fn comments_xml(list: &[Comment], authors: &mut Vec<(String, String, u32)>, author_map: &mut std::collections::HashMap<String, usize>) -> Vec<u8> {
let mut w = W::new();
root_open(&mut w, "p:cmLst", A::new());
let mut flat: Vec<&Comment> = vec![];
for c in list.iter().take(10_000) {
flat.push(c);
for r in c.replies.iter().take(1000) {
flat.push(r);
}
}
for c in flat {
let ai = author_slot(c, authors, author_map);
let idx = match authors.get_mut(ai) {
Some(a) => {
a.2 += 1;
a.2
}
None => 1,
};
let dt = if valid_date(&c.date) { c.date.clone() } else { "2024-01-01T00:00:00.000".into() };
w.open("p:cm", A::new().a("authorId", ai).a("dt", dt).a("idx", idx));
let pos = |v: f64| if v.is_finite() { (v * 8.0).round().clamp(0.0, 1.0e9) as i64 } else { 0 };
w.empty("p:pos", A::new().a("x", pos(c.x)).a("y", pos(c.y)));
w.elt("p:text", &c.text);
w.close("p:cm");
}
w.close("p:cmLst");
w.finish()
}
/// The author's slot in the shared bucket list, adding them on first use. Legacy parts index the
/// list by number, the modern authors part gives every slot a GUID.
fn author_slot(c: &Comment, authors: &mut Vec<(String, String, u32)>, map: &mut std::collections::HashMap<String, usize>) -> usize {
let author = if c.author.is_empty() { "Author" } else { &c.author };
if let Some(&i) = map.get(author) {
return i;
}
let ini = if c.initials.is_empty() { author.chars().filter(|ch| ch.is_alphabetic()).take(2).collect() } else { c.initials.clone() };
let idx = authors.len();
authors.push((author.to_string(), ini, 0));
map.insert(author.to_string(), idx);
idx
}
/// The modern (p188) threaded-comment part: replies nest and the resolved state is kept, which
/// the flattened legacy part cannot express (issue #70).
fn modern_comments_xml(
list: &[Comment],
part: &str,
authors: &mut Vec<(String, String, u32)>,
author_map: &mut std::collections::HashMap<String, usize>,
) -> Vec<u8> {
let mut w = W::new();
w.open("p188:cmLst", A::new().a("xmlns:p188", NS_P188).a("xmlns:a", NS_A).a("xmlns:r", NS_R));
for (ti, c) in list.iter().take(10_000).enumerate() {
modern_comment(&mut w, c, part, ti, authors, author_map, 0);
}
w.close("p188:cmLst");
w.finish()
}
fn modern_comment(
w: &mut W,
c: &Comment,
part: &str,
ti: usize,
authors: &mut Vec<(String, String, u32)>,
author_map: &mut std::collections::HashMap<String, usize>,
depth: usize,
) {
let ai = author_slot(c, authors, author_map);
let author = authors.get(ai).map(|(n, _, _)| n.clone()).unwrap_or_default();
let dt = if valid_date(&c.date) { c.date.clone() } else { "2024-01-01T00:00:00.000".into() };
let mut a = A::new().a("id", crate::tables::guid(&format!("deckcraft-comment:{part}:{ti}"))).a("authorId", author_guid(&author)).a("created", dt);
if c.resolved {
a = a.a("status", "resolved");
}
w.open("p188:cm", a);
w.empty0("p188:unknownAnchor");
let emu = |v: f64| if v.is_finite() { (v * 12_700.0).round().clamp(0.0, 1.0e9) as i64 } else { 0 };
w.empty("p188:pos", A::new().a("x", emu(c.x)).a("y", emu(c.y)));
if depth < 4 && !c.replies.is_empty() {
w.open0("p188:replyLst");
for (ri, r) in c.replies.iter().take(1000).enumerate() {
let ri_ai = author_slot(r, authors, author_map);
let r_author = authors.get(ri_ai).map(|(n, _, _)| n.clone()).unwrap_or_default();
let rdt = if valid_date(&r.date) { r.date.clone() } else { "2024-01-01T00:00:00.000".into() };
let mut ra = A::new()
.a("id", crate::tables::guid(&format!("deckcraft-comment:{part}:{ti}:{ri}")))
.a("authorId", author_guid(&r_author))
.a("created", rdt);
if r.resolved {
ra = ra.a("status", "resolved");
}
w.open("p188:reply", ra);
tx_body(w, &r.text);
w.close("p188:reply");
}
w.close("p188:replyLst");
}
tx_body(w, &c.text);
w.close("p188:cm");
}
/// An `a:txBody` with one paragraph per line, the shape the reader re-joins with `\n`.
fn tx_body(w: &mut W, text: &str) {
w.open0("p188:txBody");
w.empty0("a:bodyPr");
for line in text.split('\n') {
w.open0("a:p");
w.open0("a:r");
w.empty("a:rPr", A::new().a("lang", "en-US"));
w.elt("a:t", line);
w.close("a:r");
w.close("a:p");
}
w.close("p188:txBody");
}
/// The modern author id for a name: the same GUID the authors part writes.
fn author_guid(name: &str) -> String {
crate::tables::guid(&format!("deckcraft-comment-author:{name}"))
}
/// Sections with every slide in exactly one section, in slide order.
fn section_slides(p: &Presentation) -> Vec<(String, Vec<usize>)> {
let mut out: Vec<(String, Vec<usize>)> = p.sections.iter().map(|s| (s.name.clone(), vec![])).collect();
if out.is_empty() {
return out;
}
let mut cur = 0usize;
for (i, s) in p.slides.iter().enumerate() {
if let Some(k) = p.sections.iter().position(|sec| sec.slides.contains(&s.id))
&& k >= cur
{
cur = k;
}
if let Some(sec) = out.get_mut(cur) {
sec.1.push(i);
}
}
out
}
/// One embedded typeface, with the relationship id of each face that had bytes.
struct WrittenFont {
typeface: String,
panose: Option<String>,
pitch_family: Option<u8>,
charset: Option<u8>,
regular: Option<String>,
bold: Option<String>,
italic: Option<String>,
bold_italic: Option<String>,
}
impl WrittenFont {
fn any(&self) -> bool {
self.regular.is_some() || self.bold.is_some() || self.italic.is_some() || self.bold_italic.is_some()
}
}
/// Font parts for `p:embeddedFontLst`. One part per distinct media item, named `ppt/fonts/fontN.fntdata`.
fn write_embedded_fonts(x: &mut Exp, o: &mut Out) -> Vec<WrittenFont> {
struct Plan {
typeface: String,
panose: Option<String>,
pitch_family: Option<u8>,
charset: Option<u8>,
regular: Option<MediaId>,
bold: Option<MediaId>,
italic: Option<MediaId>,
bold_italic: Option<MediaId>,
}
let mut plans = Vec::new();
for font in x.p.embedded_fonts.iter().take(64) {
let typeface = font.typeface.trim();
if typeface.is_empty() {
continue;
}
plans.push(Plan {
typeface: typeface.chars().take(255).collect(),
panose: font.panose.clone().filter(|s| s.len() == 20 && s.chars().all(|c| c.is_ascii_hexdigit())),
pitch_family: font.pitch_family,
charset: font.charset,
regular: font.regular,
bold: font.bold,
italic: font.italic,
bold_italic: font.bold_italic,
});
}
let mut seen_part: HashMap<MediaId, String> = HashMap::new();
let mut n = 0u32;
let mut rel = |x: &mut Exp, o: &mut Out, id: Option<MediaId>| -> Option<String> {
let id = id?;
if let Some(rid) = seen_part.get(&id) {
return Some(rid.clone());
}
let m = x.p.media(id)?;
if m.data.is_empty() || m.data.len() > 32 * 1024 * 1024 {
return None;
}
let bytes = m.data.as_ref().clone();
n = n.saturating_add(1);
let name = format!("ppt/fonts/font{n}.fntdata");
x.pkg.binary(&name, "application/x-fontdata", bytes);
let rid = o.rels.add("font", &opc::relative("ppt/presentation.xml", &name), false);
seen_part.insert(id, rid.clone());
Some(rid)
};
let mut seen_face = Vec::new();
let mut out = Vec::new();
for font in plans {
let written = WrittenFont {
typeface: font.typeface,
panose: font.panose,
pitch_family: font.pitch_family,
charset: font.charset,
regular: rel(x, o, font.regular),
bold: rel(x, o, font.bold),
italic: rel(x, o, font.italic),
bold_italic: rel(x, o, font.bold_italic),
};
if written.any() && !seen_face.iter().any(|s| s == &written.typeface) {
seen_face.push(written.typeface.clone());
out.push(written);
}
}
out
}
fn presentation_xml(x: &mut Exp, o: &mut Out, masters: &[(u64, String)], notes: Option<&str>, handout: Option<&str>, slides: &[String]) -> Vec<u8> {
let fonts = write_embedded_fonts(x, o);
let p = x.p;
let mut w = W::new();
let first = (p.first_slide_number != 1).then_some(p.first_slide_number.min(9999));
root_open(&mut w, "p:presentation", A::new().a("saveSubsetFonts", 1).t("embedTrueTypeFonts", !fonts.is_empty()).o("firstSlideNum", first));
w.open0("p:sldMasterIdLst");
for (id, rid) in masters {
w.empty("p:sldMasterId", A::new().a("id", id).a("r:id", rid));
}
w.close("p:sldMasterIdLst");
if let Some(n) = notes {
w.open0("p:notesMasterIdLst");
w.empty("p:notesMasterId", A::new().a("r:id", n));
w.close("p:notesMasterIdLst");
}
if let Some(h) = handout {
w.open0("p:handoutMasterIdLst");
w.empty("p:handoutMasterId", A::new().a("r:id", h));
w.close("p:handoutMasterIdLst");
}
if !slides.is_empty() {
w.open0("p:sldIdLst");
for (i, rid) in slides.iter().enumerate() {
w.empty("p:sldId", A::new().a("id", 256 + i).a("r:id", rid));
}
w.close("p:sldIdLst");
}
let clamp = |v: f64| dml::emu(v).clamp(914_400, 51_206_400);
w.empty("p:sldSz", A::new().a("cx", clamp(p.slide_size.width)).a("cy", clamp(p.slide_size.height)));
w.empty("p:notesSz", A::new().a("cx", dml::emu_pos(p.notes_size.width).max(1)).a("cy", dml::emu_pos(p.notes_size.height).max(1)));
if !fonts.is_empty() {
w.open0("p:embeddedFontLst");
for f in &fonts {
w.open0("p:embeddedFont");
w.empty(
"p:font",
A::new().a("typeface", &f.typeface).o("panose", f.panose.clone()).o("pitchFamily", f.pitch_family).o("charset", f.charset),
);
for (tag, rid) in [("p:regular", &f.regular), ("p:bold", &f.bold), ("p:italic", &f.italic), ("p:boldItalic", &f.bold_italic)] {
if let Some(rid) = rid {
w.empty(tag, A::new().a("r:id", rid));
}
}
w.close("p:embeddedFont");
}
w.close("p:embeddedFontLst");
}
if !p.custom_shows.is_empty() {
w.open0("p:custShowLst");
for (i, cs) in p.custom_shows.iter().enumerate() {
w.open("p:custShow", A::new().a("name", &cs.name).a("id", i));
w.open0("p:sldLst");
for sid in &cs.slides {
if let Some(part) = x.slide_parts.get(sid).cloned() {
let rid = o.rels.add("slide", &opc::relative("ppt/presentation.xml", &part), false);
w.empty("p:sld", A::new().a("r:id", rid));
}
}
w.close("p:sldLst");
w.close("p:custShow");
}
w.close("p:custShowLst");
}
cust_data(&mut w, x, o, &p.tags);
let dts = if p.default_text_style.is_empty() { defaults::default_text_style() } else { p.default_text_style.clone() };
dml::list_style(&mut w, x, o, "p:defaultTextStyle", &dts);
let sections = section_slides(p);
let raw = p.raw_ext.as_deref().filter(|r| !r.trim().is_empty());
if !sections.is_empty() || raw.is_some() {
let mut inner = W::frag();
if !sections.is_empty() {
inner.open("p:ext", A::new().a("uri", crate::SECTION_EXT_URI));
inner.open("p14:sectionLst", A::new().a("xmlns:p14", NS_P14));
for (i, (name, list)) in sections.iter().enumerate() {
inner.open("p14:section", A::new().a("name", name).a("id", crate::tables::guid(&format!("section:{i}:{name}"))));
inner.open0("p14:sldIdLst");
for si in list {
inner.empty("p14:sldId", A::new().a("id", 256 + si));
}
inner.close("p14:sldIdLst");
inner.close("p14:section");
}
inner.close("p14:sectionLst");
inner.close("p:ext");
}
if let Some(r) = raw {
inner.raw(r);
}
ext_list(&mut w, Some(&inner.s));
}
w.close("p:presentation");
w.finish()
}
fn pres_props_xml(p: &Presentation) -> Vec<u8> {
let s = &p.show;
let mut w = W::new();
root_open(&mut w, "p:presentationPr", A::new());
w.open(
"p:showPr",
A::new()
.t("loop", s.loop_until_esc)
.a("showNarration", if s.without_narration { 0 } else { 1 })
.o("showAnimation", s.without_animation.then_some("0"))
.o("useTimings", (!s.use_timings).then_some("0")),
);
match s.show_type.as_str() {
"browsed" => w.empty("p:browse", A::new()),
"kiosk" => w.empty("p:kiosk", A::new()),
_ => w.empty0("p:present"),
}
let custom = s.custom_show.as_ref().and_then(|n| p.custom_shows.iter().position(|c| c.name == *n));
match (custom, s.range) {
(Some(i), _) => w.empty("p:custShow", A::new().a("id", i)),
(None, Some((a, b))) => w.empty("p:sldRg", A::new().a("st", a.max(1)).a("end", b.max(a).max(1))),
_ => w.empty0("p:sldAll"),
}
w.open0("p:penClr");
w.val("a:srgbClr", s.pen_color.hex());
w.close("p:penClr");
w.close("p:showPr");
w.close("p:presentationPr");
w.finish()
}
fn view_props_xml(p: &Presentation) -> Vec<u8> {
let mut w = W::new();
root_open(&mut w, "p:viewPr", A::new());
w.open0("p:normalViewPr");
w.empty("p:restoredLeft", A::new().a("sz", 15620));
w.empty("p:restoredTop", A::new().a("sz", 94660));
w.close("p:normalViewPr");
if !p.guides.is_empty() {
// Drawing guides; `pos` is in eighths of a point (576 per inch).
w.open0("p:slideViewPr");
w.open0("p:cSldViewPr");
w.open0("p:cViewPr");
w.open0("p:scale");
w.empty("a:sx", A::new().a("n", 100).a("d", 100));
w.empty("a:sy", A::new().a("n", 100).a("d", 100));
w.close("p:scale");
w.empty("p:origin", A::new().a("x", 0).a("y", 0));
w.close("p:cViewPr");
w.open0("p:guideLst");
for g in p.guides.iter().take(1000) {
let pos = (g.pos * 8.0).round().clamp(-1.0e9, 1.0e9) as i64;
let a = if g.vertical { A::new().a("pos", pos) } else { A::new().a("orient", "horz").a("pos", pos) };
w.empty("p:guide", a);
}
w.close("p:guideLst");
w.close("p:cSldViewPr");
w.close("p:slideViewPr");
}
w.empty("p:gridSpacing", A::new().a("cx", 76200).a("cy", 76200));
w.close("p:viewPr");
w.finish()
}
fn core_xml(p: &Presentation) -> Vec<u8> {
let pr = &p.props;
let mut w = W::new();
w.open(
"cp:coreProperties",
A::new()
.a("xmlns:cp", "http://schemas.openxmlformats.org/package/2006/metadata/core-properties")
.a("xmlns:dc", "http://purl.org/dc/elements/1.1/")
.a("xmlns:dcterms", "http://purl.org/dc/terms/")
.a("xmlns:dcmitype", "http://purl.org/dc/dcmitype/")
.a("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance"),
);
for (tag, v) in [
("dc:title", &pr.title),
("dc:subject", &pr.subject),
("dc:creator", &pr.author),
("cp:keywords", &pr.keywords),
("dc:description", &pr.comments),
("cp:category", &pr.category),
("cp:lastModifiedBy", &pr.last_modified_by),
] {
if !v.is_empty() {
w.elt(tag, v);
}
}
if pr.revision > 0 {
w.elt("cp:revision", &pr.revision.to_string());
}
for (tag, v) in [("dcterms:created", &pr.created), ("dcterms:modified", &pr.modified)] {
if valid_date(v) {
w.open(tag, A::new().a("xsi:type", "dcterms:W3CDTF"));
w.text(v);
w.close(tag);
}
}
w.close("cp:coreProperties");
w.finish()
}
fn app_xml(p: &Presentation) -> Vec<u8> {
let mut w = W::new();
w.open(
"Properties",
A::new()
.a("xmlns", "http://schemas.openxmlformats.org/officeDocument/2006/extended-properties")
.a("xmlns:vt", "http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes"),
);
w.elt("Application", "DeckCraft");
w.elt("Slides", &p.slides.len().to_string());
w.elt("Notes", &p.slides.iter().filter(|s| !s.notes.is_empty()).count().to_string());
w.elt("HiddenSlides", &p.slides.iter().filter(|s| s.hidden).count().to_string());
if !p.props.company.is_empty() {
w.elt("Company", &p.props.company);
}
w.close("Properties");
w.finish()
}
Reference in New Issue View Git Blame Copy Permalink