e4f86d11fe8a
roundtrip.rs
//! Round trips of decks built in code: model → PPTX → model.
use std::sync::Arc;
use deckcraft_color::{ColorTransform, Rgba, SchemeSlot};
use deckcraft_geom::Xfrm;
use deckcraft_model::anim::{AnimClass, AnimStart, Animation, TextBuild, Transition};
use deckcraft_model::chart::{Chart, ChartType};
use deckcraft_model::style::{
ColorRef, Dash, Effects, Fill, Glow, Gradient, GradientFlip, GradientShape, GradientStop, Line, LineEnd, PatternFill, PictureAdjust, PictureFill,
PictureMode, Shadow,
};
use deckcraft_model::table::Table;
use deckcraft_model::text::{
Action, Align, Anchor, AutoFit, BodyProps, Bullet, Caps, Hyperlink, Paragraph, Run, RunKind, RunProps, Spacing, Strike, TextBody, TextOverflow,
};
use deckcraft_model::{
Background, Comment, CustomPath, CustomShow, Geom, InkStroke, MediaClip, Presentation, Section, Shape, ShapeId, ShapeKind, Slide, SlideId,
defaults,
};
fn png(w: u32, h: u32, rgb: [u8; 3]) -> Vec<u8> {
let img = image::RgbImage::from_pixel(w, h, image::Rgb(rgb));
let mut out = std::io::Cursor::new(vec![]);
image::DynamicImage::ImageRgb8(img).write_to(&mut out, image::ImageFormat::Png).expect("png");
out.into_inner()
}
fn shape(p: &mut Presentation, name: &str, x: f64, y: f64, w: f64, h: f64) -> Shape {
Shape { id: ShapeId(p.alloc_id().expect("ids")), name: name.into(), xfrm: Some(Xfrm::new(x, y, w, h)), ..Default::default() }
}
fn new_slide(p: &mut Presentation, title: &str) -> Slide {
let layout = defaults::layout_of_kind(p, deckcraft_model::LayoutType::TitleOnly).unwrap_or_default();
let mut s = defaults::new_slide(p, layout).expect("slide");
if let Some(t) = s.shapes.first_mut() {
t.text = Some(TextBody::from_text(title));
}
s
}
/// A deck exercising most of what the model can hold.
pub fn rich_deck() -> Presentation {
let mut p = defaults::new_presentation(None);
p.props.title = "Rich deck".into();
p.props.author = "DeckCraft tests".into();
p.props.created = "2025-01-02T03:04:05Z".into();
let img = p.add_media("image1.png", "image/png", png(40, 30, [200, 40, 40])).expect("media");
let img2 = p.add_media("image2.png", "image/png", png(8, 8, [20, 140, 220])).expect("media");
let video = p.add_media("clip.mp4", "video/mp4", b"\x00\x00\x00\x18ftypmp42not-a-real-video".to_vec()).expect("media");
// Slide 1: title slide with notes and formatted text.
{
let first = p.slides[0].id;
let s = p.slide_mut(first).expect("slide");
s.notes = TextBody::from_text("Speaker notes line 1\nline 2");
let t = &mut s.shapes[0];
t.text = Some(TextBody {
paragraphs: vec![Paragraph {
runs: vec![
Run::with("Bold ", RunProps { bold: Some(true), size: Some(40.0), ..Default::default() }),
Run::with(
"red italic",
RunProps {
italic: Some(true),
fill: Some(Fill::solid(ColorRef::rgb(Rgba::rgb(255, 0, 0)))),
underline: Some("sng".into()),
strike: Some(Strike::Single),
caps: Some(Caps::Small),
spacing: Some(1.5),
baseline: Some(0.3),
font: Some("Lato".into()),
lang: Some("en-GB".into()),
..Default::default()
},
),
Run { text: String::new(), props: RunProps::default(), kind: RunKind::Break },
Run::with(
"link",
RunProps {
link: Some(Hyperlink {
action: Action::Url { url: "https://example.org/a?b=1&c=2".into() },
tooltip: "tip".into(),
highlight_click: false,
sound: None,
stop_sound: false,
zoom_return: None,
}),
..Default::default()
},
),
],
..Default::default()
}],
..Default::default()
});
s.transition = Some(Transition {
kind: "fade".into(),
option: "throughBlack".into(),
duration_ms: 700,
advance_after_ms: Some(3000),
..Default::default()
});
}
// Slide 2: shapes, fills, lines, effects, custom geometry, group, connector.
let mut s = new_slide(&mut p, "Shapes");
let mut a = shape(&mut p, "Gradient Star", 100.0, 120.0, 150.0, 150.0);
a.geom = Geom::Preset { name: "star5".into(), adj: vec![20000.0] };
a.fill = Some(Fill::Gradient(Gradient {
tile: [0.0; 4],
stops: vec![
GradientStop { pos: 0.0, color: ColorRef::scheme(SchemeSlot::Accent1) },
GradientStop { pos: 1.0, color: ColorRef::scheme(SchemeSlot::Accent2).with(ColorTransform::LumMod(75000)) },
],
shape: GradientShape::Linear { angle: 45.0, scaled: false },
rotate_with_shape: true,
flip: Some(GradientFlip::Xy),
}));
a.line = Some(Line { width: Some(3.0), dash: Some(Dash::Preset { name: "dash".into() }), ..Line::solid(ColorRef::rgb(Rgba::rgb(0, 0, 0)), 3.0) });
a.effects = Some(Effects {
outer_shadow: Some(Shadow {
color: ColorRef::rgb(Rgba::BLACK).with(ColorTransform::Alpha(40000)),
blur: 6.0,
dist: 3.0,
dir: 90.0,
inner: false,
sx: 1.0,
sy: 1.0,
kx: 0.0,
ky: 0.0,
align: "b".into(),
rotate_with_shape: false,
}),
glow: Some(Glow { color: ColorRef::scheme(SchemeSlot::Accent6), radius: 8.0 }),
soft_edge: Some(2.0),
..Default::default()
});
a.xfrm = Some(Xfrm { rot: 30.0, flip_h: true, ..Xfrm::new(100.0, 120.0, 150.0, 150.0) });
let mut b = shape(&mut p, "Pattern Box", 300.0, 120.0, 120.0, 80.0);
b.geom = Geom::Preset { name: "roundRect".into(), adj: vec![30000.0] };
b.fill =
Some(Fill::Pattern(PatternFill { preset: "dkDnDiag".into(), fg: ColorRef::scheme(SchemeSlot::Accent3), bg: ColorRef::rgb(Rgba::WHITE) }));
b.text = Some(TextBody {
body: BodyProps { anchor: Some(Anchor::Bottom), inset_l: Some(10.0), wrap: Some(false), autofit: Some(AutoFit::Shape), ..Default::default() },
paragraphs: vec![Paragraph {
props: deckcraft_model::text::ParaProps {
align: Some(Align::Right),
line_spacing: Some(Spacing::Pct(1.5)),
space_before: Some(Spacing::Pts(6.0)),
bullet: Some(Bullet::AutoNum { scheme: "romanUcPeriod".into(), start_at: 3 }),
..Default::default()
},
runs: vec![Run::new("numbered")],
level: 2,
..Default::default()
}],
..Default::default()
});
b.click = Some(Hyperlink {
action: Action::NextSlide,
tooltip: String::new(),
highlight_click: true,
sound: None,
stop_sound: false,
zoom_return: None,
});
let mut c = shape(&mut p, "Freeform", 450.0, 120.0, 100.0, 100.0);
c.geom = Geom::Custom {
paths: vec![CustomPath {
w: 100000.0,
h: 100000.0,
d: "M 0 0 L 100000 0 L 50000 100000 Z".into(),
fill: deckcraft_geom::preset::FillMode::Norm,
stroke: true,
}],
};
c.fill = Some(Fill::solid(ColorRef::scheme(SchemeSlot::Accent4)));
let child1 = Shape { geom: Geom::preset("ellipse"), ..shape(&mut p, "Child 1", 0.0, 0.0, 50.0, 50.0) };
let child2 = Shape { geom: Geom::preset("rect"), ..shape(&mut p, "Child 2", 60.0, 0.0, 50.0, 50.0) };
let (c1, c2) = (child1.id, child2.id);
let mut g = shape(&mut p, "Group", 600.0, 120.0, 220.0, 100.0);
g.kind = ShapeKind::Group { children: vec![child1, child2], child: Xfrm::new(0.0, 0.0, 110.0, 50.0) };
let mut cx = shape(&mut p, "Connector", 600.0, 300.0, 200.0, 0.0);
cx.kind = ShapeKind::Connector { start: Some((c1, 2)), end: Some((c2, 0)) };
cx.geom = Geom::preset("straightConnector1");
cx.line = Some(Line {
tail: Some(LineEnd { kind: "triangle".into(), w: "med".into(), len: "lg".into() }),
..Line::solid(ColorRef::scheme(SchemeSlot::Tx1), 2.0)
});
let mut tb = shape(&mut p, "Text Box", 100.0, 400.0, 300.0, 40.0);
tb.text_box = true;
tb.text = Some(TextBody::from_text("A text box"));
tb.descr = "alt text".into();
let mut bgs = shape(&mut p, "Uses background", 450.0, 400.0, 60.0, 60.0);
bgs.fill = Some(Fill::Background);
s.shapes.extend([a, b, c, g, cx, tb, bgs]);
s.background = Some(Background::Fill { fill: Fill::solid(ColorRef::rgb(Rgba::rgb(250, 248, 240))) });
s.transition = Some(Transition { kind: "morph".into(), option: "words".into(), duration_ms: 2000, ..Default::default() });
let ids: Vec<ShapeId> = s.shapes.iter().map(|x| x.id).collect();
s.animations = vec![
Animation { shape: ids[1], effect: "fly".into(), option: "l".into(), duration_ms: 750, ..Default::default() },
Animation { shape: ids[2], effect: "wipe".into(), option: "t".into(), start: AnimStart::WithPrevious, delay_ms: 250, ..Default::default() },
Animation {
shape: ids[3],
class: AnimClass::Emphasis,
effect: "spin".into(),
start: AnimStart::AfterPrevious,
duration_ms: 2000,
..Default::default()
},
Animation { shape: ids[4], class: AnimClass::Exit, effect: "fadeOut".into(), duration_ms: 400, ..Default::default() },
Animation {
shape: ids[2],
class: AnimClass::Path,
effect: "lines".into(),
option: "right".into(),
path: Some("M 0 0 L 0.25 0 E".into()),
duration_ms: 2000,
..Default::default()
},
Animation { shape: ids[6], effect: "zoom".into(), option: "in".into(), trigger: Some(ids[3]), duration_ms: 500, ..Default::default() },
];
s.comments = vec![Comment {
author: "Ada".into(),
initials: "AL".into(),
text: "Nice star".into(),
date: "2025-02-03T04:05:06.000".into(),
x: 120.0,
y: 64.0,
..Default::default()
}];
p.slides.push(Arc::new(s));
// Slide 3: pictures, media, ink.
let mut s = new_slide(&mut p, "Pictures");
let mut pic = shape(&mut p, "Picture", 100.0, 120.0, 200.0, 150.0);
pic.kind = ShapeKind::Picture {
fill: PictureFill {
media: img,
crop: [0.1, 0.05, 0.2, 0.0],
mode: PictureMode::Stretch { fill_rect: [0.0; 4] },
alpha: Some(0.5),
adjust: PictureAdjust { brightness: 0.2, contrast: -0.1, grayscale: true, ..Default::default() },
upright: false,
artistic: None,
},
};
let mut tiled = shape(&mut p, "Tiled", 350.0, 120.0, 200.0, 150.0);
tiled.fill = Some(Fill::Picture(PictureFill {
media: img2,
mode: PictureMode::Tile { tx: 0.0, ty: 0.0, sx: 0.5, sy: 0.5, flip: "none".into(), align: "tl".into() },
..Default::default()
}));
let mut vid = shape(&mut p, "Video", 600.0, 120.0, 240.0, 135.0);
vid.kind = ShapeKind::Media(MediaClip {
media: video,
video: true,
poster: Some(img),
crop: [0.1, 0.0, 0.2, 0.25],
volume: 1.0,
trim_start_ms: 500,
fade_in_ms: 250,
..Default::default()
});
let mut ink = shape(&mut p, "Ink", 100.0, 350.0, 200.0, 100.0);
ink.kind = ShapeKind::Ink {
strokes: vec![InkStroke {
points: vec![(100.0, 350.0, 0.5), (150.0, 400.0, 0.5), (300.0, 360.0, 0.5)],
color: Rgba::rgb(0, 0, 255),
width: 3.0,
highlighter: false,
}],
};
s.shapes.extend([pic, tiled, vid, ink]);
s.transition = Some(Transition { kind: "vortex".into(), option: "r".into(), duration_ms: 3000, ..Default::default() });
s.hidden = true;
p.slides.push(Arc::new(s));
// Slide 4: table with merges and a chart per type.
let mut s = new_slide(&mut p, "Table");
let mut t = Table::new(3, 3, 450.0, 30.0);
for r in 0..3 {
for c in 0..3 {
if let Some(cell) = t.cell_mut(r, c) {
cell.text = TextBody::from_text(&format!("r{r}c{c}"));
}
}
}
t.merge(1, 0, 2, 1);
t.style = "light2-accent3".into();
if let Some(cell) = t.cell_mut(0, 2) {
cell.fill = Some(Fill::solid(ColorRef::rgb(Rgba::rgb(255, 255, 0))));
cell.margins = Some([5.0, 5.0, 2.0, 2.0]);
cell.anchor = Some(Anchor::Middle);
cell.borders[3] = Some(Line::solid(ColorRef::rgb(Rgba::BLACK), 2.0));
}
let mut ts = shape(&mut p, "Table 1", 100.0, 120.0, 450.0, 90.0);
ts.kind = ShapeKind::Table(t);
s.shapes.push(ts);
s.transition = Some(Transition {
kind: "split".into(),
option: "vertIn".into(),
duration_ms: 1500,
advance_on_click: false,
advance_after_ms: Some(2000),
..Default::default()
});
p.slides.push(Arc::new(s));
let kinds = [
ChartType::Column,
ChartType::StackedBar,
ChartType::PercentColumn,
ChartType::Line,
ChartType::LineMarkers,
ChartType::Area,
ChartType::Pie,
ChartType::Doughnut,
ChartType::Scatter,
ChartType::Radar,
ChartType::Bubble,
];
let mut s = new_slide(&mut p, "Charts");
for (i, k) in kinds.iter().enumerate() {
let mut ch = shape(&mut p, &format!("Chart {i}"), 20.0 + (i % 4) as f64 * 230.0, 100.0 + (i / 4) as f64 * 140.0, 220.0, 130.0);
let mut chart = Chart::sample(*k);
chart.title = Some(k.label().to_string());
ch.kind = ShapeKind::Chart(Box::new(chart));
s.shapes.push(ch);
}
let mut combo = Chart::sample(ChartType::Column);
combo.kind = ChartType::Combo;
combo.series[0].kind = Some(ChartType::Column);
combo.series[1].kind = Some(ChartType::Line);
combo.series[2].kind = Some(ChartType::Line);
let mut ch = shape(&mut p, "Combo", 710.0, 380.0, 220.0, 130.0);
ch.kind = ShapeKind::Chart(Box::new(combo));
s.shapes.push(ch);
p.slides.push(Arc::new(s));
// Slide 6: bulleted content with a by-paragraph build, a slide link and an equation.
let layout = defaults::layout_of_kind(&p, deckcraft_model::LayoutType::TitleAndContent).unwrap_or_default();
let mut s = defaults::new_slide(&mut p, layout).expect("slide");
s.shapes[0].text = Some(TextBody::from_text("Build"));
s.shapes[1].text = Some(TextBody::from_text("One\nTwo\nThree"));
let body = s.shapes[1].id;
s.animations = vec![Animation { shape: body, effect: "fade".into(), text_build: TextBuild::ByParagraph, duration_ms: 500, ..Default::default() }];
let target = p.slides[1].id;
let mut link = shape(&mut p, "Go to shapes", 600.0, 450.0, 200.0, 40.0);
link.text = Some(TextBody::from_text("Back to shapes"));
link.click = Some(Hyperlink {
action: Action::Slide { slide: target },
tooltip: String::new(),
highlight_click: false,
sound: None,
stop_sound: false,
zoom_return: None,
});
let mut eq = shape(&mut p, "Equation", 100.0, 450.0, 300.0, 40.0);
eq.text = Some(TextBody {
paragraphs: vec![Paragraph {
runs: vec![Run {
text: "x=1".into(),
props: RunProps::default(),
kind: RunKind::Math {
omml: r#"<m:oMathPara xmlns:m="http://schemas.openxmlformats.org/officeDocument/2006/math"><m:oMath><m:r><m:t>x=1</m:t></m:r></m:oMath></m:oMathPara>"#.into(),
},
}],
..Default::default()
}],
..Default::default()
});
s.shapes.extend([link, eq]);
s.transition = Some(Transition { kind: "curtains".into(), duration_ms: 2000, ..Default::default() });
p.slides.push(Arc::new(s));
let ids: Vec<SlideId> = p.slides.iter().map(|s| s.id).collect();
p.sections = vec![Section { name: "Start".into(), slides: ids[..2].to_vec() }, Section { name: "Rest".into(), slides: ids[2..].to_vec() }];
p.custom_shows = vec![CustomShow { name: "Short".into(), slides: vec![ids[0], ids[3]] }];
p.first_slide_number = 0;
p
}
fn round(p: &Presentation) -> Presentation {
let bytes = deckcraft_pptx::export(p).expect("export");
deckcraft_pptx::import(&bytes).expect("import")
}
fn by_name<'a>(s: &'a Slide, name: &str) -> &'a Shape {
let mut found = None;
deckcraft_model::walk(&s.shapes, &mut |x, _| {
if found.is_none() && x.name == name {
found = Some(x);
}
});
found.unwrap_or_else(|| panic!("no shape {name}"))
}
#[test]
fn rich_deck_writes_to_dir() {
let p = rich_deck();
let bytes = deckcraft_pptx::export(&p).expect("export");
if let Ok(dir) = std::env::var("DECKCRAFT_PPTX_OUT") {
std::fs::write(format!("{dir}/rich.pptx"), &bytes).expect("write");
}
assert!(bytes.len() > 1000);
}
#[test]
fn deck_level_round_trip() {
let p = rich_deck();
let q = round(&p);
assert_eq!(q.slides.len(), p.slides.len());
assert!(q.validate().is_empty(), "{:?}", q.validate());
assert_eq!(q.slide_size, p.slide_size);
assert_eq!(q.first_slide_number, 0);
assert_eq!(q.props.title, "Rich deck");
assert_eq!(q.props.author, "DeckCraft tests");
assert_eq!(q.props.created, "2025-01-02T03:04:05Z");
assert_eq!(
q.sections.iter().map(|s| (s.name.clone(), s.slides.len())).collect::<Vec<_>>(),
vec![("Start".to_string(), 2), ("Rest".to_string(), 4)]
);
assert_eq!(q.custom_shows.len(), 1);
assert_eq!(q.custom_shows[0].slides, vec![q.slides[0].id, q.slides[3].id]);
assert!(q.slides[2].hidden);
// Themes and layouts.
assert_eq!(q.masters.len(), 1);
let (pm, qm) = (&p.masters[0], &q.masters[0]);
assert_eq!(qm.theme.colors.colors, pm.theme.colors.colors);
assert_eq!(qm.theme.fonts.major.latin, pm.theme.fonts.major.latin);
assert_eq!(qm.layouts.len(), pm.layouts.len());
for (a, b) in pm.layouts.iter().zip(qm.layouts.iter()) {
assert_eq!((a.name.as_str(), a.kind, a.shapes.len()), (b.name.as_str(), b.kind, b.shapes.len()));
}
assert_eq!(qm.title_style, pm.title_style);
assert_eq!(qm.body_style, pm.body_style);
assert_eq!(q.default_text_style, p.default_text_style);
for (a, b) in p.slides.iter().zip(q.slides.iter()) {
let (la, lb) = (p.layout(a.layout).map(|x| &x.1.name), q.layout(b.layout).map(|x| &x.1.name));
assert_eq!(la, lb);
}
}
#[test]
fn text_and_formatting_round_trip() {
let p = rich_deck();
let q = round(&p);
assert_eq!(q.slides[0].notes_text(), "Speaker notes line 1\nline 2");
let (a, b) = (&p.slides[0].shapes[0], &q.slides[0].shapes[0]);
assert_eq!(a.text, b.text);
assert!(b.xfrm.is_none(), "placeholder without xfrm inherits");
let sa = by_name(&p.slides[1], "Pattern Box");
let sb = by_name(&q.slides[1], "Pattern Box");
assert_eq!(sa.text, sb.text);
assert_eq!(sa.click, sb.click);
assert!(by_name(&q.slides[1], "Text Box").text_box);
assert_eq!(by_name(&q.slides[1], "Text Box").descr, "alt text");
let la = by_name(&p.slides[5], "Go to shapes");
let lb = by_name(&q.slides[5], "Go to shapes");
assert_eq!(lb.click.as_ref().map(|h| h.action.clone()), Some(Action::Slide { slide: q.slides[1].id }));
assert!(la.click.is_some());
let eq = by_name(&q.slides[5], "Equation");
let run = &eq.text.as_ref().expect("text").paragraphs[0].runs[0];
assert!(matches!(&run.kind, RunKind::Math { omml } if omml.contains("oMath")), "{run:?}");
assert_eq!(run.text, "x=1");
}
#[test]
fn centered_cell_anchor_survives_two_pptx_round_trips() {
let mut p = Presentation::default();
let mut slide = new_slide(&mut p, "Cell anchor");
let mut table_shape = shape(&mut p, "Table", 10.0, 10.0, 200.0, 80.0);
let mut table = Table::new(1, 1, 200.0, 80.0);
table.rows[0].cells[0].anchor_ctr = Some(true);
table_shape.kind = ShapeKind::Table(table);
slide.shapes.push(table_shape);
p.slides.push(Arc::new(slide));
let once = round(&p);
let twice = round(&once);
let slide = twice.slides.last().expect("added slide");
let ShapeKind::Table(table) = &by_name(slide, "Table").kind else { panic!("table") };
assert_eq!(table.rows[0].cells[0].anchor_ctr, Some(true));
}
#[test]
fn normalized_character_height_survives_two_pptx_round_trips() {
let mut p = Presentation::default();
let mut slide = new_slide(&mut p, "Normalized height");
let mut enabled = shape(&mut p, "Enabled", 10.0, 10.0, 200.0, 80.0);
let mut enabled_body = TextBody::from_text("enabled");
enabled_body.paragraphs[0].runs[0].props.normalize_height = Some(true);
enabled_body.paragraphs[0].runs[0].props.size = Some(18.0);
enabled_body.paragraphs[0].runs[0].props.caps = Some(Caps::Small);
enabled_body.paragraphs[0].runs[0].props.spacing = Some(1.5);
enabled.text = Some(enabled_body);
let mut disabled = shape(&mut p, "Disabled", 10.0, 100.0, 200.0, 80.0);
let mut disabled_body = TextBody::from_text("disabled");
disabled_body.paragraphs[0].runs[0].props.normalize_height = Some(false);
disabled.text = Some(disabled_body);
let mut absent = shape(&mut p, "Absent", 10.0, 190.0, 200.0, 80.0);
absent.text = Some(TextBody::from_text("absent"));
slide.shapes = vec![enabled, disabled, absent];
p.slides.push(Arc::new(slide));
let twice = round(&round(&p));
let slide = twice.slides.last().expect("added slide");
let run = &by_name(slide, "Enabled").text.as_ref().expect("text").paragraphs[0].runs[0];
assert_eq!(run.props.normalize_height, Some(true));
assert_eq!(run.props.size, Some(18.0));
assert_eq!(run.props.caps, Some(Caps::Small));
assert_eq!(run.props.spacing, Some(1.5));
let run = &by_name(slide, "Disabled").text.as_ref().expect("text").paragraphs[0].runs[0];
assert_eq!(run.props.normalize_height, Some(false));
let run = &by_name(slide, "Absent").text.as_ref().expect("text").paragraphs[0].runs[0];
assert_eq!(run.props.normalize_height, None);
}
#[test]
fn thai_distributed_alignment_survives_two_pptx_round_trips() {
assert_eq!(Align::from_xml("thaiDist"), Some(Align::ThaiDistributed));
assert_eq!(Align::ThaiDistributed.xml(), "thaiDist");
assert_eq!(Align::from_xml("just"), Some(Align::Justify));
let mut p = Presentation::default();
let mut slide = new_slide(&mut p, "Thai distributed alignment");
let mut text = shape(&mut p, "Text", 10.0, 10.0, 200.0, 80.0);
let mut body = TextBody::from_text("one two three");
body.paragraphs[0].props.align = Some(Align::ThaiDistributed);
text.text = Some(body);
slide.shapes.push(text);
p.slides.push(Arc::new(slide));
let twice = round(&round(&p));
let slide = twice.slides.last().expect("added slide");
let text = by_name(slide, "Text").text.as_ref().expect("text body");
assert_eq!(text.paragraphs[0].props.align, Some(Align::ThaiDistributed));
}
#[test]
fn compatible_line_spacing_mode_survives_two_pptx_round_trips() {
let mut p = Presentation::default();
let mut slide = new_slide(&mut p, "Compatible line spacing");
let mut enabled = shape(&mut p, "Enabled", 10.0, 10.0, 200.0, 80.0);
let mut enabled_body = TextBody::from_text("enabled");
enabled_body.body.compat_ln_spc = Some(true);
enabled.text = Some(enabled_body);
let mut disabled = shape(&mut p, "Disabled", 10.0, 100.0, 200.0, 80.0);
let mut disabled_body = TextBody::from_text("disabled");
disabled_body.body.compat_ln_spc = Some(false);
disabled.text = Some(disabled_body);
slide.shapes = vec![enabled, disabled];
p.slides.push(Arc::new(slide));
let twice = round(&round(&p));
let slide = twice.slides.last().expect("added slide");
assert_eq!(by_name(slide, "Enabled").text.as_ref().expect("text").body.compat_ln_spc, Some(true));
assert_eq!(by_name(slide, "Disabled").text.as_ref().expect("text").body.compat_ln_spc, Some(false));
}
#[test]
fn text_overflow_policies_survive_two_pptx_round_trips() {
let mut p = Presentation::default();
let mut slide = new_slide(&mut p, "Text overflow");
let mut text = shape(&mut p, "Text", 10.0, 10.0, 200.0, 80.0);
let mut body = TextBody::from_text("policy");
body.body.vert_overflow = Some(TextOverflow::Clip);
body.body.horz_overflow = Some(TextOverflow::Overflow);
text.text = Some(body);
let mut table_shape = shape(&mut p, "Table", 10.0, 100.0, 200.0, 80.0);
let mut table = Table::new(1, 1, 200.0, 80.0);
table.rows[0].cells[0].horz_overflow = Some(TextOverflow::Clip);
table_shape.kind = ShapeKind::Table(table);
slide.shapes = vec![text, table_shape];
p.slides.push(Arc::new(slide));
let twice = round(&round(&p));
let slide = twice.slides.last().expect("added slide");
let text = by_name(slide, "Text").text.as_ref().expect("text body");
assert_eq!(text.body.vert_overflow, Some(TextOverflow::Clip));
assert_eq!(text.body.horz_overflow, Some(TextOverflow::Overflow));
let ShapeKind::Table(table) = &by_name(slide, "Table").kind else { panic!("table") };
assert_eq!(table.rows[0].cells[0].horz_overflow, Some(TextOverflow::Clip));
}
#[test]
fn horizontal_ellipsis_is_not_written_because_only_vertical_overflow_has_it() {
let mut p = Presentation::default();
let mut slide = new_slide(&mut p, "Horizontal ellipsis");
let mut text = shape(&mut p, "Text", 10.0, 10.0, 200.0, 80.0);
let mut body = TextBody::from_text("policy");
body.body.vert_overflow = Some(TextOverflow::Ellipsis);
body.body.horz_overflow = Some(TextOverflow::Ellipsis);
text.text = Some(body);
slide.shapes = vec![text];
p.slides.push(Arc::new(slide));
let once = round(&p);
let slide = once.slides.last().expect("added slide");
let text = by_name(slide, "Text").text.as_ref().expect("text body");
assert_eq!(text.body.vert_overflow, Some(TextOverflow::Ellipsis));
assert_eq!(text.body.horz_overflow, None);
}
#[test]
fn shapes_fills_lines_effects_round_trip() {
let p = rich_deck();
let q = round(&p);
for name in ["Gradient Star", "Pattern Box", "Freeform", "Uses background"] {
let (a, b) = (by_name(&p.slides[1], name), by_name(&q.slides[1], name));
assert_eq!(a.geom, b.geom, "{name}");
assert_eq!(a.fill, b.fill, "{name}");
assert_eq!(a.line, b.line, "{name}");
assert_eq!(a.effects, b.effects, "{name}");
assert_eq!(a.xfrm, b.xfrm, "{name}");
}
let g = by_name(&q.slides[1], "Group");
assert!(matches!(&g.kind, ShapeKind::Group { children, child } if children.len() == 2 && child.w == 110.0));
let c = by_name(&q.slides[1], "Connector");
let (c1, c2) = (by_name(&q.slides[1], "Child 1").id, by_name(&q.slides[1], "Child 2").id);
assert!(matches!(c.kind, ShapeKind::Connector { start: Some((s, 2)), end: Some((e, 0)) } if s == c1 && e == c2), "{:?}", c.kind);
assert_eq!(c.line, by_name(&p.slides[1], "Connector").line);
// Ids are kept.
assert_eq!(by_name(&q.slides[1], "Group").id, by_name(&p.slides[1], "Group").id);
}
#[test]
fn bullet_size_in_points_survives_two_pptx_round_trips() {
let mut p = Presentation::default();
let mut textbox = shape(&mut p, "Point-sized bullet", 20.0, 20.0, 400.0, 100.0);
textbox.text = Some(TextBody {
paragraphs: [12.0, 500.0, 4000.0]
.into_iter()
.map(|size| Paragraph {
props: deckcraft_model::text::ParaProps {
bullet: Some(Bullet::Char { char: "•".into() }),
bullet_size_points: Some(size),
..Default::default()
},
runs: vec![Run::with("Bullet text", RunProps::default())],
..Default::default()
})
.collect(),
..Default::default()
});
Arc::make_mut(&mut p.slides[0]).shapes.push(textbox);
let q = round(&round(&p));
let props = &by_name(&q.slides[0], "Point-sized bullet").text.as_ref().expect("text").paragraphs;
assert_eq!(props.iter().map(|p| p.props.bullet_size_points).collect::<Vec<_>>(), vec![Some(12.0), Some(500.0), Some(4000.0)]);
assert!(props.iter().all(|p| p.props.bullet_size.is_none()));
}
#[test]
fn line_miter_limit_survives_two_pptx_round_trips() {
let mut p = Presentation::default();
let mut limited = shape(&mut p, "Limited miter", 20.0, 20.0, 100.0, 100.0);
limited.line = Some(Line { join: Some(deckcraft_model::style::LineJoin::Miter), miter_limit: Some(200_000), ..Default::default() });
let mut defaulted = shape(&mut p, "Default miter", 140.0, 20.0, 100.0, 100.0);
defaulted.line = Some(Line { join: Some(deckcraft_model::style::LineJoin::Miter), ..Default::default() });
let mut large = shape(&mut p, "Large miter", 260.0, 20.0, 100.0, 100.0);
large.line = Some(Line { join: Some(deckcraft_model::style::LineJoin::Miter), miter_limit: Some(1_000_001), ..Default::default() });
Arc::make_mut(&mut p.slides[0]).shapes.extend([limited, defaulted, large]);
let q = round(&round(&p));
assert_eq!(by_name(&q.slides[0], "Limited miter").line.as_ref().and_then(|line| line.miter_limit), Some(200_000));
assert_eq!(by_name(&q.slides[0], "Default miter").line.as_ref().and_then(|line| line.miter_limit), None);
assert_eq!(by_name(&q.slides[0], "Large miter").line.as_ref().and_then(|line| line.miter_limit), Some(1_000_001));
}
#[test]
fn bullet_follow_text_resets_survive_two_pptx_round_trips() {
let mut p = Presentation::default();
let mut textbox = shape(&mut p, "Follow text bullets", 20.0, 20.0, 400.0, 100.0);
textbox.text = Some(TextBody {
paragraphs: vec![Paragraph {
props: deckcraft_model::text::ParaProps {
bullet: Some(Bullet::Char { char: "•".into() }),
bullet_color_follow_text: Some(true),
bullet_size_follow_text: Some(true),
bullet_font_follow_text: Some(true),
..Default::default()
},
runs: vec![Run::with("Bullet text", RunProps::default())],
..Default::default()
}],
..Default::default()
});
Arc::make_mut(&mut p.slides[0]).shapes.push(textbox);
let mut conflicting = shape(&mut p, "Explicit bullet values", 20.0, 140.0, 400.0, 100.0);
conflicting.text = Some(TextBody {
paragraphs: vec![Paragraph {
props: deckcraft_model::text::ParaProps {
bullet: Some(Bullet::Char { char: "•".into() }),
bullet_color: Some(deckcraft_model::style::ColorRef::rgb(deckcraft_color::Rgba::rgb(255, 0, 0))),
bullet_color_follow_text: Some(true),
bullet_size: Some(1.5),
bullet_size_follow_text: Some(true),
bullet_font: Some("Inter".into()),
bullet_font_follow_text: Some(true),
..Default::default()
},
runs: vec![Run::with("Explicit bullet text", RunProps::default())],
..Default::default()
}],
..Default::default()
});
Arc::make_mut(&mut p.slides[0]).shapes.push(conflicting);
let q = round(&round(&p));
let props = &by_name(&q.slides[0], "Follow text bullets").text.as_ref().expect("text").paragraphs[0].props;
assert_eq!(props.bullet_color_follow_text, Some(true));
assert_eq!(props.bullet_size_follow_text, Some(true));
assert_eq!(props.bullet_font_follow_text, Some(true));
let explicit = &by_name(&q.slides[0], "Explicit bullet values").text.as_ref().expect("text").paragraphs[0].props;
assert_eq!(explicit.bullet_color_follow_text, None);
assert_eq!(explicit.bullet_size_follow_text, None);
assert_eq!(explicit.bullet_font_follow_text, None);
assert_eq!(explicit.bullet_size, Some(1.5));
assert_eq!(explicit.bullet_font.as_deref(), Some("Inter"));
assert_eq!(explicit.bullet_color, Some(deckcraft_model::style::ColorRef::rgb(deckcraft_color::Rgba::rgb(255, 0, 0))));
}
#[test]
fn line_alignment_survives_two_pptx_round_trips() {
let mut p = Presentation::default();
let mut inside = shape(&mut p, "Inset line", 20.0, 20.0, 100.0, 100.0);
inside.line = Some(Line { align: Some(deckcraft_model::style::LineAlign::Inside), ..Default::default() });
let mut centered = shape(&mut p, "Centered line", 140.0, 20.0, 100.0, 100.0);
centered.line = Some(Line { align: Some(deckcraft_model::style::LineAlign::Center), ..Default::default() });
Arc::make_mut(&mut p.slides[0]).shapes.extend([inside, centered]);
let q = round(&round(&p));
assert_eq!(by_name(&q.slides[0], "Inset line").line.as_ref().and_then(|line| line.align), Some(deckcraft_model::style::LineAlign::Inside));
assert_eq!(by_name(&q.slides[0], "Centered line").line.as_ref().and_then(|line| line.align), Some(deckcraft_model::style::LineAlign::Center));
assert_eq!(deckcraft_model::style::LineAlign::from_xml("out"), None);
}
#[test]
fn gradient_flip_mode_survives_two_pptx_round_trips() {
let p = rich_deck();
let q = round(&round(&p));
let gradient = by_name(&q.slides[1], "Gradient Star").fill.as_ref();
assert!(matches!(gradient, Some(Fill::Gradient(g)) if g.flip == Some(GradientFlip::Xy)));
}
#[test]
fn pictures_media_and_ink_round_trip() {
let p = rich_deck();
let q = round(&p);
let (a, b) = (by_name(&p.slides[2], "Picture"), by_name(&q.slides[2], "Picture"));
let (ShapeKind::Picture { fill: fa }, ShapeKind::Picture { fill: fb }) = (&a.kind, &b.kind) else { panic!("not pictures") };
assert_eq!(fa.crop, fb.crop);
assert_eq!(fa.alpha, fb.alpha);
assert_eq!(fa.adjust, fb.adjust);
assert_eq!(p.media(fa.media).map(|m| m.data.clone()), q.media(fb.media).map(|m| m.data.clone()));
let t = by_name(&q.slides[2], "Tiled");
assert!(matches!(&t.fill, Some(Fill::Picture(pf)) if matches!(pf.mode, PictureMode::Tile { sx, .. } if sx == 0.5)));
let v = by_name(&q.slides[2], "Video");
let ShapeKind::Media(m) = &v.kind else { panic!("not media: {:?}", v.kind) };
assert!(m.video);
assert_eq!((m.trim_start_ms, m.fade_in_ms), (500, 250));
assert!(q.media(m.media).is_some_and(|x| x.data.starts_with(b"\x00\x00\x00\x18ftyp")));
assert!(m.poster.is_some());
// The crop of the video survives the round trip (#972).
for (got, want) in m.crop.iter().zip([0.1, 0.0, 0.2, 0.25]) {
assert!((got - want).abs() < 1e-4, "video crop {:?}", m.crop);
}
// Ink comes back as freeform lines in a group. A flat 0.5 stroke keeps the pen width.
let ink = by_name(&q.slides[2], "Ink");
let ShapeKind::Group { children, .. } = &ink.kind else { panic!("ink is not a group: {:?}", ink.kind) };
assert_eq!(children.len(), 1);
assert!(matches!(children[0].geom, Geom::Custom { .. }));
let w = children[0].line.as_ref().and_then(|l| l.width).unwrap_or(0.0);
assert!((w - 3.0).abs() < 0.05, "a flat 0.5 stroke keeps the pen width, got {w}");
}
#[test]
fn pressured_ink_exports_at_its_mean_width() {
let mut p = Presentation::default();
let id = ShapeId(p.alloc_id().expect("id"));
let slide = std::sync::Arc::make_mut(&mut p.slides[0]);
slide.shapes.push(Shape {
id,
name: "Ink".into(),
xfrm: Some(Xfrm::new(0.0, 0.0, 960.0, 540.0)),
kind: ShapeKind::Ink {
strokes: vec![InkStroke {
points: vec![(10.0, 10.0, 1.0), (40.0, 10.0, 0.5), (80.0, 10.0, 0.0)],
color: Rgba::rgb(0, 0, 0),
width: 10.0,
highlighter: false,
}],
},
..Default::default()
});
let q = round(&p);
let ink = by_name(&q.slides[0], "Ink");
let ShapeKind::Group { children, .. } = &ink.kind else { panic!("{:?}", ink.kind) };
let w = children[0].line.as_ref().and_then(|l| l.width).unwrap_or(0.0);
// Full, half, and the 8% floor: (10 + 5 + 0.8) / 3.
assert!((w - (10.0 + 5.0 + 0.8) / 3.0).abs() < 0.05, "{w}");
}
#[test]
fn tables_round_trip() {
let p = rich_deck();
let q = round(&p);
let (ShapeKind::Table(a), ShapeKind::Table(b)) = (&by_name(&p.slides[3], "Table 1").kind, &by_name(&q.slides[3], "Table 1").kind) else {
panic!()
};
// A cell always has at least one paragraph in the file; compare without empty ones.
let norm = |t: &Table| {
let mut t = t.clone();
for r in &mut t.rows {
for c in &mut r.cells {
c.text.paragraphs.retain(|p| !p.is_empty());
}
}
t
};
assert_eq!(norm(a), norm(b));
}
#[test]
fn charts_round_trip() {
let p = rich_deck();
let q = round(&p);
for (sa, sb) in p.slides[4].shapes.iter().zip(q.slides[4].shapes.iter()) {
let (ShapeKind::Chart(a), ShapeKind::Chart(b)) = (&sa.kind, &sb.kind) else { continue };
assert_eq!(a.kind, b.kind, "{}", sa.name);
assert_eq!(a.title, b.title);
assert_eq!(a.series.len(), b.series.len());
for (x, y) in a.series.iter().zip(b.series.iter()) {
assert_eq!(x.name, y.name);
assert_eq!(x.values, y.values, "{}", sa.name);
}
if !matches!(a.kind, ChartType::Scatter | ChartType::Bubble) {
assert_eq!(a.categories, b.categories);
}
assert!(b.raw.is_some());
}
// Second export reuses the kept chart XML unchanged.
let r = round(&q);
for (sa, sb) in q.slides[4].shapes.iter().zip(r.slides[4].shapes.iter()) {
if let (ShapeKind::Chart(a), ShapeKind::Chart(b)) = (&sa.kind, &sb.kind) {
let (mut a, mut b) = (a.clone(), b.clone());
a.raw = None;
b.raw = None;
assert_eq!(a, b);
}
}
}
#[test]
fn transitions_and_animations_round_trip() {
let p = rich_deck();
let q = round(&p);
for (a, b) in p.slides.iter().zip(q.slides.iter()) {
match (&a.transition, &b.transition) {
(Some(x), Some(y)) => {
assert_eq!(
(&x.kind, &x.option, x.duration_ms, x.advance_on_click, x.advance_after_ms),
(&y.kind, &y.option, y.duration_ms, y.advance_on_click, y.advance_after_ms)
);
}
(None, None) => {}
other => panic!("{other:?}"),
}
assert_eq!(a.animations.len(), b.animations.len());
for (x, y) in a.animations.iter().zip(b.animations.iter()) {
assert_eq!(
(&x.effect, &x.option, x.class, x.start, x.duration_ms, x.delay_ms, x.text_build),
(&y.effect, &y.option, y.class, y.start, y.duration_ms, y.delay_ms, y.text_build)
);
assert_eq!(x.shape, y.shape);
assert_eq!(x.trigger, y.trigger);
if x.class == AnimClass::Path {
assert_eq!(x.path, y.path);
}
}
}
}
#[test]
fn comments_round_trip() {
let p = rich_deck();
let q = round(&p);
let c = &q.slides[1].comments;
assert_eq!(c.len(), 1);
assert_eq!((c[0].author.as_str(), c[0].initials.as_str(), c[0].text.as_str()), ("Ada", "AL", "Nice star"));
assert_eq!((c[0].x, c[0].y), (120.0, 64.0));
}
#[test]
fn every_transition_kind_survives() {
let mut p = defaults::new_presentation(None);
let base = p.slides[0].as_ref().clone();
p.slides.clear();
for (kind, ..) in deckcraft_model::anim::TRANSITIONS {
let mut s = base.clone();
s.id = SlideId(p.alloc_id().expect("ids"));
s.transition = Some(Transition { kind: kind.to_string(), duration_ms: 1200, ..Default::default() });
p.slides.push(Arc::new(s));
}
let q = round(&p);
for (a, b) in p.slides.iter().zip(q.slides.iter()) {
let k = a.transition.as_ref().map(|t| t.kind.clone()).unwrap_or_default();
if k == "none" {
continue;
}
assert_eq!(b.transition.as_ref().map(|t| t.kind.clone()), Some(k.clone()));
assert_eq!(b.transition.as_ref().map(|t| t.duration_ms), Some(1200), "{k}");
}
}
#[test]
fn every_animation_effect_survives() {
let mut p = defaults::new_presentation(None);
let mut s = p.slides[0].as_ref().clone();
let mut sh = shape(&mut p, "Target", 100.0, 100.0, 100.0, 100.0);
sh.text = Some(TextBody::from_text("hi"));
let id = sh.id;
s.shapes.push(sh);
for (effect, _, class, _, dur, opts) in deckcraft_model::anim::ANIMATIONS {
s.animations.push(Animation {
shape: id,
class: *class,
effect: effect.to_string(),
option: opts.first().map(|o| o.to_string()).unwrap_or_default(),
duration_ms: (*dur).max(1),
..Default::default()
});
}
p.slides[0] = Arc::new(s);
let q = round(&p);
let (a, b) = (&p.slides[0].animations, &q.slides[0].animations);
assert_eq!(a.len(), b.len());
for (x, y) in a.iter().zip(b.iter()) {
// Effects sharing a preset number come back as the first effect with that number.
let same_preset = deckcraft_model::anim::animation_info(&x.effect, x.class).map(|i| i.3)
== deckcraft_model::anim::animation_info(&y.effect, y.class).map(|i| i.3);
assert!(x.effect == y.effect || same_preset, "{} vs {}", x.effect, y.effect);
assert_eq!(x.class, y.class);
}
}
#[test]
fn animation_rewind_survives() {
let mut p = defaults::new_presentation(None);
let mut s = p.slides[0].as_ref().clone();
let sh = shape(&mut p, "Target", 100.0, 100.0, 100.0, 100.0);
let id = sh.id;
s.shapes.push(sh);
s.animations.push(Animation { shape: id, rewind: true, ..Default::default() });
s.animations.push(Animation { shape: id, effect: "fly".into(), option: "l".into(), start: AnimStart::WithPrevious, ..Default::default() });
p.slides[0] = Arc::new(s);
let q = round(&p);
let b = &q.slides[0].animations;
assert_eq!(b.len(), 2);
assert!(b[0].rewind);
assert!(!b[1].rewind);
}
/// Writes bisection variants of the rich deck to `DECKCRAFT_PPTX_BISECT` (manual checks).
#[test]
fn bisect_variants() {
let Ok(dir) = std::env::var("DECKCRAFT_PPTX_BISECT") else { return };
let p = rich_deck();
let n = p.slides.len();
for i in 0..n {
let mut q = p.clone();
q.slides = vec![p.slides[i].clone()];
q.sections.clear();
q.custom_shows.clear();
std::fs::write(format!("{dir}/bis-slide{i}.pptx"), deckcraft_pptx::export(&q).expect("export")).expect("write");
}
let mut q = p.clone();
q.sections.clear();
q.custom_shows.clear();
q.first_slide_number = 1;
for s in q.slides.iter_mut() {
Arc::make_mut(s).comments.clear();
}
std::fs::write(format!("{dir}/bis-nodeck.pptx"), deckcraft_pptx::export(&q).expect("export")).expect("write");
}
/// Finer bisection of one slide (`DECKCRAFT_PPTX_BISECT_SLIDE=<index>`): one variant per removed shape,
/// plus no animations / no transition.
#[test]
fn bisect_slide_variants() {
let (Ok(dir), Ok(idx)) = (std::env::var("DECKCRAFT_PPTX_BISECT"), std::env::var("DECKCRAFT_PPTX_BISECT_SLIDE")) else { return };
let p = rich_deck();
let i: usize = idx.parse().expect("index");
let base = p.slides[i].as_ref().clone();
let one = |s: Slide| {
let mut q = p.clone();
q.slides = vec![Arc::new(s)];
q.sections.clear();
q.custom_shows.clear();
deckcraft_pptx::export(&q).expect("export")
};
let mut s = base.clone();
s.animations.clear();
std::fs::write(format!("{dir}/v-noanim.pptx"), one(s)).expect("write");
let mut s = base.clone();
s.transition = None;
std::fs::write(format!("{dir}/v-notrans.pptx"), one(s)).expect("write");
for k in 0..base.shapes.len() {
let mut s = base.clone();
s.animations.clear();
s.transition = None;
let keep = s.shapes[k].clone();
s.shapes.retain(|x| x.id == keep.id);
std::fs::write(format!("{dir}/v-only{k}.pptx"), one(s)).expect("write");
}
}
#[test]
fn rtl_paragraphs_script_fonts_and_just_low_round_trip() {
let mut p = rich_deck();
let fonts = &mut Arc::make_mut(&mut p.masters[0]).theme.fonts;
fonts.minor.cs = "Noto Naskh Arabic".into();
fonts.minor.scripts = vec![
deckcraft_model::theme::ScriptFont { script: "Arab".into(), typeface: "Noto Naskh Arabic".into() },
deckcraft_model::theme::ScriptFont { script: "Hebr".into(), typeface: "Noto Sans Hebrew".into() },
];
let slide = Arc::make_mut(&mut p.slides[0]);
let sh = slide.shapes.iter_mut().find(|s| s.text.is_some()).expect("a text shape");
let body = sh.text.as_mut().expect("text");
body.paragraphs = vec![Paragraph { runs: vec![Run::new("سنة 2024 (Retrait) فقط")], ..Default::default() }];
body.paragraphs[0].props.rtl = Some(true);
body.paragraphs[0].props.align = Some(Align::JustLow);
let name = sh.name.clone();
let q = round(&p);
assert_eq!(q.masters[0].theme.fonts.minor.scripts, p.masters[0].theme.fonts.minor.scripts);
assert_eq!(q.masters[0].theme.fonts.minor.script("arab"), Some("Noto Naskh Arabic"));
let para = &by_name(&q.slides[0], &name).text.as_ref().expect("text").paragraphs[0];
assert_eq!(para.props.rtl, Some(true));
assert_eq!(para.props.align, Some(Align::JustLow));
assert_eq!(para.runs[0].text, "سنة 2024 (Retrait) فقط");
}
#[test]
fn date_fields_keep_their_type_and_saved_text() {
// An automatic date is a field (its saved text is what readers without a clock show); a fixed
// date is plain text.
let mut p = Presentation::default();
let mut auto = shape(&mut p, "Auto date", 10.0, 10.0, 200.0, 40.0);
let mut body = TextBody::from_text("");
body.paragraphs[0].runs =
vec![Run { text: "March 3, 2025".into(), props: RunProps::default(), kind: RunKind::Field { field: "datetime4".into() } }];
auto.text = Some(body);
let mut fixed = shape(&mut p, "Fixed date", 10.0, 60.0, 200.0, 40.0);
fixed.text = Some(TextBody::from_text("Launch day"));
Arc::make_mut(&mut p.slides[0]).shapes = vec![auto, fixed];
let q = round(&p);
for name in ["Auto date", "Fixed date"] {
assert_eq!(by_name(&q.slides[0], name).text, by_name(&p.slides[0], name).text, "{name}");
}
}
#[test]
fn colour_map_overrides_round_trip() {
let mut p = defaults::new_presentation(None);
let dark: Vec<(String, String)> =
[("bg1", "dk1"), ("tx1", "lt1"), ("bg2", "dk2"), ("tx2", "lt2")].iter().map(|(a, b)| (a.to_string(), b.to_string())).collect();
let layout = p.slides[0].layout;
std::sync::Arc::make_mut(&mut p.masters[0]).layouts.iter_mut().find(|l| l.id == layout).expect("layout").color_map = Some(dark.clone());
let first = p.slides[0].id;
p.slide_mut(first).expect("slide").color_map = Some(dark.clone());
let q = round(&p);
let get = |m: &Option<Vec<(String, String)>>, k: &str| m.as_ref().and_then(|m| m.iter().find(|(a, _)| a == k).map(|(_, v)| v.clone()));
let ql = q.masters[0].layouts.iter().find(|l| l.color_map.is_some()).expect("the layout keeps its override");
assert_eq!(get(&ql.color_map, "bg1").as_deref(), Some("dk1"));
assert_eq!(get(&q.slides[0].color_map, "tx1").as_deref(), Some("lt1"));
// Layouts and slides without one keep following the master.
assert!(q.masters[0].layouts.iter().filter(|l| l.color_map.is_none()).count() >= 1);
}
#[test]
fn a_picture_duotone_round_trips() {
let mut p = defaults::new_presentation(None);
let img = p.add_media("image1.png", "image/png", png(4, 4, [128, 128, 128])).expect("media");
let mut pic = shape(&mut p, "Duotone", 10.0, 10.0, 100.0, 100.0);
let mut pf = PictureFill { media: img, ..Default::default() };
pf.adjust.duotone = Some((ColorRef::scheme(SchemeSlot::Accent1).with(ColorTransform::Shade(30000)), ColorRef::rgb(Rgba::rgb(250, 240, 200))));
pic.kind = deckcraft_model::ShapeKind::Picture { fill: pf };
let first = p.slides[0].id;
p.slide_mut(first).expect("slide").shapes.push(pic);
let q = round(&p);
let sh = by_name(&q.slides[0], "Duotone");
let deckcraft_model::ShapeKind::Picture { fill } = &sh.kind else { panic!("picture") };
let (d, l) = fill.adjust.duotone.as_ref().expect("duotone kept");
assert!(matches!(d.base, deckcraft_model::ColorBase::Scheme { slot: SchemeSlot::Accent1 }));
assert!(matches!(l.base, deckcraft_model::ColorBase::Rgb { rgb } if rgb == Rgba::rgb(250, 240, 200)));
}
#[test]
fn line_break_options_round_trip() {
let mut p = defaults::new_presentation(None);
let first = p.slides[0].id;
let s = p.slide_mut(first).expect("slide");
let t = s.shapes[0].text.insert(TextBody::from_text("x"));
t.paragraphs[0].props.latin_line_break = Some(true);
t.paragraphs[0].props.hanging_punct = Some(false);
let q = round(&p);
let props = &q.slides[0].shapes[0].text.as_ref().expect("text").paragraphs[0].props;
assert_eq!(props.latin_line_break, Some(true));
assert_eq!(props.hanging_punct, Some(false));
}
#[test]
fn a_table_fill_round_trips() {
let mut p = defaults::new_presentation(None);
let mut t = Table::new(2, 2, 200.0, 40.0);
t.background = Some(Fill::solid(ColorRef::rgb(Rgba::rgb(0, 112, 192))));
let mut sh = shape(&mut p, "Filled table", 10.0, 10.0, 200.0, 80.0);
sh.kind = deckcraft_model::ShapeKind::Table(t);
let first = p.slides[0].id;
p.slide_mut(first).expect("slide").shapes.push(sh);
let q = round(&p);
let deckcraft_model::ShapeKind::Table(t) = &by_name(&q.slides[0], "Filled table").kind else { panic!("table") };
assert!(
matches!(&t.background, Some(Fill::Solid { color }) if matches!(color.base, deckcraft_model::ColorBase::Rgb { rgb } if rgb == Rgba::rgb(0, 112, 192)))
);
}
#[test]
fn wordart_warps_and_their_adjusts_round_trip() {
let mut p = Presentation::default();
let cases: [(&str, &str, Vec<f64>); 5] = [
("Arch pour", "textArchUpPour", vec![13_500_000.0, 30_000.0]),
("Wave", "textWave1", vec![18_000.0, -5_000.0]),
("Inflate", "textInflate", vec![30_000.0]),
("Arch", "textArchUp", vec![]),
("Ring", "textRingInside", vec![75_000.0]),
];
let mut shapes = vec![];
for (i, (name, warp, adj)) in cases.iter().enumerate() {
let mut s = shape(&mut p, name, 10.0, 10.0 + 50.0 * i as f64, 300.0, 40.0);
let mut body = TextBody::from_text("WordArt");
body.body.warp = Some((*warp).into());
body.body.warp_adj = adj.clone();
s.text = Some(body);
shapes.push(s);
}
Arc::make_mut(&mut p.slides[0]).shapes = shapes;
let q = round(&p);
for (name, warp, adj) in &cases {
let b = &by_name(&q.slides[0], name).text.as_ref().expect("text").body;
assert_eq!(b.warp.as_deref(), Some(*warp), "{name}");
assert_eq!(&b.warp_adj, adj, "{name}");
}
// The single-adjust preset is written with the guide name `adj`, two-adjust ones with
// `adj1`/`adj2`, and a preset with no adjusts given gets an empty list.
let bytes = deckcraft_pptx::export(&p).expect("export");
let mut zip = zip::ZipArchive::new(std::io::Cursor::new(bytes)).expect("zip");
let mut xml = String::new();
std::io::Read::read_to_string(&mut zip.by_name("ppt/slides/slide1.xml").expect("slide"), &mut xml).expect("read");
assert!(xml.contains(r#"<a:prstTxWarp prst="textInflate"><a:avLst><a:gd name="adj" fmla="val 30000"/></a:avLst></a:prstTxWarp>"#), "{xml}");
assert!(xml.contains(r#"<a:gd name="adj1" fmla="val 13500000"/><a:gd name="adj2" fmla="val 30000"/>"#));
assert!(xml.contains(r#"<a:prstTxWarp prst="textArchUp"><a:avLst/></a:prstTxWarp>"#));
// A file that gives only `adj2` keeps the preset's default for `adj1`; hostile values are
// read as numbers or dropped.
let edited = xml
.replace(r#"<a:gd name="adj1" fmla="val 13500000"/>"#, "")
.replace(r#"<a:gd name="adj" fmla="val 30000"/>"#, r#"<a:gd name="adj" fmla="val NaN"/>"#);
let mut out = zip::ZipWriter::new(std::io::Cursor::new(Vec::new()));
for i in 0..zip.len() {
let mut f = zip.by_index(i).expect("entry");
let name = f.name().to_string();
let mut data = vec![];
std::io::Read::read_to_end(&mut f, &mut data).expect("read");
if name == "ppt/slides/slide1.xml" {
data = edited.clone().into_bytes();
}
out.start_file(name, zip::write::SimpleFileOptions::default()).expect("start");
std::io::Write::write_all(&mut out, &data).expect("write");
}
let bytes = out.finish().expect("finish").into_inner();
let q = deckcraft_pptx::import(&bytes).expect("import");
let pour = &by_name(&q.slides[0], "Arch pour").text.as_ref().expect("text").body;
assert_eq!(pour.warp_adj, vec![10_800_000.0, 30_000.0]);
let inflate = &by_name(&q.slides[0], "Inflate").text.as_ref().expect("text").body;
assert_eq!(inflate.warp.as_deref(), Some("textInflate"));
assert!(inflate.warp_adj.is_empty());
}
/// Slide XML of a deck exported with one slide per transition (kind, option, ms, advance after).
fn transition_deck(list: &[(&str, &str, u32, Option<u32>)]) -> (Presentation, Vec<String>) {
let mut p = defaults::new_presentation(None);
let base = p.slides[0].as_ref().clone();
p.slides.clear();
for (kind, option, ms, adv) in list {
let mut s = base.clone();
s.id = SlideId(p.alloc_id().expect("ids"));
s.transition = Some(Transition {
kind: kind.to_string(),
option: option.to_string(),
duration_ms: *ms,
advance_on_click: adv.is_none(),
advance_after_ms: *adv,
..Default::default()
});
p.slides.push(Arc::new(s));
}
let bytes = deckcraft_pptx::export(&p).expect("export");
let mut zip = zip::ZipArchive::new(std::io::Cursor::new(bytes)).expect("zip");
let xml = (1..=list.len())
.map(|i| {
let mut x = String::new();
std::io::Read::read_to_string(&mut zip.by_name(&format!("ppt/slides/slide{i}.xml")).expect("slide"), &mut x).expect("read");
x
})
.collect();
(p, xml)
}
#[test]
fn transition_xml_matches_powerpoints_elements() {
// The elements, attributes and namespaces PowerPoint itself writes for these effect options
// (observed on files it saved), inside `mc:AlternateContent` with a `p:fade` fallback for
// the 2010+ effects.
let cases: &[(&str, &str, &[&str], &str)] = &[
("wipe", "ru", &[r#"<p:strips dir="ru"/>"#], "p14"),
("wipe", "u", &[r#"<p:wipe dir="u"/>"#], "p14"),
("zoom", "in", &[r#"<p14:warp dir="in"/>"#], "p14"),
("zoom", "rotate", &["<p:newsflash/>"], "p14"),
("shape", "out", &[r#"<p:zoom dir="out"/>"#], "p14"),
("glitter", "hexD", &[r#"<p14:glitter dir="d" pattern="hexagon"/>"#], "p14"),
("shred", "particlesOut", &[r#"<p14:shred pattern="rectangle" dir="out"/>"#], "p14"),
("wind", "l", &[r#"<p15:prstTrans prst="wind" invX="1"/>"#], "p15"),
("wind", "r", &[r#"<p15:prstTrans prst="wind"/>"#], "p15"),
("fallOver", "r", &[r#"<p15:prstTrans prst="fallOver" invX="1"/>"#], "p15"),
("pageCurlDouble", "singleR", &[r#"<p15:prstTrans prst="pageCurlSingle" invX="1"/>"#], "p15"),
("orbit", "u", &[r#"<p14:prism dir="u" isContent="1" isInverted="1"/>"#], "p14"),
("vortex", "r", &[r#"<p14:vortex dir="r"/>"#], "p14"),
("morph", "words", &[r#"<p159:morph option="byWord"/>"#], "p159"),
];
let list: Vec<(&str, &str, u32, Option<u32>)> = cases.iter().map(|c| (c.0, c.1, 2000, Some(1000))).collect();
let (p, xml) = transition_deck(&list);
for ((kind, option, wants, req), x) in cases.iter().zip(&xml) {
for w in *wants {
assert!(x.contains(w), "{kind}/{option}: {w} in {x}");
}
assert!(x.contains(&format!(r#"Requires="{req}""#)), "{kind}/{option}");
assert!(x.contains(r#"p14:dur="2000""#) && x.contains(r#"advTm="1000""#) && x.contains(r#"advClick="0""#), "{kind}/{option}");
assert!(x.contains("<mc:Fallback>"), "{kind}/{option}");
}
// Back in, everything is as it was.
let bytes = deckcraft_pptx::export(&p).expect("export");
let q = deckcraft_pptx::import(&bytes).expect("import");
for ((kind, option, ..), s) in cases.iter().zip(&q.slides) {
let t = s.transition.as_ref().expect("transition");
assert_eq!(
(t.kind.as_str(), t.option.as_str(), t.duration_ms, t.advance_after_ms, t.advance_on_click),
(*kind, *option, 2000, Some(1000), false)
);
}
}
#[test]
fn transition_defaults_read_like_powerpoint() {
// PowerPoint leaves out an option when it is the element's default; these are its defaults.
let cases: &[(&str, &str, &str)] = &[
("<p:push/>", "push", "l"),
("<p:wipe/>", "wipe", "l"),
("<p:strips/>", "wipe", "lu"),
("<p:randomBar/>", "randomBar", "horz"),
("<p:checker/>", "checker", "horz"),
("<p:blinds/>", "blinds", "horz"),
("<p:comb/>", "comb", "horz"),
("<p:zoom/>", "shape", "out"),
(r#"<p:zoom dir="in"/>"#, "shape", "in"),
("<p:split/>", "split", "horzOut"),
("<p14:doors/>", "doors", "horz"),
("<p14:window/>", "window", "horz"),
("<p14:pan/>", "pan", "l"),
("<p14:warp/>", "zoom", "out"),
("<p14:glitter/>", "glitter", "l"),
("<p14:shred/>", "shred", "stripsIn"),
("<p14:reveal/>", "reveal", "smoothlyLeft"),
("<p14:prism/>", "cube", "l"),
(r#"<p15:prstTrans prst="airplane"/>"#, "airplane", "r"),
(r#"<p15:prstTrans prst="peelOff"/>"#, "peelOff", "l"),
(r#"<p15:prstTrans prst="pageCurlSingle"/>"#, "pageCurlDouble", "singleL"),
];
let (_, xml) = transition_deck(&[("fade", "smoothly", 2000, None)]);
let Some(x) = xml.first() else { panic!("no slide") };
let start = x.find("<mc:AlternateContent").expect("transition");
let end = x.find("</mc:AlternateContent>").expect("transition end") + "</mc:AlternateContent>".len();
let p14 = r#"xmlns:p14="http://schemas.microsoft.com/office/powerpoint/2010/main""#;
let p15 = r#"xmlns:p15="http://schemas.microsoft.com/office/powerpoint/2012/main""#;
for (el, kind, option) in cases {
let tr = format!(r#"<p:transition {p14} {p15} spd="slow" p14:dur="2000">{el}</p:transition>"#);
let edited = format!("{}{}{}", &x[..start], tr, &x[end..]);
let mut p = defaults::new_presentation(None);
let base = p.slides[0].as_ref().clone();
p.slides = vec![Arc::new(base)];
let bytes = deckcraft_pptx::export(&p).expect("export");
let mut zip = zip::ZipArchive::new(std::io::Cursor::new(bytes)).expect("zip");
let mut out = zip::ZipWriter::new(std::io::Cursor::new(Vec::new()));
for i in 0..zip.len() {
let mut f = zip.by_index(i).expect("entry");
let name = f.name().to_string();
let mut data = vec![];
std::io::Read::read_to_end(&mut f, &mut data).expect("read");
if name == "ppt/slides/slide1.xml" {
data = edited.clone().into_bytes();
}
out.start_file(name, zip::write::SimpleFileOptions::default()).expect("start");
std::io::Write::write_all(&mut out, &data).expect("write");
}
let bytes = out.finish().expect("finish").into_inner();
let q = deckcraft_pptx::import(&bytes).expect("import");
let t = q.slides[0].transition.as_ref().expect("transition");
assert_eq!((t.kind.as_str(), t.option.as_str(), t.duration_ms), (*kind, *option, 2000), "{el}");
}
}
#[test]
fn linked_pictures_are_written_with_r_link() {
// A picture whose bytes live outside the package must be referenced with `r:link`; `r:embed`
// may only name a part inside the package (PowerPoint won't load the linked image otherwise).
let mut p = defaults::new_presentation(None);
let media = deckcraft_model::MediaId(5000);
p.media.push(deckcraft_model::MediaItem {
id: media,
name: "linked.png".into(),
content_type: "image/png".into(),
data: Arc::new(Vec::new()),
link: Some("file:///tmp/linked.png".into()),
});
let mut pic = shape(&mut p, "Linked", 100.0, 100.0, 200.0, 150.0);
pic.kind = ShapeKind::Picture { fill: PictureFill { media, ..Default::default() } };
Arc::make_mut(&mut p.slides[0]).shapes.push(pic);
let bytes = deckcraft_pptx::export(&p).expect("export");
let mut zip = zip::ZipArchive::new(std::io::Cursor::new(bytes)).expect("zip");
let mut xml = String::new();
std::io::Read::read_to_string(&mut zip.by_name("ppt/slides/slide1.xml").expect("slide"), &mut xml).expect("read");
assert!(xml.contains(r#"r:link="rId"#), "{xml}");
assert!(!xml.contains(r#"r:embed="rId"#), "{xml}");
let mut rels = String::new();
std::io::Read::read_to_string(&mut zip.by_name("ppt/slides/_rels/slide1.xml.rels").expect("rels"), &mut rels).expect("read");
assert!(rels.contains(r#"Target="file:///tmp/linked.png" TargetMode="External""#), "{rels}");
}
/// #210: `.potx` and `.ppsx` were written with the `.pptx` main content type.
#[test]
fn templates_and_slide_shows_declare_their_own_main_content_type() {
let p = rich_deck();
for (ext, kind) in [("pptx", "presentation"), ("potx", "template"), ("ppsx", "slideshow")] {
let bytes = deckcraft_pptx::export_as(&p, ext).expect("export");
let mut z = zip::ZipArchive::new(std::io::Cursor::new(&bytes)).expect("zip");
let ct = std::io::read_to_string(z.by_name("[Content_Types].xml").expect("content types")).expect("read");
assert!(ct.contains(&format!("presentationml.{kind}.main+xml")), "{ext}: {ct}");
assert_eq!(deckcraft_pptx::import(&bytes).expect("import").slides.len(), p.slides.len(), "{ext} reads back");
}
}
/// #214: a lone guide was always written `adj`, but these presets name it `adj1`, and PowerPoint
/// won't open the file otherwise. (Names as PowerPoint writes them.)
#[test]
fn single_guide_names_follow_the_preset() {
let mut p = defaults::new_presentation(None);
let mut s = new_slide(&mut p, "Guides");
let cases = [
("bentConnector3", "adj1"),
("curvedConnector3", "adj1"),
("frame", "adj1"),
("mathPlus", "adj1"),
("mathMinus", "adj1"),
("mathMultiply", "adj1"),
("roundRect", "adj"),
("chevron", "adj"),
];
for (prst, _) in cases {
let mut sh = shape(&mut p, prst, 0.0, 0.0, 100.0, 50.0);
sh.geom = Geom::Preset { name: prst.into(), adj: vec![20000.0] };
s.shapes.push(sh);
}
p.slides.push(Arc::new(s));
let bytes = deckcraft_pptx::export(&p).expect("export");
let mut z = zip::ZipArchive::new(std::io::Cursor::new(&bytes)).expect("zip");
let xml = std::io::read_to_string(z.by_name("ppt/slides/slide2.xml").expect("slide")).expect("read");
for (prst, gd) in cases {
assert!(xml.contains(&format!(r#"<a:prstGeom prst="{prst}"><a:avLst><a:gd name="{gd}" fmla="val 20000"/>"#)), "{prst} → {gd}: {xml}");
}
}
/// Large finite guides position a visible bend even when the connector is only one EMU wide.
#[test]
fn large_connector_adjustments_keep_their_elbows_through_two_saves() {
let cases = [
("ordinary", 80.0, 50000.0),
("near control", 1588.0 / 12700.0, -12800000.0),
("near negative", 1.0 / 12700.0, -20320000000.0),
("near positive", 1.0 / 12700.0, 20320000000.0),
("zero width", 0.0, 20320000000.0),
("ordinary negative", 80.0, -20000.0),
];
let mut p = defaults::new_presentation(None);
p.slides.clear();
let mut s = new_slide(&mut p, "Connectors");
s.shapes.clear();
for (name, width, guide) in cases {
let mut sh = shape(&mut p, name, 100.0, 80.0, width, 140.0);
sh.kind = ShapeKind::Connector { start: None, end: None };
sh.geom = Geom::Preset { name: "bentConnector3".into(), adj: vec![guide] };
s.shapes.push(sh);
}
p.slides.push(Arc::new(s));
for generation in 1..=2 {
p = deckcraft_pptx::import(&deckcraft_pptx::export(&p).expect("export")).expect("reopen");
for (name, width, guide) in cases {
let sh = p.slides[0].shapes.iter().find(|sh| sh.name == name).expect("connector");
let Geom::Preset { name: preset, adj } = &sh.geom else {
panic!("preset connector");
};
assert_eq!(adj, &[guide], "{name}, save {generation}");
let xfrm = sh.xfrm.expect("transform");
assert_eq!((xfrm.w, xfrm.h), (width, 140.0));
let expected = deckcraft_geom::preset::build("bentConnector3", width, 140.0, &[guide]).expect("expected geometry");
let actual = deckcraft_geom::preset::build(preset, xfrm.w, xfrm.h, adj).expect("reopened geometry");
assert_eq!(actual.outline(), expected.outline(), "{name}, save {generation}");
}
}
}
/// #147: PowerPoint's Float Down is preset 47 (Float Up is 42); it imported as a plain fade.
#[test]
fn float_down_is_preset_47_both_ways() {
let mut p = defaults::new_presentation(None);
let mut s = new_slide(&mut p, "Float");
let sh = shape(&mut p, "Building", 0.0, 0.0, 100.0, 100.0);
let id = sh.id;
s.shapes.push(sh);
s.animations = vec![
Animation { shape: id, class: AnimClass::Entrance, effect: "float".into(), option: "d".into(), ..Default::default() },
Animation { shape: id, class: AnimClass::Exit, effect: "floatOut".into(), option: "d".into(), ..Default::default() },
Animation { shape: id, class: AnimClass::Exit, effect: "floatOut".into(), option: "u".into(), ..Default::default() },
];
p.slides.push(Arc::new(s));
let bytes = deckcraft_pptx::export(&p).expect("export");
let mut z = zip::ZipArchive::new(std::io::Cursor::new(&bytes)).expect("zip");
let xml = std::io::read_to_string(z.by_name("ppt/slides/slide2.xml").expect("slide")).expect("read");
assert!(xml.contains(r#"presetID="47" presetClass="entr" presetSubtype="0""#), "{xml}");
assert!(xml.contains(r#"presetID="47" presetClass="exit" presetSubtype="0""#), "{xml}");
assert!(xml.contains(r#"presetID="42" presetClass="exit" presetSubtype="0""#), "{xml}");
let q = deckcraft_pptx::import(&bytes).expect("import");
let got: Vec<(&str, &str)> = q.slides[1].animations.iter().map(|a| (a.effect.as_str(), a.option.as_str())).collect();
assert_eq!(got, [("float", "d"), ("floatOut", "d"), ("floatOut", "u")]);
}
#[test]
fn embedded_fonts_round_trip() {
let mut p = Presentation::default();
let regular = p.add_media("font1.fntdata", "application/x-fontdata", b"REGULAR-FONT-BYTES-0123456789".to_vec()).expect("media");
let bold = p.add_media("font2.fntdata", "application/x-fontdata", b"BOLD-FONT-BYTES-0123456789abcd".to_vec()).expect("media");
p.embedded_fonts.push(deckcraft_model::EmbeddedFont {
typeface: "Deck Test Face".into(),
panose: Some("020B0604020202020204".into()),
pitch_family: Some(34),
charset: Some(0),
regular: Some(regular),
bold: Some(bold),
italic: Some(regular),
bold_italic: None,
});
// The same typeface again is one entry: PowerPoint requires each typeface once.
p.embedded_fonts.push(deckcraft_model::EmbeddedFont { typeface: "Deck Test Face".into(), regular: Some(bold), ..Default::default() });
let bytes = deckcraft_pptx::export(&p).expect("export");
let mut zip = zip::ZipArchive::new(std::io::Cursor::new(bytes.clone())).expect("zip");
let mut xml = String::new();
std::io::Read::read_to_string(&mut zip.by_name("ppt/presentation.xml").expect("pres"), &mut xml).expect("read");
assert!(xml.contains("embedTrueTypeFonts=\"1\""));
let notes = xml.find("<p:notesSz").expect("notesSz");
let list = xml.find("<p:embeddedFontLst>").expect("list");
let dts = xml.find("<p:defaultTextStyle").expect("style");
assert!(notes < list && list < dts);
assert!(xml.contains(r#"<p:font typeface="Deck Test Face" panose="020B0604020202020204" pitchFamily="34" charset="0"/>"#));
assert_eq!(xml.matches("<p:embeddedFont>").count(), 1);
let mut rels = String::new();
std::io::Read::read_to_string(&mut zip.by_name("ppt/_rels/presentation.xml.rels").expect("rels"), &mut rels).expect("read");
assert_eq!(rels.matches("relationships/font").count(), 2, "regular and italic share one part");
let q = deckcraft_pptx::import(&bytes).expect("import");
assert_eq!(q.embedded_fonts.len(), 1);
let f = &q.embedded_fonts[0];
assert_eq!(f.typeface, "Deck Test Face");
assert_eq!(f.panose.as_deref(), Some("020B0604020202020204"));
assert_eq!(f.pitch_family, Some(34));
assert_eq!(f.charset, Some(0));
assert_eq!(q.media(f.regular.expect("regular")).expect("media").data.as_slice(), b"REGULAR-FONT-BYTES-0123456789");
assert_eq!(q.media(f.bold.expect("bold")).expect("media").data.as_slice(), b"BOLD-FONT-BYTES-0123456789abcd");
assert_eq!(f.italic, f.regular);
assert!(f.bold_italic.is_none());
}
/// A package whose font list this writer did not produce: bold only, relationship id not `rIdN`.
#[test]
fn an_embedded_font_list_already_in_the_package_is_read() {
let bytes = deckcraft_pptx::export(&Presentation::default()).expect("export");
let font = b"FACE-BYTES-FROM-THE-PACKAGE";
let mut zip = zip::ZipArchive::new(std::io::Cursor::new(bytes)).expect("zip");
let mut out = zip::ZipWriter::new(std::io::Cursor::new(Vec::new()));
for i in 0..zip.len() {
let mut f = zip.by_index(i).expect("entry");
let name = f.name().to_string();
let mut data = vec![];
std::io::Read::read_to_end(&mut f, &mut data).expect("read");
if name == "ppt/presentation.xml" {
let xml = String::from_utf8(data).expect("utf8");
let xml = xml.replacen(
"<p:defaultTextStyle",
concat!(
r#"<p:embeddedFontLst><p:embeddedFont><p:font typeface="Package Face" pitchFamily="2"/>"#,
r#"<p:bold r:id="rIdFont"/></p:embeddedFont></p:embeddedFontLst><p:defaultTextStyle"#
),
1,
);
data = xml.into_bytes();
} else if name == "ppt/_rels/presentation.xml.rels" {
let xml = String::from_utf8(data).expect("utf8");
let xml = xml.replacen(
"</Relationships>",
r#"<Relationship Id="rIdFont" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/font" Target="fonts/font1.fntdata"/></Relationships>"#,
1,
);
data = xml.into_bytes();
} else if name == "[Content_Types].xml" {
let xml = String::from_utf8(data).expect("utf8");
let xml = xml.replacen("</Types>", r#"<Default Extension="fntdata" ContentType="application/x-fontdata"/></Types>"#, 1);
data = xml.into_bytes();
}
out.start_file(name, zip::write::SimpleFileOptions::default()).expect("start");
std::io::Write::write_all(&mut out, &data).expect("write");
}
out.start_file("ppt/fonts/font1.fntdata", zip::write::SimpleFileOptions::default()).expect("font");
std::io::Write::write_all(&mut out, font).expect("font bytes");
let patched = out.finish().expect("finish").into_inner();
let p = deckcraft_pptx::import(&patched).expect("import");
let f = p.embedded_fonts.first().expect("font");
assert_eq!(f.typeface, "Package Face");
assert_eq!(f.pitch_family, Some(2));
assert!(f.panose.is_none() && f.regular.is_none() && f.italic.is_none() && f.bold_italic.is_none());
assert_eq!(p.media(f.bold.expect("bold")).expect("media").data.as_slice(), font);
}
/// Text transparency (#32) is `a:alpha` on the run's colour, and survives a save.
#[test]
fn text_transparency_round_trips() {
use deckcraft_engine::Session;
let mut s = Session::with_new();
s.execute("shape.insert", &serde_json::json!({"preset": "rect", "rect": [100, 100, 200, 100], "text": "Hi"})).unwrap();
s.execute("format.color", &serde_json::json!({"color": "#336699"})).unwrap();
s.execute("format.textTransparency", &serde_json::json!({"value": 0.4})).unwrap();
let doc = s.doc().unwrap().doc.clone();
let bytes = deckcraft_pptx::export(&doc).unwrap();
let back = deckcraft_pptx::import(&bytes).unwrap();
let sh = back.slides[0].shapes.iter().find(|sh| sh.text.as_ref().is_some_and(|t| t.text().contains("Hi"))).unwrap();
let Some(deckcraft_model::Fill::Solid { color }) = &sh.text.as_ref().unwrap().paragraphs[0].runs[0].props.fill else { panic!() };
assert!((color.alpha() - 0.6).abs() < 1e-9, "{color:?}");
}
/// A tiny 8 kHz mono 16-bit WAV of `n` silent samples.
fn wav(n: u32) -> Vec<u8> {
let mut v = Vec::new();
v.extend_from_slice(b"RIFF");
v.extend_from_slice(&(36 + n * 2).to_le_bytes());
v.extend_from_slice(b"WAVEfmt ");
v.extend_from_slice(&16u32.to_le_bytes());
v.extend_from_slice(&1u16.to_le_bytes());
v.extend_from_slice(&1u16.to_le_bytes());
v.extend_from_slice(&8000u32.to_le_bytes());
v.extend_from_slice(&16000u32.to_le_bytes());
v.extend_from_slice(&2u16.to_le_bytes());
v.extend_from_slice(&16u16.to_le_bytes());
v.extend_from_slice(b"data");
v.extend_from_slice(&(n * 2).to_le_bytes());
v.resize(v.len() + n as usize * 2, 0);
v
}
/// Transitions › Sound: a chosen sound is embedded, saved as `p:sndAc`, read back, and No Sound
/// removes it; a file that isn't audio is refused.
#[test]
fn transition_sound_is_set_saved_and_removed() {
use deckcraft_engine::Session;
use serde_json::json;
let b64 = deckcraft_engine::cmd::base64_encode(&wav(800));
let mut s = Session::with_new();
s.execute("transition.set", &json!({"kind": "fade"})).unwrap();
let r = s.execute("transition.sound", &json!({"data": b64, "name": "chime.wav"})).unwrap();
assert_eq!(r["playable"], true, "{r}");
let doc = s.doc().unwrap().doc.clone();
let m = doc.slides[0].transition.as_ref().and_then(|t| t.sound).expect("sound set");
assert_eq!(doc.media(m).map(|i| i.name.as_str()), Some("chime.wav"));
let bytes = deckcraft_pptx::export(&doc).unwrap();
let back = deckcraft_pptx::import(&bytes).unwrap();
let t = back.slides[0].transition.as_ref().expect("transition");
assert_eq!(t.kind, "fade");
let m = t.sound.expect("sound survives the save");
assert_eq!(back.media(m).map(|i| i.data.len()), Some(wav(800).len()));
s.execute("transition.sound", &json!({"none": true})).unwrap();
assert!(s.doc().unwrap().doc.slides[0].transition.as_ref().is_some_and(|t| t.sound.is_none()));
let not_audio = deckcraft_engine::cmd::base64_encode(b"hello, not a sound");
assert!(s.execute("transition.sound", &json!({"data": not_audio, "name": "notes.txt"})).is_err());
}
/// Built-in transition sounds, Loop Until Next Sound and [Stop Previous Sound] are set, saved as
/// PowerPoint writes them (`p:stSnd loop="1"`, `p:endSnd`) and read back.
#[test]
fn transition_sound_options_round_trip() {
use deckcraft_engine::Session;
use serde_json::json;
let mut s = Session::with_new();
s.execute("slide.new", &json!({})).unwrap();
s.execute("slide.new", &json!({})).unwrap();
s.execute("transition.sound", &json!({"builtin": "chime", "loop": true, "index": 0})).unwrap();
s.execute("transition.sound", &json!({"builtin": "Chime", "index": 1})).unwrap();
s.execute("transition.sound", &json!({"stopPrevious": true, "index": 2})).unwrap();
let doc = s.doc().unwrap().doc.clone();
assert_eq!(doc.media.len(), 1, "the same built-in sound is embedded once");
assert_eq!(doc.media[0].name, "Chime.wav");
let bytes = deckcraft_pptx::export(&doc).unwrap();
let slide1 = {
let mut z = zip::ZipArchive::new(std::io::Cursor::new(&bytes)).unwrap();
let mut x = String::new();
std::io::Read::read_to_string(&mut z.by_name("ppt/slides/slide1.xml").unwrap(), &mut x).unwrap();
x
};
assert!(slide1.contains(r#"<p:stSnd loop="1">"#) && slide1.contains(r#"name="Chime.wav""#), "{slide1}");
let back = deckcraft_pptx::import(&bytes).unwrap();
let t: Vec<_> = back.slides.iter().map(|s| s.transition.clone().unwrap_or_default()).collect();
assert!(t[0].sound.is_some() && t[0].sound_loop && !t[0].stop_sound);
assert!(t[1].sound.is_some() && !t[1].sound_loop);
assert!(t[2].sound.is_none() && t[2].stop_sound, "{:?}", t[2]);
// Turning the loop off alone keeps the sound.
s.execute("transition.sound", &json!({"loop": false, "index": 0})).unwrap();
let t0 = s.doc().unwrap().doc.slides[0].transition.clone().unwrap();
assert!(t0.sound.is_some() && !t0.sound_loop);
assert!(s.execute("transition.sound", &json!({"builtin": "foghorn"})).is_err());
}
/// Replace `from` with `to` in every slide part of an exported deck.
fn patch_slides(bytes: Vec<u8>, from: &str, to: &str) -> Vec<u8> {
use std::io::{Read, Write};
let mut z = zip::ZipArchive::new(std::io::Cursor::new(bytes)).expect("zip");
let mut out = zip::ZipWriter::new(std::io::Cursor::new(Vec::new()));
for i in 0..z.len() {
let mut f = z.by_index(i).expect("entry");
let name = f.name().to_string();
let mut data = vec![];
f.read_to_end(&mut data).expect("read");
if name.starts_with("ppt/slides/slide") && name.ends_with(".xml") {
data = String::from_utf8(data).expect("utf8").replace(from, to).into_bytes();
}
out.start_file(name, zip::write::SimpleFileOptions::default()).expect("start");
out.write_all(&data).expect("write");
}
out.finish().expect("finish").into_inner()
}
fn runs_of(p: &Presentation, needle: &str) -> Vec<(RunKind, String)> {
for s in &p.slides {
for sh in &s.shapes {
let Some(t) = &sh.text else { continue };
for para in &t.paragraphs {
if para.runs.iter().any(|r| r.text.contains(needle)) {
return para.runs.iter().map(|r| (r.kind.clone(), r.text.clone())).collect();
}
}
}
}
panic!("no paragraph with {needle}");
}
#[test]
fn literal_line_ends_in_run_text_read_as_breaks_and_survive_save() {
let mut p = defaults::new_presentation(None);
let mut s = shape(&mut p, "Code", 10.0, 10.0, 400.0, 100.0);
s.text = Some(TextBody::from_text("CRLFHERE"));
let first = p.slides[0].id;
p.slide_mut(first).expect("slide").shapes.push(s);
let bytes = patch_slides(deckcraft_pptx::export(&p).expect("export"), "CRLFHERE", "one\r\n two\rthree");
let a = deckcraft_pptx::import(&bytes).expect("import");
let want = vec![
(RunKind::Text, "one".to_string()),
(RunKind::Break, String::new()),
(RunKind::Text, " two".to_string()),
(RunKind::Break, String::new()),
(RunKind::Text, "three".to_string()),
];
assert_eq!(runs_of(&a, "one"), want);
assert_eq!(runs_of(&round(&a), "one"), want, "save and reopen keep the runs");
}
#[test]
fn alternate_run_language_survives_pptx_saves_and_absence() {
let mut p = defaults::new_presentation(None);
let first = p.slides[0].id;
let slide = p.slide_mut(first).expect("slide");
slide.shapes[0].text = Some(TextBody {
paragraphs: vec![Paragraph {
runs: vec![
Run::with("bonjour", RunProps { lang: Some("en-US".into()), alt_lang: Some("fr-FR".into()), ..Default::default() }),
Run::with(" plain", RunProps { lang: Some("en-US".into()), ..Default::default() }),
],
..Default::default()
}],
..Default::default()
});
let mut q = round(&p);
for _ in 0..2 {
let runs = &q.slides[0].shapes[0].text.as_ref().expect("text").paragraphs[0].runs;
assert_eq!(runs[0].props.lang.as_deref(), Some("en-US"));
assert_eq!(runs[0].props.alt_lang.as_deref(), Some("fr-FR"));
assert_eq!(runs[1].props.lang.as_deref(), Some("en-US"));
assert_eq!(runs[1].props.alt_lang, None);
q = round(&q);
}
}
#[test]
fn color_pulse_keeps_its_effect_colour_and_duration() {
let mut p = defaults::new_presentation(None);
let s = shape(&mut p, "Pulsed", 10.0, 10.0, 200.0, 100.0);
let id = s.id;
let first = p.slides[0].id;
let sl = p.slide_mut(first).expect("slide");
sl.shapes.push(s);
let white = ColorRef::rgb(Rgba::rgb(255, 255, 255));
sl.animations.push(Animation {
shape: id,
class: AnimClass::Emphasis,
effect: "colorPulse".into(),
duration_ms: 1000,
color: Some(white.clone()),
..Default::default()
});
let q = round(&p);
let a = &q.slides[0].animations[0];
assert_eq!((a.class, a.effect.as_str()), (AnimClass::Emphasis, "colorPulse"));
assert_eq!(a.color, Some(white));
assert_eq!(a.amount, None, "no grow/shrink scale is invented");
assert_eq!(a.duration_ms, 1000);
}
#[test]
fn notes_master_placeholders_and_colour_map_survive_save() {
let mut p = defaults::new_presentation(None);
let mut box1 = shape(&mut p, "Confidential", 100000.0, 200000.0, 3000000.0, 400000.0);
box1.text = Some(TextBody::from_text("Company confidential"));
let map: Vec<(String, String)> = [("bg1", "dk1"), ("tx1", "lt1"), ("bg2", "dk2"), ("tx2", "lt2")]
.iter()
.chain(
[
("accent1", "accent1"),
("accent2", "accent2"),
("accent3", "accent3"),
("accent4", "accent4"),
("accent5", "accent5"),
("accent6", "accent6"),
("hlink", "hlink"),
("folHlink", "folHlink"),
]
.iter(),
)
.map(|(a, b)| (a.to_string(), b.to_string()))
.collect();
let m = deckcraft_model::Master { name: "Notes Master".into(), shapes: vec![box1], color_map: map.clone(), ..Default::default() };
p.notes_master = Some(Arc::new(m));
// No slide has notes: the notes master must still be written.
let q = round(&p);
let nm = q.notes_master.as_deref().expect("notes master kept");
assert_eq!(nm.shapes.len(), 1, "own shapes, not the defaults");
let sh = &nm.shapes[0];
assert_eq!(sh.name, "Confidential");
assert_eq!(sh.text.as_ref().map(|t| t.text()), Some("Company confidential".to_string()));
assert_eq!(nm.color_map, map);
}
/// A part's bytes, if the package has it.
fn pkg_part(pkg: &[u8], name: &str) -> Option<Vec<u8>> {
use std::io::Read;
let mut z = zip::ZipArchive::new(std::io::Cursor::new(pkg)).unwrap();
let mut f = z.by_name(name).ok()?;
let mut v = vec![];
f.read_to_end(&mut v).unwrap();
Some(v)
}
/// Rewrite a package's parts with `edit`, then add `extra` parts.
fn repack(pkg: &[u8], edit: impl Fn(&str, String) -> String, extra: &[(&str, &[u8])]) -> Vec<u8> {
use std::io::{Read, Write};
let mut z = zip::ZipArchive::new(std::io::Cursor::new(pkg)).unwrap();
let mut out = zip::ZipWriter::new(std::io::Cursor::new(Vec::new()));
let opts = zip::write::SimpleFileOptions::default();
for i in 0..z.len() {
let mut f = z.by_index(i).unwrap();
let name = f.name().to_string();
let mut data = vec![];
f.read_to_end(&mut data).unwrap();
if name.ends_with(".xml") || name.ends_with(".rels") {
data = edit(&name, String::from_utf8(data).unwrap()).into_bytes();
}
out.start_file(name, opts).unwrap();
out.write_all(&data).unwrap();
}
for (name, data) in extra {
out.start_file(*name, opts).unwrap();
out.write_all(data).unwrap();
}
out.finish().unwrap().into_inner()
}
const WATERFALL_CX: &str = r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<cx:chartSpace xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" xmlns:cx="http://schemas.microsoft.com/office/drawing/2014/chartex"><cx:chartData><cx:externalData r:id="rId1" cx:autoUpdate="0"/><cx:data id="0"><cx:strDim type="cat"><cx:f>Sheet1!$A$2:$A$5</cx:f><cx:lvl ptCount="4"><cx:pt idx="0">Start</cx:pt><cx:pt idx="1">Sales</cx:pt><cx:pt idx="2">Costs</cx:pt><cx:pt idx="3">End</cx:pt></cx:lvl></cx:strDim><cx:numDim type="val"><cx:f>Sheet1!$B$2:$B$5</cx:f><cx:lvl ptCount="4" formatCode="General"><cx:pt idx="0">100</cx:pt><cx:pt idx="1">40</cx:pt><cx:pt idx="2">-25</cx:pt><cx:pt idx="3">115</cx:pt></cx:lvl></cx:numDim></cx:data></cx:chartData><cx:chart><cx:title pos="t" align="ctr" overlay="0"><cx:tx><cx:txData><cx:v>Cash flow</cx:v></cx:txData></cx:tx></cx:title><cx:plotArea><cx:plotAreaRegion><cx:series layoutId="waterfall" uniqueId="{1}"><cx:tx><cx:txData><cx:f>Sheet1!$B$1</cx:f><cx:v>Amount</cx:v></cx:txData></cx:tx><cx:dataLabels pos="outEnd"><cx:visibility seriesName="0" categoryName="0" value="1"/></cx:dataLabels><cx:dataId val="0"/><cx:layoutPr><cx:subtotals><cx:idx val="0"/><cx:idx val="3"/></cx:subtotals></cx:layoutPr></cx:series></cx:plotAreaRegion><cx:axis id="0"><cx:catScaling gapWidth="0.5"/><cx:tickLabels/></cx:axis><cx:axis id="1"><cx:valScaling/><cx:majorGridlines/><cx:tickLabels/></cx:axis></cx:plotArea><cx:legend pos="b" align="ctr" overlay="0"/></cx:chart></cx:chartSpace>"#;
/// A waterfall frame as PowerPoint writes it: the chart in a `cx1` choice, a text box fallback.
const WATERFALL_FRAME: &str = r#"<mc:AlternateContent xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"><mc:Choice xmlns:cx1="http://schemas.microsoft.com/office/drawing/2015/9/8/chartex" Requires="cx1"><p:graphicFrame><p:nvGraphicFramePr><p:cNvPr id="90" name="Waterfall 1"/><p:cNvGraphicFramePr/><p:nvPr/></p:nvGraphicFramePr><p:xfrm><a:off x="914400" y="914400"/><a:ext cx="6096000" cy="4064000"/></p:xfrm><a:graphic><a:graphicData uri="http://schemas.microsoft.com/office/drawing/2014/chartex"><cx:chart xmlns:cx="http://schemas.microsoft.com/office/drawing/2014/chartex" r:id="rIdCx"/></a:graphicData></a:graphic></p:graphicFrame></mc:Choice><mc:Fallback><p:sp><p:nvSpPr><p:cNvPr id="90" name="Waterfall 1"/><p:cNvSpPr><a:spLocks noTextEdit="1"/></p:cNvSpPr><p:nvPr/></p:nvSpPr><p:spPr><a:xfrm><a:off x="914400" y="914400"/><a:ext cx="6096000" cy="4064000"/></a:xfrm><a:prstGeom prst="rect"><a:avLst/></a:prstGeom></p:spPr><p:txBody><a:bodyPr/><a:p><a:r><a:t>This chart isn't available in your version of PowerPoint.</a:t></a:r></a:p></p:txBody></p:sp></mc:Fallback></mc:AlternateContent>"#;
/// Office 2016 charts (`chartEx`): a waterfall reads as a waterfall chart with its data, not as
/// the "isn't available" fallback text, and an unchanged one is written back as itself with a
/// plain chart fallback; an edited one is written as a plain chart.
#[test]
fn chartex_waterfall_reads_and_round_trips() {
use deckcraft_engine::Session;
let mut s = Session::with_new();
s.execute("slide.new", &serde_json::json!({"layout": "blank"})).unwrap();
let base = deckcraft_pptx::export(&s.doc().unwrap().doc).unwrap();
let slide = (1..=9).map(|i| format!("ppt/slides/slide{i}.xml")).find(|n| pkg_part(&base, n).is_some()).unwrap();
let slide_rels = slide.replace("slides/", "slides/_rels/") + ".rels";
let cx_rels = r#"<?xml version="1.0" encoding="UTF-8"?><Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/package" Target="../embeddings/Microsoft_Excel_Worksheet.xlsx"/></Relationships>"#;
let pptx = repack(
&base,
|name, x| {
if name == slide {
x.replacen("</p:spTree>", &format!("{WATERFALL_FRAME}</p:spTree>"), 1)
} else if name == slide_rels {
x.replace("</Relationships>", r#"<Relationship Id="rIdCx" Type="http://schemas.microsoft.com/office/2014/relationships/chartEx" Target="../charts/chartEx1.xml"/></Relationships>"#)
} else if name == "[Content_Types].xml" {
x.replace(
"</Types>",
r#"<Override PartName="/ppt/charts/chartEx1.xml" ContentType="application/vnd.ms-office.chartex+xml"/></Types>"#,
)
} else {
x
}
},
&[("ppt/charts/chartEx1.xml", WATERFALL_CX.as_bytes()), ("ppt/charts/_rels/chartEx1.xml.rels", cx_rels.as_bytes())],
);
let doc = deckcraft_pptx::import(&pptx).unwrap();
let chart = |d: &Presentation| -> Option<Chart> {
d.slides.iter().flat_map(|s| s.shapes.iter()).find_map(|sh| match &sh.kind {
ShapeKind::Chart(c) => Some((**c).clone()),
_ => None,
})
};
let c = chart(&doc).expect("the waterfall is a chart, not the fallback text");
assert_eq!(c.kind, ChartType::Waterfall);
assert_eq!(c.title.as_deref(), Some("Cash flow"));
assert_eq!(c.categories, ["Start", "Sales", "Costs", "End"]);
assert_eq!(c.series.len(), 1);
assert_eq!(c.series[0].name, "Amount");
assert_eq!(c.series[0].values, [Some(100.0), Some(40.0), Some(-25.0), Some(115.0)]);
assert!(c.data_labels);
assert_eq!(c.legend.as_deref(), Some("b"));
let no_fallback_text = doc.slides.iter().flat_map(|s| s.shapes.iter()).all(|sh| !format!("{:?}", sh.kind).contains("isn't available"));
assert!(no_fallback_text);
// Unchanged: chartEx back in a cx1 choice, a plain chart as fallback, no workbook link.
let out = deckcraft_pptx::export(&doc).unwrap();
let ex = String::from_utf8(pkg_part(&out, "ppt/charts/chartEx1.xml").expect("chartEx part")).unwrap();
assert!(ex.contains(r#"layoutId="waterfall""#) && !ex.contains("externalData"), "{ex}");
let types = String::from_utf8(pkg_part(&out, "[Content_Types].xml").unwrap()).unwrap();
assert!(types.contains("application/vnd.ms-office.chartex+xml"));
let sx = String::from_utf8(pkg_part(&out, &slide).unwrap()).unwrap();
assert!(sx.contains(r#"Requires="cx1""#) && sx.contains("mc:Fallback") && sx.contains("c:chart "), "{sx}");
let srels = String::from_utf8(pkg_part(&out, &slide_rels).unwrap()).unwrap();
assert!(srels.contains("relationships/chartEx") && srels.contains("relationships/chart\""), "{srels}");
assert!(pkg_part(&out, "ppt/charts/chart1.xml").is_some());
let again = deckcraft_pptx::import(&out).unwrap();
assert_eq!(chart(&again).map(|c| (c.kind, c.categories, c.series.len())), Some((ChartType::Waterfall, c.categories.clone(), 1)));
// Edited: the kept part no longer matches, so a chartEx part is written from the model,
// still a waterfall with the new value.
let mut edited = doc.clone();
for sl in &mut edited.slides {
for sh in &mut Arc::make_mut(sl).shapes {
if let ShapeKind::Chart(ch) = &mut sh.kind {
ch.series[0].values[1] = Some(55.0);
}
}
}
let out = deckcraft_pptx::export(&edited).unwrap();
let ex = String::from_utf8(pkg_part(&out, "ppt/charts/chartEx1.xml").expect("a written chartEx part")).unwrap();
assert!(ex.contains(r#"layoutId="waterfall""#), "{ex}");
assert!(String::from_utf8(pkg_part(&out, &slide).unwrap()).unwrap().contains("cx1"));
let again = chart(&deckcraft_pptx::import(&out).unwrap()).unwrap();
assert_eq!(again.kind, ChartType::Waterfall);
assert_eq!(again.series[0].values[1], Some(55.0));
assert_eq!(again.subtotals, c.subtotals);
}
/// New Office 2016 charts made in DeckCraft are written as chartEx parts that read back as the
/// same type, data and options.
#[test]
fn chartex_new_charts_save_as_their_own_type() {
use deckcraft_engine::Session;
for (ty, kind) in [
("waterfall", ChartType::Waterfall),
("funnel", ChartType::Funnel),
("treemap", ChartType::Treemap),
("sunburst", ChartType::Sunburst),
("histogram", ChartType::Histogram),
("pareto", ChartType::Pareto),
("boxwhisker", ChartType::BoxWhisker),
] {
let chart = |d: &Presentation| -> Option<Chart> {
d.slides.iter().flat_map(|s| s.shapes.iter()).find_map(|sh| match &sh.kind {
ShapeKind::Chart(c) => Some((**c).clone()),
_ => None,
})
};
let mut s = Session::with_new();
s.execute("slide.new", &serde_json::json!({"layout": "blank"})).unwrap();
s.execute("insert.chart", &serde_json::json!({"type": ty})).unwrap();
let id = s.doc().unwrap().selection.shapes[0].0;
let opts = match kind {
ChartType::Histogram | ChartType::Pareto => serde_json::json!({"id": id, "binCount": 4, "title": "T"}),
ChartType::Waterfall => serde_json::json!({"id": id, "subtotals": [3], "title": "T"}),
_ => serde_json::json!({"id": id, "title": "T"}),
};
s.execute("chart.options", &opts).unwrap();
let doc = &s.doc().unwrap().doc;
let before = chart(doc).unwrap();
let out = deckcraft_pptx::export(doc).unwrap();
assert!(pkg_part(&out, "ppt/charts/chartEx1.xml").is_some(), "{ty}: no chartEx part");
assert!(pkg_part(&out, "ppt/charts/chart1.xml").is_some(), "{ty}: no fallback chart");
let after = chart(&deckcraft_pptx::import(&out).unwrap()).unwrap();
assert_eq!(after.kind, kind, "{ty}");
assert_eq!(after.title.as_deref(), Some("T"), "{ty}");
assert_eq!(after.categories, before.categories, "{ty}");
let n = if matches!(kind, ChartType::BoxWhisker) { before.series.len() } else { 1 };
assert_eq!(after.series.len(), n, "{ty}");
assert_eq!(after.series[0].values, before.series[0].values, "{ty}");
assert_eq!((after.bin_count, after.subtotals.clone()), (before.bin_count, before.subtotals.clone()), "{ty}");
}
}
/// A two-level treemap keeps its parent level, and a box chart its inclusive quartiles, through
/// a save and reopen.
#[test]
fn chartex_levels_and_quartiles_round_trip() {
use deckcraft_engine::Session;
let chart = |d: &Presentation| -> Option<Chart> {
d.slides.iter().flat_map(|s| s.shapes.iter()).find_map(|sh| match &sh.kind {
ShapeKind::Chart(c) => Some((**c).clone()),
_ => None,
})
};
for ty in ["treemap", "sunburst", "boxwhisker"] {
let mut s = Session::with_new();
s.execute("slide.new", &serde_json::json!({"layout": "blank"})).unwrap();
s.execute("insert.chart", &serde_json::json!({"type": ty})).unwrap();
let id = s.doc().unwrap().selection.shapes[0].0;
if ty == "boxwhisker" {
s.execute("chart.options", &serde_json::json!({"id": id, "quartiles": "inclusive"})).unwrap();
} else {
s.execute(
"chart.data",
&serde_json::json!({"id": id, "levels": [["Q1", "", "", "Q2", "", "", "Q3", ""], ["H1", "", "", "", "", "", "H2", ""]]}),
)
.unwrap();
}
let before = chart(&s.doc().unwrap().doc).unwrap();
let out = deckcraft_pptx::export(&s.doc().unwrap().doc).unwrap();
let after = chart(&deckcraft_pptx::import(&out).unwrap()).unwrap();
assert_eq!(after.category_levels, before.category_levels, "{ty}");
assert_eq!(after.inclusive_quartiles, before.inclusive_quartiles, "{ty}");
assert_eq!(after.category_tree(), before.category_tree(), "{ty}");
// Unchanged since import, the part is written back as read.
let again = deckcraft_pptx::export(&deckcraft_pptx::import(&out).unwrap()).unwrap();
assert_eq!(chart(&deckcraft_pptx::import(&again).unwrap()).unwrap().category_levels, before.category_levels, "{ty}");
}
}
/// Radar, stock (with and without up/down bars) and combo charts keep their own plot groups
/// through a save and reopen, written as PowerPoint writes them.
#[test]
fn radar_stock_and_combo_round_trip() {
use deckcraft_engine::Session;
let chart = |d: &Presentation| -> Option<Chart> {
d.slides.iter().flat_map(|s| s.shapes.iter()).find_map(|sh| match &sh.kind {
ShapeKind::Chart(c) => Some((**c).clone()),
_ => None,
})
};
for (ty, bars) in [("radar", false), ("filledradar", false), ("stock", false), ("stock", true), ("combo", false)] {
let mut s = Session::with_new();
s.execute("slide.new", &serde_json::json!({"layout": "blank"})).unwrap();
s.execute("insert.chart", &serde_json::json!({"type": ty})).unwrap();
let id = s.doc().unwrap().selection.shapes[0].0;
if bars {
s.execute("chart.options", &serde_json::json!({"id": id, "upDownBars": true})).unwrap();
}
let before = chart(&s.doc().unwrap().doc).unwrap();
let out = deckcraft_pptx::export(&s.doc().unwrap().doc).unwrap();
let after = chart(&deckcraft_pptx::import(&out).unwrap()).unwrap();
assert_eq!(after.kind, before.kind, "{ty}");
assert_eq!(after.up_down_bars, bars, "{ty}");
assert_eq!(after.series.len(), before.series.len(), "{ty}");
let kinds: Vec<_> = after.series.iter().map(|x| after.series_kind(x)).collect();
let want: Vec<_> = before.series.iter().map(|x| before.series_kind(x)).collect();
assert_eq!(kinds, want, "{ty}");
for (a, b) in after.series.iter().zip(&before.series) {
assert_eq!(a.values, b.values, "{ty}");
}
}
}
/// Home › New Slide › Reuse Slides: slides from another .pptx land after the current slide with
/// their pictures (fresh media ids, same bytes) and animations on the renumbered shapes. By
/// default they take a destination layout; Keep Source Formatting brings the source master.
#[test]
fn reuse_slides_from_another_presentation() {
use deckcraft_engine::Session;
use serde_json::json;
let b64 = deckcraft_engine::cmd::base64_encode;
// Source: three slides, a picture with an animation on the second.
let mut src = Session::with_new();
src.execute("slide.new", &json!({})).unwrap();
let pic = png(8, 8, [10, 200, 30]);
src.execute("insert.picture", &json!({"data": b64(&pic), "name": "green.png"})).unwrap();
src.execute("animation.add", &json!({"effect": "fade"})).unwrap();
src.execute("slide.new", &json!({})).unwrap();
let src_bytes = deckcraft_pptx::export(&src.doc().unwrap().doc).unwrap();
let mut s = Session::with_new();
// Media ids in the two decks overlap; the destination's own picture must stay its own.
let red = png(4, 4, [200, 0, 0]);
s.execute("insert.picture", &json!({"data": b64(&red), "name": "red.png"})).unwrap();
let r = s.execute("slide.reuse", &json!({"data": b64(&src_bytes), "name": "src.pptx", "slides": [1]})).unwrap();
assert_eq!(r["slides"], 1, "{r}");
let doc = s.doc().unwrap().doc.clone();
assert_eq!(doc.slides.len(), 2);
assert_eq!(s.doc().unwrap().selection.slide, 1, "the reused slide is selected");
let pictures = |sl: &deckcraft_model::Slide| {
let mut v = vec![];
deckcraft_model::walk(&sl.shapes, &mut |sh, _| {
if let deckcraft_model::ShapeKind::Picture { fill } = &sh.kind {
v.push(fill.media);
}
});
v
};
let mine = pictures(&doc.slides[0]);
let reused = pictures(&doc.slides[1]);
assert_eq!(doc.media(mine[0]).map(|m| m.data.as_slice() == red.as_slice()), Some(true), "own picture untouched");
assert_eq!(doc.media(reused[0]).map(|m| m.data.as_slice() == pic.as_slice()), Some(true), "reused picture copied");
let anim = &doc.slides[1].animations[0];
assert!(doc.slides[1].shapes.iter().any(|sh| sh.id == anim.shape), "animation follows its shape");
assert!(doc.layout(doc.slides[1].layout).is_some(), "uses a destination layout");
assert_eq!(doc.masters.len(), 1);
// The result saves and reopens.
let back = deckcraft_pptx::import(&deckcraft_pptx::export(&doc).unwrap()).unwrap();
assert_eq!(back.slides.len(), 2);
// Keep Source Formatting: every slide, and the source master comes along.
let r = s.execute("slide.reuse", &json!({"data": b64(&src_bytes), "name": "src.pptx", "keepFormatting": true, "at": 0})).unwrap();
assert_eq!(r["slides"], 3);
let doc = s.doc().unwrap().doc.clone();
assert_eq!(doc.slides.len(), 5);
assert_eq!(doc.masters.len(), 2);
for sl in &doc.slides[..3] {
assert_eq!(doc.layout(sl.layout).map(|(m, _)| m.id), Some(doc.masters[1].id), "source master");
}
// One undo removes the whole reuse.
s.execute("edit.undo", &json!({})).unwrap();
assert_eq!(s.doc().unwrap().doc.slides.len(), 2);
assert!(s.execute("slide.reuse", &json!({"data": b64(&src_bytes), "name": "src.pptx", "slides": [7]})).is_err());
assert!(s.execute("slide.reuse", &json!({"data": b64(&[0u8, 159, 146, 150]), "name": "x.bin"})).is_err());
}
/// Picture Format › Compress Pictures: a big picture shown small is downsampled, its original
/// goes when nothing else uses it, the saved file shrinks, a copy that wasn't compressed keeps
/// the original, and undo brings everything back.
#[test]
fn compress_pictures_shrinks_the_file_and_keeps_shared_originals() {
use deckcraft_engine::Session;
use serde_json::json;
let b64 = deckcraft_engine::cmd::base64_encode;
// A noisy 1600 × 1600 picture (doesn't compress away on its own).
let big = {
let img = image::RgbImage::from_fn(1600, 1600, |x, y| image::Rgb([(x * 31 % 251) as u8, (y * 17 % 253) as u8, ((x * y) % 255) as u8]));
let mut out = std::io::Cursor::new(Vec::new());
image::DynamicImage::ImageRgb8(img).write_to(&mut out, image::ImageFormat::Png).unwrap();
out.into_inner()
};
let mut s = Session::with_new();
s.execute("insert.picture", &json!({"data": b64(&big), "name": "noise.png"})).unwrap();
s.execute("shape.resize", &json!({"w": 144, "h": 144})).unwrap();
let size_before = deckcraft_pptx::export(&s.doc().unwrap().doc).unwrap().len();
let r = s.execute("picture.compress", &json!({"ppi": 150})).unwrap();
assert_eq!(r["pictures"], 1, "{r}");
let doc = s.doc().unwrap().doc.clone();
assert_eq!(doc.media.len(), 1, "the original is gone");
let img = image::load_from_memory(&doc.media[0].data).unwrap();
assert_eq!((img.width(), img.height()), (300, 300), "2 in at 150 ppi");
let size_after = deckcraft_pptx::export(&doc).unwrap().len();
assert!(size_after * 4 < size_before, "{size_before} → {size_after}");
s.execute("edit.undo", &json!({})).unwrap();
assert_eq!(s.doc().unwrap().doc.media[0].data.len(), big.len(), "undo restores the original");
// A duplicate that isn't compressed still needs the original.
s.execute("edit.duplicate", &json!({})).unwrap();
let copy = s.doc().unwrap().selection.shapes.clone();
let first: Vec<_> = s.doc().unwrap().doc.slides[0].shapes.iter().map(|sh| sh.id).filter(|id| !copy.contains(id)).collect();
s.execute("picture.compress", &json!({"ppi": 150, "ids": [first.last().unwrap().0]})).unwrap();
let doc = s.doc().unwrap().doc.clone();
assert_eq!(doc.media.len(), 2);
assert!(doc.media.iter().any(|m| m.data.len() == big.len()), "the copy keeps the original");
// All pictures: the copy gets compressed too, and the original goes.
s.execute("picture.compress", &json!({"ppi": 150, "all": true})).unwrap();
let doc = s.doc().unwrap().doc.clone();
assert!(doc.media.iter().all(|m| m.data.len() < big.len() / 4));
assert!(s.execute("picture.compress", &json!({"ppi": 5, "all": true})).is_err());
}
/// #203: SmartArt we can't draw kept its XML but lost its diagram parts on save.
#[test]
fn smartart_without_a_drawing_keeps_its_parts() {
let mut p = defaults::new_presentation(None);
let data = p.add_media(
"data1.xml",
"application/vnd.openxmlformats-officedocument.drawingml.diagramData+xml",
br#"<dgm:dataModel xmlns:dgm="http://schemas.openxmlformats.org/drawingml/2006/diagram" xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"><dgm:ptLst><dgm:pt modelId="1"><dgm:t><a:p><a:r><a:t>Manager</a:t></a:r></a:p></dgm:t></dgm:pt></dgm:ptLst><dgm:extLst><a:ext uri="http://schemas.microsoft.com/office/drawing/2008/diagram"><dsp:dataModelExt xmlns:dsp="http://schemas.microsoft.com/office/drawing/2008/diagram" relId="rId6"/></a:ext></dgm:extLst></dgm:dataModel>"#.to_vec(),
).expect("media");
let mut parts = vec![("rId2".to_string(), "http://schemas.openxmlformats.org/officeDocument/2006/relationships/diagramData".to_string(), data)];
for (i, kind) in ["Layout", "QuickStyle", "Colors"].into_iter().enumerate() {
let xml = format!(r#"<dgm:{kind} xmlns:dgm="http://schemas.openxmlformats.org/drawingml/2006/diagram"/>"#).into_bytes();
let m = p
.add_media(&format!("{kind}1.xml"), &format!("application/vnd.openxmlformats-officedocument.drawingml.diagram{kind}+xml"), xml)
.expect("media");
parts.push((format!("rId{}", i + 3), format!("http://schemas.openxmlformats.org/officeDocument/2006/relationships/diagram{kind}"), m));
}
let xml = r#"<p:graphicFrame xmlns:p="http://schemas.openxmlformats.org/presentationml/2006/main" xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"><p:nvGraphicFramePr><p:cNvPr id="4" name="Diagram 3"/><p:cNvGraphicFramePr/><p:nvPr/></p:nvGraphicFramePr><p:xfrm><a:off x="0" y="0"/><a:ext cx="914400" cy="914400"/></p:xfrm><a:graphic><a:graphicData uri="http://schemas.openxmlformats.org/drawingml/2006/diagram"><dgm:relIds xmlns:dgm="http://schemas.openxmlformats.org/drawingml/2006/diagram" r:dm="rId2" r:lo="rId3" r:qs="rId4" r:cs="rId5"/></a:graphicData></a:graphic></p:graphicFrame>"#;
let mut s = new_slide(&mut p, "SmartArt");
let mut frame = shape(&mut p, "Diagram 3", 0.0, 0.0, 72.0, 72.0);
frame.kind = ShapeKind::Opaque { xml: xml.into(), preview: None, label: "SmartArt".into(), parts };
s.shapes.push(frame);
p.slides.push(Arc::new(s));
// Twice: the second save starts from what the first one wrote.
let q = round(&round(&p));
let ShapeKind::Opaque { parts, .. } = &by_name(&q.slides[1], "Diagram 3").kind else { panic!("not kept as an object") };
assert_eq!(parts.len(), 4, "data, layout, style and colours all kept");
let data = q.media(parts.iter().find(|(_, k, _)| k.ends_with("/diagramData")).expect("data").2).expect("media");
let data = String::from_utf8_lossy(&data.data);
assert!(data.contains("Manager"), "{data}");
assert!(!data.contains("dataModelExt"), "the link to a drawing that isn't written is dropped: {data}");
}
/// #203: a legacy OLE object (preview in the VML drawing we don't write) is saved in PowerPoint's
/// fallback form, without `spid` and with a `p:pic` preview, or PowerPoint won't open the file.
#[test]
fn legacy_ole_object_is_written_in_the_fallback_form() {
let mut p = defaults::new_presentation(None);
let bin = p
.add_media("oleObject1.bin", "application/vnd.openxmlformats-officedocument.oleObject", b"\xD0\xCF\x11\xE0not-a-real-ole".to_vec())
.expect("media");
let prev = p.add_media("image1.png", "image/png", png(4, 3, [10, 20, 30])).expect("media");
let xml = r#"<p:graphicFrame xmlns:p="http://schemas.openxmlformats.org/presentationml/2006/main" xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"><p:nvGraphicFramePr><p:cNvPr id="4" name="Object 3"/><p:cNvGraphicFramePr/><p:nvPr/></p:nvGraphicFramePr><p:xfrm><a:off x="0" y="0"/><a:ext cx="914400" cy="914400"/></p:xfrm><a:graphic><a:graphicData uri="http://schemas.openxmlformats.org/presentationml/2006/ole"><p:oleObj spid="_x0000_s1026" name="Slide" r:id="rId4" progId="PowerPoint.Slide.8"><p:embed/></p:oleObj></a:graphicData></a:graphic></p:graphicFrame>"#;
let parts = vec![("rId4".to_string(), "http://schemas.openxmlformats.org/officeDocument/2006/relationships/oleObject".to_string(), bin)];
let mut s = new_slide(&mut p, "OLE");
let mut frame = shape(&mut p, "Object 3", 0.0, 0.0, 72.0, 72.0);
frame.kind = ShapeKind::Opaque { xml: xml.into(), preview: Some(prev), label: "Slide".into(), parts };
s.shapes.push(frame);
p.slides.push(Arc::new(s));
let q = round(&round(&p));
let ShapeKind::Opaque { xml, parts, preview, .. } = &by_name(&q.slides[1], "Object 3").kind else { panic!("not kept as an object") };
assert!(xml.contains("<p:pic>") && !xml.contains("spid"), "{xml}");
assert!(preview.is_some(), "the preview picture is kept");
assert!(parts.iter().any(|(_, k, _)| k.ends_with("/oleObject")), "the embedding is kept: {parts:?}");
}
/// Insert › Zoom: slide, section and summary zooms are linked pictures of their targets, with
/// Return to Zoom on section and summary zooms; a summary zoom makes its own slide; all of it is
/// one undo step and saves as linked pictures.
#[test]
fn zoom_inserts_linked_slide_pictures() {
use deckcraft_engine::Session;
use deckcraft_model::text::Action;
use serde_json::json;
let mut s = Session::with_new();
for t in ["Intro", "Plan", "Budget", "Risks"] {
s.execute("slide.new", &json!({"title": t})).unwrap();
}
// Slides: 0 title, 1 Intro, 2 Plan, 3 Budget, 4 Risks.
s.execute("slide.go", &json!({"index": 0})).unwrap();
let r = s.execute("insert.zoom", &json!({"slides": [2]})).unwrap();
assert_eq!(r["returnToZoom"], false);
let doc = s.doc().unwrap().doc.clone();
let zoom = doc.slides[0].shapes.iter().find(|sh| sh.name.starts_with("Slide Zoom")).expect("slide zoom");
let link = zoom.click.as_ref().unwrap();
assert_eq!(link.action, Action::Slide { slide: doc.slides[2].id });
assert_eq!(link.zoom_return, None);
assert_eq!(link.tooltip, "Plan");
let ShapeKind::Picture { fill } = &zoom.kind else { panic!() };
assert!(doc.media(fill.media).is_some_and(|m| m.data.starts_with(b"\x89PNG")));
// Section zoom: back after the section's last slide.
s.execute("section.add", &json!({"name": "Start", "at": 0})).unwrap();
s.execute("section.add", &json!({"name": "Money", "at": 3})).unwrap();
let doc = s.doc().unwrap().doc.clone();
let money = doc.sections.iter().position(|x| x.name == "Money").unwrap();
s.execute("slide.go", &json!({"index": 0})).unwrap();
s.execute("insert.zoom", &json!({"kind": "section", "sections": [money]})).unwrap();
let doc = s.doc().unwrap().doc.clone();
let sec = doc.slides[0].shapes.iter().find(|sh| sh.name.starts_with("Section Zoom")).unwrap();
let last = *doc.sections[money].slides.last().unwrap();
assert_eq!(sec.click.as_ref().unwrap().zoom_return, Some(last));
// Summary zoom on slides 1 and 3: a new slide in front, parts 1–2 and 3–4.
let before = doc.slides.len();
s.execute("insert.zoom", &json!({"kind": "summary", "slides": [1, 3]})).unwrap();
let doc = s.doc().unwrap().doc.clone();
assert_eq!(doc.slides.len(), before + 1);
let sum = &doc.slides[1];
assert!(sum.title().contains("Summary"));
let tiles: Vec<_> = sum.shapes.iter().filter_map(|sh| sh.click.as_ref()).collect();
assert_eq!(tiles.len(), 2);
assert_eq!(tiles[0].zoom_return, Some(doc.slides[3].id), "part one runs to the slide before part two");
assert_eq!(tiles[1].zoom_return, Some(doc.slides.last().unwrap().id));
s.execute("edit.undo", &json!({})).unwrap();
assert_eq!(s.doc().unwrap().doc.slides.len(), before, "one undo step");
// Saved as linked pictures.
let back = deckcraft_pptx::import(&deckcraft_pptx::export(&s.doc().unwrap().doc).unwrap()).unwrap();
let z = back.slides[0].shapes.iter().find(|sh| matches!(sh.kind, ShapeKind::Picture { .. }) && sh.click.is_some()).unwrap();
assert!(matches!(z.click.as_ref().unwrap().action, Action::Slide { .. }));
assert!(s.execute("insert.zoom", &json!({"slides": [42]})).is_err());
assert!(s.execute("insert.zoom", &json!({"kind": "slide"})).is_err());
}
#[test]
fn darken_and_desaturate_write_powerpoints_hsl_shift() {
for (effect, preset, shift) in [("darken", 24, r#"s="0" l="-25098""#), ("desaturate", 25, r#"s="-70588" l="0""#)] {
let mut p = defaults::new_presentation(None);
let mut s = p.slides[0].as_ref().clone();
let sh = shape(&mut p, "Target", 100.0, 100.0, 100.0, 100.0);
let id = sh.id;
s.shapes.push(sh);
s.animations.push(Animation { shape: id, class: AnimClass::Emphasis, effect: effect.into(), duration_ms: 500, ..Default::default() });
p.slides[0] = Arc::new(s);
let bytes = deckcraft_pptx::export(&p).expect("export");
let mut zip = zip::ZipArchive::new(std::io::Cursor::new(bytes)).unwrap();
let mut xml = String::new();
std::io::Read::read_to_string(&mut zip.by_name("ppt/slides/slide1.xml").unwrap(), &mut xml).unwrap();
assert!(xml.contains(&format!(r#"presetID="{preset}""#)), "{effect}");
assert!(xml.contains(r#"clrSpc="hsl""#) && xml.contains(shift), "{effect}: {xml}");
assert_eq!(round(&p).slides[0].animations[0].effect, effect);
}
}
/// PowerPoint's default durations (COM `AddEffect`), which differ from the 0.5 s most effects get.
#[test]
fn default_durations_match_powerpoint() {
for (effect, ms) in [
("grow", 1000),
("shrinkTurn", 1000),
("box", 2000),
("circle", 2000),
("diamond", 2000),
("boxOut", 2000),
("diamondOut", 2000),
("expand", 1000),
("contract", 1000),
("spinner", 500),
("spinnerOut", 500),
("colorPulse", 250),
("objectColor", 500),
("boldFlash", 2000),
] {
let a = deckcraft_model::anim::ANIMATIONS.iter().find(|a| a.0 == effect).unwrap();
assert_eq!(a.4, ms, "{effect}");
}
}
/// Show media controls is PowerPoint's `p14:showMediaCtrls` extension inside `p:showPr`: off is
/// written there, under its extension uri and with the p14 namespace declared on the element;
/// on (the default) writes nothing.
#[test]
fn hidden_media_controls_survive_save_and_reopen() {
let props = |p: &Presentation| {
let bytes = deckcraft_pptx::export(p).expect("export");
let mut zip = zip::ZipArchive::new(std::io::Cursor::new(bytes)).expect("zip");
let mut x = String::new();
std::io::Read::read_to_string(&mut zip.by_name("ppt/presProps.xml").expect("presProps"), &mut x).expect("read");
x
};
let mut p = Presentation::default();
p.show.show_media_controls = false;
let xml = props(&p);
let show = xml.split("<p:showPr").nth(1).and_then(|r| r.split("</p:showPr>").next()).expect("p:showPr");
assert!(
show.contains(
"<p:ext uri=\"{2FDB2607-1784-4EEB-B798-7EB5836EED8A}\"><p14:showMediaCtrls xmlns:p14=\"http://schemas.microsoft.com/office/powerpoint/2010/main\" val=\"0\"/></p:ext>"
),
"{xml}"
);
assert!(!round(&p).show.show_media_controls);
let default = Presentation::default();
assert!(!props(&default).contains("showMediaCtrls"));
assert!(round(&default).show.show_media_controls);
}
#[test]
fn reflection_angles_and_skews_out_of_range_are_written_inside_the_schema() {
let mut p = Presentation::default();
let mut slide = new_slide(&mut p, "Reflection ranges");
let mut s = shape(&mut p, "Reflected", 10.0, 10.0, 200.0, 80.0);
s.effects = Some(deckcraft_model::style::Effects {
reflection: Some(deckcraft_model::style::Reflection {
st_pos: Some(150_000),
dir: Some(-5),
fade_dir: Some(21_600_000),
kx: Some(9_000_000),
ky: Some(-9_000_000),
..Default::default()
}),
..Default::default()
});
slide.shapes.push(s);
p.slides.push(Arc::new(slide));
let r = round(&p).slides.last().and_then(|sl| by_name(sl, "Reflected").effects.clone()).and_then(|fx| fx.reflection).expect("reflection");
assert_eq!((r.st_pos, r.dir, r.fade_dir, r.kx, r.ky), (Some(100_000), Some(21_599_995), Some(0), Some(5_399_999), Some(-5_399_999)));
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.