Docs: update the progress docs for this change

Outlines, dashes, arrowheads and ink strokes were drawn under the full
transform, including the mapping of the group's child coordinate space onto its
box. A group whose children use small legacy child coordinates (scale ~1600)
therefore stroked 0.75 pt lines about 1200 pt wide and covered the slide. Inside
a group the outline is now carried through that mapping and stroked under the
slide-level view, so the line width, dash lengths and arrowhead sizes stay in
points, also for groups scaled unevenly.

Cargo.lock

@@ -1063,6 +1063,7 @@ dependencies = [
  "serde",
  "serde_json",
  "thiserror 2.0.21",
+ "unicode-segmentation",
 ]
 
 [[package]]

ROADMAP.md

@@ -129,11 +129,12 @@ app's JSON control channel (`deckcraft --control PORT`).
 | Date | What landed |
 |---|---|
 | 2026-10-12 | Objects off the slide show and can be selected and moved around it in Normal view, as in PowerPoint; the show, exports and thumbnails still clip to the slide (#270) |
-
 | 2026-10-12 | Korean, Japanese and Chinese input: IME composition shown in place and underlined, one undo step per composition, candidate window at the caret (slide text, notes, fields); interface text (title, notes, outline, sections, comments) borrows installed fonts for scripts the interface fonts lack (#101) |
-
 | 2026-10-12 | Selection Pane like PowerPoint (#133): front-most first, groups fold, drag and drop restacks among siblings, Bring Forward / Send Backward, Show All / Hide All, eye, rename in place, keyboard; Lock (pane padlock, canvas menu) keeps objects from moving, sizing or rotating and round-trips PowerPoint's locking attributes |
+| 2026-10-12 | Text keys like PowerPoint for Windows (#268): Ctrl+arrows and Ctrl+Shift+arrows by word (punctuation, CJK, emoji, RTL), Ctrl+Backspace/Delete with smart spacing, Ctrl+Up/Down by paragraph, Ctrl+Home/End, End on wrapped lines, Ctrl+]/[ and Ctrl+Shift+>/< font size, Shift+F3 case cycle, word and paragraph selection |
+| 2026-10-12 | EMF/WMF pictures draw their text (fonts, alignment, dx advances, escapement, symbol fonts), pattern and hatch brushes, PATBLT and the XOR/AND see-through shadow; legacy OLE objects show their VML preview and ActiveX controls their pictures |
 | 2026-10-12 | WordArt text warps (`prstTxWarp`): all 40 presets drawn, curves fitted to PowerPoint by observation; warp adjusts round-trip |
+| 2026-10-12 | Render: line widths, dashes and arrowheads inside a group no longer scale with the group's child-coordinate mapping, so a group in a small legacy child space (scale about 1600) draws thin lines instead of covering the slide (#233) |
 | 2026-10-10 | Progress docs restructured to the craftrules standard; full re-measure (breadth 79%, ready ~55%, mainstream ~53%, essentials ~62%, alpha). Landed: Animation Painter (#54), Morph geometry outlines (#27), animated GIF playback (#39), hyperlink colour and following links in the show (#37, #45), date fields in their own format (#36), flipped shapes keep readable text (#35), show transition fix (#46), start screen from the Home button (#49), MCP export lists PDF (#65), OmaStore manifest (#57) |
 | 2026-10-09 | v0.4.0 released. UAX #9 bidi and Arabic shaping (#4), Morph with Words and Characters (#5), tables grow to fit and PDF cell text (#14), rotating log file (#7), DX12 default on Windows (#16), H.264/HEVC overflow hardening (#2), PPTX sniffing anywhere in the zip (#19) |
 | 2026-10-08 | v0.2.0 and v0.3.0 released: Windows arm64, Flatpak aarch64, AppImage zsync updates, branded DMG |
@@ -145,6 +146,7 @@ app's JSON control channel (`deckcraft --control PORT`).
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-12 | trivial | Progress log: lines in scaled groups (#233) |
 | 2026-10-10 | minor | Readiness-by-audience table with hours to ~95% for full, mainstream and essentials |
 | 2026-10-10 | minor | Added mainstream practitioner (~53%) and essentials user (~62%); features recomputed from written area weights, ready ~56% → ~55% |
 | 2026-10-10 | minor | Stage checked against the new core-workflow gate: passes, stays alpha |

contributors/people.toml

@@ -37,3 +37,7 @@ sync_github_name = false
 
 [people.Johannesgauss]
 sync_github_name = true
+
+[people.Silvertree2010]
+display_name = "Netter"
+sync_github_name = false

crates/engine/src/cmd/format.rs

@@ -49,7 +49,15 @@ pub fn specs() -> Vec<CommandSpec> {
             color
         ),
         cmd!("format.highlight", "Text Highlight Color", ["Home", "Font"], None, "{color? (absent = none)}", has_text_or_shapes, highlight),
-        cmd!("format.case", "Change Case", ["Home", "Font"], Some("Shift+F3"), "{mode: sentence|lower|upper|title|toggle}", has_text_or_shapes, case),
+        cmd!(
+            "format.case",
+            "Change Case",
+            ["Home", "Font"],
+            Some("Shift+F3"),
+            "{mode?: cycle|sentence|lower|upper|title|toggle} — cycle (Shift+F3, the default) goes lowercase → Capitalize Each Word → UPPERCASE; a caret in a word changes that word",
+            has_text_or_shapes,
+            case
+        ),
         cmd!("format.caps", "Caps", [], None, "{caps: none|small|all}", has_text_or_shapes, caps),
         cmd!(
             "format.spacing",
@@ -328,15 +336,23 @@ fn text_outline(s: &mut Session, p: &Value) -> Result<Value> {
 }
 
 fn case(s: &mut Session, p: &Value) -> Result<Value> {
-    let mode = str_param(p, "mode").unwrap_or("sentence").to_string();
+    let mode = str_param(p, "mode").unwrap_or("cycle").to_string();
     let st = s.doc()?;
     if let Some(t) = st.selection.text.clone() {
-        let (a, b) = t.ordered();
-        if a == b {
-            return ok();
+        let (mut a, mut b) = t.ordered();
+        let body = super::text::body_of(st, &t).cloned().unwrap_or_default();
+        let collapsed = a == b;
+        if collapsed {
+            // Shift+F3 with a bare caret changes the word it is in and puts the caret at its start.
+            let (wa, wb) = ed::word_at(&body, a);
+            let is_word = ed::text_range(&body, wa, wb).chars().any(char::is_alphanumeric);
+            if !(is_word && wa.1 <= a.1 && a.1 < wb.1) {
+                return ok();
+            }
+            (a, b) = (wa, wb);
         }
-        let m = mode.clone();
-        super::text::edit_text(s, move |body, _| {
+        let m = if mode == "cycle" { ed::next_case(&ed::text_range(&body, a, b)).to_string() } else { mode.clone() };
+        super::text::edit_text(s, move |body, t| {
             for pi in a.0..=b.0 {
                 let Some(para) = body.paragraphs.get_mut(pi) else { continue };
                 let n = para.char_len();
@@ -359,9 +375,23 @@ fn case(s: &mut Session, p: &Value) -> Result<Value> {
                     pos += len;
                 }
             }
+            if collapsed {
+                t.anchor = a;
+                t.caret = a;
+            }
         })?;
         return ok();
     }
+    let mode = if mode == "cycle" {
+        let all: String =
+            st.selection.shapes.iter().filter_map(|id| st.shape(*id)).filter_map(|sh| sh.text.as_ref()).map(|t| t.text()).collect::<Vec<_>>().join(
+                "
+",
+            );
+        ed::next_case(&all).to_string()
+    } else {
+        mode
+    };
     edit_shapes(s, &json!({}), "format.case", |sh| {
         if let Some(t) = sh.text.as_mut() {
             for para in &mut t.paragraphs {

crates/engine/src/cmd/text.rs

@@ -39,6 +39,16 @@ pub fn specs() -> Vec<CommandSpec> {
             commit
         ),
         cmd!(noundo "text.move", "Move Insertion Point", [], None, "{to: left|right|up|down|wordLeft|wordRight|lineStart|lineEnd|paraStart|paraEnd|start|end, extend?: bool}", has_text, move_caret),
+        cmd!(
+            "text.delete",
+            "Delete Text",
+            [],
+            Some("Backspace"),
+            "{dir?: backward|forward|wordBackward|wordForward} — the word directions are Ctrl+Backspace/Delete: they work from the start of a selection without deleting it",
+            has_text,
+            delete
+        ),
+        cmd!(noundo "text.move", "Move Insertion Point", [], None, "{to: left|right|up|down|wordLeft|wordRight|lineStart|lineEnd|paraStart|paraEnd|paraUp|paraDown|start|end, extend?: bool} — left/right are on screen: in a right-to-left paragraph left goes forward", has_text, move_caret),
         cmd!(noundo "text.select", "Select Text", [], None, "{anchor: [p, c], caret: [p, c]}", has_text, select),
         cmd!(noundo "text.selectAll", "Select All Text", [], None, "{}", has_text, select_all),
         cmd!(noundo "text.selectWord", "Select Word", [], None, "{at?: [p, c]}", has_text, select_word),
@@ -187,7 +197,9 @@ pub fn caret_line(st: &DocState, t: &TextSel) -> Option<(deckcraft_geom::Point,
         &body,
         &deckcraft_text::Opts { rect: geo.text_rect, fields: &deckcraft_text::NoFields, prompt_color: None, no_shrink: false },
     );
-    let (cx, top, bot) = l.caret(deckcraft_text::Pos { para: t.caret.0, ch: t.caret.1 })?;
+    // After End on a wrapped line the caret is drawn at that line's end.
+    let aff = if t.at_line_end() { deckcraft_text::Affinity::Upstream } else { deckcraft_text::Affinity::Downstream };
+    let (cx, top, bot) = l.caret_drawn(deckcraft_text::Pos { para: t.caret.0, ch: t.caret.1 }, aff)?;
     let m = deckcraft_render::text_transform(x.affine(), geo.text_rect, l.rotation);
     Some((m * deckcraft_geom::Point::new(cx, top), m * deckcraft_geom::Point::new(cx, bot)))
 }
@@ -232,7 +244,7 @@ fn edit(s: &mut Session, p: &Value) -> Result<Value> {
     }
     s.select(|_, sel| {
         sel.shapes = vec![id];
-        sel.text = Some(TextSel { shape: id, anchor: at, caret: at, cell, notes: false });
+        sel.text = Some(TextSel { shape: id, anchor: at, caret: at, cell, notes: false, line_end: None });
     })?;
     Ok(json!({"id": id, "at": [at.0, at.1]}))
 }
@@ -503,13 +515,15 @@ pub(crate) fn delete_dir(s: &mut Session, dir: &str) -> Result<Value> {
     let dir = dir.to_string();
     edit_text(s, move |body, t| {
         let (a, b) = t.ordered();
-        let at = if a != b {
+        let at = if dir == "wordBackward" || dir == "wordForward" {
+            // Ctrl+Backspace/Delete work from the start of a selection and leave the rest of it
+            // (PowerPoint for Windows).
+            ed::delete_word(body, a, dir == "wordForward")
+        } else if a != b {
             ed::delete(body, a, b)
         } else {
             let other = match dir.as_str() {
                 "forward" => ed::char_move(body, a, true),
-                "wordBackward" => ed::word_move(body, a, false),
-                "wordForward" => ed::word_move(body, a, true),
                 _ => {
                     // Backspace at the start of an indented/bulleted paragraph outdents first.
                     if a.1 == 0
@@ -536,7 +550,16 @@ fn delete(s: &mut Session, p: &Value) -> Result<Value> {
     delete_dir(s, str_param(p, "dir").unwrap_or("backward"))
 }
 
+/// Is paragraph `para` right-to-left (its lines run from the right)?
+fn para_rtl(layout: Option<&deckcraft_text::TextLayout>, body: &TextBody, para: usize) -> bool {
+    match layout.and_then(|l| l.lines.iter().find(|x| x.para == para)) {
+        Some(line) => line.rtl,
+        None => body.paragraphs.get(para).and_then(|x| x.props.rtl).unwrap_or(false),
+    }
+}
+
 fn move_caret(s: &mut Session, p: &Value) -> Result<Value> {
+    use deckcraft_text::Affinity;
     let to = str_param(p, "to").unwrap_or("right").to_string();
     let extend = bool_or(p, "extend", false);
     let st = s.doc()?;
@@ -545,27 +568,44 @@ fn move_caret(s: &mut Session, p: &Value) -> Result<Value> {
     let layout = layout_for(st, &t);
     let lp = |c: Pos| deckcraft_text::Pos { para: c.0, ch: c.1 };
     let caret = t.caret;
+    let aff = if t.at_line_end() { Affinity::Upstream } else { Affinity::Downstream };
+    // Left and right are on screen: in a right-to-left paragraph left goes forward in the text.
+    let rtl = para_rtl(layout.as_ref(), &body, caret.0);
+    let to = match (to.as_str(), rtl) {
+        ("left", true) => "right",
+        ("right", true) => "left",
+        ("wordLeft", true) => "wordRight",
+        ("wordRight", true) => "wordLeft",
+        (x, _) => x,
+    }
+    .to_string();
     let collapse_to = |left: bool| if left { t.ordered().0 } else { t.ordered().1 };
+    let mut upstream = false;
     let new = match to.as_str() {
         "left" if t.is_range() && !extend => collapse_to(true),
         "right" if t.is_range() && !extend => collapse_to(false),
         "left" => ed::char_move(&body, caret, false),
         "right" => ed::char_move(&body, caret, true),
-        "wordLeft" => ed::word_move(&body, caret, false),
-        "wordRight" => ed::word_move(&body, caret, true),
+        // Ctrl+arrows with a selection go on from its start (left) or end (right).
+        "wordLeft" => ed::word_move(&body, if extend { caret } else { collapse_to(true) }, false),
+        "wordRight" => ed::word_move(&body, if extend { caret } else { collapse_to(false) }, true),
         "paraStart" => (caret.0, 0),
         "paraEnd" => (caret.0, body.paragraphs.get(caret.0).map(|x| x.char_len()).unwrap_or(0)),
+        "paraUp" => ed::para_up(&body, caret),
+        "paraDown" => ed::para_down(&body, caret),
         "start" => (0, 0),
         "end" => ed::end(&body),
         "up" | "down" | "lineStart" | "lineEnd" => match &layout {
             Some(l) => {
-                let x = l.caret(lp(caret)).map(|c| c.0).unwrap_or(0.0);
-                let r = match to.as_str() {
-                    "up" => l.vertical(lp(caret), false, x),
-                    "down" => l.vertical(lp(caret), true, x),
-                    "lineStart" => l.line_bounds(lp(caret)).0,
-                    _ => l.line_bounds(lp(caret)).1,
+                let x = l.caret_drawn(lp(caret), aff).map(|c| c.0).unwrap_or(0.0);
+                let (r, a) = match to.as_str() {
+                    "up" => l.vertical_affine(lp(caret), aff, false, x),
+                    "down" => l.vertical_affine(lp(caret), aff, true, x),
+                    "lineStart" => (l.line_bounds_affine(lp(caret), aff).0, Affinity::Downstream),
+                    // End stays on its line: after a soft wrap the caret sits at the line's end.
+                    _ => l.line_end_caret(lp(caret), aff),
                 };
+                upstream = a == Affinity::Upstream;
                 (r.para, r.ch)
             }
             None => match to.as_str() {
@@ -581,12 +621,13 @@ fn move_caret(s: &mut Session, p: &Value) -> Result<Value> {
     s.select(|_, sel| {
         if let Some(tt) = sel.text.as_mut() {
             tt.caret = new;
+            tt.line_end = if upstream { Some(new) } else { None };
             if !extend {
                 tt.anchor = new;
             }
         }
     })?;
-    Ok(json!({"caret": [new.0, new.1]}))
+    Ok(json!({"caret": [new.0, new.1], "lineEnd": upstream}))
 }
 
 fn select(s: &mut Session, p: &Value) -> Result<Value> {
@@ -633,11 +674,14 @@ fn select_para(s: &mut Session, p: &Value) -> Result<Value> {
     let st = s.doc()?;
     let t = st.selection.text.clone().ok_or_else(|| bad("text.selectParagraph", "not editing text"))?;
     let at = pos_param(p, "at").unwrap_or(t.caret);
-    let n = body_of(st, &t).and_then(|b| b.paragraphs.get(at.0)).map(|x| x.char_len()).unwrap_or(0);
+    let body = body_of(st, &t);
+    let n = body.and_then(|b| b.paragraphs.get(at.0)).map(|x| x.char_len()).unwrap_or(0);
+    // The paragraph mark is part of the paragraph (PowerPoint's triple-click selects it too).
+    let end = if body.is_some_and(|b| at.0 + 1 < b.paragraphs.len()) { (at.0 + 1, 0) } else { (at.0, n) };
     s.select(|_, sel| {
         if let Some(t) = sel.text.as_mut() {
             t.anchor = (at.0, 0);
-            t.caret = (at.0, n);
+            t.caret = end;
         }
     })?;
     ok()

crates/engine/src/keys.rs

@@ -20,6 +20,30 @@ pub fn shortcut_matches(shortcut: &str, key: &str, mods: Mods) -> bool {
     k.eq_ignore_ascii_case(key) && (has("cmd") || has("ctrl")) == mods.cmd && has("shift") == mods.shift && (has("alt") || has("option")) == mods.alt
 }
 
+/// A key name in one spelling: lower case, `ArrowLeft` → `left`, and egui's names for
+/// punctuation keys (`Period`, `CloseBracket`…) → the character, so `Cmd+Shift+.` matches the
+/// key egui reports for Ctrl+Shift+> and `Cmd+]` the one for Ctrl+].
+pub fn key_token(key: &str) -> String {
+    let k = key.to_ascii_lowercase();
+    let k = k.trim_start_matches("arrow");
+    match k {
+        "period" | ">" => ".",
+        "comma" | "<" => ",",
+        "openbracket" | "{" => "[",
+        "closebracket" | "}" => "]",
+        "equals" => "=",
+        "minus" => "-",
+        "plus" => "+",
+        "slash" => "/",
+        "backslash" => "\\",
+        "semicolon" => ";",
+        "quote" => "'",
+        "backtick" => "`",
+        other => other,
+    }
+    .to_string()
+}
+
 impl Session {
     /// Handle one key press. `key` is a name (`Enter`, `Escape`, `Backspace`, `Delete`, `Tab`,
     /// `ArrowLeft`…, `Home`, `End`, `PageUp`, `PageDown`, `F5`) or a character (`b`, `]`).
@@ -28,21 +52,17 @@ impl Session {
         self.end_composition();
         let editing = self.active().is_some_and(|d| d.selection.text.is_some());
         let has_shapes = self.active().is_some_and(|d| !d.selection.shapes.is_empty());
-        let k = key.to_ascii_lowercase();
-        let k = k.trim_start_matches("arrow");
+        let k = key_token(key);
+        let k = k.as_str();
         if self.tool.drawing_freeform() && matches!(k, "enter" | "return" | "escape") {
             return self.finish_freeform(false);
         }
+        if editing && let Some((id, params)) = self.text_key(k, mods) {
+            let r = self.execute(id, &params)?;
+            return Ok(json!({"handled": true, "command": id, "result": r}));
+        }
         if editing && !mods.cmd {
             let r = match k {
-                "left" => Some(self.execute("text.move", &json!({"to": if mods.alt { "wordLeft" } else { "left" }, "extend": mods.shift}))),
-                "right" => Some(self.execute("text.move", &json!({"to": if mods.alt { "wordRight" } else { "right" }, "extend": mods.shift}))),
-                "up" => Some(self.execute("text.move", &json!({"to": if mods.alt { "paraStart" } else { "up" }, "extend": mods.shift}))),
-                "down" => Some(self.execute("text.move", &json!({"to": if mods.alt { "paraEnd" } else { "down" }, "extend": mods.shift}))),
-                "home" => Some(self.execute("text.move", &json!({"to": "lineStart", "extend": mods.shift}))),
-                "end" => Some(self.execute("text.move", &json!({"to": "lineEnd", "extend": mods.shift}))),
-                "backspace" => Some(self.execute("text.delete", &json!({"dir": if mods.alt { "wordBackward" } else { "backward" }}))),
-                "delete" => Some(self.execute("text.delete", &json!({"dir": if mods.alt { "wordForward" } else { "forward" }}))),
                 "enter" | "return" => Some(self.execute("text.insert", &json!({"text": if mods.shift { "\u{b}" } else { "\n" }}))),
                 "escape" | "esc" => Some(self.execute("text.exit", &json!({}))),
                 "tab" => {
@@ -117,6 +137,10 @@ impl Session {
         }
         // Shortcuts from the registry.
         let key_name = match k {
+            "left" => "Left",
+            "right" => "Right",
+            "up" => "Up",
+            "down" => "Down",
             "enter" | "return" => "Enter",
             "escape" | "esc" => "Escape",
             "delete" => "Delete",
@@ -127,7 +151,7 @@ impl Session {
             "end" => "End",
             "tab" => "Tab",
             "space" | " " => "Space",
-            _ => key,
+            _ => k,
         };
         let found = crate::command_specs().iter().find(|c| c.shortcut.is_some_and(|s| shortcut_matches(s, key_name, mods))).map(|c| c.id);
         if let Some(id) = found {
@@ -137,6 +161,50 @@ impl Session {
         Ok(json!({"handled": false}))
     }
 
+    /// The text-editing command for a navigation or deletion key while editing text, by
+    /// platform: Ctrl (Windows, Linux) or Option (Mac) moves and deletes by word; Ctrl+Up/Down
+    /// moves by paragraph; Ctrl+Home/End (Cmd+Up/Down on the Mac) go to the ends of the text and
+    /// Cmd+Left/Right on the Mac to the ends of the line. Shift extends the selection.
+    fn text_key(&self, k: &str, mods: Mods) -> Option<(&'static str, Value)> {
+        let word = if self.mac_keys { mods.alt && !mods.cmd } else { mods.cmd && !mods.alt };
+        let mac_cmd = self.mac_keys && mods.cmd && !mods.alt;
+        if mods.cmd && !mods.alt && !mods.shift {
+            // Ctrl+] / Ctrl+[ grow and shrink the font, like Ctrl+Shift+> / <.
+            match k {
+                "]" => return Some(("format.grow", json!({}))),
+                "[" => return Some(("format.shrink", json!({}))),
+                _ => {}
+            }
+        }
+        let plain = !mods.cmd && !mods.alt;
+        let to = match k {
+            "left" if word => "wordLeft",
+            "right" if word => "wordRight",
+            "left" if mac_cmd => "lineStart",
+            "right" if mac_cmd => "lineEnd",
+            "left" if plain => "left",
+            "right" if plain => "right",
+            "up" if mac_cmd => "start",
+            "down" if mac_cmd => "end",
+            "up" if word && self.mac_keys => "paraStart",
+            "down" if word && self.mac_keys => "paraEnd",
+            "up" if word => "paraUp",
+            "down" if word => "paraDown",
+            "up" if plain => "up",
+            "down" if plain => "down",
+            "home" if mods.cmd && !mods.alt => "start",
+            "end" if mods.cmd && !mods.alt => "end",
+            "home" if plain => "lineStart",
+            "end" if plain => "lineEnd",
+            "backspace" if word => return Some(("text.delete", json!({"dir": "wordBackward"}))),
+            "delete" if word => return Some(("text.delete", json!({"dir": "wordForward"}))),
+            "backspace" if plain => return Some(("text.delete", json!({"dir": "backward"}))),
+            "delete" if plain => return Some(("text.delete", json!({"dir": "forward"}))),
+            _ => return None,
+        };
+        Some(("text.move", json!({"to": to, "extend": mods.shift})))
+    }
+
     /// Type text: into the text being edited, or (a shape selected) start editing it.
     pub fn type_text(&mut self, text: &str) -> Result<Value> {
         let st = self.doc()?;

crates/engine/src/lib.rs

@@ -68,6 +68,10 @@ pub struct TextSel {
     /// Editing the slide's speaker notes (shape is ignored).
     #[serde(default)]
     pub notes: bool,
+    /// The caret position that sits at the end of a wrapped line (after End) rather than at the
+    /// start of the next line. Ignored once the caret moves anywhere else.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub line_end: Option<(usize, usize)>,
 }
 
 impl TextSel {
@@ -77,6 +81,10 @@ impl TextSel {
     pub fn ordered(&self) -> ((usize, usize), (usize, usize)) {
         if self.anchor <= self.caret { (self.anchor, self.caret) } else { (self.caret, self.anchor) }
     }
+    /// Is the caret drawn at the end of the line before (upstream), not the start of the next?
+    pub fn at_line_end(&self) -> bool {
+        self.line_end == Some(self.caret)
+    }
 }
 
 /// Which shape tree is being edited: slides (normal), or a master/layout (Slide Master view).
@@ -339,6 +347,10 @@ pub struct Session {
     pub media_status: std::collections::HashMap<ShapeId, MediaStatus>,
     /// Animated GIF pictures paused with `media.gifPlay` (the others play).
     pub gif_paused: std::collections::HashSet<ShapeId>,
+    /// Text keys follow the Mac (Option+arrows move by word, Cmd+arrows to the line or text
+    /// ends) instead of Windows and Linux (Ctrl+arrows by word or paragraph). Defaults to the
+    /// platform DeckCraft was built for.
+    pub mac_keys: bool,
 }
 
 impl Default for Session {
@@ -366,6 +378,7 @@ impl Session {
             recovery_dir: None,
             media_status: Default::default(),
             gif_paused: Default::default(),
+            mac_keys: cfg!(target_os = "macos"),
         }
     }
     /// A session with one new presentation open.
@@ -492,6 +505,10 @@ impl Session {
     pub fn select(&mut self, f: impl FnOnce(&Presentation, &mut Selection)) -> Result<()> {
         let st = self.doc_mut()?;
         let doc = st.doc.clone();
+        // A caret placed anywhere starts downstream; only End puts it back at a line's end.
+        if let Some(t) = st.selection.text.as_mut() {
+            t.line_end = None;
+        }
         f(&doc, &mut st.selection);
         clamp_selection(st);
         st.revision += 1;
@@ -536,3 +553,5 @@ pub(crate) fn push_undo(st: &mut DocState, e: HistoryEntry) {
 
 #[cfg(test)]
 mod tests;
+#[cfg(test)]
+mod tests_keys;

crates/engine/src/tests_keys.rs

@@ -0,0 +1,404 @@
+//! Text-editing keys driven through `Session::key`, as the keyboard, control channel and MCP
+//! send them. Every expectation is PowerPoint for Windows' observed behaviour unless it says Mac.
+
+use serde_json::{Value, json};
+
+use crate::Session;
+use crate::tools::Mods;
+
+const NONE: Mods = Mods { shift: false, alt: false, cmd: false };
+const CTRL: Mods = Mods { shift: false, alt: false, cmd: true };
+const CTRL_SHIFT: Mods = Mods { shift: true, alt: false, cmd: true };
+const SHIFT: Mods = Mods { shift: true, alt: false, cmd: false };
+const ALT: Mods = Mods { shift: false, alt: true, cmd: false };
+
+type Pos = (usize, usize);
+
+/// A session editing a new text box holding `text` (Windows keys), caret at `at`.
+fn editing(text: &str, at: Pos) -> (Session, u32) {
+    editing_in(text, at, [60.0, 60.0, 600.0, 300.0])
+}
+
+fn editing_in(text: &str, at: Pos, rect: [f64; 4]) -> (Session, u32) {
+    let mut s = Session::with_new();
+    s.mac_keys = false;
+    s.prefs.autocorrect = false;
+    s.prefs.smart_quotes = false;
+    s.execute("insert.textBox", &json!({"rect": rect, "text": "x"})).unwrap();
+    let id = s.doc().unwrap().selection.shapes[0].0;
+    s.execute("text.set", &json!({"id": id, "text": text})).unwrap();
+    s.execute("text.edit", &json!({"id": id, "at": [at.0, at.1]})).unwrap();
+    (s, id)
+}
+
+fn sel(s: &Session) -> (Pos, Pos) {
+    let t = s.doc().unwrap().selection.text.clone().unwrap();
+    (t.anchor, t.caret)
+}
+
+fn caret(s: &Session) -> Pos {
+    sel(s).1
+}
+
+fn press(s: &mut Session, key: &str, mods: Mods) -> Value {
+    let r = s.key(key, mods).unwrap();
+    assert_eq!(r["handled"], true, "{key} {mods:?} not handled");
+    r
+}
+
+fn text(s: &mut Session, id: u32) -> String {
+    s.execute("text.get", &json!({"id": id})).unwrap()["text"].as_str().unwrap().to_string()
+}
+
+/// Press `key` until the caret stops moving; the carets visited (in the first paragraph).
+fn walk(s: &mut Session, key: &str, mods: Mods) -> Vec<usize> {
+    let mut out = vec![caret(s).1];
+    for _ in 0..200 {
+        let before = caret(s);
+        press(s, key, mods);
+        if caret(s) == before {
+            break;
+        }
+        out.push(caret(s).1);
+    }
+    out
+}
+
+#[test]
+fn ctrl_arrows_stop_where_powerpoint_does() {
+    let t = "Hello, world!  Foo...bar baz-qux it's 3.14 e.g. a_b x@y.com (end) \"q\" end.";
+    let stops = vec![0, 5, 7, 12, 15, 18, 21, 25, 33, 38, 43, 44, 45, 46, 48, 49, 50, 52, 53, 54, 55, 56, 60, 61, 64, 66, 67, 68, 70, 73, 74];
+    let (mut s, _) = editing(t, (0, 0));
+    assert_eq!(walk(&mut s, "ArrowRight", CTRL), stops);
+    let mut back = stops.clone();
+    back.reverse();
+    assert_eq!(walk(&mut s, "ArrowLeft", CTRL), back);
+}
+
+#[test]
+fn ctrl_arrows_over_cjk_rtl_emoji_and_marks() {
+    let (mut s, _) = editing("日本語のテキスト abc 한국어", (0, 0));
+    assert_eq!(walk(&mut s, "Right", CTRL), vec![0, 1, 2, 3, 4, 5, 6, 7, 9, 13, 14, 15, 16]);
+    // Arabic and Hebrew words inside a left-to-right paragraph: in logical order.
+    let (mut s, _) = editing("Hello مرحبا بالعالم world שלום end", (0, 0));
+    assert_eq!(walk(&mut s, "Right", CTRL), vec![0, 6, 12, 20, 26, 31, 34]);
+    // An emoji ZWJ sequence and a combining mark are never split.
+    let (mut s, _) = editing("e\u{301}te 👨\u{200d}👩\u{200d}👧 x", (0, 0));
+    assert_eq!(walk(&mut s, "Right", CTRL), vec![0, 5, 11, 12]);
+    assert_eq!(walk(&mut s, "Left", CTRL), vec![12, 11, 5, 0]);
+}
+
+#[test]
+fn ctrl_arrows_cross_paragraphs_line_breaks_and_tabs() {
+    let (mut s, id) = editing("One two\nThree four\n\nFive", (0, 0));
+    let mut seen = vec![caret(&s)];
+    for _ in 0..9 {
+        press(&mut s, "Right", CTRL);
+        seen.push(caret(&s));
+    }
+    assert_eq!(seen, vec![(0, 0), (0, 4), (0, 7), (1, 0), (1, 6), (1, 10), (2, 0), (3, 0), (3, 4), (3, 4)]);
+    // A line break and a tab are stops of their own.
+    s.execute("text.set", &json!({"id": id, "text": "x"})).unwrap();
+    s.execute("text.edit", &json!({"id": id, "at": [0, 0]})).unwrap();
+    s.execute("text.selectAll", &json!({})).unwrap();
+    s.execute("text.insert", &json!({"text": "Five\u{b}six seven\tTab   x"})).unwrap();
+    s.execute("text.move", &json!({"to": "start"})).unwrap();
+    assert_eq!(walk(&mut s, "Right", CTRL), vec![0, 4, 5, 9, 14, 15, 21, 22]);
+}
+
+#[test]
+fn ctrl_shift_arrows_extend_by_words() {
+    let (mut s, _) = editing("Hello world  foo, bar\nnext para", (0, 2));
+    let mut carets = vec![];
+    for _ in 0..6 {
+        press(&mut s, "Right", CTRL_SHIFT);
+        carets.push(sel(&s));
+    }
+    let a = (0, 2);
+    assert_eq!(carets.iter().map(|x| x.1).collect::<Vec<_>>(), vec![(0, 6), (0, 13), (0, 16), (0, 18), (0, 21), (1, 0)]);
+    assert!(carets.iter().all(|x| x.0 == a));
+    let mut back = vec![];
+    for _ in 0..7 {
+        press(&mut s, "Left", CTRL_SHIFT);
+        back.push(caret(&s));
+    }
+    assert_eq!(back, vec![(0, 21), (0, 18), (0, 16), (0, 13), (0, 6), (0, 0), (0, 0)]);
+    assert_eq!(sel(&s).0, a);
+    // From a caret inside a word going left: the word's start, then on.
+    let (mut s, _) = editing("Hello world  foo, bar\nnext para", (1, 2));
+    press(&mut s, "Left", CTRL_SHIFT);
+    press(&mut s, "Left", CTRL_SHIFT);
+    assert_eq!(sel(&s), ((1, 2), (0, 21)));
+}
+
+#[test]
+fn ctrl_arrows_leave_a_selection_from_its_ends() {
+    for (anchor, caret_at) in [((0, 2), (0, 7)), ((0, 7), (0, 2))] {
+        let (mut s, _) = editing("Hello world  foo, bar", anchor);
+        s.execute("text.select", &json!({"anchor": [anchor.0, anchor.1], "caret": [caret_at.0, caret_at.1]})).unwrap();
+        press(&mut s, "Right", CTRL);
+        assert_eq!(sel(&s), ((0, 13), (0, 13)));
+        s.execute("text.select", &json!({"anchor": [anchor.0, anchor.1], "caret": [caret_at.0, caret_at.1]})).unwrap();
+        press(&mut s, "Left", CTRL);
+        assert_eq!(sel(&s), ((0, 0), (0, 0)));
+    }
+}
+
+#[test]
+fn ctrl_backspace_and_delete() {
+    let (mut s, id) = editing("Hello world  foo, bar\nnext para", (0, 13));
+    press(&mut s, "Backspace", CTRL);
+    assert_eq!(text(&mut s, id), "Hello foo, bar\nnext para");
+    assert_eq!(caret(&s), (0, 6));
+    press(&mut s, "Delete", CTRL);
+    assert_eq!(text(&mut s, id), "Hello , bar\nnext para".replace(" ,", ","));
+    assert_eq!(caret(&s), (0, 5));
+    // At a paragraph's ends they join paragraphs.
+    s.execute("text.move", &json!({"to": "paraEnd"})).unwrap();
+    press(&mut s, "Delete", CTRL);
+    assert_eq!(text(&mut s, id), "Hello, barnext para");
+    // A selection is not deleted: the word goes from its start (PowerPoint for Windows).
+    let (mut s, id) = editing("Hello world", (0, 2));
+    s.execute("text.select", &json!({"anchor": [0, 2], "caret": [0, 7]})).unwrap();
+    press(&mut s, "Backspace", CTRL);
+    assert_eq!((text(&mut s, id), sel(&s)), ("llo world".into(), ((0, 0), (0, 0))));
+    let (mut s, id) = editing("Hello world", (0, 7));
+    s.execute("text.select", &json!({"anchor": [0, 7], "caret": [0, 2]})).unwrap();
+    press(&mut s, "Delete", CTRL);
+    assert_eq!((text(&mut s, id), sel(&s)), ("He world".into(), ((0, 2), (0, 2))));
+    // It is one undo step.
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert_eq!(text(&mut s, id), "Hello world");
+}
+
+#[test]
+fn ctrl_up_down_move_by_paragraph() {
+    let t = "First paragraph that is long enough to wrap in this box.\nSecond\n\nFourth para";
+    let (mut s, _) = editing_in(t, (0, 5), [60.0, 60.0, 200.0, 300.0]);
+    let mut seen = vec![];
+    for _ in 0..5 {
+        press(&mut s, "Down", CTRL);
+        seen.push(caret(&s));
+    }
+    assert_eq!(seen, vec![(1, 0), (2, 0), (3, 0), (3, 11), (3, 11)]);
+    s.execute("text.move", &json!({"to": "end"})).unwrap();
+    press(&mut s, "Left", NONE);
+    let mut seen = vec![];
+    for _ in 0..5 {
+        press(&mut s, "Up", CTRL);
+        seen.push(caret(&s));
+    }
+    assert_eq!(seen, vec![(3, 0), (2, 0), (1, 0), (0, 0), (0, 0)]);
+    // With Shift they extend; back past the anchor the selection flips.
+    s.execute("text.edit", &json!({"at": [0, 5]})).unwrap();
+    press(&mut s, "Down", CTRL_SHIFT);
+    press(&mut s, "Down", CTRL_SHIFT);
+    assert_eq!(sel(&s), ((0, 5), (2, 0)));
+    press(&mut s, "Up", CTRL_SHIFT);
+    press(&mut s, "Up", CTRL_SHIFT);
+    assert_eq!(sel(&s), ((0, 5), (0, 0)));
+}
+
+#[test]
+fn home_end_and_ctrl_home_end() {
+    let t = "First paragraph that is long enough to wrap across several lines in this narrow box.\nSecond";
+    let (mut s, _) = editing_in(t, (0, 0), [60.0, 60.0, 160.0, 300.0]);
+    let st = s.doc().unwrap();
+    let ts = st.selection.text.clone().unwrap();
+    let layout = crate::cmd::text::layout_for(st, &ts).unwrap();
+    let lines: Vec<(usize, usize)> = layout.lines.iter().filter(|l| l.para == 0).map(|l| (l.start, l.end)).collect();
+    assert!(lines.len() >= 3, "{lines:?}");
+    let (l1, l2) = (lines[1], lines[2]);
+    // End goes past a wrapped line's trailing space, to where the next line starts, as in
+    // PowerPoint, and the caret stays drawn on the line it ended.
+    let next = lines[2].0;
+    s.execute("text.edit", &json!({"at": [0, l1.0 + 2]})).unwrap();
+    press(&mut s, "Home", NONE);
+    assert_eq!(caret(&s), (0, l1.0));
+    press(&mut s, "End", NONE);
+    assert_eq!(caret(&s), (0, next));
+    assert!(s.doc().unwrap().selection.text.as_ref().unwrap().at_line_end());
+    let drawn = |s: &Session| {
+        let st = s.doc().unwrap();
+        let ts = st.selection.text.clone().unwrap();
+        let l = crate::cmd::text::layout_for(st, &ts).unwrap();
+        let aff = if ts.at_line_end() { deckcraft_text::Affinity::Upstream } else { deckcraft_text::Affinity::Downstream };
+        l.caret_drawn(deckcraft_text::Pos { para: ts.caret.0, ch: ts.caret.1 }, aff).unwrap()
+    };
+    let line1_top = layout.lines.iter().filter(|l| l.para == 0).nth(1).unwrap().top;
+    assert_eq!(drawn(&s).1, line1_top);
+    // End again stays on the line; Home goes back to its start, not the next line's.
+    press(&mut s, "End", NONE);
+    assert_eq!(caret(&s), (0, next));
+    press(&mut s, "Home", SHIFT);
+    assert_eq!(sel(&s), ((0, next), (0, l1.0)));
+    press(&mut s, "End", SHIFT);
+    assert_eq!(sel(&s), ((0, next), (0, next)));
+    assert_eq!(drawn(&s).1, line1_top);
+    // Down from a line's end lands on the next line, not two lines down.
+    press(&mut s, "Down", NONE);
+    let c = caret(&s);
+    assert!(c.1 > l2.0 && c.1 <= l2.1, "{c:?} not on line {l2:?}");
+    // The caret is drawn at the end of the line it belongs to.
+    s.execute("text.move", &json!({"to": "lineEnd"})).unwrap();
+    let ts = s.doc().unwrap().selection.text.clone().unwrap();
+    assert!(ts.at_line_end());
+    // Ctrl+Home / Ctrl+End, with Shift extending.
+    press(&mut s, "End", CTRL);
+    assert_eq!(caret(&s), (1, 6));
+    press(&mut s, "Home", CTRL_SHIFT);
+    assert_eq!(sel(&s), ((1, 6), (0, 0)));
+    press(&mut s, "Home", CTRL);
+    press(&mut s, "End", CTRL_SHIFT);
+    assert_eq!(sel(&s), ((0, 0), (1, 6)));
+    // A caret placed anywhere else is drawn at the start of its line again.
+    s.execute("text.select", &json!({"anchor": [0, next], "caret": [0, next]})).unwrap();
+    assert!(!s.doc().unwrap().selection.text.as_ref().unwrap().at_line_end());
+    assert!(drawn(&s).1 > line1_top);
+}
+
+#[test]
+fn right_to_left_paragraphs_swap_left_and_right() {
+    let (mut s, _) = editing("مرحبا بالعالم hello world", (0, 0));
+    s.execute("format.rtl", &json!({"on": true})).unwrap();
+    // Ctrl+Left goes forward in a right-to-left paragraph, Ctrl+Right back.
+    assert_eq!(walk(&mut s, "Left", CTRL), vec![0, 6, 14, 20, 25]);
+    assert_eq!(walk(&mut s, "Right", CTRL), vec![25, 20, 14, 6, 0]);
+    press(&mut s, "Left", NONE);
+    assert_eq!(caret(&s), (0, 1));
+    press(&mut s, "Left", CTRL_SHIFT);
+    assert_eq!(sel(&s), ((0, 1), (0, 6)));
+}
+
+#[test]
+fn mac_keys() {
+    let (mut s, id) = editing("Hello world foo\nnext", (0, 8));
+    s.mac_keys = true;
+    press(&mut s, "Right", ALT);
+    assert_eq!(caret(&s), (0, 12));
+    press(&mut s, "Left", ALT);
+    assert_eq!(caret(&s), (0, 6));
+    press(&mut s, "Right", CTRL);
+    assert_eq!(caret(&s), (0, 15));
+    press(&mut s, "Left", CTRL);
+    assert_eq!(caret(&s), (0, 0));
+    press(&mut s, "Down", CTRL);
+    assert_eq!(caret(&s), (1, 4));
+    press(&mut s, "Up", CTRL);
+    assert_eq!(caret(&s), (0, 0));
+    s.execute("text.edit", &json!({"id": id, "at": [0, 11]})).unwrap();
+    press(&mut s, "Backspace", ALT);
+    assert_eq!(text(&mut s, id), "Hello  foo\nnext");
+    // Ctrl+arrows aren't word moves on the Mac, nor Alt+arrows on Windows.
+    s.mac_keys = false;
+    let before = caret(&s);
+    let r = s.key("Right", ALT).unwrap();
+    assert_eq!((r["handled"].as_bool(), caret(&s)), (Some(false), before));
+}
+
+#[test]
+fn font_size_keys() {
+    let (mut s, _) = editing("hello wOrld. foo bar", (0, 0));
+    s.execute("text.select", &json!({"anchor": [0, 0], "caret": [0, 5]})).unwrap();
+    let size = |s: &mut Session| s.execute("format.state", &json!({})).unwrap()["size"].as_f64();
+    let base = size(&mut s).unwrap_or(18.0);
+    // egui names the keys `Period`, `Comma`, `CloseBracket`, `OpenBracket`.
+    press(&mut s, "Period", CTRL_SHIFT);
+    let up = size(&mut s).unwrap();
+    assert!(up > base);
+    press(&mut s, "Comma", CTRL_SHIFT);
+    assert_eq!(size(&mut s), Some(base));
+    press(&mut s, "CloseBracket", CTRL);
+    assert_eq!(size(&mut s), Some(up));
+    press(&mut s, "OpenBracket", CTRL);
+    assert_eq!(size(&mut s), Some(base));
+    press(&mut s, ">", CTRL_SHIFT);
+    assert_eq!(size(&mut s), Some(up));
+}
+
+#[test]
+fn bold_italic_underline_and_clear_on_a_caret_in_a_word() {
+    let (mut s, id) = editing("hello wOrld. foo bar", (0, 8));
+    let r = press(&mut s, "b", CTRL);
+    assert_eq!(r["command"], "format.bold");
+    let body = |s: &Session| s.doc().unwrap().shape(deckcraft_model::ShapeId(id)).unwrap().text.clone().unwrap();
+    let runs: Vec<(String, Option<bool>)> = body(&s).paragraphs[0].runs.iter().map(|r| (r.text.clone(), r.props.bold)).collect();
+    assert_eq!(runs.iter().find(|r| r.1 == Some(true)).map(|r| r.0.as_str()), Some("wOrld"));
+    // At a word boundary nothing visible changes.
+    s.execute("text.edit", &json!({"id": id, "at": [0, 5]})).unwrap();
+    press(&mut s, "i", CTRL);
+    assert!(body(&s).paragraphs[0].runs.iter().all(|r| r.props.italic != Some(true)));
+    // Ctrl+Space clears the word's formatting.
+    s.execute("text.edit", &json!({"id": id, "at": [0, 8]})).unwrap();
+    press(&mut s, "Space", CTRL);
+    assert!(body(&s).paragraphs[0].runs.iter().all(|r| r.props.bold != Some(true)));
+    press(&mut s, "u", CTRL);
+    let under: String = body(&s).paragraphs[0].runs.iter().filter(|r| r.props.underline.is_some()).map(|r| r.text.clone()).collect();
+    assert_eq!(under, "wOrld");
+}
+
+#[test]
+fn alignment_keys() {
+    let (mut s, _) = editing("one\ntwo", (0, 1));
+    for (k, want) in [("e", "ctr"), ("r", "r"), ("j", "just"), ("l", "l")] {
+        press(&mut s, k, CTRL);
+        let st = s.execute("format.state", &json!({})).unwrap();
+        assert_eq!(st["align"], want, "Ctrl+{k}");
+    }
+}
+
+#[test]
+fn shift_f3_cycles_case() {
+    let (mut s, id) = editing("hello world", (0, 0));
+    s.execute("text.selectAll", &json!({})).unwrap();
+    let mut seen = vec![];
+    for _ in 0..3 {
+        press(&mut s, "F3", SHIFT);
+        seen.push(text(&mut s, id));
+    }
+    assert_eq!(seen, vec!["Hello World", "HELLO WORLD", "hello world"]);
+    s.execute("text.set", &json!({"id": id, "text": "hello wOrld. foo"})).unwrap();
+    s.execute("text.edit", &json!({"id": id, "at": [0, 8]})).unwrap();
+    press(&mut s, "F3", SHIFT);
+    assert_eq!(text(&mut s, id), "hello WORLD. foo");
+    assert_eq!(sel(&s), ((0, 6), (0, 6)));
+    press(&mut s, "F3", SHIFT);
+    assert_eq!(text(&mut s, id), "hello world. foo");
+}
+
+#[test]
+fn shift_enter_and_word_and_paragraph_selection() {
+    let (mut s, id) = editing("Hello world,  foo bar\nnext", (0, 7));
+    s.execute("text.selectWord", &json!({})).unwrap();
+    assert_eq!(sel(&s), ((0, 6), (0, 11)));
+    s.execute("text.selectWord", &json!({"at": [0, 12]})).unwrap();
+    assert_eq!(sel(&s), ((0, 11), (0, 12)));
+    // Triple-click: the paragraph and its mark.
+    s.execute("text.selectParagraph", &json!({"at": [0, 3]})).unwrap();
+    assert_eq!(sel(&s), ((0, 0), (1, 0)));
+    s.execute("text.selectParagraph", &json!({"at": [1, 1]})).unwrap();
+    assert_eq!(sel(&s), ((1, 0), (1, 4)));
+    s.execute("text.edit", &json!({"id": id, "at": [1, 2]})).unwrap();
+    press(&mut s, "Enter", SHIFT);
+    let b = s.doc().unwrap().shape(deckcraft_model::ShapeId(id)).unwrap().text.clone().unwrap();
+    assert_eq!(b.paragraphs.len(), 2);
+    assert_eq!(b.paragraphs[1].text(), "ne\u{b}xt");
+}
+
+#[test]
+fn keys_never_panic_on_any_text() {
+    let texts = ["", " ", "\u{b}", "\t\t", "👨\u{200d}👩\u{200d}👧", "e\u{301}", "日本", "مرحبا", "a\n\nb", "  x  \n  "];
+    let keys = ["Left", "Right", "Up", "Down", "Home", "End", "Backspace", "Delete"];
+    for t in texts {
+        for k in keys {
+            for m in [CTRL, CTRL_SHIFT, NONE, SHIFT, ALT] {
+                for at in [(0, 0), (0, 1), (5, 5)] {
+                    let (mut s, _) = editing(t, at);
+                    for _ in 0..3 {
+                        let _ = s.key(k, m).unwrap();
+                    }
+                }
+            }
+        }
+    }
+}

crates/metafile/src/canvas.rs

@@ -2,8 +2,11 @@
 //! transform, pen and brush selection through an object table, the DC save stack and path brackets.
 //! Output is device-space items; `lib.rs` maps them into the picture frame.
 
+use std::sync::{Arc, OnceLock};
+
 use crate::dib::Rgba;
 use crate::geom::{Op, P};
+use crate::text::{ETO_CLIPPED, ETO_OPAQUE, Font, TA_UPDATECP, Text, align};
 use crate::{MAX_BYTES, MAX_ITEMS, MAX_OBJECTS, MAX_PATH_OPS, MAX_STACK};
 
 pub(crate) const MM_TEXT: u32 = 1;
@@ -15,9 +18,21 @@ pub(crate) const PS_NULL: u32 = 5;
 pub(crate) const PS_STYLE_MASK: u32 = 0x0F;
 const BS_SOLID: u32 = 0;
 pub(crate) const BS_NULL: u32 = 1;
+pub(crate) const BS_HATCHED: u32 = 2;
+/// BS_PATTERN, BS_DIBPATTERN and BS_DIBPATTERNPT: the brush paints a bitmap tile.
+const BS_PATTERN: u32 = 3;
+const BS_DIBPATTERN: u32 = 5;
+const BS_DIBPATTERNPT: u32 = 6;
 const WINDING: u32 = 2;
-/// SETROP2 mix mode that leaves the destination alone: outlines and fills draw nothing.
+/// SETROP2 mix modes. R2_NOP leaves the destination alone: outlines and fills draw nothing.
+/// R2_XORPEN and R2_MASKPEN draw the classic see-through shadow (XOR a colour, AND a pattern, XOR
+/// the colour again); the others draw as R2_COPYPEN.
+const R2_XORPEN: u32 = 7;
+const R2_MASKPEN: u32 = 9;
 const R2_NOP: u32 = 11;
+const R2_COPYPEN: u32 = 13;
+/// SETBKMODE OPAQUE: text cells and hatch gaps are filled with the background colour.
+const OPAQUE: u32 = 2;
 const PATCOPY: u32 = 0x00F0_0021;
 const BLACKNESS: u32 = 0x0000_0042;
 const WHITENESS: u32 = 0x00FF_0062;
@@ -48,20 +63,78 @@ pub(crate) struct Pen {
     pub color: [u8; 4],
 }
 
-#[derive(Clone, Copy, PartialEq, Debug)]
+#[derive(Clone, PartialEq, Debug)]
 pub(crate) struct Brush {
     pub style: u32,
     pub color: [u8; 4],
+    /// HS_* hatch style of a BS_HATCHED brush.
+    pub hatch: u32,
+    /// The tile of a pattern brush.
+    pub pattern: Option<Arc<Pattern>>,
 }
 
-#[derive(Clone, Copy, Debug)]
+impl Brush {
+    pub fn new(style: u32, color: [u8; 4]) -> Self {
+        Brush { style, color, hatch: 0, pattern: None }
+    }
+
+    /// A pattern brush painting `img`. A monochrome brush paints its dark pixels in the text
+    /// colour and its light ones in the background colour. None for an empty or oversized tile.
+    pub fn pattern(img: Rgba, mono: bool) -> Option<Self> {
+        if img.w == 0 || img.h == 0 || img.w > MAX_TILE_SIDE || img.h > MAX_TILE_SIDE || img.px.len() != img.w * img.h * 4 {
+            return None;
+        }
+        let pattern = Arc::new(Pattern { w: img.w, h: img.h, px: img.px, mono, plain: OnceLock::new() });
+        Some(Brush { style: BS_DIBPATTERNPT, color: [0, 0, 0, 255], hatch: 0, pattern: Some(pattern) })
+    }
+}
+
+/// A pattern brush's tile, top-down RGBA.
+#[derive(PartialEq, Debug)]
+pub(crate) struct Pattern {
+    pub w: usize,
+    pub h: usize,
+    pub px: Vec<u8>,
+    pub mono: bool,
+    /// The tile as drawn when nothing recolours it, shared by every fill with this brush.
+    pub plain: OnceLock<Arc<RawTile>>,
+}
+
+/// Largest pattern tile side kept (GDI brushes are typically 8×8).
+pub(crate) const MAX_TILE_SIDE: usize = 256;
+
+#[derive(Clone, Debug)]
 pub(crate) enum Obj {
     Pen(Pen),
     Brush(Brush),
-    /// Fonts, palettes, pattern brushes and regions: they take a table slot but draw nothing.
+    Font(Arc<LogFont>),
+    /// Palettes and regions: they take a table slot but draw nothing.
     Other,
 }
 
+/// A font object: the neutral [`Font`] and its escapement (tenths of a degree, counter-clockwise),
+/// which the text transform takes.
+#[derive(Debug, Clone, PartialEq, Default)]
+pub(crate) struct LogFont {
+    pub font: Font,
+    pub escapement: f64,
+}
+
+/// A brush tile in device units: `cell` device units per tile pixel, laid from the device origin.
+#[derive(Debug, PartialEq)]
+pub(crate) struct RawTile {
+    pub w: usize,
+    pub h: usize,
+    pub px: Vec<u8>,
+    pub cell: f64,
+}
+
+/// What a fill paints.
+enum Paint {
+    Solid([u8; 4]),
+    Tile(Arc<RawTile>),
+}
+
 /// Converts a COLORREF (0x00BBGGRR) to opaque RGBA.
 pub(crate) fn colorref(c: u32) -> [u8; 4] {
     [(c & 0xFF) as u8, ((c >> 8) & 0xFF) as u8, ((c >> 16) & 0xFF) as u8, 255]
@@ -166,8 +239,34 @@ fn ratio(num: f64, den: f64) -> f64 {
 
 /// Output of drawing, in device units. Path points are already mapped; `lib.rs` normalises them.
 pub(crate) enum Raw {
-    Path { ops: Vec<Op>, fill: Option<[u8; 4]>, stroke: Option<([u8; 4], f64)>, even_odd: bool },
-    Bitmap { rect: [f64; 4], img: Rgba },
+    Path {
+        ops: Vec<Op>,
+        fill: Option<[u8; 4]>,
+        stroke: Option<([u8; 4], f64)>,
+        even_odd: bool,
+    },
+    /// A path filled with a repeating tile.
+    Pattern {
+        ops: Vec<Op>,
+        even_odd: bool,
+        tile: Arc<RawTile>,
+    },
+    Bitmap {
+        rect: [f64; 4],
+        img: Rgba,
+    },
+    /// Text whose transform and clip are in device units.
+    Text(Box<Text>),
+}
+
+/// Text drawing state: colours, background mode, alignment and the selected font.
+#[derive(Clone)]
+struct TextState {
+    color: [u8; 4],
+    bk_color: [u8; 4],
+    bk_opaque: bool,
+    align: u32,
+    font: Option<Arc<LogFont>>,
 }
 
 #[derive(Clone)]
@@ -176,7 +275,8 @@ struct Saved {
     pen: Pen,
     brush: Brush,
     even_odd: bool,
-    nop: bool,
+    rop2: u32,
+    text: TextState,
 }
 
 pub(crate) struct Canvas {
@@ -193,8 +293,13 @@ pub(crate) struct Canvas {
     pen: Pen,
     brush: Brush,
     even_odd: bool,
-    /// The mix mode is R2_NOP: shapes draw nothing.
-    nop: bool,
+    /// SETROP2 mix mode.
+    rop2: u32,
+    /// The colour of the last fill drawn with R2_XORPEN, for the see-through shadow idiom.
+    xor_color: Option<[u8; 4]>,
+    text: TextState,
+    /// Device units per pattern-brush pixel: brushes are laid out in 96-dpi pixels.
+    pub pattern_px: f64,
     pos: P,
     in_path: bool,
     path: Vec<Op>,
@@ -212,9 +317,12 @@ impl Canvas {
             used: 0,
             objects: Vec::new(),
             pen: Pen { style: 0, width: 0.0, color: [0, 0, 0, 255] },
-            brush: Brush { style: BS_SOLID, color: [255, 255, 255, 255] },
+            brush: Brush::new(BS_SOLID, [255, 255, 255, 255]),
             even_odd: true,
-            nop: false,
+            rop2: R2_COPYPEN,
+            xor_color: None,
+            text: TextState { color: [0, 0, 0, 255], bk_color: [255, 255, 255, 255], bk_opaque: true, align: 0, font: None },
+            pattern_px: 1.0,
             pos: (0.0, 0.0),
             in_path: false,
             path: Vec::new(),
@@ -230,7 +338,14 @@ impl Canvas {
     fn push(&mut self, raw: Raw) {
         let cost = match &raw {
             Raw::Path { ops, .. } => ops.len() * std::mem::size_of::<Op>(),
+            // A tile shared with its brush is counted once (by the brush); one made for this fill
+            // counts here.
+            Raw::Pattern { ops, tile, .. } => {
+                let own = if Arc::strong_count(tile) == 1 { tile.px.len() } else { 0 };
+                ops.len() * std::mem::size_of::<Op>() + 64 + own
+            }
             Raw::Bitmap { img, .. } => img.px.len(),
+            Raw::Text(t) => t.text.len() + t.dx.len() * 4 + t.font.family.len() + 128,
         };
         if self.items.len() >= MAX_ITEMS || self.used.saturating_add(cost) > MAX_BYTES {
             self.full = true;
@@ -288,9 +403,31 @@ impl Canvas {
         self.even_odd = mode != WINDING;
     }
 
-    /// SETROP2: only R2_NOP changes what is drawn (nothing); the other mix modes draw as copy.
+    /// SETROP2. R2_NOP draws nothing; R2_XORPEN and R2_MASKPEN are read as the see-through shadow
+    /// idiom (see [`Canvas::fill_paint`]); the other mix modes draw as copy.
     pub fn set_rop2(&mut self, mode: u32) {
-        self.nop = mode == R2_NOP;
+        self.rop2 = mode;
+    }
+
+    pub fn set_text_color(&mut self, c: u32) {
+        self.text.color = colorref(c);
+    }
+
+    pub fn set_bk_color(&mut self, c: u32) {
+        self.text.bk_color = colorref(c);
+    }
+
+    pub fn set_bk_mode(&mut self, mode: u32) {
+        self.text.bk_opaque = mode == OPAQUE;
+    }
+
+    pub fn set_text_align(&mut self, ta: u32) {
+        self.text.align = ta;
+    }
+
+    /// The character set of the selected font (ANSI without one).
+    pub fn font_charset(&self) -> u8 {
+        self.text.font.as_ref().map_or(0, |f| f.font.charset)
     }
 
     /// EMF SETWORLDTRANSFORM (`mode` 4) and MODIFYWORLDTRANSFORM (1 identity, 2 left, 3 right, 4 set).
@@ -309,7 +446,14 @@ impl Canvas {
     /// could no longer match the file.
     pub fn save_dc(&mut self) {
         if self.saved.len() < MAX_STACK {
-            self.saved.push(Saved { map: self.map, pen: self.pen, brush: self.brush, even_odd: self.even_odd, nop: self.nop });
+            self.saved.push(Saved {
+                map: self.map,
+                pen: self.pen,
+                brush: self.brush.clone(),
+                even_odd: self.even_odd,
+                rop2: self.rop2,
+                text: self.text.clone(),
+            });
         } else {
             self.full = true;
         }
@@ -325,11 +469,21 @@ impl Canvas {
         self.pen = s.pen;
         self.brush = s.brush;
         self.even_odd = s.even_odd;
-        self.nop = s.nop;
+        self.rop2 = s.rop2;
+        self.text = s.text;
     }
 
     /// Stores an object in `slot` (EMF index), or in the first free slot (WMF handle table).
     pub fn add_object(&mut self, slot: Option<usize>, obj: Obj) {
+        // A pattern brush's pixels count against the byte budget like drawn items.
+        if let Obj::Brush(Brush { pattern: Some(p), .. }) = &obj {
+            let cost = p.px.len();
+            if self.used.saturating_add(cost) > MAX_BYTES {
+                self.full = true;
+                return;
+            }
+            self.used += cost;
+        }
         match slot {
             Some(i) if i < MAX_OBJECTS => {
                 if self.objects.len() <= i {
@@ -363,9 +517,10 @@ impl Canvas {
         if i & STOCK != 0 {
             return self.select_stock(i & !STOCK);
         }
-        match self.objects.get(i as usize).copied().flatten() {
+        match self.objects.get(i as usize).cloned().flatten() {
             Some(Obj::Pen(p)) => self.pen = p,
             Some(Obj::Brush(b)) => self.brush = b,
+            Some(Obj::Font(f)) => self.text.font = Some(f),
             Some(Obj::Other) | None => {}
         }
     }
@@ -373,17 +528,19 @@ impl Canvas {
     fn select_stock(&mut self, i: u32) {
         let white = [255, 255, 255, 255];
         let black = [0, 0, 0, 255];
-        let gray = |v: u8| Brush { style: BS_SOLID, color: [v, v, v, 255] };
+        let gray = |v: u8| Brush::new(BS_SOLID, [v, v, v, 255]);
         match i {
-            0 | 18 => self.brush = Brush { style: BS_SOLID, color: white },
+            0 | 18 => self.brush = Brush::new(BS_SOLID, white),
             1 => self.brush = gray(192),
             2 => self.brush = gray(128),
             3 => self.brush = gray(64),
-            4 => self.brush = Brush { style: BS_SOLID, color: black },
-            5 => self.brush = Brush { style: BS_NULL, color: black },
+            4 => self.brush = Brush::new(BS_SOLID, black),
+            5 => self.brush = Brush::new(BS_NULL, black),
             6 => self.pen = Pen { style: 0, width: 0.0, color: white },
             7 | 19 => self.pen = Pen { style: 0, width: 0.0, color: black },
             8 => self.pen = Pen { style: PS_NULL, width: 0.0, color: black },
+            // The stock fonts (OEM_FIXED_FONT … DEFAULT_GUI_FONT): drawn in the default face.
+            10..=17 => self.text.font = None,
             _ => {}
         }
     }
@@ -397,8 +554,81 @@ impl Canvas {
         }
     }
 
-    fn fill_color(&self) -> Option<[u8; 4]> {
-        (self.brush.style == BS_SOLID).then_some(self.brush.color)
+    /// The current brush's paint. Hatch and monochrome brushes take the background colour (when
+    /// the background mode is opaque) and the text colour. Under R2_MASKPEN (destination AND
+    /// brush) a tile's white pixels keep what is below, and its black ones take the colour of the
+    /// XOR fill before it: XOR, AND, XOR again leaves that colour where the tile is black.
+    fn fill_paint(&self) -> Option<Paint> {
+        let b = &self.brush;
+        match b.style {
+            BS_SOLID => Some(Paint::Solid(b.color)),
+            BS_HATCHED => {
+                let bg = self.text.bk_opaque.then_some(self.text.bk_color);
+                let px = hatch_tile(b.hatch, b.color, bg)?;
+                Some(Paint::Tile(Arc::new(RawTile { w: 8, h: 8, px, cell: self.pattern_px })))
+            }
+            BS_PATTERN | BS_DIBPATTERN | BS_DIBPATTERNPT => {
+                let p = b.pattern.as_ref()?;
+                if !p.mono && self.rop2 != R2_MASKPEN {
+                    let cell = self.pattern_px;
+                    return Some(Paint::Tile(p.plain.get_or_init(|| Arc::new(RawTile { w: p.w, h: p.h, px: p.px.clone(), cell })).clone()));
+                }
+                let mut px = p.px.clone();
+                for c in px.as_chunks_mut::<4>().0 {
+                    if p.mono {
+                        let light = u16::from(c[0]) + u16::from(c[1]) + u16::from(c[2]) >= 384;
+                        let v = if light { self.text.bk_color } else { self.text.color };
+                        *c = [v[0], v[1], v[2], 255];
+                    }
+                    if self.rop2 == R2_MASKPEN {
+                        if c[..3] == [255, 255, 255] {
+                            c[3] = 0;
+                        } else if c[..3] == [0, 0, 0]
+                            && let Some(x) = self.xor_color
+                        {
+                            *c = x;
+                        }
+                    }
+                }
+                Some(Paint::Tile(Arc::new(RawTile { w: p.w, h: p.h, px, cell: self.pattern_px })))
+            }
+            _ => None,
+        }
+    }
+
+    /// Pushes device ops filled with `fill` and stroked with `stroke`: a tile fill and its outline
+    /// are two items.
+    fn push_shape(&mut self, ops: Vec<Op>, fill: Option<Paint>, stroke: Option<([u8; 4], f64)>) {
+        let even_odd = self.even_odd;
+        match fill {
+            Some(Paint::Tile(tile)) => {
+                if stroke.is_some() {
+                    self.push(Raw::Pattern { ops: ops.clone(), even_odd, tile });
+                    self.push(Raw::Path { ops, fill: None, stroke, even_odd });
+                } else {
+                    self.push(Raw::Pattern { ops, even_odd, tile });
+                }
+            }
+            Some(Paint::Solid(c)) => self.push(Raw::Path { ops, fill: Some(c), stroke, even_odd }),
+            None if stroke.is_some() => self.push(Raw::Path { ops, fill: None, stroke, even_odd }),
+            None => {}
+        }
+    }
+
+    /// Whether the mix mode suppresses drawing: R2_NOP draws nothing, and R2_XORPEN shapes only
+    /// remember their fill colour (an XOR pair cancels; the see-through shadow idiom draws its
+    /// pattern in that colour).
+    fn mix_skips(&mut self, fill: bool) -> bool {
+        match self.rop2 {
+            R2_NOP => true,
+            R2_XORPEN => {
+                if fill && self.brush.style == BS_SOLID {
+                    self.xor_color = Some(self.brush.color);
+                }
+                true
+            }
+            _ => false,
+        }
     }
 
     fn stroke_pen(&self) -> Option<([u8; 4], f64)> {
@@ -426,16 +656,12 @@ impl Canvas {
         if self.in_path {
             return self.push_path_ops(dev);
         }
-        if self.nop {
+        if self.mix_skips(fill) || dev.len() < 2 {
             return;
         }
-        let fill = if fill { self.fill_color() } else { None };
+        let fill = if fill { self.fill_paint() } else { None };
         let stroke = if stroke { self.stroke_pen() } else { None };
-        if (fill.is_none() && stroke.is_none()) || dev.len() < 2 {
-            return;
-        }
-        let even_odd = self.even_odd;
-        self.push(Raw::Path { ops: dev, fill, stroke, even_odd });
+        self.push_shape(dev, fill, stroke);
     }
 
     pub fn move_to(&mut self, p: P) {
@@ -508,23 +734,22 @@ impl Canvas {
     /// FILLPATH, STROKEPATH and STROKEANDFILLPATH: paints the bracketed path and empties it.
     pub fn paint_path(&mut self, fill: bool, stroke: bool) {
         let ops = std::mem::take(&mut self.path);
-        if self.nop {
+        if self.mix_skips(fill) || ops.len() < 2 {
             return;
         }
-        let fill = if fill { self.fill_color() } else { None };
+        let fill = if fill { self.fill_paint() } else { None };
         let stroke = if stroke { self.stroke_pen() } else { None };
-        if ops.len() < 2 || (fill.is_none() && stroke.is_none()) {
-            return;
-        }
-        let even_odd = self.even_odd;
-        self.push(Raw::Path { ops, fill, stroke, even_odd });
+        self.push_shape(ops, fill, stroke);
     }
 
-    /// Fills a logical rectangle `[l, t, r, b]` with the current brush (nothing when it is not solid).
-    pub fn fill_brush_rect(&mut self, rect: [f64; 4]) {
-        if let Some(color) = self.fill_color() {
-            self.fill_rect_with(rect, color);
+    /// Fills a logical rectangle `[l, t, r, b]` with the current brush (PATBLT, PATCOPY blits).
+    pub fn fill_brush_rect(&mut self, [l, t, r, b]: [f64; 4]) {
+        if self.mix_skips(true) {
+            return;
         }
+        let fill = self.fill_paint();
+        let dev: Vec<Op> = crate::geom::rect(l, t, r, b).iter().map(|o| self.map_op(*o)).collect();
+        self.push_shape(dev, fill, None);
     }
 
     /// Fills a logical rectangle `[l, t, r, b]` with a solid colour (ROP fills such as BLACKNESS).
@@ -550,6 +775,75 @@ impl Canvas {
         }
     }
 
+    /// Draws `text` (one `dx` advance per character, or none) with the current font, colours and
+    /// alignment. The reference point is `at`, or the current position under TA_UPDATECP (which
+    /// then moves past the string). `rect` (logical `[l, t, r, b]`) is filled with the background
+    /// colour under ETO_OPAQUE and clips the text under ETO_CLIPPED. Text ignores the mix mode, as
+    /// GDI's does.
+    pub fn text(&mut self, at: P, text: String, dx: Vec<f32>, options: u32, rect: Option<[f64; 4]>) {
+        if let (true, Some(r)) = (options & ETO_OPAQUE != 0, rect) {
+            self.fill_rect_with(r, self.text.bk_color);
+        }
+        let lf = self.text.font.as_deref().cloned().unwrap_or_default();
+        let update = self.text.align & TA_UPDATECP != 0;
+        let origin = if update { self.pos } else { at };
+        let (h_align, v_align) = align(self.text.align);
+        let o = self.map.device(origin);
+        let ux = self.map.device((origin.0 + 1.0, origin.1));
+        let uy = self.map.device((origin.0, origin.1 + 1.0));
+        let (ux, uy) = ((ux.0 - o.0, ux.1 - o.1), (uy.0 - o.0, uy.1 - o.1));
+        if update {
+            // The current position moves along the baseline past the string (back past it when
+            // right-aligned). Without a dx array the advance is estimated from the height.
+            let adv: f64 = if dx.is_empty() {
+                f64::from(lf.font.height.abs().max(1.0)) * 0.5 * text.chars().count() as f64
+            } else {
+                dx.iter().map(|d| f64::from(*d)).sum()
+            };
+            let adv = match h_align {
+                crate::HAlign::Left => adv,
+                crate::HAlign::Right => -adv,
+                crate::HAlign::Center => 0.0,
+            };
+            let theta = (lf.escapement / 10.0).to_radians();
+            let y_sign = if uy.1 < 0.0 { 1.0 } else { -1.0 };
+            let p = (origin.0 + adv * theta.cos(), origin.1 + adv * theta.sin() * y_sign);
+            if p.0.is_finite() && p.1.is_finite() {
+                self.pos = p;
+            }
+        }
+        let (sx, sy) = (ux.0.hypot(ux.1), uy.0.hypot(uy.1));
+        let drawable = !text.is_empty() && [sx, sy, o.0, o.1].iter().all(|v| v.is_finite()) && sx > 0.0 && sy > 0.0;
+        if !drawable {
+            return;
+        }
+        // The baseline runs along the device direction of the logical x axis (rotated by a world
+        // transform; a mirroring mapping does not mirror glyphs), turned counter-clockwise by the
+        // escapement.
+        let det = ux.0 * uy.1 - ux.1 * uy.0;
+        let phi = if det > 0.0 { ux.1.atan2(ux.0) } else { ux.1.atan2(ux.0.abs()) };
+        let a = phi - (lf.escapement / 10.0).to_radians();
+        let (c, s) = (a.cos(), a.sin());
+        let clip = match (options & ETO_CLIPPED != 0, rect) {
+            (true, Some([l, t, r, b])) => {
+                let (p, q) = (self.map.device((l, t)), self.map.device((r, b)));
+                Some([p.0.min(q.0) as f32, p.1.min(q.1) as f32, p.0.max(q.0) as f32, p.1.max(q.1) as f32])
+            }
+            _ => None,
+        };
+        self.push(Raw::Text(Box::new(Text {
+            transform: [sx * c, sx * s, -sy * s, sy * c, o.0, o.1],
+            text,
+            dx,
+            font: lf.font,
+            color: self.text.color,
+            background: self.text.bk_opaque.then_some(self.text.bk_color),
+            h_align,
+            v_align,
+            clip,
+        })));
+    }
+
     /// A bitmap stretched into a logical rectangle `[x, y, w, h]`. A negative extent mirrors the
     /// bitmap, as the mapping does.
     pub fn bitmap(&mut self, rect: [f64; 4], mut img: Rgba) {
@@ -562,6 +856,31 @@ impl Canvas {
     }
 }
 
+/// An 8×8 hatch tile (HS_HORIZONTAL, HS_VERTICAL, HS_FDIAGONAL, HS_BDIAGONAL, HS_CROSS,
+/// HS_DIAGCROSS): one-pixel lines in `fg` over `bg`, or over nothing when the background is
+/// transparent. None for an unknown style.
+pub(crate) fn hatch_tile(style: u32, fg: [u8; 4], bg: Option<[u8; 4]>) -> Option<Vec<u8>> {
+    if style > 5 {
+        return None;
+    }
+    let mut px = Vec::with_capacity(8 * 8 * 4);
+    for y in 0..8u32 {
+        for x in 0..8u32 {
+            let (h, v, f, b) = (y == 7, x == 7, x == y, x + y == 7);
+            let on = match style {
+                0 => h,
+                1 => v,
+                2 => f,
+                3 => b,
+                4 => h || v,
+                _ => f || b,
+            };
+            px.extend(if on { fg } else { bg.unwrap_or([0, 0, 0, 0]) });
+        }
+    }
+    Some(px)
+}
+
 /// Cubic segments from groups of three points (control, control, end). A trailing partial group is
 /// dropped.
 fn cubics(pts: &[P]) -> Vec<Op> {

crates/metafile/src/emf.rs

@@ -1,12 +1,20 @@
 //! EMF reader (MS-EMF). Records are (type, size in bytes) followed by a payload; offsets inside a
 //! record (bitmap info and bits) are relative to the record start, so each handler reads the record slice.
 
+use std::sync::Arc;
+
 use crate::bytes::Bytes;
-use crate::canvas::{BS_NULL, Brush, Canvas, Obj, PS_NULL, PS_STYLE_MASK, Pen, Xform, colorref};
+use crate::canvas::{BS_HATCHED, BS_NULL, Brush, Canvas, LogFont, Obj, PS_NULL, PS_STYLE_MASK, Pen, Xform, colorref};
 use crate::dib::{self, Blend};
 use crate::geom::{self, ArcKind, P};
+use crate::text::{ETO_GLYPH_INDEX, ETO_PDY, Font, MAX_CHARS, decode_bytes, decode_utf16};
 use crate::{Error, Frame, MAX_PATH_OPS};
 
+/// ExtTextOut options: no rectangle in the record (EMR_SMALLTEXTOUT, EmrText), and 8-bit
+/// characters (EMR_SMALLTEXTOUT).
+const ETO_NO_RECT: u32 = 0x0100;
+const ETO_SMALL_CHARS: u32 = 0x0200;
+
 const EMF_SIGNATURE: u32 = 0x464D_4520;
 /// Hundredths of a millimetre to points.
 const HMM_TO_PT: f64 = 72.0 / 2540.0;
@@ -100,6 +108,14 @@ fn record(cv: &mut Canvas, typ: u32, r: Bytes) {
         38 => create_pen(cv, r),
         95 => create_ext_pen(cv, r),
         39 => create_brush(cv, r),
+        93 | 94 => create_dib_brush(cv, r, typ == 93),
+        82 => create_font(cv, r),
+        18 => r.u32(8).map(|m| cv.set_bk_mode(m)),
+        22 => r.u32(8).map(|a| cv.set_text_align(a)),
+        24 => r.u32(8).map(|c| cv.set_text_color(c)),
+        25 => r.u32(8).map(|c| cv.set_bk_color(c)),
+        83 | 84 => ext_text_out(cv, r, typ == 84),
+        108 => small_text_out(cv, r),
         40 => r.u32(8).map(|i| cv.delete_object(i)),
         27 => xy32(r, 8).map(|p| cv.move_to(p)),
         54 => xy32(r, 8).map(|p| cv.line_to(p)),
@@ -246,7 +262,109 @@ fn create_brush(cv: &mut Canvas, r: Bytes) -> Option<()> {
     let slot = r.u32(8)? as usize;
     let style = r.u32(12)?;
     let color = r.u32(16)?;
-    cv.add_object(Some(slot), Obj::Brush(Brush { style, color: colorref(color) }));
+    let mut b = Brush::new(style, colorref(color));
+    if style == BS_HATCHED {
+        b.hatch = r.u32(20).unwrap_or(0);
+    }
+    cv.add_object(Some(slot), Obj::Brush(b));
+    Some(())
+}
+
+/// EMR_CREATEDIBPATTERNBRUSHPT (94) and EMR_CREATEMONOBRUSH (93): handle, colour usage, then the
+/// bitmap info and bits as offset/size pairs. A mono brush (or one whose palette holds indices,
+/// DIB_PAL_COLORS) takes the text and background colours. An undecodable bitmap leaves the slot
+/// empty.
+fn create_dib_brush(cv: &mut Canvas, r: Bytes, mono: bool) -> Option<()> {
+    let slot = r.u32(8)? as usize;
+    let usage = r.u32(12)?;
+    let (bo, bl) = (r.u32(16)? as usize, r.u32(20)? as usize);
+    let (po, pl) = (r.u32(24)? as usize, r.u32(28)? as usize);
+    let img = dib::decode(Bytes(r.slice(bo, bl)?), Bytes(r.slice(po, pl)?), false)?;
+    let b = Brush::pattern(img, mono || usage == 1)?;
+    cv.add_object(Some(slot), Obj::Brush(b));
+    Some(())
+}
+
+/// EMR_EXTCREATEFONTINDIRECTW: handle, then a LogFont (MS-EMF 2.2.13): height, width, escapement,
+/// orientation, weight (i32 each), italic, underline, strike-out, charset and four more bytes, then
+/// the face name in 32 UTF-16 units (NUL-terminated).
+fn create_font(cv: &mut Canvas, r: Bytes) -> Option<()> {
+    let slot = r.u32(8)? as usize;
+    let height = r.i32(12)?;
+    let width = r.i32(16).unwrap_or(0);
+    let escapement = r.i32(20).unwrap_or(0);
+    let weight = r.i32(28).unwrap_or(0);
+    let byte = |o: usize| r.0.get(o).copied().unwrap_or(0);
+    let units: Vec<u16> = (0..32).map_while(|i| r.u16(40 + 2 * i)).take_while(|u| *u != 0).collect();
+    let (family, _) = decode_utf16(&units, &[]);
+    let font = Font {
+        family: family.trim().to_string(),
+        height: height as f32,
+        width: width as f32,
+        weight: weight.clamp(0, 1000) as u16,
+        italic: byte(32) != 0,
+        underline: byte(33) != 0,
+        strike: byte(34) != 0,
+        charset: byte(35),
+    };
+    cv.add_object(Some(slot), Obj::Font(Arc::new(LogFont { font, escapement: f64::from(escapement) })));
+    Some(())
+}
+
+/// The dx array at `off` for `n` characters: i32 advances, or (dx, dy) pairs under ETO_PDY (only
+/// dx is used). Empty when absent or short.
+fn dx_array(r: Bytes, off: usize, n: usize, opts: u32) -> Vec<f32> {
+    let step = if opts & ETO_PDY != 0 { 8 } else { 4 };
+    if off == 0 {
+        return Vec::new();
+    }
+    let dx: Vec<f32> = (0..n).map_while(|i| r.i32(off.checked_add(i.checked_mul(step)?)?)).map(|v| v as f32).collect();
+    if dx.len() == n { dx } else { Vec::new() }
+}
+
+/// EMR_EXTTEXTOUTA (83) and EMR_EXTTEXTOUTW (84): bounds, graphics mode and scales, then an EmrText
+/// at 36: reference point, character count, string offset, options, the rectangle (absent under
+/// ETO_NO_RECT) and the dx offset. Offsets count from the record start. Glyph-index strings name
+/// glyphs of a font the reader cannot match, so they are left out.
+fn ext_text_out(cv: &mut Canvas, r: Bytes, wide: bool) -> Option<()> {
+    let at = xy32(r, 36)?;
+    let n = (r.u32(44)? as usize).min(MAX_CHARS);
+    let off = r.u32(48)? as usize;
+    let opts = r.u32(52)?;
+    let (rect, dx_off) = if opts & ETO_NO_RECT != 0 { (None, r.u32(56)?) } else { (rect32(r, 56), r.u32(72)?) };
+    if opts & ETO_GLYPH_INDEX != 0 {
+        return None;
+    }
+    let dx = dx_array(r, dx_off as usize, n, opts);
+    let (text, dx) = if wide {
+        let raw = r.slice(off, n.checked_mul(2)?)?;
+        let units: Vec<u16> = raw.as_chunks::<2>().0.iter().map(|c| u16::from_le_bytes(*c)).collect();
+        decode_utf16(&units, &dx)
+    } else {
+        decode_bytes(r.slice(off, n)?, cv.font_charset(), &dx)
+    };
+    cv.text(at, text, dx, opts, rect);
+    Some(())
+}
+
+/// EMR_SMALLTEXTOUT (MS-EMF 2.3.5.37): x, y, character count, options, graphics mode, scales, the
+/// bounds (absent under ETO_NO_RECT), then the characters: 8-bit under ETO_SMALL_CHARS, else UTF-16.
+fn small_text_out(cv: &mut Canvas, r: Bytes) -> Option<()> {
+    let at = xy32(r, 8)?;
+    let n = (r.u32(16)? as usize).min(MAX_CHARS);
+    let opts = r.u32(20)?;
+    if opts & ETO_GLYPH_INDEX != 0 {
+        return None;
+    }
+    let (rect, off) = if opts & ETO_NO_RECT != 0 { (None, 36) } else { (rect32(r, 36), 52) };
+    let (text, _) = if opts & ETO_SMALL_CHARS != 0 {
+        decode_bytes(r.slice(off, n)?, cv.font_charset(), &[])
+    } else {
+        let raw = r.slice(off, n.checked_mul(2)?)?;
+        let units: Vec<u16> = raw.as_chunks::<2>().0.iter().map(|c| u16::from_le_bytes(*c)).collect();
+        decode_utf16(&units, &[])
+    };
+    cv.text(at, text, Vec::new(), opts, rect);
     Some(())
 }
 

crates/metafile/src/lib.rs

@@ -1,6 +1,9 @@
 //! DeckCraft metafiles (ported from WordCraft's `crates/metafile`): reads Windows Metafiles (WMF)
-//! and Enhanced Metafiles (EMF) into a neutral vector model of filled and stroked paths and RGBA
-//! bitmaps, in a picture frame with y down.
+//! and Enhanced Metafiles (EMF) into a neutral vector model of filled and stroked paths, pattern
+//! fills, RGBA bitmaps and text strings, in a picture frame with y down.
+//!
+//! Text stays font-agnostic: a [`Text`] item names the font the file asks for and carries the
+//! string, its advances and alignment; the renderer resolves the font and draws the glyphs.
 //!
 //! The reader is pure Rust over byte slices (no file system), so it builds for wasm. Every read is
 //! bounds-checked and every count is capped; hostile input yields a shorter picture or an [`Error`],
@@ -16,15 +19,20 @@ mod dib;
 mod emf;
 mod geom;
 mod place;
+mod text;
 mod wmf;
 
 #[cfg(test)]
 mod tests;
 
+use std::collections::HashMap;
+use std::sync::Arc;
+
 use bytes::Bytes;
 use canvas::Raw;
 use geom::{Op, P};
 pub use place::{MAX_BITMAP_SIDE, PlacedItem};
+pub use text::{Font, HAlign, SYMBOL_CHARSET, Text, VAlign};
 
 /// Items kept from one file. Past the cap the parse stops and keeps what it has.
 pub(crate) const MAX_ITEMS: usize = 200_000;
@@ -61,6 +69,22 @@ pub enum Item {
     },
     /// A bitmap stretched into `rect` = `[x, y, w, h]` (picture units), RGBA8 rows top-down.
     Bitmap { rect: [f32; 4], width: u32, height: u32, rgba: Vec<u8> },
+    /// A path filled with a repeating tile (pattern and hatch brushes). Items filled with the same
+    /// brush share its tile.
+    Pattern { segs: Vec<Seg>, even_odd: bool, tile: Arc<Tile> },
+    /// A text string.
+    Text(Box<Text>),
+}
+
+/// A brush tile: RGBA8 rows top-down (transparent where the brush leaves the background), each
+/// pixel `cell` picture units, with a tile's top-left corner at `origin`.
+#[derive(Debug, Clone, PartialEq)]
+pub struct Tile {
+    pub width: u32,
+    pub height: u32,
+    pub rgba: Vec<u8>,
+    pub cell: [f32; 2],
+    pub origin: [f32; 2],
 }
 
 #[derive(Debug, Clone, Copy, PartialEq)]
@@ -94,6 +118,8 @@ pub fn parse(bytes: &[u8]) -> Result<Picture, Error> {
     let (cv, frame) = if emf::is_emf(b) {
         emf::parse(b)?
     } else if wmf::is_wmf(b) {
+        // A WMF converted from an EMF can carry the original in MFCOMMENT escapes; PowerPoint draws
+        // the WMF's own records (its dx rounding shows), so the copy is not used.
         wmf::parse(b)?
     } else {
         return Err(Error::NotMetafile);
@@ -124,6 +150,8 @@ fn build(raw: Vec<Raw>, frame: Option<Frame>) -> Picture {
     let stroke_scale = (sx + sy) / 2.0;
     // No stroke is wider than the picture's diagonal: anything wider is a mapping artefact.
     let diag = size.0.hypot(size.1);
+    // Tiles shared by several fills stay shared.
+    let mut tiles: HashMap<*const canvas::RawTile, (Arc<canvas::RawTile>, Arc<Tile>)> = HashMap::new();
     let items = raw.into_iter().filter_map(|r| match r {
         Raw::Path { ops, fill, stroke, even_odd } => {
             let segs = ops.iter().map(|op| seg(op, tf)).collect::<Option<Vec<Seg>>>()?;
@@ -138,6 +166,44 @@ fn build(raw: Vec<Raw>, frame: Option<Frame>) -> Picture {
             let rect = [f(x)?, f(y)?, f(r[2] * sx)?, f(r[3] * sy)?];
             Some(Item::Bitmap { rect, width: img.w as u32, height: img.h as u32, rgba: img.px })
         }
+        Raw::Pattern { ops, even_odd, tile } => {
+            let segs = ops.iter().map(|op| seg(op, tf)).collect::<Option<Vec<Seg>>>()?;
+            if segs.len() < 2 {
+                return None;
+            }
+            let key = Arc::as_ptr(&tile);
+            let tile = match tiles.get(&key) {
+                Some((_, t)) => t.clone(),
+                None => {
+                    let (ox, oy) = tf((0.0, 0.0));
+                    let t = Arc::new(Tile {
+                        width: u32::try_from(tile.w).ok()?,
+                        height: u32::try_from(tile.h).ok()?,
+                        rgba: tile.px.clone(),
+                        cell: [f(tile.cell * sx)?, f(tile.cell * sy)?],
+                        origin: [f(ox)?, f(oy)?],
+                    });
+                    // The raw tile is kept with its key, so the address is never reused by another.
+                    tiles.insert(key, (tile.clone(), t.clone()));
+                    t
+                }
+            };
+            Some(Item::Pattern { segs, even_odd, tile })
+        }
+        Raw::Text(mut t) => {
+            // Device to picture: scale by (sx, sy) after moving the frame's corner to the origin.
+            let [a, b, c, d, e, g] = t.transform;
+            let (e, g) = tf((e, g));
+            t.transform = [a * sx, b * sy, c * sx, d * sy, e, g];
+            if !t.transform.iter().all(|v| v.is_finite()) {
+                return None;
+            }
+            if let Some([x0, y0, x1, y1]) = t.clip {
+                let (p, q) = (tf((f64::from(x0), f64::from(y0))), tf((f64::from(x1), f64::from(y1))));
+                t.clip = Some([f(p.0.min(q.0))?, f(p.1.min(q.1))?, f(p.0.max(q.0))?, f(p.1.max(q.1))?]);
+            }
+            Some(Item::Text(t))
+        }
     });
     let items = items.collect();
     Picture { width: f(size.0).unwrap_or(0.0), height: f(size.1).unwrap_or(0.0), items }
@@ -185,7 +251,7 @@ fn bbox(raw: &[Raw]) -> Option<[f64; 4]> {
     };
     for r in raw {
         match r {
-            Raw::Path { ops, .. } => {
+            Raw::Path { ops, .. } | Raw::Pattern { ops, .. } => {
                 for op in ops {
                     match *op {
                         Op::M(p) | Op::L(p) => grow(p),
@@ -202,6 +268,7 @@ fn bbox(raw: &[Raw]) -> Option<[f64; 4]> {
                 grow((rect[0], rect[1]));
                 grow((rect[0] + rect[2], rect[1] + rect[3]));
             }
+            Raw::Text(t) => grow((t.transform[4], t.transform[5])),
         }
     }
     b

crates/metafile/src/place.rs

@@ -19,6 +19,12 @@ pub enum PlacedItem {
     Path { path: BezPath, fill: Option<[u8; 4]>, stroke: Option<([u8; 4], f64)>, even_odd: bool },
     /// `Picture::items[index]`, a bitmap, stretched into `rect`.
     Bitmap { index: usize, rect: Rect },
+    /// `Picture::items[index]`, a pattern fill: `path` (target units) filled with the item's tile
+    /// repeated; `tile` maps tile pixels to target units.
+    Pattern { index: usize, path: BezPath, even_odd: bool, tile: Affine },
+    /// `Picture::items[index]`, a text string: `transform` maps its text space to target units;
+    /// `clip` (target units) bounds what it draws.
+    Text { index: usize, transform: Affine, clip: Option<Rect> },
 }
 
 impl Picture {
@@ -56,6 +62,26 @@ impl Picture {
                         out.push(PlacedItem::Path { path, fill: *fill, stroke, even_odd: *even_odd });
                     }
                 }
+                Item::Pattern { segs, even_odd, tile: t } => {
+                    let path = tf * bez(segs);
+                    let tile = tf
+                        * Affine::translate((f64::from(t.origin[0]), f64::from(t.origin[1])))
+                        * Affine::scale_non_uniform(f64::from(t.cell[0]), f64::from(t.cell[1]));
+                    let det = tile.determinant();
+                    if in_range(path.bounding_box()) && det.is_finite() && det.abs() > 1e-12 {
+                        out.push(PlacedItem::Pattern { index, path, even_odd: *even_odd, tile });
+                    }
+                }
+                Item::Text(t) => {
+                    let transform = tf * Affine::new(t.transform);
+                    let clip =
+                        t.clip.map(|[x0, y0, x1, y1]| tf.transform_rect_bbox(Rect::new(f64::from(x0), f64::from(y0), f64::from(x1), f64::from(y1))));
+                    let c = transform.as_coeffs();
+                    let origin = Rect::new(c[4], c[5], c[4], c[5]);
+                    if in_range(origin) && c.iter().all(|v| v.is_finite()) && clip.is_none_or(in_range) {
+                        out.push(PlacedItem::Text { index, transform, clip });
+                    }
+                }
                 Item::Bitmap { rect: [x, y, w, h], .. } => {
                     let (x0, y0) = (f64::from(*x), f64::from(*y));
                     let rect = tf.transform_rect_bbox(Rect::new(x0, y0, x0 + f64::from(*w), y0 + f64::from(*h)));

crates/metafile/src/tests.rs

@@ -120,7 +120,7 @@ const DIB24_RGBA: [u8; 16] = [255, 0, 0, 255, 255, 255, 255, 255, 0, 0, 255, 255
 fn path_segs(item: &Item) -> (&Vec<Seg>, Option<[u8; 4]>, Option<([u8; 4], f32)>, bool) {
     match item {
         Item::Path { segs, fill, stroke, even_odd } => (segs, *fill, *stroke, *even_odd),
-        Item::Bitmap { .. } => panic!("expected a path"),
+        other => panic!("expected a path: {other:?}"),
     }
 }
 
@@ -1016,3 +1016,505 @@ fn plain_wmf_target_comes_from_a_window_that_was_read() {
     let (x0, y0, x1, y1) = rect_extent(&p.items[0]);
     assert!(close(x0, 0.0) && close(y0, 0.0) && close(x1, 200.0) && close(y1, 100.0), "{x0} {y0} {x1} {y1}");
 }
+
+// ---- Text, pattern and hatch brushes, mix-mode idioms ----
+
+use crate::{HAlign, Picture, Text, VAlign};
+
+/// META_CREATEFONTINDIRECT: height, width, escapement (and orientation), weight, the italic,
+/// underline, strike-out and charset bytes, four precision bytes, then the NUL-terminated face.
+fn wfont(height: i32, weight: i32, flags: [u8; 3], charset: u8, esc: i32, face: &[u8]) -> Vec<u8> {
+    let mut v = cat(vec![h16(height), h16(0), h16(esc), h16(esc), h16(weight)]);
+    v.extend(flags);
+    v.extend([charset, 0, 0, 0, 0]);
+    v.extend(face);
+    v.push(0);
+    wrec(0x02FB, &v)
+}
+
+/// META_EXTTEXTOUT at (x, y): the rectangle when given, the string padded to a word, then `dx`.
+fn wtext(x: i32, y: i32, s: &[u8], opts: i32, rect: Option<[i32; 4]>, dx: &[i32]) -> Vec<u8> {
+    let mut v = cat(vec![h16(y), h16(x), h16(s.len() as i32), h16(opts)]);
+    for c in rect.into_iter().flatten() {
+        v.extend(h16(c));
+    }
+    v.extend(s);
+    if s.len() % 2 == 1 {
+        v.push(0);
+    }
+    for d in dx {
+        v.extend(h16(*d));
+    }
+    wrec(0x0A32, &v)
+}
+
+/// A plain WMF whose 200 × 100 window maps one logical unit to one picture unit.
+fn wmf200(records: &[Vec<u8>]) -> Picture {
+    let mut recs = vec![wrec(0x020C, &cat(vec![h16(100), h16(200)]))];
+    recs.extend(records.iter().cloned());
+    parse(&wmf(&recs, None)).unwrap()
+}
+
+fn texts(p: &Picture) -> Vec<&Text> {
+    p.items
+        .iter()
+        .filter_map(|i| match i {
+            Item::Text(t) => Some(t.as_ref()),
+            _ => None,
+        })
+        .collect()
+}
+
+fn close6(a: [f64; 6], b: [f64; 6]) -> bool {
+    a.iter().zip(b).all(|(x, y)| (x - y).abs() < 1e-6)
+}
+
+#[test]
+fn wmf_text_reads_the_font_string_dx_colour_and_alignment() {
+    let recs = [
+        wfont(-20, 700, [1, 1, 1], 0, 0, b"Arial"),
+        wrec(0x012D, &h16(0)),
+        wrec(0x0209, &h32(0x0000_00FF)),
+        wrec(0x0102, &h16(1)),
+        wrec(0x012E, &h16(24 | 6)),
+        wtext(50, 60, b"Hi!", 0, None, &[10, 8, 6]),
+    ];
+    let p = wmf200(&recs);
+    let t = texts(&p);
+    assert_eq!(t.len(), 1, "{:?}", p.items);
+    let t = t[0];
+    assert_eq!(t.text, "Hi!");
+    assert_eq!(t.dx, vec![10.0, 8.0, 6.0], "the dx array follows the word-padded odd string");
+    assert_eq!(t.font.family, "Arial");
+    assert_eq!((t.font.height, t.font.weight, t.font.italic, t.font.underline, t.font.strike), (-20.0, 700, true, true, true));
+    assert_eq!(t.color, [255, 0, 0, 255]);
+    assert_eq!(t.background, None, "TRANSPARENT background mode");
+    assert_eq!((t.h_align, t.v_align), (HAlign::Center, VAlign::Baseline));
+    assert!(close6(t.transform, [1.0, 0.0, 0.0, 1.0, 50.0, 60.0]), "{:?}", t.transform);
+    assert_eq!(t.clip, None);
+}
+
+#[test]
+fn font_height_sign_and_default_state_are_kept() {
+    // A positive height is the cell height; it stays positive for the renderer to resolve. Without
+    // SETTEXTALIGN the reference point is the top left; without SETBKMODE the cell is filled white.
+    let recs = [wfont(30, 400, [0, 0, 0], 0, 0, b"Times New Roman"), wrec(0x012D, &h16(0)), wtext(5, 5, b"x", 0, None, &[])];
+    let p = wmf200(&recs);
+    let t = texts(&p)[0];
+    assert_eq!(t.font.height, 30.0);
+    assert_eq!(t.font.family, "Times New Roman");
+    assert_eq!((t.h_align, t.v_align), (HAlign::Left, VAlign::Top));
+    assert_eq!(t.background, Some([255, 255, 255, 255]));
+    assert!(t.dx.is_empty(), "no dx array in the record");
+    // Right and bottom.
+    let p = wmf200(&[wrec(0x012E, &h16(2 | 8)), wtext(5, 5, b"x", 0, None, &[])]);
+    let t = texts(&p)[0];
+    assert_eq!((t.h_align, t.v_align), (HAlign::Right, VAlign::Bottom));
+    assert_eq!(t.font, crate::Font::default(), "no font selected");
+}
+
+#[test]
+fn escapement_turns_the_baseline_counter_clockwise() {
+    let recs = [wfont(-20, 400, [0, 0, 0], 0, 900, b"Arial"), wrec(0x012D, &h16(0)), wtext(100, 90, b"Up", 0, None, &[])];
+    let p = wmf200(&recs);
+    let t = texts(&p)[0];
+    // Text x runs up the picture (0, -1); text y (down the glyphs) runs right (1, 0).
+    assert!(close6(t.transform, [0.0, -1.0, 1.0, 0.0, 100.0, 90.0]), "{:?}", t.transform);
+}
+
+#[test]
+fn a_y_up_mapping_moves_text_but_does_not_mirror_it() {
+    // Window 200 × -100 onto a 200 × 100 viewport: y goes up.
+    let recs = [
+        wrec(0x0103, &h16(8)),
+        wrec(0x020C, &cat(vec![h16(-100), h16(200)])),
+        wrec(0x020E, &cat(vec![h16(100), h16(200)])),
+        wtext(40, -30, b"A", 0, None, &[]),
+    ];
+    let p = parse(&wmf(&recs, None)).unwrap();
+    let t = texts(&p)[0];
+    assert!(close6(t.transform, [1.0, 0.0, 0.0, 1.0, 40.0, 30.0]), "{:?}", t.transform);
+}
+
+#[test]
+fn update_cp_starts_at_the_current_position_and_moves_past_the_string() {
+    let recs =
+        [wrec(0x012E, &h16(1)), wrec(0x0214, &cat(vec![h16(20), h16(10)])), wtext(0, 0, b"ab", 0, None, &[5, 7]), wtext(0, 0, b"c", 0, None, &[3])];
+    let p = wmf200(&recs);
+    let t = texts(&p);
+    assert_eq!(t.len(), 2);
+    assert!(close6(t[0].transform, [1.0, 0.0, 0.0, 1.0, 10.0, 20.0]), "{:?}", t[0].transform);
+    assert!(close6(t[1].transform, [1.0, 0.0, 0.0, 1.0, 22.0, 20.0]), "{:?}", t[1].transform);
+}
+
+#[test]
+fn eto_opaque_fills_the_rectangle_and_eto_clipped_clips() {
+    let recs = [wrec(0x0201, &h32(0x0000_FF00)), wtext(12, 30, b"ok", 2 | 4, Some([10, 10, 60, 40]), &[])];
+    let p = wmf200(&recs);
+    assert_eq!(p.items.len(), 2, "{:?}", p.items);
+    let (x0, y0, x1, y1) = rect_extent(&p.items[0]);
+    assert!(close(x0, 10.0) && close(y0, 10.0) && close(x1, 60.0) && close(y1, 40.0));
+    assert_eq!(path_segs(&p.items[0]).1, Some([0, 255, 0, 255]));
+    let t = texts(&p)[0];
+    assert_eq!(t.clip, Some([10.0, 10.0, 60.0, 40.0]));
+    assert_eq!(t.background, Some([0, 255, 0, 255]));
+}
+
+#[test]
+fn character_sets_decode_bytes() {
+    let one = |charset: u8, s: &[u8]| {
+        let p = wmf200(&[wfont(-10, 400, [0, 0, 0], charset, 0, b"F"), wrec(0x012D, &h16(0)), wtext(0, 0, s, 0, None, &[])]);
+        texts(&p)[0].text.clone()
+    };
+    assert_eq!(one(0, &[b'A', 0x80, 0x93, 0x94, 0xE9]), "A€“”é");
+    assert_eq!(one(238, &[0xB9, 0xE8, 0x9E, 0xA3]), "ąčžŁ");
+    assert_eq!(one(204, &[0xC0, 0xFF, 0xA8]), "АяЁ");
+    assert_eq!(one(2, b"n\xA7"), "\u{F06E}\u{F0A7}", "symbol fonts keep their codes in the private-use area");
+    assert_eq!(one(0, &[0x81]), "\u{FFFD}", "an undefined byte");
+    // A double-byte character set: a lead and trail byte become one blank with both advances.
+    let p =
+        wmf200(&[wfont(-10, 400, [0, 0, 0], 128, 0, b"F"), wrec(0x012D, &h16(0)), wtext(0, 0, &[0x41, 0x82, 0xA0, 0x42], 0, None, &[1, 2, 3, 4])]);
+    let t = texts(&p)[0];
+    assert_eq!((t.text.as_str(), t.dx.as_slice()), ("A B", [1.0, 5.0, 4.0].as_slice()));
+}
+
+#[test]
+fn wmf_textout_reads_its_string_and_position() {
+    let mut v = cat(vec![h16(3)]);
+    v.extend(b"abc\0");
+    v.extend(cat(vec![h16(40), h16(30)]));
+    let p = wmf200(&[wrec(0x0521, &v)]);
+    let t = texts(&p)[0];
+    assert_eq!(t.text, "abc");
+    assert!(close6(t.transform, [1.0, 0.0, 0.0, 1.0, 30.0, 40.0]), "{:?}", t.transform);
+}
+
+#[test]
+fn savedc_restores_text_colour_and_font() {
+    let recs = [
+        wfont(-10, 400, [0, 0, 0], 0, 0, b"One"),
+        wrec(0x012D, &h16(0)),
+        wrec(0x0209, &h32(0x0000_00FF)),
+        wrec(0x001E, &[]),
+        wfont(-10, 400, [0, 0, 0], 0, 0, b"Two"),
+        wrec(0x012D, &h16(1)),
+        wrec(0x0209, &h32(0x00FF_0000)),
+        wrec(0x0127, &h16(-1)),
+        wtext(0, 0, b"x", 0, None, &[]),
+    ];
+    let p = wmf200(&recs);
+    let t = texts(&p)[0];
+    assert_eq!((t.font.family.as_str(), t.color), ("One", [255, 0, 0, 255]));
+}
+
+/// EMR_EXTCREATEFONTINDIRECTW in slot 1: LogFont at 12, face at 40.
+fn efont(height: i32, esc: i32, weight: i32, italic: u8, charset: u8, face: &str) -> Vec<u8> {
+    let mut v = cat(vec![h32(1), e32(height), e32(0), e32(esc), e32(esc), e32(weight)]);
+    v.extend([italic, 0, 0, charset, 0, 0, 0, 0]);
+    let mut name: Vec<u8> = face.encode_utf16().flat_map(|u| u.to_le_bytes()).collect();
+    name.resize(64, 0);
+    v.extend(name);
+    erec(82, &v)
+}
+
+/// EMR_EXTTEXTOUTW (or A) at (x, y) with options, the rectangle (absent under ETO_NO_RECT), the
+/// string at 76 and the dx array after it.
+fn etext(wide: bool, x: i32, y: i32, units: &[u16], opts: u32, dx: &[i32]) -> Vec<u8> {
+    let no_rect = opts & 0x100 != 0;
+    let fixed = if no_rect { 60 } else { 76 };
+    let s: Vec<u8> = if wide { units.iter().flat_map(|u| u.to_le_bytes()).collect() } else { units.iter().map(|u| *u as u8).collect() };
+    let s_off = fixed;
+    let dx_off = (s_off + s.len()).next_multiple_of(4);
+    let len = dx_off + dx.len() * 4;
+    let mut f = vec![(24, 1u32), (36, x as u32), (40, y as u32), (44, units.len() as u32), (48, s_off as u32), (52, opts)];
+    f.push((if no_rect { 56 } else { 72 }, if dx.is_empty() { 0 } else { dx_off as u32 }));
+    let dxb: Vec<u8> = dx.iter().flat_map(|d| d.to_le_bytes()).collect();
+    erec_at(if wide { 84 } else { 83 }, len.next_multiple_of(4), &f, &[(s_off, &s), (dx_off, &dxb)])
+}
+
+#[test]
+fn emf_exttextoutw_reads_utf16_dx_and_the_font() {
+    let recs = [
+        efont(24, 0, 400, 1, 0, "Segoe UI"),
+        erec(37, &h32(1)),
+        erec(22, &h32(0x18 | 2)),
+        erec(24, &h32(0x0000_FF00)),
+        erec(18, &h32(1)),
+        etext(true, 100, 50, &[0x41, 0xD83D, 0xDE00], 0, &[10, 6, 0]),
+    ];
+    let p = parse(&emf(&recs, [0, 0, 200, 100], [0, 0, 5000, 2500])).unwrap();
+    let t = texts(&p);
+    assert_eq!(t.len(), 1, "{:?}", p.items);
+    let t = t[0];
+    assert_eq!(t.text, "A\u{1F600}");
+    assert_eq!(t.dx, vec![10.0, 6.0], "a surrogate pair takes both advances");
+    assert_eq!((t.font.family.as_str(), t.font.height, t.font.italic), ("Segoe UI", 24.0, true));
+    assert_eq!((t.h_align, t.v_align, t.color, t.background), (HAlign::Right, VAlign::Baseline, [0, 255, 0, 255], None));
+    // Upright, uniformly scaled.
+    let [a, b, c, d, ..] = t.transform;
+    assert!(a > 0.0 && d > 0.0 && b.abs() < 1e-9 && c.abs() < 1e-9 && (a - d).abs() < 1e-9, "{:?}", t.transform);
+}
+
+#[test]
+fn emf_text_options_pdy_no_rect_ansi_and_glyph_indices() {
+    // ETO_PDY: (dx, dy) pairs, of which dx is used. ETO_NO_RECT moves the dx offset to 56.
+    let recs = [etext(true, 0, 0, &[0x61, 0x62], 0x2000 | 0x100, &[7, 1, 9, 2])];
+    let p = parse(&emf(&recs, [0, 0, 200, 100], [0, 0, 5000, 2500])).unwrap();
+    assert_eq!(texts(&p)[0].dx, vec![7.0, 9.0]);
+    // EXTTEXTOUTA decodes through the font's charset.
+    let recs = [efont(-10, 0, 400, 0, 238, "F"), erec(37, &h32(1)), etext(false, 0, 0, &[0xB9], 0, &[])];
+    let p = parse(&emf(&recs, [0, 0, 200, 100], [0, 0, 5000, 2500])).unwrap();
+    assert_eq!(texts(&p)[0].text, "ą");
+    // Glyph indices name glyphs of a font we cannot match: left out.
+    let recs = [etext(true, 0, 0, &[5, 6], 0x10, &[])];
+    let p = parse(&emf(&recs, [0, 0, 200, 100], [0, 0, 5000, 2500])).unwrap();
+    assert!(texts(&p).is_empty());
+}
+
+#[test]
+fn emf_smalltextout_reads_8_bit_and_16_bit_strings() {
+    // x, y, count, options, mode, scales, (no bounds under ETO_NO_RECT), characters.
+    let small = |opts: u32, chars: &[u8]| {
+        let mut v = cat(vec![e32(3), e32(4), h32(2), h32(opts), h32(1), h32(0), h32(0)]);
+        v.extend(chars);
+        erec(108, &v)
+    };
+    let p = parse(&emf(&[small(0x100 | 0x200, b"hi")], [0, 0, 200, 100], [0, 0, 5000, 2500])).unwrap();
+    assert_eq!(texts(&p)[0].text, "hi");
+    let p = parse(&emf(&[small(0x100, &[b'o', 0, b'k', 0])], [0, 0, 200, 100], [0, 0, 5000, 2500])).unwrap();
+    assert_eq!(texts(&p)[0].text, "ok");
+}
+
+/// An 8 × 8 one-bit DIB (palette white, black; stored bottom-up): `rows` top to bottom.
+fn mono_dib(rows: [u8; 8]) -> Vec<u8> {
+    let mut v = info_header(8, 8, 1, 32);
+    v.extend([255, 255, 255, 0, 0, 0, 0, 0]);
+    for r in rows.iter().rev() {
+        v.extend([*r, 0, 0, 0]);
+    }
+    v
+}
+
+fn pattern_of(item: &Item) -> &crate::Tile {
+    match item {
+        Item::Pattern { tile, .. } => tile,
+        other => panic!("expected a pattern fill: {other:?}"),
+    }
+}
+
+/// Pixel (x, y) of a tile.
+fn tile_px(t: &crate::Tile, x: usize, y: usize) -> [u8; 4] {
+    let o = (y * t.width as usize + x) * 4;
+    t.rgba[o..o + 4].try_into().unwrap()
+}
+
+#[test]
+fn wmf_dib_pattern_brush_paints_its_rows_top_down() {
+    let brush = wrec(0x0142, &cat(vec![h16(5), h16(0), mono_dib([0xFF, 0x80, 0, 0, 0, 0, 0, 0x01])]));
+    let recs = [
+        brush,
+        // A pen after the brush: the brush took handle 0.
+        wrec(0x02FA, &cat(vec![h16(0), h16(1), h16(0), h32(0x0000_00FF)])),
+        wrec(0x012D, &h16(0)),
+        wrec(0x012D, &h16(1)),
+        wrec(0x041B, &cat(vec![h16(720), h16(1440), h16(0), h16(0)])),
+    ];
+    let p = parse(&wmf(&recs, Some([0, 0, 1440, 720]))).unwrap();
+    assert_eq!(p.items.len(), 2, "the tile fill and the outline: {:?}", p.items);
+    let t = pattern_of(&p.items[0]);
+    assert_eq!((t.width, t.height), (8, 8));
+    for x in 0..8 {
+        assert_eq!(tile_px(t, x, 0), [0, 0, 0, 255], "top row is set: black");
+    }
+    assert_eq!(tile_px(t, 0, 1), [0, 0, 0, 255]);
+    assert_eq!(tile_px(t, 1, 1), [255, 255, 255, 255]);
+    assert_eq!(tile_px(t, 7, 7), [0, 0, 0, 255]);
+    assert_eq!(tile_px(t, 0, 7), [255, 255, 255, 255]);
+    // 96-dpi pixels of a picture in points, laid from the picture's corner.
+    assert!(close(t.cell[0], 0.75) && close(t.cell[1], 0.75) && t.origin == [0.0, 0.0], "{:?} {:?}", t.cell, t.origin);
+    assert_eq!(path_segs(&p.items[1]).2.map(|s| s.0), Some([255, 0, 0, 255]));
+}
+
+#[test]
+fn hatch_brushes_draw_lines_over_the_background_mode() {
+    let hatch = |style: i32| wrec(0x02FC, &cat(vec![h16(2), h32(0x00FF_0000), h16(style)]));
+    let rect = wrec(0x041B, &cat(vec![h16(50), h16(50), h16(0), h16(0)]));
+    // HS_CROSS over a transparent background.
+    let p = wmf200(&[hatch(4), wrec(0x012D, &h16(0)), wrec(0x0102, &h16(1)), rect.clone()]);
+    let t = pattern_of(&p.items[0]);
+    let blue = [0, 0, 255, 255];
+    assert_eq!((tile_px(t, 3, 7), tile_px(t, 7, 3)), (blue, blue));
+    assert_eq!(tile_px(t, 3, 3)[3], 0, "gaps are transparent");
+    // HS_BDIAGONAL over the opaque white background.
+    let p = wmf200(&[hatch(3), wrec(0x012D, &h16(0)), rect.clone()]);
+    let t = pattern_of(&p.items[0]);
+    assert_eq!((tile_px(t, 0, 7), tile_px(t, 7, 0)), (blue, blue));
+    assert_eq!(tile_px(t, 0, 0), [255, 255, 255, 255]);
+    // An unknown hatch style draws no fill.
+    let p = wmf200(&[hatch(9), wrec(0x012D, &h16(0)), rect]);
+    assert!(p.items.iter().all(|i| !matches!(i, Item::Pattern { .. })), "{:?}", p.items);
+}
+
+#[test]
+fn xor_mask_xor_draws_the_pattern_in_the_xor_colour() {
+    // The see-through shadow: XOR a grey polygon, AND a checker pattern, XOR the polygon again.
+    let square = wrec(0x0324, &cat(vec![h16(4), h16(0), h16(0), h16(40), h16(0), h16(40), h16(40), h16(0), h16(40)]));
+    let recs = [
+        wrec(0x0104, &h16(7)),
+        wrec(0x02FC, &cat(vec![h16(0), h32(0x0080_8080), h16(0)])),
+        wrec(0x012D, &h16(0)),
+        square.clone(),
+        wrec(0x0104, &h16(9)),
+        wrec(0x0142, &cat(vec![h16(5), h16(0), mono_dib([0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA])])),
+        wrec(0x012D, &h16(1)),
+        wrec(0x041B, &cat(vec![h16(40), h16(40), h16(0), h16(0)])),
+        wrec(0x0104, &h16(7)),
+        wrec(0x012D, &h16(0)),
+        square,
+    ];
+    let p = wmf200(&recs);
+    assert_eq!(p.items.len(), 2, "only the AND pattern (and its outline) draw: {:?}", p.items);
+    let t = pattern_of(&p.items[0]);
+    // 0x55 = 0101 0101: white, black, …
+    assert_eq!(tile_px(t, 0, 0)[3], 0, "white keeps what is below");
+    assert_eq!(tile_px(t, 1, 0), [128, 128, 128, 255], "black takes the XOR colour");
+}
+
+#[test]
+fn patblt_fills_with_the_brush() {
+    let patblt = |rop: u32| wrec(0x061D, &cat(vec![h32(rop), h16(30), h16(40), h16(10), h16(20)]));
+    let recs = [wrec(0x02FC, &cat(vec![h16(0), h32(0x00FF_0000), h16(0)])), wrec(0x012D, &h16(0)), patblt(0x00F0_0021), patblt(0x0055_0009)];
+    let p = wmf200(&recs);
+    assert_eq!(p.items.len(), 1, "DSTINVERT draws nothing: {:?}", p.items);
+    let (x0, y0, x1, y1) = rect_extent(&p.items[0]);
+    assert!(close(x0, 20.0) && close(y0, 10.0) && close(x1, 60.0) && close(y1, 40.0), "{x0} {y0} {x1} {y1}");
+    assert_eq!(path_segs(&p.items[0]).1, Some([0, 0, 255, 255]));
+}
+
+#[test]
+fn emf_dib_pattern_and_mono_brushes() {
+    let dib = mono_dib([0xF0; 8]);
+    let (info, bits) = dib.split_at(48);
+    let brush = |typ: u32| {
+        let f = [(8, 1u32), (12, 0), (16, 32), (20, info.len() as u32), (24, 32 + info.len() as u32), (28, bits.len() as u32)];
+        erec_at(typ, 32 + dib.len(), &f, &[(32, info), (32 + info.len(), bits)])
+    };
+    let rect = erec(43, &cat(vec![e32(0), e32(0), e32(40), e32(40)]));
+    let null_pen = erec(37, &h32(0x8000_0008));
+    let p = parse(&emf(&[brush(94), erec(37, &h32(1)), null_pen.clone(), rect.clone()], [0, 0, 200, 100], [0, 0, 5000, 2500])).unwrap();
+    let t = pattern_of(&p.items[0]);
+    assert_eq!((tile_px(t, 0, 0), tile_px(t, 7, 0)), ([0, 0, 0, 255], [255, 255, 255, 255]));
+    // A mono brush paints in the text colour (red) and the background colour (green).
+    let recs = [erec(24, &h32(0xFF)), erec(25, &h32(0xFF00)), brush(93), erec(37, &h32(1)), null_pen, rect];
+    let p = parse(&emf(&recs, [0, 0, 200, 100], [0, 0, 5000, 2500])).unwrap();
+    let t = pattern_of(&p.items[0]);
+    assert_eq!((tile_px(t, 0, 0), tile_px(t, 7, 0)), ([255, 0, 0, 255], [0, 255, 0, 255]));
+}
+
+#[test]
+fn hostile_text_and_brush_records_never_panic() {
+    // A string longer than its record is cut to what the record holds.
+    let mut v = cat(vec![h16(0), h16(0), h16(0x7FFF), h16(0)]);
+    v.extend(b"abcd");
+    let p = wmf200(&[wrec(0x0A32, &v)]);
+    assert_eq!(texts(&p)[0].text, "abcd");
+    // The rectangle flag without room for the rectangle draws nothing.
+    let p = wmf200(&[wrec(0x0A32, &cat(vec![h16(0), h16(0), h16(1), h16(6)]))]);
+    assert!(texts(&p).is_empty());
+    // A face name with no terminator stops at 32 bytes.
+    let p = wmf200(&[wfont(-10, 400, [0, 0, 0], 0, 0, &[b'A'; 40]), wrec(0x012D, &h16(0)), wtext(0, 0, b"x", 0, None, &[])]);
+    assert_eq!(texts(&p)[0].font.family.len(), 32);
+    // A pattern brush whose DIB is cut short, or too big for a tile, still takes its handle slot
+    // and draws no fill.
+    let short = wrec(0x0142, &cat(vec![h16(5), h16(0), info_header(8, 8, 1, 32)]));
+    let mut huge = info_header(300, 300, 1, 0);
+    huge.extend([255, 255, 255, 0, 0, 0, 0, 0]);
+    huge.extend(vec![0u8; 40 * 300]);
+    let huge = wrec(0x0142, &cat(vec![h16(5), h16(0), huge]));
+    for b in [short, huge] {
+        let recs = [
+            b,
+            wrec(0x02FA, &cat(vec![h16(0), h16(1), h16(0), h32(0xFF)])),
+            wrec(0x012D, &h16(0)),
+            wrec(0x012D, &h16(1)),
+            wrec(0x041B, &cat(vec![h16(9), h16(9), h16(0), h16(0)])),
+        ];
+        let p = wmf200(&recs);
+        assert_eq!(p.items.len(), 1, "{:?}", p.items);
+        let (_, fill, stroke, _) = path_segs(&p.items[0]);
+        assert_eq!((fill, stroke.map(|s| s.0)), (Some([255, 255, 255, 255]), Some([255, 0, 0, 255])));
+    }
+    // EMF: the string offset past the record, a huge count, a dx offset past the record.
+    let bad = [
+        erec_at(84, 80, &[(44, 2), (48, 4000), (52, 0)], &[]),
+        erec_at(84, 84, &[(44, u32::MAX), (48, 76), (52, 0)], &[(76, &[b'a', 0, b'b', 0])]),
+        erec_at(84, 80, &[(44, 2), (48, 76), (52, 0), (72, 0xFFFF_FFF0)], &[(76, &[b'a', 0, b'b', 0])]),
+        erec_at(82, 20, &[(8, 1)], &[]),
+        erec_at(94, 32, &[(8, 1), (16, 0xFFFF_FFFF), (20, 40), (24, 0), (28, 0xFFFF_FFFF)], &[]),
+        erec_at(108, 40, &[(16, u32::MAX), (20, 0x300)], &[]),
+    ];
+    for r in bad {
+        let _ = parse(&emf(&[r], [0, 0, 200, 100], [0, 0, 5000, 2500]));
+    }
+    let p = parse(&emf(
+        &[erec_at(84, 84, &[(44, 2), (48, 76), (52, 0), (72, 0xFFFF_FFF0)], &[(76, &[b'a', 0, b'b', 0])])],
+        [0, 0, 200, 100],
+        [0, 0, 5000, 2500],
+    ))
+    .unwrap();
+    assert!(texts(&p)[0].dx.is_empty(), "a dx array past the record is dropped");
+    // Mutated text and brush files.
+    let wfile = wmf(
+        &[
+            wfont(-20, 700, [1, 1, 1], 238, 450, b"Arial"),
+            wrec(0x012D, &h16(0)),
+            wrec(0x0142, &cat(vec![h16(5), h16(0), mono_dib([0x55; 8])])),
+            wrec(0x012D, &h16(1)),
+            wrec(0x012E, &h16(1)),
+            wtext(5, 5, b"Hello", 6, Some([0, 0, 50, 50]), &[1, 2, 3, 4, 5]),
+            wrec(0x041B, &cat(vec![h16(9), h16(9), h16(0), h16(0)])),
+        ],
+        Some([0, 0, 100, 100]),
+    );
+    let efile = emf(
+        &[efont(24, 900, 400, 1, 0, "Segoe UI"), erec(37, &h32(1)), etext(true, 1, 2, &[0x41, 0xD83D, 0xDE00], 0x2000, &[1, 2, 3, 4, 5, 6])],
+        [0, 0, 200, 100],
+        [0, 0, 5000, 2500],
+    );
+    let mut rng = Lcg(0x9E37_79B9_7F4A_7C15);
+    for file in [&wfile, &efile] {
+        for n in 0..=file.len() {
+            let _ = parse(&file[..n]);
+        }
+        for _ in 0..1500 {
+            let mut buf = file.clone();
+            for _ in 0..6 {
+                let at = rng.rnd() as usize % buf.len();
+                buf[at] = rng.rnd() as u8;
+            }
+            let _ = parse(&buf);
+        }
+    }
+}
+
+#[test]
+fn text_items_are_capped_like_any_other() {
+    let t = wtext(0, 0, b"x", 0, None, &[]);
+    let recs: Vec<Vec<u8>> = (0..MAX_ITEMS + 5).map(|_| t.clone()).collect();
+    let p = wmf200(&recs);
+    assert_eq!(p.items.len(), MAX_ITEMS);
+}
+
+#[test]
+fn pattern_brush_pixels_count_against_the_byte_budget() {
+    // 256 × 256 one-bit pattern brushes (256 KiB of RGBA each): far fewer than the object table
+    // holds fit the budget, and the parse stops there.
+    let mut dib = info_header(256, 256, 1, 0);
+    dib.extend([255, 255, 255, 0, 0, 0, 0, 0]);
+    dib.extend(vec![0x55u8; 32 * 256]);
+    let brush = wrec(0x0142, &cat(vec![h16(5), h16(0), dib]));
+    let mut recs: Vec<Vec<u8>> = (0..1100).map(|_| brush.clone()).collect();
+    recs.push(wrec(0x041B, &cat(vec![h16(9), h16(9), h16(0), h16(0)])));
+    let p = wmf200(&recs);
+    assert!(p.items.is_empty(), "the parse stopped at the budget: {:?}", p.items.len());
+}

crates/metafile/src/text.rs

@@ -0,0 +1,200 @@
+//! Text records: the font (LOGFONT), the text string decoded from its character set, and the
+//! neutral [`Text`] item. The metafile crate knows no fonts, so measuring, alignment against the
+//! font's metrics and glyph drawing are left to the renderer.
+
+/// A font chosen by a CREATEFONTINDIRECT record (MS-WMF 2.2.1.2 Font, MS-EMF 2.2.13 LogFont).
+#[derive(Debug, Clone, PartialEq, Default)]
+pub struct Font {
+    /// The face name the file asks for (`"Arial"`, `"Wingdings"`); may be empty.
+    pub family: String,
+    /// LOGFONT height in text units: negative is the character (em) height, positive the cell
+    /// height (ascent plus descent), 0 the default size.
+    pub height: f32,
+    /// Average character width in text units; 0 keeps the font's own proportions.
+    pub width: f32,
+    /// 100..=900 (400 regular, 700 bold); 0 is the default weight.
+    pub weight: u16,
+    pub italic: bool,
+    pub underline: bool,
+    pub strike: bool,
+    /// LOGFONT character set (0 ANSI, 2 SYMBOL, 238 EASTEUROPE…).
+    pub charset: u8,
+}
+
+/// SYMBOL_CHARSET: byte codes are the font's own symbol codes.
+pub const SYMBOL_CHARSET: u8 = 2;
+
+/// Where the reference point sits on the string horizontally (TA_LEFT, TA_CENTER, TA_RIGHT).
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub enum HAlign {
+    #[default]
+    Left,
+    Center,
+    Right,
+}
+
+/// Where the reference point sits vertically (TA_TOP, TA_BASELINE, TA_BOTTOM): the top of the
+/// character cell, the baseline or the bottom of the cell.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub enum VAlign {
+    #[default]
+    Top,
+    Baseline,
+    Bottom,
+}
+
+/// One string drawn by EXTTEXTOUT, TEXTOUT or SMALLTEXTOUT.
+#[derive(Debug, Clone, PartialEq)]
+pub struct Text {
+    /// Text space to picture space as affine coefficients `[a, b, c, d, e, f]` (`x' = a·x + c·y + e`,
+    /// `y' = b·x + d·y + f`, kurbo's order). Text space has x along the baseline and y down, in the
+    /// metafile's logical units, with the reference point at the origin. Escapement and the
+    /// mapping are folded in; glyphs are never mirrored.
+    pub transform: [f64; 6],
+    pub text: String,
+    /// Advance after each character of `text`, in text units (the dx array). Empty when the file
+    /// gives none: the font's own advances apply.
+    pub dx: Vec<f32>,
+    pub font: Font,
+    pub color: [u8; 4],
+    /// Colour filled behind the character cells (OPAQUE background mode); None when transparent.
+    pub background: Option<[u8; 4]>,
+    pub h_align: HAlign,
+    pub v_align: VAlign,
+    /// Clip rectangle `[x0, y0, x1, y1]` in picture units (ETO_CLIPPED).
+    pub clip: Option<[f32; 4]>,
+}
+
+/// TA_UPDATECP: the string starts at the current position, which moves past it.
+pub(crate) const TA_UPDATECP: u32 = 0x0001;
+/// ETO_OPAQUE fills the rectangle with the background colour; ETO_CLIPPED clips the text to it.
+pub(crate) const ETO_OPAQUE: u32 = 0x0002;
+pub(crate) const ETO_CLIPPED: u32 = 0x0004;
+/// The string holds glyph indices, not characters (drawn only when the font matches).
+pub(crate) const ETO_GLYPH_INDEX: u32 = 0x0010;
+/// The dx array holds (dx, dy) pairs.
+pub(crate) const ETO_PDY: u32 = 0x2000;
+/// Longest string kept from one record.
+pub(crate) const MAX_CHARS: usize = 16_384;
+
+/// Horizontal and vertical alignment from a TA_* word (the vertical bits are 0 top, 8 bottom,
+/// 24 baseline; the horizontal ones 0 left, 2 right, 6 center).
+pub(crate) fn align(ta: u32) -> (HAlign, VAlign) {
+    let h = match ta & 0x06 {
+        6 => HAlign::Center,
+        2 => HAlign::Right,
+        _ => HAlign::Left,
+    };
+    let v = match ta & 0x18 {
+        0x18 => VAlign::Baseline,
+        0x08 => VAlign::Bottom,
+        _ => VAlign::Top,
+    };
+    (h, v)
+}
+
+/// Decodes 8-bit text in `charset` to one character per byte, and merges `dx` to match: a
+/// double-byte character set's lead and trail bytes become one blank (its glyphs are not
+/// decoded) whose advance is the sum of both. `dx` may be empty.
+pub(crate) fn decode_bytes(bytes: &[u8], charset: u8, dx: &[f32]) -> (String, Vec<f32>) {
+    let mut s = String::with_capacity(bytes.len());
+    let mut out_dx = Vec::with_capacity(dx.len().min(bytes.len()));
+    let dbcs = matches!(charset, 128 | 129 | 130 | 134 | 136);
+    let mut i = 0;
+    while let Some(&b) = bytes.get(i) {
+        let n = if dbcs && b >= 0x81 && i + 1 < bytes.len() { 2 } else { 1 };
+        let c = if n == 2 { ' ' } else { byte_char(b, charset) };
+        s.push(c);
+        if !dx.is_empty() {
+            out_dx.push((i..i + n).filter_map(|k| dx.get(k)).sum());
+        }
+        i += n;
+    }
+    (s, out_dx)
+}
+
+/// UTF-16 text to a string with one dx entry per character: a surrogate pair takes the sum of
+/// its two advances. Unpaired surrogates become U+FFFD.
+pub(crate) fn decode_utf16(units: &[u16], dx: &[f32]) -> (String, Vec<f32>) {
+    let mut s = String::with_capacity(units.len());
+    let mut out_dx = Vec::with_capacity(dx.len().min(units.len()));
+    let mut i = 0;
+    for r in char::decode_utf16(units.iter().copied()) {
+        let c = r.unwrap_or(char::REPLACEMENT_CHARACTER);
+        let n = c.len_utf16();
+        s.push(c);
+        if !dx.is_empty() {
+            out_dx.push((i..i + n).filter_map(|k| dx.get(k)).sum());
+        }
+        i += n;
+    }
+    (s, out_dx)
+}
+
+/// One byte in a single-byte Windows code page. Symbol fonts keep their codes in the private-use
+/// range (U+F000 + code), where symbol fonts map them.
+fn byte_char(b: u8, charset: u8) -> char {
+    if b < 0x80 && charset != SYMBOL_CHARSET {
+        return char::from(b);
+    }
+    let cp = match charset {
+        SYMBOL_CHARSET => 0xF000 | u32::from(b),
+        238 => high(b, &CP1250),
+        204 => high(b, &CP1251),
+        _ => high(b, &CP1252),
+    };
+    char::from_u32(cp).unwrap_or(char::REPLACEMENT_CHARACTER)
+}
+
+/// The code point of byte `b` (0x80..=0xFF) from a table of the upper half; 0 entries are
+/// undefined bytes, drawn as U+FFFD.
+fn high(b: u8, table: &[u16; 128]) -> u32 {
+    match table.get(usize::from(b.wrapping_sub(0x80))) {
+        Some(0) | None => 0xFFFD,
+        Some(v) => u32::from(*v),
+    }
+}
+
+/// Windows-1252 (Western) 0x80..=0xFF: the upper half of Latin-1 with typographic marks in 0x80..=0x9F.
+const CP1252: [u16; 128] = {
+    let mut t = [0u16; 128];
+    let low: [u16; 32] = [
+        0x20AC, 0, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021, 0x02C6, 0x2030, 0x0160, 0x2039, 0x0152, 0, 0x017D, 0, 0, 0x2018, 0x2019, 0x201C,
+        0x201D, 0x2022, 0x2013, 0x2014, 0x02DC, 0x2122, 0x0161, 0x203A, 0x0153, 0, 0x017E, 0x0178,
+    ];
+    let mut i = 0;
+    while i < 128 {
+        t[i] = if i < 32 { low[i] } else { 0x80 + i as u16 };
+        i += 1;
+    }
+    t
+};
+
+/// Windows-1250 (Central European) 0x80..=0xFF.
+const CP1250: [u16; 128] = [
+    0x20AC, 0, 0x201A, 0, 0x201E, 0x2026, 0x2020, 0x2021, 0, 0x2030, 0x0160, 0x2039, 0x015A, 0x0164, 0x017D, 0x0179, //
+    0, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014, 0, 0x2122, 0x0161, 0x203A, 0x015B, 0x0165, 0x017E, 0x017A, //
+    0x00A0, 0x02C7, 0x02D8, 0x0141, 0x00A4, 0x0104, 0x00A6, 0x00A7, 0x00A8, 0x00A9, 0x015E, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x017B, //
+    0x00B0, 0x00B1, 0x02DB, 0x0142, 0x00B4, 0x00B5, 0x00B6, 0x00B7, 0x00B8, 0x0105, 0x015F, 0x00BB, 0x013D, 0x02DD, 0x013E, 0x017C, //
+    0x0154, 0x00C1, 0x00C2, 0x0102, 0x00C4, 0x0139, 0x0106, 0x00C7, 0x010C, 0x00C9, 0x0118, 0x00CB, 0x011A, 0x00CD, 0x00CE, 0x010E, //
+    0x0110, 0x0143, 0x0147, 0x00D3, 0x00D4, 0x0150, 0x00D6, 0x00D7, 0x0158, 0x016E, 0x00DA, 0x0170, 0x00DC, 0x00DD, 0x0162, 0x00DF, //
+    0x0155, 0x00E1, 0x00E2, 0x0103, 0x00E4, 0x013A, 0x0107, 0x00E7, 0x010D, 0x00E9, 0x0119, 0x00EB, 0x011B, 0x00ED, 0x00EE, 0x010F, //
+    0x0111, 0x0144, 0x0148, 0x00F3, 0x00F4, 0x0151, 0x00F6, 0x00F7, 0x0159, 0x016F, 0x00FA, 0x0171, 0x00FC, 0x00FD, 0x0163, 0x02D9,
+];
+
+/// Windows-1251 (Cyrillic) 0x80..=0xFF; 0xC0..=0xFF are А..я in order.
+const CP1251: [u16; 128] = {
+    let low: [u16; 64] = [
+        0x0402, 0x0403, 0x201A, 0x0453, 0x201E, 0x2026, 0x2020, 0x2021, 0x20AC, 0x2030, 0x0409, 0x2039, 0x040A, 0x040C, 0x040B, 0x040F, //
+        0x0452, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014, 0, 0x2122, 0x0459, 0x203A, 0x045A, 0x045C, 0x045B, 0x045F, //
+        0x00A0, 0x040E, 0x045E, 0x0408, 0x00A4, 0x0490, 0x00A6, 0x00A7, 0x0401, 0x00A9, 0x0404, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x0407, //
+        0x00B0, 0x00B1, 0x0406, 0x0456, 0x0491, 0x00B5, 0x00B6, 0x00B7, 0x0451, 0x2116, 0x0454, 0x00BB, 0x0458, 0x0405, 0x0455, 0x0457,
+    ];
+    let mut t = [0u16; 128];
+    let mut i = 0;
+    while i < 128 {
+        t[i] = if i < 64 { low[i] } else { 0x0410 + (i as u16 - 64) };
+        i += 1;
+    }
+    t
+};

crates/metafile/src/wmf.rs

@@ -1,14 +1,19 @@
 //! WMF reader (MS-WMF). A file is an optional 22-byte placeable header, a 9-word standard header, then
 //! records of (size in 16-bit words, function, parameters). Parameters are read at byte 6 of each record.
 
+use std::sync::Arc;
+
 use crate::bytes::Bytes;
-use crate::canvas::{Brush, Canvas, Obj, Pen, colorref};
+use crate::canvas::{BS_HATCHED, Brush, Canvas, LogFont, Obj, Pen, colorref};
 use crate::dib;
 use crate::geom::{self, ArcKind, P};
+use crate::text::{ETO_CLIPPED, ETO_OPAQUE, Font, MAX_CHARS, decode_bytes};
 use crate::{Error, Frame, MAX_PATH_OPS};
 
 const PLACEABLE_KEY: u32 = 0x9AC6_CDD7;
 const DEFAULT_INCH: f64 = 1440.0;
+/// A placeable WMF plays into a target sized in points; brushes are laid out in 96-dpi pixels.
+const PT_PER_PX: f64 = 72.0 / 96.0;
 
 pub(crate) fn is_wmf(b: Bytes) -> bool {
     if b.u32(0) == Some(PLACEABLE_KEY) {
@@ -42,6 +47,7 @@ pub(crate) fn parse(input: Bytes) -> Result<(Canvas, Option<Frame>), Error> {
     let mut cv = Canvas::new();
     if let Some((c, size)) = bounds {
         cv.play_into(Some([c[0], c[1], c[2] - c[0], c[3] - c[1]]), size);
+        cv.pattern_px = PT_PER_PX;
     }
     let mut player_viewport = bounds.is_some();
     let mut parsed = 0usize;
@@ -128,12 +134,31 @@ fn record(cv: &mut Canvas, func: u16, r: Bytes) {
         }),
         0x02FA => create_pen(cv, r),
         0x02FC => create_brush(cv, r),
-        // Fonts, palettes, pattern brushes and regions take a handle slot too, so later SELECTOBJECT
-        // handles count them; selecting one draws nothing.
-        0x02FB | 0x00F7 | 0x01F9 | 0x0142 | 0x06FF => {
+        0x02FB => {
+            let f = font(r).unwrap_or_default();
+            cv.add_object(None, Obj::Font(Arc::new(f)));
+            Some(())
+        }
+        0x0142 => {
+            // A pattern the reader cannot decode still takes its handle slot.
+            let b = dib_pattern_brush(r).map_or(Obj::Other, Obj::Brush);
+            cv.add_object(None, b);
+            Some(())
+        }
+        // Palettes, old-style pattern brushes and regions take a handle slot too, so later
+        // SELECTOBJECT handles count them; selecting one draws nothing.
+        0x00F7 | 0x01F9 | 0x06FF => {
             cv.add_object(None, Obj::Other);
             Some(())
         }
+        0x0209 => r.u32(6).map(|c| cv.set_text_color(c)),
+        0x0201 => r.u32(6).map(|c| cv.set_bk_color(c)),
+        0x0102 => r.u16(6).map(|m| cv.set_bk_mode(u32::from(m))),
+        0x012E => r.u16(6).map(|a| cv.set_text_align(u32::from(a))),
+        0x0A32 => ext_text_out(cv, r),
+        0x0521 => text_out(cv, r),
+        // PATBLT: rop(4), height, width, y, x.
+        0x061D => r.u32(6).map(|rop| cv.fill_rop([i16s(r, 16), i16s(r, 14), i16s(r, 12), i16s(r, 10)], rop)),
         0x012D => r.u16(6).map(|h| cv.select(wmf_handle(h))),
         0x01F0 => r.u16(6).map(|h| cv.delete_object(u32::from(h))),
         // STRETCHDIB: rop(4) usage(2) srcH srcW ySrc xSrc destH destW yDest xDest, then the DIB.
@@ -168,11 +193,93 @@ fn create_pen(cv: &mut Canvas, r: Bytes) -> Option<()> {
     Some(())
 }
 
-/// CREATEBRUSHINDIRECT: style, colour, hatch (hatch is not drawn).
+/// CREATEBRUSHINDIRECT: style, colour, hatch.
 fn create_brush(cv: &mut Canvas, r: Bytes) -> Option<()> {
-    let style = r.u16(6)?;
+    let style = u32::from(r.u16(6)?);
     let color = r.u32(8)?;
-    cv.add_object(None, Obj::Brush(Brush { style: u32::from(style), color: colorref(color) }));
+    let mut b = Brush::new(style, colorref(color));
+    if style == BS_HATCHED {
+        b.hatch = u32::from(r.u16(12).unwrap_or(0));
+    }
+    cv.add_object(None, Obj::Brush(b));
+    Some(())
+}
+
+/// DIBCREATEPATTERNBRUSH: style, colour usage, then a DIB (MS-WMF 2.3.4.8). The DIB's own palette
+/// gives the colours; with DIB_PAL_COLORS (indices into a palette the reader does not keep) a
+/// monochrome DIB takes the text and background colours.
+fn dib_pattern_brush(r: Bytes) -> Option<Brush> {
+    let usage = r.u16(8)?;
+    let dib = r.tail(10)?;
+    let n = dib::info_len(dib)?;
+    let img = dib::decode(Bytes(dib.slice(0, n)?), dib.tail(n)?, false)?;
+    Brush::pattern(img, usage == 1)
+}
+
+/// Font object (MS-WMF 2.2.1.2): height, width, escapement, orientation, weight (i16 each), italic,
+/// underline, strike-out and charset bytes, three precision/quality bytes, pitch and family, then the
+/// face name (up to 32 bytes, NUL-terminated, in the font's character set).
+fn font(r: Bytes) -> Option<LogFont> {
+    let height = r.i16(6)?;
+    let width = r.i16(8).unwrap_or(0);
+    let escapement = r.i16(10).unwrap_or(0);
+    let weight = r.i16(14).unwrap_or(0);
+    let byte = |o: usize| r.0.get(o).copied().unwrap_or(0);
+    let charset = byte(19);
+    let name = r.0.get(24..).unwrap_or(&[]);
+    let name = name.get(..32).unwrap_or(name);
+    let name = name.split(|b| *b == 0).next().unwrap_or(&[]);
+    // Face names are plain ASCII in practice; other bytes go through the Western code page.
+    let (family, _) = decode_bytes(name, 0, &[]);
+    Some(LogFont {
+        font: Font {
+            family: family.trim().to_string(),
+            height: f32::from(height),
+            width: f32::from(width),
+            weight: weight.clamp(0, 1000) as u16,
+            italic: byte(16) != 0,
+            underline: byte(17) != 0,
+            strike: byte(18) != 0,
+            charset,
+        },
+        escapement: f64::from(escapement),
+    })
+}
+
+/// The charset of the selected font, for decoding 8-bit text.
+fn charset(cv: &Canvas) -> u8 {
+    cv.font_charset()
+}
+
+/// EXTTEXTOUT (MS-WMF 2.3.3.5): y, x, string length, options, the rectangle (left, top, right,
+/// bottom) when ETO_OPAQUE or ETO_CLIPPED is set, the string padded to a word, then an optional dx
+/// array of i16 advances.
+fn ext_text_out(cv: &mut Canvas, r: Bytes) -> Option<()> {
+    let (y, x) = (r.i16(6)?, r.i16(8)?);
+    let n = usize::from(r.u16(10)?).min(MAX_CHARS);
+    let opts = u32::from(r.u16(12)?);
+    let has_rect = opts & (ETO_OPAQUE | ETO_CLIPPED) != 0;
+    let rect = if has_rect { Some([i16s(r, 14), i16s(r, 16), i16s(r, 18), i16s(r, 20)]) } else { None };
+    let at = if has_rect { 22 } else { 14 };
+    // A string running past the record is cut to what the record holds.
+    let avail = r.0.len().saturating_sub(at);
+    let n = n.min(avail);
+    let bytes = r.slice(at, n)?;
+    let dx_at = at + n.next_multiple_of(2);
+    let dx: Vec<f32> = if r.0.len() >= dx_at + 2 * n { (0..n).filter_map(|i| r.i16(dx_at + 2 * i)).map(f32::from).collect() } else { Vec::new() };
+    let (text, dx) = decode_bytes(bytes, charset(cv), &dx);
+    cv.text((f64::from(x), f64::from(y)), text, dx, opts, rect);
+    Some(())
+}
+
+/// TEXTOUT (MS-WMF 2.3.3.20): string length, the string padded to a word, then y and x.
+fn text_out(cv: &mut Canvas, r: Bytes) -> Option<()> {
+    let n = usize::from(r.u16(6)?).min(MAX_CHARS);
+    let bytes = r.slice(8, n)?;
+    let at = 8 + n.next_multiple_of(2);
+    let (y, x) = (r.i16(at)?, r.i16(at + 2)?);
+    let (text, _) = decode_bytes(bytes, charset(cv), &[]);
+    cv.text((f64::from(x), f64::from(y)), text, Vec::new(), 0, None);
     Some(())
 }
 

crates/model/Cargo.toml

@@ -14,3 +14,4 @@ deckcraft-color = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 thiserror = { workspace = true }
+unicode-segmentation = { workspace = true }

crates/model/src/edit.rs

@@ -2,6 +2,7 @@
 //! with `\n` splits paragraphs; formatting a range splits runs at its ends.
 
 use crate::text::{Paragraph, Run, RunKind, RunProps, TextBody};
+use crate::words;
 
 /// (paragraph, char offset in the paragraph).
 pub type Pos = (usize, usize);
@@ -275,65 +276,109 @@ pub fn insert_body(body: &mut TextBody, pos: Pos, src: &TextBody) -> Pos {
     caret
 }
 
-fn is_word(c: char) -> bool {
-    c.is_alphanumeric() || c == '_' || c == '\''
+fn para_text(body: &TextBody, pi: usize) -> String {
+    body.paragraphs.get(pi).map(Paragraph::text).unwrap_or_default()
 }
 
-/// Word boundaries around `pos` (double-click selection).
+/// The word a double-click selects around `pos` (see [`words::word_at`]): the word without its
+/// trailing spaces, as PowerPoint selects it.
 pub fn word_at(body: &TextBody, pos: Pos) -> (Pos, Pos) {
     let (pi, ch) = clamp(body, pos);
-    let t: Vec<char> = body.paragraphs.get(pi).map(|p| p.text().chars().collect()).unwrap_or_default();
-    if t.is_empty() {
-        return ((pi, 0), (pi, 0));
-    }
-    let at = ch.min(t.len().saturating_sub(1));
-    let w = t.get(at).copied().is_some_and(is_word);
-    let mut s = at;
-    while s > 0 && t.get(s - 1).copied().is_some_and(|c| is_word(c) == w && !c.is_whitespace() || (w && is_word(c))) {
-        s -= 1;
-    }
-    let mut e = at;
-    while e < t.len() && t.get(e).copied().is_some_and(|c| is_word(c) == w && (w || !c.is_whitespace())) {
-        e += 1;
-    }
-    // Include trailing spaces after a word.
-    while w && e < t.len() && t.get(e) == Some(&' ') {
-        e += 1;
-    }
-    ((pi, s), (pi, e.max(s)))
+    let (s, e) = words::word_at(&para_text(body, pi), ch);
+    ((pi, s), (pi, e))
 }
 
-/// Next/previous word start (Option/Ctrl + arrows).
+/// Next/previous word stop (Ctrl+Right/Left on Windows, Option+arrows on the Mac). At the end of
+/// a paragraph Ctrl+Right goes to the start of the next one; at its start Ctrl+Left goes to the
+/// end of the previous one.
 pub fn word_move(body: &TextBody, pos: Pos, forward: bool) -> Pos {
     let (pi, ch) = clamp(body, pos);
-    let t: Vec<char> = body.paragraphs.get(pi).map(|p| p.text().chars().collect()).unwrap_or_default();
+    let t = para_text(body, pi);
     if forward {
-        if ch >= t.len() {
-            return if pi + 1 < body.paragraphs.len() { (pi + 1, 0) } else { (pi, ch) };
+        match words::next_stop(&t, ch) {
+            Some(s) => (pi, s),
+            None if pi + 1 < body.paragraphs.len() => (pi + 1, 0),
+            None => (pi, ch),
         }
-        let mut i = ch;
-        while i < t.len() && t.get(i).copied().is_some_and(is_word) {
-            i += 1;
-        }
-        while i < t.len() && !t.get(i).copied().is_some_and(is_word) {
-            i += 1;
-        }
-        (pi, i)
     } else {
-        if ch == 0 {
-            return if pi > 0 { (pi - 1, body.paragraphs.get(pi - 1).map(Paragraph::char_len).unwrap_or(0)) } else { (0, 0) };
+        match words::prev_stop(&t, ch) {
+            Some(s) => (pi, s),
+            None if pi > 0 => (pi - 1, body.paragraphs.get(pi - 1).map(Paragraph::char_len).unwrap_or(0)),
+            None => (pi, 0),
         }
-        let mut i = ch;
-        while i > 0 && !t.get(i - 1).copied().is_some_and(is_word) {
-            i -= 1;
-        }
-        while i > 0 && t.get(i - 1).copied().is_some_and(is_word) {
-            i -= 1;
-        }
-        (pi, i)
     }
 }
 
+/// Ctrl+Up: the start of the paragraph, or of the previous one when already there.
+pub fn para_up(body: &TextBody, pos: Pos) -> Pos {
+    let (pi, ch) = clamp(body, pos);
+    if ch > 0 { (pi, 0) } else { (pi.saturating_sub(1), 0) }
+}
+
+/// Ctrl+Down: the start of the next paragraph, or the end of the last one.
+pub fn para_down(body: &TextBody, pos: Pos) -> Pos {
+    let (pi, _) = clamp(body, pos);
+    if pi + 1 < body.paragraphs.len() { (pi + 1, 0) } else { (pi, body.paragraphs.get(pi).map(Paragraph::char_len).unwrap_or(0)) }
+}
+
+/// Delete a word from `pos` as Ctrl+Backspace (`forward == false`) or Ctrl+Delete does in
+/// PowerPoint; returns the caret.
+///
+/// Ctrl+Backspace deletes back to the previous word stop (at a paragraph's start it joins the
+/// paragraph to the one before). Ctrl+Delete deletes the rest of the word, or the spaces after a
+/// word and the next word, or up to the next stop (see [`words::delete_forward_end`]), then
+/// tidies the spacing as PowerPoint's smart cut does: spaces left before closing punctuation or
+/// at the end of the paragraph after a word go, and sentence punctuation left against a word
+/// gets a space. At a paragraph's end it joins the next paragraph.
+pub fn delete_word(body: &mut TextBody, pos: Pos, forward: bool) -> Pos {
+    if body.paragraphs.is_empty() {
+        return (0, 0);
+    }
+    let (pi, ch) = clamp(body, pos);
+    let t = para_text(body, pi);
+    if !forward {
+        let to = match words::prev_stop(&t, ch) {
+            Some(s) => (pi, s),
+            None => char_move(body, (pi, ch), false),
+        };
+        return delete(body, to, (pi, ch));
+    }
+    let Some(e) = words::delete_forward_end(&t, ch) else {
+        let to = char_move(body, (pi, ch), true);
+        return delete(body, (pi, ch), to);
+    };
+    let at = delete(body, (pi, ch), (pi, e));
+    smart_space(body, at)
+}
+
+/// PowerPoint's smart-cut spacing after a word was deleted at `at`; returns the caret.
+fn smart_space(body: &mut TextBody, at: Pos) -> Pos {
+    let (pi, s) = at;
+    let chars: Vec<char> = para_text(body, pi).chars().collect();
+    let after = chars.get(s).copied();
+    let before = s.checked_sub(1).and_then(|i| chars.get(i)).copied();
+    if after.is_none_or(words::is_closing_punct) && before.is_some_and(|c| c == ' ') {
+        let mut w = s;
+        while w > 0 && chars.get(w - 1) == Some(&' ') {
+            w -= 1;
+        }
+        if w > 0 && chars.get(w - 1).is_some_and(|c| c.is_alphanumeric()) {
+            return delete(body, (pi, w), (pi, s));
+        }
+        return at;
+    }
+    if let (Some(b), Some(a)) = (before, after)
+        && words::is_sentence_punct(b)
+        && a.is_alphanumeric()
+    {
+        let digits = s >= 2 && chars.get(s - 2).is_some_and(|c| c.is_numeric()) && a.is_numeric();
+        if !digits {
+            return insert(body, at, " ", None);
+        }
+    }
+    at
+}
+
 /// One character left/right across paragraph boundaries.
 pub fn char_move(body: &TextBody, pos: Pos, forward: bool) -> Pos {
     let (pi, ch) = clamp(body, pos);
@@ -361,6 +406,18 @@ pub fn end(body: &TextBody) -> Pos {
     (pi, body.paragraphs.get(pi).map(Paragraph::char_len).unwrap_or(0))
 }
 
+/// The case Shift+F3 changes `s` to next, as PowerPoint cycles it: lowercase → Capitalize Each
+/// Word → UPPERCASE → lowercase; any other mix goes to UPPERCASE first.
+pub fn next_case(s: &str) -> &'static str {
+    if s == s.to_lowercase() && s.chars().any(char::is_alphabetic) {
+        "title"
+    } else if s == s.to_uppercase() && s.chars().any(char::is_alphabetic) {
+        "lower"
+    } else {
+        "upper"
+    }
+}
+
 /// Change case: `upper`, `lower`, `sentence`, `title`, `toggle`.
 pub fn change_case(s: &str, mode: &str) -> String {
     match mode {
@@ -456,7 +513,7 @@ mod tests {
     #[test]
     fn words_and_moves() {
         let b = body("Hello brave world");
-        assert_eq!(word_at(&b, (0, 7)), ((0, 6), (0, 12)));
+        assert_eq!(word_at(&b, (0, 7)), ((0, 6), (0, 11)));
         assert_eq!(word_move(&b, (0, 0), true), (0, 6));
         assert_eq!(word_move(&b, (0, 8), false), (0, 6));
         assert_eq!(char_move(&b, (0, 17), true), (0, 17));
@@ -472,4 +529,150 @@ mod tests {
         assert_eq!(b.paragraphs[0].char_len(), 3);
         assert_eq!(b.paragraphs.len(), 1);
     }
+
+    /// Ctrl+Backspace / Ctrl+Delete from `at`: the text and caret after (PowerPoint's results).
+    fn del_word(text: &str, at: Pos, forward: bool) -> (String, Pos) {
+        let mut b = body(text);
+        let c = delete_word(&mut b, at, forward);
+        (b.text(), c)
+    }
+
+    #[test]
+    fn ctrl_backspace_like_powerpoint() {
+        let t = "ab   cd...ef gh";
+        let want = [
+            ("ab   cd...ef gh", 0),
+            ("b   cd...ef gh", 0),
+            ("   cd...ef gh", 0),
+            ("  cd...ef gh", 0),
+            (" cd...ef gh", 0),
+            ("cd...ef gh", 0),
+            ("ab   d...ef gh", 5),
+            ("ab   ...ef gh", 5),
+            ("ab   cd..ef gh", 7),
+            ("ab   cd.ef gh", 7),
+            ("ab   cdef gh", 7),
+            ("ab   cd...f gh", 10),
+            ("ab   cd... gh", 10),
+            ("ab   cd...gh", 10),
+            ("ab   cd...ef h", 13),
+            ("ab   cd...ef ", 13),
+        ];
+        for (c, (txt, caret)) in want.iter().enumerate() {
+            assert_eq!(del_word(t, (0, c), false), (txt.to_string(), (0, *caret)), "caret {c}");
+        }
+        let w = "Hello world  foo, bar\nnext para";
+        assert_eq!(del_word(w, (0, 12), false), ("Hello  foo, bar\nnext para".into(), (0, 6)));
+        assert_eq!(del_word(w, (0, 17), false), ("Hello world  foo bar\nnext para".into(), (0, 16)));
+        // At a paragraph's start it joins the paragraph before.
+        assert_eq!(del_word(w, (1, 0), false), ("Hello world  foo, barnext para".into(), (0, 21)));
+        assert_eq!(del_word("ab\n  cd", (1, 2), false), ("ab\ncd".into(), (1, 0)));
+        // A line break is a word of its own.
+        let mut b = body("ab");
+        insert(&mut b, (0, 2), "\u{b}cd", None);
+        assert_eq!(delete_word(&mut b, (0, 3), false), (0, 2));
+        assert_eq!(b.text(), "abcd");
+        let mut b = body("ab");
+        insert(&mut b, (0, 2), "\u{b}cd", None);
+        assert_eq!(delete_word(&mut b, (0, 2), true), (0, 2));
+        assert_eq!(b.text(), "abcd");
+        assert_eq!(del_word("x", (0, 0), false), ("x".into(), (0, 0)));
+        // Emoji sequences and combining marks are never split.
+        assert_eq!(del_word("a 👨\u{200d}👩\u{200d}👧", (0, 7), false), ("a ".into(), (0, 2)));
+        assert_eq!(del_word("ce\u{301}te x", (0, 5), false), (" x".into(), (0, 0)));
+        assert_eq!(del_word("ce\u{301}te x", (0, 6), false), ("x".into(), (0, 0)));
+        // Each CJK character is a word.
+        assert_eq!(del_word("日本語", (0, 3), false), ("日本".into(), (0, 2)));
+    }
+
+    #[test]
+    fn ctrl_delete_like_powerpoint() {
+        let t = "ab   cd...ef gh";
+        let want = [
+            ("cd...ef gh", 0),
+            ("a   cd...ef gh", 1),
+            ("ab...ef gh", 2),
+            ("ab cd...ef gh", 3),
+            ("ab  cd...ef gh", 4),
+            ("ab...ef gh", 2),
+            ("ab   c...ef gh", 6),
+            ("ab   cdef gh", 7),
+            ("ab   cd. ef gh", 9),
+            ("ab   cd.. ef gh", 10),
+            ("ab   cd... gh", 11),
+            ("ab   cd...e gh", 11),
+            ("ab   cd...ef", 12),
+            ("ab   cd...ef", 12),
+            ("ab   cd...ef g", 14),
+            ("ab   cd...ef gh", 15),
+        ];
+        for (c, (txt, caret)) in want.iter().enumerate() {
+            assert_eq!(del_word(t, (0, c), true), (txt.to_string(), (0, *caret)), "caret {c}");
+        }
+        let w = "Hello world  foo, bar\nnext para";
+        let want = [
+            (0, "world  foo, bar\nnext para", 0),
+            (2, "He world  foo, bar\nnext para", 2),
+            (5, "Hello  foo, bar\nnext para", 5),
+            (6, "Hello foo, bar\nnext para", 6),
+            (8, "Hello wo  foo, bar\nnext para", 8),
+            (11, "Hello world, bar\nnext para", 11),
+            (12, "Hello world foo, bar\nnext para", 12),
+            (16, "Hello world  foobar\nnext para", 16),
+            (17, "Hello world  foo,\nnext para", 17),
+            (18, "Hello world  foo, \nnext para", 18),
+            (21, "Hello world  foo, barnext para", 21),
+        ];
+        for (c, txt, caret) in want {
+            assert_eq!(del_word(w, (0, c), true), (txt.to_string(), (0, caret)), "caret {c}");
+        }
+        assert_eq!(del_word(w, (1, 0), true), ("Hello world  foo, bar\npara".into(), (1, 0)));
+        assert_eq!(del_word(w, (1, 2), true), ("Hello world  foo, bar\nne para".into(), (1, 2)));
+        assert_eq!(del_word("ab  \ncd", (0, 2), true), ("ab\ncd".into(), (0, 2)));
+        assert_eq!(del_word("ab  \ncd", (0, 3), true), ("ab\ncd".into(), (0, 2)));
+        assert_eq!(del_word("ab\t cd", (0, 2), true), ("ab cd".into(), (0, 2)));
+        assert_eq!(del_word("ab cd(x) ef", (0, 3), true), ("ab (x) ef".into(), (0, 3)));
+        assert_eq!(del_word("ab cd, ef", (0, 3), true), ("ab, ef".into(), (0, 2)));
+        assert_eq!(del_word("ab. (cd) ef", (0, 5), true), ("ab. () ef".into(), (0, 5)));
+        assert_eq!(del_word("ab \"cd\" ef", (0, 4), true), ("ab \"\" ef".into(), (0, 4)));
+        assert_eq!(del_word("ab, cd", (0, 4), true), ("ab, ".into(), (0, 4)));
+        // Right-to-left text deletes in logical order like any other.
+        assert_eq!(del_word("مرحبا بالعالم hello", (0, 6), true), ("مرحبا hello".into(), (0, 6)));
+        assert_eq!(del_word("مرحبا بالعالم hello", (0, 8), false), ("مرحبا لعالم hello".into(), (0, 6)));
+        // Numbers keep their separators: no space is pushed into "3.14".
+        assert_eq!(del_word("3.x 14", (0, 2), true), ("3.14".into(), (0, 2)));
+        // Hostile positions clamp.
+        assert_eq!(del_word("ab", (9, 9), true).0, "ab");
+        assert_eq!(del_word("", (0, 0), false).0, "");
+        let mut empty = TextBody::default();
+        assert_eq!(delete_word(&mut empty, (3, 3), true), (0, 0));
+    }
+
+    #[test]
+    fn paragraph_moves() {
+        let b = body("one two\nthree\n\nfour");
+        assert_eq!(para_down(&b, (0, 2)), (1, 0));
+        assert_eq!(para_down(&b, (1, 0)), (2, 0));
+        assert_eq!(para_down(&b, (3, 1)), (3, 4));
+        assert_eq!(para_up(&b, (3, 2)), (3, 0));
+        assert_eq!(para_up(&b, (3, 0)), (2, 0));
+        assert_eq!(para_up(&b, (0, 0)), (0, 0));
+        assert_eq!(word_move(&b, (0, 4), true), (0, 7));
+        assert_eq!(word_move(&b, (0, 7), true), (1, 0));
+        assert_eq!(word_move(&b, (1, 0), false), (0, 7));
+        assert_eq!(word_move(&b, (2, 0), true), (3, 0));
+        assert_eq!(word_move(&b, (3, 4), true), (3, 4));
+        assert_eq!(word_move(&b, (0, 0), false), (0, 0));
+    }
+
+    #[test]
+    fn case_cycle() {
+        assert_eq!(next_case("hello world"), "title");
+        assert_eq!(next_case("Hello World"), "upper");
+        assert_eq!(next_case("HELLO WORLD"), "lower");
+        assert_eq!(next_case("Hello world"), "upper");
+        assert_eq!(next_case("hELLO wORLD"), "upper");
+        assert_eq!(next_case("hello. world is HERE"), "upper");
+        assert_eq!(next_case("123"), "upper");
+    }
 }

crates/model/src/lib.rs

@@ -16,6 +16,7 @@ pub mod style;
 pub mod table;
 pub mod text;
 pub mod theme;
+pub mod words;
 
 use std::sync::Arc;
 

crates/model/src/words.rs

@@ -0,0 +1,420 @@
+//! Word boundaries in a paragraph, as PowerPoint's Ctrl+arrow, Ctrl+Backspace/Delete and
+//! double-click see them (observed black-box on PowerPoint for Windows, see
+//! `docs/ui-parity.md`, Text editing keys).
+//!
+//! A paragraph splits into *tokens*. Each token is a run of one class of grapheme clusters plus
+//! the spaces that follow it:
+//!
+//! - **word**: letters, digits and combining marks. An apostrophe (`'` or `’`) joins a word when a
+//!   letter or digit follows it (`it's`, `'tis`, but `dogs'` ends before it); a hyphen joins when
+//!   a letter or digit comes before it (`a-b`, `1-2`, `a-`); `.`, `,` and `:` join between digits
+//!   (`3.14`, `1,000`, `3:45`, but `e.g.` is five tokens).
+//! - **punctuation**: everything else that is not a symbol; a run of it is one token (`...`,
+//!   `?!`, `),`, `。。`). `_`, `@`, `/`, `#`, quotes and brackets are punctuation.
+//! - **symbol**: emoji and pictographs (a run of them is one token, `👍👍`), `©`, `®`, `™`.
+//! - **ideograph**: each CJK ideograph, kana or Hangul syllable is a token of its own.
+//! - **tab** and **line break**: each is a token of its own, and spaces after one form their own
+//!   token instead of joining it.
+//! - **space**: U+0020, no-break space, ideographic space and the other fixed-width spaces. Spaces
+//!   join the token before them; spaces at the start of a paragraph (or after a tab or line break)
+//!   are a token of their own.
+//!
+//! Positions are character (Unicode scalar) offsets in the paragraph text, where a line break is
+//! one `\u{b}` character. A token never splits a grapheme cluster, so the caret never lands
+//! inside an emoji sequence or between a letter and its combining marks.
+
+use unicode_segmentation::UnicodeSegmentation;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum Class {
+    Space,
+    Tab,
+    Break,
+    Word,
+    Ideo,
+    Punct,
+    Symbol,
+}
+
+/// One grapheme cluster: its first character offset and class.
+#[derive(Clone, Copy, Debug)]
+struct Cluster {
+    start: usize,
+    class: Class,
+}
+
+/// A space for word movement: absorbed into the token before it.
+pub fn is_space(c: char) -> bool {
+    matches!(c, ' ' | '\u{a0}' | '\u{1680}' | '\u{2000}'..='\u{200a}' | '\u{202f}' | '\u{205f}' | '\u{3000}')
+}
+
+/// CJK ideographs, kana and Hangul: every one is a word of its own.
+fn is_ideo(c: char) -> bool {
+    matches!(c,
+        '\u{1100}'..='\u{11ff}'
+        | '\u{2e80}'..='\u{2fdf}'
+        | '\u{3005}'..='\u{3007}'
+        | '\u{3021}'..='\u{3029}'
+        | '\u{3031}'..='\u{3035}'
+        | '\u{3038}'..='\u{303c}'
+        | '\u{3040}'..='\u{309f}'
+        | '\u{30a0}'..='\u{30ff}'
+        | '\u{3100}'..='\u{318f}'
+        | '\u{31a0}'..='\u{31ff}'
+        | '\u{3400}'..='\u{4dbf}'
+        | '\u{4e00}'..='\u{9fff}'
+        | '\u{a960}'..='\u{a97f}'
+        | '\u{ac00}'..='\u{d7ff}'
+        | '\u{f900}'..='\u{faff}'
+        | '\u{ff66}'..='\u{ffdc}'
+        | '\u{20000}'..='\u{3134f}')
+}
+
+/// Emoji, pictographs and the common letter-like symbols.
+fn is_symbol(c: char) -> bool {
+    matches!(c,
+        '\u{a9}' | '\u{ae}' | '\u{2122}'
+        | '\u{2190}'..='\u{21ff}'
+        | '\u{2300}'..='\u{23ff}'
+        | '\u{25a0}'..='\u{27bf}'
+        | '\u{2b00}'..='\u{2bff}'
+        | '\u{1f000}'..='\u{1faff}')
+}
+
+fn base_class(c: char) -> Class {
+    match c {
+        '\u{b}' | '\n' | '\r' | '\u{2028}' | '\u{2029}' => Class::Break,
+        '\t' => Class::Tab,
+        c if is_space(c) => Class::Space,
+        c if is_ideo(c) => Class::Ideo,
+        c if c.is_alphanumeric() => Class::Word,
+        c if is_symbol(c) => Class::Symbol,
+        // A combining mark with no base (or any other mark) stays with letters.
+        '\u{300}'..='\u{36f}' | '\u{1ab0}'..='\u{1aff}' | '\u{1dc0}'..='\u{1dff}' | '\u{20d0}'..='\u{20ff}' | '\u{fe20}'..='\u{fe2f}' => Class::Word,
+        _ => Class::Punct,
+    }
+}
+
+fn clusters(text: &str) -> Vec<Cluster> {
+    let mut out: Vec<Cluster> = Vec::new();
+    let mut firsts: Vec<char> = Vec::new();
+    let mut pos = 0;
+    for g in text.graphemes(true) {
+        let n = g.chars().count();
+        let first = g.chars().next().unwrap_or(' ');
+        // "\r\n" is one grapheme; any other cluster takes the class of its first character.
+        out.push(Cluster { start: pos, class: base_class(first) });
+        firsts.push(first);
+        pos += n;
+    }
+    // Context: apostrophes, hyphens and number separators that belong to a word.
+    let classes: Vec<Class> = out.iter().map(|c| c.class).collect();
+    for (i, cl) in out.iter_mut().enumerate() {
+        let Some(&c) = firsts.get(i) else { continue };
+        let prev = i.checked_sub(1).and_then(|j| firsts.get(j)).copied();
+        let next = firsts.get(i + 1).copied();
+        let joins = match c {
+            '\'' | '\u{2019}' => next.is_some_and(char::is_alphanumeric),
+            '-' => prev.is_some_and(char::is_alphanumeric),
+            '.' | ',' | ':' => prev.is_some_and(char::is_numeric) && next.is_some_and(char::is_numeric),
+            _ => false,
+        };
+        if joins && classes.get(i) == Some(&Class::Punct) {
+            cl.class = Class::Word;
+        }
+    }
+    out
+}
+
+/// Does a token start at cluster `cur` (after `prev`)?
+fn starts_token(prev: Class, cur: Class) -> bool {
+    if cur == Class::Space {
+        // Spaces join the token before them, except after a tab or a line break.
+        return matches!(prev, Class::Tab | Class::Break);
+    }
+    prev == Class::Space || prev != cur || matches!(cur, Class::Ideo | Class::Tab | Class::Break)
+}
+
+/// The word stops of a paragraph's text in ascending order: 0, the start of every token, and the
+/// end of the text. Ctrl+Right goes to the next one.
+pub fn stops(text: &str) -> Vec<usize> {
+    let cs = clusters(text);
+    let mut out = vec![0];
+    for w in cs.windows(2) {
+        if let [a, b] = w
+            && starts_token(a.class, b.class)
+        {
+            out.push(b.start);
+        }
+    }
+    let n = text.chars().count();
+    if out.last() != Some(&n) {
+        out.push(n);
+    }
+    out
+}
+
+/// The stops Ctrl+Left uses. PowerPoint's backward scan differs from the forward one in two
+/// observed details: a no-break or other non-ASCII space is a stop of its own (unless an ASCII
+/// space follows it), and a symbol followed by punctuation (`👍?`) is one token.
+pub fn back_stops(text: &str) -> Vec<usize> {
+    let cs = clusters(text);
+    let chars: Vec<char> = text.chars().collect();
+    let mut out = vec![0];
+    for w in cs.windows(2) {
+        if let [a, b] = w {
+            let symbol_punct = matches!((a.class, b.class), (Class::Symbol, Class::Punct) | (Class::Punct, Class::Symbol));
+            if starts_token(a.class, b.class) && !symbol_punct {
+                out.push(b.start);
+            }
+        }
+    }
+    for (i, c) in chars.iter().enumerate() {
+        if *c != ' ' && is_space(*c) && chars.get(i + 1) != Some(&' ') && i > 0 {
+            out.push(i);
+        }
+    }
+    out.sort_unstable();
+    out.dedup();
+    let n = chars.len();
+    if out.last() != Some(&n) {
+        out.push(n);
+    }
+    out
+}
+
+/// The next stop after `ch` (Ctrl+Right), or `None` at the end of the text.
+pub fn next_stop(text: &str, ch: usize) -> Option<usize> {
+    stops(text).into_iter().find(|s| *s > ch)
+}
+
+/// The previous stop before `ch` (Ctrl+Left), or `None` at the start.
+pub fn prev_stop(text: &str, ch: usize) -> Option<usize> {
+    back_stops(text).into_iter().rev().find(|s| *s < ch)
+}
+
+/// Is the character at `i` a space (for word purposes)?
+fn space_at(chars: &[char], i: usize) -> bool {
+    chars.get(i).is_some_and(|c| is_space(*c))
+}
+
+/// The end of the token's text (before its trailing spaces) for the token containing `ch`.
+fn content_end(text: &str, ch: usize) -> usize {
+    let chars: Vec<char> = text.chars().collect();
+    let next = next_stop(text, ch).unwrap_or(chars.len());
+    let mut e = ch;
+    while e < next && !space_at(&chars, e) {
+        e += 1;
+    }
+    // A token made only of spaces (leading spaces) ends at the next stop.
+    if e == ch && space_at(&chars, ch) { next } else { e }
+}
+
+/// The word a double-click at `ch` selects: the token under the caret without its trailing
+/// spaces; on a space just after a token, that token; in a run of spaces, the spaces.
+pub fn word_at(text: &str, ch: usize) -> (usize, usize) {
+    let chars: Vec<char> = text.chars().collect();
+    let n = chars.len();
+    if n == 0 {
+        return (0, 0);
+    }
+    let ch = ch.min(n);
+    let on_space = ch >= n || space_at(&chars, ch);
+    let after_token = ch > 0 && !space_at(&chars, ch - 1);
+    let at = if on_space && after_token { ch - 1 } else { ch.min(n - 1) };
+    if space_at(&chars, at) {
+        let mut s = at;
+        while s > 0 && space_at(&chars, s - 1) {
+            s -= 1;
+        }
+        let mut e = at;
+        while e < n && space_at(&chars, e) {
+            e += 1;
+        }
+        return (s, e);
+    }
+    let s = stops(text).into_iter().rev().find(|s| *s <= at).unwrap_or(0);
+    (s, content_end(text, s).max(at + 1).min(n))
+}
+
+/// What Ctrl+Delete removes from `ch` (before smart spacing): inside a token, the rest of its
+/// text; on spaces right after a token, those spaces and the next token's text; anywhere else up
+/// to the next stop. `None` at the end of the text.
+pub fn delete_forward_end(text: &str, ch: usize) -> Option<usize> {
+    let chars: Vec<char> = text.chars().collect();
+    let n = chars.len();
+    if ch >= n {
+        return None;
+    }
+    let st = stops(text);
+    let at_stop = st.contains(&ch);
+    if !at_stop && !space_at(&chars, ch) {
+        return Some(content_end(text, ch));
+    }
+    let prev_is_text = ch > 0 && chars.get(ch - 1).is_some_and(|c| !is_space(*c) && !matches!(base_class(*c), Class::Tab | Class::Break));
+    if space_at(&chars, ch) && prev_is_text {
+        let mut j = ch;
+        while j < n && space_at(&chars, j) {
+            j += 1;
+        }
+        if j >= n {
+            return Some(n);
+        }
+        return Some(content_end(text, j));
+    }
+    st.into_iter().find(|s| *s > ch)
+}
+
+/// Closing punctuation that a smart delete pulls its word's spaces up to (`ab cd, ef` → Ctrl+Delete
+/// on `cd` gives `ab, ef`).
+pub fn is_closing_punct(c: char) -> bool {
+    matches!(c, '.' | ',' | ';' | ':' | '!' | '?' | ')' | ']' | '}' | '%' | '\u{2026}' | '\u{201d}' | '\u{2019}' | '\u{bb}')
+}
+
+/// Punctuation that a smart delete keeps a space after when a word follows (`cd...ef gh` →
+/// Ctrl+Delete on `ef` gives `cd... gh`).
+pub fn is_sentence_punct(c: char) -> bool {
+    matches!(c, '.' | ',' | ';' | ':' | '!' | '?' | '\u{2026}')
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Stops drawn as `|` in the text, for readable assertions.
+    fn marked(text: &str, st: &[usize]) -> String {
+        let mut out = String::new();
+        for (i, c) in text.chars().enumerate() {
+            if st.contains(&i) {
+                out.push('|');
+            }
+            out.push(match c {
+                '\u{b}' => '↵',
+                '\t' => '→',
+                c => c,
+            });
+        }
+        if st.contains(&text.chars().count()) {
+            out.push('|');
+        }
+        out
+    }
+    fn fwd(text: &str) -> String {
+        marked(text, &stops(text))
+    }
+    fn back(text: &str) -> String {
+        marked(text, &back_stops(text))
+    }
+
+    // Every expected string below is a stop trace observed in PowerPoint for Windows.
+    #[test]
+    fn punctuation_and_spaces() {
+        let t = "Hello, world!  Foo...bar baz-qux it's 3.14 e.g. a_b x@y.com (end) \"q\" end.";
+        let want = "|Hello|, |world|!  |Foo|...|bar |baz-qux |it's |3.14 |e|.|g|. |a|_|b |x|@|y|.|com |(|end|) |\"|q|\" |end|.|";
+        assert_eq!(fwd(t), want);
+        assert_eq!(back(t), want);
+    }
+
+    #[test]
+    fn hyphens_apostrophes_numbers() {
+        let t = "a-b -b a--b a - b a- b dogs' x 'q' 1,000.5 3:45 v1.2.3 $5 50% a/b x&y #tag a+b c++ end";
+        assert_eq!(
+            fwd(t),
+            "|a-b |-|b |a-|-|b |a |- |b |a- |b |dogs|' |x |'q|' |1,000.5 |3:45 |v1.2.3 |$|5 |50|% |a|/|b |x|&|y |#|tag |a|+|b |c|++ |end|"
+        );
+        let t = "it’s x a?!b a.)b a),b 1.a a1.b 1.5.x 1-2 a1-b A-1 —x x— a's 'tis o'clock ‘q’ end";
+        assert_eq!(fwd(t), "|it’s |x |a|?!|b |a|.)|b |a|),|b |1|.|a |a1|.|b |1.5|.|x |1-2 |a1-b |A-1 |—|x |x|— |a's |'tis |o'clock |‘|q|’ |end|");
+    }
+
+    #[test]
+    fn marks_emoji_symbols() {
+        let t = "café e\u{301}te 👍🏽 x 👨\u{200d}👩\u{200d}👧 y ½ ®z «q» “w” ¿no? ok—em dash–en x";
+        let want = "|café |e\u{301}te |👍🏽 |x |👨\u{200d}👩\u{200d}👧 |y |½ |®|z |«|q|» |“|w|” |¿|no|? |ok|—|em |dash|–|en |x|";
+        assert_eq!(fwd(t), want);
+        assert_eq!(back(t), want);
+        // A run of emoji is one token; emoji then punctuation is two going right, one going left.
+        assert_eq!(fwd("👍👍 x 👍? x👍y"), "|👍👍 |x |👍|? |x|👍|y|");
+        assert_eq!(back("👍👍 x 👍? x👍y"), "|👍👍 |x |👍? |x|👍|y|");
+    }
+
+    #[test]
+    fn cjk_each_character() {
+        let t = "日本語のテキストです。カタカナ漢字 abc 中文字符，标点。한국어 문장 a。。b";
+        assert_eq!(fwd(t), "|日|本|語|の|テ|キ|ス|ト|で|す|。|カ|タ|カ|ナ|漢|字 |abc |中|文|字|符|，|标|点|。|한|국|어 |문|장 |a|。。|b|");
+        assert_eq!(back(t), fwd(t));
+    }
+
+    #[test]
+    fn rtl_words_in_logical_order() {
+        let t = "Hello مرحبا بالعالم world שלום עולם end";
+        assert_eq!(fwd(t), "|Hello |مرحبا |بالعالم |world |שלום |עולם |end|");
+    }
+
+    #[test]
+    fn tabs_breaks_and_other_spaces() {
+        assert_eq!(fwd("  lead x   mid  "), "|  |lead |x   |mid  |");
+        assert_eq!(fwd("Five\u{b}six seven\tTab   x"), "|Five|↵|six |seven|→|Tab   |x|");
+        assert_eq!(fwd("a\t  b x  \u{b}  y q\u{b}\u{b}z"), "|a|→|  |b |x  |↵|  |y |q|↵|↵|z|");
+        let t = "a\u{a0}\u{a0}b a\u{3000}b a\u{2003}b a \u{a0}b a\t\tb a \tb a\u{a0} b end";
+        assert_eq!(fwd(t), "|a\u{a0}\u{a0}|b |a\u{3000}|b |a\u{2003}|b |a \u{a0}|b |a|→|→|b |a |→|b |a\u{a0} |b |end|");
+        assert_eq!(back(t), "|a|\u{a0}|\u{a0}|b |a|\u{3000}|b |a|\u{2003}|b |a |\u{a0}|b |a|→|→|b |a |→|b |a\u{a0} |b |end|");
+    }
+
+    #[test]
+    fn next_and_prev() {
+        let t = "  lead x   mid  ";
+        assert_eq!(next_stop(t, 1), Some(2));
+        assert_eq!(next_stop(t, 9), Some(11));
+        assert_eq!(next_stop(t, 16), None);
+        assert_eq!(prev_stop(t, 1), Some(0));
+        assert_eq!(prev_stop(t, 9), Some(7));
+        assert_eq!(prev_stop(t, 15), Some(11));
+        assert_eq!(prev_stop(t, 0), None);
+        assert_eq!(next_stop("", 0), None);
+        assert_eq!(prev_stop("", 0), None);
+    }
+
+    #[test]
+    fn double_click_word() {
+        let t = "Hello world,  foo bar";
+        assert_eq!(word_at(t, 7), (6, 11));
+        assert_eq!(word_at(t, 15), (14, 17));
+        assert_eq!(word_at(t, 11), (11, 12));
+        assert_eq!(word_at(t, 12), (11, 12));
+        assert_eq!(word_at(t, 13), (12, 14));
+        assert_eq!(word_at(t, 21), (18, 21));
+        assert_eq!(word_at("日本語のテキスト abc", 5), (5, 6));
+        assert_eq!(word_at("", 3), (0, 0));
+        assert_eq!(word_at("x👨\u{200d}👩\u{200d}👧y", 2), (1, 6));
+    }
+
+    #[test]
+    fn delete_forward_extent() {
+        let t = "ab   cd...ef gh";
+        let ends: Vec<Option<usize>> = (0..=t.len()).map(|c| delete_forward_end(t, c)).collect();
+        // Before smart spacing: PowerPoint's results after it are tested in `edit`.
+        assert_eq!(
+            ends,
+            vec![
+                Some(5),
+                Some(2),
+                Some(7),
+                Some(5),
+                Some(5),
+                Some(7),
+                Some(7),
+                Some(10),
+                Some(10),
+                Some(10),
+                Some(13),
+                Some(12),
+                Some(15),
+                Some(15),
+                Some(15),
+                None
+            ]
+        );
+        assert_eq!(delete_forward_end("ab\t cd", 2), Some(3));
+        assert_eq!(delete_forward_end("ab  ", 2), Some(4));
+    }
+}

crates/pptx/src/read/mod.rs

@@ -711,6 +711,10 @@ fn read_slide(imp: &mut Imp, part: &Part, doc: &Doc, id: SlideId, layout: Layout
         if let Some(tree) = csld.child("spTree") {
             s.shapes = shapes::sp_tree(imp, part, &mut ctx, tree, 0);
         }
+        if let Some(c) = csld.child("controls") {
+            let pics = shapes::controls(imp, part, &mut ctx, c);
+            s.shapes.extend(pics);
+        }
     }
     if let Some(t) = root.child("transition") {
         s.transition = timing::transition(imp, part, t);

crates/pptx/src/read/shapes.rs

@@ -87,6 +87,22 @@ pub fn sp_tree(imp: &mut Imp, part: &Part, ctx: &mut IdCtx, tree: &El, depth: us
     out
 }
 
+/// ActiveX controls (`p:controls`): each control's picture (`p:pic`), the image PowerPoint shows
+/// for it, as a picture above the slide's shapes. Controls without one are left out.
+pub fn controls(imp: &mut Imp, part: &Part, ctx: &mut IdCtx, controls: &El) -> Vec<Shape> {
+    let mut out = vec![];
+    for c in controls.children_named("control") {
+        if ctx.count >= MAX_SHAPES {
+            break;
+        }
+        if let Some(p) = c.child("pic") {
+            ctx.count += 1;
+            out.push(pic(imp, part, ctx, p));
+        }
+    }
+    out
+}
+
 fn remap_connectors(shapes: &mut [Shape], ctx: &IdCtx, depth: usize) {
     if depth > MAX_TREE_DEPTH {
         return;

crates/pptx/tests/ole_vml.rs

@@ -0,0 +1,84 @@
+//! Legacy OLE objects whose preview picture lives in the slide's VML drawing, and ActiveX controls
+//! shown by their pictures.
+
+use std::io::{Cursor, Read, Write};
+
+use deckcraft_model::ShapeKind;
+use deckcraft_model::defaults;
+
+const FRAME: &str = r#"<p:graphicFrame><p:nvGraphicFramePr><p:cNvPr id="90" 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_s2050" name="Slide" r:id="rIdOle" progId="Thing.1"><p:embed/></p:oleObj></a:graphicData></a:graphic></p:graphicFrame>"#;
+
+const VML: &str = r#"<xml xmlns:v="urn:schemas-microsoft-com:vml" xmlns:o="urn:schemas-microsoft-com:office:office"><v:shape id="_x0000_s2049"><v:imagedata o:relid="rIdA"/></v:shape><v:shape id="_x0000_s2050" style='position:absolute;left:0;top:0;width:1in;height:1in'><v:imagedata o:relid="rIdB" o:title=""/></v:shape></xml>"#;
+
+const VML_RELS: &str = r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rIdA" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/image" Target="../media/other.png"/><Relationship Id="rIdB" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/image" Target="../media/preview.png"/></Relationships>"#;
+
+const SLIDE_RELS: &str = r#"<Relationship Id="rIdVml" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/vmlDrawing" Target="../drawings/vmlDrawing1.vml"/><Relationship Id="rIdPic" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/image" Target="../media/preview.png"/>"#;
+
+/// An ActiveX control as PowerPoint writes it: a VML-only choice, and a fallback with its picture.
+const CONTROLS: &str = r#"<p:controls><mc:AlternateContent xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"><mc:Choice xmlns:v="urn:schemas-microsoft-com:vml" Requires="v"><p:control spid="1137" name="CheckBox1" r:id="rIdX" imgW="1933560" imgH="514440"/></mc:Choice><mc:Fallback><p:control name="CheckBox1" r:id="rIdX" imgW="1933560" imgH="514440"><p:pic><p:nvPicPr><p:cNvPr id="4" name="CheckBox1"/><p:cNvPicPr/><p:nvPr/></p:nvPicPr><p:blipFill><a:blip r:embed="rIdPic"/><a:stretch><a:fillRect/></a:stretch></p:blipFill><p:spPr><a:xfrm><a:off x="12700" y="25400"/><a:ext cx="127000" cy="63500"/></a:xfrm><a:prstGeom prst="rect"><a:avLst/></a:prstGeom></p:spPr></p:pic></p:control></mc:Fallback></mc:AlternateContent><p:control name="NoPicture" r:id="rIdY"/></p:controls>"#;
+
+fn png(v: u8) -> Vec<u8> {
+    let mut out = Cursor::new(vec![]);
+    image::DynamicImage::ImageRgb8(image::RgbImage::from_pixel(2, 2, image::Rgb([v, v, v])))
+        .write_to(&mut out, image::ImageFormat::Png)
+        .expect("png");
+    out.into_inner()
+}
+
+/// A new deck whose first slide holds [`FRAME`], with the VML drawing, its rels and two pictures.
+fn deck() -> Vec<u8> {
+    let bytes = deckcraft_pptx::export(&defaults::new_presentation(None)).expect("export");
+    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 == "ppt/slides/slide1.xml" {
+            let s = String::from_utf8(d).expect("utf8");
+            let at = s.rfind("</p:spTree>").expect("spTree");
+            let s = format!("{}{FRAME}{}", &s[..at], &s[at..]);
+            let at = s.rfind("</p:cSld>").expect("cSld");
+            d = format!("{}{CONTROLS}{}", &s[..at], &s[at..]).into_bytes();
+        } else if name == "ppt/slides/_rels/slide1.xml.rels" {
+            let s = String::from_utf8(d).expect("utf8");
+            d = s.replace("</Relationships>", &format!("{SLIDE_RELS}</Relationships>")).into_bytes();
+        }
+        out.start_file(name, o).expect("start");
+        out.write_all(&d).expect("write");
+    }
+    for (name, data) in [
+        ("ppt/drawings/vmlDrawing1.vml", VML.as_bytes().to_vec()),
+        ("ppt/drawings/_rels/vmlDrawing1.vml.rels", VML_RELS.as_bytes().to_vec()),
+        ("ppt/media/other.png", png(10)),
+        ("ppt/media/preview.png", png(200)),
+    ] {
+        out.start_file(name, o).expect("start");
+        out.write_all(&data).expect("write");
+    }
+    out.finish().expect("finish").into_inner()
+}
+
+#[test]
+fn an_ole_object_without_a_picture_shows_its_vml_preview() {
+    let p = deckcraft_pptx::import(&deck()).expect("import");
+    let s = p.slides[0].shapes.iter().find(|s| s.name == "Object 3").expect("frame");
+    let ShapeKind::Opaque { preview: Some(m), label, .. } = &s.kind else { panic!("{:?}", s.kind) };
+    assert_eq!(label, "Thing.1");
+    let media = p.media.iter().find(|x| x.id == *m).expect("media");
+    // The shape whose id is the object's spid, not the first one in the drawing.
+    assert_eq!(media.name, "preview.png");
+}
+
+#[test]
+fn activex_controls_show_their_pictures() {
+    let p = deckcraft_pptx::import(&deck()).expect("import");
+    let s = p.slides[0].shapes.iter().find(|s| s.name == "CheckBox1").expect("control picture");
+    let ShapeKind::Picture { fill } = &s.kind else { panic!("{:?}", s.kind) };
+    assert_eq!(p.media.iter().find(|m| m.id == fill.media).map(|m| m.name.as_str()), Some("preview.png"));
+    let x = s.xfrm.expect("xfrm");
+    assert_eq!((x.x, x.y, x.w, x.h), (1.0, 2.0, 10.0, 5.0));
+    assert!(!p.slides[0].shapes.iter().any(|s| s.name == "NoPicture"), "a control without a picture draws nothing");
+}

crates/render/src/lib.rs

@@ -238,11 +238,14 @@ pub struct Renderer {
     /// What the frame being drawn has painted so far, in output pixels: the editor learns from it
     /// how far a slide's drawing (text spilling out of its box too) reaches off the slide.
     drawn: Option<Rect>,
+    /// The transform a top-level shape is drawn under (slide to pixels); a group's children draw
+    /// under it combined with the group's child-coordinate mapping, which must not scale lines.
+    view: Affine,
 }
 
 impl Default for Renderer {
     fn default() -> Self {
-        Renderer { resources: Resources::new(), paths: Vec::new(), bg: None, drawn: None }
+        Renderer { resources: Resources::new(), paths: Vec::new(), bg: None, drawn: None, view: Affine::IDENTITY }
     }
 }
 
@@ -660,6 +663,25 @@ impl Renderer {
     }
 
     fn shape(&mut self, ctx: &mut RenderContext, f: &Frame, rctx: &Ctx, s: &Shape, parent: Affine, depth: usize) {
+        if depth == 0 {
+            let outer = std::mem::replace(&mut self.view, parent);
+            self.shape_at(ctx, f, rctx, s, parent, depth);
+            self.view = outer;
+        } else {
+            self.shape_at(ctx, f, rctx, s, parent, depth);
+        }
+    }
+
+    /// How lines are drawn for a shape under `m` at `depth`: the transform to stroke under and the
+    /// one that takes the shape's outline into it. Inside a group they are the slide-level view and
+    /// the rest of the chain, so the group's child-coordinate scale moves and sizes the outline but
+    /// never the line width; outside a group, `m` itself and no change to the outline.
+    fn line_space(&self, m: Affine, depth: usize) -> (Affine, Affine) {
+        let view = self.view;
+        if depth > 0 && view.determinant().abs() > 1e-12 && view.is_finite() { (view, view.inverse() * m) } else { (m, Affine::IDENTITY) }
+    }
+
+    fn shape_at(&mut self, ctx: &mut RenderContext, f: &Frame, rctx: &Ctx, s: &Shape, parent: Affine, depth: usize) {
         if depth > 32 || (s.hidden && !f.opts.show_hidden) || f.opts.skip.contains(&s.id) {
             return;
         }
@@ -718,20 +740,34 @@ impl Renderer {
                             bp.line_to((*px, *py));
                         }
                     }
-                    ctx.set_transform(parent);
+                    let (base, rel) = self.line_space(parent, depth);
+                    bp.apply_affine(rel);
+                    ctx.set_transform(base);
                     ctx.set_paint(color(sk.color, if sk.highlighter { 0.4 } else { 1.0 }));
                     ctx.set_stroke(kurbo::Stroke::new(sk.width.max(0.1)).with_caps(kurbo::Cap::Round).with_join(kurbo::Join::Round));
                     ctx.stroke_path(&bp);
                 }
             }
-            _ => self.geometry_shape(ctx, f, rctx, s, m, x.w, x.h, &st),
+            _ => self.geometry_shape(ctx, f, rctx, s, m, x.w, x.h, &st, depth),
         }
         if layered {
             ctx.pop_layer();
         }
     }
 
-    fn geometry_shape(&mut self, ctx: &mut RenderContext, f: &Frame, rctx: &Ctx, s: &Shape, m: Affine, w: f64, h: f64, st: &ShapeState) {
+    #[allow(clippy::too_many_arguments)]
+    fn geometry_shape(
+        &mut self,
+        ctx: &mut RenderContext,
+        f: &Frame,
+        rctx: &Ctx,
+        s: &Shape,
+        m: Affine,
+        w: f64,
+        h: f64,
+        st: &ShapeState,
+        depth: usize,
+    ) {
         let (geo, fades) = match self.paths.iter().find(|p| p.id == s.id) {
             Some(pm) => morph_path::geometry(pm, s, w, h),
             None => (shape_geometry(s, w, h), Vec::new()),
@@ -816,11 +852,19 @@ impl Renderer {
         // Outline.
         if line.fill.as_ref().is_some_and(|f| !f.is_none()) {
             let lw = line.width.unwrap_or(0.75).max(0.0);
+            let (base, rel) = self.line_space(m, depth);
             for (i, sp) in geo.paths.iter().enumerate().filter(|(i, p)| p.stroke && fade(*i).stroke > 0.0) {
-                stroke(ctx, rctx, &line, line_ph, &sp.path, m, lw, fade(i).stroke);
+                let path = if rel == Affine::IDENTITY {
+                    std::borrow::Cow::Borrowed(&sp.path)
+                } else {
+                    let mut moved = sp.path.clone();
+                    moved.apply_affine(rel);
+                    std::borrow::Cow::Owned(moved)
+                };
+                stroke(ctx, rctx, &line, line_ph, &path, base, lw, fade(i).stroke);
             }
             if s.is_line() || geo.is_open() {
-                arrowheads(ctx, rctx, &line, line_ph, &geo, m, lw);
+                arrowheads(ctx, rctx, &line, line_ph, &geo, rel, base, lw);
             }
         }
         if let Some(r) = soft {
@@ -1069,9 +1113,12 @@ fn end_points(path: &BezPath) -> Option<((Point, Point), (Point, Point))> {
     Some(((first, second), (last, prev)))
 }
 
-fn arrowheads(ctx: &mut RenderContext, rctx: &Ctx, line: &Line, ph: Option<Rgba>, geo: &Geometry, m: Affine, lw: f64) {
+#[allow(clippy::too_many_arguments)]
+fn arrowheads(ctx: &mut RenderContext, rctx: &Ctx, line: &Line, ph: Option<Rgba>, geo: &Geometry, rel: Affine, m: Affine, lw: f64) {
     let Some(sp) = geo.paths.iter().find(|p| p.stroke) else { return };
     let Some(((a, a2), (b, b2))) = end_points(&sp.path) else { return };
+    // The outline's ends in the space the arrowheads are sized and drawn in.
+    let (a, a2, b, b2) = (rel * a, rel * a2, rel * b, rel * b2);
     let col = match &line.fill {
         Some(Fill::Solid { color: c }) => rctx.color(c, ph),
         _ => Rgba::BLACK,

crates/render/src/metafile.rs

@@ -1,17 +1,30 @@
 //! Windows Metafile and Enhanced Metafile pictures (`image/x-wmf`, `image/x-emf`): parsed by
 //! `deckcraft-metafile` and drawn as vectors into a bitmap of the size the slide needs, so they go
 //! through the same crop, tile and recolour path as any other picture.
+//!
+//! Text items name the font the file asks for; they are drawn with the face slide text would use
+//! for that family (`FontDb::document_face`, so a missing font falls back the same way), symbol
+//! fonts mapped as bullets map them, and the file's own advances (the dx array) placing each
+//! character.
 
+use std::collections::HashMap;
 use std::sync::Arc;
 
-use deckcraft_metafile::PlacedItem;
-use kurbo::{Affine, Rect, Shape as _};
+use deckcraft_fonts::{FontDb, FontFace};
+use deckcraft_metafile::{HAlign, Item, PlacedItem, Text, Tile, VAlign};
+use kurbo::{Affine, BezPath, Rect, Shape as _};
+use skrifa::MetadataProvider as _;
 use vello_cpu::{Pixmap, RenderContext, Resources, peniko};
 
 /// Longest side of a metafile drawn without a target size (export, thumbnails of the picture).
 pub const DEFAULT_SIDE: u32 = 1024;
 /// Largest side drawn.
 const MAX_SIDE: u32 = 8192;
+/// Pattern cells smaller than this (output pixels) are drawn as the tile's average colour: a
+/// sub-pixel pattern would only alias.
+const MIN_CELL_PX: f64 = 1.5;
+/// Size of text whose font gives no height (LOGFONT height 0), in text units.
+const DEFAULT_EM: f64 = 12.0;
 
 /// Is `bytes` a WMF or EMF file?
 pub fn is_metafile(bytes: &[u8]) -> bool {
@@ -31,6 +44,8 @@ pub fn rasterize(bytes: &[u8], side: u32) -> Option<image::RgbaImage> {
     let w = (pw * k).round().clamp(1.0, MAX_SIDE as f64) as u16;
     let h = (ph * k).round().clamp(1.0, MAX_SIDE as f64) as u16;
     let pixmaps: Vec<Option<Arc<Pixmap>>> = pic.items.iter_mut().map(|it| it.take_pixels().and_then(|(w, h, px)| premul(w, h, &px))).collect();
+    // Pattern tiles shared by several fills are converted once.
+    let mut tiles: HashMap<*const Tile, (Option<Arc<Pixmap>>, peniko::Color)> = HashMap::new();
     let mut ctx = RenderContext::new_with(w, h, vello_cpu::RenderSettings { num_threads: 0, ..Default::default() });
     let r = Rect::new(0.0, 0.0, w as f64, h as f64);
     ctx.push_clip_layer(&r.to_path(0.1));
@@ -60,6 +75,43 @@ pub fn rasterize(bytes: &[u8], side: u32) -> Option<image::RgbaImage> {
                 ctx.fill_rect(&rect);
                 ctx.reset_paint_transform();
             }
+            PlacedItem::Pattern { index, path, even_odd, tile } => {
+                let Some(Item::Pattern { tile: t, .. }) = pic.items.get(index) else { continue };
+                let key = Arc::as_ptr(t);
+                let (pm, avg) = tiles.entry(key).or_insert_with(|| (premul(t.width, t.height, &t.rgba), average(&t.rgba))).clone();
+                ctx.set_fill_rule(if even_odd { peniko::Fill::EvenOdd } else { peniko::Fill::NonZero });
+                let cell = tile.determinant().abs().sqrt();
+                match pm {
+                    Some(pm) if cell >= MIN_CELL_PX => {
+                        ctx.set_paint(vello_cpu::Image {
+                            image: vello_cpu::ImageSource::Pixmap(pm),
+                            sampler: peniko::ImageSampler {
+                                x_extend: peniko::Extend::Repeat,
+                                y_extend: peniko::Extend::Repeat,
+                                quality: peniko::ImageQuality::Low,
+                                alpha: 1.0,
+                            },
+                        });
+                        ctx.set_paint_transform(tile);
+                        ctx.fill_path(&path);
+                        ctx.reset_paint_transform();
+                    }
+                    _ => {
+                        ctx.set_paint(avg);
+                        ctx.fill_path(&path);
+                    }
+                }
+            }
+            PlacedItem::Text { index, transform, clip } => {
+                let Some(Item::Text(t)) = pic.items.get(index) else { continue };
+                if let Some(c) = clip {
+                    ctx.push_clip_layer(&c.to_path(0.1));
+                }
+                draw_text(&mut ctx, t, transform);
+                if clip.is_some() {
+                    ctx.pop_layer();
+                }
+            }
         }
     }
     ctx.set_fill_rule(peniko::Fill::NonZero);
@@ -81,10 +133,213 @@ pub fn rasterize(bytes: &[u8], side: u32) -> Option<image::RgbaImage> {
     image::RgbaImage::from_raw(w as u32, h as u32, px)
 }
 
+/// One glyph placed in text space (x along the baseline from the string's start, font units at
+/// `scale` text units each).
+struct Glyph {
+    face: Arc<FontFace>,
+    gid: u32,
+    x: f64,
+    y: f64,
+}
+
+/// Draws a text item; `m` maps its text space to the output.
+fn draw_text(ctx: &mut RenderContext, t: &Text, m: Affine) {
+    let db = FontDb::global();
+    let font = &t.font;
+    let family = if font.family.trim().is_empty() { "Arial" } else { font.family.trim() };
+    let (bold, italic) = (font.weight >= 600, font.italic);
+    let style = match (bold, italic) {
+        (true, true) => "Bold Italic",
+        (true, false) => "Bold",
+        (false, true) => "Italic",
+        (false, false) => "Regular",
+    };
+    let face = db.document_face(family, style);
+    let upem = face.upem.max(1.0);
+    let (asc, desc) = win_metrics(&face);
+    // LOGFONT height: negative is the em, positive the cell (ascent plus descent).
+    let h = f64::from(font.height);
+    let em = if h < 0.0 {
+        -h
+    } else if h > 0.0 {
+        h * upem / (asc + desc).max(1.0)
+    } else {
+        DEFAULT_EM
+    };
+    let k = em / upem;
+    if !k.is_finite() || k <= 0.0 {
+        return;
+    }
+    // Characters as drawn: symbol fonts (Wingdings…) map like bullets; each character takes the
+    // face that has it.
+    let chars: Vec<char> = t.text.chars().map(|c| deckcraft_text::symbol_char(&face, family, c).unwrap_or(c)).collect();
+    let faces: Vec<Arc<FontFace>> = chars
+        .iter()
+        .map(|c| {
+            if c.is_whitespace() || c.is_control() || face.covers(*c) { face.clone() } else { db.cascade(&[*c], std::slice::from_ref(&face), style) }
+        })
+        .collect();
+    // Shape runs of one face; record each glyph's pen position and its character.
+    let mut shaped: Vec<(Glyph, usize)> = Vec::with_capacity(chars.len());
+    let mut char_pen: Vec<f64> = vec![0.0; chars.len() + 1];
+    let mut pen = 0.0;
+    let mut i = 0;
+    while i < chars.len() {
+        let Some(f) = faces.get(i).cloned() else { break };
+        let mut j = i + 1;
+        while faces.get(j).is_some_and(|g| g.id() == f.id()) {
+            j += 1;
+        }
+        let run: String = chars.get(i..j).unwrap_or(&[]).iter().collect();
+        // Byte offset in the run → character index in the string.
+        let byte_char: Vec<usize> = run.char_indices().map(|(b, _)| b).collect();
+        let ku = f.upem.max(1.0);
+        for g in deckcraft_fonts::shape(&f, &run, &[], |c| c) {
+            let ci = i + byte_char.partition_point(|b| *b < g.cluster).min(j - i - 1);
+            let s = em / ku;
+            shaped.push((Glyph { face: f.clone(), gid: g.gid, x: pen + f64::from(g.x_offset) * s, y: -f64::from(g.y_offset) * s }, ci));
+            pen += f64::from(g.x_advance) * s;
+            if let Some(p) = char_pen.get_mut(ci + 1) {
+                *p = pen;
+            }
+        }
+        i = j;
+    }
+    // Character start pens: a character's start is the previous one's end.
+    for ci in 1..char_pen.len() {
+        let prev = char_pen.get(ci - 1).copied().unwrap_or(0.0);
+        if let Some(p) = char_pen.get_mut(ci)
+            && *p < prev
+        {
+            *p = prev;
+        }
+    }
+    // The file's advances place each character; glyphs keep their offset within their character.
+    let use_dx = !t.dx.is_empty() && t.dx.len() == chars.len();
+    let mut width = pen;
+    let mut x_scale = 1.0;
+    if use_dx {
+        let mut starts = Vec::with_capacity(chars.len() + 1);
+        let mut x = 0.0;
+        for d in &t.dx {
+            starts.push(x);
+            x += f64::from(*d);
+        }
+        width = x;
+        for (g, ci) in &mut shaped {
+            let (start, pen_start) = (starts.get(*ci).copied().unwrap_or(0.0), char_pen.get(*ci).copied().unwrap_or(0.0));
+            g.x = start + (g.x - pen_start);
+        }
+    } else if font.width > 0.0 {
+        // A LOGFONT width narrows or widens the font against its average character width.
+        let avg = avg_char_width(&face) * k;
+        if avg > 0.0 {
+            x_scale = (f64::from(font.width) / avg).clamp(0.05, 20.0);
+            width *= x_scale;
+            for (g, _) in &mut shaped {
+                g.x *= x_scale;
+            }
+        }
+    }
+    let x0 = match t.h_align {
+        HAlign::Left => 0.0,
+        HAlign::Center => -width / 2.0,
+        HAlign::Right => -width,
+    };
+    let (a, d) = (asc * k, desc * k);
+    let base = match t.v_align {
+        VAlign::Baseline => 0.0,
+        VAlign::Top => a,
+        VAlign::Bottom => -d,
+    };
+    let at = m * Affine::translate((x0, base));
+    ctx.set_fill_rule(peniko::Fill::NonZero);
+    if let Some(bg) = t.background
+        && width > 0.0
+    {
+        ctx.set_paint(rgba(bg));
+        ctx.fill_path(&(at * Rect::new(0.0, -a, width, d).to_path(0.1)));
+    }
+    let color = rgba(t.color);
+    ctx.set_paint(color);
+    for (g, _) in &shaped {
+        let path = db.outline(&g.face, g.gid);
+        if path.elements().is_empty() {
+            continue;
+        }
+        let s = em / g.face.upem.max(1.0);
+        let skew = if italic && !g.face.italic { Affine::new([1.0, 0.0, -0.2, 1.0, 0.0, 0.0]) } else { Affine::IDENTITY };
+        let gm = at * Affine::translate((g.x, g.y)) * Affine::scale_non_uniform(x_scale, 1.0) * skew * Affine::scale(s);
+        let p: BezPath = gm * path.as_ref().clone();
+        ctx.fill_path(&p);
+        if bold && g.face.weight < 600.0 {
+            ctx.set_stroke(kurbo::Stroke::new(em * 0.025 * scale_of(at)).with_join(kurbo::Join::Round));
+            ctx.stroke_path(&p);
+        }
+    }
+    // Underline and strike-out: the font's own positions and thickness.
+    let metrics = face.skrifa().map(|f| f.metrics(skrifa::instance::Size::unscaled(), face.location()));
+    let deco = |on: bool, d: Option<skrifa::metrics::Decoration>, fallback: (f64, f64)| -> Option<Rect> {
+        if !on || width <= 0.0 {
+            return None;
+        }
+        let (off, th) = d.map_or(fallback, |d| (f64::from(d.offset) * k, f64::from(d.thickness) * k));
+        let th = if th > 0.0 { th } else { em / 20.0 };
+        // Offsets are y-up from the baseline; text space is y-down.
+        Some(Rect::new(0.0, -off - th / 2.0, width, -off + th / 2.0))
+    };
+    let lines = [
+        deco(font.underline, metrics.as_ref().and_then(|m| m.underline), (-em * 0.1, em / 20.0)),
+        deco(font.strike, metrics.as_ref().and_then(|m| m.strikeout), (em * 0.26, em / 20.0)),
+    ];
+    for r in lines.into_iter().flatten() {
+        ctx.fill_path(&(at * r.to_path(0.1)));
+    }
+}
+
+/// Mean scale of an affine transform's linear part.
+fn scale_of(m: Affine) -> f64 {
+    m.determinant().abs().sqrt()
+}
+
+/// The face's Windows ascent and descent (OS/2 `usWinAscent`/`usWinDescent`, as GDI measures the
+/// cell), in font units; the typographic ones when the font has no OS/2 table.
+fn win_metrics(face: &FontFace) -> (f64, f64) {
+    use skrifa::raw::TableProvider as _;
+    let os2 = face.skrifa().and_then(|f| f.os2().ok()).map(|o| (f64::from(o.us_win_ascent()), f64::from(o.us_win_descent())));
+    match os2 {
+        Some((a, d)) if a + d > 0.0 => (a, d),
+        _ => (face.ascent.max(0.0), face.descent.max(0.0)),
+    }
+}
+
+/// OS/2 `xAvgCharWidth` in font units (half an em without it).
+fn avg_char_width(face: &FontFace) -> f64 {
+    use skrifa::raw::TableProvider as _;
+    face.skrifa().and_then(|f| f.os2().ok()).map(|o| f64::from(o.x_avg_char_width())).filter(|w| *w > 0.0).unwrap_or(face.upem * 0.5)
+}
+
 fn rgba(c: [u8; 4]) -> peniko::Color {
     peniko::Color::from_rgba8(c[0], c[1], c[2], c[3])
 }
 
+/// The average colour of straight RGBA pixels (alpha-weighted).
+fn average(px: &[u8]) -> peniko::Color {
+    let (mut r, mut g, mut b, mut a, mut n) = (0u64, 0u64, 0u64, 0u64, 0u64);
+    for p in px.as_chunks::<4>().0 {
+        let w = u64::from(p[3]);
+        r += u64::from(p[0]) * w;
+        g += u64::from(p[1]) * w;
+        b += u64::from(p[2]) * w;
+        a += w;
+        n += 1;
+    }
+    if a == 0 || n == 0 {
+        return peniko::Color::from_rgba8(0, 0, 0, 0);
+    }
+    peniko::Color::from_rgba8((r / a) as u8, (g / a) as u8, (b / a) as u8, (a / n) as u8)
+}
+
 /// Straight RGBA rows to a premultiplied pixmap.
 fn premul(w: u32, h: u32, px: &[u8]) -> Option<Arc<Pixmap>> {
     if w == 0 || h == 0 || w > u16::MAX as u32 || h > u16::MAX as u32 || px.len() < w as usize * h as usize * 4 {

crates/render/src/tests.rs

@@ -1268,3 +1268,241 @@ fn text_spilling_out_of_its_box_below_the_slide_is_reported() {
     let (_, drawn) = render_slide_drawn(&Presentation::default(), 0, &RenderOpts { scale: 0.5, edit: true, ..Default::default() });
     assert_eq!(drawn, Rect::new(0.0, 0.0, 960.0, 540.0));
 }
+
+/// A placeable WMF (1440 units per inch, bounds `w` × `h`) holding `records` (function, parameter
+/// bytes).
+fn wmf_with(w: i16, h: i16, records: &[(u16, Vec<u8>)]) -> Vec<u8> {
+    let mut body = Vec::new();
+    for (func, params) in records {
+        let mut p = params.clone();
+        if p.len() % 2 == 1 {
+            p.push(0);
+        }
+        body.extend(((6 + p.len()) as u32 / 2).to_le_bytes());
+        body.extend(func.to_le_bytes());
+        body.extend(p);
+    }
+    body.extend([3, 0, 0, 0, 0, 0]);
+    let mut f = 0x9AC6_CDD7u32.to_le_bytes().to_vec();
+    f.extend(0u16.to_le_bytes());
+    for v in [0i16, 0, w, h] {
+        f.extend(v.to_le_bytes());
+    }
+    f.extend(1440u16.to_le_bytes());
+    f.extend(0u32.to_le_bytes());
+    f.extend(0u16.to_le_bytes());
+    let total = (f.len() + 18 + body.len()) / 2;
+    for v in [1u16, 9, 0x300] {
+        f.extend(v.to_le_bytes());
+    }
+    f.extend((total as u32).to_le_bytes());
+    f.extend(16u16.to_le_bytes());
+    f.extend(0u32.to_le_bytes());
+    f.extend(0u16.to_le_bytes());
+    f.extend(body);
+    f
+}
+
+fn i16s(v: &[i32]) -> Vec<u8> {
+    v.iter().flat_map(|x| (*x as i16).to_le_bytes()).collect()
+}
+
+/// CREATEFONTINDIRECT (height, escapement, face) then SELECTOBJECT of it (handle 0), transparent
+/// background, and the alignment `ta`.
+fn font_records(height: i32, esc: i32, face: &str, ta: i32) -> Vec<(u16, Vec<u8>)> {
+    let mut f = i16s(&[height, 0, esc, esc, 400]);
+    f.extend([0, 0, 0, if face.contains("dings") { 2 } else { 0 }, 0, 0, 0, 0]);
+    f.extend(face.as_bytes());
+    f.push(0);
+    vec![(0x02FB, f), (0x012D, i16s(&[0])), (0x0102, i16s(&[1])), (0x012E, i16s(&[ta]))]
+}
+
+/// EXTTEXTOUT at (x, y) with an optional dx array.
+fn text_record(x: i32, y: i32, s: &str, dx: &[i32]) -> (u16, Vec<u8>) {
+    let mut v = i16s(&[y, x, s.len() as i32, 0]);
+    v.extend(s.as_bytes());
+    if s.len() % 2 == 1 {
+        v.push(0);
+    }
+    v.extend(i16s(dx));
+    (0x0A32, v)
+}
+
+/// Bounding box (x0, y0, x1, y1) of the pixels at least half opaque and darker than mid-grey.
+fn mf_ink(img: &image::RgbaImage) -> Option<(u32, u32, u32, u32)> {
+    let mut b: Option<(u32, u32, u32, u32)> = None;
+    for (x, y, p) in img.enumerate_pixels() {
+        if p[3] > 128 && (p[0] as u32 + p[1] as u32 + p[2] as u32) < 384 {
+            b = Some(match b {
+                None => (x, y, x, y),
+                Some((a, c, d, e)) => (a.min(x), c.min(y), d.max(x), e.max(y)),
+            });
+        }
+    }
+    b
+}
+
+#[test]
+fn metafile_text_ink_lands_at_its_reference_point() {
+    // 2 × 1 inch (144 × 72 pt) drawn 288 px wide: 2 px per point. A 36-point "HH", top-left
+    // aligned at (72, 18) pt.
+    let mut recs = font_records(-720, 0, "Arial", 0);
+    recs.push(text_record(1440, 360, "HH", &[]));
+    let img = crate::metafile::rasterize(&wmf_with(2880, 1440, &recs), 288).expect("raster");
+    let (x0, y0, x1, y1) = mf_ink(&img).expect("text ink");
+    assert!((144..156).contains(&x0), "left edge at the reference point: {x0}");
+    assert!(x1 > x0 + 40 && x1 < 288, "two capitals wide: {x1}");
+    // The cell's top is at 36 px; a capital starts below the cell top and sits on the baseline.
+    assert!((38..72).contains(&y0), "cap top below the cell top: {y0}");
+    assert!((88..112).contains(&y1), "baseline one ascent below the top: {y1}");
+}
+
+#[test]
+fn metafile_text_centre_baseline_and_escapement() {
+    // TA_CENTER | TA_BASELINE at (72, 36) pt: the ink is centred on 144 px and sits on 72 px.
+    let mut recs = font_records(-720, 0, "Arial", 24 | 6);
+    recs.push(text_record(1440, 720, "HH", &[]));
+    let img = crate::metafile::rasterize(&wmf_with(2880, 1440, &recs), 288).expect("raster");
+    let (x0, _, x1, y1) = mf_ink(&img).expect("ink");
+    assert!(((x0 + x1) as i32 / 2 - 144).abs() <= 4, "centred: {x0}..{x1}");
+    assert!((69..=74).contains(&y1), "on the baseline: {y1}");
+    // Escapement 90°: the string runs up the picture.
+    let mut recs = font_records(-360, 900, "Arial", 24);
+    recs.push(text_record(1440, 1300, "HHHH", &[]));
+    let img = crate::metafile::rasterize(&wmf_with(2880, 1440, &recs), 288).expect("raster");
+    let (x0, y0, x1, y1) = mf_ink(&img).expect("ink");
+    assert!(y1 - y0 > 2 * (x1 - x0), "a vertical run: {x0} {y0} {x1} {y1}");
+    assert!(x1 <= 146 && y1 <= 132, "drawn up and left of the baseline origin (144, 130): {x1} {y1}");
+}
+
+#[test]
+fn metafile_text_follows_its_dx_array() {
+    // "HH" with the second H a full inch (144 px) after the first: two clumps of ink, a gap between.
+    let mut recs = font_records(-360, 0, "Arial", 24);
+    recs.push(text_record(360, 720, "HH", &[1440, 100]));
+    let img = crate::metafile::rasterize(&wmf_with(2880, 1440, &recs), 288).expect("raster");
+    let col_has_ink = |x: u32| (0..img.height()).any(|y| img.get_pixel(x, y)[3] > 128);
+    assert!((36..56).any(col_has_ink), "first H at 36 px");
+    assert!((180..200).any(col_has_ink), "second H one inch later");
+    assert!(!(70..170).any(col_has_ink), "nothing between them");
+}
+
+#[test]
+fn metafile_symbol_text_draws_a_bullet_not_a_box() {
+    // Webdings "n" is a filled circle (installed, or mapped to a black circle where it is not), as
+    // is Wingdings "l" in a symbol font that is not installed anywhere.
+    for (face, s) in [("Webdings", "n"), ("Wingdings Not Installed", "l")] {
+        let mut recs = font_records(-1080, 0, face, 0);
+        recs.push(text_record(360, 0, s, &[]));
+        let img = crate::metafile::rasterize(&wmf_with(2880, 1440, &recs), 288).expect("raster");
+        let (x0, y0, x1, y1) = mf_ink(&img).expect("ink");
+        assert!(x1 - x0 > 10 && y1 - y0 > 10, "{face}: a sizeable mark: {x0} {y0} {x1} {y1}");
+        let (cx, cy) = ((x0 + x1) / 2, (y0 + y1) / 2);
+        assert!(img.get_pixel(cx, cy)[3] > 200, "{face}: filled in the middle");
+        for (x, y) in [(x0, y0), (x1, y0), (x0, y1), (x1, y1)] {
+            assert!(img.get_pixel(x, y)[3] < 128, "{face}: round, not a box: corner ({x}, {y})");
+        }
+    }
+}
+
+#[test]
+fn metafile_opaque_text_fills_its_cell() {
+    // OPAQUE background in red behind a space.
+    let mut recs = font_records(-720, 0, "Arial", 0);
+    recs.push((0x0102, i16s(&[2])));
+    recs.push((0x0201, 0x0000_00FFu32.to_le_bytes().to_vec()));
+    recs.push(text_record(1440, 360, " ", &[]));
+    let img = crate::metafile::rasterize(&wmf_with(2880, 1440, &recs), 288).expect("raster");
+    let p = img.get_pixel(148, 60);
+    assert!(p[0] > 200 && p[1] < 60 && p[3] > 200, "cell filled red: {p:?}");
+    assert!(img.get_pixel(140, 60)[3] < 50, "nothing left of the cell");
+}
+
+#[test]
+fn metafile_pattern_brush_tiles_and_averages_when_tiny() {
+    // A 1-bit 8 × 8 checker (palette white, black), a null pen and a one-inch square.
+    let mut dib: Vec<u8> = [40u32, 8, 8].iter().flat_map(|v| v.to_le_bytes()).collect();
+    dib.extend(1u16.to_le_bytes());
+    dib.extend(1u16.to_le_bytes());
+    dib.extend([0u8; 24]);
+    dib.extend([255, 255, 255, 0, 0, 0, 0, 0]);
+    for r in 0..8 {
+        dib.extend([if r % 2 == 0 { 0x55 } else { 0xAA }, 0, 0, 0]);
+    }
+    let mut brush = i16s(&[5, 0]);
+    brush.extend(dib);
+    let recs = vec![(0x0142, brush), (0x012D, i16s(&[0])), (0x012D, i16s(&[0x8008])), (0x041B, i16s(&[1440, 1440, 0, 0]))];
+    let bytes = wmf_with(1440, 1440, &recs);
+    // 4 px per point: a 0.75 pt cell is 3 px.
+    let img = crate::metafile::rasterize(&bytes, 288).expect("raster");
+    let (a, b) = (img.get_pixel(1, 1), img.get_pixel(4, 1));
+    assert!(a[3] > 200 && b[3] > 200);
+    assert!((a[0] as i32 - b[0] as i32).abs() > 200, "neighbouring cells alternate: {a:?} {b:?}");
+    // Far below one pixel per cell: the average grey.
+    let img = crate::metafile::rasterize(&bytes, 32).expect("raster");
+    let p = img.get_pixel(16, 16);
+    assert!((100..156).contains(&p[0]) && p[3] > 200, "average grey: {p:?}");
+}
+
+/// A 400 x 200 group at (100, 100) holding a dashed 4 pt rectangle and a 3 pt line with an
+/// arrowhead, placed in the group's child coordinates by `to_child` (slide point to child point).
+fn outlined_group(child: Xfrm, to_child: impl Fn(f64, f64) -> (f64, f64)) -> Image {
+    use deckcraft_model::style::{Dash, LineEnd};
+    let ink = |w: f64| deckcraft_model::style::Line { dash: None, ..deckcraft_model::style::Line::solid(ColorRef::rgb(Rgba::rgb(200, 0, 0)), w) };
+    let place = |x0: f64, y0: f64, x1: f64, y1: f64| {
+        let ((a, b), (c, d)) = (to_child(x0, y0), to_child(x1, y1));
+        Xfrm::new(a, b, c - a, d - b)
+    };
+    let rect = Shape {
+        id: ShapeId(11),
+        xfrm: Some(place(140.0, 120.0, 300.0, 200.0)),
+        geom: Geom::preset("rect"),
+        line: Some(deckcraft_model::style::Line { dash: Some(Dash::Preset { name: "dash".into() }), ..ink(4.0) }),
+        ..Default::default()
+    };
+    let end = LineEnd { kind: "triangle".into(), w: "lg".into(), len: "lg".into() };
+    let line = Shape {
+        id: ShapeId(12),
+        xfrm: Some(Xfrm { flip_v: true, ..place(150.0, 170.0, 450.0, 260.0) }),
+        geom: Geom::preset("line"),
+        line: Some(deckcraft_model::style::Line { tail: Some(end), ..ink(3.0) }),
+        ..Default::default()
+    };
+    let pts: Vec<(f64, f64, f32)> = [(160.0, 240.0), (260.0, 285.0)].iter().map(|(x, y)| to_child(*x, *y)).map(|(x, y)| (x, y, 1.0)).collect();
+    let ink = Shape {
+        id: ShapeId(13),
+        xfrm: Some(place(100.0, 100.0, 500.0, 300.0)),
+        kind: ShapeKind::Ink {
+            strokes: vec![deckcraft_model::InkStroke { points: pts, color: Rgba::rgb(200, 0, 0), width: 5.0, highlighter: false }],
+        },
+        ..Default::default()
+    };
+    let group = Shape {
+        id: ShapeId(10),
+        xfrm: Some(Xfrm::new(100.0, 100.0, 400.0, 200.0)),
+        kind: ShapeKind::Group { children: vec![rect, line, ink], child },
+        ..Default::default()
+    };
+    render_slide(&deck_with(vec![group]), 0, &RenderOpts { scale: 1.0, ..Default::default() })
+}
+
+fn inked(img: &Image) -> usize {
+    img.pixels.as_chunks::<4>().0.iter().filter(|px| px[1] < 200).count()
+}
+
+#[test]
+fn group_child_scale_does_not_scale_line_widths() {
+    // Children laid out 1:1 with the slide are the reference.
+    let reference = outlined_group(Xfrm::new(100.0, 100.0, 400.0, 200.0), |x, y| (x, y));
+    let drawn = inked(&reference);
+    assert!((500..20_000).contains(&drawn), "the reference draws thin lines: {drawn}");
+    // The same drawing in a small legacy child space (scale 100), and one scaled unevenly
+    // (100 across, 50 down): same outlines, same line widths, dashes and arrowhead.
+    let uniform = outlined_group(Xfrm::new(1.0, 1.0, 4.0, 2.0), |x, y| (1.0 + (x - 100.0) / 100.0, 1.0 + (y - 100.0) / 100.0));
+    let uneven = outlined_group(Xfrm::new(1.0, 1.0, 4.0, 4.0), |x, y| (1.0 + (x - 100.0) / 100.0, 1.0 + (y - 100.0) / 50.0));
+    for (name, img) in [("uniform", &uniform), ("uneven", &uneven)] {
+        let (n, d) = (inked(img), differing(&reference, img));
+        assert!(n.abs_diff(drawn) * 20 < drawn, "{name}: {n} inked pixels against {drawn}");
+        assert!(d * 20 < drawn, "{name}: {d} differing values against {drawn} inked pixels");
+    }
+}

crates/text/src/lib.rs

@@ -773,9 +773,37 @@ fn symbol_font_char(face: &FontFace, c: &str, font: Option<&str>) -> Option<char
     }
 }
 
+/// The character that draws `c`, a character of text set in the symbol font `font` (Wingdings,
+/// Symbol, Webdings…: its code, or U+F000 + its code), with `face`: the installed symbol font's own
+/// glyph when `face` is that font, else a Unicode look-alike as bullets use. None when `font` is not
+/// a symbol font or `c` is not a symbol code. Metafile text takes this path.
+pub fn symbol_char(face: &FontFace, font: &str, c: char) -> Option<char> {
+    let code = c as u32;
+    if !is_symbol_font(font) || !(code < 0x100 || (0xF000..=0xF0FF).contains(&code)) {
+        return None;
+    }
+    let plain = char::from_u32(code & 0xFF)?;
+    let s = plain.to_string();
+    Some(symbol_font_char(face, &s, Some(font)).unwrap_or_else(|| map_symbol_bullet(&s, Some(font)).chars().next().unwrap_or('•')))
+}
+
 fn map_symbol_bullet(c: &str, font: Option<&str>) -> String {
     let f = font.unwrap_or("").to_ascii_lowercase();
     let first = c.chars().next().unwrap_or('•');
+    if f.starts_with("webdings") {
+        let m = match (first as u32) & 0xff {
+            0x6e => '●',
+            0x67 => '■',
+            0x61 => '✓',
+            0x72 => '✕',
+            0x33 => '◀',
+            0x34 => '▶',
+            0x35 => '▲',
+            0x36 => '▼',
+            _ => '•',
+        };
+        return m.to_string();
+    }
     if f.contains("wingdings") || f.contains("symbol") || ('\u{f000}'..='\u{f0ff}').contains(&first) {
         let code = (first as u32) & 0xff;
         // Wingdings 2 and 3 put different shapes at the same codes.
@@ -1860,24 +1888,70 @@ impl TextLayout {
     }
     /// Vertical caret movement: the position on the line above/below closest to `x`.
     pub fn vertical(&self, pos: Pos, down: bool, x: f64) -> Pos {
-        let Some(li) = self.line_of(pos) else { return pos };
-        let target = if down { li + 1 } else { li.wrapping_sub(1) };
-        let Some(l) = self.lines.get(target) else { return pos };
+        self.vertical_affine(pos, Affinity::Downstream, down, x).0
+    }
+    /// The line a caret is on. An upstream caret at the start of a soft-wrapped line (where End
+    /// leaves it, after the previous line's trailing spaces) belongs to the line before.
+    pub fn line_index(&self, pos: Pos, affinity: Affinity) -> Option<usize> {
+        if affinity == Affinity::Upstream && pos.ch > 0 {
+            for (i, w) in self.lines.windows(2).enumerate() {
+                if let [a, b] = w
+                    && b.para == pos.para
+                    && a.para == pos.para
+                    && b.start == pos.ch
+                {
+                    return Some(i);
+                }
+            }
+        }
+        self.line_of_affine(pos, affinity)
+    }
+    /// Up/Down from a caret with its affinity: the position on the line above/below nearest `x`.
+    pub fn vertical_affine(&self, pos: Pos, affinity: Affinity, down: bool, x: f64) -> (Pos, Affinity) {
+        let Some(li) = self.line_index(pos, affinity) else { return (pos, affinity) };
+        let target = if down { li.checked_add(1) } else { li.checked_sub(1) };
+        let Some(l) = target.and_then(|t| self.lines.get(t)) else { return (pos, affinity) };
         let p = Point::new(x, (l.top + l.bottom) / 2.0);
         let mut h = self.hit(p);
         if h.para != l.para {
             h.para = l.para;
-            h.ch = h.ch.clamp(l.start, l.end);
         }
-        h
+        h.ch = h.ch.clamp(l.start, l.end);
+        (h, Affinity::Downstream)
     }
     /// Start/end of the visual line containing `pos` (logical: Home/End).
     pub fn line_bounds(&self, pos: Pos) -> (Pos, Pos) {
-        match self.line_of(pos).and_then(|i| self.lines.get(i)) {
+        self.line_bounds_affine(pos, Affinity::Downstream)
+    }
+    /// Start/end of the visual line a caret with this affinity is on.
+    pub fn line_bounds_affine(&self, pos: Pos, affinity: Affinity) -> (Pos, Pos) {
+        match self.line_index(pos, affinity).and_then(|i| self.lines.get(i)) {
             Some(l) => (Pos { para: l.para, ch: l.start }, Pos { para: l.para, ch: l.end }),
             None => (pos, pos),
         }
     }
+    /// Where End puts the caret: after a soft wrap, past the line's trailing spaces at the start
+    /// of the next line with upstream affinity (so it is still drawn on this line), else the end
+    /// of the paragraph.
+    pub fn line_end_caret(&self, pos: Pos, affinity: Affinity) -> (Pos, Affinity) {
+        let Some(li) = self.line_index(pos, affinity) else { return (pos, Affinity::Downstream) };
+        let Some(l) = self.lines.get(li) else { return (pos, Affinity::Downstream) };
+        match self.lines.get(li + 1) {
+            Some(n) if n.para == l.para && n.start > l.start => (Pos { para: l.para, ch: n.start }, Affinity::Upstream),
+            _ => (Pos { para: l.para, ch: l.end }, Affinity::Downstream),
+        }
+    }
+    /// The caret to draw (x, top, bottom): an upstream caret after a soft wrap is drawn at the end
+    /// of the line it belongs to.
+    pub fn caret_drawn(&self, pos: Pos, affinity: Affinity) -> Option<(f64, f64, f64)> {
+        let li = self.line_index(pos, affinity)?;
+        let l = self.lines.get(li)?;
+        if pos.ch > l.end {
+            let x = l.caret_x.last().copied()?;
+            return Some((x, l.top, l.bottom));
+        }
+        self.caret_at(pos, affinity)
+    }
     /// Bounding box of all glyphs/lines (shape-local).
     pub fn bounds(&self) -> Rect {
         let mut r: Option<Rect> = None;

crates/text/src/tests.rs

@@ -748,3 +748,14 @@ fn an_installed_symbol_font_draws_its_own_bullet() {
     assert_eq!(symbol_font_char(&face, "\u{ea}", Some("Wingdings 2")), Some('\u{f0ea}'));
     assert_eq!(symbol_font_char(&face, "\u{ea}", Some("Arial")), None);
 }
+
+#[test]
+fn symbol_char_maps_symbol_font_codes() {
+    // Inter is not a symbol font, so the codes map to look-alikes.
+    let face = FontDb::global().face("Inter", "Regular");
+    assert_eq!(symbol_char(&face, "Arial", 'n'), None, "not a symbol font");
+    assert_eq!(symbol_char(&face, "Webdings", 'n'), Some('\u{25CF}'));
+    assert_eq!(symbol_char(&face, "Webdings", '\u{F06E}'), Some('\u{25CF}'), "the private-use form of the code");
+    assert_eq!(symbol_char(&face, "Wingdings", '\u{F06E}'), Some('\u{25A0}'));
+    assert_eq!(symbol_char(&face, "Wingdings", '\u{100}'), None, "not a symbol code");
+}

crates/ui-egui/src/lib.rs

@@ -1036,6 +1036,89 @@ mod tests {
         assert_eq!(harness.state().session.documents().len(), 2);
     }
 
+    /// #268: Ctrl+Backspace, Ctrl+Delete, Ctrl+arrows and Ctrl+Shift+arrows in text, through real
+    /// egui key events (Windows keys).
+    #[test]
+    fn ctrl_word_keys_edit_text() {
+        use egui::{Key, Modifiers};
+        let mut session = Session::with_new();
+        session.mac_keys = false;
+        session.prefs.autocorrect = false;
+        let mut harness = egui_kittest::Harness::builder().with_size(egui::vec2(1200.0, 800.0)).build_ui_state(
+            |ui, app: &mut SlideApp| {
+                app.logic(ui.ctx());
+                app.ui(ui);
+            },
+            SlideApp::new(session, Services::default()),
+        );
+        harness.run_steps(2);
+        let title = harness.state().session.active().unwrap().doc.slides[0].shapes[0].id.0;
+        harness.state_mut().session.execute("text.edit", &json!({"id": title})).unwrap();
+        harness.event(egui::Event::Text("Hello, world.  Foo bar".into()));
+        harness.run_steps(1);
+        assert_eq!(title_text(harness.state()), "Hello, world.  Foo bar");
+        let caret = |h: &egui_kittest::Harness<'_, SlideApp>| h.state().session.active().unwrap().selection.text.clone().unwrap();
+        let ctrl = Modifiers::COMMAND;
+        let ctrl_shift = Modifiers::COMMAND | Modifiers::SHIFT;
+
+        // Ctrl+Left stops at every word and punctuation run, as in PowerPoint.
+        let mut stops = vec![];
+        for _ in 0..6 {
+            harness.key_press_modifiers(ctrl, Key::ArrowLeft);
+            harness.run_steps(1);
+            stops.push(caret(&harness).caret.1);
+        }
+        assert_eq!(stops, vec![19, 15, 12, 7, 5, 0]);
+        harness.key_press_modifiers(ctrl, Key::ArrowRight);
+        harness.run_steps(1);
+        assert_eq!(caret(&harness).caret, (0, 5));
+
+        // Ctrl+Shift+Right selects to the next stops.
+        harness.key_press_modifiers(ctrl_shift, Key::ArrowRight);
+        harness.key_press_modifiers(ctrl_shift, Key::ArrowRight);
+        harness.run_steps(1);
+        let t = caret(&harness);
+        assert_eq!((t.anchor, t.caret), ((0, 5), (0, 12)));
+
+        // Ctrl+Delete deletes the next word from the selection's start; Ctrl+Backspace the one
+        // before the caret.
+        harness.key_press_modifiers(ctrl, Key::Delete);
+        harness.run_steps(1);
+        assert_eq!(title_text(harness.state()), "Helloworld.  Foo bar");
+        harness.key_press(Key::End);
+        harness.key_press_modifiers(ctrl, Key::Backspace);
+        harness.run_steps(1);
+        assert_eq!(title_text(harness.state()), "Helloworld.  Foo ");
+
+        // Ctrl+Up/Down go by paragraph, Ctrl+Home/End to the text's ends.
+        harness.key_press(Key::Enter);
+        harness.event(egui::Event::Text("Next".into()));
+        harness.key_press_modifiers(ctrl, Key::ArrowUp);
+        harness.run_steps(1);
+        assert_eq!(caret(&harness).caret, (1, 0));
+        harness.key_press_modifiers(ctrl, Key::ArrowUp);
+        harness.run_steps(1);
+        assert_eq!(caret(&harness).caret, (0, 0));
+        harness.key_press_modifiers(ctrl, Key::ArrowDown);
+        harness.run_steps(1);
+        assert_eq!(caret(&harness).caret, (1, 0));
+        harness.key_press_modifiers(ctrl_shift, Key::Home);
+        harness.run_steps(1);
+        let t = caret(&harness);
+        assert_eq!((t.anchor, t.caret), ((1, 0), (0, 0)));
+
+        // Ctrl+Shift+> (egui reports the Period key) grows the selected text's font.
+        let size = |h: &mut egui_kittest::Harness<'_, SlideApp>| h.state_mut().session.execute("format.state", &json!({})).unwrap()["size"].as_f64();
+        let before = size(&mut harness);
+        harness.key_press_modifiers(ctrl_shift, Key::Period);
+        harness.run_steps(1);
+        let after = size(&mut harness).unwrap();
+        assert!(after > before.unwrap_or(0.0), "{before:?} → {after}");
+        harness.key_press_modifiers(ctrl, Key::OpenBracket);
+        harness.run_steps(1);
+        assert!(size(&mut harness).unwrap_or(f64::MAX) < after, "Ctrl+[ shrinks");
+    }
+
     #[test]
     fn home_needs_an_open_presentation() {
         let mut app = SlideApp::new(Session::new(), Services::default());

crates/ui-egui/src/theme.rs

@@ -191,6 +191,16 @@ pub fn font_definitions(extra: &[std::sync::Arc<deckcraft_fonts::FontFace>]) ->
     bold.extend(defs.families.get(&FontFamily::Proportional).cloned().unwrap_or_default());
     defs.families.insert(FontFamily::Name("bold".into()), bold);
     add_fallback_faces(&mut defs, extra);
+    // The Japanese interface face (the first one when Inter isn't embedded) hints its en and em
+    // dashes, bars thinner than a pixel, down to nothing, so they drew as gaps in interface text;
+    // unhinted, they draw.
+    for (name, d) in defs.font_data.iter_mut() {
+        if name.contains("BIZ UDPGothic") {
+            let mut data = (**d).clone();
+            data.tweak.hinting = Some(false);
+            *d = std::sync::Arc::new(data);
+        }
+    }
     defs
 }
 
@@ -221,3 +231,38 @@ pub fn font(size: f32) -> egui::FontId {
 pub fn to_color32(c: deckcraft_color::Rgba) -> Color32 {
     Color32::from_rgba_unmultiplied(c.r, c.g, c.b, c.a)
 }
+
+#[cfg(test)]
+mod tests {
+    /// Each character of `text` laid out in the interface fonts at interface sizes, and whether it
+    /// has ink (a glyph image).
+    fn drawn(text: &str) -> Vec<(char, f32, bool)> {
+        let ctx = egui::Context::default();
+        ctx.set_fonts(super::font_definitions(&[]));
+        let mut o = ctx.run_ui(Default::default(), |_| {});
+        o.textures_delta.clear();
+        let mut out = vec![];
+        ctx.fonts_mut(|f| {
+            for size in [11.0, 12.0, 13.0, 16.0] {
+                for family in [egui::FontFamily::Proportional, egui::FontFamily::Name("bold".into())] {
+                    let g = f.layout_no_wrap(text.to_string(), egui::FontId::new(size, family), egui::Color32::WHITE);
+                    for gl in g.rows.iter().flat_map(|r| &r.glyphs) {
+                        out.push((gl.chr, size, gl.uv_rect.size.x > 0.0 && gl.uv_rect.size.y > 0.0));
+                    }
+                }
+            }
+        });
+        let mut o = ctx.run_ui(Default::default(), |_| {});
+        o.textures_delta.clear();
+        out
+    }
+
+    #[test]
+    fn thin_punctuation_is_drawn_in_interface_text() {
+        // En and em dashes (thin bars) were hinted down to nothing in the Japanese interface face,
+        // so notes and the outline showed gaps where they were.
+        for (c, size, ink) in drawn("\u{2013}\u{2014}-_\u{2026}\u{2022}\u{00b7}\u{2018}\u{2019}\u{201c}\u{201d}=~") {
+            assert!(ink, "{c:?} ({:04X}) draws nothing at {size} px", c as u32);
+        }
+    }
+}

docs/file-format-parity.md

@@ -1,6 +1,6 @@
 # File-format parity with PowerPoint
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-10 · **Change:** major (created; formats taken from PowerPoint 16.113.4's Info.plist, PPTX coverage measured from `crates/pptx`) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-12 · **Change:** trivial (Groups with a small legacy child coordinate space draw outlines, dashes, arrowheads and ink at their own width (#233); previously major: created; formats taken from PowerPoint 16.113.4's Info.plist, PPTX coverage measured from `crates/pptx`) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
 
 Every format PowerPoint reads or writes, DeckCraft's support, fidelity and how it is tested.
 Gaps are itemized in [gaps.md](gaps.md#file-formats). Dimension score: **~58% ready**
@@ -38,7 +38,7 @@ PowerPoint opens and saves; Viewer = opens only).
 |---|---|---|---|
 | PNG, JPEG, GIF (animated), BMP, TIFF, WebP | yes | yes | `image` 0.25; animated GIFs play since #39 |
 | SVG | yes (with PNG fallback) | **no** | The PNG fallback shows; SVG files can't be inserted |
-| EMF / WMF | yes | partial | Drawn as vectors (paths, pens, bitmaps); text records inside are skipped |
+| EMF / WMF | yes | partial | Drawn as vectors (paths, pens, pattern and hatch brushes, bitmaps, text in the document's fonts with the file's character advances); clip regions and EMF+ records are not drawn. Legacy OLE objects (VML preview) and ActiveX controls show their pictures |
 | HEIC | yes (macOS) | no | |
 | Audio: MP3, AAC/M4A, ALAC, WAV, AIFF, CAF, FLAC, Ogg Vorbis, Opus | yes (Ogg/Opus partly) | yes | Pure-Rust decoders in `crates/media`, `crates/opus` |
 | WMA | yes (Windows) | embedded, not playable | |
@@ -63,7 +63,7 @@ the round trip even though DeckCraft doesn't model it.
 | Themes: colour, font (Latin/EA/CS), effect schemes, background styles | yes | yes | Unknown theme parts kept |
 | Notes slides and notes master | yes | yes | No notes-master editing view |
 | Handout master | no | no | |
-| Shapes: preset geometry (~180 presets), custom geometry, groups, connectors | yes | yes | Presets re-derived in `crates/geom/src/preset.rs` (and `preset/extra.rs`) |
+| Shapes: preset geometry (~180 presets), custom geometry, groups, connectors | yes | yes | Presets re-derived in `crates/geom/src/preset.rs` (and `preset/extra.rs`). Outlines, dashes, arrowheads and ink inside a group keep their width in points whatever the group's child-coordinate scale (#233); text in a group with a tiny child space is not drawn yet. |
 | Fills: solid, gradient, picture (stretch/tile/crop), pattern, group | yes | yes | |
 | Lines: dash, compound, caps, joins, arrowheads | yes | yes | |
 | Effects: shadow, glow, soft edges, reflection | yes | yes | |
@@ -93,11 +93,13 @@ the round trip even though DeckCraft doesn't model it.
    embedded fonts, every transition and animation) in a corpus repo, with import → render → export
    → re-import checks in CI and a PowerPoint reference render for each (owner runs PowerPoint).
 2. The round-trip losses above (#70, #74, #77).
-3. SVG rendering, and text inside EMF/WMF.
+3. SVG rendering, and clip regions inside EMF/WMF.
 
 ## Revision history
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-12 | minor | EMF/WMF text and pattern brushes drawn; OLE (VML) and ActiveX previews read |
 | 2026-10-12 | minor | Text warps rendered; their adjust values read and written |
+| 2026-10-12 | trivial | Groups with a small legacy child coordinate space draw outlines, dashes, arrowheads and ink at their own width (#233) |
 | 2026-10-10 | major | Created from PowerPoint 16.113.4's `CFBundleDocumentTypes`, `crates/pptx` reader/writer and tests, and the open round-trip issues |

docs/gaps.md

@@ -20,7 +20,7 @@ revision history.
 | 1 | PPTX never tested against a corpus of real decks | File format | B | 20–35 | [file-format-parity.md](file-format-parity.md) |
 | 2 | Data loss and crashes on common paths (#60, #40, #59) | Stability | B | 6–12 | this file |
 | 3 | PPTX round trip drops comment threads, media options, rewind (#70, #74, #77) | File format | B | 3–6 | [file-format-parity.md](file-format-parity.md) |
-| 4 | SVG pictures don't render (EMF/WMF do) | File format | B | 8–14 | [file-format-parity.md](file-format-parity.md) |
+| 4 | SVG pictures don't render (EMF/WMF do) | File format | B | 6–12 | [file-format-parity.md](file-format-parity.md) |
 | 5 | No localization: English only | Localization | B (infra + 5 languages) | 55–90 | [localization-parity.md](localization-parity.md) |
 | 6 | No printing | Feature | B | 5–8 | [file-format-parity.md](file-format-parity.md) |
 | 7 | Fonts: only Regular, Bold and Italic faces (#69) | Feature | B | 3–5 | [ui-parity.md](ui-parity.md) |
@@ -77,12 +77,12 @@ Detail in [file-format-parity.md](file-format-parity.md).
 
 ### SVG pictures don't render
 - **Evidence:** `crates/render/src/images.rs` decodes through `image` 0.25 (PNG, JPEG, WebP, GIF,
-  TIFF, BMP), and EMF/WMF through `deckcraft-metafile` (ported from WordCraft: paths, fills, pens
-  and bitmaps; text records are skipped). Nothing reads SVG; PowerPoint's Insert Icons stores SVG
-  with a PNG fallback.
-- **Impact:** SVG icons show only their raster fallback, and SVG files can't be inserted. Text
-  drawn inside an EMF/WMF is missing.
-- **Estimate:** 4–8 h (an SVG renderer through `resvg`-style crates); EMF text records 2–4 h.
+  TIFF, BMP), and EMF/WMF through `deckcraft-metafile` (ported from WordCraft: paths, fills, pens,
+  pattern and hatch brushes, bitmaps and text; clip regions and EMF+ records are not drawn).
+  Nothing reads SVG; PowerPoint's Insert Icons stores SVG with a PNG fallback.
+- **Impact:** SVG icons show only their raster fallback, and SVG files can't be inserted. An
+  EMF/WMF that clips its drawing (EXTSELECTCLIPRGN, INTERSECTCLIPRECT) draws past its clip.
+- **Estimate:** 4–8 h (an SVG renderer through `resvg`-style crates); EMF/WMF clip regions 2–4 h.
 
 ### Template, slide-show and macro variants are saved as plain `.pptx`
 - **Evidence:** `crates/pptx/src/write/mod.rs` always writes the
@@ -256,6 +256,7 @@ Detail in [localization-parity.md](localization-parity.md).
 | Date | Change | Summary |
 |---|---|---|
 | 2026-10-12 | minor | IME composition in slide text and notes, and CJK interface text with real glyphs (#101): the IME gap is now Korean on the web and table-cell underlines |
+| 2026-10-12 | minor | EMF/WMF text, pattern and hatch brushes drawn; legacy OLE and ActiveX previews shown; the SVG gap keeps only EMF clip regions |
 | 2026-10-12 | minor | Text warps render (all 40 presets, adjusts round-trip); the warp gap is now the gallery, command and handles |
 | 2026-10-10 | minor | Noted that no gap blocks alpha (core-workflow gate passes) |
 | 2026-10-10 | major | Created: every gap from the 2026-10-10 re-measure and the 16 open GitHub issues, ranked, with beta blockers marked |

docs/ui-parity.md

@@ -2,6 +2,8 @@
 
 > **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-12 · **Change:** minor (off-slide objects in Normal view, #270) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
 
+> **Last reviewed:** 2026-10-12 · **Last updated:** 2026-10-12 · **Change:** minor (text editing keys observed in PowerPoint for Windows, #268) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
+
 How DeckCraft looks and feels next to PowerPoint: the shell, the ribbon, menus, panes, dialogs,
 direct manipulation, keyboard and precision. Observations of PowerPoint are kept locally in
 `plan/powerpoint/01-observed-ui.md` and `menu-tree.txt` (gitignored, clean-room rules in
@@ -64,6 +66,35 @@ group/ungroup, bold/italic/underline, alignment, font size, list levels, Format
 start/current, view switching. Not yet: Cmd+F Find opening a find bar on the slide, Option+drag
 precision without snapping, F6 pane cycling, ribbon KeyTips (Windows).
 
+### Text editing keys
+
+Observed black-box in PowerPoint for Windows (Microsoft 365, October 2026) on synthetic text, and
+pinned by tests in `crates/model/src/words.rs`, `crates/model/src/edit.rs` and
+`crates/engine/src/tests_keys.rs` (#268). Windows and Linux use Ctrl; the Mac uses Option for words
+and Cmd for line and text ends (`Session::mac_keys`).
+
+| Keys | Behaviour |
+|---|---|
+| Ctrl+Left / Right | Previous / next word stop. A stop is the start of every word, punctuation run, symbol run, tab, line break and CJK character, plus the paragraph's end; spaces belong to the word before them. `it's`, `baz-qux`, `a-`, `3.14`, `1,000`, `3:45` are one word; `e.g.`, `a_b`, `x@y.com`, `dogs'` are not. Every CJK ideograph, kana and Hangul syllable is a word. Combining marks and emoji sequences never split. With a selection: Right goes on from its end, Left from its start |
+| Ctrl+Shift+Left / Right | Moves the selection's moving end by the same stops |
+| Ctrl+Up / Down | Start of the paragraph (then of the previous one) / start of the next paragraph (end of the text in the last one); Shift extends |
+| Ctrl+Backspace | Deletes back to the previous stop (word plus its trailing spaces); at a paragraph's start joins it to the previous paragraph |
+| Ctrl+Delete | Inside a word: the rest of it. On spaces after a word: the spaces and the next word. At a word's start: the word and its spaces. Then smart spacing: spaces left before closing punctuation (`ab cd, ef` → `ab, ef`) or at the paragraph's end after a word go; sentence punctuation left touching a word gets a space (`cd...ef gh` → `cd... gh`). At a paragraph's end joins the next paragraph |
+| Ctrl+Backspace / Delete with a selection | Leave the selection and delete the word part before / after its start |
+| Right-to-left paragraph | Left and Right (with or without Ctrl) swap: Left goes forward in the text. Arabic or Hebrew words in a left-to-right paragraph move in logical order |
+| Home / End | Start / end of the visual line. End on a wrapped line goes past its trailing space and the caret stays drawn at that line's end; End again stays; Home from there returns to the same line's start |
+| Ctrl+Home / End | Start / end of the text; Shift extends |
+| Ctrl+Shift+> / <, Ctrl+] / [ | Next / previous size in the font size list (18 → 20 → 24) |
+| Ctrl+B / I / U, Ctrl+Space | With a caret strictly inside a word, the whole word (without trailing spaces); at a word's edge, only what is typed next |
+| Ctrl+E / L / R / J | Center / left / right / justify the paragraphs in the selection |
+| Shift+F3 | Cycles lowercase → Capitalize Each Word → UPPERCASE → lowercase; other mixes go to UPPERCASE first. A caret in a word changes that word and moves to its start |
+| Shift+Enter | Line break |
+| Double-click / triple-click | The word without its trailing spaces (a CJK character on its own) / the paragraph including its paragraph mark |
+
+Quirks kept on purpose because PowerPoint has them: Ctrl+Left (not Ctrl+Right) also stops at
+each no-break or ideographic space, and treats an emoji followed by punctuation as one word. Tab, Shift+Tab and
+Alt+Shift+arrows in text are handled elsewhere (#78, #93).
+
 ## Visual fidelity
 
 Colours, spacing, ribbon card and tab geometry follow the observations in
@@ -89,6 +120,6 @@ imitate Microsoft's. No pixel comparison against PowerPoint screenshots has been
 | Date | Change | Summary |
 |---|---|---|
 | 2026-10-12 | minor | Off-slide objects drawn and editable around the slide in Normal view (#270) |
-
 | 2026-10-12 | minor | Selection Pane matched to PowerPoint (#133): drag and drop, arrows, groups, eye, Lock |
+| 2026-10-12 | minor | Text editing keys: Ctrl+arrows, Ctrl+Backspace/Delete, Ctrl+Up/Down, Home/End on wrapped lines, Shift+F3, font size keys, as observed in PowerPoint for Windows (#268) |
 | 2026-10-10 | major | Created: shell, panes and dialogs, direct manipulation, shortcuts and visual fidelity against PowerPoint 16.113 |