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
use super::*;
use crate::edit::{EditOp, EditResult, Editor};
use crate::inspect::HeaderFooterOutline;
use crate::opc::Package;
use crate::test_support::{deck, fonts, text_box};
const LAYOUT_TYPE: &str =
"application/vnd.openxmlformats-officedocument.presentationml.slideLayout+xml";
const REL: &str = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
/// Footer placeholders as PowerPoint's default master has them.
const MASTER_FOOTERS: &str = concat!(
r#"<p:sp><p:nvSpPr><p:cNvPr id="4" name="Date Placeholder 3"/><p:cNvSpPr><a:spLocks noGrp="1"/></p:cNvSpPr><p:nvPr><p:ph type="dt" sz="half" idx="2"/></p:nvPr></p:nvSpPr><p:spPr><a:xfrm><a:off x="838200" y="6356350"/><a:ext cx="2743200" cy="365125"/></a:xfrm><a:prstGeom prst="rect"><a:avLst/></a:prstGeom></p:spPr><p:txBody><a:bodyPr anchor="ctr"/><a:lstStyle><a:lvl1pPr algn="l"><a:defRPr sz="1200"/></a:lvl1pPr></a:lstStyle><a:p><a:fld id="{4A8D63E1-1E3C-4F5B-9C1A-2D3B4C5D6E7F}" type="datetimeFigureOut"><a:rPr lang="en-US"/><a:t>10/3/2026</a:t></a:fld><a:endParaRPr lang="en-US"/></a:p></p:txBody></p:sp>"#,
r#"<p:sp><p:nvSpPr><p:cNvPr id="5" name="Footer Placeholder 4"/><p:cNvSpPr><a:spLocks noGrp="1"/></p:cNvSpPr><p:nvPr><p:ph type="ftr" sz="quarter" idx="3"/></p:nvPr></p:nvSpPr><p:spPr><a:xfrm><a:off x="4038600" y="6356350"/><a:ext cx="4114800" cy="365125"/></a:xfrm><a:prstGeom prst="rect"><a:avLst/></a:prstGeom></p:spPr><p:txBody><a:bodyPr anchor="ctr"/><a:lstStyle><a:lvl1pPr algn="ctr"><a:defRPr sz="1200"/></a:lvl1pPr></a:lstStyle><a:p><a:endParaRPr lang="en-US"/></a:p></p:txBody></p:sp>"#,
r#"<p:sp><p:nvSpPr><p:cNvPr id="6" name="Slide Number Placeholder 5"/><p:cNvSpPr><a:spLocks noGrp="1"/></p:cNvSpPr><p:nvPr><p:ph type="sldNum" sz="quarter" idx="4"/></p:nvPr></p:nvSpPr><p:spPr><a:xfrm><a:off x="8610600" y="6356350"/><a:ext cx="2743200" cy="365125"/></a:xfrm><a:prstGeom prst="rect"><a:avLst/></a:prstGeom></p:spPr><p:txBody><a:bodyPr anchor="ctr"/><a:lstStyle><a:lvl1pPr algn="r"><a:defRPr sz="1200"/></a:lvl1pPr></a:lstStyle><a:p><a:fld id="{8B1C2D3E-4F5A-4B6C-8D7E-9F0A1B2C3D4E}" type="slidenum"><a:rPr lang="en-US"/><a:t>‹#›</a:t></a:fld><a:endParaRPr lang="en-US"/></a:p></p:txBody></p:sp>"#
);
/// The same placeholders as PowerPoint's layouts have them (inheriting
/// position and style, with layout indexes 10-12).
const LAYOUT_FOOTERS: &str = concat!(
r#"<p:sp><p:nvSpPr><p:cNvPr id="4" name="Date Placeholder 3"/><p:cNvSpPr><a:spLocks noGrp="1"/></p:cNvSpPr><p:nvPr><p:ph type="dt" sz="half" idx="10"/></p:nvPr></p:nvSpPr><p:spPr/><p:txBody><a:bodyPr/><a:lstStyle/><a:p><a:fld id="{4A8D63E1-1E3C-4F5B-9C1A-2D3B4C5D6E7F}" type="datetimeFigureOut"><a:rPr lang="en-US"/><a:t>10/3/2026</a:t></a:fld><a:endParaRPr lang="en-US"/></a:p></p:txBody></p:sp>"#,
r#"<p:sp><p:nvSpPr><p:cNvPr id="5" name="Footer Placeholder 4"/><p:cNvSpPr><a:spLocks noGrp="1"/></p:cNvSpPr><p:nvPr><p:ph type="ftr" sz="quarter" idx="11"/></p:nvPr></p:nvSpPr><p:spPr/><p:txBody><a:bodyPr/><a:lstStyle/><a:p><a:endParaRPr lang="en-US"/></a:p></p:txBody></p:sp>"#,
r#"<p:sp><p:nvSpPr><p:cNvPr id="6" name="Slide Number Placeholder 5"/><p:cNvSpPr><a:spLocks noGrp="1"/></p:cNvSpPr><p:nvPr><p:ph type="sldNum" sz="quarter" idx="12"/></p:nvPr></p:nvSpPr><p:spPr/><p:txBody><a:bodyPr/><a:lstStyle/><a:p><a:fld id="{8B1C2D3E-4F5A-4B6C-8D7E-9F0A1B2C3D4E}" type="slidenum"><a:rPr lang="en-US" b="1"/><a:t>‹#›</a:t></a:fld><a:endParaRPr lang="en-US"/></a:p></p:txBody></p:sp>"#
);
/// A fixed clock: Monday, October 5, 2026, 9:07:30 AM.
const NOW: FieldTime = FieldTime {
year: 2026,
month: 10,
day: 5,
hour: 9,
minute: 7,
second: 30,
};
fn read_part(pkg: &Package, name: &str) -> String {
String::from_utf8(pkg.read(name).unwrap().into_owned()).unwrap()
}
fn patch(pkg: &mut Package, name: &str, from: &str, to: &str) {
let xml = read_part(pkg, name);
assert!(xml.contains(from), "{name} lacks {from}");
pkg.write(name, xml.replacen(from, to, 1).into_bytes(), None);
}
/// A deck of `slides` slides with footer placeholders in the master and its
/// two layouts: "Title and Content" and a "Title Slide" layout (`title`),
/// which the first slide uses.
fn footer_deck(slides: usize) -> Presentation {
let shapes: Vec<String> = (0..slides)
.map(|i| {
let p = format!("<a:p><a:r><a:rPr lang=\"en-US\"/><a:t>Slide {i}</a:t></a:r></a:p>");
text_box(2, 0, 0, 1_270_000, 635_000, &p)
})
.collect();
let refs: Vec<&str> = shapes.iter().map(String::as_str).collect();
let mut pkg = Package::open(deck(&refs)).unwrap();
let master = "/ppt/slideMasters/slideMaster1.xml";
patch(
&mut pkg,
master,
"</p:spTree>",
&format!("{MASTER_FOOTERS}</p:spTree>"),
);
patch(
&mut pkg,
master,
"</p:sldLayoutIdLst>",
r#"<p:sldLayoutId id="2147483650" r:id="rId3"/></p:sldLayoutIdLst>"#,
);
patch(
&mut pkg,
"/ppt/slideMasters/_rels/slideMaster1.xml.rels",
"</Relationships>",
&format!(
r#"<Relationship Id="rId3" Type="{REL}/slideLayout" Target="../slideLayouts/slideLayout2.xml"/></Relationships>"#
),
);
let layout = "/ppt/slideLayouts/slideLayout1.xml";
patch(
&mut pkg,
layout,
"</p:spTree>",
&format!("{LAYOUT_FOOTERS}</p:spTree>"),
);
let title = read_part(&pkg, layout)
.replace(r#"type="obj""#, r#"type="title""#)
.replace("Title and Content", "Title Slide");
pkg.write(
"/ppt/slideLayouts/slideLayout2.xml",
title.into_bytes(),
Some(LAYOUT_TYPE),
);
let rels = read_part(&pkg, "/ppt/slideLayouts/_rels/slideLayout1.xml.rels");
pkg.write(
"/ppt/slideLayouts/_rels/slideLayout2.xml.rels",
rels.into_bytes(),
None,
);
patch(
&mut pkg,
"/ppt/slides/_rels/slide1.xml.rels",
"slideLayout1.xml",
"slideLayout2.xml",
);
let mut pres = Presentation::open(pkg.save().unwrap()).unwrap();
pres.set_clock(Some(NOW));
pres
}
fn editor(slides: usize) -> Editor {
Editor::new(footer_deck(slides))
}
fn set(slides: Option<Vec<u32>>) -> EditOp {
EditOp::SetHeaderFooter {
slides,
slide_number: None,
date: None,
date_text: None,
date_format: None,
footer: None,
footer_text: None,
not_on_title: false,
}
}
fn with(mut op: EditOp, f: impl FnOnce(&mut EditOp)) -> EditOp {
f(&mut op);
op
}
fn apply(ed: &mut Editor, op: EditOp) -> EditResult {
ed.apply(&[op], None, fonts()).unwrap()
}
fn state(pres: &mut Presentation, index: usize) -> Option<HeaderFooterOutline> {
pres.slide_outline(index).unwrap().header_footer
}
fn part_xml(pres: &mut Presentation, name: &str) -> String {
pres.flush();
read_part(pres.package(), name)
}
fn slide_xml(pres: &mut Presentation, index: usize) -> String {
let part = pres.slides()[index].part.clone();
part_xml(pres, &part)
}
/// The paragraphs the renderer lays out on a slide (fields resolved), after
/// checking that the slide renders.
fn drawn_text(pres: &mut Presentation, index: usize) -> Vec<String> {
use crate::model::shape::{Inherit, WalkCtx, resolve_tree};
pres.render_slide(index, 64, fonts()).unwrap();
let ctx = pres.slide_context(index).unwrap();
let walk = WalkCtx {
ctx: &ctx,
inherit: Inherit::Slide,
};
let tree = sp_tree(&ctx.slide.doc).unwrap();
resolve_tree(&walk, &ctx.slide, tree)
.iter()
.filter_map(|s| s.text.as_ref())
.flat_map(|body| body.paragraphs.iter())
.map(crate::render::text::paragraph_text)
.collect()
}
fn assert_valid(pres: &mut Presentation) -> Presentation {
let mut reopened = Presentation::open(pres.save().unwrap()).unwrap();
let problems = reopened.integrity_problems().unwrap();
assert!(problems.is_empty(), "{problems:#?}");
reopened
}
#[test]
fn apply_to_all_adds_placeholders_from_the_layouts() {
let mut ed = editor(3);
let op = with(set(None), |op| {
if let EditOp::SetHeaderFooter {
slide_number,
date,
footer,
footer_text,
..
} = op
{
*slide_number = Some(true);
*date = Some(true);
*footer = Some(true);
*footer_text = Some("Confidential".into());
}
});
let result = apply(&mut ed, op);
assert_eq!(result.changed_slides.len(), 3);
let pres = ed.presentation_mut();
for i in 0..3 {
assert_eq!(
state(pres, i),
Some(HeaderFooterOutline {
slide_number: true,
date: true,
date_text: None,
date_format: Some("datetime1".into()),
footer: true,
footer_text: Some("Confidential".into()),
})
);
}
let xml = slide_xml(pres, 1);
// Placeholders copy the layout's type, size, and index, and take the
// field ids and run formatting of its paragraphs.
assert!(
xml.contains(r#"<p:cNvPr id="3" name="Date Placeholder 2"/><p:cNvSpPr><a:spLocks noGrp="1"/></p:cNvSpPr><p:nvPr><p:ph type="dt" sz="half" idx="10"/></p:nvPr></p:nvSpPr><p:spPr/><p:txBody><a:bodyPr/><a:lstStyle/><a:p><a:fld id="{4A8D63E1-1E3C-4F5B-9C1A-2D3B4C5D6E7F}" type="datetime1"><a:rPr lang="en-US"/><a:t>10/5/2026</a:t></a:fld><a:endParaRPr lang="en-US"/></a:p>"#),
"{xml}"
);
assert!(
xml.contains(r#"<p:ph type="ftr" sz="quarter" idx="11"/></p:nvPr></p:nvSpPr><p:spPr/><p:txBody><a:bodyPr/><a:lstStyle/><a:p><a:r><a:rPr lang="en-US" dirty="0"/><a:t>Confidential</a:t></a:r><a:endParaRPr lang="en-US"/></a:p>"#),
"{xml}"
);
assert!(
xml.contains(r#"<p:ph type="sldNum" sz="quarter" idx="12"/></p:nvPr></p:nvSpPr><p:spPr/><p:txBody><a:bodyPr/><a:lstStyle/><a:p><a:fld id="{8B1C2D3E-4F5A-4B6C-8D7E-9F0A1B2C3D4E}" type="slidenum"><a:rPr lang="en-US" b="1"/><a:t>2</a:t></a:fld>"#),
"{xml}"
);
// The master records what new slides show; the title layout follows it.
let master = part_xml(pres, "/ppt/slideMasters/slideMaster1.xml");
assert!(
master.contains(r#"<p:hf hdr="0"/><p:txStyles>"#),
"{master}"
);
assert!(master.find("</p:sldLayoutIdLst>") < master.find("<p:hf"));
assert!(!part_xml(pres, "/ppt/slideLayouts/slideLayout2.xml").contains("<p:hf"));
// Rendered: the number, the clock's date, and the footer.
let text = drawn_text(pres, 2).join(" ");
for expected in ["10/5/2026", "Confidential", "3"] {
assert!(text.contains(expected), "{expected} in {text:?}");
}
let mut reopened = assert_valid(pres);
assert_eq!(state(&mut reopened, 0), state(pres, 0));
// Undo removes it all.
ed.undo().unwrap();
let pres = ed.presentation_mut();
assert_eq!(state(pres, 1), None);
assert!(!part_xml(pres, "/ppt/slideMasters/slideMaster1.xml").contains("<p:hf"));
}
#[test]
fn hiding_removes_placeholders_and_omitted_fields_keep_state() {
let mut ed = editor(2);
let on = with(set(None), |op| {
if let EditOp::SetHeaderFooter {
slide_number, date, ..
} = op
{
*slide_number = Some(true);
*date = Some(true);
}
});
apply(&mut ed, on);
// Null fields (as AI tool calls send them) keep everything; a fixed date
// replaces the automatic one on slides that show a date.
let op: EditOp = serde_json::from_str(
r#"{"op":"setHeaderFooter","slides":null,"slideNumber":null,"date":null,"dateText":"Q4 2026","dateFormat":null,"footer":null,"footerText":"ignored","notOnTitle":null}"#,
)
.unwrap();
apply(&mut ed, op);
let pres = ed.presentation_mut();
let s = state(pres, 1).unwrap();
assert!(s.slide_number && s.date && !s.footer, "{s:?}");
assert_eq!(s.date_text.as_deref(), Some("Q4 2026"));
assert_eq!(s.date_format, None);
assert_eq!(s.footer_text, None, "footer text alone does not turn it on");
// Back to automatic, in another format.
let op: EditOp = serde_json::from_str(
r#"{"op":"setHeaderFooter","slides":[257],"dateText":"","dateFormat":"datetime2"}"#,
)
.unwrap();
let result = apply(&mut ed, op);
assert_eq!(result.changed_slides, [257]);
let pres = ed.presentation_mut();
assert_eq!(
state(pres, 1).unwrap().date_format.as_deref(),
Some("datetime2")
);
assert_eq!(
state(pres, 0).unwrap().date_text.as_deref(),
Some("Q4 2026")
);
assert!(
drawn_text(pres, 1)
.join(" ")
.contains("Monday, October 5, 2026")
);
// Hiding the slide number on one slide removes its placeholder only.
apply(
&mut ed,
with(set(Some(vec![256])), |op| {
if let EditOp::SetHeaderFooter { slide_number, .. } = op {
*slide_number = Some(false);
}
}),
);
let pres = ed.presentation_mut();
assert!(!state(pres, 0).unwrap().slide_number);
assert!(state(pres, 1).unwrap().slide_number);
assert!(!slide_xml(pres, 0).contains("sldNum"));
// Hiding everything leaves no state.
apply(
&mut ed,
with(set(None), |op| {
if let EditOp::SetHeaderFooter {
slide_number, date, ..
} = op
{
*slide_number = Some(false);
*date = Some(false);
}
}),
);
let pres = ed.presentation_mut();
assert_eq!(state(pres, 0), None);
assert_eq!(state(pres, 1), None);
assert!(!part_xml(pres, "/ppt/slideMasters/slideMaster1.xml").contains("<p:hf"));
assert_valid(pres);
}
#[test]
fn not_on_title_skips_title_slides_and_marks_their_layout() {
let mut ed = editor(3);
let op = with(set(None), |op| {
if let EditOp::SetHeaderFooter {
slide_number,
not_on_title,
..
} = op
{
*slide_number = Some(true);
*not_on_title = true;
}
});
apply(&mut ed, op);
let pres = ed.presentation_mut();
assert_eq!(state(pres, 0), None, "slide 1 has the Title Slide layout");
assert!(state(pres, 1).unwrap().slide_number);
let master = part_xml(pres, "/ppt/slideMasters/slideMaster1.xml");
assert!(
master.contains(r#"<p:hf hdr="0" ftr="0" dt="0"/>"#),
"{master}"
);
let title = part_xml(pres, "/ppt/slideLayouts/slideLayout2.xml");
assert!(
title.contains(r#"</p:clrMapOvr><p:hf sldNum="0" hdr="0" ftr="0" dt="0"/></p:sldLayout>"#),
"{title}"
);
// New slides follow the master: a content slide gets a number, a title
// slide does not.
let content = apply(
&mut ed,
EditOp::AddSlide {
layout: Some("Title and Content".into()),
after: Some(257),
title: None,
body: None,
},
)
.created[0]
.slide;
let title_slide = apply(
&mut ed,
EditOp::AddSlide {
layout: Some("Title Slide".into()),
after: None,
title: None,
body: None,
},
)
.created[0]
.slide;
let pres = ed.presentation_mut();
let index = |pres: &Presentation, id| pres.slides().iter().position(|s| s.id == id).unwrap();
let content_index = index(pres, content);
let s = state(pres, content_index).unwrap();
assert!(s.slide_number && !s.date && !s.footer, "{s:?}");
assert!(drawn_text(pres, content_index).contains(&"3".to_owned()));
let title_index = index(pres, title_slide);
assert_eq!(state(pres, title_index), None);
assert_valid(pres);
}
#[test]
fn slide_numbers_count_from_the_first_slide_number() {
let mut pres = footer_deck(2);
let name = pres.main_part_name().to_owned();
let xml = read_part(pres.package(), &name)
.replace("<p:presentation ", "<p:presentation firstSlideNum=\"0\" ");
pres.pkg.write(&name, xml.into_bytes(), None);
pres.forget(&name);
pres.reload_structure().unwrap();
let op = with(set(None), |op| {
if let EditOp::SetHeaderFooter { slide_number, .. } = op {
*slide_number = Some(true);
}
});
pres.apply(&[op], fonts()).unwrap();
assert_eq!(pres.slide_number(1), 1);
assert!(
slide_xml(&mut pres, 1)
.contains("type=\"slidenum\"><a:rPr lang=\"en-US\" b=\"1\"/><a:t>1</a:t>")
);
assert!(drawn_text(&mut pres, 1).contains(&"1".to_owned()));
// Without a clock, dates render their cached text.
pres.set_clock(None);
let op = with(set(None), |op| {
if let EditOp::SetHeaderFooter { date, .. } = op {
*date = Some(true);
}
});
pres.apply(&[op], fonts()).unwrap();
let cached = state(&mut pres, 1).unwrap();
assert_eq!(cached.date_format.as_deref(), Some("datetime1"));
let xml = slide_xml(&mut pres, 1);
let text_start = xml.find("type=\"datetime1\">").unwrap();
let cached_text = &xml[text_start..];
let t =
&cached_text[cached_text.find("<a:t>").unwrap() + 5..cached_text.find("</a:t>").unwrap()];
assert!(drawn_text(&mut pres, 1).contains(&t.to_owned()), "{t}");
}
#[test]
fn bad_formats_and_slides_are_rejected() {
let mut ed = editor(2);
let bad_format = with(set(None), |op| {
if let EditOp::SetHeaderFooter {
date, date_format, ..
} = op
{
*date = Some(true);
*date_format = Some("datetime14".into());
}
});
assert!(matches!(
ed.apply(&[bad_format], None, fonts()),
Err(Error::InvalidEdit(_))
));
let missing = with(set(Some(vec![999])), |op| {
if let EditOp::SetHeaderFooter { footer, .. } = op {
*footer = Some(true);
}
});
assert!(matches!(
ed.apply(&[missing], None, fonts()),
Err(Error::NotFound(_))
));
}
#[test]
fn layouts_without_footers_show_nothing() {
// The plain test deck's layout has no footer placeholders.
let shape = text_box(
2,
0,
0,
914_400,
457_200,
"<a:p><a:endParaRPr lang=\"en-US\"/></a:p>",
);
let mut pres = Presentation::open(deck(&[&shape])).unwrap();
let op = with(set(None), |op| {
if let EditOp::SetHeaderFooter { slide_number, .. } = op {
*slide_number = Some(true);
}
});
pres.apply(&[op], fonts()).unwrap();
assert_eq!(state(&mut pres, 0), None);
}