Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
//! Slide Master view edits: adding, duplicating, renaming, and deleting
//! slide layouts (and masters), inserting placeholders on layouts, and a
//! layout's Title, Footers, and Hide Background Graphics options.
//!
//! Masters and layouts are addressed by their ids (see
//! [`crate::model::masters`]); their shapes are edited by the ordinary shape
//! and text operations, which take a master's or layout's id as their slide.
//! New layouts follow what PowerPoint writes for Insert Layout: a
//! `preserve`d, `userDrawn` custom layout listed in its master's
//! `p:sldLayoutIdLst` with a fresh id above every master and layout id, so
//! the ids stay unique and PowerPoint opens the file without repair.
use super::header_footer::MASTER_ORDER;
use super::ops::{ParaPatch, PlaceholderKind, RunPatch, TextPos};
use super::parts::copy_part_tree;
use super::shapes::append_to_tree;
use super::slides::{PML_NAMESPACES, TREE_HEADER, drop_creation_id, layout_of};
use super::text::{format_paragraphs, patch_rpr};
use super::xmlutil::{P_PR_ORDER, esc, fresh_shape_id, import_fragment};
use crate::error::{Error, Result};
use crate::model::masters::{MASTER_ID_BASE, MasterPage, entry_id};
use crate::model::presentation::Presentation;
use crate::model::shape::{Placeholder, c_nv_pr, placeholder_of, sp_tree, tree_children};
use crate::opc::{Relationships, rel_type};
use crate::units::pt_to_emu;
use crate::xml::{NodeId, Ns, STANDARD_DECLARATION, XmlDoc};
use std::collections::{HashMap, HashSet};
/// Content type of a slide layout part.
const LAYOUT_CONTENT_TYPE: &str =
"application/vnd.openxmlformats-officedocument.presentationml.slideLayout+xml";
/// The name PowerPoint gives an inserted layout.
const NEW_LAYOUT_NAME: &str = "Custom Layout";
/// The prompt text of a layout's title placeholder.
const TITLE_PROMPT: &str = "Click to edit Master title style";
/// The prompt text of a content or text placeholder, by outline level.
const TEXT_PROMPTS: [&str; 5] = [
"Click to edit Master text styles",
"Second level",
"Third level",
"Fourth level",
"Fifth level",
];
/// The footer placeholder types, in the order layouts carry them.
const FOOTERS: [&str; 3] = ["dt", "ftr", "sldNum"];
/// Placeholder indexes PowerPoint gives a layout's date, footer, and slide
/// number; inserted placeholders count on from the next one.
const FOOTER_INDEXES: [u32; 3] = [10, 11, 12];
/// `p:cSld/@name` of a part.
fn name_of(doc: &XmlDoc) -> String {
doc.child(doc.root(), Ns::P, "cSld")
.and_then(|c| doc.attr(c, "name"))
.unwrap_or("")
.to_owned()
}
/// `base`, or `1_base`, `2_base`... (PowerPoint's numbering of copies), the
/// first that `taken` does not hold.
fn unique_name(base: &str, taken: &[String]) -> String {
if !taken.iter().any(|t| t == base) {
return base.to_owned();
}
(1..)
.map(|n| format!("{n}_{base}"))
.find(|candidate| !taken.contains(candidate))
.expect("unbounded search")
}
/// An id for a new layout: above every master and layout id (PowerPoint
/// numbers them upward), random above them in a collaborative deck.
fn new_page_id(pres: &mut Presentation, pages: &[MasterPage]) -> Result<u32> {
let used: HashSet<u32> = pages.iter().map(|p| p.id).collect();
let floor = pages
.iter()
.map(|p| p.id)
.max()
.unwrap_or(MASTER_ID_BASE - 1)
.max(MASTER_ID_BASE - 1);
let candidate = match pres.pkg.ids() {
Some(random) if floor < u32::MAX - 1 => {
Some(random.next_in(u64::from(floor) + 1..u64::from(u32::MAX) + 1) as u32)
}
_ => floor.checked_add(1),
};
candidate
.filter(|id| !used.contains(id))
.or_else(|| (MASTER_ID_BASE..=u32::MAX).find(|id| !used.contains(id)))
.ok_or_else(|| Error::LimitExceeded("slide layout ids".into()))
}
fn find_page(pages: &[MasterPage], id: u32) -> Result<&MasterPage> {
pages
.iter()
.find(|p| p.id == id)
.ok_or_else(|| Error::NotFound(format!("slide master or layout {id}")))
}
fn layout_page(pages: &[MasterPage], id: u32) -> Result<&MasterPage> {
let page = find_page(pages, id)?;
if !page.is_layout {
return Err(Error::InvalidEdit(format!(
"{id} is a slide master; this applies to slide layouts"
)));
}
Ok(page)
}
/// Markup of a title placeholder that takes everything from the master.
fn title_xml(id: u32) -> String {
format!(
"<p:sp><p:nvSpPr><p:cNvPr id=\"{id}\" name=\"Title {}\"/><p:cNvSpPr><a:spLocks noGrp=\"1\"/></p:cNvSpPr><p:nvPr><p:ph type=\"title\"/></p:nvPr></p:nvSpPr><p:spPr/><p:txBody><a:bodyPr/><a:lstStyle/><a:p><a:r><a:rPr lang=\"en-US\"/><a:t>{TITLE_PROMPT}</a:t></a:r><a:endParaRPr lang=\"en-US\"/></a:p></p:txBody></p:sp>",
id.saturating_sub(1)
)
}
/// The display name PowerPoint gives a footer placeholder.
fn footer_name(kind: &str) -> &'static str {
match kind {
"dt" => "Date Placeholder",
"ftr" => "Footer Placeholder",
_ => "Slide Number Placeholder",
}
}
/// The placeholder `p:ph` element of a shape.
fn ph_element(doc: &XmlDoc, shape: NodeId) -> Option<NodeId> {
let nv = doc
.children(shape)
.find(|&c| doc.local(c).starts_with("nv"))?;
doc.child(nv, Ns::P, "nvPr")
.and_then(|nv| doc.child(nv, Ns::P, "ph"))
}
/// Top-level placeholders of a page, in z-order.
fn placeholders(doc: &XmlDoc) -> Vec<(NodeId, Placeholder)> {
sp_tree(doc)
.map(|tree| {
tree_children(doc, tree)
.into_iter()
.filter_map(|n| placeholder_of(doc, n).map(|p| (n, p)))
.collect()
})
.unwrap_or_default()
}
/// Markup of a footer placeholder (`dt`, `ftr`, or `sldNum`) for a layout of
/// `master`: a copy of the one another of its layouts has, else one that
/// takes its position and style from the master's, with the master's
/// fields. `None` when the master has no such placeholder.
fn footer_xml(
pres: &mut Presentation,
master: &MasterPage,
pages: &[MasterPage],
kind: &str,
id: u32,
) -> Result<Option<String>> {
let name = format!("{} {}", footer_name(kind), id.saturating_sub(1));
for page in pages
.iter()
.filter(|p| p.is_layout && p.master == master.id)
{
let doc = pres.xml(&page.part)?;
if let Some((node, _)) = placeholders(&doc).into_iter().find(|(_, p)| p.kind == kind) {
let mut copy = doc.fragment(node);
if let Some(nv) = c_nv_pr(©, copy.root()) {
copy.set_attr(nv, "id", &id.to_string());
copy.set_attr(nv, "name", &name);
copy.remove_children_named(nv, Ns::A, "extLst");
}
return Ok(Some(String::from_utf8_lossy(©.to_bytes()).into_owned()));
}
}
let doc = pres.xml(&master.part)?;
let Some((node, _)) = placeholders(&doc).into_iter().find(|(_, p)| p.kind == kind) else {
return Ok(None);
};
let sz = ph_element(&doc, node)
.and_then(|ph| doc.attr(ph, "sz"))
.map(|sz| format!(" sz=\"{}\"", esc(sz)))
.unwrap_or_default();
let idx = FOOTER_INDEXES[FOOTERS.iter().position(|k| *k == kind).unwrap_or(0)];
let paragraphs: String = doc
.children(node)
.find(|&c| doc.local(c) == "txBody")
.map(|body| {
doc.children_named(body, Ns::A, "p")
.map(|p| String::from_utf8_lossy(&doc.fragment(p).to_bytes()).into_owned())
.collect()
})
.unwrap_or_default();
let paragraphs = if paragraphs.is_empty() {
"<a:p><a:endParaRPr lang=\"en-US\"/></a:p>".to_owned()
} else {
paragraphs
};
Ok(Some(format!(
"<p:sp><p:nvSpPr><p:cNvPr id=\"{id}\" name=\"{}\"/><p:cNvSpPr><a:spLocks noGrp=\"1\"/></p:cNvSpPr><p:nvPr><p:ph type=\"{kind}\"{sz} idx=\"{idx}\"/></p:nvPr></p:nvSpPr><p:spPr/><p:txBody><a:bodyPr/><a:lstStyle/>{paragraphs}</p:txBody></p:sp>",
esc(&name)
)))
}
/// Markup of the layout PowerPoint's Insert Layout adds to `master`.
fn new_layout_xml(
pres: &mut Presentation,
master: &MasterPage,
pages: &[MasterPage],
name: &str,
) -> Result<String> {
let mut shapes = title_xml(2);
let mut id = 3;
for kind in FOOTERS {
if let Some(xml) = footer_xml(pres, master, pages, kind, id)? {
shapes.push_str(&xml);
id += 1;
}
}
Ok(format!(
"{STANDARD_DECLARATION}<p:sldLayout {PML_NAMESPACES} preserve=\"1\" userDrawn=\"1\"><p:cSld name=\"{}\"><p:spTree>{TREE_HEADER}{shapes}</p:spTree></p:cSld><p:clrMapOvr><a:masterClrMapping/></p:clrMapOvr></p:sldLayout>",
esc(name)
))
}
/// Removes the co-authoring creation ids a copied layout carries.
fn drop_layout_creation_ids(doc: &mut XmlDoc) {
drop_creation_id(doc);
let Some(ext_lst) = doc.path(doc.root(), Ns::P, &["cSld", "extLst"]) else {
return;
};
let doomed: Vec<NodeId> = doc
.children(ext_lst)
.filter(|&e| {
doc.descendants(e)
.iter()
.any(|&n| doc.local(n) == "creationId")
})
.collect();
for d in doomed {
doc.detach(d);
}
if doc.first_child(ext_lst).is_none() {
doc.detach(ext_lst);
}
}
/// Adds a layout (see `EditOp::AddLayout`); returns its id.
pub(super) fn add_layout(
pres: &mut Presentation,
master: Option<u32>,
after: Option<u32>,
duplicate: Option<u32>,
name: Option<&str>,
) -> Result<u32> {
store_ids(pres)?;
let pages = pres.master_pages()?;
let source = duplicate.map(|id| layout_page(&pages, id)).transpose()?;
let anchor = after.map(|id| find_page(&pages, id)).transpose()?;
let master_id = master
.or(source.map(|s| s.master))
.or(anchor.map(|a| a.master))
.or(pages.first().map(|p| p.master))
.ok_or_else(|| Error::InvalidEdit("the presentation has no slide master".into()))?;
let master_page = find_page(&pages, master_id)?.clone();
if master_page.is_layout {
return Err(Error::InvalidEdit(format!(
"{master_id} is a slide layout, not a slide master"
)));
}
if let Some(a) = anchor
&& a.master != master_id
{
return Err(Error::InvalidEdit(format!(
"layout {} belongs to another slide master",
a.id
)));
}
let taken: Vec<String> = pages
.iter()
.filter(|p| p.is_layout && p.master == master_id)
.map(|p| pres.xml(&p.part).map(|d| name_of(&d)))
.collect::<Result<_>>()?;
let given = name.map(str::trim).filter(|n| !n.is_empty());
let part = match source {
Some(src) => {
let mut renamed = HashMap::new();
let part = copy_part_tree(pres, &src.part, &mut renamed)?;
let original = name_of(&*pres.xml(&src.part)?);
let name = given.map_or_else(|| unique_name(&original, &taken), str::to_owned);
let doc = pres.xml_mut(&part)?;
drop_layout_creation_ids(doc);
if let Some(c_sld) = doc.child(doc.root(), Ns::P, "cSld") {
doc.set_attr(c_sld, "name", &name);
}
part
}
None => {
let name = given.map_or_else(|| unique_name(NEW_LAYOUT_NAME, &taken), str::to_owned);
let xml = new_layout_xml(pres, &master_page, &pages, &name)?;
let part = pres
.pkg
.unique_part_name("/ppt/slideLayouts/slideLayout", ".xml");
pres.pkg
.write(&part, xml.into_bytes(), Some(LAYOUT_CONTENT_TYPE));
// Footers copied from other layouts repeat the namespace declarations.
let doc = pres.xml_mut(&part)?;
if let Some(tree) = sp_tree(doc) {
for shape in tree_children(doc, tree) {
doc.drop_redundant_ns_decls(shape);
}
}
let mut rels = Relationships::empty(&part);
rels.add_internal(rel_type::SLIDE_MASTER, &master_page.part);
pres.put_rels(rels);
part
}
};
let id = new_page_id(pres, &pages)?;
let rid = pres
.rels_mut(&master_page.part)?
.add_internal(rel_type::SLIDE_LAYOUT, &part);
// After the anchor, else after the copied layout, else at the end.
let previous = match (anchor, source) {
(Some(a), _) => Some(a.id),
(None, Some(s)) => Some(s.id),
(None, None) => None,
};
let doc = pres.xml_mut(&master_page.part)?;
let root = doc.root();
let list = doc.ensure_child(root, Ns::P, "sldLayoutIdLst", MASTER_ORDER);
let el = doc.create_element(Ns::P, "sldLayoutId");
doc.set_attr(el, "id", &id.to_string());
doc.set_attr_ns(el, Ns::R, "id", &rid);
let entries: Vec<NodeId> = doc.children_named(list, Ns::P, "sldLayoutId").collect();
let after_entry = entries
.iter()
.copied()
.find(|&e| previous.is_some_and(|p| entry_id(doc, e) == Some(p)));
match (previous, after_entry) {
// The master's own id: first among its layouts.
(Some(p), None) if p == master_id => match entries.first() {
Some(&first) => doc.insert_before(first, el),
None => doc.append_child(list, el),
},
(_, Some(e)) => doc.insert_after(e, el),
_ => match doc
.children(list)
.last()
.filter(|&c| doc.local(c) == "extLst")
{
Some(ext) => doc.insert_before(ext, el),
None => doc.append_child(list, el),
},
}
Ok(id)
}
/// Renames a layout, or a master and its theme (see `EditOp::RenameLayout`).
pub(super) fn rename(pres: &mut Presentation, id: u32, name: &str) -> Result<()> {
let name = name.trim();
if name.is_empty() {
return Err(Error::InvalidEdit("the name is empty".into()));
}
let page = pres.master_page(id)?;
let named = |doc: &mut XmlDoc, always: bool| {
if let Some(c_sld) = doc.child(doc.root(), Ns::P, "cSld")
&& (always
|| doc
.attr(c_sld, "name")
.is_some_and(|n| !n.trim().is_empty()))
{
doc.set_attr(c_sld, "name", name);
}
};
if page.is_layout {
named(pres.xml_mut(&page.part)?, true);
return Ok(());
}
// PowerPoint shows a master by its theme's name; an own name is kept in step.
named(pres.xml_mut(&page.part)?, false);
let rels = pres.part_rels(&page.part)?;
if let Some(theme) = rels.first_of_type(rel_type::THEME).map(|r| rels.resolve(r)) {
let doc = pres.xml_mut(&theme)?;
let root = doc.root();
doc.set_attr(root, "name", name);
pres.forget_theme(&theme);
} else {
named(pres.xml_mut(&page.part)?, true);
}
Ok(())
}
/// Slide ids using each layout part.
fn users(pres: &mut Presentation) -> Vec<(String, u32)> {
pres.slides
.clone()
.into_iter()
.filter_map(|s| layout_of(pres, &s.part).map(|l| (l, s.id)))
.collect()
}
/// "slide 2" or "slides 2, 5, and 7" (1-based positions).
fn slide_list(pres: &Presentation, ids: &[u32]) -> String {
let numbers: Vec<String> = ids
.iter()
.filter_map(|id| pres.slides.iter().position(|s| s.id == *id))
.map(|i| (i + 1).to_string())
.collect();
match numbers.as_slice() {
[one] => format!("slide {one}"),
[rest @ .., last] => format!("slides {} and {last}", rest.join(", ")),
[] => "no slides".to_owned(),
}
}
/// Removes the list entry with `id` from `list` of the part's root; returns its `r:id`.
fn remove_entry(doc: &mut XmlDoc, list: &str, item: &str, id: u32) -> Option<String> {
let list = doc.child(doc.root(), Ns::P, list)?;
let entry = doc
.children_named(list, Ns::P, item)
.find(|&e| entry_id(doc, e) == Some(id))?;
let rid = doc.attr_ns(entry, Ns::R, "id").map(str::to_owned);
doc.detach(entry);
rid
}
/// Deletes an unused layout or master (see `EditOp::DeleteLayout`). The
/// parts left unreachable are removed after the batch.
pub(super) fn delete(pres: &mut Presentation, id: u32) -> Result<()> {
store_ids(pres)?;
let pages = pres.master_pages()?;
let page = find_page(&pages, id)?.clone();
let users = users(pres);
let doomed: Vec<&MasterPage> = pages
.iter()
.filter(|p| p.id == id || !page.is_layout && p.master == id && p.is_layout)
.collect();
let used: Vec<u32> = users
.iter()
.filter(|(layout, _)| doomed.iter().any(|p| p.part == *layout))
.map(|(_, slide)| *slide)
.collect();
let name = {
let doc = pres.xml(&page.part)?;
name_of(&doc)
};
if !used.is_empty() {
let what = if page.is_layout {
format!("layout `{name}`")
} else {
"this slide master's layouts".to_owned()
};
return Err(Error::InvalidEdit(format!(
"{what} cannot be deleted: {} {} it; give {} another layout first (setSlideLayout)",
slide_list(pres, &used),
if used.len() == 1 { "uses" } else { "use" },
if used.len() == 1 { "it" } else { "them" },
)));
}
if page.is_layout {
let siblings = pages
.iter()
.filter(|p| p.is_layout && p.master == page.master)
.count();
if siblings <= 1 {
return Err(Error::InvalidEdit(
"a slide master keeps at least one layout".into(),
));
}
let doc = pres.xml_mut(&page.master_part)?;
if let Some(rid) = remove_entry(doc, "sldLayoutIdLst", "sldLayoutId", id) {
pres.rels_mut(&page.master_part)?.remove(&rid);
}
return Ok(());
}
if pages.iter().filter(|p| !p.is_layout).count() <= 1 {
return Err(Error::InvalidEdit(
"the presentation keeps at least one slide master".into(),
));
}
let main = pres.main_part.clone();
let doc = pres.xml_mut(&main)?;
if let Some(rid) = remove_entry(doc, "sldMasterIdLst", "sldMasterId", id) {
pres.rels_mut(&main)?.remove(&rid);
}
Ok(())
}
/// The next placeholder index of a layout: past its own and the footers'.
fn next_index(doc: &XmlDoc) -> u32 {
placeholders(doc)
.iter()
.map(|(_, p)| p.idx)
.chain(FOOTER_INDEXES)
.max()
.unwrap_or(0)
.saturating_add(1)
}
/// Adds a placeholder to a layout (see `EditOp::InsertPlaceholder`); returns its id.
pub(super) fn insert_placeholder(
pres: &mut Presentation,
layout: u32,
kind: PlaceholderKind,
rect: [f32; 4],
vertical: bool,
) -> Result<u32> {
let pages = pres.master_pages()?;
let part = layout_page(&pages, layout)
.map_err(|_| {
Error::InvalidEdit(format!(
"{layout} is not a slide layout; placeholders are inserted on layouts"
))
})?
.part
.clone();
if rect.iter().any(|v| !v.is_finite()) || rect[2] <= 0.0 || rect[3] <= 0.0 {
return Err(Error::InvalidEdit(
"a placeholder needs a finite position and a positive size".into(),
));
}
if vertical && kind.label().is_some() {
return Err(Error::InvalidEdit(
"only content and text placeholders can be vertical".into(),
));
}
let random = pres.pkg.ids().cloned();
let doc = pres.xml_mut(&part)?;
let id = fresh_shape_id(doc, random.as_deref());
let number = if random.is_some() {
placeholders(doc).len() as u32 + 1
} else {
id - 1
};
let idx = next_index(doc);
let type_attr = kind
.ph_type()
.map(|t| format!(" type=\"{t}\""))
.unwrap_or_default();
let orient = if vertical { " orient=\"vert\"" } else { "" };
let [x, y, w, h] = rect.map(|v| pt_to_emu(f64::from(v)));
let (body_pr, lst_style, paragraphs) = match kind.label() {
None => (
if vertical {
"<a:bodyPr vert=\"eaVert\"/>"
} else {
"<a:bodyPr/>"
},
"<a:lstStyle/>".to_owned(),
TEXT_PROMPTS
.iter()
.enumerate()
.map(|(level, text)| {
format!(
"<a:p><a:pPr lvl=\"{level}\"/><a:r><a:rPr lang=\"en-US\"/><a:t>{text}</a:t></a:r></a:p>"
)
})
.collect::<String>(),
),
// Media placeholders show their kind, centered and unbulleted.
Some(label) => (
"<a:bodyPr anchor=\"ctr\"/>",
"<a:lstStyle><a:lvl1pPr marL=\"0\" indent=\"0\" algn=\"ctr\"><a:buNone/></a:lvl1pPr></a:lstStyle>".to_owned(),
format!(
"<a:p><a:r><a:rPr lang=\"en-US\"/><a:t>{label}</a:t></a:r><a:endParaRPr lang=\"en-US\"/></a:p>"
),
),
};
let locks = if kind == PlaceholderKind::Picture {
"<a:spLocks noGrp=\"1\" noChangeAspect=\"1\"/>"
} else {
"<a:spLocks noGrp=\"1\"/>"
};
let xml = format!(
"<p:sp><p:nvSpPr><p:cNvPr id=\"{id}\" name=\"{} {number}\"/><p:cNvSpPr>{locks}</p:cNvSpPr><p:nvPr><p:ph{type_attr}{orient} sz=\"quarter\" idx=\"{idx}\"/></p:nvPr></p:nvSpPr><p:spPr><a:xfrm><a:off x=\"{x}\" y=\"{y}\"/><a:ext cx=\"{w}\" cy=\"{h}\"/></a:xfrm></p:spPr><p:txBody>{body_pr}{lst_style}{paragraphs}</p:txBody></p:sp>",
kind.shape_name()
);
let tree = sp_tree(doc).ok_or_else(|| Error::InvalidEdit("layout has no shape tree".into()))?;
let el = import_fragment(doc, &xml)?;
append_to_tree(doc, tree, el);
Ok(id)
}
/// Gives a layout placeholder copied within the layout (Duplicate) an index
/// of its own, as PowerPoint does, so slides tell the two apart.
pub(super) fn renumber_copy(pres: &mut Presentation, part: &str, shape: u32) -> Result<()> {
let doc = pres.xml(part)?;
if !doc.is(doc.root(), Ns::P, "sldLayout") {
return Ok(());
}
let Some(node) = super::xmlutil::find_shape(&doc, shape) else {
return Ok(());
};
let Some(ph) = placeholder_of(&doc, node) else {
return Ok(());
};
let shared = placeholders(&doc)
.iter()
.any(|(n, p)| *n != node && p.idx == ph.idx && p.kind == ph.kind);
if !shared {
return Ok(());
}
let idx = next_index(&doc);
let doc = pres.xml_mut(part)?;
if let Some(node) = super::xmlutil::find_shape(doc, shape)
&& let Some(el) = ph_element(doc, node)
{
doc.set_attr(el, "idx", &idx.to_string());
}
Ok(())
}
/// Sets a layout's Title, Footers, and Hide Background Graphics (see
/// `EditOp::SetLayoutOptions`).
pub(super) fn set_layout_options(
pres: &mut Presentation,
layout: u32,
title: Option<bool>,
footers: Option<bool>,
hide_background_graphics: Option<bool>,
) -> Result<()> {
let pages = pres.master_pages()?;
let page = layout_page(&pages, layout)?.clone();
let master = find_page(&pages, page.master)?.clone();
if let Some(show) = title {
let doc = pres.xml(&page.part)?;
let titles: Vec<NodeId> = placeholders(&doc)
.into_iter()
.filter(|(_, p)| matches!(p.kind.as_str(), "title" | "ctrTitle"))
.map(|(n, _)| n)
.collect();
if !show {
let doc = pres.xml_mut(&page.part)?;
for n in titles {
doc.detach(n);
}
} else if titles.is_empty() {
let random = pres.pkg.ids().cloned();
let master_doc = pres.xml(&master.part)?;
let has_master_title = placeholders(&master_doc)
.iter()
.any(|(_, p)| p.kind == "title");
let (w, h) = pres.slide_size();
let doc = pres.xml_mut(&page.part)?;
let id = fresh_shape_id(doc, random.as_deref());
let mut xml = title_xml(id);
if !has_master_title {
// Nothing to inherit a place from: the top of the slide.
xml = xml.replace(
"<p:spPr/>",
&format!(
"<p:spPr><a:xfrm><a:off x=\"{}\" y=\"{}\"/><a:ext cx=\"{}\" cy=\"{}\"/></a:xfrm></p:spPr>",
w / 14,
h / 18,
w - w / 7,
h / 5
),
);
}
let tree = sp_tree(doc)
.ok_or_else(|| Error::InvalidEdit("layout has no shape tree".into()))?;
let el = import_fragment(doc, &xml)?;
// The title goes to the back, where PowerPoint puts it.
let first = doc
.children(tree)
.find(|&c| !matches!(doc.local(c), "nvGrpSpPr" | "grpSpPr"));
match first {
Some(f) if doc.local(f) != "extLst" => doc.insert_before(f, el),
_ => append_to_tree(doc, tree, el),
}
}
}
if let Some(show) = footers {
let doc = pres.xml(&page.part)?;
let present: Vec<(NodeId, String)> = placeholders(&doc)
.into_iter()
.filter(|(_, p)| FOOTERS.contains(&p.kind.as_str()))
.map(|(n, p)| (n, p.kind))
.collect();
if !show {
let doc = pres.xml_mut(&page.part)?;
for (n, _) in present {
doc.detach(n);
}
} else {
let random = pres.pkg.ids().cloned();
let mut added = 0;
for kind in FOOTERS {
if present.iter().any(|(_, k)| k == kind) {
continue;
}
let id = fresh_shape_id(&*pres.xml(&page.part)?, random.as_deref());
let Some(xml) = footer_xml(pres, &master, &pages, kind, id)? else {
continue;
};
let doc = pres.xml_mut(&page.part)?;
let tree = sp_tree(doc)
.ok_or_else(|| Error::InvalidEdit("layout has no shape tree".into()))?;
let el = import_fragment(doc, &xml)?;
append_to_tree(doc, tree, el);
doc.drop_redundant_ns_decls(el);
added += 1;
}
if added == 0 && present.is_empty() {
return Err(Error::InvalidEdit(
"the slide master has no date, footer, or slide number placeholders".into(),
));
}
}
}
if let Some(hide) = hide_background_graphics {
let doc = pres.xml_mut(&page.part)?;
let root = doc.root();
if hide {
doc.set_attr(root, "showMasterSp", "0");
} else {
doc.remove_attr(root, "showMasterSp");
}
}
Ok(())
}
/// Child order of a list style (`a:lstStyle`, `p:titleStyle`...).
const LIST_STYLE_ORDER: &[&str] = &[
"defPPr", "lvl1pPr", "lvl2pPr", "lvl3pPr", "lvl4pPr", "lvl5pPr", "lvl6pPr", "lvl7pPr",
"lvl8pPr", "lvl9pPr", "extLst",
];
/// Child order of `p:txStyles`.
const TX_STYLES_ORDER: &[&str] = &["titleStyle", "bodyStyle", "otherStyle", "extLst"];
/// Child order of `a:txBody`.
const TX_BODY_ORDER: &[&str] = &["bodyPr", "lstStyle", "p"];
/// The placeholder `shape` of a master or layout part with its text body,
/// when formatting it should carry over to the slides based on it.
fn styled_placeholder(doc: &XmlDoc, shape: u32) -> Option<(NodeId, Placeholder)> {
let root = doc.root();
if !doc.is(root, Ns::P, "sldMaster") && !doc.is(root, Ns::P, "sldLayout") {
return None;
}
let node = super::xmlutil::find_shape(doc, shape)?;
let ph = placeholder_of(doc, node)?;
let body = doc.children(node).find(|&c| doc.local(c) == "txBody")?;
Some((body, ph))
}
/// The outline level of a paragraph (`a:pPr/@lvl`, 0-8).
fn level_of(doc: &XmlDoc, p: NodeId) -> usize {
doc.child(p, Ns::A, "pPr")
.and_then(|pr| doc.attr_i64(pr, "lvl"))
.unwrap_or(0)
.clamp(0, 8) as usize
}
/// The list style level slides inherit a placeholder's paragraphs of
/// `level` from: on a master, its title or body text style (as PowerPoint
/// keeps them) or the placeholder's own list style; on a layout, the
/// placeholder's list style.
fn style_level(doc: &mut XmlDoc, body: NodeId, ph: &Placeholder, level: usize) -> NodeId {
let root = doc.root();
let master_style = match ph.style_family() {
"title" => Some("titleStyle"),
"body" => Some("bodyStyle"),
_ => None,
}
.filter(|_| doc.is(root, Ns::P, "sldMaster"));
let list = match master_style {
Some(style) => {
let styles = doc.ensure_child(root, Ns::P, "txStyles", MASTER_ORDER);
doc.ensure_child(styles, Ns::P, style, TX_STYLES_ORDER)
}
None => doc.ensure_child(body, Ns::A, "lstStyle", TX_BODY_ORDER),
};
doc.ensure_child(list, Ns::A, LIST_STYLE_ORDER[level + 1], LIST_STYLE_ORDER)
}
/// Levels of the paragraphs `formatText` covers whole between `start` and `end`.
fn covered_levels(
doc: &XmlDoc,
body: NodeId,
start: Option<TextPos>,
end: Option<TextPos>,
) -> Vec<usize> {
let ps = super::text::paragraphs(doc, body);
let mut levels = Vec::new();
for (i, &p) in ps.iter().enumerate() {
let len = super::text::para_len(doc, p);
let from = match start {
Some(s) if s.paragraph > i => continue,
Some(s) if s.paragraph == i => s.offset.min(len),
_ => 0,
};
let to = match end {
Some(e) if e.paragraph < i => continue,
Some(e) if e.paragraph == i => e.offset.min(len),
_ => len,
};
if from == 0 && to == len && !levels.contains(&level_of(doc, p)) {
levels.push(level_of(doc, p));
}
}
levels
}
/// Carries character formatting given to whole paragraphs of a master's or
/// layout's placeholder into the text style its slides inherit, as
/// PowerPoint's Slide Master view does (the formatted text keeps it too).
pub(super) fn inherit_text_format(
pres: &mut Presentation,
part: &str,
shape: u32,
start: Option<TextPos>,
end: Option<TextPos>,
patch: &RunPatch,
) -> Result<()> {
let Some((body, ph)) = styled_placeholder(&*pres.xml(part)?, shape) else {
return Ok(());
};
let patch = RunPatch {
link: None,
link_tip: None,
..patch.clone()
};
let doc = pres.xml_mut(part)?;
for level in covered_levels(doc, body, start, end) {
let lvl = style_level(doc, body, &ph, level);
let def = doc.ensure_child(lvl, Ns::A, "defRPr", P_PR_ORDER);
patch_rpr(doc, def, &patch, None)?;
}
Ok(())
}
/// Carries paragraph formatting of a master's or layout's placeholder into
/// the text style its slides inherit (see [`inherit_text_format`]).
pub(super) fn inherit_paragraph_format(
pres: &mut Presentation,
part: &str,
shape: u32,
from: Option<usize>,
to: Option<usize>,
patch: &ParaPatch,
) -> Result<()> {
let Some((body, ph)) = styled_placeholder(&*pres.xml(part)?, shape) else {
return Ok(());
};
let patch = ParaPatch {
level: None,
..patch.clone()
};
let doc = pres.xml_mut(part)?;
let ps = super::text::paragraphs(doc, body);
let last = ps.len().saturating_sub(1);
let mut levels = Vec::new();
for &p in ps
.iter()
.take(to.unwrap_or(last).min(last) + 1)
.skip(from.unwrap_or(0))
{
let level = level_of(doc, p);
if !levels.contains(&level) {
levels.push(level);
}
}
for level in levels {
let lvl = style_level(doc, body, &ph, level);
patch_level(doc, lvl, &patch)?;
}
Ok(())
}
/// Applies a paragraph patch to a list style level (`a:lvlNpPr`, which has
/// the schema of `a:pPr`) the way paragraph formatting applies it to a
/// paragraph: through a scratch paragraph carrying the level's properties.
fn patch_level(doc: &mut XmlDoc, lvl: NodeId, patch: &ParaPatch) -> Result<()> {
let mut scratch = XmlDoc::new_root(Ns::A, "txBody");
let body = scratch.root();
let p = scratch.create_element(Ns::A, "p");
scratch.append_child(body, p);
let ppr = scratch.import(doc, lvl);
scratch.rename(ppr, "pPr");
scratch.append_child(p, ppr);
format_paragraphs(&mut scratch, body, None, None, patch)?;
let name = doc.local(lvl).to_owned();
let patched = doc.import(&scratch, ppr);
doc.rename(patched, &name);
doc.insert_before(lvl, patched);
doc.detach(lvl);
Ok(())
}
/// The scheme colors of the Background Styles gallery's columns.
const BACKGROUND_STYLE_COLORS: [&str; 4] = ["bg1", "tx1", "bg2", "tx2"];
/// Gives a slide, master, or layout background style `style` (1-12) of
/// the theme (see `EditOp::SetBackgroundStyle`).
pub(super) fn set_background_style(pres: &mut Presentation, id: u32, style: u8) -> Result<()> {
if !(1..=12).contains(&style) {
return Err(Error::InvalidEdit(format!(
"background style {style} is not 1-12"
)));
}
let index = usize::from(style - 1);
let fill = 1001 + index / 4;
let color = BACKGROUND_STYLE_COLORS[index % 4];
let part = pres.page_part(id)?;
let doc = pres.xml_mut(&part)?;
let c_sld = doc
.child(doc.root(), Ns::P, "cSld")
.ok_or_else(|| Error::InvalidEdit("the slide has no cSld".into()))?;
doc.remove_children_named(c_sld, Ns::P, "bg");
let bg = import_fragment(
doc,
&format!("<p:bg><p:bgRef idx=\"{fill}\"><a:schemeClr val=\"{color}\"/></p:bgRef></p:bg>"),
)?;
doc.insert_child(c_sld, 0, bg);
doc.drop_redundant_ns_decls(bg);
Ok(())
}
/// Problems with master and layout ids that make PowerPoint repair a file:
/// ids below 2147483648, and ids used twice.
pub(crate) fn id_problems(pres: &mut Presentation) -> Result<Vec<String>> {
let mut problems = Vec::new();
let mut seen = HashSet::new();
let main = pres.main_part.clone();
let mut lists = vec![(main, "sldMasterIdLst", "sldMasterId")];
for page in pres.master_pages()?.into_iter().filter(|p| !p.is_layout) {
lists.push((page.part, "sldLayoutIdLst", "sldLayoutId"));
}
for (part, list, item) in lists {
let doc = pres.xml(&part)?;
let Some(list) = doc.child(doc.root(), Ns::P, list) else {
continue;
};
// The ids are optional; a listed one must be valid and unique.
for id in doc
.children_named(list, Ns::P, item)
.filter_map(|e| doc.attr(e, "id"))
{
match id.parse::<u32>() {
Ok(n) if n >= MASTER_ID_BASE => {
if !seen.insert(n) {
problems.push(format!("master or layout id {n} is used twice"));
}
}
_ => problems.push(format!("{part}: id {id} is not at least 2147483648")),
}
}
}
Ok(problems)
}
/// Writes the ids of masters and layouts the file lists without a valid one
/// (see [`MasterPage::stored`]) before the lists change, so every page
/// keeps the id it had.
fn store_ids(pres: &mut Presentation) -> Result<()> {
let pages = pres.master_pages()?;
if pages.iter().all(|p| p.stored) {
return Ok(());
}
let main = pres.main_part.clone();
let mut lists = vec![(main, "sldMasterIdLst", "sldMasterId", false)];
for page in pages.iter().filter(|p| !p.is_layout) {
lists.push((page.part.clone(), "sldLayoutIdLst", "sldLayoutId", true));
}
for (part, list, item, layouts) in lists {
let rels = pres.part_rels(&part)?;
let doc = pres.xml(&part)?;
let Some(list_node) = doc.child(doc.root(), Ns::P, list) else {
continue;
};
let mut writes = Vec::new();
for (at, entry) in doc.children_named(list_node, Ns::P, item).enumerate() {
let target = doc
.attr_ns(entry, Ns::R, "id")
.and_then(|rid| rels.target_part(rid))
.and_then(|t| pres.pkg.canonical_name(&t).map(str::to_owned));
let page = pages.iter().find(|p| {
Some(&p.part) == target.as_ref()
&& p.is_layout == layouts
&& (!layouts || p.master_part == part)
});
if let Some(page) = page.filter(|p| !p.stored) {
writes.push((at, page.id));
}
}
if writes.is_empty() {
continue;
}
let doc = pres.xml_mut(&part)?;
let Some(list_node) = doc.child(doc.root(), Ns::P, list) else {
continue;
};
let entries: Vec<NodeId> = doc.children_named(list_node, Ns::P, item).collect();
for (at, id) in writes {
doc.set_attr(entries[at], "id", &id.to_string());
}
}
Ok(())
}
#[cfg(test)]
mod test;