Render: two-colour gradients ramp like PowerPoint's

PowerPoint blends a gradient of exactly two stops at 0% and 100% in linear
light, with the second colour's share following an S-shaped curve (black to
white is 105/186/238 at a quarter/half/three quarters, not 64/128/191).
Gradients with more stops, or a stop moved off an end, stay linear in sRGB.
Measured with PowerPoint's slide export on shapes and backgrounds, in both
directions. The two-colour case is expanded into sixteen pieces per
segment so vello's sRGB interpolation draws the same ramp.

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

crates/engine/src/cmd/design.rs

@@ -483,7 +483,6 @@ fn insert_layout(s: &mut Session, p: &Value) -> Result<Value> {
                 background: None,
                 show_master_shapes: true,
                 preserve: true,
-                color_map: None,
                 raw_ext: None,
             },
         );

crates/fonts/src/fontdb.rs

@@ -79,10 +79,6 @@ pub struct FontFace {
     /// values).
     pub cap_height: f64,
     pub x_height: f64,
-    /// Where the baseline sits in a line, as a share of the line's height from its top: the
-    /// Windows ascent over the Windows ascent plus descent (OS/2 `usWinAscent`/`usWinDescent`),
-    /// the split PowerPoint uses (computed by `line_split`).
-    pub line_split: f64,
     pub shaper: harfrust::ShaperData,
     /// Variable fonts: the named instance's axis settings (user units; empty = default instance),
     /// the normalised location and the shaper's view of it.
@@ -440,23 +436,6 @@ pub(crate) fn last_resort_face() -> Arc<FontFace> {
     .clone()
 }
 
-/// The share of a line above the baseline (`FontFace::line_split`): OS/2 `usWinAscent` over
-/// `usWinAscent + usWinDescent`, else the ascent over ascent plus descent. Fonts whose Windows
-/// extent is huge (Gabriola, Cambria Math: over 1.5 em) get 0.81, where PowerPoint puts their
-/// baseline (observed).
-fn line_split(f: &skrifa::FontRef, ascent: f64, descent: f64, upem: f64) -> f64 {
-    use skrifa::raw::TableProvider;
-    let (a, d) = match f.os2() {
-        Ok(os2) if os2.us_win_ascent() > 0 => (os2.us_win_ascent() as f64, os2.us_win_descent() as f64),
-        _ => (ascent, descent),
-    };
-    let total = a + d;
-    if !total.is_finite() || total <= 0.0 || a < 0.0 || d < 0.0 {
-        return 0.8;
-    }
-    if total > upem * 1.5 { 0.81 } else { (a / total).clamp(0.5, 1.0) }
-}
-
 fn make_face(bytes: FontBytes, index: u32, family: String, style: String, coords: Vec<([u8; 4], f32)>) -> Option<FontFace> {
     let data: &[u8] = match &bytes {
         FontBytes::Static(b) => b,
@@ -488,7 +467,6 @@ fn make_face(bytes: FontBytes, index: u32, family: String, style: String, coords
         descent: -(m.descent as f64),
         cap_height: m.cap_height.map(|v| v as f64).filter(|v| *v > 0.0).unwrap_or(m.ascent as f64 * 0.72),
         x_height: m.x_height.map(|v| v as f64).filter(|v| *v > 0.0).unwrap_or(m.ascent as f64 * 0.5),
-        line_split: line_split(&f, m.ascent as f64, -(m.descent as f64), m.units_per_em.max(1) as f64),
         shaper,
         coords,
         location,

crates/fonts/src/lib.rs

@@ -143,17 +143,6 @@ mod tests {
         assert!(f.upem > 0.0);
     }
 
-    #[test]
-    fn line_split_follows_the_windows_ascent_and_descent() {
-        use skrifa::raw::TableProvider;
-        let f = fontdb::last_resort_face();
-        let font = skrifa::FontRef::new(f.data()).unwrap();
-        let os2 = font.os2().unwrap();
-        let (a, d) = (os2.us_win_ascent() as f64, os2.us_win_descent() as f64);
-        assert!((f.line_split - a / (a + d)).abs() < 1e-9, "{} vs {}", f.line_split, a / (a + d));
-        assert!(f.line_split > 0.5 && f.line_split < 1.0);
-    }
-
     #[test]
     fn some_face_always_resolves() {
         let db = FontDb::with_font_dirs(Vec::new());

crates/model/src/defaults.rs

@@ -243,7 +243,6 @@ pub fn build_master(size: Size, theme: Theme, first_id: u32) -> (Master, u32) {
             background: None,
             show_master_shapes: true,
             preserve: true,
-            color_map: None,
             raw_ext: None,
         });
     };

crates/model/src/lib.rs

@@ -488,10 +488,6 @@ pub struct Slide {
     /// Speaker notes.
     pub notes: TextBody,
     pub comments: Vec<Comment>,
-    /// `clrMapOvr`: a colour map replacing the layout's or master's (`bg1`→`dk1`…); None follows
-    /// the layout.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub color_map: Option<Vec<(String, String)>>,
     /// Unmodelled XML kept for round-trip (custom data, tags).
     #[serde(skip_serializing_if = "Option::is_none")]
     pub raw_ext: Option<String>,
@@ -511,7 +507,6 @@ impl Default for Slide {
             animations: vec![],
             notes: TextBody::default(),
             comments: vec![],
-            color_map: None,
             raw_ext: None,
         }
     }
@@ -601,10 +596,6 @@ pub struct Layout {
     pub background: Option<Background>,
     pub show_master_shapes: bool,
     pub preserve: bool,
-    /// `clrMapOvr`: a colour map replacing the master's for this layout and the slides using it
-    /// (dark "section" layouts map `bg1` to `dk1`); None follows the master.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub color_map: Option<Vec<(String, String)>>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub raw_ext: Option<String>,
 }
@@ -650,17 +641,24 @@ impl Master {
     }
     /// Resolve `bg1`/`tx1`/`bg2`/`tx2` through the colour map.
     pub fn map_slot(&self, slot: SchemeSlot) -> SchemeSlot {
-        map_slot(&self.color_map, slot)
+        let key = match slot {
+            SchemeSlot::Bg1 => "bg1",
+            SchemeSlot::Tx1 => "tx1",
+            SchemeSlot::Bg2 => "bg2",
+            SchemeSlot::Tx2 => "tx2",
+            other => return other,
+        };
+        self.color_map.iter().find(|(k, _)| k == key).and_then(|(_, v)| SchemeSlot::from_xml(v)).unwrap_or(match slot {
+            SchemeSlot::Bg1 => SchemeSlot::Lt1,
+            SchemeSlot::Tx1 => SchemeSlot::Dk1,
+            SchemeSlot::Bg2 => SchemeSlot::Lt2,
+            _ => SchemeSlot::Dk2,
+        })
     }
     /// The theme's colour scheme with the colour map applied (`bg1`… resolve to mapped colours).
     pub fn scheme(&self) -> ColorScheme {
-        self.scheme_with(&self.color_map)
-    }
-    /// The theme's colour scheme with `map` (a layout's or slide's override, or the master's own)
-    /// applied.
-    pub fn scheme_with(&self, map: &[(String, String)]) -> ColorScheme {
         let mut s = self.theme.colors.clone();
-        if map.is_empty() {
+        if self.color_map.is_empty() {
             return s;
         }
         let base = self.theme.colors.clone();
@@ -670,30 +668,12 @@ impl Master {
             (SchemeSlot::Bg2, SchemeSlot::Lt2),
             (SchemeSlot::Tx2, SchemeSlot::Dk2),
         ] {
-            s.set(slot, base.get(map_slot(map, alias)));
+            s.set(slot, base.get(self.map_slot(alias)));
         }
         s
     }
 }
 
-/// Resolve `bg1`/`tx1`/`bg2`/`tx2` through the colour map `map` (the default mapping when it has
-/// no entry).
-pub fn map_slot(map: &[(String, String)], slot: SchemeSlot) -> SchemeSlot {
-    let key = match slot {
-        SchemeSlot::Bg1 => "bg1",
-        SchemeSlot::Tx1 => "tx1",
-        SchemeSlot::Bg2 => "bg2",
-        SchemeSlot::Tx2 => "tx2",
-        other => return other,
-    };
-    map.iter().find(|(k, _)| k == key).and_then(|(_, v)| SchemeSlot::from_xml(v)).unwrap_or(match slot {
-        SchemeSlot::Bg1 => SchemeSlot::Lt1,
-        SchemeSlot::Tx1 => SchemeSlot::Dk1,
-        SchemeSlot::Bg2 => SchemeSlot::Lt2,
-        _ => SchemeSlot::Dk2,
-    })
-}
-
 #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
 #[serde(default, rename_all = "camelCase")]
 pub struct Section {

crates/model/src/resolve.rs

@@ -22,27 +22,23 @@ pub struct Ctx<'a> {
     pub layout: Option<&'a Layout>,
     pub owner: Owner,
     pub scheme: ColorScheme,
-    /// The colour map in force: the slide's override, else its layout's, else the master's.
-    pub color_map: Vec<(String, String)>,
 }
 
 impl<'a> Ctx<'a> {
     pub fn for_slide(pres: &'a Presentation, slide: &Slide) -> Option<Ctx<'a>> {
         let (master, layout) = pres.master_for(slide)?;
-        let map = slide.color_map.as_ref().or(layout.and_then(|l| l.color_map.as_ref())).unwrap_or(&master.color_map).clone();
-        Some(Ctx { pres, master, layout, owner: Owner::Slide, scheme: master.scheme_with(&map), color_map: map })
+        Some(Ctx { pres, master, layout, owner: Owner::Slide, scheme: master.scheme() })
     }
     pub fn for_layout(pres: &'a Presentation, master: &'a Master, layout: &'a Layout) -> Ctx<'a> {
-        let map = layout.color_map.as_ref().unwrap_or(&master.color_map).clone();
-        Ctx { pres, master, layout: Some(layout), owner: Owner::Layout, scheme: master.scheme_with(&map), color_map: map }
+        Ctx { pres, master, layout: Some(layout), owner: Owner::Layout, scheme: master.scheme() }
     }
     pub fn for_master(pres: &'a Presentation, master: &'a Master) -> Ctx<'a> {
-        Ctx { pres, master, layout: None, owner: Owner::Master, scheme: master.scheme(), color_map: master.color_map.clone() }
+        Ctx { pres, master, layout: None, owner: Owner::Master, scheme: master.scheme() }
     }
     pub fn color(&self, c: &ColorRef, ph: Option<Rgba>) -> Rgba {
         let c = match &c.base {
             crate::ColorBase::Scheme { slot } if matches!(slot, SchemeSlot::Bg1 | SchemeSlot::Tx1 | SchemeSlot::Bg2 | SchemeSlot::Tx2) => {
-                ColorRef { base: crate::ColorBase::Scheme { slot: crate::map_slot(&self.color_map, *slot) }, mods: c.mods.clone() }
+                ColorRef { base: crate::ColorBase::Scheme { slot: self.master.map_slot(*slot) }, mods: c.mods.clone() }
             }
             _ => c.clone(),
         };

crates/model/src/tests.rs

@@ -159,31 +159,3 @@ fn hyperlinked_runs_take_the_theme_hyperlink_look() {
     let dbl = resolve::run(&ctx, title, &para, &RunProps { link, underline: Some("dbl".into()), ..Default::default() });
     assert_eq!((dbl.fill, dbl.underline.as_deref()), (hlink, Some("dbl")));
 }
-
-#[test]
-fn a_layout_colour_map_override_applies_to_its_slides() {
-    // A dark "section" layout maps bg1→dk1 and tx1→lt1; a slide on it that keeps the master
-    // mapping (`masterClrMapping`) follows the layout, as PowerPoint draws it.
-    let mut p = Presentation::default();
-    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;
-    let m = std::sync::Arc::make_mut(&mut p.masters[0]);
-    let colors = m.theme.colors.clone();
-    m.layouts.iter_mut().find(|l| l.id == layout).unwrap().color_map = Some(dark.clone());
-    let s: Slide = (*p.slides[0]).clone();
-    let ctx = Ctx::for_slide(&p, &s).unwrap();
-    assert_eq!(ctx.color(&ColorRef::scheme(SchemeSlot::Bg1), None), colors.get(SchemeSlot::Dk1));
-    assert_eq!(ctx.color(&ColorRef::scheme(SchemeSlot::Tx2), None), colors.get(SchemeSlot::Lt2));
-    assert_eq!(ctx.scheme.get(SchemeSlot::Lt1), colors.get(SchemeSlot::Dk1));
-    // The slide's own override wins over the layout's.
-    let mut own = s.clone();
-    own.color_map = Some([("bg1", "lt1"), ("tx1", "dk1")].iter().map(|(a, b)| (a.to_string(), b.to_string())).collect());
-    let ctx = Ctx::for_slide(&p, &own).unwrap();
-    assert_eq!(ctx.color(&ColorRef::scheme(SchemeSlot::Bg1), None), colors.get(SchemeSlot::Lt1));
-    // The layout itself draws with its override; the master keeps its own map.
-    let m = &p.masters[0];
-    let l = m.layout(layout).unwrap();
-    assert_eq!(Ctx::for_layout(&p, m, l).color(&ColorRef::scheme(SchemeSlot::Bg1), None), colors.get(SchemeSlot::Dk1));
-    assert_eq!(Ctx::for_master(&p, m).color(&ColorRef::scheme(SchemeSlot::Bg1), None), colors.get(SchemeSlot::Lt1));
-}

crates/pptx/src/read/dml.rs

@@ -77,12 +77,6 @@ pub fn fill_el(imp: &mut Imp, part: &Part, f: &El) -> Option<Fill> {
         "solidFill" => Fill::Solid { color: color(f).unwrap_or(ColorRef::rgb(Rgba::BLACK)) },
         "gradFill" => Fill::Gradient(gradient(f)),
         "blipFill" => match blip_fill(imp, part, f) {
-            // A picture filling a shape or background with neither `a:stretch` nor `a:tile` is
-            // tiled at its own size, as PowerPoint draws it.
-            Some(mut p) if f.child("stretch").is_none() && f.child("tile").is_none() => {
-                p.mode = PictureMode::Tile { tx: 0.0, ty: 0.0, sx: 1.0, sy: 1.0, flip: "none".into(), align: "tl".into() };
-                Fill::Picture(p)
-            }
             Some(p) => Fill::Picture(p),
             None => Fill::None,
         },

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, Geom, HeaderFooter, Layout, LayoutId, LayoutType, Master, MasterId, MediaId, MediaItem, PhType, Presentation,
+    Background, Comment, CustomShow, HeaderFooter, Layout, LayoutId, LayoutType, Master, MasterId, MediaId, MediaItem, PhType, Presentation,
     Properties, Section, ShowSettings, Slide, SlideId, defaults,
 };
 
@@ -387,7 +387,6 @@ 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;
@@ -420,91 +419,6 @@ 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") {
@@ -609,18 +523,12 @@ fn read_layout(imp: &mut Imp, part: &Part, doc: &Doc) -> Layout {
             l.shapes = shapes::sp_tree(imp, part, &mut ctx, tree, 0);
         }
     }
-    l.color_map = color_map_override(root);
     if let Some(ext) = root.child("extLst").filter(|e| !has_rel_refs(e)) {
         l.raw_ext = Some(ext.elements().map(|e| part.keep(e)).collect());
     }
     l
 }
 
-/// A layout's or slide's `clrMapOvr/overrideClrMapping` (None for `masterClrMapping` or none).
-fn color_map_override(root: &El) -> Option<Vec<(String, String)>> {
-    root.child("clrMapOvr")?.child("overrideClrMapping").map(color_map)
-}
-
 fn read_slide(imp: &mut Imp, part: &Part, doc: &Doc, id: SlideId, layout: LayoutId) -> Slide {
     let root = &doc.root;
     let mut s = Slide {
@@ -628,7 +536,6 @@ fn read_slide(imp: &mut Imp, part: &Part, doc: &Doc, id: SlideId, layout: Layout
         layout,
         hidden: root.bool("show") == Some(false),
         show_master_shapes: root.bool("showMasterSp").unwrap_or(true),
-        color_map: color_map_override(root),
         ..Default::default()
     };
     let mut ctx = shapes::IdCtx::default();

crates/pptx/src/read/shapes.rs

@@ -180,15 +180,6 @@ 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") {
@@ -238,7 +229,6 @@ 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/src/write/mod.rs

@@ -227,21 +227,6 @@ const CLR_KEYS: [(&str, &str); 12] = [
 ];
 
 fn clr_map(w: &mut W, map: &[(String, String)]) {
-    w.empty("p:clrMap", clr_map_attrs(map));
-}
-
-/// `p:clrMapOvr`: the layout's or slide's own colour map, else `a:masterClrMapping`.
-fn clr_map_ovr(w: &mut W, map: Option<&[(String, String)]>) {
-    w.open0("p:clrMapOvr");
-    match map {
-        Some(m) => w.empty("a:overrideClrMapping", clr_map_attrs(m)),
-        None => w.empty0("a:masterClrMapping"),
-    }
-    w.close("p:clrMapOvr");
-}
-
-/// The twelve colour map attributes, each a theme slot (the default for anything else).
-fn clr_map_attrs(map: &[(String, String)]) -> A {
     let mut a = A::new();
     for (k, d) in CLR_KEYS {
         let v = map
@@ -252,7 +237,7 @@ fn clr_map_attrs(map: &[(String, String)]) -> A {
             .unwrap_or(d);
         a = a.a(k, v);
     }
-    a
+    w.empty("p:clrMap", a);
 }
 
 fn ext_list(w: &mut W, raw: Option<&str>) {
@@ -537,7 +522,9 @@ fn layout_xml(x: &mut Exp, o: &mut Out, l: &Layout) -> Vec<u8> {
         A::new().o("showMasterSp", (!l.show_master_shapes).then_some("0")).a("type", l.kind.xml()).t("preserve", l.preserve),
     );
     csld(&mut w, x, o, &l.name, l.background.as_ref(), &l.shapes);
-    clr_map_ovr(&mut w, l.color_map.as_deref());
+    w.open0("p:clrMapOvr");
+    w.empty0("a:masterClrMapping");
+    w.close("p:clrMapOvr");
     ext_list(&mut w, ext_children(l.raw_ext.as_deref()).as_deref());
     w.close("p:sldLayout");
     w.finish()
@@ -569,7 +556,9 @@ fn slide_xml(x: &mut Exp, o: &mut Out, s: &Slide) -> Vec<u8> {
     let mut w = W::new();
     root_open(&mut w, "p:sld", A::new().o("showMasterSp", (!s.show_master_shapes).then_some("0")).o("show", s.hidden.then_some("0")));
     let ids = csld(&mut w, x, o, &s.name, s.background.as_ref(), &s.shapes);
-    clr_map_ovr(&mut w, s.color_map.as_deref());
+    w.open0("p:clrMapOvr");
+    w.empty0("a:masterClrMapping");
+    w.close("p:clrMapOvr");
     if let Some(t) = &s.transition {
         timing::transition(&mut w, x, o, t);
     }

crates/pptx/tests/fills.rs

@@ -1,81 +0,0 @@
-//! Fills read from decks written by other tools.
-
-use std::io::{Cursor, Read, Write};
-
-use deckcraft_geom::Xfrm;
-use deckcraft_model::style::{Fill, PictureFill, PictureMode};
-use deckcraft_model::{Shape, ShapeId, 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()
-}
-
-fn png() -> Vec<u8> {
-    let mut out = Cursor::new(vec![]);
-    image::DynamicImage::ImageRgb8(image::RgbImage::from_pixel(4, 4, image::Rgb([10, 200, 30])))
-        .write_to(&mut out, image::ImageFormat::Png)
-        .expect("png");
-    out.into_inner()
-}
-
-/// A deck with one shape filled with a stretched picture, exported.
-fn deck() -> Vec<u8> {
-    let mut p = defaults::new_presentation(None);
-    let media = p.add_media("tile.png", "image/png", png());
-    let id = ShapeId(p.alloc_id());
-    let first = p.slides[0].id;
-    p.slide_mut(first).expect("slide").shapes.push(Shape {
-        id,
-        name: "Textured".into(),
-        xfrm: Some(Xfrm::new(10.0, 10.0, 200.0, 100.0)),
-        fill: Some(Fill::Picture(PictureFill { media, ..Default::default() })),
-        ..Default::default()
-    });
-    deckcraft_pptx::export(&p).expect("export")
-}
-
-fn textured_mode(bytes: &[u8]) -> PictureMode {
-    let q = deckcraft_pptx::import(bytes).expect("import");
-    let s = q.slides[0].shapes.iter().find(|s| s.name == "Textured").expect("shape");
-    match &s.fill {
-        Some(Fill::Picture(pf)) => pf.mode.clone(),
-        other => panic!("{other:?}"),
-    }
-}
-
-#[test]
-fn a_shape_picture_fill_without_stretch_or_tile_tiles() {
-    // tdf#128596: `<a:blipFill><a:blip/></a:blipFill>` on a shape, as some tools write it;
-    // PowerPoint tiles the picture at its own size.
-    let bare = edit_slides(&deck(), |s| {
-        let s = regex_free_strip(&s, "<a:stretch>", "</a:stretch>");
-        assert!(!s.contains("<a:stretch"), "the test deck lost its stretch");
-        s
-    });
-    assert!(matches!(textured_mode(&bare), PictureMode::Tile { sx, sy, .. } if sx == 1.0 && sy == 1.0));
-    // An explicit stretch is still a stretch.
-    assert!(matches!(textured_mode(&deck()), PictureMode::Stretch { .. }));
-}
-
-/// `s` without the first `open`…`close` span inside a `blipFill`.
-fn regex_free_strip(s: &str, open: &str, close: &str) -> String {
-    let Some(b) = s.find("<a:blipFill") else { return s.to_string() };
-    let Some(i) = s[b..].find(open).map(|i| i + b) else { return s.to_string() };
-    let Some(j) = s[i..].find(close).map(|j| j + i + close.len()) else { return s.to_string() };
-    format!("{}{}", &s[..i], &s[j..])
-}

crates/pptx/tests/placeholders.rs

@@ -1,64 +0,0 @@
-//! 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/pptx/tests/roundtrip.rs

@@ -730,39 +730,3 @@ fn date_fields_keep_their_type_and_saved_text() {
         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]));
-    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)));
-}

crates/render/src/images.rs

@@ -79,26 +79,9 @@ fn adjust_key(a: &PictureAdjust) -> u64 {
     if let Some(c) = a.clear_color {
         mix(((c.r as u64) << 16) | ((c.g as u64) << 8) | c.b as u64 | 1 << 40);
     }
-    if let Some((d, l)) = duotone_rgb(a) {
-        for c in [d, l] {
-            mix(((c.r as u64) << 24) | ((c.g as u64) << 16) | ((c.b as u64) << 8) | c.a as u64 | 1 << 41);
-        }
-    }
     h
 }
 
-/// The duotone's dark and light colours. The painter resolves them to plain RGB first (see
-/// `paint::resolved`); a colour that is still a scheme reference falls back to black and white.
-fn duotone_rgb(a: &PictureAdjust) -> Option<(deckcraft_color::Rgba, deckcraft_color::Rgba)> {
-    use deckcraft_model::style::ColorBase;
-    let (d, l) = a.duotone.as_ref()?;
-    let rgb = |c: &deckcraft_model::style::ColorRef, or: deckcraft_color::Rgba| match &c.base {
-        ColorBase::Rgb { rgb } if c.mods.is_empty() => *rgb,
-        _ => or,
-    };
-    Some((rgb(d, deckcraft_color::Rgba::BLACK), rgb(l, deckcraft_color::Rgba::WHITE)))
-}
-
 /// Decode encoded bytes (PNG, JPEG, GIF, WebP, BMP, TIFF) to straight RGBA.
 pub fn decode(bytes: &[u8]) -> Option<image::RgbaImage> {
     if bytes.len() > 512 << 20 {
@@ -250,7 +233,6 @@ fn apply_adjust(img: &mut image::RgbaImage, a: &PictureAdjust) {
     if a.brightness == 0.0 && a.contrast == 0.0 && sat == 1.0 && !a.grayscale && a.clear_color.is_none() && a.duotone.is_none() {
         return;
     }
-    let duo = duotone_rgb(a);
     let b = a.brightness.clamp(-1.0, 1.0) * 255.0;
     let c = a.contrast.clamp(-1.0, 1.0);
     let cf = if c >= 0.0 { 1.0 / (1.0 - c * 0.99) } else { 1.0 + c };
@@ -270,12 +252,6 @@ fn apply_adjust(img: &mut image::RgbaImage, a: &PictureAdjust) {
             *v = y + (*v - y) * s;
             *v = (*v - 128.0) * cf + 128.0 + b;
         }
-        // Duotone: the pixel's luminance picks a colour between the dark and the light one.
-        if let Some((d, l)) = duo {
-            let t = ((0.299 * rgb[0] + 0.587 * rgb[1] + 0.114 * rgb[2]) / 255.0).clamp(0.0, 1.0);
-            rgb =
-                [d.r as f64 + (l.r as f64 - d.r as f64) * t, d.g as f64 + (l.g as f64 - d.g as f64) * t, d.b as f64 + (l.b as f64 - d.b as f64) * t];
-        }
         for (i, v) in rgb.iter().enumerate() {
             if let Some(ch) = p.0.get_mut(i) {
                 *ch = v.round().clamp(0.0, 255.0) as u8;
@@ -290,25 +266,6 @@ mod tests {
 
     use super::*;
 
-    #[test]
-    fn duotone_maps_luminance_between_its_two_colours() {
-        use deckcraft_color::Rgba;
-        use deckcraft_model::style::ColorRef;
-        let mut img = image::RgbaImage::from_fn(3, 1, |x, _| image::Rgba([[0, 0, 0, 255], [128, 128, 128, 200], [255, 255, 255, 255]][x as usize]));
-        let adj =
-            PictureAdjust { duotone: Some((ColorRef::rgb(Rgba::rgb(100, 40, 0)), ColorRef::rgb(Rgba::rgb(250, 240, 200)))), ..Default::default() };
-        apply_adjust(&mut img, &adj);
-        assert_eq!(img.get_pixel(0, 0).0, [100, 40, 0, 255], "black takes the dark colour");
-        assert_eq!(img.get_pixel(2, 0).0, [250, 240, 200, 255], "white takes the light colour");
-        let mid = img.get_pixel(1, 0).0;
-        assert!((mid[0] as i32 - 175).abs() <= 1 && (mid[1] as i32 - 140).abs() <= 1 && (mid[2] as i32 - 100).abs() <= 1, "{mid:?}");
-        assert_eq!(mid[3], 200, "alpha is kept");
-        // Different duotones are cached separately.
-        let other = PictureAdjust { duotone: Some((ColorRef::rgb(Rgba::rgb(0, 0, 0)), ColorRef::rgb(Rgba::rgb(255, 0, 0)))), ..Default::default() };
-        assert_ne!(adjust_key(&adj), adjust_key(&other));
-        assert_ne!(adjust_key(&adj), adjust_key(&PictureAdjust::default()));
-    }
-
     #[test]
     fn a_gif_of_many_tiny_frames_keeps_only_the_frame_cap() {
         use image::{Delay, Frame, Rgba, RgbaImage};

crates/render/src/lib.rs

@@ -684,7 +684,7 @@ impl Renderer {
                 let bounds = Rect::new(0.0, 0.0, w, h);
                 ctx.push_clip_layer(&outline);
                 let t = f.opts.gif_times.iter().find(|g| g.0 == s.id).map(|g| g.1);
-                paint::picture(ctx, f.pres, &paint::resolved(rctx, pf, None), bounds, m, t);
+                paint::picture(ctx, f.pres, pf, bounds, m, t);
                 ctx.pop_layer();
             }
             ShapeKind::Media(mc) => {

crates/render/src/paint.rs

@@ -3,7 +3,7 @@
 use deckcraft_color::Rgba;
 use deckcraft_geom::preset::FillMode;
 use deckcraft_model::resolve::Ctx;
-use deckcraft_model::style::{ColorRef, Fill, GradientShape, PictureFill, PictureMode};
+use deckcraft_model::style::{Fill, GradientShape, PictureFill, PictureMode};
 use deckcraft_model::{PhType, Presentation};
 use kurbo::{Affine, BezPath, Point, Rect, Shape as _};
 use vello_cpu::{RenderContext, peniko};
@@ -66,7 +66,7 @@ pub fn fill_path(
         }
         Fill::Picture(pf) => {
             ctx.push_clip_layer(path);
-            picture(ctx, pres, &resolved(rctx, pf, ph), bounds, m, None);
+            picture(ctx, pres, pf, bounds, m, None);
             ctx.pop_layer();
         }
         Fill::Pattern(p) => {
@@ -121,16 +121,6 @@ fn p_rect(x: f64, y: f64, w: f64, h: f64) -> BezPath {
 }
 fn p_add(_a: &mut BezPath, _b: &mut BezPath) {}
 
-/// `pf` with its duotone colours resolved to plain RGB against the slide's colours and the
-/// placeholder colour `ph` (theme background pictures recolour with `phClr`), so the decoded-image
-/// cache can apply and key them without a colour scheme.
-pub fn resolved<'a>(rctx: &Ctx, pf: &'a PictureFill, ph: Option<Rgba>) -> std::borrow::Cow<'a, PictureFill> {
-    let Some((d, l)) = &pf.adjust.duotone else { return std::borrow::Cow::Borrowed(pf) };
-    let mut out = pf.clone();
-    out.adjust.duotone = Some((ColorRef::rgb(rctx.color(d, ph)), ColorRef::rgb(rctx.color(l, ph))));
-    std::borrow::Cow::Owned(out)
-}
-
 /// Draw a picture fill into `bounds` (shape-local) honouring crop and stretch/tile modes; an animated
 /// GIF shows its frame at `gif_time` seconds.
 pub fn picture(ctx: &mut RenderContext, pres: &Presentation, pf: &PictureFill, bounds: Rect, m: Affine, gif_time: Option<f64>) {

crates/text/src/lib.rs

@@ -566,9 +566,6 @@ fn shape_cells(ctx: &Ctx, text: &str, char_style: &[usize], styles: &[Style], fa
     cells
 }
 
-/// Size of superscript and subscript text relative to the run's size.
-const SUB_SUPER: f64 = 0.66;
-
 /// Shape cells `range` (one item) and hang each cluster's glyphs on its first cell, sharing the
 /// cluster's advance among its graphemes (by the ligature's GDEF carets when it has them).
 #[allow(clippy::too_many_arguments)]
@@ -596,11 +593,7 @@ fn shape_item(
         let st = styles.get(cell.style);
         let size = st.map(|s| s.size).unwrap_or(18.0);
         let small = st.is_some_and(|s| s.caps == Caps::Small) && cell.ch.is_lowercase();
-        let size = if small { size * 0.8 } else { size };
-        // Superscript and subscript glyphs are drawn at two thirds of the size, so they advance by
-        // two thirds too.
-        let size = if st.is_some_and(|s| s.baseline != 0.0) { size * SUB_SUPER } else { size };
-        size / upem
+        (if small { size * 0.8 } else { size }) / upem
     };
     // Cluster heads in this item, ascending; each cluster spans to the next head.
     let mut heads: Vec<usize> = glyphs.iter().filter_map(|g| char_at_byte.get(&g.cluster).copied()).filter(|h| range.contains(h)).collect();
@@ -686,8 +679,7 @@ fn map_symbol_bullet(c: &str, font: Option<&str>) -> String {
         };
         return m.to_string();
     }
-    // PowerPoint draws only the first character of a longer `buChar` ("••" draws one dot).
-    c.graphemes(true).next().unwrap_or("•").to_string()
+    c.to_string()
 }
 
 fn measure_str(face: &FontFace, size: f64, s: &str) -> (f64, Vec<(u32, f64)>) {
@@ -702,20 +694,9 @@ fn measure_str(face: &FontFace, size: f64, s: &str) -> (f64, Vec<(u32, f64)>) {
     (x, out)
 }
 
-/// Single line spacing as a multiple of the font size. PowerPoint spaces single-spaced lines 1.2
-/// times the size apart in every font (observed on twenty Latin, CJK, Thai and Indic fonts at 18
-/// and 40 pt), whatever the font's own ascent and descent.
-///
-/// Caveat: this was measured on one Windows install of desktop PowerPoint. It may be a Windows or
-/// machine setting; PowerPoint on macOS or the web may space lines by the font's own metrics.
-/// Keep it a single tunable value, and re-measure on the other platform before changing it.
-const LINE_PITCH: f64 = 1.2;
-
-/// A line's height above and below the baseline at `size`: [`LINE_PITCH`] × size, split where
-/// the font's Windows ascent and descent put the baseline.
 fn line_metrics(face: &FontFace, size: f64) -> (f64, f64) {
-    let h = size * LINE_PITCH;
-    (h * face.line_split, h * (1.0 - face.line_split))
+    let k = size / face.upem.max(1.0);
+    (face.ascent * k, face.descent * k)
 }
 
 /// Break opportunities: allowed[i] = a line may start at char i.
@@ -928,11 +909,7 @@ fn layout_scaled(ctx: &Ctx, shape: &Shape, body: &TextBody, bp: &BodyProps, opts
         let bullet_w = p.bullet.as_ref().map(|(s, st)| measure_str(&st.face, st.size, s).0).unwrap_or(0.0);
         let first_x = if p.bullet.is_some() {
             let bx = (margin + indent).max(0.0);
-            // A hanging bullet's text starts at the margin. When the hang reaches left of the box
-            // (marL + indent < 0), PowerPoint pins the bullet to the box's edge and keeps the
-            // hang: the first line's text starts at -indent (later lines stay at the margin).
-            let stop = margin.max(-indent);
-            if indent < 0.0 && bx + bullet_w <= stop { stop } else { bx + bullet_w + if indent >= 0.0 { 0.0 } else { 3.0 } }
+            if indent < 0.0 && bx + bullet_w <= margin { margin } else { bx + bullet_w + if indent >= 0.0 { 0.0 } else { 3.0 } }
         } else {
             (margin + indent).max(0.0)
         };
@@ -1178,7 +1155,7 @@ fn layout_scaled(ctx: &Ctx, shape: &Shape, body: &TextBody, bp: &BodyProps, opts
             let Some(st) = p.styles.get(cell.style) else { continue };
             let Some(&(cx, cx1)) = line.edges.get(k) else { continue };
             let base_y = line.baseline - st.baseline * st.size;
-            let size = if st.baseline != 0.0 { st.size * SUB_SUPER } else { st.size };
+            let size = if st.baseline != 0.0 { st.size * 0.66 } else { st.size };
             let size = if st.caps == Caps::Small && cell.ch.is_lowercase() { size * 0.8 } else { size };
             let key = (cell.style, cell.face);
             if key != cur_key {
@@ -1227,8 +1204,9 @@ fn layout_scaled(ctx: &Ctx, shape: &Shape, body: &TextBody, bp: &BodyProps, opts
                             }
                         }
                     }
+                    let k66 = if st.baseline != 0.0 { 0.66 } else { 1.0 };
                     for (gid, gx, gy) in &cell.glyphs {
-                        r.glyphs.push((*gid, cl + kash + gx, base_y + gy));
+                        r.glyphs.push((*gid, cl + kash + gx * k66, base_y + gy));
                         r.cells.push((ci, cell.ch));
                     }
                 }

crates/text/src/tests.rs

@@ -45,20 +45,6 @@ fn bullets_are_drawn_for_body_text() {
     assert_eq!(l.para_lines.len(), 2);
 }
 
-#[test]
-fn only_the_first_character_of_a_bullet_is_drawn() {
-    // "••" (seen in the wild) draws one dot in PowerPoint.
-    for (char, glyphs) in [("\u{2022}\u{2022}", 1), ("\u{2022}", 1), ("-->", 1)] {
-        let (p, mut sh) = setup("One", 600.0, 300.0);
-        sh.text.as_mut().unwrap().paragraphs[0].props.bullet = Some(Bullet::Char { char: char.into() });
-        let l = lay(&p, &sh, 600.0, 300.0);
-        let bullet = l.runs.iter().find(|r| r.chars == (0, 0)).expect("bullet run");
-        assert_eq!(bullet.glyphs.len(), glyphs, "{char:?}");
-    }
-    // The first grapheme cluster is kept whole.
-    assert_eq!(map_symbol_bullet("e\u{301}x", None), "e\u{301}");
-}
-
 #[test]
 fn shrink_on_overflow() {
     let text = (0..30).map(|i| format!("Line number {i}")).collect::<Vec<_>>().join("\n");
@@ -409,114 +395,3 @@ fn hostile_bidi_input_never_panics() {
         }
     }
 }
-
-/// Width of `word` laid out in a run with `baseline` (0 = normal, 0.3 = superscript …).
-fn run_width(word: &str, baseline: Option<f64>) -> f64 {
-    let mut run = Run::new(word);
-    run.props.size = Some(24.0);
-    run.props.baseline = baseline;
-    let (p, sh) = bidi_setup(vec![run], 2000.0, false, Align::Left);
-    let l = lay(&p, &sh, 2000.0, 300.0);
-    let line = &l.lines[0];
-    line.caret_x.last().unwrap() - line.caret_x.first().unwrap()
-}
-
-#[test]
-fn superscript_and_subscript_advance_at_their_drawn_size() {
-    // The glyphs are drawn at two thirds of the size; advancing by the full size spread the
-    // letters apart ("s u p e r").
-    let normal = run_width("superscript", None);
-    for b in [Some(0.3), Some(-0.25)] {
-        let w = run_width("superscript", b);
-        assert!((w / normal - SUB_SUPER).abs() < 0.02, "{b:?}: {w} vs {normal}");
-    }
-}
-
-#[test]
-fn superscript_glyphs_sit_inside_their_cells() {
-    let mut run = Run::new("super");
-    run.props.size = Some(24.0);
-    run.props.baseline = Some(0.3);
-    let (p, sh) = bidi_setup(vec![run], 2000.0, false, Align::Left);
-    let l = lay(&p, &sh, 2000.0, 300.0);
-    let line = &l.lines[0];
-    let r = l.runs.iter().find(|r| !r.cells.is_empty()).unwrap();
-    assert!((r.size - 24.0 * SUB_SUPER).abs() < 1e-6);
-    for (g, (ci, _)) in r.glyphs.iter().zip(&r.cells) {
-        let (x0, x1) = line.edges[*ci - line.start];
-        assert!(g.1 >= x0 - 0.01 && g.1 < x1, "glyph at {} outside its cell {x0}..{x1}", g.1);
-    }
-}
-
-/// A wrapping numbered paragraph with `marL` and `indent`; returns (bullet x, first line's text
-/// x, second line's text x).
-fn hanging(margin: f64, indent: f64, bullet: Bullet) -> (Option<f64>, f64, f64) {
-    let text = "Wrapping words go on and on so the paragraph needs at least two or three lines here";
-    let (p, mut sh) = setup(text, 300.0, 300.0);
-    let para = &mut sh.text.as_mut().unwrap().paragraphs[0];
-    para.props.bullet = Some(bullet);
-    para.props.margin_left = Some(margin);
-    para.props.indent = Some(indent);
-    let l = lay(&p, &sh, 300.0, 300.0);
-    assert!(l.lines.len() >= 2, "{} lines", l.lines.len());
-    let bx = l.runs.iter().find(|r| r.cells.is_empty() && !r.glyphs.is_empty()).map(|r| r.glyphs[0].1);
-    (bx, l.lines[0].caret_x[0], l.lines[1].caret_x[0])
-}
-
-#[test]
-fn a_hang_past_the_box_edge_keeps_its_width_on_the_first_line() {
-    // PowerPoint, marL 0 / indent -36pt: the number sits at the box's edge, the first line's text
-    // 36pt in, and the wrapped lines at the margin (observed with PowerPoint's slide export).
-    let num = || Bullet::AutoNum { scheme: "arabicPeriod".into(), start_at: 1 };
-    let (bx, first, rest) = hanging(0.0, -36.0, num());
-    assert!((first - rest - 36.0).abs() < 0.5, "first {first} rest {rest}");
-    assert!((bx.unwrap() - rest).abs() < 0.5, "bullet {bx:?} rest {rest}");
-    // marL 18 / indent -54: number at the edge, first line at 54, the rest at 18.
-    let (bx, first, rest) = hanging(18.0, -54.0, num());
-    assert!((first - rest - 36.0).abs() < 0.5, "first {first} rest {rest}");
-    assert!((rest - bx.unwrap() - 18.0).abs() < 0.5, "bullet {bx:?} rest {rest}");
-    // A character bullet behaves the same.
-    let (_, first, rest) = hanging(0.0, -36.0, Bullet::Char { char: "•".into() });
-    assert!((first - rest - 36.0).abs() < 0.5, "first {first} rest {rest}");
-    // Without a bullet the first line just starts at the edge.
-    let (_, first, rest) = hanging(0.0, -36.0, Bullet::None);
-    assert!((first - rest).abs() < 0.5, "first {first} rest {rest}");
-}
-
-#[test]
-fn an_ordinary_hang_still_puts_the_text_at_the_margin() {
-    let (bx, first, rest) = hanging(36.0, -36.0, Bullet::AutoNum { scheme: "arabicPeriod".into(), start_at: 1 });
-    assert!((first - rest).abs() < 0.5, "first {first} rest {rest}");
-    assert!((rest - bx.unwrap() - 36.0).abs() < 0.5);
-}
-
-#[test]
-fn single_spaced_lines_are_1_2_times_the_size_apart_whatever_the_font() {
-    // PowerPoint spaces single-spaced lines 1.2 × the font size apart in every font, with the
-    // baseline where the font's Windows ascent/descent split puts it (observed on twenty fonts).
-    for size in [18.0, 40.0] {
-        let mut run = Run::new("HHH");
-        run.props.size = Some(size);
-        let (p, mut sh) = bidi_setup(vec![run], 2000.0, false, Align::Left);
-        let t = sh.text.as_mut().unwrap();
-        t.body.autofit = Some(AutoFit::None);
-        let second = t.paragraphs[0].clone();
-        t.paragraphs.push(second.clone());
-        t.paragraphs.push(second);
-        for para in &mut t.paragraphs {
-            para.props.line_spacing = Some(Spacing::Pct(1.0));
-            para.props.space_before = Some(Spacing::Pts(0.0));
-            para.props.space_after = Some(Spacing::Pts(0.0));
-        }
-        let l = lay(&p, &sh, 2000.0, 600.0);
-        assert_eq!(l.lines.len(), 3);
-        // Each line is 1.2 × the size tall (the face is not compared across lines: another
-        // test's thread can load the family between them, see #252).
-        for line in &l.lines {
-            assert!((line.bottom - line.top - size * LINE_PITCH).abs() < 1e-6, "{size}: {}", line.bottom - line.top);
-        }
-        let face = &l.runs[0].face;
-        let first = &l.lines[0];
-        assert!((first.baseline - first.top - size * LINE_PITCH * face.line_split).abs() < 1e-6);
-    }
-}