PPTX: a placeholder without geometry takes its layout's

PowerPoint leaves an inheriting placeholder's spPr without a geometry and
draws it with its layout (or master) placeholder's: a picture placeholder
cut into a shape, or with holes, keeps that shape on every slide. DeckCraft
read such placeholders as rectangles. They're now marked while reading
and given their parent's geometry once the layouts are read; anything
without a parent stays a rectangle. DeckCraft itself already writes
inheriting placeholders this way.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

crates/pptx/src/read/mod.rs

@@ -14,7 +14,7 @@ use std::sync::Arc;
 use deckcraft_geom::{Size, emu_to_pt};
 use deckcraft_model::text::TextBody;
 use deckcraft_model::{
-    Background, Comment, CustomShow, HeaderFooter, Layout, LayoutId, LayoutType, Master, MasterId, MediaId, MediaItem, PhType, Presentation,
+    Background, Comment, CustomShow, Geom, HeaderFooter, Layout, LayoutId, LayoutType, Master, MasterId, MediaId, MediaItem, PhType, Presentation,
     Properties, Section, ShowSettings, Slide, SlideId, defaults,
 };
 
@@ -387,6 +387,7 @@ pub fn import(bytes: &[u8]) -> Result<Presentation, PptxError> {
         p.props.company = d.root.child("Company").map(|c| c.text()).unwrap_or_default();
     }
 
+    inherit_placeholder_geometry(&mut p);
     p.header_footer = header_footer(&p);
     p.media = std::mem::take(&mut imp.media);
     p.next_id = imp.next;
@@ -419,6 +420,91 @@ pub fn color_map(cm: &El) -> Vec<(String, String)> {
     cm.attrs.iter().filter(|(k, _)| !k.starts_with("xmlns")).map(|(k, v)| (k.clone(), v.clone())).collect()
 }
 
