Skip to content

VectorCraft: An open-source, vector art tool written by scratch in pure Rust

Type on a path: right-to-left text that overflows shows its start

Jürg Lehni83a5978d6ebf
diff --git a/crates/text/src/layout.rs b/crates/text/src/layout.rs
index 5bf9f30bf..3f7e40011 100644
--- a/crates/text/src/layout.rs
+++ b/crates/text/src/layout.rs
@@ -2278,28 +2278,36 @@ fn on_path(cx: &mut Ctx<'_>, paras: &[Range<usize>], t: &TextObject, path: &Path
cx.out.on_path = true;
// Type on a path is one line: the first paragraph's attributes align it.
let para = t.para_at(0);
- let mut sg = Vec::new();
// The first paragraph's direction aligns the line (Auto) and sets the caret's.
let mut rtl = None;
+ let mut shaped = Vec::new();
for pr in paras {
let text = cx.text;
let bidi = para_bidi(text.get(pr.clone()).unwrap_or_default(), para.direction);
rtl.get_or_insert(is_rtl(bidi.as_ref()) && !cx.vertical);
- let shaped = cx.shape_para(pr.clone(), bidi.as_ref());
- for i in visual_order(bidi.as_ref().filter(|_| !cx.vertical), pr.start, pr.clone(), &shaped) {
- if let Some(g) = shaped.get(i) {
- sg.push(g.clone());
- }
- }
+ let glyphs = cx.shape_para(pr.clone(), bidi.as_ref());
+ shaped.push((pr.clone(), bidi.filter(|b| b.has_rtl() && !cx.vertical), glyphs));
}
let rtl = rtl.unwrap_or(false);
+ // The text before byte `cut` in visual order, as area type reorders each line it breaks.
+ let visual = |cut: usize| {
+ let mut sg = Vec::new();
+ for (pr, bidi, glyphs) in &shaped {
+ let n = glyphs.iter().take_while(|g| g.byte < cut).count();
+ let line = glyphs.get(..n).unwrap_or_default();
+ let end = glyphs.get(n).map_or(pr.end, |g| g.byte);
+ sg.extend(visual_order(bidi.as_ref(), pr.start, pr.start..end, line).into_iter().filter_map(|i| line.get(i).cloned()));
+ }
+ sg
+ };
+ let text_len = cx.text.len();
+ let mut sg = visual(text_len);
// A path out of range holds no text, as a path with no length holds none.
let ap = if in_range(&path.to_bezpath()) { ArcPath::new(path) } else { ArcPath::default() };
let m = Metrics::max(&sg).map(|m| (m.asc, m.desc)).unwrap_or_else(|| {
let s = style_metrics(cx.db, cx.style_at(0));
(s.0, s.1)
});
- let text_len = cx.text.len();
if ap.is_empty() {
cx.out.overflow = !sg.is_empty();
cx.out.lines.push(LineInfo {
@@ -2324,8 +2332,6 @@ fn on_path(cx: &mut Ctx<'_>, paras: &[Range<usize>], t: &TextObject, path: &Path
let s_start = from * ap.len();
let avail = (to - from) * ap.len();
let spacing = if t.path_spacing.is_finite() { t.path_spacing } else { 0.0 };
- let mut steps = path_steps(&ap, &sg, s_start, spacing);
- let w: f64 = steps.iter().sum();
// Optical Margin Alignment and Roman Hanging Punctuation: the brackets are the margins, and the
// glyphs at the line's ends hang outside them by `hang_l` and `hang_r`, measured along the path.
// The line is aligned in a span that much longer at each end, and the glyphs that hang at the
@@ -2336,7 +2342,7 @@ fn on_path(cx: &mut Ctx<'_>, paras: &[Range<usize>], t: &TextObject, path: &Path
// The hangs are measured on the steps the glyphs take where the line is placed. A right-to-left
// line is read from right to left ([`optical_hangs_rtl`]); in vertical type `sg` is in text order.
let hanging = t.optical_margin || para.roman_hanging;
- let hangs = |steps: &[f64]| {
+ let hangs = |sg: &[SGlyph], steps: &[f64]| {
if !hanging {
return (0.0, 0.0, 0);
}
@@ -2364,34 +2370,85 @@ fn on_path(cx: &mut Ctx<'_>, paras: &[Range<usize>], t: &TextObject, path: &Path
};
(l, r, hung_r)
};
- let place = |(l, r, _): (f64, f64, usize)| {
- let (lo, room) = (s_start - l, avail + l + r);
- match para.justify {
- Justify::Auto if rtl => lo + (room - w).max(0.0),
- Justify::Center | Justify::JustifyCenter => lo + ((room - w) * 0.5).max(0.0),
- Justify::Right | Justify::JustifyRight => lo + (room - w).max(0.0),
- _ => lo,
+ // The glyphs `sg` arranged on the path: their steps, where the first starts, and the hangs.
+ let arrange = |sg: &[SGlyph]| {
+ let mut steps = path_steps(&ap, sg, s_start, spacing);
+ let w: f64 = steps.iter().sum();
+ let place = |(l, r, _): (f64, f64, usize)| {
+ let (lo, room) = (s_start - l, avail + l + r);
+ match para.justify {
+ Justify::Auto if rtl => lo + (room - w).max(0.0),
+ Justify::Center | Justify::JustifyCenter => lo + ((room - w) * 0.5).max(0.0),
+ Justify::Right | Justify::JustifyRight => lo + (room - w).max(0.0),
+ _ => lo,
+ }
+ };
+ let mut hung = hangs(sg, &steps);
+ let mut s0 = place(hung);
+ if spacing != 0.0 && s0 != s_start {
+ // Spaced from where the alignment puts them, the curve under them is another. That
+ // changes the hanging glyphs' steps, so the line is placed again from the new steps
+ // until it stays where it is (at most 8 times).
+ steps = path_steps(&ap, sg, s0, spacing);
+ for _ in 0..8 {
+ hung = hangs(sg, &steps);
+ let moved = place(hung);
+ if (moved - s0).abs() < 1e-9 {
+ break;
+ }
+ s0 = moved;
+ steps = path_steps(&ap, sg, s0, spacing);
+ }
}
+ (steps, s0, hung)
};
- let mut hung = hangs(&steps);
- let mut s0 = place(hung);
- if spacing != 0.0 && s0 != s_start {
- // Spaced from where the alignment puts them, the curve under them is another. That changes
- // the hanging glyphs' steps, so the line is placed again from the new steps until it stays
- // where it is (at most 8 times).
- steps = path_steps(&ap, &sg, s0, spacing);
- for _ in 0..8 {
- hung = hangs(&steps);
- let moved = place(hung);
- if (moved - s0).abs() < 1e-9 {
- break;
+ // How many of the arranged glyphs fit before one runs past the end bracket (with the hang).
+ let fitting = |steps: &[f64], s0: f64, (hang_l, hang_r, hung_r): (f64, f64, usize)| {
+ let (lo, room) = (s_start - hang_l, avail + hang_l + hang_r);
+ let mut x = 0.0;
+ steps
+ .iter()
+ .enumerate()
+ .take_while(|&(k, &step)| {
+ let end = if k + hung_r >= steps.len() { room } else { room - hang_r };
+ let fit = s0 + x + step - lo <= end + 1e-6;
+ x += step;
+ fit
+ })
+ .count()
+ };
+ let (mut steps, mut s0, mut hung) = arrange(&sg);
+ // Where the text that fits ends: before the first glyph that doesn't, which threaded text
+ // flows on from, as from the last line of area type.
+ let mut fits = text_len;
+ // Right-to-left text that overflows keeps the start of its text, not what comes first in visual
+ // order: the longest start, in reading order, whose glyphs fit in visual order is laid out.
+ if shaped.iter().any(|(_, bidi, _)| bidi.is_some()) && fitting(&steps, s0, hung) < sg.len() {
+ let mut starts: Vec<usize> = shaped.iter().flat_map(|(_, _, glyphs)| glyphs.iter().map(|g| g.byte)).collect();
+ starts.dedup();
+ // The text before `starts[fit]` fits; before `starts[over]` (the whole text at the end) it
+ // doesn't.
+ let (mut fit, mut over) = (0, starts.len());
+ while over - fit > 1 {
+ let mid = (fit + over) / 2;
+ let sg = visual(starts.get(mid).copied().unwrap_or(text_len));
+ let (steps, s0, hung) = arrange(&sg);
+ if fitting(&steps, s0, hung) == sg.len() {
+ fit = mid;
+ } else {
+ over = mid;
}
- s0 = moved;
- steps = path_steps(&ap, &sg, s0, spacing);
}
+ cx.out.overflow = true;
+ fits = starts.get(fit).copied().unwrap_or(text_len);
+ sg = visual(fits);
+ (steps, s0, hung) = arrange(&sg);
+ }
+ let fit = fitting(&steps, s0, hung);
+ if fit < sg.len() {
+ cx.out.overflow = true;
+ fits = sg.get(fit..).and_then(|rest| rest.iter().map(|g| g.byte).min()).unwrap_or(text_len);
}
- let (hang_l, hang_r, hung_r) = hung;
- let (lo, room) = (s_start - hang_l, avail + hang_l + hang_r);
// Align to Path: how far down (glyph space) the type moves to run its ascender, centre or
// descender along the path instead of its baseline.
let rise = match t.path_align {
@@ -2401,17 +2458,8 @@ fn on_path(cx: &mut Ctx<'_>, paras: &[Range<usize>], t: &TextObject, path: &Path
PathAlign::Center => (m.0 - m.1) * 0.5,
};
let mut x = 0.0;
- // Where the text that fits ends: before the first glyph that doesn't, which threaded text
- // flows on from, as from the last line of area type.
- let mut fits = text_len;
- for (k, (g, &step)) in sg.iter().zip(&steps).enumerate() {
+ for (g, &step) in sg.iter().zip(&steps).take(fit) {
let s = s0 + x;
- let end = if k + hung_r >= sg.len() { room } else { room - hang_r };
- if s + step - lo > end + 1e-6 {
- cx.out.overflow = true;
- fits = sg.get(k..).and_then(|rest| rest.iter().map(|g| g.byte).min()).unwrap_or(text_len);
- break;
- }
let (p, dir) = ap.at(s + step * 0.5);
let angle = dir.y.atan2(dir.x);
let half = Affine::translate((-g.adv * 0.5, rise));
diff --git a/crates/text/src/tests_bidi.rs b/crates/text/src/tests_bidi.rs
index 4646384de..c213f09cf 100644
--- a/crates/text/src/tests_bidi.rs
+++ b/crates/text/src/tests_bidi.rs
@@ -551,3 +551,63 @@ fn digits_draw_every_digit_in_the_styles_numeral_system() {
// Default leaves each digit as typed.
assert_ne!(gids(&lay("3 ٣ ۳", Digits::Default)), gids(&lay("3 ٣ ۳", Digits::Hindi)));
}
+
+/// Right-to-left type on a path that overflows shows the start of its text, as a line of area
+/// type does, not whatever comes first in visual order.
+#[test]
+fn overflowing_rtl_type_on_a_path_keeps_the_start_of_its_text() {
+ let s = "שלום עולם ".repeat(8);
+ let mut t = TextObject::point(Point::ZERO, &s, CharStyle::default());
+ let line = kurbo::Line::new((0.0, 0.0), (100.0, 0.0)).to_path(0.1);
+ t.kind = TextKind::OnPath { path: vectorcraft_geom::PathData::from_bezpath(&line), start: 0.0, end: None };
+ let l = layout(FontDb::global(), &t);
+ assert!(l.overflow && !l.glyphs.is_empty());
+ let shown: Vec<_> = source_clusters(&l).into_iter().map(|(byte, _)| byte).collect();
+ let last = shown.last().copied().unwrap_or(0);
+ let start: Vec<_> = s.char_indices().map(|(i, _)| i).take_while(|i| *i <= last).collect();
+ assert_eq!(shown, start, "the glyphs shown are the text's start");
+ let x = |byte: usize| l.glyphs.iter().find(|g| g.byte == byte).map(|g| g.origin.x).unwrap();
+ assert!(x(0) > x(last), "the text runs right to left along the path");
+}
+
+/// On a curve with spacing, where a glyph's step depends on where it sits, what fits is measured
+/// where the glyphs are placed: the start of the text shows, and every glyph of it.
+#[test]
+fn overflowing_rtl_type_on_a_spaced_curve_keeps_the_start_of_its_text() {
+ let s = "שלום, עולם! אבג ".repeat(6);
+ // Straight, then tightly curved: glyphs take other steps there.
+ let mut path = BezPath::new();
+ path.move_to((0.0, 0.0));
+ path.line_to((60.0, 0.0));
+ path.extend(kurbo::Arc::new((60.0, 12.0), (12.0, 12.0), -std::f64::consts::FRAC_PI_2, std::f64::consts::PI, 0.0).append_iter(0.1));
+ let mut t = TextObject::point(Point::ZERO, &s, CharStyle::default());
+ t.kind = TextKind::OnPath { path: vectorcraft_geom::PathData::from_bezpath(&path), start: 0.0, end: None };
+ for spacing in (-12..=12).map(|i| f64::from(i) * 5.0) {
+ t.path_spacing = spacing;
+ let l = layout(FontDb::global(), &t);
+ assert!(l.overflow && !l.glyphs.is_empty());
+ let shown: Vec<_> = source_clusters(&l).into_iter().map(|(byte, _)| byte).collect();
+ let last = shown.last().copied().unwrap_or(0);
+ let start: Vec<_> = s.char_indices().map(|(i, _)| i).take_while(|i| *i <= last).collect();
+ assert_eq!(shown, start, "the glyphs shown are the text's start ({spacing})");
+ }
+}
+
+/// A left-to-right line with right-to-left text in it fits as it is laid out: a period that
+/// hangs past the end bracket (Roman Hanging Punctuation) stays, and nothing overflows.
+#[test]
+fn mixed_type_on_a_path_hangs_its_final_period() {
+ let s = "bא.";
+ let line = kurbo::Line::new((0.0, 0.0), (400.0, 0.0)).to_path(0.1);
+ let mut t = TextObject::point(Point::ZERO, s, CharStyle::default());
+ t.kind = TextKind::OnPath { path: vectorcraft_geom::PathData::from_bezpath(&line), start: 0.0, end: None };
+ t.para.roman_hanging = true;
+ let advances: Vec<f64> = layout(FontDb::global(), &t).glyphs.iter().map(|g| g.advance).collect();
+ assert_eq!(advances.len(), 3);
+ // The end bracket halfway through the period, with path beyond it.
+ let end = advances[0] + advances[1] + advances[2] * 0.5;
+ t.kind = TextKind::OnPath { path: vectorcraft_geom::PathData::from_bezpath(&line), start: 0.0, end: Some(end / 400.0) };
+ let l = layout(FontDb::global(), &t);
+ assert!(l.glyphs.iter().any(|g| g.byte == s.len() - 1), "the period shows");
+ assert!(!l.overflow, "all of it fits");
+}
diff --git a/crates/text/src/thread.rs b/crates/text/src/thread.rs
index 4707b049b..a1fbf9093 100644
--- a/crates/text/src/thread.rs
+++ b/crates/text/src/thread.rs
@@ -178,6 +178,23 @@ mod tests {
assert!(at_space > 0, "some lengths end at a space");
}
+ /// A right-to-left story flows on from where its text stops fitting a path, in reading order.
+ #[test]
+ fn right_to_left_story_flows_on_from_a_path() {
+ let db = FontDb::global();
+ let text = "שלום עולם ".repeat(8);
+ let story = vec![TextRun { text: text.clone(), style: CharStyle::default(), inline: None }];
+ let (a, b) = (path_frame(100.0), frame(400.0));
+ let parts: Vec<Vec<TextRun>> = distribute(db, &[&a, &b], &story, &[]).into_iter().map(|s| s.runs).collect();
+ let lens: Vec<usize> = parts.iter().map(|p| runs_len(p)).collect();
+ assert!(lens.iter().all(|l| *l > 0), "each frame takes a share: {lens:?}");
+ let joined: String = parts.iter().flatten().map(|r| r.text.as_str()).collect();
+ assert_eq!(joined, text, "no character lost or duplicated");
+ let mut on_path = a.clone();
+ on_path.runs = parts[0].clone();
+ assert!(!layout(db, &on_path).overflow, "the path's share fits it");
+ }
+
/// A path with no length holds no text, so the story flows past it.
#[test]
fn story_flows_past_a_path_with_no_length() {