feat(svg): textPath onto text on a path; per-character x, y, dx, dy and rotate where simple; fixture with goldens (M4)

This commit is contained in:
Tanish Manku committed 2026-11-12 00:53:53 -07:00
1 parent 16a871e7ed
commit d146fa4ebb
6 files changed
+433 -35

No files matched your search

+6 -9
View File
@@ -230,11 +230,8 @@ pub(crate) fn lay_out_on_path(text: &str, style: &TextStyle, on: &TextPath) -> R
TextAlign::Right => Align::Right,
};
let offset = if on.offset.is_finite() { on.offset.clamp(-MAX_PATH_OFFSET, MAX_PATH_OFFSET) } else { 0.0 };
let set = anicraft_text::on_path(&layout.glyphs, &on.path, anicraft_text::PathPlacement { offset, flip: on.flip, align }).ok_or_else(|| EngineError::State("the path has no length to set text along".into()))?;
// The box: the path and the glyphs, from the origin.
let b = set.outline.bounds().union(&on.path.bounds());
let shift = if b.min.x.is_finite() && b.min.y.is_finite() { b.min } else { Vec2::ZERO };
let back = Affine::translate(-shift.x, -shift.y);
let set = anicraft_text::on_path_boxed(&layout.glyphs, &on.path, anicraft_text::PathPlacement { offset, flip: on.flip, align }).ok_or_else(|| EngineError::State("the path has no length to set text along".into()))?;
let shift = set.shift;
let block = TextBlock {
text: text.to_string(),
font: layout.family,
@@ -246,11 +243,11 @@ pub(crate) fn lay_out_on_path(text: &str, style: &TextStyle, on: &TextPath) -> R
letter_spacing: style.letter_spacing,
line_spacing: style.line_spacing,
width: None,
outline: Arc::new(set.outline.transformed(&back)),
box_width: if b.width().is_finite() { b.width().max(0.0) } else { 0.0 },
box_height: if b.height().is_finite() { b.height().max(0.0) } else { 0.0 },
outline: Arc::new(set.outline),
box_width: set.width,
box_height: set.height,
field: None,
on_path: Some(TextPath { path: on.path.transformed(&back), offset, flip: on.flip }),
on_path: Some(TextPath { path: set.path, offset, flip: on.flip }),
};
Ok((block, note, shift))
}
+41
View File
@@ -1557,6 +1557,47 @@ fn soft_masks_round_trip_through_svg_onto_soft_mask_layers() {
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn the_soft_mask_and_text_path_fixture_imports_with_its_goldens() {
// crates/svg/fixtures/soft-masks-text-paths.svg (ADR 0070): pixel values worked out from
// the drawing itself.
let dir = std::env::temp_dir().join(format!("anicraft-svg-fixture-0070-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
let svg = dir.join("fixture.svg");
std::fs::write(&svg, include_str!("../../svg/fixtures/soft-masks-text-paths.svg")).unwrap();
let mut s = Session::default();
run(&mut s, "file.new", json!({"width": 200, "height": 100}));
run(&mut s, "file.import", json!({"path": svg.display().to_string(), "x": 0, "y": 0}));
let tl = s.doc.timeline(s.scene);
let mut modes: Vec<anicraft_doc::MaskMode> = tl.layers.iter().filter(|l| l.kind == anicraft_doc::LayerKind::Mask).map(|l| l.mask_mode).collect();
modes.sort_by_key(|m| m.key());
assert_eq!(modes, [anicraft_doc::MaskMode::Alpha, anicraft_doc::MaskMode::Luminance]);
let pm = anicraft_render::render_frame(&s.doc, 0, 1.0).unwrap();
let px = |x, y| pm.pixel(x, y).unwrap();
// Alpha mask: red fades out left to right, x 25 → 1 − 25.5 / 100.
for (x, y) in [(25u32, 10u32), (75, 10)] {
let want = 1.0 - (x as f32 + 0.5) / 100.0;
assert!((px(x, y)[0] - want).abs() < 6e-3 && px(x, y)[1] < 1e-3, "({x}, {y}): {:?} vs {want}", px(x, y));
}
// Luminance mask: #808080 shows 128 / 255 of the green.
assert!((px(150, 95)[1] - 128.0 / 255.0).abs() < 3e-3 && px(150, 95)[0] < 1e-3, "{:?}", px(150, 95));
// The text follows the arc, centred on it, when this computer has fonts.
if !anicraft_text::Fonts::get().families().is_empty() {
let els: Vec<std::sync::Arc<anicraft_doc::Element>> = s.timeline().layers.iter().filter_map(|l| anicraft_doc::evaluate_layer_elements(l, 0)).flat_map(|(_, e)| e.into_owned()).collect();
let text = els.into_iter().find_map(|e| match &e.kind {
anicraft_doc::ElementKind::Text(t) => Some((e.transform, t.clone())),
_ => None,
});
let (xf, t) = text.expect("the text");
assert_eq!(t.text, "on the arc");
let on = t.on_path.as_ref().expect("on its path");
assert!(t.align == anicraft_doc::TextAlign::Center && on.offset > 50.0);
let b = t.outline.bounds().transformed(&xf);
assert!((b.center().x - 100.0).abs() < 4.0 && b.min.y > 20.0 && b.max.y < 70.0, "{b:?}");
}
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn imported_svg_text_is_editable_text() {
if anicraft_text::Fonts::get().families().is_empty() {
@@ -0,0 +1,14 @@
<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="200" height="100">
<!-- Self-authored test drawing for AniCraft's SVG import (ADR 0070): an alpha gradient mask,
a grey luminance mask and text on a curved path. -->
<defs>
<linearGradient id="fade" x1="0" x2="1"><stop offset="0" stop-color="#fff"/><stop offset="1" stop-color="#fff" stop-opacity="0"/></linearGradient>
<mask id="soft" mask-type="alpha"><rect width="100" height="100" fill="url(#fade)"/></mask>
<mask id="grey"><rect x="100" width="100" height="100" fill="#808080"/></mask>
<path id="arc" d="M 20 90 Q 100 10 180 90"/>
</defs>
<rect width="200" height="100" fill="#000"/>
<rect width="100" height="100" fill="#ff0000" mask="url(#soft)"/>
<rect x="100" width="100" height="100" fill="#00ff00" mask="url(#grey)"/>
<text font-family="sans-serif" font-size="14" fill="#fff"><textPath xlink:href="#arc" startOffset="50%" text-anchor="middle">on the arc</textPath></text>
</svg>

After

Width:  |  Height:  |  Size: 1017 B

+270 -24
View File
@@ -6,6 +6,11 @@
//! An AniCraft block has one style, so a chunk whose pieces differ in style takes the style of
//! most of its visible characters, and the report counts it (as in ADR 0014). Whitespace is
//! collapsed as browsers do, unless `xml:space="preserve"`.
//!
//! ADR 0070: a `textPath` becomes text on a path (its `startOffset`, `side` and the
//! `text-anchor`), and per-character positions are kept where they are simple: a character
//! with its own `x`/`y`, a `dx`/`dy` shift or a `rotate` angle starts a block of its own there
//! (rotated about its baseline origin), the next continuing after the text before it.
use crate::{Anchor, Builder, ImportedElement, PaintSpec, Style, declarations, get, hidden, length, local, name_of};
use anicraft_doc::{ElementKind, Paint, TextAlign, TextBlock};
@@ -26,9 +31,33 @@ struct Chunk {
anchor: Anchor,
pieces: Vec<(String, Style)>,
chars: usize,
/// `x` is a shift from where the text before it ended (a `dx`), not a position.
follow: bool,
/// Degrees, about the chunk's baseline origin (a per-character `rotate`).
rotate: f32,
/// Set along a path (`textPath`).
path: Option<OnPath>,
}
/// A `textPath`'s path in the text's user space, and where along it the text is anchored.
struct OnPath {
path: anicraft_geom::Path,
offset: f32,
flip: bool,
}
impl Chunk {
fn at(x: f32, y: f32, anchor: Anchor) -> Chunk {
Chunk { x, y, anchor, pieces: Vec::new(), chars: 0, follow: false, rotate: 0.0, path: None }
}
}
impl Chunk {
/// Characters it holds, whitespace included (what moves the pen on).
fn len(&self) -> usize {
self.pieces.iter().map(|(t, _)| t.chars().count()).sum()
}
fn has_text(&self) -> bool {
self.pieces.iter().any(|(t, _)| !t.trim().is_empty())
}
@@ -38,8 +67,10 @@ impl Chunk {
#[derive(Default)]
struct Flags {
per_char: bool,
rotated: bool,
on_path: bool,
nested_chars: bool,
lost_path: bool,
after_path: bool,
anchored_chars: bool,
decorated: bool,
vertical: bool,
cut: bool,
@@ -65,6 +96,44 @@ fn families(css: &str) -> Vec<String> {
css.split(',').map(|n| n.trim().trim_matches(['"', '\'']).trim().to_string()).filter(|n| !n.is_empty()).take(16).collect()
}
/// A `textPath`'s text (its `tspan`s flattened into pieces of their styles).
fn gather(el: &X, style: &Style, c: &mut Chunk, report: &mut crate::Report, depth: usize) {
for child in &el.children {
match local(&child.name) {
anicraft_xml::TEXT_NODE => {
let room = MAX_CHARS.saturating_sub(c.chars);
c.chars += child.text.chars().count().min(room);
c.pieces.push((child.text.chars().take(room).collect(), style.clone()));
}
"tspan" | "a" if depth < MAX_TSPAN_DEPTH => {
let d = declarations(child);
if get(&d, "display") == Some("none") || hidden(&d) {
continue;
}
let st = style.with(child, report);
gather(child, &st, c, report, depth + 1);
}
_ => {}
}
}
}
/// One text node's whitespace collapsed as browsers do (line breaks and tabs are spaces, runs
/// of spaces one), leading spaces dropped when `at_start`.
fn collapse_str(t: &str, at_start: bool) -> String {
let mut out = String::with_capacity(t.len());
let mut prev_space = at_start;
for ch in t.chars() {
let ch = if matches!(ch, '\n' | '\r' | '\t') { ' ' } else { ch };
if ch == ' ' && prev_space {
continue;
}
prev_space = ch == ' ';
out.push(ch);
}
out
}
/// Collapses whitespace across the chunks as browsers do: line breaks and tabs are spaces,
/// runs of spaces are one, and spaces at the start go. `xml:space="preserve"` keeps them.
fn collapse(chunks: &mut [Chunk]) {
@@ -99,8 +168,10 @@ impl<'a> Builder<'a> {
collapse(&mut chunks);
let report = [
(flags.per_char, "per-character text positions (ignored)"),
(flags.rotated, "rotated characters (drawn upright)"),
(flags.on_path, "text on a path"),
(flags.nested_chars, "per-character positions running into nested tspans (ignored there)"),
(flags.lost_path, "text on a path whose path is missing (drawn on a line)"),
(flags.after_path, "text after a text path (placed at the text's start)"),
(flags.anchored_chars, "per-character shifts in centred or right-anchored text (approximate)"),
(flags.decorated, "underlined or struck-through text (lines left out)"),
(flags.vertical, "vertical text (drawn horizontal)"),
(flags.cut, "text cut to 100,000 characters per block"),
@@ -111,8 +182,20 @@ impl<'a> Builder<'a> {
}
}
let mut out = Vec::new();
// Where the text before ends (a following chunk continues there).
let mut pen_x = 0.0f32;
let mut space: Option<f32> = None;
for c in chunks {
let start_x = if c.follow { pen_x + c.x } else { c.x };
if !c.has_text() {
// Only spaces: they still move the pen on.
if c.path.is_none() {
let n = c.len() as f32;
if n > 0.0 && let Some((_, st)) = c.pieces.first() {
let w = *space.get_or_insert_with(|| self.space_width(st));
pen_x = start_x + n * w;
}
}
continue;
}
// The style most of the visible characters have (the first on a tie).
@@ -136,6 +219,26 @@ impl<'a> Builder<'a> {
let Some((_, st)) = best.and_then(|(i, _)| c.pieces.get(i)) else { continue };
let st = st.clone();
let text: String = c.pieces.iter().map(|(t, _)| t.as_str()).collect();
let trailing = text.chars().rev().take_while(|ch| *ch == ' ').count() as f32;
let align = match c.anchor {
Anchor::Start => TextAlign::Left,
Anchor::Middle => TextAlign::Center,
Anchor::End => TextAlign::Right,
};
if let Some(on) = &c.path {
match self.path_block(text, &st, alpha, on, align) {
Ok(Some((block, shift))) => {
let transform = m.mul(&Affine::translate(shift.x, shift.y));
if transform.is_finite() {
let name = if out.is_empty() { name_of(el) } else { String::new() };
out.push(ImportedElement { name, transform, alpha, kind: ElementKind::Text(Arc::new(block)) });
}
}
Ok(None) => {}
Err(()) => break,
}
continue;
}
match self.text_block(text, &st, alpha) {
Ok(Some((block, ascent))) => {
let w = block.box_width;
@@ -144,13 +247,18 @@ impl<'a> Builder<'a> {
Anchor::Middle => -w * 0.5,
Anchor::End => -w,
};
let transform = m.mul(&Affine::translate(c.x + shift, c.y - ascent));
pen_x = start_x + shift + w + if trailing > 0.0 { trailing * *space.get_or_insert_with(|| self.space_width(&st)) } else { 0.0 };
let transform = if c.rotate != 0.0 {
m.mul(&Affine::translate(start_x + shift, c.y)).mul(&Affine::rotate(c.rotate.to_radians())).mul(&Affine::translate(0.0, -ascent))
} else {
m.mul(&Affine::translate(start_x + shift, c.y - ascent))
};
if !transform.is_finite() {
continue;
}
let name = if out.is_empty() { name_of(el) } else { String::new() };
let block_alpha = alpha;
let block = TextBlock { align: match c.anchor { Anchor::Start => TextAlign::Left, Anchor::Middle => TextAlign::Center, Anchor::End => TextAlign::Right }, ..block };
let block = TextBlock { align, ..block };
out.push(ImportedElement { name, transform, alpha: block_alpha, kind: ElementKind::Text(Arc::new(block)) });
}
Ok(None) => {}
@@ -163,12 +271,12 @@ impl<'a> Builder<'a> {
/// Reads `el`'s positions and content into chunks.
fn text_content(&mut self, el: &'a X, style: &Style, chunks: &mut Vec<Chunk>, flags: &mut Flags, depth: usize) {
let (vw, vh) = self.viewport;
let list = |key: &str, reference: f32| -> Vec<f32> { el.attr(key).map(|v| v.split([' ', ',', '\t', '\n', '\r']).filter(|p| !p.is_empty()).filter_map(|p| length(p, reference)).collect()).unwrap_or_default() };
let list = |key: &str, reference: f32| -> Vec<f32> { el.attr(key).map(|v| v.split([' ', ',', '\t', '\n', '\r']).filter(|p| !p.is_empty()).take(MAX_CHARS).filter_map(|p| length(p, reference)).collect()).unwrap_or_default() };
let (xs, ys, dxs, dys) = (list("x", vw), list("y", vh), list("dx", vw), list("dy", vh));
if xs.len() > 1 || ys.len() > 1 || dxs.len() > 1 || dys.len() > 1 {
flags.per_char = true;
}
flags.rotated |= el.attr("rotate").is_some_and(|r| r.split([' ', ',']).any(|v| v.trim().parse::<f32>().is_ok_and(|a| a != 0.0)));
let rotates: Vec<f32> = list("rotate", 1.0).into_iter().map(|a| if a.is_finite() { a } else { 0.0 }).collect();
// Per-character positions (ADR 0070): the first values place the element's start (as
// before); the rest go to its own characters, in order.
let per_char = xs.len() > 1 || ys.len() > 1 || dxs.len() > 1 || dys.len() > 1 || rotates.iter().any(|a| *a != 0.0);
let d = declarations(el);
flags.decorated |= get(&d, "text-decoration").is_some_and(|v| v != "none");
flags.vertical |= get(&d, "writing-mode").is_some_and(|v| v.starts_with("tb") || v.starts_with("vertical"));
@@ -179,13 +287,12 @@ impl<'a> Builder<'a> {
return;
}
let y = ys.first().copied().or_else(|| chunks.last().map(|c| c.y)).unwrap_or(0.0);
chunks.push(Chunk { x: xs.first().copied().unwrap_or(0.0), y, anchor: style.anchor, pieces: Vec::new(), chars: 0 });
chunks.push(Chunk::at(xs.first().copied().unwrap_or(0.0), y, style.anchor));
} else if let Some(&y) = ys.first() {
// A new line without a new x continues after the text before it, which only the
// layout knows: kept on the line when there is text already.
// A new line without a new x continues after the text before it.
match chunks.last_mut() {
Some(c) if !c.has_text() => c.y = y,
_ => flags.per_char = true,
_ => chunks.push(Chunk { follow: true, ..Chunk::at(0.0, y, style.anchor) }),
}
}
let (dx, dy) = (dxs.first().copied().unwrap_or(0.0), dys.first().copied().unwrap_or(0.0));
@@ -195,35 +302,174 @@ impl<'a> Builder<'a> {
c.x += dx;
c.y += dy;
}
_ => flags.per_char = true,
Some(c) => {
let y = c.y + dy;
chunks.push(Chunk { follow: true, ..Chunk::at(dx, y, style.anchor) });
}
None => {}
}
}
// The character of this element's own text reached so far (for per-character values).
let mut k = 0usize;
let mut last_rotate = 0.0f32;
for child in &el.children {
match local(&child.name) {
anicraft_xml::TEXT_NODE => {
let Some(c) = chunks.last_mut() else { continue };
let room = MAX_CHARS.saturating_sub(c.chars);
let n = child.text.chars().count();
if n > room {
flags.cut = true;
if !per_char {
let Some(c) = chunks.last_mut() else { continue };
if c.path.is_some() {
// Text after a text path: on a line of its own at the text's start.
if !child.text.trim().is_empty() {
flags.after_path = true;
}
let (x, y) = (0.0, c.y);
chunks.push(Chunk::at(x, y, style.anchor));
}
let Some(c) = chunks.last_mut() else { continue };
let room = MAX_CHARS.saturating_sub(c.chars);
let n = child.text.chars().count();
if n > room {
flags.cut = true;
}
c.chars += n.min(room);
c.pieces.push((child.text.chars().take(room).collect(), style.clone()));
continue;
}
// Character by character: one starts a chunk where it has its own position,
// shift or angle (or follows a rotated one).
let text = if style.preserve { child.text.clone() } else { collapse_str(&child.text, k == 0 && chunks.last().is_none_or(|c| !c.has_text())) };
for ch in text.chars() {
let rot = rotates.get(k).or(rotates.last()).copied().unwrap_or(0.0);
let (ax, ay) = (xs.get(k).copied().filter(|_| k > 0), ys.get(k).copied().filter(|_| k > 0));
let (ddx, ddy) = if k > 0 { (dxs.get(k).copied().unwrap_or(0.0), dys.get(k).copied().unwrap_or(0.0)) } else { (0.0, 0.0) };
let has_text = chunks.last().is_some_and(Chunk::has_text);
let fresh = ax.is_some() || ay.is_some() || ddx != 0.0 || ddy != 0.0 || ((rot != 0.0 || last_rotate != 0.0) && has_text);
if fresh {
if chunks.len() >= MAX_CHUNKS {
flags.cut = true;
return;
}
let y = ay.or_else(|| chunks.last().map(|c| c.y)).unwrap_or(0.0) + ddy;
let c = match ax {
Some(x) => Chunk::at(x + ddx, y, style.anchor),
None => {
if style.anchor != Anchor::Start {
flags.anchored_chars = true;
}
Chunk { follow: true, ..Chunk::at(ddx, y, Anchor::Start) }
}
};
chunks.push(c);
}
let Some(c) = chunks.last_mut() else { break };
if c.chars >= MAX_CHARS {
flags.cut = true;
break;
}
c.rotate = rot;
c.chars += 1;
match c.pieces.last_mut() {
Some((t, st)) if same_look(st, style) && st.preserve == style.preserve => t.push(ch),
_ => c.pieces.push((ch.to_string(), style.clone())),
}
last_rotate = rot;
k += 1;
}
c.chars += n.min(room);
c.pieces.push((child.text.chars().take(room).collect(), style.clone()));
}
"tspan" | "a" => {
let cd = declarations(child);
if get(&cd, "display") == Some("none") || hidden(&cd) || depth >= MAX_TSPAN_DEPTH {
continue;
}
if per_char && (k < xs.len().max(ys.len()).max(dxs.len()).max(dys.len()) || rotates.iter().skip(k).any(|a| *a != 0.0)) {
flags.nested_chars = true;
}
let st = style.with(child, &mut self.report);
self.text_content(child, &st, chunks, flags, depth + 1);
}
"textPath" => flags.on_path = true,
"textPath" => {
let st = style.with(child, &mut self.report);
match self.text_path(child) {
Some(on) => {
if chunks.len() >= MAX_CHUNKS {
flags.cut = true;
return;
}
let y = chunks.last().map_or(0.0, |c| c.y);
let mut c = Chunk { path: Some(on), ..Chunk::at(0.0, y, st.anchor) };
gather(child, &st, &mut c, &mut self.report, 0);
chunks.push(c);
}
None => {
flags.lost_path = true;
self.text_content(child, &st, chunks, flags, depth + 1);
}
}
}
_ => {}
}
}
}
/// A `textPath`'s path (`href`: a path or basic shape, with its own transform) and its
/// `startOffset` (a length or a percentage of the path's length) and `side`.
fn text_path(&mut self, tp: &'a X) -> Option<OnPath> {
let href = tp.attr("href").or_else(|| tp.attr("xlink:href"))?.trim().trim_start_matches('#');
let target = self.ids.get(href).copied()?;
let name = local(&target.name);
if !matches!(name, "path" | "rect" | "circle" | "ellipse" | "polyline" | "polygon" | "line") {
return None;
}
let (path, _) = self.geometry(target, name)?;
let path = path.transformed(&target.attr("transform").map_or(Affine::IDENTITY, crate::transform));
let len = anicraft_geom::walk::CurveWalk::new(&path)?.length();
let offset = tp.attr("startOffset").map(str::trim).and_then(|v| match v.strip_suffix('%') {
Some(p) => p.trim().parse::<f32>().ok().map(|p| p / 100.0 * len),
None => length(v, len),
});
let offset = offset.filter(|o| o.is_finite()).unwrap_or(0.0).clamp(-anicraft_doc::MAX_PATH_OFFSET, anicraft_doc::MAX_PATH_OFFSET);
Some(OnPath { path, offset, flip: tp.attr("side") == Some("right") })
}
/// The width a space takes in style `st` (pixels).
fn space_width(&mut self, st: &Style) -> f32 {
let fonts = self.fonts();
let face = self.face(fonts, &st.font_family);
let style = anicraft_text::Style { family: face.family.unwrap_or_default(), size: st.font_size, bold: st.bold || face.bold, italic: st.italic || face.italic, letter_spacing: st.letter_spacing, ..anicraft_text::Style::default() };
let w = |t: &str| fonts.layout(t, &style).map_or(0.0, |l| l.width);
(w("x x") - w("xx")).max(0.0)
}
/// Lays one chunk out along its path: the block (on its path, boxed from the origin) and
/// where that origin is in the text's user space. `Ok(None)` draws nothing; `Err` means no
/// text can be laid out at all.
fn path_block(&mut self, text: String, st: &Style, alpha: f32, on: &OnPath, align: TextAlign) -> Result<Option<(TextBlock, anicraft_geom::Vec2)>, ()> {
let Some((block, _)) = self.text_block(text, st, alpha)? else { return Ok(None) };
let fonts = self.fonts();
let style = anicraft_text::Style { family: block.font.clone(), size: block.size, bold: block.bold, italic: block.italic, letter_spacing: block.letter_spacing, ..anicraft_text::Style::default() };
let line: String = block.text.chars().map(|c| if c == '\n' || c == '\r' { ' ' } else { c }).collect();
let Ok(layout) = fonts.layout_glyphs(&line, &style) else { return Ok(None) };
let how = anicraft_text::PathPlacement {
offset: on.offset,
flip: on.flip,
align: match align {
TextAlign::Left => Align::Left,
TextAlign::Center => Align::Center,
TextAlign::Right => Align::Right,
},
};
let Some(set) = anicraft_text::on_path_boxed(&layout.glyphs, &on.path, how) else { return Ok(None) };
let block = TextBlock {
align,
outline: Arc::new(set.outline),
box_width: set.width,
box_height: set.height,
on_path: Some(anicraft_doc::TextPath { path: set.path, offset: on.offset, flip: on.flip }),
..block
};
Ok(Some((block, set.shift)))
}
/// Lays one chunk out: the block (aligned left, at the origin) and its first baseline.
/// `Ok(None)` draws nothing; `Err` means no text can be laid out at all.
fn text_block(&mut self, text: String, st: &Style, alpha: f32) -> Result<Option<(TextBlock, f32)>, ()> {
+79 -2
View File
@@ -91,11 +91,19 @@ fn missing_fonts_and_unsupported_text_are_reported() {
</svg>"##,
fonts,
);
assert_eq!(t.len(), 3, "{:?}", t.iter().map(|(_, b)| &b.text).collect::<Vec<_>>());
// Per-character x positions split "Three" where they place characters (ADR 0070); a text
// path whose path is missing is drawn on a line.
let words: Vec<&str> = t.iter().map(|(_, b)| b.text.as_str()).collect();
assert_eq!(words, ["One", "Two", "T", "h", "ree", "Four"]);
for (k, x) in [(3, 10.0), (4, 20.0)] {
let r = ink(&t[k].0, &t[k].1);
assert!(r.min.x >= x - 0.5 && r.min.x < x + 4.0, "{}: {r:?}", t[k].1.text);
}
assert_eq!(report.missing_fonts.iter().map(String::as_str).collect::<Vec<_>>(), ["Zz Missing Face"]);
assert!(fonts.families().contains(report.fallback_font.as_ref().unwrap()));
assert!(report.summary().contains("Fonts not on this computer, drawn in"), "{}", report.summary());
for k in ["underlined or struck-through text (lines left out)", "per-character text positions (ignored)", "strokes on text (left out)", "text on a path", "outlined text without a fill (left out)"] {
assert_eq!(report.skipped.get("strokes on text (left out)"), Some(&3), "once per block");
for k in ["underlined or struck-through text (lines left out)", "text on a path whose path is missing (drawn on a line)", "outlined text without a fill (left out)"] {
assert_eq!(report.skipped.get(k), Some(&1), "{k}: {report:?}");
}
}
@@ -115,3 +123,72 @@ fn text_can_be_a_clip_and_needs_fonts() {
let mask = i.layers.iter().find_map(|l| l.mask.as_ref()).expect("a mask layer");
assert!(matches!(&mask.elements[0].kind, ElementKind::Text(b) if b.text == "REVEAL"), "the mask stays editable text");
}
#[test]
fn text_paths_become_text_on_a_path() {
let Some(fonts) = fonts() else { return };
let (t, report) = texts(
r##"<svg width="400" height="300" font-family="sans-serif" font-size="20">
<defs><path id="line" d="M 50 200 L 350 200"/><circle id="ring" cx="200" cy="100" r="60" transform="translate(0 10)"/></defs>
<text><textPath href="#line">Start here</textPath></text>
<text text-anchor="middle"><textPath xlink:href="#line" startOffset="50%">Middle</textPath></text>
<text><textPath href="#line" startOffset="20" side="right">Under</textPath></text>
<text><textPath href="#ring">Around the ring</textPath></text>
</svg>"##,
fonts,
);
assert!(report.skipped.is_empty(), "{report:?}");
let words: Vec<&str> = t.iter().map(|(_, b)| b.text.as_str()).collect();
assert_eq!(words, ["Start here", "Middle", "Under", "Around the ring"]);
for (_, b) in &t {
assert!(b.on_path.is_some(), "{}", b.text);
}
// On the line, standing on it, from its start.
let r = ink(&t[0].0, &t[0].1);
assert!((r.min.x - 50.0).abs() < 4.0 && r.max.y <= 206.0 && r.max.y > 195.0, "{r:?}");
// startOffset 50% with text-anchor middle: centred on x 200.
assert_eq!(t[1].1.align, TextAlign::Center);
assert!((ink(&t[1].0, &t[1].1).center().x - 200.0).abs() < 3.0);
assert!((t[1].1.on_path.as_ref().unwrap().offset - 150.0).abs() < 0.01);
// side="right": walked backwards from the end, under the line.
let u = ink(&t[2].0, &t[2].1);
let on = t[2].1.on_path.as_ref().unwrap();
assert!(on.flip && u.min.y > 195.0 && u.max.x <= 331.0, "{u:?}");
// The ring keeps its own transform: glyphs sit round (200, 110), radius 60.
let ring = ink(&t[3].0, &t[3].1);
assert!(ring.min.x > 200.0 - 90.0 && ring.max.x < 200.0 + 90.0 && ring.min.y > 110.0 - 90.0 && ring.max.y < 110.0 + 90.0, "{ring:?}");
let path = t[3].1.on_path.as_ref().unwrap().path.transformed(&t[3].0.transform).bounds();
assert!((path.center().y - 110.0).abs() < 0.5 && (path.width() - 120.0).abs() < 0.5, "{path:?}");
}
#[test]
fn per_character_shifts_and_rotations_place_their_characters() {
let Some(fonts) = fonts() else { return };
let (t, report) = texts(
r##"<svg width="400" height="300" font-family="sans-serif" font-size="20">
<text x="10" y="50" dx="0 0 30">abcd</text>
<text x="10" y="100" dy="0 10 10">xyz</text>
<text x="10" y="150" rotate="0 90">ok</text>
<text x="10 40" y="200 220">AB</text>
</svg>"##,
fonts,
);
assert!(report.skipped.is_empty(), "{report:?}");
let words: Vec<&str> = t.iter().map(|(_, b)| b.text.as_str()).collect();
assert_eq!(words, ["ab", "cd", "x", "y", "z", "o", "k", "A", "B"]);
// dx 30 on "c": it starts 30 px after "ab" ends.
let (ab, cd) = (ink(&t[0].0, &t[0].1), ink(&t[1].0, &t[1].1));
let gap = cd.min.x - (t[0].0.transform.translation().x + t[0].1.box_width);
assert!((gap - 30.0).abs() < 3.0, "{ab:?} {cd:?} gap {gap}");
assert!((ab.max.y - cd.max.y).abs() < 2.0, "same baseline");
// dy moves each later character down, cumulatively.
let (x, y, z) = (ink(&t[2].0, &t[2].1), ink(&t[3].0, &t[3].1), ink(&t[4].0, &t[4].1));
assert!((y.min.y - x.min.y - 10.0).abs() < 2.0 && (z.min.y - x.min.y - 20.0).abs() < 2.0, "{x:?} {y:?} {z:?}");
assert!(y.min.x > x.max.x - 1.0, "continues after the x");
// rotate 90 on "k": turned a quarter about its baseline origin (taller than wide, below).
let k = ink(&t[6].0, &t[6].1);
assert!(k.min.y > 140.0 && t[6].0.transform.m[1].abs() > 0.99, "{k:?} {:?}", t[6].0.transform);
// Absolute x and y lists place each character.
let b = ink(&t[8].0, &t[8].1);
assert!(b.min.x >= 40.0 && b.min.x < 44.0 && (b.max.y - 220.0).abs() < 1.5, "{b:?}");
}
+23
View File
@@ -168,6 +168,29 @@ pub fn on_path(glyphs: &[PlacedGlyph], path: &Path, how: PathPlacement) -> Optio
Some(out)
}
/// Text on a path in a box of its own, as text blocks keep it (ADR 0070): the glyphs set along
/// the path, then the glyphs and the path moved together so their bounds start at the origin.
#[derive(Clone, Debug, PartialEq)]
pub struct BoxedPathText {
pub outline: Path,
pub path: Path,
pub width: f32,
pub height: f32,
/// Where the box's origin is in the path's space: what to translate by to put it back.
pub shift: Vec2,
pub hidden: usize,
}
/// [`on_path`], boxed ([`BoxedPathText`]).
pub fn on_path_boxed(glyphs: &[PlacedGlyph], path: &Path, how: PathPlacement) -> Option<BoxedPathText> {
let set = on_path(glyphs, path, how)?;
let b = set.outline.bounds().union(&path.bounds());
let shift = if b.min.x.is_finite() && b.min.y.is_finite() { b.min } else { Vec2::ZERO };
let back = anicraft_geom::Affine::translate(-shift.x, -shift.y);
let size = |v: f32| if v.is_finite() { v.max(0.0) } else { 0.0 };
Some(BoxedPathText { outline: set.outline.transformed(&back), path: path.transformed(&back), width: size(b.width()), height: size(b.height()), shift, hidden: set.hidden })
}
/// Whether a path's first subpath ends with a close.
fn first_subpath_closed(path: &Path) -> bool {
for (i, c) in path.cmds.iter().enumerate() {