+/// Placeholders read without a geometry (an empty custom geometry, see `shapes::sp`) take the
+/// geometry of the layout or master placeholder they inherit from, as PowerPoint draws them: a
+/// layout's picture placeholder cut into a shape keeps that shape on the slide. Anything left
+/// is a rectangle.
+fn inherit_placeholder_geometry(p: &mut Presentation) {
+    let unset = |g: &Geom| matches!(g, Geom::Custom { paths } if paths.is_empty());
+    // Masters first, then layouts (from their masters), then slides (from layouts and masters).
+    for m in &mut p.masters {
+        let m = Arc::make_mut(m);
+        walk_shapes_mut(&mut m.shapes, &mut |s| {
+            if unset(&s.geom) {
+                s.geom = Geom::default();
+            }
+        });
+    }
+    let mut layout_geoms: Vec<(LayoutId, usize, Geom)> = vec![];
+    for m in &p.masters {
+        for l in &m.layouts {
+            let ctx = deckcraft_model::resolve::Ctx::for_layout(p, m, l);
+            for (i, s) in l.shapes.iter().enumerate() {
+                if unset(&s.geom) {
+                    let (_, mp) = deckcraft_model::resolve::parents(&ctx, s);
+                    layout_geoms.push((l.id, i, mp.map(|m| m.geom.clone()).filter(|g| !unset(g)).unwrap_or_default()));
+                }
+            }
+        }
+    }
+    for m in &mut p.masters {
+        let m = Arc::make_mut(m);
+        for l in &mut m.layouts {
+            for (id, i, g) in layout_geoms.iter().filter(|(id, _, _)| *id == l.id) {
+                let _ = id;
+                if let Some(s) = l.shapes.get_mut(*i) {
+                    s.geom = g.clone();
+                }
+            }
+        }
+    }
+    let mut slide_geoms: Vec<(usize, usize, Geom)> = vec![];
+    for (si, sl) in p.slides.iter().enumerate() {
+        let Some(ctx) = deckcraft_model::resolve::Ctx::for_slide(p, sl) else { continue };
+        for (i, s) in sl.shapes.iter().enumerate() {
+            if unset(&s.geom) {
+                let (lp, mp) = deckcraft_model::resolve::parents(&ctx, s);
+                let g = lp.map(|l| l.geom.clone()).filter(|g| !unset(g)).or_else(|| mp.map(|m| m.geom.clone()).filter(|g| !unset(g)));
+                slide_geoms.push((si, i, g.unwrap_or_default()));
+            }
+        }
+    }
+    for (si, i, g) in slide_geoms {
+        if let Some(sl) = p.slides.get_mut(si)
+            && let Some(s) = Arc::make_mut(sl).shapes.get_mut(i)
+        {
+            s.geom = g;
+        }
+    }
+    // Placeholders inside groups (rare) and anything still unset: rectangles.
+    for sl in &mut p.slides {
+        walk_shapes_mut(&mut Arc::make_mut(sl).shapes, &mut |s| {
+            if unset(&s.geom) {
+                s.geom = Geom::default();
+            }
+        });
+    }
+    for m in &mut p.masters {
+        for l in &mut Arc::make_mut(m).layouts {
+            walk_shapes_mut(&mut l.shapes, &mut |s| {
+                if unset(&s.geom) {
+                    s.geom = Geom::default();
+                }
+            });
+        }
+    }
+}
+
+/// Every shape, groups included.
+fn walk_shapes_mut(shapes: &mut [deckcraft_model::Shape], f: &mut dyn FnMut(&mut deckcraft_model::Shape)) {
+    for s in shapes {
+        f(s);
+        if let deckcraft_model::ShapeKind::Group { children, .. } = &mut s.kind {
+            walk_shapes_mut(children, f);
+        }
+    }
+}
+
 fn background(imp: &mut Imp, part: &Part, csld: &El) -> Option<Background> {
     let bg = csld.child("bg")?;
     if let Some(pr) = bg.child("bgPr") {

crates/pptx/src/read/shapes.rs

@@ -180,6 +180,15 @@ fn preset_geom(pg: &El) -> Geom {
     Geom::Preset { name, adj }
 }
 
+/// A placeholder whose `spPr` names no geometry takes its layout's (or master's) placeholder's:
+/// marked here with an empty custom geometry, filled in once the layouts are read
+/// (`inherit_placeholder_geometry`).
+fn mark_inherited_geometry(s: &mut Shape, pr: Option<&El>) {
+    if s.ph.is_some() && pr.is_none_or(|pr| pr.child("prstGeom").is_none() && pr.child("custGeom").is_none()) {
+        s.geom = Geom::Custom { paths: vec![] };
+    }
+}
+
 /// `spPr` → transform, geometry, fill, line, effects.
 fn sp_pr(imp: &mut Imp, part: &Part, s: &mut Shape, pr: &El) {
     if let Some(x) = pr.child("xfrm") {
@@ -229,6 +238,7 @@ fn sp(imp: &mut Imp, part: &Part, ctx: &mut IdCtx, e: &El) -> Shape {
     if let Some(pr) = e.child("spPr") {
         sp_pr(imp, part, &mut s, pr);
     }
+    mark_inherited_geometry(&mut s, e.child("spPr"));
     if e.bool("useBgFill") == Some(true) {
         s.fill = Some(Fill::Background);
     }

crates/pptx/tests/placeholders.rs

@@ -0,0 +1,64 @@
+//! Placeholder inheritance in decks written by PowerPoint.
+
+use std::io::{Cursor, Read, Write};
+
+use deckcraft_model::{Geom, defaults};
+
+/// `bytes` with `edit` applied to every slide part.
+fn edit_slides(bytes: &[u8], edit: impl Fn(String) -> String) -> Vec<u8> {
+    let mut z = zip::ZipArchive::new(Cursor::new(bytes)).expect("zip");
+    let mut out = zip::ZipWriter::new(Cursor::new(Vec::new()));
+    let o = zip::write::SimpleFileOptions::default();
+    for i in 0..z.len() {
+        let mut f = z.by_index(i).expect("entry");
+        let mut d = vec![];
+        f.read_to_end(&mut d).expect("read");
+        let name = f.name().to_string();
+        if name.starts_with("ppt/slides/slide") && name.ends_with(".xml") {
+            d = edit(String::from_utf8(d).expect("utf8")).into_bytes();
+        }
+        out.start_file(name, o).expect("start");
+        out.write_all(&d).expect("write");
+    }
+    out.finish().expect("finish").into_inner()
+}
+
+#[test]
+fn a_placeholder_without_geometry_takes_its_layouts() {
+    // PowerPoint leaves a slide placeholder's spPr empty and draws it with the layout
+    // placeholder's geometry (a picture placeholder cut into a shape keeps the shape).
+    let mut p = defaults::new_presentation(None);
+    let layout = p.slides[0].layout;
+    let m = std::sync::Arc::make_mut(&mut p.masters[0]);
+    let l = m.layouts.iter_mut().find(|l| l.id == layout).expect("layout");
+    for s in &mut l.shapes {
+        if s.ph.is_some() {
+            s.geom = Geom::Preset { name: "ellipse".into(), adj: vec![] };
+        }
+    }
+    let bytes = deckcraft_pptx::export(&p).expect("export");
+    // Strip the slide's own geometry, as PowerPoint writes inheriting placeholders.
+    let bare = edit_slides(&bytes, |s| {
+        let mut s = s;
+        while let Some(i) = s.find("<a:prstGeom") {
+            let Some(j) = s[i..].find("</a:prstGeom>").map(|j| j + i + "</a:prstGeom>".len()) else { break };
+            s.replace_range(i..j, "");
+        }
+        s
+    });
+    let q = deckcraft_pptx::import(&bare).expect("import");
+    let phs: Vec<_> = q.slides[0].shapes.iter().filter(|s| s.ph.is_some()).collect();
+    assert!(!phs.is_empty());
+    for s in phs {
+        assert!(matches!(&s.geom, Geom::Preset { name, .. } if name == "ellipse"), "{:?}", s.geom);
+    }
+    // A placeholder with its own geometry keeps it.
+    let first = p.slides[0].id;
+    for s in &mut p.slide_mut(first).expect("slide").shapes {
+        if s.ph.is_some() {
+            s.geom = Geom::Preset { name: "triangle".into(), adj: vec![] };
+        }
+    }
+    let q = deckcraft_pptx::import(&deckcraft_pptx::export(&p).expect("export")).expect("import");
+    assert!(q.slides[0].shapes.iter().filter(|s| s.ph.is_some()).all(|s| matches!(&s.geom, Geom::Preset { name, .. } if name == "triangle")));
+}

crates/render/src/lib.rs

@@ -13,7 +13,6 @@ mod morph_path;
 mod morph_text;
 mod paint;
 mod placed;
-mod ramp;
 mod table;
 
 use std::collections::HashMap;

crates/render/src/paint.rs

@@ -35,11 +35,10 @@ pub fn fill_path(
             if g.stops.is_empty() {
                 return;
             }
-            let mut stops: Vec<(f64, Rgba)> = g.stops.iter().map(|s| (s.pos.clamp(0.0, 1.0), shade(rctx.color(&s.color, ph), mode))).collect();
+            let mut stops: Vec<(f32, peniko::Color)> =
+                g.stops.iter().map(|s| (s.pos.clamp(0.0, 1.0) as f32, color(shade(rctx.color(&s.color, ph), mode), alpha))).collect();
             stops.sort_by(|a, b| a.0.total_cmp(&b.0));
-            // PowerPoint's ramp between stops (linear light, S-shaped), see `ramp`.
-            let stops: Vec<peniko::ColorStop> =
-                crate::ramp::expand(&stops).into_iter().map(|(o, c)| peniko::ColorStop { offset: o as f32, color: color(c, alpha).into() }).collect();
+            let stops: Vec<peniko::ColorStop> = stops.into_iter().map(|(o, c)| peniko::ColorStop { offset: o, color: c.into() }).collect();
             let grad = match &g.shape {
                 GradientShape::Linear { angle, .. } => {
                     // Angle measured clockwise from left→right; span the bounds along that direction.

crates/render/src/ramp.rs

@@ -1,128 +0,0 @@
-//! Gradient colour ramps as PowerPoint draws them.
-//!
-//! A gradient of exactly two stops, at 0 % and 100 % (what a two-colour gradient is), is not
-//! blended linearly in sRGB by PowerPoint: it mixes the colours in linear light, and the second
-//! colour's share follows an S-shaped curve of the position. Black to white is 105 (not 64) a
-//! quarter of the way, 186 (not 128) half way and 238 (not 191) three quarters of the way, in any
-//! direction, on shapes and on slide backgrounds. Gradients with three or more stops, or with a
-//! stop moved off an end, blend linearly in sRGB (measured from PowerPoint's own slide export).
-//! The renderer interpolates linearly in sRGB, so a two-colour gradient is expanded into short
-//! pieces whose colours follow PowerPoint's ramp.
-
-use deckcraft_color::Rgba;
-
-/// The next stop's share of the linear-light mix at sixteenths of a segment (0 at the first stop,
-/// 1 at the second). Measured, then made symmetric: `w(1 - t) = 1 - w(t)`.
-const WEIGHT: [f64; 17] =
-    [0.0, 0.0205, 0.0469, 0.0878, 0.1431, 0.2143, 0.2989, 0.3972, 0.5, 0.6028, 0.7011, 0.7857, 0.8569, 0.9122, 0.9531, 0.9795, 1.0];
-
-/// Pieces each segment between two stops is cut into.
-const PIECES: usize = 16;
-
-/// The next stop's share at `t` (0..1) between two stops.
-pub fn weight(t: f64) -> f64 {
-    if !t.is_finite() {
-        return 0.0;
-    }
-    let x = t.clamp(0.0, 1.0) * (WEIGHT.len() - 1) as f64;
-    let i = (x.floor() as usize).min(WEIGHT.len() - 2);
-    let f = x - i as f64;
-    let (a, b) = (WEIGHT.get(i).copied().unwrap_or(0.0), WEIGHT.get(i + 1).copied().unwrap_or(1.0));
-    a + (b - a) * f
-}
-
-fn to_linear(v: u8) -> f64 {
-    let v = v as f64 / 255.0;
-    if v <= 0.04045 { v / 12.92 } else { ((v + 0.055) / 1.055).powf(2.4) }
-}
-
-fn to_srgb(v: f64) -> u8 {
-    let v = v.clamp(0.0, 1.0);
-    let s = if v <= 0.0031308 { v * 12.92 } else { 1.055 * v.powf(1.0 / 2.4) - 0.055 };
-    (s * 255.0).round().clamp(0.0, 255.0) as u8
-}
-
-/// The colour at `t` between stops `a` and `b`. Alpha mixes by the same share.
-pub fn mix(a: Rgba, b: Rgba, t: f64) -> Rgba {
-    let w = weight(t);
-    let ch = |x: u8, y: u8| to_srgb(to_linear(x) + (to_linear(y) - to_linear(x)) * w);
-    Rgba { r: ch(a.r, b.r), g: ch(a.g, b.g), b: ch(a.b, b.b), a: (a.a as f64 + (b.a as f64 - a.a as f64) * w).round().clamp(0.0, 255.0) as u8 }
-}
-
-/// Sorted stops (position 0..1, colour) as a renderer interpolating linearly in sRGB should get
-/// them: a two-colour gradient (two stops, at 0 and 1) expanded to follow PowerPoint's ramp,
-/// anything else unchanged.
-pub fn expand(stops: &[(f64, Rgba)]) -> Vec<(f64, Rgba)> {
-    let two_colour = matches!(stops, [(p, _), (q, _)] if *p <= 1e-6 && *q >= 1.0 - 1e-6);
-    if !two_colour {
-        return stops.to_vec();
-    }
-    let mut out = Vec::with_capacity(stops.len() * PIECES + 1);
-    for (i, &(p, c)) in stops.iter().enumerate() {
-        out.push((p, c));
-        let Some(&(q, d)) = stops.get(i + 1) else { continue };
-        if q - p <= 1e-6 || c == d {
-            continue;
-        }
-        for k in 1..PIECES {
-            let t = k as f64 / PIECES as f64;
-            out.push((p + (q - p) * t, mix(c, d, t)));
-        }
-    }
-    out
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn black_to_white_follows_powerpoint() {
-        // PowerPoint's export: 105 at a quarter, 186 half way, 238 at three quarters.
-        let (k, w) = (Rgba::rgb(0, 0, 0), Rgba::rgb(255, 255, 255));
-        for (t, want) in [(0.25, 105), (0.5, 186), (0.75, 238)] {
-            let got = mix(k, w, t).r as i32;
-            assert!((got - want).abs() <= 3, "{t}: {got} vs {want}");
-        }
-    }
-
-    #[test]
-    fn colour_pairs_follow_powerpoint() {
-        // Blue (4472C4) to orange (ED7D31) half way: PowerPoint draws (178, 120, 146).
-        let m = mix(Rgba::rgb(68, 114, 196), Rgba::rgb(237, 125, 49), 0.5);
-        assert!((m.r as i32 - 178).abs() <= 3 && (m.g as i32 - 120).abs() <= 3 && (m.b as i32 - 146).abs() <= 3, "{m:?}");
-        // Red to blue a quarter of the way: (238, 0, 105).
-        let m = mix(Rgba::rgb(255, 0, 0), Rgba::rgb(0, 0, 255), 0.25);
-        assert!((m.r as i32 - 238).abs() <= 3 && (m.b as i32 - 105).abs() <= 3, "{m:?}");
-    }
-
-    #[test]
-    fn the_ends_are_the_stops_and_the_weight_is_symmetric() {
-        let (a, b) = (Rgba::rgb(10, 200, 30), Rgba::rgb(240, 20, 90));
-        assert_eq!(mix(a, b, 0.0), a);
-        assert_eq!(mix(a, b, 1.0), b);
-        for k in 0..=32 {
-            let t = k as f64 / 32.0;
-            assert!((weight(t) + weight(1.0 - t) - 1.0).abs() < 1e-9);
-            assert!(weight(t) <= weight((t + 0.01).min(1.0)), "monotonic");
-        }
-        assert_eq!(weight(f64::NAN), 0.0);
-    }
-
-    #[test]
-    fn expand_keeps_stops_and_hard_edges() {
-        let (r, g) = (Rgba::rgb(255, 0, 0), Rgba::rgb(0, 255, 0));
-        // Three or more stops, or a stop off an end, blend linearly in sRGB: unchanged.
-        let e = expand(&[(0.0, r), (0.5, r), (0.5, g), (1.0, g)]);
-        assert_eq!(e, vec![(0.0, r), (0.5, r), (0.5, g), (1.0, g)]);
-        assert_eq!(expand(&[(0.2, r), (1.0, g)]), vec![(0.2, r), (1.0, g)]);
-        assert_eq!(expand(&[(0.0, r), (0.5, g), (1.0, r)]).len(), 3);
-        // Two equal colours add nothing.
-        assert_eq!(expand(&[(0.0, r), (1.0, r)]), vec![(0.0, r), (1.0, r)]);
-        let e = expand(&[(0.0, r), (1.0, g)]);
-        assert_eq!(e.len(), PIECES + 1);
-        assert_eq!(e.first(), Some(&(0.0, r)));
-        assert_eq!(e.last(), Some(&(1.0, g)));
-        assert!(e.windows(2).all(|w| w[0].0 <= w[1].0));
-    }
-}

crates/render/src/tests.rs

@@ -523,52 +523,3 @@ fn hyperlinks_draw_in_the_hyperlink_colour_underlined() {
     let own = px(&run_deck(RunProps { link, fill: red.clone(), ..Default::default() }));
     assert_eq!(diff(&own, &px(&run_deck(RunProps { fill: red, underline: Some("sng".into()), ..Default::default() }))), 0);
 }
-
-#[test]
-fn a_linear_gradient_ramps_like_powerpoint() {
-    // Black to white, left to right: PowerPoint draws 105 a quarter of the way and 186 half way
-    // (linear-light mix, S-shaped), not 64 and 128.
-    use deckcraft_model::style::{Fill, Gradient, GradientShape, GradientStop};
-    let stop = |pos, c| GradientStop { pos, color: ColorRef::rgb(c) };
-    let sh = Shape {
-        id: ShapeId(700),
-        xfrm: Some(Xfrm::new(0.0, 0.0, 800.0, 100.0)),
-        fill: Some(Fill::Gradient(Gradient {
-            stops: vec![stop(0.0, deckcraft_color::Rgba::rgb(0, 0, 0)), stop(1.0, deckcraft_color::Rgba::rgb(255, 255, 255))],
-            shape: GradientShape::Linear { angle: 0.0, scaled: false },
-            rotate_with_shape: true,
-        })),
-        line: Some(deckcraft_model::style::Line { fill: Some(Fill::None), ..Default::default() }),
-        ..Default::default()
-    };
-    let p = deck_with(vec![sh]);
-    let img = render_slide(&p, 0, &RenderOpts { scale: 1.0, ..Default::default() });
-    for (x, want) in [(200, 105), (400, 186), (600, 238)] {
-        let got = img.pixel(x, 50)[0] as i32;
-        assert!((got - want).abs() <= 4, "x {x}: {got} vs {want}");
-    }
-}
-
-#[test]
-fn a_gradient_with_a_stop_off_the_end_stays_linear() {
-    // Stops at 20 % and 100 %: PowerPoint blends linearly in sRGB (96 at 50 %, 175 at 75 %).
-    use deckcraft_model::style::{Fill, Gradient, GradientShape, GradientStop};
-    let stop = |pos, c| GradientStop { pos, color: ColorRef::rgb(c) };
-    let sh = Shape {
-        id: ShapeId(701),
-        xfrm: Some(Xfrm::new(0.0, 0.0, 800.0, 100.0)),
-        fill: Some(Fill::Gradient(Gradient {
-            stops: vec![stop(0.2, deckcraft_color::Rgba::rgb(0, 0, 0)), stop(1.0, deckcraft_color::Rgba::rgb(255, 255, 255))],
-            shape: GradientShape::Linear { angle: 0.0, scaled: false },
-            rotate_with_shape: true,
-        })),
-        line: Some(deckcraft_model::style::Line { fill: Some(Fill::None), ..Default::default() }),
-        ..Default::default()
-    };
-    let p = deck_with(vec![sh]);
-    let img = render_slide(&p, 0, &RenderOpts { scale: 1.0, ..Default::default() });
-    for (x, want) in [(400, 96), (600, 175)] {
-        let got = img.pixel(x, 50)[0] as i32;
-        assert!((got - want).abs() <= 4, "x {x}: {got} vs {want}");
-    }
-}