Skip to content

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

refactor(text): move layout.rs items to layout/{bidi,breaking,driver,flow,on_path,region,ruby,vertical}.rs

aiongga8935c0ada37
diff --git a/crates/text/src/layout.rs b/crates/text/src/layout.rs
index 2405ad55f..f9db3de68 100644
--- a/crates/text/src/layout.rs
+++ b/crates/text/src/layout.rs
@@ -23,6 +23,22 @@ use crate::shape::{
};
use crate::{Composer, FirstBaseline, InlineGlyph, LayoutOptions, LineInfo, ListMarker, OtFeatures, PositionedGlyph, TextLayout, VerticalAlign};
+mod bidi;
+mod breaking;
+mod driver;
+mod flow;
+mod on_path;
+mod region;
+mod ruby;
+mod vertical;
+
+pub(crate) use bidi::{is_rtl, para_bidi};
+use breaking::tab_advance;
+#[cfg(test)]
+use breaking::{break_line, candidates};
+pub use driver::{decorations, fit_first_line, layout, layout_with, scaled};
+use vertical::{stands_upright, tate_chu_yoko, upright_cell, upright_centre, whole_character_widths};
+
const EPS: f64 = 1e-6;
struct Ctx<'a> {
@@ -287,1548 +303,145 @@ impl Ctx<'_> {
}
}
-/// Lay out a text object into text-space glyph outlines (default [`LayoutOptions`]).
-pub fn layout(db: &FontDb, t: &TextObject) -> TextLayout {
- let a = &t.area;
- let opts = LayoutOptions {
- rows: a.rows,
- columns: a.columns,
- gutter: a.gutter,
- inset: a.inset,
- first_baseline: a.first_baseline,
- first_baseline_min: a.first_baseline_min,
- vertical_align: a.vertical_align,
- fit: a.fit,
- ..LayoutOptions::default()
- };
- layout_with(db, t, &opts)
-}
-
-/// Area type in a frame too short for its first line draws nothing (type that doesn't fit its frame
-/// isn't drawn). For importers whose source shows that line: the frame is made taller, from its
-/// top, by what the first line needs. Whether it was.
-pub fn fit_first_line(db: &FontDb, t: &mut TextObject) -> bool {
- let TextKind::Area { frame } = &t.kind else { return false };
- let Some(b) = frame.bounds().filter(|b| b.height() > 1e-6) else { return false };
- if !layout(db, t).lines.is_empty() {
- return false;
- }
- // The height of its first line: the line's as point type.
- let point = TextObject { kind: TextKind::Point, ..t.clone() };
- let Some(need) = layout(db, &point).lines.first().map(|l| l.ascent + l.descent) else { return false };
- // (A little more than it, for the rounding of the layout.)
- let by = (need + 0.05) / b.height();
- if !(by.is_finite() && by > 1.0) {
- return false;
- }
- let taller = frame.transformed(Affine::translate((0.0, b.y0)) * Affine::scale_non_uniform(1.0, by) * Affine::translate((0.0, -b.y0)));
- let short = std::mem::replace(&mut t.kind, TextKind::Area { frame: taller });
- // Something else keeps the line out (a frame narrower than a letter): as the source has it.
- if layout(db, t).lines.is_empty() {
- t.kind = short;
- return false;
- }
- true
-}
+#[cfg(test)]
+mod wrapping_tests {
+ use super::*;
+ use std::sync::Arc;
-/// The underline and strikethrough bars of `t` laid out as `layout` (#847): per run and line, a
-/// bar from the stretch's first glyph to its last one's advance, placed and sized by the font's
-/// own underline and strikeout metrics through the glyph's transform (so the size, baseline shift
-/// and scaling follow) → (run, bar in text space). Type on a path and vertical type have none yet.
-pub fn decorations(layout: &TextLayout, db: &FontDb, t: &TextObject) -> Vec<(usize, BezPath)> {
- let mut out = vec![];
- if layout.on_path || layout.vertical {
- return out;
- }
- let glyphs = &layout.glyphs;
- let mut i = 0;
- while let Some(g) = glyphs.get(i) {
- // The stretch: the glyphs of this run on this line, in a row. A list marker has no
- // underline or strikethrough.
- let marker = layout.marker_of(i).is_some();
- let end = glyphs
+ fn synthetic_glyphs(specs: &[(usize, usize, f64, char)]) -> Vec<SGlyph> {
+ // The face is only a required SGlyph field here; advances and cluster boundaries below are
+ // entirely synthetic, so the regressions don't depend on a particular font's shaping.
+ static DB: std::sync::OnceLock<FontDb> = std::sync::OnceLock::new();
+ let db = DB.get_or_init(|| FontDb::with_font_dirs(vec![]));
+ let face = db.face("Source Sans 3", "Regular").expect("bundled test face");
+ specs
.iter()
- .enumerate()
- .skip(i)
- .position(|(k, h)| h.run != g.run || h.line != g.line || layout.marker_of(k).is_some() != marker)
- .map_or(glyphs.len(), |n| i + n);
- let stretch = glyphs.get(i..end).unwrap_or_default();
- i = end.max(i + 1);
- if marker {
- continue;
- }
- let Some(style) = t.runs.get(g.run).map(|r| &r.style) else { continue };
- if !(style.underline || style.strikethrough) {
- continue;
- }
- let Some(face) = db.face_by_id(g.font_id) else { continue };
- let (x0, x1) = stretch.iter().fold((f64::INFINITY, f64::NEG_INFINITY), |(a, b), h| {
- let (s, e) = (h.origin.x, h.origin.x + h.advance);
- (a.min(s).min(e), b.max(s).max(e))
- });
- for (on, (offset, thickness)) in [(style.underline, face.underline), (style.strikethrough, face.strikeout)] {
- if !on {
- continue;
- }
- // Font units run y down in the glyph's transform: the bar's top is at -offset.
- let (top, bottom) = ((g.xf * Point::new(0.0, -offset)).y, (g.xf * Point::new(0.0, -offset + thickness)).y);
- let bar = Rect::new(x0, top.min(bottom), x1, top.max(bottom));
- if bar.width() > 0.0 && bar.height() > 0.0 && bar.width().is_finite() && bar.height().is_finite() {
- out.push((g.run, bar.to_path(0.1)));
- }
- }
- }
- out
-}
-
-/// Most layout passes Shrink Text to Fit runs past the first (bisection plus the final pass).
-const SHRINK_PASSES: usize = 11;
-
-/// Lay out a text object with explicit options (area type rows/columns, inset, first baseline,
-/// fit, composer, OpenType features).
-pub fn layout_with(db: &FontDb, t: &TextObject, opts: &LayoutOptions) -> TextLayout {
- let first = layout_once(db, t, opts);
- match (opts.fit.min_scale(), &t.kind) {
- (Some(min), TextKind::Area { .. }) if first.overflow => shrink_to_fit(db, t, opts, min).unwrap_or(first),
- _ => first,
- }
-}
-
-/// Shrink Text to Fit for text that overflows at full size: the largest scale in `min..1` at which
-/// it fits, searched by bisection over the first run's document size in steps of 0.1 pt (so its scaled size
-/// is a whole number of tenths of a point, the same every time). Down at `min` it lays out there,
-/// still overflowing. None (keep the full-size layout) when the text has no usable size.
-fn shrink_to_fit(db: &FontDb, t: &TextObject, opts: &LayoutOptions, min: f64) -> Option<TextLayout> {
- // Exact size edits after object scaling may store a local size below 0.1. Fit in the
- // same document points as the Character controls, independent of that representation.
- let points = t.style_scale()?.points;
- let size = t.runs.first().map(|r| r.style.size * points).filter(|s| s.is_finite() && *s >= 0.1)?;
- if !(min.is_finite() && min < 1.0) {
- return None;
- }
- let tenths = size * 10.0;
- if !tenths.is_finite() {
- return None;
- }
- // Candidate sizes k/10 pt for k in lo..hi: `hi` (full size, rounded down) is known to overflow
- // unless it is below the full size; `lo` is the smallest allowed.
- let mut lo = (tenths * min).ceil().max(1.0);
- let mut hi = tenths.floor();
- if hi < lo {
- hi = lo;
- }
- let at = |k: f64| -> TextLayout {
- let f = (k / tenths).clamp(min, 1.0);
- let mut l = layout_once(db, &scaled(t, f), opts);
- l.fit_scale = f;
- l
- };
- let mut passes = 0;
- let mut best: Option<TextLayout> = None;
- // `hi` itself may fit when the size isn't a whole number of tenths.
- if hi < tenths && hi > lo {
- let l = at(hi);
- passes += 1;
- if !l.overflow {
- return Some(l);
- }
- }
- // Invariant: everything at `hi` or above overflows; `lo` fits or is the floor.
- while hi - lo > 1.0 && passes + 1 < SHRINK_PASSES {
- let mid = (lo + (hi - lo) * 0.5).floor();
- let l = at(mid);
- passes += 1;
- if l.overflow {
- hi = mid;
- } else {
- lo = mid;
- best = Some(l);
- }
- }
- // `best` is the layout at `lo` once `lo` has moved; at the floor it still needs laying out.
- Some(best.unwrap_or_else(|| at(lo)))
-}
-
-/// `t` with every run's size, explicit leading and baseline shift scaled by `f`, inline art's own
-/// shift included (auto leading and the art's size follow the size; paragraph spacing stays).
-/// Shrink Text to Fit lays `t` out as `scaled(t, f)`, where `f` is the layout's
-/// [`TextLayout::fit_scale`], so the result holds the styles the text is drawn in.
-pub fn scaled(t: &TextObject, f: f64) -> TextObject {
- let mut s = t.clone();
- for r in &mut s.runs {
- r.style.size *= f;
- r.style.leading = r.style.leading.map(|l| l * f);
- r.style.baseline_shift *= f;
- if let Some(a) = &mut r.inline {
- a.baseline_shift *= f;
- }
+ .map(|&(byte, len, adv, ch)| SGlyph {
+ face: Arc::clone(&face),
+ gid: 0,
+ byte,
+ len,
+ run: 0,
+ adv,
+ dx: 0.0,
+ dy: 0.0,
+ sx: 1.0,
+ sy: 1.0,
+ bshift: 0.0,
+ rotation: 0.0,
+ ascent: 8.0,
+ descent: 2.0,
+ leading: 0.0,
+ cap: 6.0,
+ xh: 4.0,
+ ch,
+ tcy: None,
+ inline: None,
+ word_end: false,
+ lead: 0.0,
+ proportional: false,
+ vpal: None,
+ level: unicode_bidi::Level::ltr(),
+ no_break: false,
+ cursive: false,
+ })
+ .collect()
}
- s
-}
-/// One layout pass, without fitting.
-fn layout_once(db: &FontDb, t: &TextObject, opts: &LayoutOptions) -> TextLayout {
- let text = t.plain_text();
- let mut runs = Vec::with_capacity(t.runs.len());
- let mut inlines = Vec::with_capacity(t.runs.len());
- let mut off = 0;
- for r in &t.runs {
- runs.push((off..off + r.text.len(), &r.style));
- // Only a well-formed inline run (one object replacement character) is a graphic.
- inlines.push(r.inline.as_ref().filter(|_| crate::edit::is_inline_text(&r.text)));
- off += r.text.len();
- }
- let mut paras = Vec::new();
- let mut s = 0;
- for (i, c) in text.char_indices() {
- if c == '\n' {
- paras.push(s..i);
- s = i + 1;
- }
- }
- paras.push(s..text.len());
- let vertical = t.vertical;
- let is_on_path = matches!(&t.kind, TextKind::OnPath { .. });
- let vopts;
- let opts = if vertical {
- vopts = LayoutOptions { features: OtFeatures { vertical: true, ..opts.features }, ..opts.clone() };
- &vopts
- } else {
- opts
- };
- let mut cx = Ctx {
- on_path: is_on_path,
- db,
- text: &text,
- runs,
- inlines,
- default: CharStyle::default(),
- opts,
- vertical,
- system_layout: t.system_layout,
- fractional_widths: t.fractional_widths,
- out: TextLayout::default(),
- };
- // Vertical type: line space turned a quarter turn clockwise (lines become columns, each next
- // one to the left). Point type's anchor is on the first column's centre line. Vertical path
- // type stays on its path (each glyph turned across it in `emit`).
- let line_xf = match &t.kind {
- _ if !vertical => Affine::IDENTITY,
- TextKind::OnPath { .. } => Affine::IDENTITY,
- TextKind::Point => {
- let first = cx.style_at(0);
- let centre = db.style_face(first).map_or(EM_CENTER, |f| f.ideographic_centre());
- Affine::translate((-centre * first.size, 0.0)) * QUARTER_TURN
- }
- _ => QUARTER_TURN,
- };
- match &t.kind {
- TextKind::Point => flow(&mut cx, &paras, t, None),
- TextKind::Area { frame } => {
- let to_lines = line_xf.inverse();
- let wrap: Vec<vectorcraft_doc::WrapShape> = if vertical {
- t.wrap.iter().map(|w| vectorcraft_doc::WrapShape { path: w.path.transformed(to_lines), ..w.clone() }).collect()
- } else {
- t.wrap.clone()
- };
- let mut regions = Region::cells(&(to_lines * frame.to_bezpath()), opts, &wrap);
- cx.out.frames = regions.iter().map(|r| line_xf.transform_rect_bbox(r.cell)).collect();
- flow(&mut cx, &paras, t, Some(&regions));
- if opts.vertical_align != VerticalAlign::Top {
- align_vertically(&mut cx, &paras, t, &mut regions);
- }
- }
- TextKind::OnPath { path, .. } => on_path(&mut cx, &paras, t, path),
- }
- // Ruby (furigana): placed over its base text in line space, before vertical type turns the
- // lines into columns, so the same pass puts it above (right in vertical type) and widens the
- // lines it sits on. Type on a path has no above/below; its ruby is left out for now.
- if !is_on_path && !t.ruby.is_empty() {
- ruby_layout(&mut cx, t);
- }
- if vertical && !is_on_path {
- // Glyph origins, outlines and transforms to text space (lines stay in line space).
- for g in &mut cx.out.glyphs {
- g.outline.apply_affine(line_xf);
- g.xf = line_xf * g.xf;
- g.origin = line_xf * g.origin;
- g.angle += std::f64::consts::FRAC_PI_2;
- }
- // Ruby glyphs are placed in line space too (upright, along the column, in the vertical
- // pass); the same turn takes them to text space.
- for g in &mut cx.out.ruby {
- g.outline.apply_affine(line_xf);
- g.xf = line_xf * g.xf;
- g.origin = line_xf * g.origin;
- g.angle += std::f64::consts::FRAC_PI_2;
- }
- for i in &mut cx.out.inlines {
- i.xf = line_xf * i.xf;
- i.bounds = line_xf.transform_rect_bbox(i.bounds);
- }
- cx.out.vertical = true;
- cx.out.line_xf = line_xf;
+ fn source_range(glyphs: &[SGlyph], start: usize, end: usize) -> Range<usize> {
+ let first = glyphs.get(start).expect("nonempty source range");
+ let last = glyphs.get(end - 1).expect("nonempty source range");
+ first.byte..last.byte + last.len
}
- finish_bounds(&mut cx.out);
- cx.out
-}
-/// System Layout on or Fractional Widths off: each character that takes space advances by a whole
-/// number of points, at least one, so small type does not collapse onto itself. A zero advance (a
-/// tate-chu-yoko continuation, a zero-width mark) stays zero.
-fn whole_character_widths(glyphs: &mut [SGlyph]) {
- for g in glyphs {
- if g.adv.is_finite() && g.adv > 0.0 {
- g.adv = g.adv.round().max(1.0);
- }
- }
-}
+ #[test]
+ fn greedy_wrap_keeps_an_oversized_first_cluster_and_its_source_range() {
+ let text = "بَت";
+ let glyphs = synthetic_glyphs(&[(0, 4, 2.0, 'ب'), (0, 4, 2.0, 'ب'), (4, 2, 1.0, 'ت')]);
-/// Tate-chu-yoko: a horizontal block one em of the column long, squeezed to the em when wider.
-///
-/// Automatic: a run of two or three half-width digits (`10`月, `100`年). A single digit and a
-/// longer number (`2026`) stay on their side.
-///
-/// Manual (Character panel menu › Tate-chu-yoko): any characters marked `tateChuYoko`, including
-/// one character, letters and numbers longer than three digits. Marked characters are taken
-/// before the automatic digit rule.
-/// <https://helpx.adobe.com/illustrator/using/formatting-asian-characters.html>
-fn tate_chu_yoko(g: &mut [SGlyph], style: impl Fn(&SGlyph) -> (f64, bool)) {
- let manual: Vec<bool> = g.iter().map(|gl| style(gl).1).collect();
- let digits: Vec<bool> = g.iter().map(|gl| gl.inline.is_none() && gl.ch.is_ascii_digit()).collect();
- let mut i = 0;
- while i < g.len() {
- if manual.get(i).copied().unwrap_or(false) {
- let mut end = i + 1;
- while manual.get(end).copied().unwrap_or(false) {
- end += 1;
- }
- let em = style(&g[i]).0;
- place_tcy_block(&mut g[i..end], em);
- i = end;
- continue;
- }
- if !digits.get(i).copied().unwrap_or(false) {
- i += 1;
- continue;
- }
- let mut end = i + 1;
- while digits.get(end).copied().unwrap_or(false) && !manual.get(end).copied().unwrap_or(false) {
- end += 1;
- }
- if (2..=3).contains(&(end - i)) {
- let em = style(&g[i]).0;
- place_tcy_block(&mut g[i..end], em);
- }
- i = end;
- }
-}
+ let (end, hyphenated) = break_line(text, &glyphs, 0, 3.0, &[], 0.0, None, Burasagari::None, Kinsoku::Hard);
-/// Lay `g` across one em of the column. The first glyph takes the em; the rest share its cell.
-fn place_tcy_block(g: &mut [SGlyph], em: f64) {
- let width: f64 = g.iter().map(|gl| gl.adv).sum();
- let squeeze = if width > em && width > 0.0 { em / width } else { 1.0 };
- let mut ink = 0.0;
- for (k, gl) in g.iter_mut().enumerate() {
- let adv = gl.adv;
- gl.tcy = Some(Tcy { pen: if k == 0 { 0.0 } else { em }, ink, width, squeeze });
- gl.adv = if k == 0 { em } else { 0.0 };
- ink += adv;
+ assert!(!hyphenated);
+ assert_eq!(end, 2, "oversized base-plus-mark cluster must stay together");
+ assert_eq!(source_range(&glyphs, 0, end), 0..4);
+ assert_eq!(glyphs.get(end).map(|g| g.byte), Some(4));
}
-}
-/// Half an em of `g`'s size when it is full-width Japanese punctuation of kind `kind` (its
-/// advance an em, give or take a tenth), the space that mojikumi can take off.
-fn punct_half(g: &SGlyph, kind: Punct) -> Option<f64> {
- // A glyph Proportional Metrics re-spaced has no empty half left to take off (#966).
- if punct(g.ch)? != kind || g.tcy.is_some() || g.proportional {
- return None;
- }
- let em = g.face.units_per_em();
- ((g.face.advance(g.gid) - em).abs() <= em * 0.1).then_some(em * 0.5 * g.sx)
-}
+ #[test]
+ fn greedy_wrap_keeps_an_oversized_cluster_after_a_line_start_atomic() {
+ let text = "بَتَث";
+ let glyphs = synthetic_glyphs(&[(0, 4, 1.0, 'ب'), (4, 4, 2.0, 'ت'), (4, 4, 2.0, 'ت'), (8, 2, 1.0, 'ث')]);
-/// Mojikumi (JLREQ 3.1.4): consecutive punctuation shares one half-em space. A closing bracket,
-/// comma or full stop followed by punctuation loses the space after it; an opening bracket after
-/// another loses the space before it. Returns which glyphs lost the space after them (a line
-/// ending in one takes nothing more off).
-fn compress_punctuation(sg: &mut [SGlyph]) -> Vec<bool> {
- let mut lost_after = vec![false; sg.len()];
- for j in 1..sg.len() {
- let (before, after) = sg.split_at_mut(j);
- let (Some(a), Some(b)) = (before.last_mut(), after.first_mut()) else { continue };
- if punct(b.ch).is_none() {
- continue;
- }
- if let Some(h) = punct_half(a, Punct::Closing) {
- a.adv -= h;
- if let Some(l) = lost_after.get_mut(j - 1) {
- *l = true;
- }
- } else if punct(a.ch) == Some(Punct::Opening)
- && let Some(h) = punct_half(b, Punct::Opening)
- {
- b.adv -= h;
- b.lead += h;
- }
- }
- lost_after
-}
+ let (first_end, _) = break_line(text, &glyphs, 0, 3.0, &[], 0.0, None, Burasagari::None, Kinsoku::Hard);
+ assert_eq!(first_end, 1);
+ assert_eq!(source_range(&glyphs, 0, first_end), 0..4);
-/// The space between Japanese and Latin letters or digits (JLREQ 3.2.2: a quarter em of the
-/// Japanese characters' size), with Line-end Punctuation Half Width.
-const WAKAN_AKI: f64 = 0.25;
+ let (second_end, hyphenated) = break_line(text, &glyphs, first_end, 3.0, &[], 0.0, None, Burasagari::None, Kinsoku::Hard);
-/// A Japanese character for the space next to Latin text: kana and kanji (and full-width
-/// letters, and the iteration and abbreviation marks 々 〆 〇), not punctuation or symbols, nor
-/// Hangul (Korean sets a word space instead).
-fn is_japanese_letter(c: char) -> bool {
- if matches!(c, '々' | '〆' | '〇') {
- return true;
+ assert!(!hyphenated);
+ assert_eq!(second_end, 3, "oversized cluster at the next line start must stay together");
+ assert_eq!(source_range(&glyphs, first_end, second_end), 4..8);
+ assert_eq!(glyphs.get(second_end).map(|g| g.byte), Some(8));
}
- is_cjk(c)
- && !matches!(
- c as u32,
- 0x3000..=0x303F | 0x3130..=0x318F | 0xAC00..=0xD7AF | 0xFF01..=0xFF0F | 0xFF1A..=0xFF20 | 0xFF3B..=0xFF40 | 0xFF5B..=0xFF65 | 0xFFA0..=0xFFDC
- )
- && c != '・'
- && punct(c).is_none()
-}
-/// A Latin letter or digit (or another script's letter), set proportionally.
-fn is_latin_letter(c: char) -> bool {
- c.is_alphanumeric() && !is_cjk(c)
-}
-
-/// Mojikumi (JLREQ 3.2.2): a quarter em between a Japanese character and a Latin letter or digit,
-/// either way round, added after the first of the two. Returns what each glyph got after it (taken
-/// off again when the line ends there).
-fn space_japanese_and_latin(sg: &mut [SGlyph]) -> Vec<f64> {
- let mut added = vec![0.0; sg.len()];
- for j in 1..sg.len() {
- let (before, after) = sg.split_at_mut(j);
- let (Some(a), Some(b)) = (before.last_mut(), after.first()) else { continue };
- if a.tcy.is_some() || b.tcy.is_some() {
- continue;
- }
- let japanese = if is_japanese_letter(a.ch) && is_latin_letter(b.ch) {
- Some(&*a)
- } else if is_latin_letter(a.ch) && is_japanese_letter(b.ch) {
- Some(b)
- } else {
- None
+ #[test]
+ fn narrow_arabic_area_wrap_keeps_base_and_mark_together_when_supported() {
+ let db = FontDb::global();
+ let Some(face) = db.face_covering('ب').filter(|face| face.covers('َ')) else {
+ // Arabic integration coverage depends on an installed font; synthetic tests above are
+ // the font-independent regression oracle.
+ return;
};
- if let Some(g) = japanese {
- let aki = WAKAN_AKI * g.face.units_per_em() * g.sx;
- a.adv += aki;
- if let Some(x) = added.get_mut(j - 1) {
- *x = aki;
- }
- }
- }
- added
-}
-
-/// The size of `g`'s em, in points.
-fn glyph_em(g: &SGlyph) -> f64 {
- g.face.units_per_em() * g.sy
-}
-
-/// How far up (line space) Character Alignment `a` moves glyph `g` on a line whose largest em is
-/// `line_em`: the glyph's em box top, centre or bottom onto the line's (the em box running from
-/// its centre less half an em to its centre plus half an em above the baseline), or its ICF's top
-/// or bottom (the em box's less the face's [`crate::IcfMargins`]; across a vertical line, its
-/// right and left). Nothing on the Roman baseline, or for the line's largest characters.
-///
-/// An inline graphic has its run's em (whatever its scale): it counts as one of the line's
-/// largest characters only when its run's size is, and moves with the text of its run (its art
-/// stays centred on that text's cap height).
-fn align_shift(g: &SGlyph, a: vectorcraft_doc::CharAlign, line_em: f64, vertical: bool) -> f64 {
- use vectorcraft_doc::CharAlign;
- let icf = || g.face.icf_margins();
- let k = match a {
- CharAlign::RomanBaseline => return 0.0,
- CharAlign::EmBoxTop => 0.5,
- CharAlign::EmBoxCenter => 0.0,
- CharAlign::EmBoxBottom => -0.5,
- CharAlign::IcfTop => 0.5 - if vertical { icf().right } else { icf().top },
- CharAlign::IcfBottom => -0.5 + if vertical { icf().left } else { icf().bottom },
- };
- (g.face.ideographic_centre() + k) * (line_em - glyph_em(g)).max(0.0)
-}
-
-/// The length an upright glyph takes down the column before tracking and justification: its
-/// vertical advance (the font's vertical metrics), else its advance, at least one em.
-fn upright_cell(g: &SGlyph) -> f64 {
- match g.face.vertical_glyph(g.gid) {
- Some((advance, _)) => advance * g.sy,
- None => (g.face.advance(g.gid) * g.sx).max(g.face.units_per_em() * g.sx),
- }
-}
-
-/// Height above the baseline (line space) of the centre of an upright glyph's `cell`, the point it
-/// turns about: from the font's vertical metrics, the cell hanging from the glyph's vertical origin;
-/// else the centre of the ideographic em box ([`EM_CENTER`] of the size `em`).
-fn upright_centre(g: &SGlyph, cell: f64, em: f64) -> f64 {
- match g.face.vertical_glyph(g.gid) {
- Some((_, origin)) => origin * g.sy - cell * 0.5,
- None => EM_CENTER * em,
- }
-}
-
-/// Height of the centre of the ideographic em box above the baseline, in ems (the em box runs
-/// from 0.12 em below the baseline to 0.88 em above it), for fonts without vertical metrics.
-const EM_CENTER: f64 = 0.38;
-
-/// A quarter turn clockwise (y down), exact: line space → text space for vertical type.
-const QUARTER_TURN: Affine = Affine::new([0.0, 1.0, -1.0, 0.0, 0.0, 0.0]);
-
-/// Does the glyph stand upright in vertical type? CJK characters and symbols do (their vertical
-/// forms come from the font's `vert` feature); Latin letters, digits and other characters lie on
-/// their side. Brackets, the long vowel mark and similar marks that need a vertical form lie on
-/// their side when the font has none (Unicode's Vertical_Orientation Tr).
-/// Fullwidth !/? instead keep the nominal glyph upright (Tu fallback, UAX #50 §3.1):
-/// <https://www.unicode.org/reports/tr50/#vo>.
-fn stands_upright(g: &SGlyph) -> bool {
- let c = g.ch as u32;
- let upright = matches!(c,
- 0x00A7 | 0x00A9 | 0x00AE | 0x00B1 | 0x00BC..=0x00BE | 0x00D7 | 0x00F7
- | 0x2016 | 0x2020 | 0x2021 | 0x2030 | 0x2031 | 0x203B | 0x203C | 0x2042 | 0x2047..=0x2049 | 0x2051
- | 0x20DD..=0x20E0 | 0x20E2..=0x20E4 | 0x2100..=0x2101 | 0x2103..=0x2109 | 0x210F | 0x2113 | 0x2116 | 0x2117
- | 0x211E..=0x2123 | 0x2125 | 0x2127 | 0x2129 | 0x212E | 0x2135..=0x213F | 0x2145..=0x214A | 0x214C | 0x214D | 0x214F..=0x2189
- | 0x2460..=0x24FF | 0x25A0..=0x27BF | 0x2B12..=0x2B2F | 0x2B50..=0x2B59
- | 0x1100..=0x11FF | 0x2E80..=0x303F | 0x3040..=0xA4CF | 0xA960..=0xA97F | 0xAC00..=0xD7FF
- | 0xE000..=0xFAFF | 0xFE10..=0xFE1F | 0xFE30..=0xFE4F | 0xFE50..=0xFE6F | 0xFF00..=0xFFE7
- | 0x1F000..=0x1FAFF | 0x20000..=0x3FFFF);
- if !upright {
- return false;
- }
- let needs_vertical_form = matches!(c,
- 0x3001 | 0x3002 | 0x3008..=0x3011 | 0x3013..=0x301F | 0x3030 | 0x30A0 | 0x30FC
- | 0xFE50..=0xFE52 | 0xFE59..=0xFE5E | 0xFF08 | 0xFF09 | 0xFF0C | 0xFF0E | 0xFF1A | 0xFF1B
- | 0xFF3B | 0xFF3D | 0xFF3F | 0xFF5B..=0xFF60 | 0xFFE3);
- // Without a vertical alternate the shaped glyph is the nominal one.
- !needs_vertical_form || g.gid != g.face.glyph_for(g.ch)
-}
-
-fn finish_bounds(out: &mut TextLayout) {
- let xf = out.line_xf;
- let mut b: Option<Rect> = None;
- let mut add = |r: Rect| b = Some(b.map_or(r, |b| b.union(r)));
- for g in &out.glyphs {
- if !g.outline.elements().is_empty() {
- add(g.outline.bounding_box());
- }
- if let Some((image, xf)) = g.placed_image() {
- add(xf.transform_rect_bbox(image.rect()));
- }
- if let Some(b) = g.colour.as_ref().and_then(|c| c.geometric_bounds()) {
- add(g.xf.transform_rect_bbox(b));
- }
- }
- // Ruby: covered by its line's ascent, but its ink can overhang sideways past the line.
- for g in &out.ruby {
- if !g.outline.elements().is_empty() {
- add(g.outline.bounding_box());
- }
- }
- for i in &out.inlines {
- add(i.bounds);
- }
- if !out.on_path {
- for l in &out.lines {
- add(xf.transform_rect_bbox(Rect::new(l.x0.min(l.x1), l.baseline - l.ascent, l.x0.max(l.x1), l.baseline + l.descent)));
- }
- }
- out.bounds = b.unwrap_or_default();
-}
-
-/// Space left in each cell after flowing top-aligned: (space above the first line's ascent, space
-/// below the last line's descent, number of distinct baselines). Cells without lines are `None`.
-fn cell_space(out: &TextLayout, regions: &[Region]) -> Vec<Option<(f64, f64, usize)>> {
- regions
- .iter()
- .enumerate()
- .map(|(ri, r)| {
- let mut top = f64::INFINITY;
- let mut bottom = f64::NEG_INFINITY;
- let mut baselines: Vec<f64> = vec![];
- for l in out.lines.iter().filter(|l| l.region == ri) {
- top = top.min(l.baseline - l.ascent);
- bottom = bottom.max(l.baseline + l.descent);
- if !baselines.iter().any(|b| (b - l.baseline).abs() < 1e-6) {
- baselines.push(l.baseline);
- }
- }
- if baselines.is_empty() || !top.is_finite() || !bottom.is_finite() {
- return None;
- }
- // Never negative: a full (or overflowing) cell stays where top alignment put it.
- Some(((top - r.top()).max(0.0), (r.bottom() - bottom).max(0.0), baselines.len()))
- })
- .collect()
-}
-
-/// Area Type Options "Align" other than Top: move each cell's lines down. Rectangular cells
-/// without text wrap shift their lines (centre: half the space left below the last line;
-/// bottom: all of it; justify: the first line stays, each further line gets an equal share of it).
-/// Other frames give lines different widths at different heights, so the text flows again with
-/// each cell's lines started lower (or spaced wider) until it settles, at most eight passes; a
-/// pass that would push text out of the frame is undone and retried with half the step.
-fn align_vertically(cx: &mut Ctx<'_>, paras: &[Range<usize>], t: &TextObject, regions: &mut [Region]) {
- let align = cx.opts.vertical_align;
- let plain = regions.iter().all(|r| (r.rect || r.polys.is_empty()) && r.wraps.is_empty());
- if plain {
- let space = cell_space(&cx.out, regions);
- // Each distinct baseline's index within its cell, for justify.
- let mut seen: Vec<Vec<f64>> = vec![vec![]; regions.len()];
- let offs: Vec<f64> = cx
- .out
- .lines
- .iter()
- .map(|l| {
- let Some(Some((_, below, n))) = space.get(l.region).copied() else { return 0.0 };
- match align {
- VerticalAlign::Top => 0.0,
- VerticalAlign::Center => below * 0.5,
- VerticalAlign::Bottom => below,
- VerticalAlign::Justify => {
- let Some(s) = seen.get_mut(l.region) else { return 0.0 };
- let k = s.iter().position(|b| (b - l.baseline).abs() < 1e-6).unwrap_or_else(|| {
- s.push(l.baseline);
- s.len() - 1
- });
- if n > 1 { below * k as f64 / (n - 1) as f64 } else { 0.0 }
- }
- }
- })
- .collect();
- for (l, d) in cx.out.lines.iter_mut().zip(&offs) {
- l.baseline += d;
- }
- for g in &mut cx.out.glyphs {
- let d = offs.get(g.line).copied().unwrap_or(0.0);
- if d != 0.0 {
- let m = Affine::translate((0.0, d));
- g.outline.apply_affine(m);
- g.xf = m * g.xf;
- g.origin.y += d;
- }
- }
- // Inline art moves with its glyph's line.
- for i in &mut cx.out.inlines {
- let d = cx.out.glyphs.get(i.glyph).and_then(|g| offs.get(g.line)).copied().unwrap_or(0.0);
- if d != 0.0 {
- let m = Affine::translate((0.0, d));
- i.xf = m * i.xf;
- i.bounds = m.transform_rect_bbox(i.bounds);
- }
- }
- return;
- }
- let laid_out = |out: &TextLayout| out.lines.last().map_or(0, |l| l.end);
- // How much of the measured space a pass takes up: halved after a pass that lost text.
- let mut step = 1.0;
- for _ in 0..8 {
- let space = cell_space(&cx.out, regions);
- let mut moved = false;
- let saved: Vec<(f64, f64)> = regions.iter().map(|r| (r.shift, r.gap)).collect();
- for (r, s) in regions.iter_mut().zip(&space) {
- let Some((above, below, n)) = *s else { continue };
- let (shift, gap) = match align {
- VerticalAlign::Top => (r.shift, r.gap),
- VerticalAlign::Center => (r.shift + (below - above) * 0.5 * step, r.gap),
- VerticalAlign::Bottom => (r.shift + below * step, r.gap),
- VerticalAlign::Justify if n > 1 => (r.shift, r.gap + below * step / (n - 1) as f64),
- VerticalAlign::Justify => (r.shift, r.gap),
- };
- let (shift, gap) = (shift.clamp(0.0, r.cell.height().max(0.0)), gap.clamp(0.0, r.cell.height().max(0.0)));
- if (shift - r.shift).abs() > 0.25 || (gap - r.gap).abs() > 0.01 {
- moved = true;
- }
- r.shift = shift;
- r.gap = gap;
- }
- if !moved {
+ let text = "بَت";
+ let style = CharStyle { font_family: face.family.clone(), font_style: face.style.clone(), size: 20.0, ..CharStyle::default() };
+ let bidi = para_bidi(text, None);
+ let levels = bidi.as_ref().map_or(&[][..], |info| &info.levels);
+ let mut shaped = Vec::new();
+ shape_range(db, text, 0..text.len(), &[(0..text.len(), &style)], &[], &OtFeatures::default(), levels, &mut shaped);
+ let Some(first) = shaped.first() else { return };
+ let first_end = shaped.iter().take_while(|g| g.byte == first.byte).count();
+ if first.byte != 0 || first_end < 2 || first_end >= shaped.len() {
return;
}
- let before = laid_out(&cx.out);
- let prev = (
- std::mem::take(&mut cx.out.glyphs),
- std::mem::take(&mut cx.out.lines),
- std::mem::take(&mut cx.out.inlines),
- std::mem::take(&mut cx.out.markers),
- std::mem::replace(&mut cx.out.overflow, false),
- );
- flow(cx, paras, t, Some(regions));
- if laid_out(&cx.out) < before {
- // Text no longer fits (lines got narrower, or flow around a wrap object): undo the
- // pass and try a smaller step.
- (cx.out.glyphs, cx.out.lines, cx.out.inlines, cx.out.markers, cx.out.overflow) = prev;
- for (r, (shift, gap)) in regions.iter_mut().zip(saved) {
- r.shift = shift;
- r.gap = gap;
- }
- step *= 0.5;
- if step < 0.1 {
- return;
+ // Pick a narrow width that fits glyphs before one positive-advance glyph but not that next
+ // glyph. This ensures the old per-glyph loop would have returned inside the first cluster.
+ let mut prefix = shaped.first().map_or(0.0, |g| g.adv);
+ let width = (1..first_end).find_map(|k| {
+ let advance = shaped.get(k)?.adv;
+ if prefix > EPS && advance > EPS {
+ Some(prefix)
+ } else {
+ prefix += advance;
+ None
}
- }
- }
-}
-
-/// A flattened text wrap shape: (polygons, offset, invert).
-type FlatWrap = (Vec<Vec<Point>>, f64, bool);
-
-/// One cell of a flattened area-type frame (the whole frame, or one row/column of it).
-struct Region {
- /// The cell (frame bounds, or a grid cell of them).
- cell: Rect,
- /// Inset applied inside the frame edges.
- inset: f64,
- polys: std::sync::Arc<[Vec<Point>]>,
- /// The frame is its own bounding rectangle (spans need no polygon intersection).
- rect: bool,
- /// Text Wrap shapes.
- wraps: std::sync::Arc<[FlatWrap]>,
- /// Vertical alignment: how far below the top-aligned position the first line starts.
- shift: f64,
- /// Vertical justification: extra space added between consecutive lines.
- gap: f64,
-}
-
-/// The largest magnitude a coordinate of a frame, a text wrap shape or the path of type on a path
-/// may have (points), control points included. A frame or path with a larger coordinate, or a
-/// coordinate that isn't finite, holds no text, and a text wrap shape with one is ignored.
-const MAX_COORD: f64 = 1e9;
-
-/// Are the coordinates of `path`, control points included, finite and within [`MAX_COORD`]?
-fn in_range(path: &BezPath) -> bool {
- let near = |p: &Point| p.x.abs() <= MAX_COORD && p.y.abs() <= MAX_COORD;
- path.elements().iter().all(|el| match el {
- PathEl::MoveTo(p) | PathEl::LineTo(p) => near(p),
- PathEl::QuadTo(a, p) => near(a) && near(p),
- PathEl::CurveTo(a, b, p) => near(a) && near(b) && near(p),
- PathEl::ClosePath => true,
- })
-}
+ });
+ let Some(width) = width else { return };
-/// Flattened closed polygons of a path; `None` when it isn't [`in_range`].
-fn polygons(path: &BezPath) -> Option<Vec<Vec<Point>>> {
- if !in_range(path) {
- return None;
- }
- let mut polys: Vec<Vec<Point>> = Vec::new();
- kurbo::flatten(path, 0.1, |el| match el {
- PathEl::MoveTo(p) => polys.push(vec![p]),
- PathEl::LineTo(p) => {
- if let Some(v) = polys.last_mut() {
- v.push(p);
- }
- }
- _ => {}
- });
- polys.retain(|p| p.len() >= 3);
- Some(polys)
-}
+ let mut object = TextObject::point(Point::ZERO, text, style);
+ object.kind = TextKind::Area { frame: PathData::from_bezpath(&Rect::new(0.0, 0.0, width, 100.0).to_path(0.1)) };
+ let result = layout_with(db, &object, &LayoutOptions::default());
-/// Inside intervals (even-odd) of the horizontal line at `y` through `polys`.
-fn poly_intervals(polys: &[Vec<Point>], y: f64) -> Vec<(f64, f64)> {
- let mut xs = Vec::new();
- for poly in polys {
- for i in 0..poly.len() {
- let a = poly[i];
- let b = poly[(i + 1) % poly.len()];
- if (a.y <= y) != (b.y <= y) {
- xs.push(a.x + (y - a.y) / (b.y - a.y) * (b.x - a.x));
- }
- }
+ let next_cluster_byte = shaped.get(first_end).map(|g| g.byte);
+ assert_eq!(result.lines.first().map(|line| line.end), next_cluster_byte);
}
- xs.sort_by(f64::total_cmp);
- xs.as_chunks::<2>().0.iter().map(|c| (c[0], c[1])).collect()
-}
-/// Union of sorted-or-not intervals.
-fn union_intervals(mut v: Vec<(f64, f64)>) -> Vec<(f64, f64)> {
- v.sort_by(|a, b| a.0.total_cmp(&b.0));
- let mut out: Vec<(f64, f64)> = Vec::with_capacity(v.len());
- for (a, b) in v {
- match out.last_mut() {
- Some(l) if a <= l.1 => l.1 = l.1.max(b),
- _ => out.push((a, b)),
- }
- }
- out
-}
+ /// No Break keeps the marked characters on one line, including across a space, and moves a
+ /// marked run that does not fit to the next line whole.
+ #[test]
+ fn no_break_keeps_marked_characters_on_one_line() {
+ let text = "A B";
+ let plain = synthetic_glyphs(&[(0, 1, 10.0, 'A'), (1, 1, 4.0, ' '), (2, 1, 10.0, 'B')]);
+ let (end, hyphen) = break_line(text, &plain, 0, 16.0, &[], 0.0, None, Burasagari::None, Kinsoku::None);
+ assert!(!hyphen);
+ assert_eq!(end, 2, "without the mark the line ends after the space");
-/// `a` minus `b` (both unions of disjoint intervals).
-fn subtract_intervals(a: &[(f64, f64)], b: &[(f64, f64)]) -> Vec<(f64, f64)> {
- let mut out = vec![];
- for &(mut s, e) in a {
- for &(c, d) in b {
- if d <= s || c >= e {
- continue;
- }
- if c > s {
- out.push((s, c));
- }
- s = s.max(d);
- }
- if e > s {
- out.push((s, e));
+ let mut marked = plain;
+ for g in &mut marked {
+ g.no_break = true;
}
- }
- out
-}
-
-/// `a` ∩ `b`.
-fn intersect_intervals(a: &[(f64, f64)], b: &[(f64, f64)]) -> Vec<(f64, f64)> {
- let mut out = vec![];
- for &(s, e) in a {
- for &(c, d) in b {
- let (x, y) = (s.max(c), e.min(d));
- if y > x {
- out.push((x, y));
- }
- }
- }
- out
-}
-
-impl Region {
- fn cells(path: &BezPath, opts: &LayoutOptions, wrap: &[vectorcraft_doc::WrapShape]) -> Vec<Region> {
- // A frame out of range has no cells, and a wrap shape out of range is left out.
- let Some(polys) = polygons(path) else { return vec![] };
- // Every cell shares one copy of the frame's polygons and one copy of the text wrap shapes.
- let polys: std::sync::Arc<[Vec<Point>]> = polys.into();
- let wraps: std::sync::Arc<[FlatWrap]> = wrap
- .iter()
- .filter_map(|w| Some((polygons(&w.path.to_bezpath())?, w.wrap.offset.max(0.0), w.wrap.invert)))
- .filter(|w| !w.0.is_empty())
- .collect();
- let bbox = path.bounding_box();
- let rect = polys.len() == 1 && {
- let area: f64 = polys[0].iter().zip(polys[0].iter().cycle().skip(1)).map(|(a, b)| a.x * b.y - b.x * a.y).sum::<f64>().abs() * 0.5;
- (area - bbox.area()).abs() <= bbox.area() * 1e-6 + 1e-9
- };
- let max = vectorcraft_doc::AreaOptions::MAX_ROWS_COLUMNS;
- let (rows, cols) = (opts.rows.clamp(1, max), opts.columns.clamp(1, max));
- let gutter = opts.gutter.max(0.0);
- let cw = ((bbox.width() - gutter * (cols - 1) as f64) / cols as f64).max(0.0);
- let rh = ((bbox.height() - gutter * (rows - 1) as f64) / rows as f64).max(0.0);
- let mut out = Vec::with_capacity(rows * cols);
- // Text flows down each column, then across (Illustrator's default "by columns").
- for c in 0..cols {
- for r in 0..rows {
- let x0 = bbox.x0 + c as f64 * (cw + gutter);
- let y0 = bbox.y0 + r as f64 * (rh + gutter);
- let cell = if rows * cols == 1 { bbox } else { Rect::new(x0, y0, x0 + cw, y0 + rh) };
- out.push(Region { cell, inset: opts.inset.max(0.0), polys: polys.clone(), rect, wraps: wraps.clone(), shift: 0.0, gap: 0.0 });
- }
- }
- out
- }
-
- fn top(&self) -> f64 {
- self.cell.y0 + self.inset
- }
- fn bottom(&self) -> f64 {
- self.cell.y1 - self.inset
- }
-
- /// Inside intervals (even-odd) of the horizontal line at `y`, minus the wrap objects (or
- /// inside them, for Invert Wrap). Offsets grow each wrap shape vertically and horizontally.
- fn intervals(&self, y: f64) -> Vec<(f64, f64)> {
- let mut iv = if self.polys.is_empty() || self.rect { vec![(self.cell.x0, self.cell.x1)] } else { poly_intervals(&self.polys, y) };
- for (polys, off, invert) in self.wraps.iter() {
- let ys = if *off > 0.0 { vec![y - off, y - off * 0.5, y, y + off * 0.5, y + off] } else { vec![y] };
- let w = union_intervals(ys.into_iter().flat_map(|y| poly_intervals(polys, y)).map(|(a, b)| (a - off, b + off)).collect());
- iv = if *invert { intersect_intervals(&iv, &w) } else { subtract_intervals(&iv, &w) };
- }
- iv
- }
-
- /// Widest horizontal span inside the frame (and the cell) over the band `top..bottom`.
- fn span(&self, top: f64, bottom: f64) -> Option<(f64, f64)> {
- self.spans(top, bottom).into_iter().max_by(|x, y| (x.1 - x.0).total_cmp(&(y.1 - y.0)))
- }
-
- /// Every horizontal span inside the frame (and the cell) over the band `top..bottom`, left to
- /// right (text wraps on both sides of an object).
- fn spans(&self, top: f64, bottom: f64) -> Vec<(f64, f64)> {
- let clip = |(a, b): (f64, f64)| {
- let (a, b) = (a.max(self.cell.x0) + self.inset, b.min(self.cell.x1) - self.inset);
- (b > a).then_some((a, b))
- };
- let plain = self.polys.is_empty() || self.rect;
- if plain && self.wraps.is_empty() {
- return (self.cell.width() > 0.0).then_some((self.cell.x0, self.cell.x1)).and_then(clip).into_iter().collect();
- }
- let fb = if plain {
- self.cell
- } else {
- self.polys.iter().flatten().fold(Rect::new(f64::MAX, f64::MAX, f64::MIN, f64::MIN), |r, p| r.union_pt(*p))
- };
- let clamp = |y: f64| if plain { y } else { y.clamp(fb.y0 + 1e-4, fb.y1 - 1e-4) };
- // Sample the band densely enough for curved frames (circles, blobs).
- let samples = 5;
- let mut rows: Vec<Vec<(f64, f64)>> =
- (0..samples).map(|k| self.intervals(clamp(top + (bottom - top) * k as f64 / (samples - 1) as f64))).collect();
- let mid = rows.swap_remove(samples / 2);
- if !self.wraps.is_empty() {
- // Wrap objects split lines: keep exactly what is free on every sampled row.
- let free = rows.iter().fold(mid, |acc, r| intersect_intervals(&acc, r));
- return free.into_iter().filter_map(clip).collect();
- }
- mid.into_iter()
- .filter_map(|(mut a, mut b)| {
- for o in &rows {
- let best =
- o.iter().map(|&(c, d)| (a.max(c), b.min(d))).filter(|(c, d)| d > c).max_by(|x, y| (x.1 - x.0).total_cmp(&(y.1 - y.0)))?;
- a = best.0;
- b = best.1;
- }
- clip((a, b))
- })
- .collect()
- }
-}
-
-/// The 10,000 cells of a frame in 100 rows and 100 columns share one copy of the frame's polygons
-/// and one copy of the text wrap shapes.
-#[cfg(test)]
-#[test]
-fn the_cells_of_a_frame_share_its_polygons_and_the_wrap_shapes() {
- let frame = kurbo::Circle::new((0.0, 0.0), 1000.0).to_path(0.1);
- let square = PathData::from_bezpath(&Rect::new(-10.0, -10.0, 10.0, 10.0).to_path(0.1));
- let wrap = vectorcraft_doc::WrapShape { path: square, wrap: Default::default() };
- let cells = Region::cells(&frame, &LayoutOptions { rows: 100, columns: 100, ..LayoutOptions::default() }, &[wrap]);
- assert_eq!(cells.len(), 10_000);
- let first = &cells[0];
- assert!(!first.polys.is_empty() && !first.wraps.is_empty());
- assert!(cells.iter().all(|c| c.polys.as_ptr() == first.polys.as_ptr() && c.wraps.as_ptr() == first.wraps.as_ptr()));
-}
-
-/// Vertical metrics of a line: (ascent, descent, leading, cap height, x height).
-#[derive(Clone, Copy, Debug, PartialEq)]
-struct Metrics {
- asc: f64,
- desc: f64,
- lead: f64,
- cap: f64,
- xh: f64,
- /// Height of the top of the ideographic em box above the baseline.
- top: f64,
-}
-
-impl Metrics {
- fn of(g: &SGlyph) -> Self {
- let em = g.face.units_per_em() * g.sy;
- Self { asc: g.ascent, desc: g.descent, lead: g.leading, cap: g.cap, xh: g.xh, top: (g.face.ideographic_centre() + 0.5) * em }
- }
- fn max(g: &[SGlyph]) -> Option<Self> {
- let mut it = g.iter();
- let first = Self::of(it.next()?);
- Some(it.fold(first, |m, g| Self {
- asc: m.asc.max(g.ascent),
- desc: m.desc.max(g.descent),
- lead: m.lead.max(g.leading),
- cap: m.cap.max(g.cap),
- xh: m.xh.max(g.xh),
- top: m.top.max(Self::of(g).top),
- }))
- }
- /// Distance from the frame top to the first baseline.
- fn first_baseline(&self, fb: FirstBaseline, min: f64) -> f64 {
- let v = match fb {
- FirstBaseline::Ascent => self.asc,
- FirstBaseline::CapHeight => self.cap,
- FirstBaseline::XHeight => self.xh,
- FirstBaseline::Leading => self.lead,
- FirstBaseline::Fixed => 0.0,
- };
- v.max(min)
- }
-}
-
-/// Where the next line goes: the region being filled and the previous baseline in it.
-#[derive(Clone)]
-struct Pen<'r> {
- regions: Option<&'r [Region]>,
- ri: usize,
- prev: Option<f64>,
- pending: f64,
- fb: FirstBaseline,
- fb_min: f64,
- /// Further spans at the current baseline (text wrapping on both sides of an object).
- queued: Vec<(f64, f64, f64)>,
- /// Leading measured from em box top to em box top: where the next line's em box top goes.
- model: LeadingModel,
- next_top: Option<f64>,
- /// The narrowest word no line from here down is wide enough for (see [`Pen::place`]).
- no_room_for: f64,
-}
-
-/// The largest number of steps layout takes to move a line down a frame cell to find room for it:
-/// in a cell taller than this many leads, a step is the cell's height divided by this.
-const MAX_STEPS: usize = 100_000;
-
-impl Pen<'_> {
- /// Baseline and horizontal span for a line with estimated metrics `est` and indents that starts
- /// with a word `word` wide; `None` = the frame is full (overflow).
- /// In a frame that isn't a rectangle, lines too short for the word are left empty and it moves
- /// down to the first one wide enough. Only when no line is does it go on the first line with
- /// room for any text, and get broken there.
- /// The `bool` is true for a further span at the previous line's baseline.
- fn place(&mut self, est: Metrics, ind_l: f64, ind_r: f64, word: f64) -> Option<(f64, f64, f64, bool)> {
- if word > 0.0 && word < self.no_room_for {
- let mut pen = self.clone();
- if let Some(placed) = pen.place_at_least(est, ind_l, ind_r, word) {
- *self = pen;
- return Some(placed);
- }
- // Lines further down are no wider for this word: don't search for it, or a wider one, again.
- self.no_room_for = word;
- }
- self.place_at_least(est, ind_l, ind_r, 0.0)
- }
-
- /// [`Pen::place`], skipping lines of a non-rectangular frame narrower than `min`.
- fn place_at_least(&mut self, est: Metrics, ind_l: f64, ind_r: f64, min: f64) -> Option<(f64, f64, f64, bool)> {
- let Some(regions) = self.regions else {
- let b = self.prev.map_or(0.0, |b| self.next_baseline(b, est));
- return Some((b, f64::NEG_INFINITY, f64::INFINITY, false));
- };
- if !self.queued.is_empty() {
- let (b, x0, x1) = self.queued.remove(0);
- return Some((b, x0, x1, true));
- }
- loop {
- let r = regions.get(self.ri)?;
- let mut baseline = match self.prev {
- None if self.model == LeadingModel::EmBoxTop => r.top() + r.shift + est.top.max(self.fb_min),
- None => r.top() + r.shift + est.first_baseline(self.fb, self.fb_min),
- Some(b) => self.next_baseline(b, est) + r.gap,
- };
- // The baseline moves down the cell a lead at a time, or a `MAX_STEPS`th of the cell's
- // height when that is more, in at most `MAX_STEPS` steps.
- let step = est.lead.max(1.0).max(r.cell.height() / MAX_STEPS as f64);
- for _ in 0..=MAX_STEPS {
- if baseline + est.desc > r.bottom() + 0.01 {
- break;
- }
- // A rectangle's lines are all as wide: none below has more room for the word
- // (until wrap shapes can narrow the first baseline: they stay bounded).
- let constant = (r.rect || r.polys.is_empty()) && r.wraps.is_empty();
- let min = if constant { 0.0 } else { min };
- let fits = |&(a, b): &(f64, f64)| {
- let room = b - a - ind_l - ind_r;
- room > est.asc.max(1.0) && room + EPS >= min
- };
- if r.wraps.is_empty() {
- match r.span(baseline - est.asc, baseline + est.desc) {
- Some(s) if fits(&s) => return Some((baseline, s.0, s.1, false)),
- // Too narrow here is too narrow all the way down the cell: next cell.
- Some(_) if constant => break,
- _ => baseline += step,
- }
- } else {
- // Wrap objects can split a line: fill every span, left to right.
- let mut spans: Vec<(f64, f64)> = r.spans(baseline - est.asc, baseline + est.desc).into_iter().filter(fits).collect();
- if spans.is_empty() {
- baseline += step;
- continue;
- }
- let (a, b) = spans.remove(0);
- self.queued = spans.into_iter().map(|(a, b)| (baseline, a, b)).collect();
- return Some((baseline, a, b, false));
- }
- }
- // Next row/column.
- self.ri += 1;
- self.prev = None;
- self.pending = 0.0;
- self.queued.clear();
- }
- }
- fn bottom(&self) -> f64 {
- self.regions.and_then(|r| r.get(self.ri)).map_or(f64::INFINITY, |r| r.bottom())
- }
- /// The baseline of the line after the one at `prev`, for a line of metrics `est`.
- fn next_baseline(&self, prev: f64, est: Metrics) -> f64 {
- match (self.model, self.next_top) {
- (LeadingModel::EmBoxTop, Some(top)) => top + est.top + self.pending,
- _ => prev + est.lead + self.pending,
- }
- }
- /// A line was set at `baseline` with metrics `m`: where the next one goes from.
- fn settled(&mut self, baseline: f64, m: Metrics) {
- self.prev = Some(baseline);
- self.next_top = Some(baseline - m.top + m.lead);
- }
-}
-
-/// Advance of a tab at pen position `x`: up to the next stop after it (explicit stops first, then
-/// every ½ inch), and the leader of that stop (default stops have none). Right, centre and decimal
-/// stops align the text that follows (`rest`, up to the next tab) on the stop.
-fn tab_advance<'t>(tabs: &'t [vectorcraft_doc::TabStop], origin: f64, x: f64, rest: &[SGlyph]) -> (f64, &'t str) {
- use vectorcraft_doc::TabAlign;
- let rel = x - origin;
- let seg: Vec<&SGlyph> = rest.iter().take_while(|g| g.ch != '\t').collect();
- let width: f64 = seg.iter().map(|g| g.adv).sum();
- let target = |pos: f64, align: TabAlign, on: char| match align {
- TabAlign::Left => pos,
- TabAlign::Right => pos - width,
- TabAlign::Center => pos - width / 2.0,
- TabAlign::Decimal => pos - seg.iter().take_while(|g| g.ch != on).map(|g| g.adv).sum::<f64>(),
- };
- let explicit = tabs.iter().find_map(|t| {
- let at = target(t.position, t.align, t.align_on);
- (at > rel + 1e-6).then_some((at, t.leader.as_str()))
- });
- let (at, leader) = explicit.unwrap_or_else(|| {
- let last = tabs.iter().map(|t| t.position).fold(0.0, f64::max).max(0.0);
- let base = rel.max(last);
- (((base / vectorcraft_doc::text::DEFAULT_TAB_INTERVAL).floor() + 1.0) * vectorcraft_doc::text::DEFAULT_TAB_INTERVAL, "")
- });
- ((at - rel).max(0.0), leader)
-}
-
-/// The width of glyphs `from..to` of `sg` set on a line whose content starts `x_start` from the
-/// tab origin: tabs of the text take what [`tab_advance`] gives them, not the width of their
-/// glyph. The tab after a list marker (length 0) keeps its own width.
-fn set_width(sg: &[SGlyph], from: usize, to: usize, tabs: &[vectorcraft_doc::TabStop], x_start: f64) -> f64 {
- let mut x = x_start;
- for (j, g) in sg.iter().enumerate().take(to).skip(from) {
- x += if g.ch == '\t' && g.len > 0 { tab_advance(tabs, 0.0, x, sg.get(j + 1..to).unwrap_or_default()).0 } else { g.adv };
- }
- x - x_start
-}
-
-/// Most copies of a leader drawn in one tab: a tiny type size and a far stop must not make
-/// millions of outlines.
-const MAX_LEADER_COPIES: f64 = 4096.0;
-
-/// The outline of a tab leader: `leader`'s characters, in the font and size of tab `g`, repeated
-/// across the tab's gap `from..to` on baseline `y`. Copies sit on a grid of the leader's width
-/// from `origin` (where tab stops are measured from), so the leaders of lines above one another
-/// line up; only whole copies are drawn. Characters the font lacks draw nothing.
-fn leader_outline(db: &FontDb, g: &SGlyph, leader: &str, origin: f64, from: f64, to: f64, y: f64) -> BezPath {
- let mut out = BezPath::new();
- let glyphs: Vec<(u32, f64)> = leader
- .chars()
- .filter(|c| !c.is_control())
- .map(|c| {
- let gid = g.face.glyph_for(c);
- (gid, g.face.advance(gid) * g.sx)
- })
- .collect();
- let width: f64 = glyphs.iter().map(|(_, a)| a).sum();
- if !(width > EPS && width.is_finite() && from.is_finite() && to.is_finite()) {
- return out;
- }
- let first = ((from - origin) / width - EPS).ceil();
- let copies = (((to - origin) / width + EPS).floor() - first).clamp(0.0, MAX_LEADER_COPIES) as usize;
- let local = Affine::rotate(-g.rotation.to_radians()) * Affine::translate((0.0, -g.bshift)) * Affine::scale_non_uniform(g.sx, g.sy);
- for k in 0..copies {
- let mut pen = origin + (first + k as f64) * width;
- for &(gid, adv) in &glyphs {
- if gid != 0 {
- let m = Affine::translate((pen, y)) * local;
- out.extend(db.outline(&g.face, gid).elements().iter().map(|el| m * *el));
- }
- pen += adv;
- }
- }
- out
-}
-
-/// Width of the word starting at glyph `i`: its advances up to the first break opportunity (spaces
-/// left out, the hyphen of a soft hyphen in), the least room a line needs not to break inside it.
-/// A list marker at `i` (glyphs of length 0) counts whole, with the word after it.
-fn word_width(g: &[SGlyph], i: usize) -> f64 {
- /// Glyphs measured at most: a word wrapped over many lines is measured again from each line's
- /// start, and one this long is broken inside whatever cell it meets.
- const MAX_GLYPHS: usize = 1024;
- let rest = g.get(i..).unwrap_or_default();
- let marker = rest.iter().take_while(|gl| gl.len == 0).count();
- let mut w: f64 = rest.iter().take(marker).map(|gl| gl.adv).sum();
- for gl in rest.iter().skip(marker).take(MAX_GLYPHS) {
- if gl.is_space() {
- break;
- }
- if gl.is_soft_hyphen() {
- return w + hyphen_glyph(gl).adv;
- }
- w += gl.adv;
- if gl.break_after() {
- break;
- }
- }
- w
-}
-
-/// Greedy break: returns (end glyph index, hyphenated) for a line starting at `i` of `width`.
-/// With burasagari, a comma or full stop that doesn't fit ends the line, hanging outside it.
-/// `hyphenate` holds the paragraph's Hyphenation options and the Hyphenation Zone in force when
-/// the line may hyphenate a word; a line whose text before the overflowing word already ends
-/// within the zone breaks before that word. A tab is as wide as it is set: up to its next stop
-/// (`tabs`), with the line's content starting `x_start` from the tab origin.
-#[allow(clippy::too_many_arguments)]
-fn break_line(
- text: &str,
- g: &[SGlyph],
- i: usize,
- width: f64,
- tabs: &[vectorcraft_doc::TabStop],
- x_start: f64,
- hyphenate: Option<(&HyphenationOptions, f64)>,
- burasagari: Burasagari,
- kinsoku: Kinsoku,
-) -> (usize, bool) {
- if !width.is_finite() {
- return (g.len(), false);
- }
- let mut x = 0.0;
- let mut last_break: Option<(usize, bool)> = None;
- // A list marker (length 0) is a cluster of its own; the line holds it and at least the first
- // cluster after it.
- let first = i + g.get(i..).unwrap_or_default().iter().take_while(|h| h.len == 0).count();
- let mut j = i;
- while j < g.len() {
- let gl = &g[j];
- let mut cluster_end = j + 1;
- while g.get(cluster_end).is_some_and(|next| next.byte == gl.byte && (next.len == 0) == (gl.len == 0)) {
- cluster_end += 1;
- }
- // No Break: the marked characters stay on one line, including across a space inside the run.
- if gl.no_break {
- while let Some(n) = g.get(cluster_end) {
- if !n.no_break {
- break;
- }
- let b = n.byte;
- cluster_end += 1;
- while g.get(cluster_end).is_some_and(|next| next.byte == b) {
- cluster_end += 1;
- }
- }
- }
- let cluster_width: f64 = if gl.ch == '\t' {
- tab_advance(tabs, 0.0, x_start + x, g.get(cluster_end..).unwrap_or_default()).0
- } else {
- g[j..cluster_end].iter().map(|glyph| glyph.adv).sum()
- };
- if j > first && !gl.is_space() && x + cluster_width > width + EPS {
- // It ends the line with the spaces after it.
- if burasagari != Burasagari::None && hangs(gl) && kinsoku_allows(g, cluster_end - 1, kinsoku) {
- let mut end = cluster_end;
- while g.get(end).is_some_and(SGlyph::is_space) {
- end += 1;
- }
- return (end, false);
- }
- break;
- }
- x += cluster_width;
- let last = &g[cluster_end - 1];
- if last.break_after() && last.len > 0 && kinsoku_allows(g, cluster_end - 1, kinsoku) && !splits_no_break(g, cluster_end) {
- if last.is_soft_hyphen() {
- if x + hyphen_glyph(last).adv <= width + EPS {
- last_break = Some((cluster_end, true));
- }
- } else {
- last_break = Some((cluster_end, false));
- }
- }
- j = cluster_end;
- }
- if j >= g.len() {
- return (g.len(), false);
- }
- // Hyphenate the word that overflows.
- let word_start = last_break.map_or(i, |b| b.0);
- let in_zone = |zone: f64| {
- let mut te = word_start;
- while te > i && g[te - 1].is_space() {
- te -= 1;
- }
- te > i && zone > 0.0 && width - g[i..te].iter().map(|g| g.adv).sum::<f64>() <= zone + EPS
- };
- if let Some((opts, zone)) = hyphenate
- && g[j].is_letter()
- && !in_zone(zone)
- {
- let mut we = j;
- while we < g.len() && !g[we].is_space() && !g[we].break_after() {
- we += 1;
- }
- let x_ws: f64 = g[i..word_start].iter().map(|g| g.adv).sum();
- let pts: Vec<usize> = hyphen_breaks(text, g, word_start, we, opts)
- .into_iter()
- .filter(|&k| k > 0 && kinsoku_allows(g, k - 1, kinsoku) && !splits_no_break(g, k))
- .collect();
- for &k in pts.iter().rev() {
- if k <= j && k > i {
- let w = x_ws + g[word_start..k].iter().map(|g| g.adv).sum::<f64>() + hyphen_glyph(&g[k - 1]).adv;
- if w <= width + EPS {
- return (k, true);
- }
- }
- }
- }
- // Break candidates and greedy overflow are cluster boundaries; hyphenation also returns only
- // cluster starts, so the resulting end always keeps each source cluster together.
- let (end, hy) = match last_break {
- Some(b) if b.0 > i => b,
- _ => (j, false),
- };
- (end, hy)
-}
-
-/// Can glyph `g` hang outside the line (burasagari)? An East Asian comma or full stop, full width
-/// (、。,.) or half width (、。); not a closing bracket, nor Latin punctuation (Latin text keeps
-/// its line breaks and composer). Never an inline graphic (U+FFFC).
-fn hangs(g: &SGlyph) -> bool {
- g.inline.is_none() && matches!(g.ch, '、' | '。' | ',' | '.' | '、' | '。') && g.tcy.is_none()
-}
-
-/// Optical Margin Alignment: the share of glyph `g`'s advance that hangs outside the margin when
-/// `g` starts or ends a line. Quotation marks, hyphens, full stops and commas hang whole, and
-/// asterisks, tildes, ellipses, en and em dashes, colons and semicolons hang by half (the amounts
-/// published for Roman Hanging Punctuation). A, V, W, Y, v, w and y hang by a tenth of their
-/// advance, VectorCraft's own amount for their slanted sides. Other characters, East Asian
-/// punctuation (which burasagari hangs) and inline graphics don't hang.
-fn optical_share(g: &SGlyph) -> f64 {
- if g.inline.is_some() || g.tcy.is_some() {
- return 0.0;
- }
- match g.ch {
- '-' | '\u{2010}' | '\u{2011}' | '.' | ',' => 1.0,
- c if is_quote(c) => 1.0,
- '*' | '~' | '…' | '–' | '—' | ':' | ';' => 0.5,
- 'A' | 'V' | 'W' | 'Y' | 'v' | 'w' | 'y' => 0.1,
- _ => 0.0,
- }
-}
-
-/// Roman Hanging Punctuation: the share of glyph `g`'s advance that hangs outside the margin when
-/// `g` starts or ends a line: [`optical_share`]'s punctuation, and no letters.
-fn roman_share(g: &SGlyph) -> f64 {
- if g.ch.is_alphabetic() { 0.0 } else { optical_share(g) }
-}
-
-/// A punctuation mark that hangs ([`optical_share`]), not a letter.
-fn optical_punct(g: &SGlyph) -> bool {
- !g.ch.is_alphabetic() && optical_share(g) > 0.0
-}
-
-/// A single or double quotation mark: straight, curly, low-9 or reversed-9.
-fn is_quote(c: char) -> bool {
- matches!(c, '\'' | '"' | '‘' | '’' | '‚' | '‛' | '“' | '”' | '„' | '‟')
-}
-
-/// Optical Margin Alignment and Roman Hanging Punctuation: how far a line hangs outside its left
-/// and right margins, from the glyph at each end of `line` (its glyphs in visual order, each with
-/// the advance it is set with) and its `share` ([`optical_share`] or [`roman_share`]), and how many glyphs hang at each end → (left, right, left glyphs,
-/// right glyphs). A punctuation mark followed by a quotation mark hangs together with it: `."`
-/// ending a line and `'"` starting one hang both their glyphs. A line of one glyph hangs at
-/// neither end.
-fn optical_hangs(line: &[(&SGlyph, f64)], share: fn(&SGlyph) -> f64) -> (f64, f64, usize, usize) {
- let n = line.len();
- if n < 2 {
- return (0.0, 0.0, 0, 0);
- }
- let hang = |k: usize| line.get(k).map_or(0.0, |&(g, adv)| share(g) * adv.max(0.0));
- let punct = |k: usize| line.get(k).is_some_and(|&(g, _)| optical_punct(g));
- let quote = |k: usize| line.get(k).is_some_and(|&(g, _)| is_quote(g.ch) && share(g) > 0.0);
- let mut left = hang(0);
- // The glyphs that hang at the left; the right end takes none of them.
- let mut taken = usize::from(left > 0.0);
- if left > 0.0 && n > 2 && punct(0) && quote(1) {
- left += hang(1);
- taken = 2;
- }
- let mut right = hang(n - 1);
- let mut right_glyphs = usize::from(right > 0.0);
- if right > 0.0 && n > 2 && n - 2 >= taken && punct(n - 2) && quote(n - 1) {
- right += hang(n - 2);
- right_glyphs = 2;
- }
- (left, right, taken, right_glyphs)
-}
-
-/// Works as [`optical_hangs`] does for a right-to-left line, whose `line` is also in visual order.
-/// The line is read from right to left: `."` ending it hangs both its glyphs at the left, `'"` starting it hangs both at
-/// the right, and the right end takes its glyphs first.
-fn optical_hangs_rtl(line: &[(&SGlyph, f64)], share: fn(&SGlyph) -> f64) -> (f64, f64, usize, usize) {
- let reversed: Vec<(&SGlyph, f64)> = line.iter().rev().copied().collect();
- let (right, left, right_glyphs, left_glyphs) = optical_hangs(&reversed, share);
- (left, right, left_glyphs, right_glyphs)
-}
-
-/// Would a line ending at glyph index `end` split a No Break run?
-fn splits_no_break(g: &[SGlyph], end: usize) -> bool {
- end > 0 && g.get(end - 1).is_some_and(|a| a.no_break) && g.get(end).is_some_and(|b| b.no_break)
-}
-
-/// Does kinsoku allow a line break after glyph `j`? Not after an opening bracket, nor before a
-/// closing one, a comma, a full stop, a small kana… (the character is pushed to the next line
-/// with the one before it).
-fn kinsoku_allows(g: &[SGlyph], j: usize, kinsoku: Kinsoku) -> bool {
- g.get(j).is_some_and(|gl| kinsoku_between(gl.ch, g.get(j + 1).map(|n| n.ch), kinsoku))
-}
-
-/// Kinsoku for a break between `before` and `after` (none: the end of the paragraph): Hard keeps
-/// every character of the set off the line start and end, Soft lets 々, ー and small kana start a
-/// line, None allows the break.
-fn kinsoku_between(before: char, after: Option<char>, kinsoku: Kinsoku) -> bool {
- match kinsoku {
- Kinsoku::None => true,
- Kinsoku::Hard => !no_line_end(before) && after.is_none_or(|c| !no_line_start(c)),
- Kinsoku::Soft => !no_line_end(before) && after.is_none_or(|c| !no_line_start(c) || soft_line_start(c)),
- }
-}
-
-#[cfg(test)]
-mod wrapping_tests {
- use super::*;
- use std::sync::Arc;
-
- fn synthetic_glyphs(specs: &[(usize, usize, f64, char)]) -> Vec<SGlyph> {
- // The face is only a required SGlyph field here; advances and cluster boundaries below are
- // entirely synthetic, so the regressions don't depend on a particular font's shaping.
- static DB: std::sync::OnceLock<FontDb> = std::sync::OnceLock::new();
- let db = DB.get_or_init(|| FontDb::with_font_dirs(vec![]));
- let face = db.face("Source Sans 3", "Regular").expect("bundled test face");
- specs
- .iter()
- .map(|&(byte, len, adv, ch)| SGlyph {
- face: Arc::clone(&face),
- gid: 0,
- byte,
- len,
- run: 0,
- adv,
- dx: 0.0,
- dy: 0.0,
- sx: 1.0,
- sy: 1.0,
- bshift: 0.0,
- rotation: 0.0,
- ascent: 8.0,
- descent: 2.0,
- leading: 0.0,
- cap: 6.0,
- xh: 4.0,
- ch,
- tcy: None,
- inline: None,
- word_end: false,
- lead: 0.0,
- proportional: false,
- vpal: None,
- level: unicode_bidi::Level::ltr(),
- no_break: false,
- cursive: false,
- })
- .collect()
- }
-
- fn source_range(glyphs: &[SGlyph], start: usize, end: usize) -> Range<usize> {
- let first = glyphs.get(start).expect("nonempty source range");
- let last = glyphs.get(end - 1).expect("nonempty source range");
- first.byte..last.byte + last.len
- }
-
- #[test]
- fn greedy_wrap_keeps_an_oversized_first_cluster_and_its_source_range() {
- let text = "بَت";
- let glyphs = synthetic_glyphs(&[(0, 4, 2.0, 'ب'), (0, 4, 2.0, 'ب'), (4, 2, 1.0, 'ت')]);
-
- let (end, hyphenated) = break_line(text, &glyphs, 0, 3.0, &[], 0.0, None, Burasagari::None, Kinsoku::Hard);
-
- assert!(!hyphenated);
- assert_eq!(end, 2, "oversized base-plus-mark cluster must stay together");
- assert_eq!(source_range(&glyphs, 0, end), 0..4);
- assert_eq!(glyphs.get(end).map(|g| g.byte), Some(4));
- }
-
- #[test]
- fn greedy_wrap_keeps_an_oversized_cluster_after_a_line_start_atomic() {
- let text = "بَتَث";
- let glyphs = synthetic_glyphs(&[(0, 4, 1.0, 'ب'), (4, 4, 2.0, 'ت'), (4, 4, 2.0, 'ت'), (8, 2, 1.0, 'ث')]);
-
- let (first_end, _) = break_line(text, &glyphs, 0, 3.0, &[], 0.0, None, Burasagari::None, Kinsoku::Hard);
- assert_eq!(first_end, 1);
- assert_eq!(source_range(&glyphs, 0, first_end), 0..4);
-
- let (second_end, hyphenated) = break_line(text, &glyphs, first_end, 3.0, &[], 0.0, None, Burasagari::None, Kinsoku::Hard);
-
- assert!(!hyphenated);
- assert_eq!(second_end, 3, "oversized cluster at the next line start must stay together");
- assert_eq!(source_range(&glyphs, first_end, second_end), 4..8);
- assert_eq!(glyphs.get(second_end).map(|g| g.byte), Some(8));
- }
-
- #[test]
- fn narrow_arabic_area_wrap_keeps_base_and_mark_together_when_supported() {
- let db = FontDb::global();
- let Some(face) = db.face_covering('ب').filter(|face| face.covers('َ')) else {
- // Arabic integration coverage depends on an installed font; synthetic tests above are
- // the font-independent regression oracle.
- return;
- };
- let text = "بَت";
- let style = CharStyle { font_family: face.family.clone(), font_style: face.style.clone(), size: 20.0, ..CharStyle::default() };
- let bidi = para_bidi(text, None);
- let levels = bidi.as_ref().map_or(&[][..], |info| &info.levels);
- let mut shaped = Vec::new();
- shape_range(db, text, 0..text.len(), &[(0..text.len(), &style)], &[], &OtFeatures::default(), levels, &mut shaped);
- let Some(first) = shaped.first() else { return };
- let first_end = shaped.iter().take_while(|g| g.byte == first.byte).count();
- if first.byte != 0 || first_end < 2 || first_end >= shaped.len() {
- return;
- }
- // Pick a narrow width that fits glyphs before one positive-advance glyph but not that next
- // glyph. This ensures the old per-glyph loop would have returned inside the first cluster.
- let mut prefix = shaped.first().map_or(0.0, |g| g.adv);
- let width = (1..first_end).find_map(|k| {
- let advance = shaped.get(k)?.adv;
- if prefix > EPS && advance > EPS {
- Some(prefix)
- } else {
- prefix += advance;
- None
- }
- });
- let Some(width) = width else { return };
-
- let mut object = TextObject::point(Point::ZERO, text, style);
- object.kind = TextKind::Area { frame: PathData::from_bezpath(&Rect::new(0.0, 0.0, width, 100.0).to_path(0.1)) };
- let result = layout_with(db, &object, &LayoutOptions::default());
-
- let next_cluster_byte = shaped.get(first_end).map(|g| g.byte);
- assert_eq!(result.lines.first().map(|line| line.end), next_cluster_byte);
- }
-
- /// No Break keeps the marked characters on one line, including across a space, and moves a
- /// marked run that does not fit to the next line whole.
- #[test]
- fn no_break_keeps_marked_characters_on_one_line() {
- let text = "A B";
- let plain = synthetic_glyphs(&[(0, 1, 10.0, 'A'), (1, 1, 4.0, ' '), (2, 1, 10.0, 'B')]);
- let (end, hyphen) = break_line(text, &plain, 0, 16.0, &[], 0.0, None, Burasagari::None, Kinsoku::None);
- assert!(!hyphen);
- assert_eq!(end, 2, "without the mark the line ends after the space");
-
- let mut marked = plain;
- for g in &mut marked {
- g.no_break = true;
- }
- let (end, hyphen) = break_line(text, &marked, 0, 16.0, &[], 0.0, None, Burasagari::None, Kinsoku::None);
- assert!(!hyphen);
- assert_eq!(end, 3, "the marked words stay together even though they are wider than the line");
+ let (end, hyphen) = break_line(text, &marked, 0, 16.0, &[], 0.0, None, Burasagari::None, Kinsoku::None);
+ assert!(!hyphen);
+ assert_eq!(end, 3, "the marked words stay together even though they are wider than the line");
// 日 and 本 may break between them. Marked, they move together when they do not fit after "A ".
let text = "A 日本";
@@ -1844,1491 +457,3 @@ mod wrapping_tests {
assert!(breaks.iter().all(|b| b.end != 3), "no break between the marked characters: {breaks:?}");
}
}
-
-#[cfg(test)]
-#[test]
-fn japanese_letters_for_the_latin_space_are_kana_kanji_and_marks_not_hangul_or_punctuation() {
- for c in ['あ', 'カ', '漢', '々', '〆', '〇', 'A'] {
- assert!(is_japanese_letter(c), "{c}");
- }
- // Hangul in every form: syllables, compatibility jamo (ㄱ ㅏ), half-width jamo (ᄀ).
- for c in ['한', 'ㄱ', 'ㅏ', '\u{FFA1}', '。', '「', '・', '、', 'a'] {
- assert!(!is_japanese_letter(c), "{c}");
- }
-}
-
-#[cfg(test)]
-#[test]
-fn kinsoku_keeps_closing_marks_off_line_starts_and_opening_ones_off_line_ends() {
- for (a, b) in [('字', '。'), ('弧', '」'), ('」', '、'), ('ャ', 'ー'), ('カ', 'ッ'), ('「', 'か'), ('(', '雅')] {
- assert!(!kinsoku_between(a, Some(b), Kinsoku::Hard), "{a}{b}");
- }
- for (a, b) in [('。', '雅'), ('」', 'は'), ('字', '「'), ('の', '演')] {
- assert!(kinsoku_between(a, Some(b), Kinsoku::Hard), "{a}{b}");
- }
- assert!(kinsoku_between('。', None, Kinsoku::Hard));
-}
-
-/// Soft kinsoku lets 々, ー and small kana (JLREQ cl-09's 々, cl-10, cl-11) start a line and keeps
-/// the rest of the set (half-width forms aren't in those classes); None allows any break.
-#[cfg(test)]
-#[test]
-fn soft_kinsoku_lets_small_kana_and_the_prolonged_sound_mark_start_a_line() {
- for (a, b) in [('ャ', 'ー'), ('カ', 'ッ'), ('時', '々'), ('ト', 'ㇰ'), ('か', 'ゃ')] {
- assert!(!kinsoku_between(a, Some(b), Kinsoku::Hard), "{a}{b}");
- assert!(kinsoku_between(a, Some(b), Kinsoku::Soft), "{a}{b}");
- }
- for (a, b) in [('字', '。'), ('弧', '」'), ('「', 'か'), ('カ', 'ッ'), ('カ', 'ー'), ('字', 'ゝ')] {
- assert!(!kinsoku_between(a, Some(b), Kinsoku::Soft), "{a}{b}");
- assert!(kinsoku_between(a, Some(b), Kinsoku::None), "{a}{b}");
- }
-}
-
-/// Glyph indices inside `g[ws..we]` (a word) where a hyphenated break may go under `opts`.
-fn hyphen_breaks(text: &str, g: &[SGlyph], ws: usize, we: usize, opts: &HyphenationOptions) -> Vec<usize> {
- // Strip leading/trailing punctuation (quotes, commas).
- let (mut a, mut b) = (ws, we);
- while a < b && !g[a].is_letter() {
- a += 1;
- }
- while b > a && !g[b - 1].is_letter() {
- b -= 1;
- }
- if b <= a || g[a..b].iter().any(|g| !g.is_letter()) {
- return vec![];
- }
- let (s, e) = (g[a].byte, g[b - 1].byte + g[b - 1].len);
- let Some(word) = text.get(s..e) else { return vec![] };
- let offs: Vec<usize> = word.char_indices().map(|(o, _)| s + o).collect();
- // The first glyph of each cluster start (not inside a ligature), by its byte: one pass, not a
- // search for each point.
- let mut starts = std::collections::HashMap::new();
- for k in a + 1..b {
- if g[k].byte != g[k - 1].byte {
- starts.entry(g[k].byte).or_insert(k);
- }
- }
- hyphen_points_with(word, opts).into_iter().filter_map(|ci| starts.get(offs.get(ci)?).copied()).collect()
-}
-
-/// Break candidates for the every-line composer: hyphenation points under `hyphenate` (the
-/// paragraph's Hyphenation options) when it is given. No break comes before a space: a line that
-/// may end after a dash, a Thai word or a space ends after the spaces that follow it, as in
-/// [`break_line`].
-fn candidates(text: &str, g: &[SGlyph], hyphenate: Option<&HyphenationOptions>, kinsoku: Kinsoku) -> Vec<Breakpoint> {
- let mut v = vec![];
- let mut ws = 0;
- for (j, gl) in g.iter().enumerate() {
- let end_of_word = gl.is_space() || gl.break_after();
- if end_of_word {
- if let Some(opts) = hyphenate
- && j > ws
- {
- for k in
- hyphen_breaks(text, g, ws, j, opts).into_iter().filter(|&k| k > 0 && kinsoku_allows(g, k - 1, kinsoku) && !splits_no_break(g, k))
- {
- v.push(Breakpoint { end: k, hyphen: hyphen_glyph(&g[k - 1]).adv });
- }
- }
- let hy = if gl.is_soft_hyphen() { hyphen_glyph(gl).adv } else { 0.0 };
- if j + 1 < g.len() && g[j + 1].byte != gl.byte && !g[j + 1].is_space() && kinsoku_allows(g, j, kinsoku) && !splits_no_break(g, j + 1) {
- v.push(Breakpoint { end: j + 1, hyphen: hy });
- }
- ws = j + 1;
- }
- }
- if let Some(opts) = hyphenate
- && g.len() > ws
- {
- for k in
- hyphen_breaks(text, g, ws, g.len(), opts).into_iter().filter(|&k| k > 0 && kinsoku_allows(g, k - 1, kinsoku) && !splits_no_break(g, k))
- {
- v.push(Breakpoint { end: k, hyphen: hyphen_glyph(&g[k - 1]).adv });
- }
- }
- v.sort_by_key(|b| b.end);
- v.dedup_by_key(|b| b.end);
- v
-}
-
-/// Paragraphs longer than this (glyphs) are always broken line by line.
-const MAX_COMPOSE_GLYPHS: usize = 200_000;
-
-/// Every-line composition of paragraph glyphs `sg` if applicable (area text, justified or ragged,
-/// with uniform line metrics or in rectangular cells without text wrap); `None` falls back to the
-/// greedy single-line composer. With `continued`, the paragraph continues from the frame before,
-/// and its first composed line is not its first line.
-fn compose_para(
- cx: &Ctx<'_>,
- sg: &[SGlyph],
- flex: &[Flex],
- para: &ParaStyle,
- pen: &Pen<'_>,
- rtl: bool,
- continued: bool,
-) -> Option<Vec<(usize, bool)>> {
- let ragged = matches!(para.justify, Justify::Auto | Justify::Left | Justify::Center | Justify::Right);
- let composer = cx.opts.composer.unwrap_or(para.composer);
- // A paragraph whose commas or full stops may hang is composed line by line (as the Japanese
- // single-line composer does).
- let may_hang = para.burasagari != Burasagari::None && sg.iter().any(hangs);
- // A tab's width depends on where it falls in its line, which the composer's fixed glyph widths
- // can't follow: such a paragraph is broken line by line ([`break_line`] measures its tabs).
- // The tab after a list marker always starts the first line and has a fixed width.
- let has_tab = sg.iter().any(|g| g.ch == '\t' && g.len > 0);
- if composer != Composer::EveryLine || pen.regions.is_none() || sg.len() < 2 || sg.len() > MAX_COMPOSE_GLYPHS || may_hang || has_tab {
- return None;
- }
- let m = Metrics::of(&sg[0]);
- // Line widths are independent of the breaks when every line has the same metrics, or when
- // a line's width does not depend on how far down the frame it is set: rectangular cells
- // without text wrap. Then a paragraph whose characters differ in line metrics (type size,
- // font, leading, vertical scale, an inline graphic taller than the text) is composed too. In
- // other shapes, or with text wrap, a taller line can move the lines below it to where the
- // frame is narrower, so such a paragraph is broken line by line.
- let plain = pen.regions.is_some_and(|r| r.iter().all(|r| (r.rect || r.polys.is_empty()) && r.wraps.is_empty()));
- if !plain && sg.iter().any(|g| Metrics::of(g) != m) {
- return None;
- }
- let total: f64 = sg.iter().map(|g| g.adv).sum();
- let mut sim = pen.clone();
- let mut widths = vec![];
- let mut acc = 0.0;
- // A line's width and placement depend on the sum of its indents alone, which the mirrored
- // indents of a right-to-left list ([`line_indents`]) keep.
- while widths.len() < sg.len() {
- let first = widths.is_empty();
- let ind_l = para.left_indent + if first && !continued { para.first_line_indent } else { 0.0 };
- // Only the first line's first word is known here. Later lines are placed as the composed
- // lines need: each fits its width, so its first word does too.
- let word = if first { word_width(sg, 0) } else { 0.0 };
- let Some((b, x0, x1, _)) = sim.place(m, ind_l, para.right_indent, word) else { break };
- let w = x1 - x0 - ind_l - para.right_indent;
- widths.push(w);
- acc += w.max(1.0);
- sim.settled(b, m);
- sim.pending = 0.0;
- if acc > total * 1.6 + 4.0 * w.max(1.0) {
- break;
- }
- }
- let last = *widths.last()?;
- let width = |k: usize| widths.get(k).copied().unwrap_or(last);
- // Lines from `uniform_from` on are interchangeable (same width).
- let uniform_from = widths.iter().rposition(|&w| (w - last).abs() > EPS).map_or(0, |k| k + 1);
- let cands = candidates(cx.text, sg, para.hyphenate.then_some(&para.hyphenation), para.kinsoku);
- let justify_last = para.justify == Justify::JustifyAll;
- let hyphen_limit = usize::try_from(para.hyphenation.hyphen_limit).unwrap_or(usize::MAX);
- let params = |tolerance| Params { justify_last, ragged, tolerance, uniform_from, hyphen_limit };
- // First look for breaks that keep every line within its range (ragged: at most one rag zone,
- // a sixth of the width, left on each line; justified: the Justification options' Minimum and
- // Maximum), then accept any lines that fit, the loosest scored worst. Justified text used to
- // stop at four times its stretch and fall back to the single-line composer; the documented
- // default range (word spacing up to 133%) is narrow enough that most paragraphs would.
- let (strict, loose) = (1.0, f64::INFINITY);
- // The same rule as the line loop below: an opening bracket starting a wrapped line gives up
- // the space before it.
- let start_credit = |i: usize| {
- let flush = !rtl && para.mojikumi == Mojikumi::LineEndHalf;
- sg.get(i).filter(|g| flush && g.lead <= 0.0).and_then(|g| punct_half(g, Punct::Opening)).unwrap_or(0.0)
- };
- compose(sg, &width, &start_credit, &cands, flex, &params(strict)).or_else(|| compose(sg, &width, &start_credit, &cands, flex, &params(loose)))
-}
-
-/// The list marker of each of the paragraphs `paras` of `t` (None for none): bullets, and numbers
-/// counted through consecutive list paragraphs from [`TextObject::list_count`], as
-/// [`vectorcraft_doc::text::ParaList::next_marker`] counts them.
-fn list_markers(t: &TextObject, paras: &[Range<usize>]) -> Vec<Option<String>> {
- let mut count = t.list_count;
- paras.iter().enumerate().map(|(pi, pr)| vectorcraft_doc::text::ParaList::next_marker(t.para_at(pi).list, pr.is_empty(), &mut count)).collect()
-}
-
-/// Whether paragraph `para` (right to left when `rtl`) has its indents mirrored: a horizontal
-/// right-to-left list paragraph does.
-fn mirrors_indents(para: &ParaStyle, rtl: bool, vertical: bool) -> bool {
- rtl && !vertical && para.list.is_some()
-}
-
-/// The indents at the left and at the right of a line of paragraph `para` (its first line when
-/// `first`). With `mirror` ([`mirrors_indents`]) the left and first-line indents are measured from
-/// the right and the right indent from the left: the bullet of a right-to-left list hangs at the
-/// right, and the lines it wraps to line up with the text after the bullet.
-fn line_indents(para: &ParaStyle, first: bool, mirror: bool) -> (f64, f64) {
- let start = para.left_indent + if first { para.first_line_indent } else { 0.0 };
- if mirror { (para.right_indent, start) } else { (start, para.right_indent) }
-}
-
-/// Flow paragraphs `paras` (byte ranges) of `t`, each with its own paragraph attributes
-/// (alignment, indents, spacing, direction, mojikumi, leading model…).
-fn flow(cx: &mut Ctx<'_>, paras: &[Range<usize>], t: &TextObject, regions: Option<&[Region]>) {
- let mut pen = Pen {
- regions,
- ri: 0,
- prev: None,
- pending: 0.0,
- fb: cx.opts.first_baseline,
- fb_min: cx.opts.first_baseline_min,
- queued: vec![],
- model: t.para_at(0).leading_model,
- next_top: None,
- no_room_for: f64::INFINITY,
- };
- let markers = list_markers(t, paras);
- 'paras: for (pi, pr) in paras.iter().enumerate() {
- let para = t.para_at(pi);
- let marker_text = markers.get(pi).and_then(Option::as_deref);
- // The leading model is a paragraph attribute: this paragraph's lines (and the space to
- // its first line) follow its own.
- pen.model = para.leading_model;
- let text = cx.text;
- let bidi = para_bidi_with(text.get(pr.clone()).unwrap_or_default(), para.direction, &cx.char_directions(pr));
- let rtl = is_rtl(bidi.as_ref());
- let mut sg = cx.shape_para(pr.clone(), bidi.as_ref());
- // Thai, Lao, Khmer and Myanmar break lines between words, not at spaces.
- mark_word_ends(text.get(pr.clone()).unwrap_or_default(), pr.start, &mut sg);
- // Japanese composition: consecutive punctuation shares one half-em space.
- let mut compressed = if para.mojikumi == Mojikumi::LineEndHalf { compress_punctuation(&mut sg) } else { vec![] };
- // …and a quarter em between Japanese and Latin text.
- let mut wakan = if para.mojikumi == Mojikumi::LineEndHalf { space_japanese_and_latin(&mut sg) } else { vec![] };
- // Justification…: the glyphs at Desired word and letter spacing and glyph scaling, and how
- // far a justified line may move each one from it.
- let mut flex = apply_desired(&mut sg, &para.justification, !cx.vertical);
- // Threaded text: a first paragraph that continues from the frame before has its first
- // line, first-line indent and list marker there.
- let continued = pi == 0 && t.first_para_continues;
- // Bullets and numbers: the list marker's glyphs `0..marker` start the paragraph.
- // Justification and Optical Margin Alignment leave them as they are.
- let marker = if continued { 0 } else { cx.prepend_marker(pr, para, marker_text, rtl, &mut sg) };
- if marker > 0 {
- flex.splice(0..0, vec![Flex::default(); marker]);
- if !compressed.is_empty() {
- compressed.splice(0..0, vec![false; marker]);
- }
- if !wakan.is_empty() {
- wakan.splice(0..0, vec![0.0; marker]);
- }
- }
- // …and Auto Leading: characters whose leading is Auto take this paragraph's share of their size.
- let auto_leading = |st: &CharStyle| st.leading.unwrap_or_else(|| para.justification.auto_leading_for(st.size));
- if para.justification.auto_leading != vectorcraft_doc::JustificationOptions::default().auto_leading {
- for g in sg.iter_mut().filter(|g| g.inline.is_none()) {
- g.leading = auto_leading(cx.style_at(g.byte));
- }
- }
- let pm = {
- let (asc, desc, _) = style_metrics(cx.db, cx.style_at(pr.start));
- let lead = auto_leading(cx.style_at(pr.start));
- let st = cx.style_at(pr.start);
- let (cap, xh) = cap_x_heights(cx.db, st);
- let centre = cx.db.style_face(st).map_or(EM_CENTER, |f| f.ideographic_centre());
- Metrics { asc, desc, lead, cap, xh, top: (centre + 0.5) * st.size * st.v_scale / 100.0 }
- };
- if pi > 0 {
- pen.pending += para.space_before;
- }
- let n = sg.len();
- let composed = compose_para(cx, &sg, &flex, para, &pen, rtl, continued);
- // Hyphenation options: the Hyphenation Zone applies with the Single-line Composer, and the
- // Hyphen Limit counts the lines in a row that end with a hyphen.
- let zone = if cx.opts.composer.unwrap_or(para.composer) == Composer::SingleLine { para.hyphenation.zone } else { 0.0 };
- let hyphen_limit = usize::try_from(para.hyphenation.hyphen_limit).unwrap_or(usize::MAX);
- let mut hyphen_run = 0;
- let mut li_para = 0;
- let mut i = 0;
- let mirror = mirrors_indents(para, rtl, cx.vertical);
- loop {
- let est = if i < n { Metrics::of(&sg[i]) } else { pm };
- let first_line = li_para == 0 && !continued;
- let (ind_l, ind_r) = line_indents(para, first_line, mirror);
- // Measured before Mojikumi narrows an opening bracket, as the composer measures it.
- let word = word_width(&sg, i);
- // Mojikumi: an opening bracket starting a line is set flush with the line's start (the
- // space before it goes), and the line has that much more room. At a paragraph's start
- // that is the first-line indent: JIS X 4051's principle (JLREQ 3.1.5, Figure 71 ①).
- if !rtl
- && para.mojikumi == Mojikumi::LineEndHalf
- && let Some(g) = sg.get_mut(i)
- && g.lead <= 0.0
- && let Some(h) = punct_half(g, Punct::Opening)
- {
- g.adv -= h;
- g.lead += h;
- }
- // Place, break, then settle the baseline on the line's real metrics (moving on to the
- // next row/column if it no longer fits).
- let (baseline, x0, x1, end, hyph, m) = loop {
- let first_in_region = pen.prev.is_none();
- let Some((mut baseline, x0, x1, same_baseline)) = pen.place(est, ind_l, ind_r, word) else {
- cx.out.overflow = cx.text.len() > if i < n { sg[i].byte } else { pr.start };
- break 'paras;
- };
- let width = x1 - x0 - ind_l - ind_r;
- let hyphenate = (para.hyphenate && (hyphen_limit == 0 || hyphen_run < hyphen_limit)).then_some((&para.hyphenation, zone));
- let (end, hyph) = match composed.as_ref().and_then(|c| c.get(li_para)) {
- Some(&(e, h)) if e > i => (e, h),
- _ if i < n => break_line(cx.text, &sg, i, width, &para.tabs, ind_l, hyphenate, para.burasagari, para.kinsoku),
- _ => (n, false),
- };
- let m = Metrics::max(&sg[i..end]).unwrap_or(pm);
- baseline += if same_baseline || (pen.regions.is_none() && first_in_region) {
- 0.0
- } else if pen.model == LeadingModel::EmBoxTop {
- // The em box top is fixed (the frame's top, or the line above's): the baseline
- // hangs from it by this line's tallest em box.
- if first_in_region { m.top.max(pen.fb_min) - est.top.max(pen.fb_min) } else { m.top - est.top }
- } else if first_in_region {
- m.first_baseline(pen.fb, pen.fb_min) - est.first_baseline(pen.fb, pen.fb_min)
- } else {
- m.lead - est.lead
- };
- if pen.regions.is_some() && baseline + m.desc > pen.bottom() + 0.01 {
- // Try the next row/column; overflow if there is none.
- pen.ri += 1;
- pen.prev = None;
- pen.pending = 0.0;
- pen.queued.clear();
- continue;
- }
- break (baseline, x0, x1, end, hyph, m);
- };
- hyphen_run = if hyph && end > i { hyphen_run + 1 } else { 0 };
- let (ax0, ax1) = if regions.is_some() { (x0 + ind_l, x1 - ind_r) } else { (x0, x1) };
- let width = ax1 - ax0;
- pen.pending = 0.0;
- let last_of_para = end >= n;
- let mut trimmed = end;
- while trimmed > i && sg[trimmed - 1].is_space() {
- trimmed -= 1;
- }
- let hyphen = (hyph && end > i).then(|| hyphen_glyph(&sg[end - 1]));
- // Mojikumi: a closing bracket, comma or full stop ending the line is set half width, and
- // no Japanese–Latin space is left at the end of a line.
- let end_trim = match trimmed.checked_sub(1).filter(|&k| k >= i && para.mojikumi == Mojikumi::LineEndHalf) {
- Some(k) => {
- let half = if compressed.get(k).copied().unwrap_or(false) { None } else { sg.get(k).and_then(|g| punct_half(g, Punct::Closing)) };
- half.unwrap_or(0.0) + wakan.get(k).copied().unwrap_or(0.0)
- }
- None => 0.0,
- };
- let w: f64 = set_width(&sg, i, trimmed, &para.tabs, ind_l) + hyphen.as_ref().map_or(0.0, |h| h.adv) - end_trim;
- let line_start = sg.get(i).map_or(pr.start, |g| g.byte);
- let line_end = sg.get(end).map_or(pr.end, |g| g.byte);
- let order = visual_order(bidi.as_ref().filter(|_| !cx.vertical), pr.start, line_start..line_end, &sg[i..end]);
- // Optical Margin Alignment or Roman Hanging Punctuation: the share of a glyph that hangs.
- let share: Option<fn(&SGlyph) -> f64> =
- (t.optical_margin || para.roman_hanging).then_some(if t.optical_margin { optical_share } else { roman_share });
- // The glyphs before `stop` in visual order, each with the advance it is set with. A list
- // marker does not hang: it is counted with no width.
- let set = |j: usize, g: &SGlyph| {
- if j < marker {
- 0.0
- } else if j + 1 == trimmed {
- g.adv - end_trim
- } else {
- g.adv
- }
- };
- let visible = |stop: usize| -> (Vec<usize>, Vec<(&SGlyph, f64)>) {
- let at: Vec<usize> = order.iter().map(|&offset| i + offset).filter(|&j| j < stop).collect();
- let glyphs = at.iter().filter_map(|&j| sg.get(j).map(|g| (g, set(j, g)))).collect();
- (at, glyphs)
- };
- // Burasagari: a comma or full stop ending an area type line hangs outside it (Standard:
- // when it doesn't fit, counting what hangs at the line's start as room; Forced:
- // always). The rest of the line is aligned and justified without it, and it follows
- // the line's last character.
- let room_at_start = || share.map_or(0.0, |share| optical_hangs(&visible(trimmed).1, share).0);
- let hang = (regions.is_some() && !rtl && hyphen.is_none() && trimmed > i + 1)
- .then(|| sg.get(trimmed - 1))
- .flatten()
- .filter(|g| hangs(g))
- .map(|g| g.adv - end_trim)
- .filter(|_| match para.burasagari {
- Burasagari::None => false,
- Burasagari::Standard => w > width + room_at_start() + EPS,
- Burasagari::Forced => true,
- });
- let body = if hang.is_some() { trimmed - 1 } else { trimmed };
- let w = w - hang.unwrap_or(0.0);
- // The glyphs before the line's trailing spaces (and its burasagari mark), in the order
- // they are drawn.
- let (drawn, mut visible) = visible(body);
- // Optical Margin Alignment: the glyphs at the ends of a line hang outside its margins
- // by `opt_l` and `opt_r`. The line is aligned and justified in a measure that much
- // wider at each end. A left-aligned line then hangs only at its left, a right-aligned
- // line hangs only at its right, and centered and justified lines hang at both; Auto
- // aligns a right-to-left line at its right. A right-to-left line is read from right to
- // left ([`optical_hangs_rtl`]). A line that ends in a burasagari mark hangs only at its
- // left. Justification adds no space after a punctuation mark hanging at the left, nor
- // before one hanging at the right (`held`). A letter that hangs by part of its width
- // keeps its gaps. Glyph Scaling leaves the glyphs that hang (`hung`) at their width, so
- // they hang exactly by their published share. Roman Hanging Punctuation (a paragraph
- // attribute) hangs the same punctuation by the same amounts, and no letters; with
- // Optical Margin Alignment on as well, the letters hang too.
- let (opt_l, opt_r, held, hung) = if let Some(share) = share {
- if let Some(h) = &hyphen {
- visible.push((h, h.adv));
- }
- let (l, r, left_glyphs, right_glyphs) =
- if rtl && !cx.vertical { optical_hangs_rtl(&visible, share) } else { optical_hangs(&visible, share) };
- let (r, right_glyphs) = if hang.is_some() { (0.0, 0) } else { (r, right_glyphs) };
- let n_visible = visible.len();
- let punct = |k: usize| visible.get(k).is_some_and(|&(g, _)| optical_punct(g));
- let held: Vec<usize> = drawn
- .iter()
- .enumerate()
- .filter(|&(k, _)| (k < left_glyphs && punct(k)) || (right_glyphs > 0 && k + 1 + right_glyphs >= n_visible && punct(k + 1)))
- .map(|(_, &j)| j)
- .collect();
- let hung: Vec<usize> = drawn
- .iter()
- .enumerate()
- .filter(|&(k, _)| k < left_glyphs || (right_glyphs > 0 && k + right_glyphs >= n_visible))
- .map(|(_, &j)| j)
- .collect();
- (l, r, held, hung)
- } else {
- (0.0, 0.0, vec![], vec![])
- };
- // Justification adds nothing to the list marker's glyphs.
- let mut held = held;
- held.extend(i..marker.min(body));
- // What justification may change of glyph `j`: nothing of a `held` glyph, and no glyph
- // scaling of a `hung` one.
- let line_flex = |j: usize| {
- if held.contains(&j) {
- return Flex::default();
- }
- let mut f = flex.get(j).copied().unwrap_or_default();
- if hung.contains(&j) {
- f.glyph = (0.0, 0.0);
- }
- f
- };
- let room = width + opt_l + opt_r;
- let (align, justify) = match para.justify {
- Justify::Auto => (if rtl { 2 } else { 0 }, false),
- Justify::Left => (0, false),
- Justify::Center => (1, false),
- Justify::Right => (2, false),
- Justify::JustifyLeft => (0, !last_of_para),
- Justify::JustifyCenter => (1, !last_of_para),
- Justify::JustifyRight => (2, !last_of_para),
- Justify::JustifyAll => (0, true),
- };
- let justify = justify && regions.is_some();
- let (mut per_space, mut per_gap, mut per_cjk) = (0.0, 0.0, 0.0);
- let mut fit = LineFit::default();
- let spaces = (i..body).filter(|&j| j >= marker && sg[j].is_space()).count();
- // A gap that justification adds between two glyphs goes into the advance of the one
- // drawn first: `drawn_after(j)` is the glyph drawn right after glyph `j`, which in a
- // right-to-left line comes before it in the text.
- let mut after: Vec<Option<usize>> = vec![None; body.saturating_sub(i)];
- for (&a, &b) in drawn.iter().zip(drawn.iter().skip(1)) {
- if let Some(slot) = after.get_mut(a - i) {
- *slot = Some(b);
- }
- }
- let drawn_after = |j: usize| j.checked_sub(i).and_then(|k| after.get(k).copied().flatten());
- // Japanese (and Chinese) lines are justified between their characters (JLREQ 3.8): the
- // gaps next to a CJK character, not inside a Latin word or a tate-chu-yoko block.
- let cjk_gap = |j: usize| {
- !held.contains(&j)
- && drawn_after(j)
- .and_then(|k| sg.get(j).zip(sg.get(k)))
- .is_some_and(|(a, b)| !a.is_space() && !b.is_space() && !b.continues_tcy() && a.ch != '\t' && (is_cjk(a.ch) || is_cjk(b.ch)))
- };
- let cjk_gaps = (i..body).filter(|&j| cjk_gap(j)).count();
- // Single Word Justification: a justified line holding one word (no word space) is
- // spread between its letters (Full Justify) or aligned.
- let single_word = justify && spaces == 0 && cjk_gaps == 0;
- let (align, justify) = match (single_word, para.justification.single_word) {
- (false, _) | (true, SingleWordJustify::FullJustify) => (align, justify),
- (true, SingleWordJustify::AlignLeft) => (0, false),
- (true, SingleWordJustify::AlignCenter) => (1, false),
- (true, SingleWordJustify::AlignRight) => (2, false),
- };
- // Insert Kashidas: the Arabic words of a horizontal line take its room on kashidas,
- // and the word spaces and gaps take what is left.
- let kashidas =
- if justify && !cx.vertical && room > w + EPS { kashida::plan(cx.text, &sg, i..body, para.kashida, room - w) } else { vec![] };
- let w = w + kashidas.iter().map(|k| k.1).sum::<f64>();
- if justify && (room - w).abs() > EPS {
- if cjk_gaps > 0 && room > w {
- // Spread over the CJK gaps and the word spaces alike.
- let per = (room - w) / (cjk_gaps + spaces) as f64;
- (per_space, per_cjk) = (per, per);
- } else if spaces > 0 {
- // Word spacing, letter spacing and glyph scaling within their ranges, then the
- // word spaces alone; composed lines may shrink word spaces (never below zero).
- let line: Vec<Flex> = (i..body).map(line_flex).collect();
- let floor = (i..body).filter(|&j| j >= marker && sg[j].is_space()).map(|j| sg[j].adv).fold(f64::MAX, f64::min);
- fit = fit_line(&line, room - w, spaces, floor);
- } else if room > w {
- // One word: its letter spacing and glyph scaling, then the gaps between its glyphs.
- let line: Vec<Flex> = (i..body).map(line_flex).collect();
- fit = fit_line(&line, room - w, 0, 0.0);
- let used: f64 = line.iter().map(|f| fit.letter(f) + fit.glyph(f)).sum();
- let rest = room - w - used;
- let gaps = (i..body)
- .filter(|&j| !held.contains(&j) && drawn_after(j).and_then(|k| sg.get(k)).is_some_and(|next| !next.continues_tcy()))
- .count();
- if gaps > 0 && rest > EPS {
- per_gap = rest / gaps as f64;
- }
- }
- }
- let start_x = if justify {
- ax0 - opt_l
- } else if regions.is_none() {
- match align {
- 0 => ind_l - opt_l,
- 1 => (ind_l - opt_l - ind_r + opt_r - w) * 0.5,
- _ => -ind_r + opt_r - w,
- }
- } else {
- match align {
- 0 => ax0 - opt_l,
- 1 => ax0 - opt_l + (room - w) * 0.5,
- _ => ax1 + opt_r - w,
- }
- };
- let li = cx.out.lines.len();
- let glyph_start = cx.out.glyphs.len();
- // Character Alignment lines smaller characters up with the line's largest em box.
- let line_em = sg.get(i..end).map_or(0.0, |line| line.iter().map(glyph_em).fold(0.0, f64::max));
- let mut x_end = start_x;
- // Tab stops are measured from the frame's left edge (point type: the origin).
- let tab_origin = if regions.is_some() { x0 } else { 0.0 };
- // A line with tabs is measured as if it started at the left (see `set_width`), then
- // aligned as a whole: its tabs stop where they were measured, however it is aligned.
- let tab_shift = start_x - if regions.is_some() { ax0 } else { ind_l };
- // RTL's logical trailing spaces precede the visible content. Keep them outside
- // the aligned content extent, just as LTR trailing spaces extend to its right.
- let leading_space_width: f64 =
- order.iter().take_while(|&&offset| i + offset >= trimmed).filter_map(|&offset| sg.get(i + offset)).map(|g| g.adv).sum();
- let mut x = start_x - leading_space_width;
- // The glyphs drawn for the list marker, and the index of its tab's glyph, when the line starts the paragraph.
- let mut marker_glyphs: Option<Range<usize>> = None;
- let mut marker_tab = 0;
- for (oi, &offset) in order.iter().enumerate() {
- let j = i + offset;
- let Some(g) = sg.get(j) else { continue };
- let mut adv = g.adv;
- if j + 1 == trimmed {
- adv -= end_trim;
- }
- // Glyph scaling a justified line adds to the glyph (1: none).
- let mut scale = 1.0;
- let mut leader = "";
- if g.ch == '\t' {
- // The tab after a list marker keeps the width `prepend_marker` gave it.
- if g.len > 0 {
- (adv, leader) = tab_advance(&para.tabs, tab_origin, x - tab_shift, &sg[j + 1..trimmed.max(j + 1)]);
- }
- } else if j < body {
- let f = line_flex(j);
- if is_word_space(g) {
- adv += fit.space(&f);
- } else {
- adv += fit.letter(&f) + fit.glyph(&f);
- scale = fit.glyph_scale(&f);
- }
- if g.is_space() {
- adv += per_space;
- } else if per_cjk != 0.0 {
- if cjk_gap(j) {
- adv += per_cjk;
- }
- } else if !held.contains(&j) && drawn_after(j).and_then(|k| sg.get(k)).is_some_and(|next| !next.continues_tcy()) {
- // Between glyphs, never inside a tate-chu-yoko block (one cell).
- adv += per_gap;
- }
- }
- // The kashida before a cluster in the text is drawn at the cluster's right, between
- // it and the letter before it, and the cluster's last glyph advances over it: the
- // caret, selection and hit testing take it as part of the cluster.
- let kashida = kashidas
- .binary_search_by_key(&g.byte, |k| k.0)
- .ok()
- .and_then(|at| kashidas.get(at))
- .filter(|_| order.get(oi + 1).and_then(|&o| sg.get(i + o)).is_none_or(|next| next.byte != g.byte))
- .map(|k| k.1);
- adv += kashida.unwrap_or(0.0);
- let y = baseline - align_shift(g, cx.style_at(g.byte).char_align, line_em, cx.vertical);
- let place = if scale != 1.0 { Affine::translate((x, y)) * Affine::scale_non_uniform(scale, 1.0) } else { Affine::translate((x, y)) };
- if j < marker {
- let at = cx.out.glyphs.len();
- marker_glyphs = Some(marker_glyphs.map_or(at..at + 1, |r: Range<usize>| r.start.min(at)..r.end.max(at + 1)));
- if j + 1 == marker {
- marker_tab = at;
- }
- }
- cx.emit(g, place, Point::new(x, y), 0.0, adv, li);
- if let Some(out) = cx.out.glyphs.last_mut() {
- out.scale = flex.get(j).map_or(1.0, |f| f.scale) * scale;
- }
- if !leader.is_empty() {
- // The leader belongs to the tab's glyph: the gap stays one character for the
- // caret, selection and hit testing.
- let dots = leader_outline(cx.db, g, leader, tab_origin, x, x + adv, y);
- if let Some(tab) = cx.out.glyphs.last_mut() {
- tab.outline.extend(dots);
- }
- }
- if let Some(len) = kashida {
- cx.emit_kashida(g, para.kashida, len, Point::new(x + adv - len, y), li);
- }
- x += adv;
- if j < trimmed {
- x_end = x;
- }
- }
- if let (Some(glyphs), Some(text)) = (marker_glyphs, marker_text) {
- cx.out.markers.push(ListMarker { glyphs, tab: marker_tab, text: text.to_string() });
- }
- if let Some(h) = &hyphen {
- // The hyphen follows the last non-space glyph.
- let hx = x_end;
- cx.emit(h, Affine::translate((hx, baseline)), Point::new(hx, baseline), 0.0, h.adv, li);
- x_end = hx + h.adv;
- }
- cx.out.lines.push(LineInfo {
- rtl: rtl && !cx.vertical,
- baseline,
- x0: start_x,
- x1: x_end,
- ascent: m.asc,
- descent: m.desc,
- first_baseline: if pen.model == LeadingModel::EmBoxTop { m.top.max(pen.fb_min) } else { m.first_baseline(pen.fb, pen.fb_min) },
- start: if i < n { sg[i].byte } else { pr.start },
- end: if last_of_para { pr.end } else { sg[end].byte },
- glyph_start,
- glyph_end: cx.out.glyphs.len(),
- avail: if regions.is_some() { (ax0, ax1) } else { (start_x, x_end) },
- region: if regions.is_some() { pen.ri } else { 0 },
- });
- pen.settled(baseline, m);
- // Further spans of this line band share the settled baseline.
- for q in &mut pen.queued {
- q.0 = baseline;
- }
- li_para += 1;
- i = end;
- if i >= n {
- break;
- }
- }
- pen.pending += para.space_after;
- }
-}
-
-/// The distance along type on a path each glyph takes: its advance measured `spacing` points above
-/// the path (Type on a Path Options › Spacing), so glyphs close up round the outside of a curve and
-/// open up round the inside; just the advances without spacing. Glyphs start `from` along the path.
-fn path_steps(ap: &ArcPath, glyphs: &[SGlyph], from: f64, spacing: f64) -> Vec<f64> {
- let mut s = from;
- glyphs
- .iter()
- .map(|g| {
- let mut step = g.adv;
- if spacing != 0.0 && g.adv > 1e-9 {
- // How far the path turns across the glyph: positive bending away from its top.
- let ((_, a), (_, b)) = (ap.at(s), ap.at(s + g.adv));
- let curvature = a.cross(b).atan2(a.dot(b)) / g.adv;
- step = g.adv / (1.0 + curvature * spacing).clamp(0.25, 4.0);
- }
- s += step;
- step
- })
- .collect()
-}
-
-/// How closely a bent glyph's curves follow the path (text space units).
-const BEND_TOLERANCE: f64 = 0.01;
-/// The most pieces one segment of a glyph's outline is cut into to bend it.
-const BEND_PIECES: usize = 32;
-/// The most elements a bent glyph outline may have; beyond that the glyph stays straight.
-const BEND_MAX_ELEMENTS: usize = 8192;
-
-/// `outline` (text space, placed straight by `pre`, which takes the glyph's pen space there) bent
-/// along `ap` as `bend` says ([`GlyphBend`]); `None` where the path doesn't turn under the glyph
-/// (it stays as it is, exactly), or the bent outline would be too large or not finite.
-fn bend_outline(outline: &BezPath, pre: Affine, ap: &ArcPath, bend: &GlyphBend) -> Option<BezPath> {
- let GlyphBend { s, step, advance, rise } = *bend;
- if outline.elements().is_empty() || !(advance > 1e-9 && step.is_finite() && step > 0.0 && s.is_finite() && rise.is_finite()) {
- return None;
- }
- // How far the path turns under the glyph; none: it lies straight already.
- let ((_, a), (_, b)) = (ap.at(s), ap.at(s + step));
- let turn = a.cross(b).atan2(a.dot(b)).abs();
- if !(turn.is_finite() && turn > 1e-9) {
- return None;
- }
- let det = pre.determinant();
- if !(det.is_finite() && det.abs() > 1e-12) {
- return None;
- }
- let to_pen = pre.inverse();
- let k = step / advance;
- let map = |q: Point| {
- let (p, d) = ap.at(s + q.x * k);
- p + Vec2::new(-d.y, d.x) * (q.y + rise)
- };
- // Pieces short enough that mapping a piece's control points stays within the tolerance: the
- // error of a piece of length L under curvature c, at height y, is about L² c (1 + |y| c) / 8.
- let curvature = turn / step;
- let pen = to_pen * outline.clone();
- let height = pen.bounding_box().y0.abs().max(pen.bounding_box().y1.abs()) + rise.abs();
- let piece = ((8.0 * BEND_TOLERANCE) / (curvature * (1.0 + height * curvature))).sqrt();
- let pieces = |a: Point, b: Point| -> usize {
- let n = ((b - a).hypot() / piece).ceil();
- if n.is_finite() { (n as usize).clamp(1, BEND_PIECES) } else { BEND_PIECES }
- };
- let mut out = BezPath::new();
- let (mut start, mut cur) = (Point::ZERO, Point::ZERO);
- let line = |out: &mut BezPath, from: Point, to: Point| {
- let n = pieces(from, to);
- for i in 1..=n {
- out.line_to(map(from.lerp(to, i as f64 / n as f64)));
- }
- };
- for el in pen.elements() {
- match *el {
- PathEl::MoveTo(p) => {
- out.move_to(map(p));
- (start, cur) = (p, p);
- }
- PathEl::LineTo(p) => {
- line(&mut out, cur, p);
- cur = p;
- }
- PathEl::QuadTo(p1, p2) => {
- let c = kurbo::QuadBez::new(cur, p1, p2).raise();
- let n = pieces(cur, p1).max(pieces(p1, p2));
- for i in 0..n {
- let q = c.subsegment(i as f64 / n as f64..(i + 1) as f64 / n as f64);
- out.curve_to(map(q.p1), map(q.p2), map(q.p3));
- }
- cur = p2;
- }
- PathEl::CurveTo(p1, p2, p3) => {
- let c = kurbo::CubicBez::new(cur, p1, p2, p3);
- let n = pieces(cur, p1).max(pieces(p1, p2)).max(pieces(p2, p3));
- for i in 0..n {
- let q = c.subsegment(i as f64 / n as f64..(i + 1) as f64 / n as f64);
- out.curve_to(map(q.p1), map(q.p2), map(q.p3));
- }
- cur = p3;
- }
- PathEl::ClosePath => {
- if (cur - start).hypot() > 1e-12 {
- line(&mut out, cur, start);
- }
- out.close_path();
- cur = start;
- }
- }
- if out.elements().len() > BEND_MAX_ELEMENTS {
- return None;
- }
- }
- let finite = |p: Point| p.x.is_finite() && p.y.is_finite();
- out.elements()
- .iter()
- .all(|el| match *el {
- PathEl::MoveTo(p) | PathEl::LineTo(p) => finite(p),
- PathEl::QuadTo(a, b) => finite(a) && finite(b),
- PathEl::CurveTo(a, b, c) => finite(a) && finite(b) && finite(c),
- PathEl::ClosePath => true,
- })
- .then_some(out)
-}
-
-/// Lay type on a path out along `path` (text space), between its brackets.
-fn on_path(cx: &mut Ctx<'_>, paras: &[Range<usize>], t: &TextObject, path: &PathData) {
- 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);
- // The first paragraph's direction aligns the line (Auto) and sets the caret's.
- let mut rtl = None;
- let mut shaped = Vec::new();
- let markers = list_markers(t, paras);
- for (pi, pr) in paras.iter().enumerate() {
- let text = cx.text;
- let bidi = para_bidi_with(text.get(pr.clone()).unwrap_or_default(), para.direction, &cx.char_directions(pr));
- rtl.get_or_insert(is_rtl(bidi.as_ref()) && !cx.vertical);
- let mut glyphs = cx.shape_para(pr.clone(), bidi.as_ref());
- // Bullets and numbers: a list paragraph's text starts after its marker here too, unless
- // the paragraph continues from the frame before in its thread.
- if pi > 0 || !t.first_para_continues {
- let marker_text = markers.get(pi).and_then(Option::as_deref);
- cx.prepend_marker(pr, t.para_at(pi), marker_text, is_rtl(bidi.as_ref()) && !cx.vertical, &mut glyphs);
- }
- 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)
- });
- if ap.is_empty() {
- cx.out.overflow = !sg.is_empty();
- cx.out.lines.push(LineInfo {
- rtl,
- baseline: 0.0,
- x0: 0.0,
- x1: 0.0,
- ascent: m.0,
- descent: m.1,
- first_baseline: 0.0,
- start: 0,
- end: 0,
- glyph_start: 0,
- glyph_end: 0,
- avail: (0.0, 0.0),
- region: 0,
- });
- return;
- }
- let centre = path.bounds().unwrap_or_default().center();
- let (from, to) = t.kind.path_span().unwrap_or((0.0, 1.0));
- 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 };
- // 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
- // end (`hung_r` of them) do not make it overflow past the end bracket. On an open path a hang
- // stops at the path's end. On a closed path the two hangs together take at most the stretch
- // between the end and start brackets: the end where the line is placed takes its share first.
- // A centered line's ends each get up to half of it, and either end takes what the other leaves.
- // 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 = |sg: &[SGlyph], steps: &[f64]| {
- if !hanging {
- return (0.0, 0.0, 0);
- }
- let share: fn(&SGlyph) -> f64 = if t.optical_margin { optical_share } else { roman_share };
- // A list marker (the glyphs of length 0) does not hang: it is counted with no width.
- let line: Vec<(&SGlyph, f64)> = sg.iter().zip(steps).map(|(g, &step)| (g, if g.len == 0 { 0.0 } else { step })).collect();
- let (l, r, _, hung_r) = if rtl { optical_hangs_rtl(&line, share) } else { optical_hangs(&line, share) };
- let (l, r) = if ap.is_closed() {
- let gap = (ap.len() - avail).max(0.0);
- match para.justify {
- j if matches!(j, Justify::Right | Justify::JustifyRight) || (rtl && j == Justify::Auto) => {
- let r = r.min(gap);
- (l.min(gap - r), r)
- }
- Justify::Center | Justify::JustifyCenter => {
- let l = l.min(gap - r.min(gap * 0.5));
- (l, r.min(gap - l))
- }
- _ => {
- let l = l.min(gap);
- (l, r.min(gap - l))
- }
- }
- } else {
- (l.min(s_start), r.min((ap.len() - s_start - avail).max(0.0)))
- };
- (l, r, hung_r)
- };
- // 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)
- };
- // 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;
- }
- }
- 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);
- }
- // 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 {
- PathAlign::Baseline => 0.0,
- PathAlign::Ascender => m.0,
- PathAlign::Descender => -m.1,
- PathAlign::Center => (m.0 - m.1) * 0.5,
- };
- let mut x = 0.0;
- for (g, &step) in sg.iter().zip(&steps).take(fit) {
- let s = s0 + x;
- 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));
- // Glyph space: x along the advance, y down from the baseline; `pre` maps it onto the path.
- let pre = match t.path_effect {
- PathEffect::Rainbow => Affine::translate(p.to_vec2()) * Affine::rotate(angle) * half,
- // x axis along the tangent, y axis stays vertical.
- PathEffect::Skew => Affine::translate(p.to_vec2()) * Affine::new([dir.x, dir.y, 0.0, 1.0, 0.0, 0.0]) * half,
- // x axis stays horizontal (facing the path's direction), y axis perpendicular to the path.
- PathEffect::Ribbon3d => {
- let sx = if dir.x < 0.0 { -1.0 } else { 1.0 };
- Affine::translate(p.to_vec2()) * Affine::new([sx, 0.0, -dir.y * sx, dir.x * sx, 0.0, 0.0]) * half
- }
- PathEffect::StairStep => Affine::translate(ap.at(s).0.to_vec2()) * Affine::translate((0.0, rise)),
- // x axis along the tangent; vertical edges point at the path's centre (kept on the glyph's
- // up side, and never closer than ~17° to the baseline so glyphs stay legible).
- PathEffect::Gravity => {
- let n = Vec2::new(dir.y, -dir.x);
- let mut up = p - centre;
- up = if up.hypot() < 1e-9 { n } else { up / up.hypot() };
- if up.dot(n) < 0.0 {
- up = -up;
- }
- if up.dot(n) < 0.3 {
- let along = up - n * up.dot(n);
- up = n * 0.3 + along / along.hypot().max(1e-9) * (1.0 - 0.09f64).sqrt();
- }
- Affine::translate(p.to_vec2()) * Affine::new([dir.x, dir.y, -up.x, -up.y, 0.0, 0.0]) * half
- }
- };
- // The caret's baseline moves with the type.
- let origin = p - dir * (g.adv * 0.5) + Vec2::new(-dir.y, dir.x) * rise;
- // A list marker's glyphs (the only glyphs here with no length) are in a row at the byte of
- // their paragraph's start.
- if g.len == 0 {
- let at = cx.out.glyphs.len();
- let starts_paragraph = |b: usize| paras.iter().position(|p| p.start == b);
- match cx.out.markers.last_mut() {
- Some(m) if m.glyphs.end == at && cx.out.glyphs.get(m.glyphs.start).is_some_and(|h| h.byte == g.byte) => m.glyphs.end = at + 1,
- _ => {
- if let Some(text) = starts_paragraph(g.byte).and_then(|pi| markers.get(pi)).and_then(Option::as_ref) {
- cx.out.markers.push(ListMarker { glyphs: at..at + 1, tab: at, text: text.clone() });
- }
- }
- }
- if let Some(m) = cx.out.markers.last_mut().filter(|m| m.glyphs.end == at + 1 && g.ch == '\t') {
- m.tab = at;
- }
- }
- cx.emit(g, pre, origin, angle, g.adv, 0);
- // A glyph of a script whose letters join is bent along a curved path (Rainbow), so its
- // joining strokes meet its neighbours' instead of standing off the curve.
- if t.path_effect == PathEffect::Rainbow && g.cursive && !cx.vertical && g.inline.is_none() {
- let bend = GlyphBend { s, step, advance: g.adv, rise };
- if let Some(last) = cx.out.glyphs.last_mut()
- && last.image.is_none()
- && last.colour.is_none()
- && let Some(bent) = bend_outline(&last.outline, pre, &ap, &bend)
- {
- last.outline = bent;
- last.bend = Some(bend);
- }
- }
- x += step;
- }
- let (ps, _) = ap.at(s0);
- let (pe, _) = ap.at(s0 + x);
- cx.out.lines.push(LineInfo {
- rtl,
- baseline: ps.y,
- x0: ps.x,
- x1: pe.x,
- ascent: m.0,
- descent: m.1,
- first_baseline: 0.0,
- start: 0,
- end: fits,
- glyph_start: 0,
- glyph_end: cx.out.glyphs.len(),
- avail: (0.0, ap.len()),
- region: 0,
- });
-}
-
-/// The bidirectional resolution (UAX #9) of paragraph `text`, its base direction `direction` or,
-/// without one, from its first strong character. `None` for the usual paragraph with nothing right
-/// to left in it (no right-to-left character or direction), which skips the algorithm.
-pub(crate) fn para_bidi(text: &str, direction: Option<ParaDirection>) -> Option<BidiInfo<'_>> {
- use unicode_bidi::BidiClass::{AL, AN, FSI, R, RLE, RLI, RLO};
- let rtl_set = direction == Some(ParaDirection::RightToLeft);
- if !rtl_set && !text.chars().any(|c| matches!(unicode_bidi::bidi_class(c), R | AL | AN | RLE | RLO | RLI | FSI)) {
- return None;
- }
- let level = direction.map(|d| if d == ParaDirection::RightToLeft { Level::rtl() } else { Level::ltr() });
- Some(BidiInfo::new(text, level))
-}
-
-/// [`para_bidi`] for a paragraph whose characters in `set` (byte ranges of `text`, in order and not
-/// overlapping, from [`Ctx::char_directions`]) have a Character Direction: each range is resolved
-/// as a Unicode bidi embedding, as if an LRE or RLE stood before it and a PDF after it (UAX #9 X2,
-/// X3, X7). The levels, classes and paragraphs come back for the bytes of `text`. The paragraph's own
-/// direction is unchanged: the first strong character is found inside embeddings too (P2).
-pub(crate) fn para_bidi_with<'a>(text: &'a str, direction: Option<ParaDirection>, set: &[(Range<usize>, ParaDirection)]) -> Option<BidiInfo<'a>> {
- let plain = para_bidi(text, direction);
- if set.is_empty() || (plain.is_none() && set.iter().all(|(_, d)| *d == ParaDirection::LeftToRight)) {
- // A left-to-right embedding in left-to-right text takes an even level: its order is the same.
- return plain;
- }
- // The text with the embedding controls, and where each byte of `text` is in it.
- let mut marked = String::with_capacity(text.len() + set.len() * 6);
- let mut at_byte: Vec<usize> = Vec::with_capacity(text.len());
- let mut copy = |marked: &mut String, from: usize, to: usize| {
- if let Some(s) = text.get(from..to) {
- at_byte.extend(marked.len()..marked.len() + s.len());
- marked.push_str(s);
- }
- };
- let mut done = 0;
- for (r, d) in set {
- let (a, b) = (r.start.max(done).min(text.len()), r.end.min(text.len()));
- if a >= b {
- continue;
- }
- copy(&mut marked, done, a);
- marked.push(if *d == ParaDirection::RightToLeft { '\u{202B}' } else { '\u{202A}' });
- copy(&mut marked, a, b);
- marked.push('\u{202C}');
- done = b;
- }
- copy(&mut marked, done, text.len());
- let level = direction.map(|d| if d == ParaDirection::RightToLeft { Level::rtl() } else { Level::ltr() });
- let info = BidiInfo::new(&marked, level);
- let back = |i: usize| at_byte.partition_point(|&m| m < i);
- let paragraphs =
- info.paragraphs.iter().map(|p| unicode_bidi::ParagraphInfo { range: back(p.range.start)..back(p.range.end), level: p.level }).collect();
- Some(BidiInfo {
- text,
- original_classes: at_byte.iter().filter_map(|&i| info.original_classes.get(i).copied()).collect(),
- levels: at_byte.iter().filter_map(|&i| info.levels.get(i).copied()).collect(),
- paragraphs,
- })
-}
-
-/// Does the paragraph run right to left ([`para_bidi`])?
-pub(crate) fn is_rtl(bidi: Option<&BidiInfo<'_>>) -> bool {
- bidi.and_then(|b| b.paragraphs.first()).is_some_and(|p| p.level.is_rtl())
-}
-
-/// The visual order of a line's `glyphs` (indices into them), whole shaping clusters reordered
-/// (UAX #9 L1–L2) for the line `line` (bytes of the text) of the paragraph starting at byte
-/// `paragraph_start`; their own order when nothing is right to left (`bidi` None).
-fn visual_order(bidi: Option<&BidiInfo<'_>>, paragraph_start: usize, line: Range<usize>, glyphs: &[SGlyph]) -> Vec<usize> {
- let Some((bidi, para)) = bidi.filter(|b| b.has_rtl()).and_then(|b| Some((b, b.paragraphs.first()?))) else {
- return (0..glyphs.len()).collect();
- };
- if glyphs.is_empty() {
- return vec![];
- }
- let levels = bidi.reordered_levels(para, line.start.saturating_sub(paragraph_start)..line.end.saturating_sub(paragraph_start));
- // A list marker (length 0) is a cluster of its own.
- let mut clusters: Vec<Range<usize>> = Vec::new();
- for (i, g) in glyphs.iter().enumerate() {
- if i > 0 && glyphs.get(i - 1).is_some_and(|p| p.byte == g.byte && (p.len == 0) == (g.len == 0)) {
- if let Some(c) = clusters.last_mut() {
- c.end = i + 1;
- }
- } else {
- clusters.push(i..i + 1);
- }
- }
- // A list marker is at the paragraph's level, and at a right-to-left one its tab is drawn
- // before (left of) its characters.
- let cluster_levels: Vec<_> = clusters
- .iter()
- .filter_map(|c| glyphs.get(c.start))
- .map(|g| if g.len == 0 { g.level } else { levels.get(g.byte.saturating_sub(paragraph_start)).copied().unwrap_or(g.level) })
- .collect();
- let reversed = |i: usize| glyphs.get(clusters.get(i).map_or(0, |c| c.start)).is_some_and(|g| g.len == 0 && g.level.is_rtl());
- unicode_bidi::BidiInfo::reorder_visual(&cluster_levels)
- .into_iter()
- .filter_map(|i| clusters.get(i).map(|c| (c.clone(), reversed(i))))
- .flat_map(|(c, rev)| {
- let mut v: Vec<usize> = c.collect();
- if rev {
- v.reverse();
- }
- v
- })
- .collect()
-}
-
-/// Ruby (furigana): lays each reading out over its base text in line space, grows the line's
-/// ascent/descent so the ruby fits, and moves the lines after it on in the block direction.
-///
-/// Positions are measured from the line's baseline. Vertical type uses the same geometry — ruby
-/// "above" the baseline is right of the column once the lines are turned — with each reading
-/// character set upright along the column (a quarter turn that the final vertical turn undoes).
-/// A reading over a line break is split between the lines, by the base characters' share of it.
-/// A reading wider than its base hangs over the neighbours (`overhang`), or is squeezed to the
-/// base's width. Type on a path is left out (it has no above/below).
-fn ruby_layout(cx: &mut Ctx<'_>, t: &TextObject) {
- use std::collections::BTreeMap;
-
- let db = cx.db;
- let text_len = cx.text.len();
- let n_lines = cx.out.lines.len();
- if n_lines == 0 || cx.out.glyphs.is_empty() {
- return;
- }
- let base_baselines: Vec<f64> = cx.out.lines.iter().map(|l| l.baseline).collect();
- let old_ascent: Vec<f64> = cx.out.lines.iter().map(|l| l.ascent).collect();
- let old_descent: Vec<f64> = cx.out.lines.iter().map(|l| l.descent).collect();
- // One piece of base text on one line, with the part of the reading that belongs to it.
- struct Piece {
- line: usize,
- x0: f64,
- x1: f64,
- run: usize,
- byte: usize,
- reading: String,
- style: CharStyle,
- position: RubyPosition,
- align: RubyAlign,
- base_size: f64,
- overhang: bool,
- }
- let mut pieces: Vec<Piece> = Vec::new();
- // The glyphs by their byte, to find a span's without a scan of them all for each span.
- let byte_of = |i: usize| cx.out.glyphs.get(i).map_or(0, |g| g.byte);
- let mut by_byte: Vec<usize> = (0..cx.out.glyphs.len()).collect();
- by_byte.sort_by_key(|&i| byte_of(i));
- let longest = cx.out.glyphs.iter().map(|g| g.len.max(1)).max().unwrap_or(1);
- for span in &t.ruby {
- let (start, end) = (span.start.min(text_len), span.end.min(text_len));
- if start >= end || span.text.trim().is_empty() {
- continue;
- }
- // The base glyphs of the span, by line; a glyph's cluster is its byte range (`len`, or
- // one byte for generated glyphs). A list marker is not part of the base.
- let mut by_line: BTreeMap<usize, Vec<usize>> = BTreeMap::new();
- let hi = by_byte.partition_point(|&i| byte_of(i) < end);
- let lo = by_byte.partition_point(|&i| byte_of(i).saturating_add(longest) <= start).min(hi);
- let mut hits: Vec<usize> = by_byte.get(lo..hi).unwrap_or_default().to_vec();
- // In glyph order, as the scan found them.
- hits.sort_unstable();
- for i in hits {
- let Some(g) = cx.out.glyphs.get(i) else { continue };
- let b = g.byte.saturating_add(g.len.max(1));
- if g.byte < end && b > start && cx.out.marker_of(i).is_none() {
- by_line.entry(g.line).or_default().push(i);
- }
- }
- let total: usize = by_line.values().map(Vec::len).sum();
- if total == 0 {
- continue;
- }
- let reading: Vec<char> = span.text.trim().chars().collect();
- let ratio = span.safe_size_percent() / 100.0;
- // Split the reading by each line's share of the base glyphs: cumulative fractions keep
- // every character once and in order.
- let mut taken = 0;
- let mut done = 0;
- let lines: Vec<usize> = by_line.keys().copied().collect();
- for line in &lines {
- let count = by_line.get(line).map_or(0, Vec::len);
- done += count;
- let upto = if reading.is_empty() { 0 } else { (reading.len() * done / total).min(reading.len()) };
- let part: String = reading.get(taken.min(reading.len())..upto.min(reading.len())).unwrap_or_default().iter().collect();
- taken = upto;
- if part.is_empty() {
- continue;
- }
- let glyphs = by_line.get(line).map(Vec::as_slice).unwrap_or_default();
- let mut x0 = f64::INFINITY;
- let mut x1 = f64::NEG_INFINITY;
- let mut base_size: f64 = 0.0;
- let mut run = 0;
- let mut byte = start;
- for (j, &gi) in glyphs.iter().enumerate() {
- let Some(g) = cx.out.glyphs.get(gi) else { continue };
- x0 = x0.min(g.origin.x);
- x1 = x1.max(g.origin.x + g.advance);
- base_size = base_size.max(cx.style_at(g.byte).size);
- if j == 0 {
- run = g.run;
- byte = g.byte;
- }
- }
- if !(x0.is_finite() && x1.is_finite()) || base_size <= 0.0 {
- continue;
- }
- let mut style = cx.style_at(byte).clone();
- style.size = base_size * ratio;
- style.leading = None;
- style.baseline_shift = 0.0;
- style.tracking = 0.0;
- style.kerning = None;
- pieces.push(Piece {
- line: *line,
- x0,
- x1,
- run,
- byte,
- reading: part,
- style,
- position: span.position,
- align: span.align,
- base_size,
- overhang: span.overhang,
- });
- }
- }
- // Phase A: shape each reading, place it relative to the (unshifted) baseline, and note how
- // far above/below the baseline its ink reaches.
- let mut placed: Vec<(usize, Vec<PositionedGlyph>, f64, f64)> = Vec::new(); // (line, glyphs, ascent, descent)
- for piece in &pieces {
- let Some(baseline) = base_baselines.get(piece.line).copied() else { continue };
- let mini = TextObject::point(Point::ZERO, &piece.reading, piece.style.clone());
- let lay = layout(db, &mini);
- let Some(first_line) = lay.lines.first() else { continue };
- let mini_base = first_line.baseline;
- let mini_asc = first_line.ascent;
- let mini_desc = first_line.descent;
- let base_w = (piece.x1 - piece.x0).max(0.0);
- // Above: the reading's bottom sits on the base's em box top. Below: its top sits on the
- // base's em box bottom (the line's descent below the baseline).
- let ruby_y = if piece.position == RubyPosition::Above {
- baseline - piece.base_size - mini_desc
- } else {
- baseline + old_descent.get(piece.line).copied().unwrap_or(0.0) + mini_asc
- };
- let dest = |width: f64| match piece.align {
- RubyAlign::Center => piece.x0 + (base_w - width) * 0.5,
- RubyAlign::Start => piece.x0,
- RubyAlign::End => piece.x1 - width,
- };
- let mut glyphs: Vec<PositionedGlyph> = Vec::new();
- if cx.vertical {
- // Each reading character in its own cell along the column, upright once the lines turn.
- let cell = (mini_asc + mini_desc).max(piece.style.size * 0.5);
- let mut clusters: Vec<Vec<&PositionedGlyph>> = Vec::new();
- for g in &lay.glyphs {
- match clusters.last_mut() {
- Some(c) if c.last().is_some_and(|p| p.byte == g.byte && p.len == g.len) => c.push(g),
- _ => clusters.push(vec![g]),
- }
- }
- let mut ruby_w = clusters.len() as f64 * cell;
- let mut squeeze = 1.0;
- if !piece.overhang && ruby_w > base_w + EPS && ruby_w > EPS {
- squeeze = base_w / ruby_w;
- ruby_w = base_w;
- }
- let x = dest(ruby_w);
- for (ci, cluster) in clusters.iter().enumerate() {
- let anchor = Point::new(x + (ci as f64 + 0.5) * cell, ruby_y);
- let mut box_: Option<Rect> = None;
- for g in cluster {
- if g.outline.elements().is_empty() {
- continue;
- }
- let b = g.outline.bounding_box();
- box_ = Some(box_.map_or(b, |a| a.union(b)));
- }
- let centre = box_.map_or(anchor, |b| Point::new((b.x0 + b.x1) * 0.5, (b.y0 + b.y1) * 0.5));
- let mut m =
- Affine::rotate_about(-std::f64::consts::FRAC_PI_2, anchor) * Affine::translate((anchor.x - centre.x, anchor.y - centre.y));
- if squeeze != 1.0 {
- m = Affine::translate((x, 0.0)) * Affine::scale_non_uniform(squeeze, 1.0) * Affine::translate((-x, 0.0)) * m;
- }
- for g in cluster {
- glyphs.push(ruby_glyph(g, m, piece.run, piece.byte, piece.line));
- }
- }
- } else {
- // The reading set along the line: the line's extent, centred or aligned to the base.
- let mut ruby_w = (first_line.x1 - first_line.x0).max(0.0);
- let mut squeeze = 1.0;
- if !piece.overhang && ruby_w > base_w + EPS && ruby_w > EPS {
- squeeze = base_w / ruby_w;
- ruby_w = base_w;
- }
- let x = dest(ruby_w);
- let mut m = Affine::translate((x - first_line.x0, ruby_y - mini_base));
- if squeeze != 1.0 {
- m = Affine::translate((x, 0.0)) * Affine::scale_non_uniform(squeeze, 1.0) * Affine::translate((-x, 0.0)) * m;
- }
- for g in &lay.glyphs {
- glyphs.push(ruby_glyph(g, m, piece.run, piece.byte, piece.line));
- }
- }
- // How far the reading reaches above and below the base line's baseline (its ink).
- let mut ascent: f64 = 0.0;
- let mut descent: f64 = 0.0;
- for g in &glyphs {
- if g.outline.elements().is_empty() {
- continue;
- }
- let b = g.outline.bounding_box();
- ascent = ascent.max(baseline - b.y0);
- descent = descent.max(b.y1 - baseline);
- }
- if !glyphs.is_empty() {
- placed.push((piece.line, glyphs, ascent, descent));
- }
- }
- if placed.is_empty() {
- return;
- }
- // Phase B: grow each line's box to fit its ruby, then move the lines on after it by what they
- // need in the block direction (the first line too for area type, so the ruby stays inside the
- // frame; point type's first baseline is its anchor and stays).
- let mut growth = vec![0.0_f64; n_lines];
- for (line, _, ascent, descent) in &placed {
- if let (Some(a), Some(d)) = (old_ascent.get(*line), old_descent.get(*line)) {
- let grown = (a.max(*ascent) + d.max(*descent)) - (a + d);
- if grown > 0.0 {
- let g = growth.get_mut(*line);
- if let Some(slot) = g {
- *slot = slot.max(grown);
- }
- }
- }
- }
- // A line's ruby grows above it: the line moves on in the block direction by its own growth,
- // so the line before it keeps its room (for area type the first line moves too, keeping the
- // ruby inside the frame; point type's first baseline is its anchor and stays).
- let area = matches!(t.kind, TextKind::Area { .. });
- let mut shift = vec![0.0_f64; n_lines];
- let mut cum = 0.0;
- for i in 0..n_lines {
- if area || i > 0 {
- cum += growth.get(i).copied().unwrap_or(0.0);
- if let Some(s) = shift.get_mut(i) {
- *s = cum;
- }
- }
- }
- // Grow the lines' boxes to fit their ruby, then move them on in the block direction.
- for (line, _, ascent, descent) in &placed {
- if let Some(l) = cx.out.lines.get_mut(*line) {
- l.ascent = l.ascent.max(*ascent);
- l.descent = l.descent.max(*descent);
- }
- }
- for (i, line) in cx.out.lines.iter_mut().enumerate() {
- line.baseline += shift.get(i).copied().unwrap_or(0.0);
- }
- for g in &mut cx.out.glyphs {
- let s = shift.get(g.line).copied().unwrap_or(0.0);
- if s != 0.0 {
- g.origin.y += s;
- g.outline.apply_affine(Affine::translate((0.0, s)));
- g.xf = Affine::translate((0.0, s)) * g.xf;
- }
- }
- for (line, glyphs, _, _) in placed {
- let s = shift.get(line).copied().unwrap_or(0.0);
- for mut g in glyphs {
- if s != 0.0 {
- g.origin.y += s;
- g.outline.apply_affine(Affine::translate((0.0, s)));
- }
- g.line = line;
- cx.out.ruby.push(g);
- }
- }
-}
-
-/// A ruby glyph from one of a reading's laid-out glyphs, moved by `m` into the base text's line
-/// space. It is not a character of the text: `len` 0, the base text's `run` for fill and stroke.
-fn ruby_glyph(g: &PositionedGlyph, m: Affine, run: usize, byte: usize, line: usize) -> PositionedGlyph {
- PositionedGlyph {
- outline: m * g.outline.clone(),
- run,
- byte,
- origin: m * g.origin,
- advance: 0.0,
- len: 0,
- angle: 0.0,
- line,
- font_id: g.font_id,
- gid: g.gid,
- xf: Affine::IDENTITY,
- rtl: false,
- scale: 1.0,
- // Ruby draws outlines only.
- image: None,
- colour: None,
- bend: None,
- }
-}
diff --git a/crates/text/src/layout/bidi.rs b/crates/text/src/layout/bidi.rs
new file mode 100644
index 000000000..5512725a6
--- /dev/null
+++ b/crates/text/src/layout/bidi.rs
@@ -0,0 +1,108 @@
+use super::*;
+
+/// The bidirectional resolution (UAX #9) of paragraph `text`, its base direction `direction` or,
+/// without one, from its first strong character. `None` for the usual paragraph with nothing right
+/// to left in it (no right-to-left character or direction), which skips the algorithm.
+pub(crate) fn para_bidi(text: &str, direction: Option<ParaDirection>) -> Option<BidiInfo<'_>> {
+ use unicode_bidi::BidiClass::{AL, AN, FSI, R, RLE, RLI, RLO};
+ let rtl_set = direction == Some(ParaDirection::RightToLeft);
+ if !rtl_set && !text.chars().any(|c| matches!(unicode_bidi::bidi_class(c), R | AL | AN | RLE | RLO | RLI | FSI)) {
+ return None;
+ }
+ let level = direction.map(|d| if d == ParaDirection::RightToLeft { Level::rtl() } else { Level::ltr() });
+ Some(BidiInfo::new(text, level))
+}
+
+/// [`para_bidi`] for a paragraph whose characters in `set` (byte ranges of `text`, in order and not
+/// overlapping, from [`Ctx::char_directions`]) have a Character Direction: each range is resolved
+/// as a Unicode bidi embedding, as if an LRE or RLE stood before it and a PDF after it (UAX #9 X2,
+/// X3, X7). The levels, classes and paragraphs come back for the bytes of `text`. The paragraph's own
+/// direction is unchanged: the first strong character is found inside embeddings too (P2).
+pub(crate) fn para_bidi_with<'a>(text: &'a str, direction: Option<ParaDirection>, set: &[(Range<usize>, ParaDirection)]) -> Option<BidiInfo<'a>> {
+ let plain = para_bidi(text, direction);
+ if set.is_empty() || (plain.is_none() && set.iter().all(|(_, d)| *d == ParaDirection::LeftToRight)) {
+ // A left-to-right embedding in left-to-right text takes an even level: its order is the same.
+ return plain;
+ }
+ // The text with the embedding controls, and where each byte of `text` is in it.
+ let mut marked = String::with_capacity(text.len() + set.len() * 6);
+ let mut at_byte: Vec<usize> = Vec::with_capacity(text.len());
+ let mut copy = |marked: &mut String, from: usize, to: usize| {
+ if let Some(s) = text.get(from..to) {
+ at_byte.extend(marked.len()..marked.len() + s.len());
+ marked.push_str(s);
+ }
+ };
+ let mut done = 0;
+ for (r, d) in set {
+ let (a, b) = (r.start.max(done).min(text.len()), r.end.min(text.len()));
+ if a >= b {
+ continue;
+ }
+ copy(&mut marked, done, a);
+ marked.push(if *d == ParaDirection::RightToLeft { '\u{202B}' } else { '\u{202A}' });
+ copy(&mut marked, a, b);
+ marked.push('\u{202C}');
+ done = b;
+ }
+ copy(&mut marked, done, text.len());
+ let level = direction.map(|d| if d == ParaDirection::RightToLeft { Level::rtl() } else { Level::ltr() });
+ let info = BidiInfo::new(&marked, level);
+ let back = |i: usize| at_byte.partition_point(|&m| m < i);
+ let paragraphs =
+ info.paragraphs.iter().map(|p| unicode_bidi::ParagraphInfo { range: back(p.range.start)..back(p.range.end), level: p.level }).collect();
+ Some(BidiInfo {
+ text,
+ original_classes: at_byte.iter().filter_map(|&i| info.original_classes.get(i).copied()).collect(),
+ levels: at_byte.iter().filter_map(|&i| info.levels.get(i).copied()).collect(),
+ paragraphs,
+ })
+}
+
+/// Does the paragraph run right to left ([`para_bidi`])?
+pub(crate) fn is_rtl(bidi: Option<&BidiInfo<'_>>) -> bool {
+ bidi.and_then(|b| b.paragraphs.first()).is_some_and(|p| p.level.is_rtl())
+}
+
+/// The visual order of a line's `glyphs` (indices into them), whole shaping clusters reordered
+/// (UAX #9 L1–L2) for the line `line` (bytes of the text) of the paragraph starting at byte
+/// `paragraph_start`; their own order when nothing is right to left (`bidi` None).
+pub(super) fn visual_order(bidi: Option<&BidiInfo<'_>>, paragraph_start: usize, line: Range<usize>, glyphs: &[SGlyph]) -> Vec<usize> {
+ let Some((bidi, para)) = bidi.filter(|b| b.has_rtl()).and_then(|b| Some((b, b.paragraphs.first()?))) else {
+ return (0..glyphs.len()).collect();
+ };
+ if glyphs.is_empty() {
+ return vec![];
+ }
+ let levels = bidi.reordered_levels(para, line.start.saturating_sub(paragraph_start)..line.end.saturating_sub(paragraph_start));
+ // A list marker (length 0) is a cluster of its own.
+ let mut clusters: Vec<Range<usize>> = Vec::new();
+ for (i, g) in glyphs.iter().enumerate() {
+ if i > 0 && glyphs.get(i - 1).is_some_and(|p| p.byte == g.byte && (p.len == 0) == (g.len == 0)) {
+ if let Some(c) = clusters.last_mut() {
+ c.end = i + 1;
+ }
+ } else {
+ clusters.push(i..i + 1);
+ }
+ }
+ // A list marker is at the paragraph's level, and at a right-to-left one its tab is drawn
+ // before (left of) its characters.
+ let cluster_levels: Vec<_> = clusters
+ .iter()
+ .filter_map(|c| glyphs.get(c.start))
+ .map(|g| if g.len == 0 { g.level } else { levels.get(g.byte.saturating_sub(paragraph_start)).copied().unwrap_or(g.level) })
+ .collect();
+ let reversed = |i: usize| glyphs.get(clusters.get(i).map_or(0, |c| c.start)).is_some_and(|g| g.len == 0 && g.level.is_rtl());
+ unicode_bidi::BidiInfo::reorder_visual(&cluster_levels)
+ .into_iter()
+ .filter_map(|i| clusters.get(i).map(|c| (c.clone(), reversed(i))))
+ .flat_map(|(c, rev)| {
+ let mut v: Vec<usize> = c.collect();
+ if rev {
+ v.reverse();
+ }
+ v
+ })
+ .collect()
+}
diff --git a/crates/text/src/layout/breaking.rs b/crates/text/src/layout/breaking.rs
new file mode 100644
index 000000000..6dea3d9c6
--- /dev/null
+++ b/crates/text/src/layout/breaking.rs
@@ -0,0 +1,577 @@
+use super::region::Region;
+use super::*;
+
+/// Vertical metrics of a line: (ascent, descent, leading, cap height, x height).
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub(super) struct Metrics {
+ pub(super) asc: f64,
+ pub(super) desc: f64,
+ pub(super) lead: f64,
+ pub(super) cap: f64,
+ pub(super) xh: f64,
+ /// Height of the top of the ideographic em box above the baseline.
+ pub(super) top: f64,
+}
+
+impl Metrics {
+ pub(super) fn of(g: &SGlyph) -> Self {
+ let em = g.face.units_per_em() * g.sy;
+ Self { asc: g.ascent, desc: g.descent, lead: g.leading, cap: g.cap, xh: g.xh, top: (g.face.ideographic_centre() + 0.5) * em }
+ }
+ pub(super) fn max(g: &[SGlyph]) -> Option<Self> {
+ let mut it = g.iter();
+ let first = Self::of(it.next()?);
+ Some(it.fold(first, |m, g| Self {
+ asc: m.asc.max(g.ascent),
+ desc: m.desc.max(g.descent),
+ lead: m.lead.max(g.leading),
+ cap: m.cap.max(g.cap),
+ xh: m.xh.max(g.xh),
+ top: m.top.max(Self::of(g).top),
+ }))
+ }
+ /// Distance from the frame top to the first baseline.
+ pub(super) fn first_baseline(&self, fb: FirstBaseline, min: f64) -> f64 {
+ let v = match fb {
+ FirstBaseline::Ascent => self.asc,
+ FirstBaseline::CapHeight => self.cap,
+ FirstBaseline::XHeight => self.xh,
+ FirstBaseline::Leading => self.lead,
+ FirstBaseline::Fixed => 0.0,
+ };
+ v.max(min)
+ }
+}
+
+/// Where the next line goes: the region being filled and the previous baseline in it.
+#[derive(Clone)]
+pub(super) struct Pen<'r> {
+ pub(super) regions: Option<&'r [Region]>,
+ pub(super) ri: usize,
+ pub(super) prev: Option<f64>,
+ pub(super) pending: f64,
+ pub(super) fb: FirstBaseline,
+ pub(super) fb_min: f64,
+ /// Further spans at the current baseline (text wrapping on both sides of an object).
+ pub(super) queued: Vec<(f64, f64, f64)>,
+ /// Leading measured from em box top to em box top: where the next line's em box top goes.
+ pub(super) model: LeadingModel,
+ pub(super) next_top: Option<f64>,
+ /// The narrowest word no line from here down is wide enough for (see [`Pen::place`]).
+ pub(super) no_room_for: f64,
+}
+
+/// The largest number of steps layout takes to move a line down a frame cell to find room for it:
+/// in a cell taller than this many leads, a step is the cell's height divided by this.
+const MAX_STEPS: usize = 100_000;
+
+impl Pen<'_> {
+ /// Baseline and horizontal span for a line with estimated metrics `est` and indents that starts
+ /// with a word `word` wide; `None` = the frame is full (overflow).
+ /// In a frame that isn't a rectangle, lines too short for the word are left empty and it moves
+ /// down to the first one wide enough. Only when no line is does it go on the first line with
+ /// room for any text, and get broken there.
+ /// The `bool` is true for a further span at the previous line's baseline.
+ pub(super) fn place(&mut self, est: Metrics, ind_l: f64, ind_r: f64, word: f64) -> Option<(f64, f64, f64, bool)> {
+ if word > 0.0 && word < self.no_room_for {
+ let mut pen = self.clone();
+ if let Some(placed) = pen.place_at_least(est, ind_l, ind_r, word) {
+ *self = pen;
+ return Some(placed);
+ }
+ // Lines further down are no wider for this word: don't search for it, or a wider one, again.
+ self.no_room_for = word;
+ }
+ self.place_at_least(est, ind_l, ind_r, 0.0)
+ }
+
+ /// [`Pen::place`], skipping lines of a non-rectangular frame narrower than `min`.
+ fn place_at_least(&mut self, est: Metrics, ind_l: f64, ind_r: f64, min: f64) -> Option<(f64, f64, f64, bool)> {
+ let Some(regions) = self.regions else {
+ let b = self.prev.map_or(0.0, |b| self.next_baseline(b, est));
+ return Some((b, f64::NEG_INFINITY, f64::INFINITY, false));
+ };
+ if !self.queued.is_empty() {
+ let (b, x0, x1) = self.queued.remove(0);
+ return Some((b, x0, x1, true));
+ }
+ loop {
+ let r = regions.get(self.ri)?;
+ let mut baseline = match self.prev {
+ None if self.model == LeadingModel::EmBoxTop => r.top() + r.shift + est.top.max(self.fb_min),
+ None => r.top() + r.shift + est.first_baseline(self.fb, self.fb_min),
+ Some(b) => self.next_baseline(b, est) + r.gap,
+ };
+ // The baseline moves down the cell a lead at a time, or a `MAX_STEPS`th of the cell's
+ // height when that is more, in at most `MAX_STEPS` steps.
+ let step = est.lead.max(1.0).max(r.cell.height() / MAX_STEPS as f64);
+ for _ in 0..=MAX_STEPS {
+ if baseline + est.desc > r.bottom() + 0.01 {
+ break;
+ }
+ // A rectangle's lines are all as wide: none below has more room for the word
+ // (until wrap shapes can narrow the first baseline: they stay bounded).
+ let constant = (r.rect || r.polys.is_empty()) && r.wraps.is_empty();
+ let min = if constant { 0.0 } else { min };
+ let fits = |&(a, b): &(f64, f64)| {
+ let room = b - a - ind_l - ind_r;
+ room > est.asc.max(1.0) && room + EPS >= min
+ };
+ if r.wraps.is_empty() {
+ match r.span(baseline - est.asc, baseline + est.desc) {
+ Some(s) if fits(&s) => return Some((baseline, s.0, s.1, false)),
+ // Too narrow here is too narrow all the way down the cell: next cell.
+ Some(_) if constant => break,
+ _ => baseline += step,
+ }
+ } else {
+ // Wrap objects can split a line: fill every span, left to right.
+ let mut spans: Vec<(f64, f64)> = r.spans(baseline - est.asc, baseline + est.desc).into_iter().filter(fits).collect();
+ if spans.is_empty() {
+ baseline += step;
+ continue;
+ }
+ let (a, b) = spans.remove(0);
+ self.queued = spans.into_iter().map(|(a, b)| (baseline, a, b)).collect();
+ return Some((baseline, a, b, false));
+ }
+ }
+ // Next row/column.
+ self.ri += 1;
+ self.prev = None;
+ self.pending = 0.0;
+ self.queued.clear();
+ }
+ }
+ pub(super) fn bottom(&self) -> f64 {
+ self.regions.and_then(|r| r.get(self.ri)).map_or(f64::INFINITY, |r| r.bottom())
+ }
+ /// The baseline of the line after the one at `prev`, for a line of metrics `est`.
+ fn next_baseline(&self, prev: f64, est: Metrics) -> f64 {
+ match (self.model, self.next_top) {
+ (LeadingModel::EmBoxTop, Some(top)) => top + est.top + self.pending,
+ _ => prev + est.lead + self.pending,
+ }
+ }
+ /// A line was set at `baseline` with metrics `m`: where the next one goes from.
+ pub(super) fn settled(&mut self, baseline: f64, m: Metrics) {
+ self.prev = Some(baseline);
+ self.next_top = Some(baseline - m.top + m.lead);
+ }
+}
+
+/// Advance of a tab at pen position `x`: up to the next stop after it (explicit stops first, then
+/// every ½ inch), and the leader of that stop (default stops have none). Right, centre and decimal
+/// stops align the text that follows (`rest`, up to the next tab) on the stop.
+pub(super) fn tab_advance<'t>(tabs: &'t [vectorcraft_doc::TabStop], origin: f64, x: f64, rest: &[SGlyph]) -> (f64, &'t str) {
+ use vectorcraft_doc::TabAlign;
+ let rel = x - origin;
+ let seg: Vec<&SGlyph> = rest.iter().take_while(|g| g.ch != '\t').collect();
+ let width: f64 = seg.iter().map(|g| g.adv).sum();
+ let target = |pos: f64, align: TabAlign, on: char| match align {
+ TabAlign::Left => pos,
+ TabAlign::Right => pos - width,
+ TabAlign::Center => pos - width / 2.0,
+ TabAlign::Decimal => pos - seg.iter().take_while(|g| g.ch != on).map(|g| g.adv).sum::<f64>(),
+ };
+ let explicit = tabs.iter().find_map(|t| {
+ let at = target(t.position, t.align, t.align_on);
+ (at > rel + 1e-6).then_some((at, t.leader.as_str()))
+ });
+ let (at, leader) = explicit.unwrap_or_else(|| {
+ let last = tabs.iter().map(|t| t.position).fold(0.0, f64::max).max(0.0);
+ let base = rel.max(last);
+ (((base / vectorcraft_doc::text::DEFAULT_TAB_INTERVAL).floor() + 1.0) * vectorcraft_doc::text::DEFAULT_TAB_INTERVAL, "")
+ });
+ ((at - rel).max(0.0), leader)
+}
+
+/// The width of glyphs `from..to` of `sg` set on a line whose content starts `x_start` from the
+/// tab origin: tabs of the text take what [`tab_advance`] gives them, not the width of their
+/// glyph. The tab after a list marker (length 0) keeps its own width.
+pub(super) fn set_width(sg: &[SGlyph], from: usize, to: usize, tabs: &[vectorcraft_doc::TabStop], x_start: f64) -> f64 {
+ let mut x = x_start;
+ for (j, g) in sg.iter().enumerate().take(to).skip(from) {
+ x += if g.ch == '\t' && g.len > 0 { tab_advance(tabs, 0.0, x, sg.get(j + 1..to).unwrap_or_default()).0 } else { g.adv };
+ }
+ x - x_start
+}
+
+/// Most copies of a leader drawn in one tab: a tiny type size and a far stop must not make
+/// millions of outlines.
+const MAX_LEADER_COPIES: f64 = 4096.0;
+
+/// The outline of a tab leader: `leader`'s characters, in the font and size of tab `g`, repeated
+/// across the tab's gap `from..to` on baseline `y`. Copies sit on a grid of the leader's width
+/// from `origin` (where tab stops are measured from), so the leaders of lines above one another
+/// line up; only whole copies are drawn. Characters the font lacks draw nothing.
+pub(super) fn leader_outline(db: &FontDb, g: &SGlyph, leader: &str, origin: f64, from: f64, to: f64, y: f64) -> BezPath {
+ let mut out = BezPath::new();
+ let glyphs: Vec<(u32, f64)> = leader
+ .chars()
+ .filter(|c| !c.is_control())
+ .map(|c| {
+ let gid = g.face.glyph_for(c);
+ (gid, g.face.advance(gid) * g.sx)
+ })
+ .collect();
+ let width: f64 = glyphs.iter().map(|(_, a)| a).sum();
+ if !(width > EPS && width.is_finite() && from.is_finite() && to.is_finite()) {
+ return out;
+ }
+ let first = ((from - origin) / width - EPS).ceil();
+ let copies = (((to - origin) / width + EPS).floor() - first).clamp(0.0, MAX_LEADER_COPIES) as usize;
+ let local = Affine::rotate(-g.rotation.to_radians()) * Affine::translate((0.0, -g.bshift)) * Affine::scale_non_uniform(g.sx, g.sy);
+ for k in 0..copies {
+ let mut pen = origin + (first + k as f64) * width;
+ for &(gid, adv) in &glyphs {
+ if gid != 0 {
+ let m = Affine::translate((pen, y)) * local;
+ out.extend(db.outline(&g.face, gid).elements().iter().map(|el| m * *el));
+ }
+ pen += adv;
+ }
+ }
+ out
+}
+
+/// Width of the word starting at glyph `i`: its advances up to the first break opportunity (spaces
+/// left out, the hyphen of a soft hyphen in), the least room a line needs not to break inside it.
+/// A list marker at `i` (glyphs of length 0) counts whole, with the word after it.
+pub(super) fn word_width(g: &[SGlyph], i: usize) -> f64 {
+ /// Glyphs measured at most: a word wrapped over many lines is measured again from each line's
+ /// start, and one this long is broken inside whatever cell it meets.
+ const MAX_GLYPHS: usize = 1024;
+ let rest = g.get(i..).unwrap_or_default();
+ let marker = rest.iter().take_while(|gl| gl.len == 0).count();
+ let mut w: f64 = rest.iter().take(marker).map(|gl| gl.adv).sum();
+ for gl in rest.iter().skip(marker).take(MAX_GLYPHS) {
+ if gl.is_space() {
+ break;
+ }
+ if gl.is_soft_hyphen() {
+ return w + hyphen_glyph(gl).adv;
+ }
+ w += gl.adv;
+ if gl.break_after() {
+ break;
+ }
+ }
+ w
+}
+
+/// Greedy break: returns (end glyph index, hyphenated) for a line starting at `i` of `width`.
+/// With burasagari, a comma or full stop that doesn't fit ends the line, hanging outside it.
+/// `hyphenate` holds the paragraph's Hyphenation options and the Hyphenation Zone in force when
+/// the line may hyphenate a word; a line whose text before the overflowing word already ends
+/// within the zone breaks before that word. A tab is as wide as it is set: up to its next stop
+/// (`tabs`), with the line's content starting `x_start` from the tab origin.
+#[allow(clippy::too_many_arguments)]
+pub(super) fn break_line(
+ text: &str,
+ g: &[SGlyph],
+ i: usize,
+ width: f64,
+ tabs: &[vectorcraft_doc::TabStop],
+ x_start: f64,
+ hyphenate: Option<(&HyphenationOptions, f64)>,
+ burasagari: Burasagari,
+ kinsoku: Kinsoku,
+) -> (usize, bool) {
+ if !width.is_finite() {
+ return (g.len(), false);
+ }
+ let mut x = 0.0;
+ let mut last_break: Option<(usize, bool)> = None;
+ // A list marker (length 0) is a cluster of its own; the line holds it and at least the first
+ // cluster after it.
+ let first = i + g.get(i..).unwrap_or_default().iter().take_while(|h| h.len == 0).count();
+ let mut j = i;
+ while j < g.len() {
+ let gl = &g[j];
+ let mut cluster_end = j + 1;
+ while g.get(cluster_end).is_some_and(|next| next.byte == gl.byte && (next.len == 0) == (gl.len == 0)) {
+ cluster_end += 1;
+ }
+ // No Break: the marked characters stay on one line, including across a space inside the run.
+ if gl.no_break {
+ while let Some(n) = g.get(cluster_end) {
+ if !n.no_break {
+ break;
+ }
+ let b = n.byte;
+ cluster_end += 1;
+ while g.get(cluster_end).is_some_and(|next| next.byte == b) {
+ cluster_end += 1;
+ }
+ }
+ }
+ let cluster_width: f64 = if gl.ch == '\t' {
+ tab_advance(tabs, 0.0, x_start + x, g.get(cluster_end..).unwrap_or_default()).0
+ } else {
+ g[j..cluster_end].iter().map(|glyph| glyph.adv).sum()
+ };
+ if j > first && !gl.is_space() && x + cluster_width > width + EPS {
+ // It ends the line with the spaces after it.
+ if burasagari != Burasagari::None && hangs(gl) && kinsoku_allows(g, cluster_end - 1, kinsoku) {
+ let mut end = cluster_end;
+ while g.get(end).is_some_and(SGlyph::is_space) {
+ end += 1;
+ }
+ return (end, false);
+ }
+ break;
+ }
+ x += cluster_width;
+ let last = &g[cluster_end - 1];
+ if last.break_after() && last.len > 0 && kinsoku_allows(g, cluster_end - 1, kinsoku) && !splits_no_break(g, cluster_end) {
+ if last.is_soft_hyphen() {
+ if x + hyphen_glyph(last).adv <= width + EPS {
+ last_break = Some((cluster_end, true));
+ }
+ } else {
+ last_break = Some((cluster_end, false));
+ }
+ }
+ j = cluster_end;
+ }
+ if j >= g.len() {
+ return (g.len(), false);
+ }
+ // Hyphenate the word that overflows.
+ let word_start = last_break.map_or(i, |b| b.0);
+ let in_zone = |zone: f64| {
+ let mut te = word_start;
+ while te > i && g[te - 1].is_space() {
+ te -= 1;
+ }
+ te > i && zone > 0.0 && width - g[i..te].iter().map(|g| g.adv).sum::<f64>() <= zone + EPS
+ };
+ if let Some((opts, zone)) = hyphenate
+ && g[j].is_letter()
+ && !in_zone(zone)
+ {
+ let mut we = j;
+ while we < g.len() && !g[we].is_space() && !g[we].break_after() {
+ we += 1;
+ }
+ let x_ws: f64 = g[i..word_start].iter().map(|g| g.adv).sum();
+ let pts: Vec<usize> = hyphen_breaks(text, g, word_start, we, opts)
+ .into_iter()
+ .filter(|&k| k > 0 && kinsoku_allows(g, k - 1, kinsoku) && !splits_no_break(g, k))
+ .collect();
+ for &k in pts.iter().rev() {
+ if k <= j && k > i {
+ let w = x_ws + g[word_start..k].iter().map(|g| g.adv).sum::<f64>() + hyphen_glyph(&g[k - 1]).adv;
+ if w <= width + EPS {
+ return (k, true);
+ }
+ }
+ }
+ }
+ // Break candidates and greedy overflow are cluster boundaries; hyphenation also returns only
+ // cluster starts, so the resulting end always keeps each source cluster together.
+ let (end, hy) = match last_break {
+ Some(b) if b.0 > i => b,
+ _ => (j, false),
+ };
+ (end, hy)
+}
+
+/// Can glyph `g` hang outside the line (burasagari)? An East Asian comma or full stop, full width
+/// (、。,.) or half width (、。); not a closing bracket, nor Latin punctuation (Latin text keeps
+/// its line breaks and composer). Never an inline graphic (U+FFFC).
+pub(super) fn hangs(g: &SGlyph) -> bool {
+ g.inline.is_none() && matches!(g.ch, '、' | '。' | ',' | '.' | '、' | '。') && g.tcy.is_none()
+}
+
+/// Optical Margin Alignment: the share of glyph `g`'s advance that hangs outside the margin when
+/// `g` starts or ends a line. Quotation marks, hyphens, full stops and commas hang whole, and
+/// asterisks, tildes, ellipses, en and em dashes, colons and semicolons hang by half (the amounts
+/// published for Roman Hanging Punctuation). A, V, W, Y, v, w and y hang by a tenth of their
+/// advance, VectorCraft's own amount for their slanted sides. Other characters, East Asian
+/// punctuation (which burasagari hangs) and inline graphics don't hang.
+pub(super) fn optical_share(g: &SGlyph) -> f64 {
+ if g.inline.is_some() || g.tcy.is_some() {
+ return 0.0;
+ }
+ match g.ch {
+ '-' | '\u{2010}' | '\u{2011}' | '.' | ',' => 1.0,
+ c if is_quote(c) => 1.0,
+ '*' | '~' | '…' | '–' | '—' | ':' | ';' => 0.5,
+ 'A' | 'V' | 'W' | 'Y' | 'v' | 'w' | 'y' => 0.1,
+ _ => 0.0,
+ }
+}
+
+/// Roman Hanging Punctuation: the share of glyph `g`'s advance that hangs outside the margin when
+/// `g` starts or ends a line: [`optical_share`]'s punctuation, and no letters.
+pub(super) fn roman_share(g: &SGlyph) -> f64 {
+ if g.ch.is_alphabetic() { 0.0 } else { optical_share(g) }
+}
+
+/// A punctuation mark that hangs ([`optical_share`]), not a letter.
+pub(super) fn optical_punct(g: &SGlyph) -> bool {
+ !g.ch.is_alphabetic() && optical_share(g) > 0.0
+}
+
+/// A single or double quotation mark: straight, curly, low-9 or reversed-9.
+fn is_quote(c: char) -> bool {
+ matches!(c, '\'' | '"' | '‘' | '’' | '‚' | '‛' | '“' | '”' | '„' | '‟')
+}
+
+/// Optical Margin Alignment and Roman Hanging Punctuation: how far a line hangs outside its left
+/// and right margins, from the glyph at each end of `line` (its glyphs in visual order, each with
+/// the advance it is set with) and its `share` ([`optical_share`] or [`roman_share`]), and how many glyphs hang at each end → (left, right, left glyphs,
+/// right glyphs). A punctuation mark followed by a quotation mark hangs together with it: `."`
+/// ending a line and `'"` starting one hang both their glyphs. A line of one glyph hangs at
+/// neither end.
+pub(super) fn optical_hangs(line: &[(&SGlyph, f64)], share: fn(&SGlyph) -> f64) -> (f64, f64, usize, usize) {
+ let n = line.len();
+ if n < 2 {
+ return (0.0, 0.0, 0, 0);
+ }
+ let hang = |k: usize| line.get(k).map_or(0.0, |&(g, adv)| share(g) * adv.max(0.0));
+ let punct = |k: usize| line.get(k).is_some_and(|&(g, _)| optical_punct(g));
+ let quote = |k: usize| line.get(k).is_some_and(|&(g, _)| is_quote(g.ch) && share(g) > 0.0);
+ let mut left = hang(0);
+ // The glyphs that hang at the left; the right end takes none of them.
+ let mut taken = usize::from(left > 0.0);
+ if left > 0.0 && n > 2 && punct(0) && quote(1) {
+ left += hang(1);
+ taken = 2;
+ }
+ let mut right = hang(n - 1);
+ let mut right_glyphs = usize::from(right > 0.0);
+ if right > 0.0 && n > 2 && n - 2 >= taken && punct(n - 2) && quote(n - 1) {
+ right += hang(n - 2);
+ right_glyphs = 2;
+ }
+ (left, right, taken, right_glyphs)
+}
+
+/// Works as [`optical_hangs`] does for a right-to-left line, whose `line` is also in visual order.
+/// The line is read from right to left: `."` ending it hangs both its glyphs at the left, `'"` starting it hangs both at
+/// the right, and the right end takes its glyphs first.
+pub(super) fn optical_hangs_rtl(line: &[(&SGlyph, f64)], share: fn(&SGlyph) -> f64) -> (f64, f64, usize, usize) {
+ let reversed: Vec<(&SGlyph, f64)> = line.iter().rev().copied().collect();
+ let (right, left, right_glyphs, left_glyphs) = optical_hangs(&reversed, share);
+ (left, right, left_glyphs, right_glyphs)
+}
+
+/// Would a line ending at glyph index `end` split a No Break run?
+fn splits_no_break(g: &[SGlyph], end: usize) -> bool {
+ end > 0 && g.get(end - 1).is_some_and(|a| a.no_break) && g.get(end).is_some_and(|b| b.no_break)
+}
+
+/// Does kinsoku allow a line break after glyph `j`? Not after an opening bracket, nor before a
+/// closing one, a comma, a full stop, a small kana… (the character is pushed to the next line
+/// with the one before it).
+fn kinsoku_allows(g: &[SGlyph], j: usize, kinsoku: Kinsoku) -> bool {
+ g.get(j).is_some_and(|gl| kinsoku_between(gl.ch, g.get(j + 1).map(|n| n.ch), kinsoku))
+}
+
+/// Kinsoku for a break between `before` and `after` (none: the end of the paragraph): Hard keeps
+/// every character of the set off the line start and end, Soft lets 々, ー and small kana start a
+/// line, None allows the break.
+fn kinsoku_between(before: char, after: Option<char>, kinsoku: Kinsoku) -> bool {
+ match kinsoku {
+ Kinsoku::None => true,
+ Kinsoku::Hard => !no_line_end(before) && after.is_none_or(|c| !no_line_start(c)),
+ Kinsoku::Soft => !no_line_end(before) && after.is_none_or(|c| !no_line_start(c) || soft_line_start(c)),
+ }
+}
+
+#[cfg(test)]
+#[test]
+fn kinsoku_keeps_closing_marks_off_line_starts_and_opening_ones_off_line_ends() {
+ for (a, b) in [('字', '。'), ('弧', '」'), ('」', '、'), ('ャ', 'ー'), ('カ', 'ッ'), ('「', 'か'), ('(', '雅')] {
+ assert!(!kinsoku_between(a, Some(b), Kinsoku::Hard), "{a}{b}");
+ }
+ for (a, b) in [('。', '雅'), ('」', 'は'), ('字', '「'), ('の', '演')] {
+ assert!(kinsoku_between(a, Some(b), Kinsoku::Hard), "{a}{b}");
+ }
+ assert!(kinsoku_between('。', None, Kinsoku::Hard));
+}
+
+/// Soft kinsoku lets 々, ー and small kana (JLREQ cl-09's 々, cl-10, cl-11) start a line and keeps
+/// the rest of the set (half-width forms aren't in those classes); None allows any break.
+#[cfg(test)]
+#[test]
+fn soft_kinsoku_lets_small_kana_and_the_prolonged_sound_mark_start_a_line() {
+ for (a, b) in [('ャ', 'ー'), ('カ', 'ッ'), ('時', '々'), ('ト', 'ㇰ'), ('か', 'ゃ')] {
+ assert!(!kinsoku_between(a, Some(b), Kinsoku::Hard), "{a}{b}");
+ assert!(kinsoku_between(a, Some(b), Kinsoku::Soft), "{a}{b}");
+ }
+ for (a, b) in [('字', '。'), ('弧', '」'), ('「', 'か'), ('カ', 'ッ'), ('カ', 'ー'), ('字', 'ゝ')] {
+ assert!(!kinsoku_between(a, Some(b), Kinsoku::Soft), "{a}{b}");
+ assert!(kinsoku_between(a, Some(b), Kinsoku::None), "{a}{b}");
+ }
+}
+
+/// Glyph indices inside `g[ws..we]` (a word) where a hyphenated break may go under `opts`.
+fn hyphen_breaks(text: &str, g: &[SGlyph], ws: usize, we: usize, opts: &HyphenationOptions) -> Vec<usize> {
+ // Strip leading/trailing punctuation (quotes, commas).
+ let (mut a, mut b) = (ws, we);
+ while a < b && !g[a].is_letter() {
+ a += 1;
+ }
+ while b > a && !g[b - 1].is_letter() {
+ b -= 1;
+ }
+ if b <= a || g[a..b].iter().any(|g| !g.is_letter()) {
+ return vec![];
+ }
+ let (s, e) = (g[a].byte, g[b - 1].byte + g[b - 1].len);
+ let Some(word) = text.get(s..e) else { return vec![] };
+ let offs: Vec<usize> = word.char_indices().map(|(o, _)| s + o).collect();
+ // The first glyph of each cluster start (not inside a ligature), by its byte: one pass, not a
+ // search for each point.
+ let mut starts = std::collections::HashMap::new();
+ for k in a + 1..b {
+ if g[k].byte != g[k - 1].byte {
+ starts.entry(g[k].byte).or_insert(k);
+ }
+ }
+ hyphen_points_with(word, opts).into_iter().filter_map(|ci| starts.get(offs.get(ci)?).copied()).collect()
+}
+
+/// Break candidates for the every-line composer: hyphenation points under `hyphenate` (the
+/// paragraph's Hyphenation options) when it is given. No break comes before a space: a line that
+/// may end after a dash, a Thai word or a space ends after the spaces that follow it, as in
+/// [`break_line`].
+pub(super) fn candidates(text: &str, g: &[SGlyph], hyphenate: Option<&HyphenationOptions>, kinsoku: Kinsoku) -> Vec<Breakpoint> {
+ let mut v = vec![];
+ let mut ws = 0;
+ for (j, gl) in g.iter().enumerate() {
+ let end_of_word = gl.is_space() || gl.break_after();
+ if end_of_word {
+ if let Some(opts) = hyphenate
+ && j > ws
+ {
+ for k in
+ hyphen_breaks(text, g, ws, j, opts).into_iter().filter(|&k| k > 0 && kinsoku_allows(g, k - 1, kinsoku) && !splits_no_break(g, k))
+ {
+ v.push(Breakpoint { end: k, hyphen: hyphen_glyph(&g[k - 1]).adv });
+ }
+ }
+ let hy = if gl.is_soft_hyphen() { hyphen_glyph(gl).adv } else { 0.0 };
+ if j + 1 < g.len() && g[j + 1].byte != gl.byte && !g[j + 1].is_space() && kinsoku_allows(g, j, kinsoku) && !splits_no_break(g, j + 1) {
+ v.push(Breakpoint { end: j + 1, hyphen: hy });
+ }
+ ws = j + 1;
+ }
+ }
+ if let Some(opts) = hyphenate
+ && g.len() > ws
+ {
+ for k in
+ hyphen_breaks(text, g, ws, g.len(), opts).into_iter().filter(|&k| k > 0 && kinsoku_allows(g, k - 1, kinsoku) && !splits_no_break(g, k))
+ {
+ v.push(Breakpoint { end: k, hyphen: hyphen_glyph(&g[k - 1]).adv });
+ }
+ }
+ v.sort_by_key(|b| b.end);
+ v.dedup_by_key(|b| b.end);
+ v
+}
diff --git a/crates/text/src/layout/driver.rs b/crates/text/src/layout/driver.rs
new file mode 100644
index 000000000..2c8f74b0c
--- /dev/null
+++ b/crates/text/src/layout/driver.rs
@@ -0,0 +1,292 @@
+use super::flow::flow;
+use super::on_path::on_path;
+use super::region::Region;
+use super::ruby::ruby_layout;
+use super::vertical::{EM_CENTER, QUARTER_TURN, align_vertically, finish_bounds};
+use super::*;
+
+/// Lay out a text object into text-space glyph outlines (default [`LayoutOptions`]).
+pub fn layout(db: &FontDb, t: &TextObject) -> TextLayout {
+ let a = &t.area;
+ let opts = LayoutOptions {
+ rows: a.rows,
+ columns: a.columns,
+ gutter: a.gutter,
+ inset: a.inset,
+ first_baseline: a.first_baseline,
+ first_baseline_min: a.first_baseline_min,
+ vertical_align: a.vertical_align,
+ fit: a.fit,
+ ..LayoutOptions::default()
+ };
+ layout_with(db, t, &opts)
+}
+
+/// Area type in a frame too short for its first line draws nothing (type that doesn't fit its frame
+/// isn't drawn). For importers whose source shows that line: the frame is made taller, from its
+/// top, by what the first line needs. Whether it was.
+pub fn fit_first_line(db: &FontDb, t: &mut TextObject) -> bool {
+ let TextKind::Area { frame } = &t.kind else { return false };
+ let Some(b) = frame.bounds().filter(|b| b.height() > 1e-6) else { return false };
+ if !layout(db, t).lines.is_empty() {
+ return false;
+ }
+ // The height of its first line: the line's as point type.
+ let point = TextObject { kind: TextKind::Point, ..t.clone() };
+ let Some(need) = layout(db, &point).lines.first().map(|l| l.ascent + l.descent) else { return false };
+ // (A little more than it, for the rounding of the layout.)
+ let by = (need + 0.05) / b.height();
+ if !(by.is_finite() && by > 1.0) {
+ return false;
+ }
+ let taller = frame.transformed(Affine::translate((0.0, b.y0)) * Affine::scale_non_uniform(1.0, by) * Affine::translate((0.0, -b.y0)));
+ let short = std::mem::replace(&mut t.kind, TextKind::Area { frame: taller });
+ // Something else keeps the line out (a frame narrower than a letter): as the source has it.
+ if layout(db, t).lines.is_empty() {
+ t.kind = short;
+ return false;
+ }
+ true
+}
+
+/// The underline and strikethrough bars of `t` laid out as `layout` (#847): per run and line, a
+/// bar from the stretch's first glyph to its last one's advance, placed and sized by the font's
+/// own underline and strikeout metrics through the glyph's transform (so the size, baseline shift
+/// and scaling follow) → (run, bar in text space). Type on a path and vertical type have none yet.
+pub fn decorations(layout: &TextLayout, db: &FontDb, t: &TextObject) -> Vec<(usize, BezPath)> {
+ let mut out = vec![];
+ if layout.on_path || layout.vertical {
+ return out;
+ }
+ let glyphs = &layout.glyphs;
+ let mut i = 0;
+ while let Some(g) = glyphs.get(i) {
+ // The stretch: the glyphs of this run on this line, in a row. A list marker has no
+ // underline or strikethrough.
+ let marker = layout.marker_of(i).is_some();
+ let end = glyphs
+ .iter()
+ .enumerate()
+ .skip(i)
+ .position(|(k, h)| h.run != g.run || h.line != g.line || layout.marker_of(k).is_some() != marker)
+ .map_or(glyphs.len(), |n| i + n);
+ let stretch = glyphs.get(i..end).unwrap_or_default();
+ i = end.max(i + 1);
+ if marker {
+ continue;
+ }
+ let Some(style) = t.runs.get(g.run).map(|r| &r.style) else { continue };
+ if !(style.underline || style.strikethrough) {
+ continue;
+ }
+ let Some(face) = db.face_by_id(g.font_id) else { continue };
+ let (x0, x1) = stretch.iter().fold((f64::INFINITY, f64::NEG_INFINITY), |(a, b), h| {
+ let (s, e) = (h.origin.x, h.origin.x + h.advance);
+ (a.min(s).min(e), b.max(s).max(e))
+ });
+ for (on, (offset, thickness)) in [(style.underline, face.underline), (style.strikethrough, face.strikeout)] {
+ if !on {
+ continue;
+ }
+ // Font units run y down in the glyph's transform: the bar's top is at -offset.
+ let (top, bottom) = ((g.xf * Point::new(0.0, -offset)).y, (g.xf * Point::new(0.0, -offset + thickness)).y);
+ let bar = Rect::new(x0, top.min(bottom), x1, top.max(bottom));
+ if bar.width() > 0.0 && bar.height() > 0.0 && bar.width().is_finite() && bar.height().is_finite() {
+ out.push((g.run, bar.to_path(0.1)));
+ }
+ }
+ }
+ out
+}
+
+/// Most layout passes Shrink Text to Fit runs past the first (bisection plus the final pass).
+const SHRINK_PASSES: usize = 11;
+
+/// Lay out a text object with explicit options (area type rows/columns, inset, first baseline,
+/// fit, composer, OpenType features).
+pub fn layout_with(db: &FontDb, t: &TextObject, opts: &LayoutOptions) -> TextLayout {
+ let first = layout_once(db, t, opts);
+ match (opts.fit.min_scale(), &t.kind) {
+ (Some(min), TextKind::Area { .. }) if first.overflow => shrink_to_fit(db, t, opts, min).unwrap_or(first),
+ _ => first,
+ }
+}
+
+/// Shrink Text to Fit for text that overflows at full size: the largest scale in `min..1` at which
+/// it fits, searched by bisection over the first run's document size in steps of 0.1 pt (so its scaled size
+/// is a whole number of tenths of a point, the same every time). Down at `min` it lays out there,
+/// still overflowing. None (keep the full-size layout) when the text has no usable size.
+fn shrink_to_fit(db: &FontDb, t: &TextObject, opts: &LayoutOptions, min: f64) -> Option<TextLayout> {
+ // Exact size edits after object scaling may store a local size below 0.1. Fit in the
+ // same document points as the Character controls, independent of that representation.
+ let points = t.style_scale()?.points;
+ let size = t.runs.first().map(|r| r.style.size * points).filter(|s| s.is_finite() && *s >= 0.1)?;
+ if !(min.is_finite() && min < 1.0) {
+ return None;
+ }
+ let tenths = size * 10.0;
+ if !tenths.is_finite() {
+ return None;
+ }
+ // Candidate sizes k/10 pt for k in lo..hi: `hi` (full size, rounded down) is known to overflow
+ // unless it is below the full size; `lo` is the smallest allowed.
+ let mut lo = (tenths * min).ceil().max(1.0);
+ let mut hi = tenths.floor();
+ if hi < lo {
+ hi = lo;
+ }
+ let at = |k: f64| -> TextLayout {
+ let f = (k / tenths).clamp(min, 1.0);
+ let mut l = layout_once(db, &scaled(t, f), opts);
+ l.fit_scale = f;
+ l
+ };
+ let mut passes = 0;
+ let mut best: Option<TextLayout> = None;
+ // `hi` itself may fit when the size isn't a whole number of tenths.
+ if hi < tenths && hi > lo {
+ let l = at(hi);
+ passes += 1;
+ if !l.overflow {
+ return Some(l);
+ }
+ }
+ // Invariant: everything at `hi` or above overflows; `lo` fits or is the floor.
+ while hi - lo > 1.0 && passes + 1 < SHRINK_PASSES {
+ let mid = (lo + (hi - lo) * 0.5).floor();
+ let l = at(mid);
+ passes += 1;
+ if l.overflow {
+ hi = mid;
+ } else {
+ lo = mid;
+ best = Some(l);
+ }
+ }
+ // `best` is the layout at `lo` once `lo` has moved; at the floor it still needs laying out.
+ Some(best.unwrap_or_else(|| at(lo)))
+}
+
+/// `t` with every run's size, explicit leading and baseline shift scaled by `f`, inline art's own
+/// shift included (auto leading and the art's size follow the size; paragraph spacing stays).
+/// Shrink Text to Fit lays `t` out as `scaled(t, f)`, where `f` is the layout's
+/// [`TextLayout::fit_scale`], so the result holds the styles the text is drawn in.
+pub fn scaled(t: &TextObject, f: f64) -> TextObject {
+ let mut s = t.clone();
+ for r in &mut s.runs {
+ r.style.size *= f;
+ r.style.leading = r.style.leading.map(|l| l * f);
+ r.style.baseline_shift *= f;
+ if let Some(a) = &mut r.inline {
+ a.baseline_shift *= f;
+ }
+ }
+ s
+}
+
+/// One layout pass, without fitting.
+fn layout_once(db: &FontDb, t: &TextObject, opts: &LayoutOptions) -> TextLayout {
+ let text = t.plain_text();
+ let mut runs = Vec::with_capacity(t.runs.len());
+ let mut inlines = Vec::with_capacity(t.runs.len());
+ let mut off = 0;
+ for r in &t.runs {
+ runs.push((off..off + r.text.len(), &r.style));
+ // Only a well-formed inline run (one object replacement character) is a graphic.
+ inlines.push(r.inline.as_ref().filter(|_| crate::edit::is_inline_text(&r.text)));
+ off += r.text.len();
+ }
+ let mut paras = Vec::new();
+ let mut s = 0;
+ for (i, c) in text.char_indices() {
+ if c == '\n' {
+ paras.push(s..i);
+ s = i + 1;
+ }
+ }
+ paras.push(s..text.len());
+ let vertical = t.vertical;
+ let is_on_path = matches!(&t.kind, TextKind::OnPath { .. });
+ let vopts;
+ let opts = if vertical {
+ vopts = LayoutOptions { features: OtFeatures { vertical: true, ..opts.features }, ..opts.clone() };
+ &vopts
+ } else {
+ opts
+ };
+ let mut cx = Ctx {
+ on_path: is_on_path,
+ db,
+ text: &text,
+ runs,
+ inlines,
+ default: CharStyle::default(),
+ opts,
+ vertical,
+ system_layout: t.system_layout,
+ fractional_widths: t.fractional_widths,
+ out: TextLayout::default(),
+ };
+ // Vertical type: line space turned a quarter turn clockwise (lines become columns, each next
+ // one to the left). Point type's anchor is on the first column's centre line. Vertical path
+ // type stays on its path (each glyph turned across it in `emit`).
+ let line_xf = match &t.kind {
+ _ if !vertical => Affine::IDENTITY,
+ TextKind::OnPath { .. } => Affine::IDENTITY,
+ TextKind::Point => {
+ let first = cx.style_at(0);
+ let centre = db.style_face(first).map_or(EM_CENTER, |f| f.ideographic_centre());
+ Affine::translate((-centre * first.size, 0.0)) * QUARTER_TURN
+ }
+ _ => QUARTER_TURN,
+ };
+ match &t.kind {
+ TextKind::Point => flow(&mut cx, &paras, t, None),
+ TextKind::Area { frame } => {
+ let to_lines = line_xf.inverse();
+ let wrap: Vec<vectorcraft_doc::WrapShape> = if vertical {
+ t.wrap.iter().map(|w| vectorcraft_doc::WrapShape { path: w.path.transformed(to_lines), ..w.clone() }).collect()
+ } else {
+ t.wrap.clone()
+ };
+ let mut regions = Region::cells(&(to_lines * frame.to_bezpath()), opts, &wrap);
+ cx.out.frames = regions.iter().map(|r| line_xf.transform_rect_bbox(r.cell)).collect();
+ flow(&mut cx, &paras, t, Some(&regions));
+ if opts.vertical_align != VerticalAlign::Top {
+ align_vertically(&mut cx, &paras, t, &mut regions);
+ }
+ }
+ TextKind::OnPath { path, .. } => on_path(&mut cx, &paras, t, path),
+ }
+ // Ruby (furigana): placed over its base text in line space, before vertical type turns the
+ // lines into columns, so the same pass puts it above (right in vertical type) and widens the
+ // lines it sits on. Type on a path has no above/below; its ruby is left out for now.
+ if !is_on_path && !t.ruby.is_empty() {
+ ruby_layout(&mut cx, t);
+ }
+ if vertical && !is_on_path {
+ // Glyph origins, outlines and transforms to text space (lines stay in line space).
+ for g in &mut cx.out.glyphs {
+ g.outline.apply_affine(line_xf);
+ g.xf = line_xf * g.xf;
+ g.origin = line_xf * g.origin;
+ g.angle += std::f64::consts::FRAC_PI_2;
+ }
+ // Ruby glyphs are placed in line space too (upright, along the column, in the vertical
+ // pass); the same turn takes them to text space.
+ for g in &mut cx.out.ruby {
+ g.outline.apply_affine(line_xf);
+ g.xf = line_xf * g.xf;
+ g.origin = line_xf * g.origin;
+ g.angle += std::f64::consts::FRAC_PI_2;
+ }
+ for i in &mut cx.out.inlines {
+ i.xf = line_xf * i.xf;
+ i.bounds = line_xf.transform_rect_bbox(i.bounds);
+ }
+ cx.out.vertical = true;
+ cx.out.line_xf = line_xf;
+ }
+ finish_bounds(&mut cx.out);
+ cx.out
+}
diff --git a/crates/text/src/layout/flow.rs b/crates/text/src/layout/flow.rs
new file mode 100644
index 000000000..b923328f7
--- /dev/null
+++ b/crates/text/src/layout/flow.rs
@@ -0,0 +1,580 @@
+use super::bidi::{is_rtl, para_bidi_with, visual_order};
+use super::breaking::{
+ Metrics, Pen, break_line, candidates, hangs, leader_outline, optical_hangs, optical_hangs_rtl, optical_punct, optical_share, roman_share,
+ set_width, tab_advance, word_width,
+};
+use super::region::Region;
+use super::vertical::{EM_CENTER, align_shift, compress_punctuation, glyph_em, punct_half, space_japanese_and_latin};
+use super::*;
+
+/// Paragraphs longer than this (glyphs) are always broken line by line.
+const MAX_COMPOSE_GLYPHS: usize = 200_000;
+
+/// Every-line composition of paragraph glyphs `sg` if applicable (area text, justified or ragged,
+/// with uniform line metrics or in rectangular cells without text wrap); `None` falls back to the
+/// greedy single-line composer. With `continued`, the paragraph continues from the frame before,
+/// and its first composed line is not its first line.
+fn compose_para(
+ cx: &Ctx<'_>,
+ sg: &[SGlyph],
+ flex: &[Flex],
+ para: &ParaStyle,
+ pen: &Pen<'_>,
+ rtl: bool,
+ continued: bool,
+) -> Option<Vec<(usize, bool)>> {
+ let ragged = matches!(para.justify, Justify::Auto | Justify::Left | Justify::Center | Justify::Right);
+ let composer = cx.opts.composer.unwrap_or(para.composer);
+ // A paragraph whose commas or full stops may hang is composed line by line (as the Japanese
+ // single-line composer does).
+ let may_hang = para.burasagari != Burasagari::None && sg.iter().any(hangs);
+ // A tab's width depends on where it falls in its line, which the composer's fixed glyph widths
+ // can't follow: such a paragraph is broken line by line ([`break_line`] measures its tabs).
+ // The tab after a list marker always starts the first line and has a fixed width.
+ let has_tab = sg.iter().any(|g| g.ch == '\t' && g.len > 0);
+ if composer != Composer::EveryLine || pen.regions.is_none() || sg.len() < 2 || sg.len() > MAX_COMPOSE_GLYPHS || may_hang || has_tab {
+ return None;
+ }
+ let m = Metrics::of(&sg[0]);
+ // Line widths are independent of the breaks when every line has the same metrics, or when
+ // a line's width does not depend on how far down the frame it is set: rectangular cells
+ // without text wrap. Then a paragraph whose characters differ in line metrics (type size,
+ // font, leading, vertical scale, an inline graphic taller than the text) is composed too. In
+ // other shapes, or with text wrap, a taller line can move the lines below it to where the
+ // frame is narrower, so such a paragraph is broken line by line.
+ let plain = pen.regions.is_some_and(|r| r.iter().all(|r| (r.rect || r.polys.is_empty()) && r.wraps.is_empty()));
+ if !plain && sg.iter().any(|g| Metrics::of(g) != m) {
+ return None;
+ }
+ let total: f64 = sg.iter().map(|g| g.adv).sum();
+ let mut sim = pen.clone();
+ let mut widths = vec![];
+ let mut acc = 0.0;
+ // A line's width and placement depend on the sum of its indents alone, which the mirrored
+ // indents of a right-to-left list ([`line_indents`]) keep.
+ while widths.len() < sg.len() {
+ let first = widths.is_empty();
+ let ind_l = para.left_indent + if first && !continued { para.first_line_indent } else { 0.0 };
+ // Only the first line's first word is known here. Later lines are placed as the composed
+ // lines need: each fits its width, so its first word does too.
+ let word = if first { word_width(sg, 0) } else { 0.0 };
+ let Some((b, x0, x1, _)) = sim.place(m, ind_l, para.right_indent, word) else { break };
+ let w = x1 - x0 - ind_l - para.right_indent;
+ widths.push(w);
+ acc += w.max(1.0);
+ sim.settled(b, m);
+ sim.pending = 0.0;
+ if acc > total * 1.6 + 4.0 * w.max(1.0) {
+ break;
+ }
+ }
+ let last = *widths.last()?;
+ let width = |k: usize| widths.get(k).copied().unwrap_or(last);
+ // Lines from `uniform_from` on are interchangeable (same width).
+ let uniform_from = widths.iter().rposition(|&w| (w - last).abs() > EPS).map_or(0, |k| k + 1);
+ let cands = candidates(cx.text, sg, para.hyphenate.then_some(&para.hyphenation), para.kinsoku);
+ let justify_last = para.justify == Justify::JustifyAll;
+ let hyphen_limit = usize::try_from(para.hyphenation.hyphen_limit).unwrap_or(usize::MAX);
+ let params = |tolerance| Params { justify_last, ragged, tolerance, uniform_from, hyphen_limit };
+ // First look for breaks that keep every line within its range (ragged: at most one rag zone,
+ // a sixth of the width, left on each line; justified: the Justification options' Minimum and
+ // Maximum), then accept any lines that fit, the loosest scored worst. Justified text used to
+ // stop at four times its stretch and fall back to the single-line composer; the documented
+ // default range (word spacing up to 133%) is narrow enough that most paragraphs would.
+ let (strict, loose) = (1.0, f64::INFINITY);
+ // The same rule as the line loop below: an opening bracket starting a wrapped line gives up
+ // the space before it.
+ let start_credit = |i: usize| {
+ let flush = !rtl && para.mojikumi == Mojikumi::LineEndHalf;
+ sg.get(i).filter(|g| flush && g.lead <= 0.0).and_then(|g| punct_half(g, Punct::Opening)).unwrap_or(0.0)
+ };
+ compose(sg, &width, &start_credit, &cands, flex, &params(strict)).or_else(|| compose(sg, &width, &start_credit, &cands, flex, &params(loose)))
+}
+
+/// The list marker of each of the paragraphs `paras` of `t` (None for none): bullets, and numbers
+/// counted through consecutive list paragraphs from [`TextObject::list_count`], as
+/// [`vectorcraft_doc::text::ParaList::next_marker`] counts them.
+pub(super) fn list_markers(t: &TextObject, paras: &[Range<usize>]) -> Vec<Option<String>> {
+ let mut count = t.list_count;
+ paras.iter().enumerate().map(|(pi, pr)| vectorcraft_doc::text::ParaList::next_marker(t.para_at(pi).list, pr.is_empty(), &mut count)).collect()
+}
+
+/// Whether paragraph `para` (right to left when `rtl`) has its indents mirrored: a horizontal
+/// right-to-left list paragraph does.
+fn mirrors_indents(para: &ParaStyle, rtl: bool, vertical: bool) -> bool {
+ rtl && !vertical && para.list.is_some()
+}
+
+/// The indents at the left and at the right of a line of paragraph `para` (its first line when
+/// `first`). With `mirror` ([`mirrors_indents`]) the left and first-line indents are measured from
+/// the right and the right indent from the left: the bullet of a right-to-left list hangs at the
+/// right, and the lines it wraps to line up with the text after the bullet.
+fn line_indents(para: &ParaStyle, first: bool, mirror: bool) -> (f64, f64) {
+ let start = para.left_indent + if first { para.first_line_indent } else { 0.0 };
+ if mirror { (para.right_indent, start) } else { (start, para.right_indent) }
+}
+
+/// Flow paragraphs `paras` (byte ranges) of `t`, each with its own paragraph attributes
+/// (alignment, indents, spacing, direction, mojikumi, leading model…).
+pub(super) fn flow(cx: &mut Ctx<'_>, paras: &[Range<usize>], t: &TextObject, regions: Option<&[Region]>) {
+ let mut pen = Pen {
+ regions,
+ ri: 0,
+ prev: None,
+ pending: 0.0,
+ fb: cx.opts.first_baseline,
+ fb_min: cx.opts.first_baseline_min,
+ queued: vec![],
+ model: t.para_at(0).leading_model,
+ next_top: None,
+ no_room_for: f64::INFINITY,
+ };
+ let markers = list_markers(t, paras);
+ 'paras: for (pi, pr) in paras.iter().enumerate() {
+ let para = t.para_at(pi);
+ let marker_text = markers.get(pi).and_then(Option::as_deref);
+ // The leading model is a paragraph attribute: this paragraph's lines (and the space to
+ // its first line) follow its own.
+ pen.model = para.leading_model;
+ let text = cx.text;
+ let bidi = para_bidi_with(text.get(pr.clone()).unwrap_or_default(), para.direction, &cx.char_directions(pr));
+ let rtl = is_rtl(bidi.as_ref());
+ let mut sg = cx.shape_para(pr.clone(), bidi.as_ref());
+ // Thai, Lao, Khmer and Myanmar break lines between words, not at spaces.
+ mark_word_ends(text.get(pr.clone()).unwrap_or_default(), pr.start, &mut sg);
+ // Japanese composition: consecutive punctuation shares one half-em space.
+ let mut compressed = if para.mojikumi == Mojikumi::LineEndHalf { compress_punctuation(&mut sg) } else { vec![] };
+ // …and a quarter em between Japanese and Latin text.
+ let mut wakan = if para.mojikumi == Mojikumi::LineEndHalf { space_japanese_and_latin(&mut sg) } else { vec![] };
+ // Justification…: the glyphs at Desired word and letter spacing and glyph scaling, and how
+ // far a justified line may move each one from it.
+ let mut flex = apply_desired(&mut sg, &para.justification, !cx.vertical);
+ // Threaded text: a first paragraph that continues from the frame before has its first
+ // line, first-line indent and list marker there.
+ let continued = pi == 0 && t.first_para_continues;
+ // Bullets and numbers: the list marker's glyphs `0..marker` start the paragraph.
+ // Justification and Optical Margin Alignment leave them as they are.
+ let marker = if continued { 0 } else { cx.prepend_marker(pr, para, marker_text, rtl, &mut sg) };
+ if marker > 0 {
+ flex.splice(0..0, vec![Flex::default(); marker]);
+ if !compressed.is_empty() {
+ compressed.splice(0..0, vec![false; marker]);
+ }
+ if !wakan.is_empty() {
+ wakan.splice(0..0, vec![0.0; marker]);
+ }
+ }
+ // …and Auto Leading: characters whose leading is Auto take this paragraph's share of their size.
+ let auto_leading = |st: &CharStyle| st.leading.unwrap_or_else(|| para.justification.auto_leading_for(st.size));
+ if para.justification.auto_leading != vectorcraft_doc::JustificationOptions::default().auto_leading {
+ for g in sg.iter_mut().filter(|g| g.inline.is_none()) {
+ g.leading = auto_leading(cx.style_at(g.byte));
+ }
+ }
+ let pm = {
+ let (asc, desc, _) = style_metrics(cx.db, cx.style_at(pr.start));
+ let lead = auto_leading(cx.style_at(pr.start));
+ let st = cx.style_at(pr.start);
+ let (cap, xh) = cap_x_heights(cx.db, st);
+ let centre = cx.db.style_face(st).map_or(EM_CENTER, |f| f.ideographic_centre());
+ Metrics { asc, desc, lead, cap, xh, top: (centre + 0.5) * st.size * st.v_scale / 100.0 }
+ };
+ if pi > 0 {
+ pen.pending += para.space_before;
+ }
+ let n = sg.len();
+ let composed = compose_para(cx, &sg, &flex, para, &pen, rtl, continued);
+ // Hyphenation options: the Hyphenation Zone applies with the Single-line Composer, and the
+ // Hyphen Limit counts the lines in a row that end with a hyphen.
+ let zone = if cx.opts.composer.unwrap_or(para.composer) == Composer::SingleLine { para.hyphenation.zone } else { 0.0 };
+ let hyphen_limit = usize::try_from(para.hyphenation.hyphen_limit).unwrap_or(usize::MAX);
+ let mut hyphen_run = 0;
+ let mut li_para = 0;
+ let mut i = 0;
+ let mirror = mirrors_indents(para, rtl, cx.vertical);
+ loop {
+ let est = if i < n { Metrics::of(&sg[i]) } else { pm };
+ let first_line = li_para == 0 && !continued;
+ let (ind_l, ind_r) = line_indents(para, first_line, mirror);
+ // Measured before Mojikumi narrows an opening bracket, as the composer measures it.
+ let word = word_width(&sg, i);
+ // Mojikumi: an opening bracket starting a line is set flush with the line's start (the
+ // space before it goes), and the line has that much more room. At a paragraph's start
+ // that is the first-line indent: JIS X 4051's principle (JLREQ 3.1.5, Figure 71 ①).
+ if !rtl
+ && para.mojikumi == Mojikumi::LineEndHalf
+ && let Some(g) = sg.get_mut(i)
+ && g.lead <= 0.0
+ && let Some(h) = punct_half(g, Punct::Opening)
+ {
+ g.adv -= h;
+ g.lead += h;
+ }
+ // Place, break, then settle the baseline on the line's real metrics (moving on to the
+ // next row/column if it no longer fits).
+ let (baseline, x0, x1, end, hyph, m) = loop {
+ let first_in_region = pen.prev.is_none();
+ let Some((mut baseline, x0, x1, same_baseline)) = pen.place(est, ind_l, ind_r, word) else {
+ cx.out.overflow = cx.text.len() > if i < n { sg[i].byte } else { pr.start };
+ break 'paras;
+ };
+ let width = x1 - x0 - ind_l - ind_r;
+ let hyphenate = (para.hyphenate && (hyphen_limit == 0 || hyphen_run < hyphen_limit)).then_some((&para.hyphenation, zone));
+ let (end, hyph) = match composed.as_ref().and_then(|c| c.get(li_para)) {
+ Some(&(e, h)) if e > i => (e, h),
+ _ if i < n => break_line(cx.text, &sg, i, width, &para.tabs, ind_l, hyphenate, para.burasagari, para.kinsoku),
+ _ => (n, false),
+ };
+ let m = Metrics::max(&sg[i..end]).unwrap_or(pm);
+ baseline += if same_baseline || (pen.regions.is_none() && first_in_region) {
+ 0.0
+ } else if pen.model == LeadingModel::EmBoxTop {
+ // The em box top is fixed (the frame's top, or the line above's): the baseline
+ // hangs from it by this line's tallest em box.
+ if first_in_region { m.top.max(pen.fb_min) - est.top.max(pen.fb_min) } else { m.top - est.top }
+ } else if first_in_region {
+ m.first_baseline(pen.fb, pen.fb_min) - est.first_baseline(pen.fb, pen.fb_min)
+ } else {
+ m.lead - est.lead
+ };
+ if pen.regions.is_some() && baseline + m.desc > pen.bottom() + 0.01 {
+ // Try the next row/column; overflow if there is none.
+ pen.ri += 1;
+ pen.prev = None;
+ pen.pending = 0.0;
+ pen.queued.clear();
+ continue;
+ }
+ break (baseline, x0, x1, end, hyph, m);
+ };
+ hyphen_run = if hyph && end > i { hyphen_run + 1 } else { 0 };
+ let (ax0, ax1) = if regions.is_some() { (x0 + ind_l, x1 - ind_r) } else { (x0, x1) };
+ let width = ax1 - ax0;
+ pen.pending = 0.0;
+ let last_of_para = end >= n;
+ let mut trimmed = end;
+ while trimmed > i && sg[trimmed - 1].is_space() {
+ trimmed -= 1;
+ }
+ let hyphen = (hyph && end > i).then(|| hyphen_glyph(&sg[end - 1]));
+ // Mojikumi: a closing bracket, comma or full stop ending the line is set half width, and
+ // no Japanese–Latin space is left at the end of a line.
+ let end_trim = match trimmed.checked_sub(1).filter(|&k| k >= i && para.mojikumi == Mojikumi::LineEndHalf) {
+ Some(k) => {
+ let half = if compressed.get(k).copied().unwrap_or(false) { None } else { sg.get(k).and_then(|g| punct_half(g, Punct::Closing)) };
+ half.unwrap_or(0.0) + wakan.get(k).copied().unwrap_or(0.0)
+ }
+ None => 0.0,
+ };
+ let w: f64 = set_width(&sg, i, trimmed, &para.tabs, ind_l) + hyphen.as_ref().map_or(0.0, |h| h.adv) - end_trim;
+ let line_start = sg.get(i).map_or(pr.start, |g| g.byte);
+ let line_end = sg.get(end).map_or(pr.end, |g| g.byte);
+ let order = visual_order(bidi.as_ref().filter(|_| !cx.vertical), pr.start, line_start..line_end, &sg[i..end]);
+ // Optical Margin Alignment or Roman Hanging Punctuation: the share of a glyph that hangs.
+ let share: Option<fn(&SGlyph) -> f64> =
+ (t.optical_margin || para.roman_hanging).then_some(if t.optical_margin { optical_share } else { roman_share });
+ // The glyphs before `stop` in visual order, each with the advance it is set with. A list
+ // marker does not hang: it is counted with no width.
+ let set = |j: usize, g: &SGlyph| {
+ if j < marker {
+ 0.0
+ } else if j + 1 == trimmed {
+ g.adv - end_trim
+ } else {
+ g.adv
+ }
+ };
+ let visible = |stop: usize| -> (Vec<usize>, Vec<(&SGlyph, f64)>) {
+ let at: Vec<usize> = order.iter().map(|&offset| i + offset).filter(|&j| j < stop).collect();
+ let glyphs = at.iter().filter_map(|&j| sg.get(j).map(|g| (g, set(j, g)))).collect();
+ (at, glyphs)
+ };
+ // Burasagari: a comma or full stop ending an area type line hangs outside it (Standard:
+ // when it doesn't fit, counting what hangs at the line's start as room; Forced:
+ // always). The rest of the line is aligned and justified without it, and it follows
+ // the line's last character.
+ let room_at_start = || share.map_or(0.0, |share| optical_hangs(&visible(trimmed).1, share).0);
+ let hang = (regions.is_some() && !rtl && hyphen.is_none() && trimmed > i + 1)
+ .then(|| sg.get(trimmed - 1))
+ .flatten()
+ .filter(|g| hangs(g))
+ .map(|g| g.adv - end_trim)
+ .filter(|_| match para.burasagari {
+ Burasagari::None => false,
+ Burasagari::Standard => w > width + room_at_start() + EPS,
+ Burasagari::Forced => true,
+ });
+ let body = if hang.is_some() { trimmed - 1 } else { trimmed };
+ let w = w - hang.unwrap_or(0.0);
+ // The glyphs before the line's trailing spaces (and its burasagari mark), in the order
+ // they are drawn.
+ let (drawn, mut visible) = visible(body);
+ // Optical Margin Alignment: the glyphs at the ends of a line hang outside its margins
+ // by `opt_l` and `opt_r`. The line is aligned and justified in a measure that much
+ // wider at each end. A left-aligned line then hangs only at its left, a right-aligned
+ // line hangs only at its right, and centered and justified lines hang at both; Auto
+ // aligns a right-to-left line at its right. A right-to-left line is read from right to
+ // left ([`optical_hangs_rtl`]). A line that ends in a burasagari mark hangs only at its
+ // left. Justification adds no space after a punctuation mark hanging at the left, nor
+ // before one hanging at the right (`held`). A letter that hangs by part of its width
+ // keeps its gaps. Glyph Scaling leaves the glyphs that hang (`hung`) at their width, so
+ // they hang exactly by their published share. Roman Hanging Punctuation (a paragraph
+ // attribute) hangs the same punctuation by the same amounts, and no letters; with
+ // Optical Margin Alignment on as well, the letters hang too.
+ let (opt_l, opt_r, held, hung) = if let Some(share) = share {
+ if let Some(h) = &hyphen {
+ visible.push((h, h.adv));
+ }
+ let (l, r, left_glyphs, right_glyphs) =
+ if rtl && !cx.vertical { optical_hangs_rtl(&visible, share) } else { optical_hangs(&visible, share) };
+ let (r, right_glyphs) = if hang.is_some() { (0.0, 0) } else { (r, right_glyphs) };
+ let n_visible = visible.len();
+ let punct = |k: usize| visible.get(k).is_some_and(|&(g, _)| optical_punct(g));
+ let held: Vec<usize> = drawn
+ .iter()
+ .enumerate()
+ .filter(|&(k, _)| (k < left_glyphs && punct(k)) || (right_glyphs > 0 && k + 1 + right_glyphs >= n_visible && punct(k + 1)))
+ .map(|(_, &j)| j)
+ .collect();
+ let hung: Vec<usize> = drawn
+ .iter()
+ .enumerate()
+ .filter(|&(k, _)| k < left_glyphs || (right_glyphs > 0 && k + right_glyphs >= n_visible))
+ .map(|(_, &j)| j)
+ .collect();
+ (l, r, held, hung)
+ } else {
+ (0.0, 0.0, vec![], vec![])
+ };
+ // Justification adds nothing to the list marker's glyphs.
+ let mut held = held;
+ held.extend(i..marker.min(body));
+ // What justification may change of glyph `j`: nothing of a `held` glyph, and no glyph
+ // scaling of a `hung` one.
+ let line_flex = |j: usize| {
+ if held.contains(&j) {
+ return Flex::default();
+ }
+ let mut f = flex.get(j).copied().unwrap_or_default();
+ if hung.contains(&j) {
+ f.glyph = (0.0, 0.0);
+ }
+ f
+ };
+ let room = width + opt_l + opt_r;
+ let (align, justify) = match para.justify {
+ Justify::Auto => (if rtl { 2 } else { 0 }, false),
+ Justify::Left => (0, false),
+ Justify::Center => (1, false),
+ Justify::Right => (2, false),
+ Justify::JustifyLeft => (0, !last_of_para),
+ Justify::JustifyCenter => (1, !last_of_para),
+ Justify::JustifyRight => (2, !last_of_para),
+ Justify::JustifyAll => (0, true),
+ };
+ let justify = justify && regions.is_some();
+ let (mut per_space, mut per_gap, mut per_cjk) = (0.0, 0.0, 0.0);
+ let mut fit = LineFit::default();
+ let spaces = (i..body).filter(|&j| j >= marker && sg[j].is_space()).count();
+ // A gap that justification adds between two glyphs goes into the advance of the one
+ // drawn first: `drawn_after(j)` is the glyph drawn right after glyph `j`, which in a
+ // right-to-left line comes before it in the text.
+ let mut after: Vec<Option<usize>> = vec![None; body.saturating_sub(i)];
+ for (&a, &b) in drawn.iter().zip(drawn.iter().skip(1)) {
+ if let Some(slot) = after.get_mut(a - i) {
+ *slot = Some(b);
+ }
+ }
+ let drawn_after = |j: usize| j.checked_sub(i).and_then(|k| after.get(k).copied().flatten());
+ // Japanese (and Chinese) lines are justified between their characters (JLREQ 3.8): the
+ // gaps next to a CJK character, not inside a Latin word or a tate-chu-yoko block.
+ let cjk_gap = |j: usize| {
+ !held.contains(&j)
+ && drawn_after(j)
+ .and_then(|k| sg.get(j).zip(sg.get(k)))
+ .is_some_and(|(a, b)| !a.is_space() && !b.is_space() && !b.continues_tcy() && a.ch != '\t' && (is_cjk(a.ch) || is_cjk(b.ch)))
+ };
+ let cjk_gaps = (i..body).filter(|&j| cjk_gap(j)).count();
+ // Single Word Justification: a justified line holding one word (no word space) is
+ // spread between its letters (Full Justify) or aligned.
+ let single_word = justify && spaces == 0 && cjk_gaps == 0;
+ let (align, justify) = match (single_word, para.justification.single_word) {
+ (false, _) | (true, SingleWordJustify::FullJustify) => (align, justify),
+ (true, SingleWordJustify::AlignLeft) => (0, false),
+ (true, SingleWordJustify::AlignCenter) => (1, false),
+ (true, SingleWordJustify::AlignRight) => (2, false),
+ };
+ // Insert Kashidas: the Arabic words of a horizontal line take its room on kashidas,
+ // and the word spaces and gaps take what is left.
+ let kashidas =
+ if justify && !cx.vertical && room > w + EPS { kashida::plan(cx.text, &sg, i..body, para.kashida, room - w) } else { vec![] };
+ let w = w + kashidas.iter().map(|k| k.1).sum::<f64>();
+ if justify && (room - w).abs() > EPS {
+ if cjk_gaps > 0 && room > w {
+ // Spread over the CJK gaps and the word spaces alike.
+ let per = (room - w) / (cjk_gaps + spaces) as f64;
+ (per_space, per_cjk) = (per, per);
+ } else if spaces > 0 {
+ // Word spacing, letter spacing and glyph scaling within their ranges, then the
+ // word spaces alone; composed lines may shrink word spaces (never below zero).
+ let line: Vec<Flex> = (i..body).map(line_flex).collect();
+ let floor = (i..body).filter(|&j| j >= marker && sg[j].is_space()).map(|j| sg[j].adv).fold(f64::MAX, f64::min);
+ fit = fit_line(&line, room - w, spaces, floor);
+ } else if room > w {
+ // One word: its letter spacing and glyph scaling, then the gaps between its glyphs.
+ let line: Vec<Flex> = (i..body).map(line_flex).collect();
+ fit = fit_line(&line, room - w, 0, 0.0);
+ let used: f64 = line.iter().map(|f| fit.letter(f) + fit.glyph(f)).sum();
+ let rest = room - w - used;
+ let gaps = (i..body)
+ .filter(|&j| !held.contains(&j) && drawn_after(j).and_then(|k| sg.get(k)).is_some_and(|next| !next.continues_tcy()))
+ .count();
+ if gaps > 0 && rest > EPS {
+ per_gap = rest / gaps as f64;
+ }
+ }
+ }
+ let start_x = if justify {
+ ax0 - opt_l
+ } else if regions.is_none() {
+ match align {
+ 0 => ind_l - opt_l,
+ 1 => (ind_l - opt_l - ind_r + opt_r - w) * 0.5,
+ _ => -ind_r + opt_r - w,
+ }
+ } else {
+ match align {
+ 0 => ax0 - opt_l,
+ 1 => ax0 - opt_l + (room - w) * 0.5,
+ _ => ax1 + opt_r - w,
+ }
+ };
+ let li = cx.out.lines.len();
+ let glyph_start = cx.out.glyphs.len();
+ // Character Alignment lines smaller characters up with the line's largest em box.
+ let line_em = sg.get(i..end).map_or(0.0, |line| line.iter().map(glyph_em).fold(0.0, f64::max));
+ let mut x_end = start_x;
+ // Tab stops are measured from the frame's left edge (point type: the origin).
+ let tab_origin = if regions.is_some() { x0 } else { 0.0 };
+ // A line with tabs is measured as if it started at the left (see `set_width`), then
+ // aligned as a whole: its tabs stop where they were measured, however it is aligned.
+ let tab_shift = start_x - if regions.is_some() { ax0 } else { ind_l };
+ // RTL's logical trailing spaces precede the visible content. Keep them outside
+ // the aligned content extent, just as LTR trailing spaces extend to its right.
+ let leading_space_width: f64 =
+ order.iter().take_while(|&&offset| i + offset >= trimmed).filter_map(|&offset| sg.get(i + offset)).map(|g| g.adv).sum();
+ let mut x = start_x - leading_space_width;
+ // The glyphs drawn for the list marker, and the index of its tab's glyph, when the line starts the paragraph.
+ let mut marker_glyphs: Option<Range<usize>> = None;
+ let mut marker_tab = 0;
+ for (oi, &offset) in order.iter().enumerate() {
+ let j = i + offset;
+ let Some(g) = sg.get(j) else { continue };
+ let mut adv = g.adv;
+ if j + 1 == trimmed {
+ adv -= end_trim;
+ }
+ // Glyph scaling a justified line adds to the glyph (1: none).
+ let mut scale = 1.0;
+ let mut leader = "";
+ if g.ch == '\t' {
+ // The tab after a list marker keeps the width `prepend_marker` gave it.
+ if g.len > 0 {
+ (adv, leader) = tab_advance(&para.tabs, tab_origin, x - tab_shift, &sg[j + 1..trimmed.max(j + 1)]);
+ }
+ } else if j < body {
+ let f = line_flex(j);
+ if is_word_space(g) {
+ adv += fit.space(&f);
+ } else {
+ adv += fit.letter(&f) + fit.glyph(&f);
+ scale = fit.glyph_scale(&f);
+ }
+ if g.is_space() {
+ adv += per_space;
+ } else if per_cjk != 0.0 {
+ if cjk_gap(j) {
+ adv += per_cjk;
+ }
+ } else if !held.contains(&j) && drawn_after(j).and_then(|k| sg.get(k)).is_some_and(|next| !next.continues_tcy()) {
+ // Between glyphs, never inside a tate-chu-yoko block (one cell).
+ adv += per_gap;
+ }
+ }
+ // The kashida before a cluster in the text is drawn at the cluster's right, between
+ // it and the letter before it, and the cluster's last glyph advances over it: the
+ // caret, selection and hit testing take it as part of the cluster.
+ let kashida = kashidas
+ .binary_search_by_key(&g.byte, |k| k.0)
+ .ok()
+ .and_then(|at| kashidas.get(at))
+ .filter(|_| order.get(oi + 1).and_then(|&o| sg.get(i + o)).is_none_or(|next| next.byte != g.byte))
+ .map(|k| k.1);
+ adv += kashida.unwrap_or(0.0);
+ let y = baseline - align_shift(g, cx.style_at(g.byte).char_align, line_em, cx.vertical);
+ let place = if scale != 1.0 { Affine::translate((x, y)) * Affine::scale_non_uniform(scale, 1.0) } else { Affine::translate((x, y)) };
+ if j < marker {
+ let at = cx.out.glyphs.len();
+ marker_glyphs = Some(marker_glyphs.map_or(at..at + 1, |r: Range<usize>| r.start.min(at)..r.end.max(at + 1)));
+ if j + 1 == marker {
+ marker_tab = at;
+ }
+ }
+ cx.emit(g, place, Point::new(x, y), 0.0, adv, li);
+ if let Some(out) = cx.out.glyphs.last_mut() {
+ out.scale = flex.get(j).map_or(1.0, |f| f.scale) * scale;
+ }
+ if !leader.is_empty() {
+ // The leader belongs to the tab's glyph: the gap stays one character for the
+ // caret, selection and hit testing.
+ let dots = leader_outline(cx.db, g, leader, tab_origin, x, x + adv, y);
+ if let Some(tab) = cx.out.glyphs.last_mut() {
+ tab.outline.extend(dots);
+ }
+ }
+ if let Some(len) = kashida {
+ cx.emit_kashida(g, para.kashida, len, Point::new(x + adv - len, y), li);
+ }
+ x += adv;
+ if j < trimmed {
+ x_end = x;
+ }
+ }
+ if let (Some(glyphs), Some(text)) = (marker_glyphs, marker_text) {
+ cx.out.markers.push(ListMarker { glyphs, tab: marker_tab, text: text.to_string() });
+ }
+ if let Some(h) = &hyphen {
+ // The hyphen follows the last non-space glyph.
+ let hx = x_end;
+ cx.emit(h, Affine::translate((hx, baseline)), Point::new(hx, baseline), 0.0, h.adv, li);
+ x_end = hx + h.adv;
+ }
+ cx.out.lines.push(LineInfo {
+ rtl: rtl && !cx.vertical,
+ baseline,
+ x0: start_x,
+ x1: x_end,
+ ascent: m.asc,
+ descent: m.desc,
+ first_baseline: if pen.model == LeadingModel::EmBoxTop { m.top.max(pen.fb_min) } else { m.first_baseline(pen.fb, pen.fb_min) },
+ start: if i < n { sg[i].byte } else { pr.start },
+ end: if last_of_para { pr.end } else { sg[end].byte },
+ glyph_start,
+ glyph_end: cx.out.glyphs.len(),
+ avail: if regions.is_some() { (ax0, ax1) } else { (start_x, x_end) },
+ region: if regions.is_some() { pen.ri } else { 0 },
+ });
+ pen.settled(baseline, m);
+ // Further spans of this line band share the settled baseline.
+ for q in &mut pen.queued {
+ q.0 = baseline;
+ }
+ li_para += 1;
+ i = end;
+ if i >= n {
+ break;
+ }
+ }
+ pen.pending += para.space_after;
+ }
+}
diff --git a/crates/text/src/layout/on_path.rs b/crates/text/src/layout/on_path.rs
new file mode 100644
index 000000000..7bdeba66d
--- /dev/null
+++ b/crates/text/src/layout/on_path.rs
@@ -0,0 +1,408 @@
+use super::bidi::{is_rtl, para_bidi_with, visual_order};
+use super::breaking::{Metrics, optical_hangs, optical_hangs_rtl, optical_share, roman_share};
+use super::flow::list_markers;
+use super::region::in_range;
+use super::*;
+
+/// The distance along type on a path each glyph takes: its advance measured `spacing` points above
+/// the path (Type on a Path Options › Spacing), so glyphs close up round the outside of a curve and
+/// open up round the inside; just the advances without spacing. Glyphs start `from` along the path.
+fn path_steps(ap: &ArcPath, glyphs: &[SGlyph], from: f64, spacing: f64) -> Vec<f64> {
+ let mut s = from;
+ glyphs
+ .iter()
+ .map(|g| {
+ let mut step = g.adv;
+ if spacing != 0.0 && g.adv > 1e-9 {
+ // How far the path turns across the glyph: positive bending away from its top.
+ let ((_, a), (_, b)) = (ap.at(s), ap.at(s + g.adv));
+ let curvature = a.cross(b).atan2(a.dot(b)) / g.adv;
+ step = g.adv / (1.0 + curvature * spacing).clamp(0.25, 4.0);
+ }
+ s += step;
+ step
+ })
+ .collect()
+}
+
+/// How closely a bent glyph's curves follow the path (text space units).
+const BEND_TOLERANCE: f64 = 0.01;
+
+/// The most pieces one segment of a glyph's outline is cut into to bend it.
+const BEND_PIECES: usize = 32;
+
+/// The most elements a bent glyph outline may have; beyond that the glyph stays straight.
+const BEND_MAX_ELEMENTS: usize = 8192;
+
+/// `outline` (text space, placed straight by `pre`, which takes the glyph's pen space there) bent
+/// along `ap` as `bend` says ([`GlyphBend`]); `None` where the path doesn't turn under the glyph
+/// (it stays as it is, exactly), or the bent outline would be too large or not finite.
+fn bend_outline(outline: &BezPath, pre: Affine, ap: &ArcPath, bend: &GlyphBend) -> Option<BezPath> {
+ let GlyphBend { s, step, advance, rise } = *bend;
+ if outline.elements().is_empty() || !(advance > 1e-9 && step.is_finite() && step > 0.0 && s.is_finite() && rise.is_finite()) {
+ return None;
+ }
+ // How far the path turns under the glyph; none: it lies straight already.
+ let ((_, a), (_, b)) = (ap.at(s), ap.at(s + step));
+ let turn = a.cross(b).atan2(a.dot(b)).abs();
+ if !(turn.is_finite() && turn > 1e-9) {
+ return None;
+ }
+ let det = pre.determinant();
+ if !(det.is_finite() && det.abs() > 1e-12) {
+ return None;
+ }
+ let to_pen = pre.inverse();
+ let k = step / advance;
+ let map = |q: Point| {
+ let (p, d) = ap.at(s + q.x * k);
+ p + Vec2::new(-d.y, d.x) * (q.y + rise)
+ };
+ // Pieces short enough that mapping a piece's control points stays within the tolerance: the
+ // error of a piece of length L under curvature c, at height y, is about L² c (1 + |y| c) / 8.
+ let curvature = turn / step;
+ let pen = to_pen * outline.clone();
+ let height = pen.bounding_box().y0.abs().max(pen.bounding_box().y1.abs()) + rise.abs();
+ let piece = ((8.0 * BEND_TOLERANCE) / (curvature * (1.0 + height * curvature))).sqrt();
+ let pieces = |a: Point, b: Point| -> usize {
+ let n = ((b - a).hypot() / piece).ceil();
+ if n.is_finite() { (n as usize).clamp(1, BEND_PIECES) } else { BEND_PIECES }
+ };
+ let mut out = BezPath::new();
+ let (mut start, mut cur) = (Point::ZERO, Point::ZERO);
+ let line = |out: &mut BezPath, from: Point, to: Point| {
+ let n = pieces(from, to);
+ for i in 1..=n {
+ out.line_to(map(from.lerp(to, i as f64 / n as f64)));
+ }
+ };
+ for el in pen.elements() {
+ match *el {
+ PathEl::MoveTo(p) => {
+ out.move_to(map(p));
+ (start, cur) = (p, p);
+ }
+ PathEl::LineTo(p) => {
+ line(&mut out, cur, p);
+ cur = p;
+ }
+ PathEl::QuadTo(p1, p2) => {
+ let c = kurbo::QuadBez::new(cur, p1, p2).raise();
+ let n = pieces(cur, p1).max(pieces(p1, p2));
+ for i in 0..n {
+ let q = c.subsegment(i as f64 / n as f64..(i + 1) as f64 / n as f64);
+ out.curve_to(map(q.p1), map(q.p2), map(q.p3));
+ }
+ cur = p2;
+ }
+ PathEl::CurveTo(p1, p2, p3) => {
+ let c = kurbo::CubicBez::new(cur, p1, p2, p3);
+ let n = pieces(cur, p1).max(pieces(p1, p2)).max(pieces(p2, p3));
+ for i in 0..n {
+ let q = c.subsegment(i as f64 / n as f64..(i + 1) as f64 / n as f64);
+ out.curve_to(map(q.p1), map(q.p2), map(q.p3));
+ }
+ cur = p3;
+ }
+ PathEl::ClosePath => {
+ if (cur - start).hypot() > 1e-12 {
+ line(&mut out, cur, start);
+ }
+ out.close_path();
+ cur = start;
+ }
+ }
+ if out.elements().len() > BEND_MAX_ELEMENTS {
+ return None;
+ }
+ }
+ let finite = |p: Point| p.x.is_finite() && p.y.is_finite();
+ out.elements()
+ .iter()
+ .all(|el| match *el {
+ PathEl::MoveTo(p) | PathEl::LineTo(p) => finite(p),
+ PathEl::QuadTo(a, b) => finite(a) && finite(b),
+ PathEl::CurveTo(a, b, c) => finite(a) && finite(b) && finite(c),
+ PathEl::ClosePath => true,
+ })
+ .then_some(out)
+}
+
+/// Lay type on a path out along `path` (text space), between its brackets.
+pub(super) fn on_path(cx: &mut Ctx<'_>, paras: &[Range<usize>], t: &TextObject, path: &PathData) {
+ 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);
+ // The first paragraph's direction aligns the line (Auto) and sets the caret's.
+ let mut rtl = None;
+ let mut shaped = Vec::new();
+ let markers = list_markers(t, paras);
+ for (pi, pr) in paras.iter().enumerate() {
+ let text = cx.text;
+ let bidi = para_bidi_with(text.get(pr.clone()).unwrap_or_default(), para.direction, &cx.char_directions(pr));
+ rtl.get_or_insert(is_rtl(bidi.as_ref()) && !cx.vertical);
+ let mut glyphs = cx.shape_para(pr.clone(), bidi.as_ref());
+ // Bullets and numbers: a list paragraph's text starts after its marker here too, unless
+ // the paragraph continues from the frame before in its thread.
+ if pi > 0 || !t.first_para_continues {
+ let marker_text = markers.get(pi).and_then(Option::as_deref);
+ cx.prepend_marker(pr, t.para_at(pi), marker_text, is_rtl(bidi.as_ref()) && !cx.vertical, &mut glyphs);
+ }
+ 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)
+ });
+ if ap.is_empty() {
+ cx.out.overflow = !sg.is_empty();
+ cx.out.lines.push(LineInfo {
+ rtl,
+ baseline: 0.0,
+ x0: 0.0,
+ x1: 0.0,
+ ascent: m.0,
+ descent: m.1,
+ first_baseline: 0.0,
+ start: 0,
+ end: 0,
+ glyph_start: 0,
+ glyph_end: 0,
+ avail: (0.0, 0.0),
+ region: 0,
+ });
+ return;
+ }
+ let centre = path.bounds().unwrap_or_default().center();
+ let (from, to) = t.kind.path_span().unwrap_or((0.0, 1.0));
+ 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 };
+ // 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
+ // end (`hung_r` of them) do not make it overflow past the end bracket. On an open path a hang
+ // stops at the path's end. On a closed path the two hangs together take at most the stretch
+ // between the end and start brackets: the end where the line is placed takes its share first.
+ // A centered line's ends each get up to half of it, and either end takes what the other leaves.
+ // 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 = |sg: &[SGlyph], steps: &[f64]| {
+ if !hanging {
+ return (0.0, 0.0, 0);
+ }
+ let share: fn(&SGlyph) -> f64 = if t.optical_margin { optical_share } else { roman_share };
+ // A list marker (the glyphs of length 0) does not hang: it is counted with no width.
+ let line: Vec<(&SGlyph, f64)> = sg.iter().zip(steps).map(|(g, &step)| (g, if g.len == 0 { 0.0 } else { step })).collect();
+ let (l, r, _, hung_r) = if rtl { optical_hangs_rtl(&line, share) } else { optical_hangs(&line, share) };
+ let (l, r) = if ap.is_closed() {
+ let gap = (ap.len() - avail).max(0.0);
+ match para.justify {
+ j if matches!(j, Justify::Right | Justify::JustifyRight) || (rtl && j == Justify::Auto) => {
+ let r = r.min(gap);
+ (l.min(gap - r), r)
+ }
+ Justify::Center | Justify::JustifyCenter => {
+ let l = l.min(gap - r.min(gap * 0.5));
+ (l, r.min(gap - l))
+ }
+ _ => {
+ let l = l.min(gap);
+ (l, r.min(gap - l))
+ }
+ }
+ } else {
+ (l.min(s_start), r.min((ap.len() - s_start - avail).max(0.0)))
+ };
+ (l, r, hung_r)
+ };
+ // 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)
+ };
+ // 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;
+ }
+ }
+ 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);
+ }
+ // 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 {
+ PathAlign::Baseline => 0.0,
+ PathAlign::Ascender => m.0,
+ PathAlign::Descender => -m.1,
+ PathAlign::Center => (m.0 - m.1) * 0.5,
+ };
+ let mut x = 0.0;
+ for (g, &step) in sg.iter().zip(&steps).take(fit) {
+ let s = s0 + x;
+ 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));
+ // Glyph space: x along the advance, y down from the baseline; `pre` maps it onto the path.
+ let pre = match t.path_effect {
+ PathEffect::Rainbow => Affine::translate(p.to_vec2()) * Affine::rotate(angle) * half,
+ // x axis along the tangent, y axis stays vertical.
+ PathEffect::Skew => Affine::translate(p.to_vec2()) * Affine::new([dir.x, dir.y, 0.0, 1.0, 0.0, 0.0]) * half,
+ // x axis stays horizontal (facing the path's direction), y axis perpendicular to the path.
+ PathEffect::Ribbon3d => {
+ let sx = if dir.x < 0.0 { -1.0 } else { 1.0 };
+ Affine::translate(p.to_vec2()) * Affine::new([sx, 0.0, -dir.y * sx, dir.x * sx, 0.0, 0.0]) * half
+ }
+ PathEffect::StairStep => Affine::translate(ap.at(s).0.to_vec2()) * Affine::translate((0.0, rise)),
+ // x axis along the tangent; vertical edges point at the path's centre (kept on the glyph's
+ // up side, and never closer than ~17° to the baseline so glyphs stay legible).
+ PathEffect::Gravity => {
+ let n = Vec2::new(dir.y, -dir.x);
+ let mut up = p - centre;
+ up = if up.hypot() < 1e-9 { n } else { up / up.hypot() };
+ if up.dot(n) < 0.0 {
+ up = -up;
+ }
+ if up.dot(n) < 0.3 {
+ let along = up - n * up.dot(n);
+ up = n * 0.3 + along / along.hypot().max(1e-9) * (1.0 - 0.09f64).sqrt();
+ }
+ Affine::translate(p.to_vec2()) * Affine::new([dir.x, dir.y, -up.x, -up.y, 0.0, 0.0]) * half
+ }
+ };
+ // The caret's baseline moves with the type.
+ let origin = p - dir * (g.adv * 0.5) + Vec2::new(-dir.y, dir.x) * rise;
+ // A list marker's glyphs (the only glyphs here with no length) are in a row at the byte of
+ // their paragraph's start.
+ if g.len == 0 {
+ let at = cx.out.glyphs.len();
+ let starts_paragraph = |b: usize| paras.iter().position(|p| p.start == b);
+ match cx.out.markers.last_mut() {
+ Some(m) if m.glyphs.end == at && cx.out.glyphs.get(m.glyphs.start).is_some_and(|h| h.byte == g.byte) => m.glyphs.end = at + 1,
+ _ => {
+ if let Some(text) = starts_paragraph(g.byte).and_then(|pi| markers.get(pi)).and_then(Option::as_ref) {
+ cx.out.markers.push(ListMarker { glyphs: at..at + 1, tab: at, text: text.clone() });
+ }
+ }
+ }
+ if let Some(m) = cx.out.markers.last_mut().filter(|m| m.glyphs.end == at + 1 && g.ch == '\t') {
+ m.tab = at;
+ }
+ }
+ cx.emit(g, pre, origin, angle, g.adv, 0);
+ // A glyph of a script whose letters join is bent along a curved path (Rainbow), so its
+ // joining strokes meet its neighbours' instead of standing off the curve.
+ if t.path_effect == PathEffect::Rainbow && g.cursive && !cx.vertical && g.inline.is_none() {
+ let bend = GlyphBend { s, step, advance: g.adv, rise };
+ if let Some(last) = cx.out.glyphs.last_mut()
+ && last.image.is_none()
+ && last.colour.is_none()
+ && let Some(bent) = bend_outline(&last.outline, pre, &ap, &bend)
+ {
+ last.outline = bent;
+ last.bend = Some(bend);
+ }
+ }
+ x += step;
+ }
+ let (ps, _) = ap.at(s0);
+ let (pe, _) = ap.at(s0 + x);
+ cx.out.lines.push(LineInfo {
+ rtl,
+ baseline: ps.y,
+ x0: ps.x,
+ x1: pe.x,
+ ascent: m.0,
+ descent: m.1,
+ first_baseline: 0.0,
+ start: 0,
+ end: fits,
+ glyph_start: 0,
+ glyph_end: cx.out.glyphs.len(),
+ avail: (0.0, ap.len()),
+ region: 0,
+ });
+}
diff --git a/crates/text/src/layout/region.rs b/crates/text/src/layout/region.rs
new file mode 100644
index 000000000..d3f953359
--- /dev/null
+++ b/crates/text/src/layout/region.rs
@@ -0,0 +1,233 @@
+use super::*;
+
+/// A flattened text wrap shape: (polygons, offset, invert).
+pub(super) type FlatWrap = (Vec<Vec<Point>>, f64, bool);
+
+/// One cell of a flattened area-type frame (the whole frame, or one row/column of it).
+pub(super) struct Region {
+ /// The cell (frame bounds, or a grid cell of them).
+ pub(super) cell: Rect,
+ /// Inset applied inside the frame edges.
+ inset: f64,
+ pub(super) polys: std::sync::Arc<[Vec<Point>]>,
+ /// The frame is its own bounding rectangle (spans need no polygon intersection).
+ pub(super) rect: bool,
+ /// Text Wrap shapes.
+ pub(super) wraps: std::sync::Arc<[FlatWrap]>,
+ /// Vertical alignment: how far below the top-aligned position the first line starts.
+ pub(super) shift: f64,
+ /// Vertical justification: extra space added between consecutive lines.
+ pub(super) gap: f64,
+}
+
+/// The largest magnitude a coordinate of a frame, a text wrap shape or the path of type on a path
+/// may have (points), control points included. A frame or path with a larger coordinate, or a
+/// coordinate that isn't finite, holds no text, and a text wrap shape with one is ignored.
+const MAX_COORD: f64 = 1e9;
+
+/// Are the coordinates of `path`, control points included, finite and within [`MAX_COORD`]?
+pub(super) fn in_range(path: &BezPath) -> bool {
+ let near = |p: &Point| p.x.abs() <= MAX_COORD && p.y.abs() <= MAX_COORD;
+ path.elements().iter().all(|el| match el {
+ PathEl::MoveTo(p) | PathEl::LineTo(p) => near(p),
+ PathEl::QuadTo(a, p) => near(a) && near(p),
+ PathEl::CurveTo(a, b, p) => near(a) && near(b) && near(p),
+ PathEl::ClosePath => true,
+ })
+}
+
+/// Flattened closed polygons of a path; `None` when it isn't [`in_range`].
+fn polygons(path: &BezPath) -> Option<Vec<Vec<Point>>> {
+ if !in_range(path) {
+ return None;
+ }
+ let mut polys: Vec<Vec<Point>> = Vec::new();
+ kurbo::flatten(path, 0.1, |el| match el {
+ PathEl::MoveTo(p) => polys.push(vec![p]),
+ PathEl::LineTo(p) => {
+ if let Some(v) = polys.last_mut() {
+ v.push(p);
+ }
+ }
+ _ => {}
+ });
+ polys.retain(|p| p.len() >= 3);
+ Some(polys)
+}
+
+/// Inside intervals (even-odd) of the horizontal line at `y` through `polys`.
+fn poly_intervals(polys: &[Vec<Point>], y: f64) -> Vec<(f64, f64)> {
+ let mut xs = Vec::new();
+ for poly in polys {
+ for i in 0..poly.len() {
+ let a = poly[i];
+ let b = poly[(i + 1) % poly.len()];
+ if (a.y <= y) != (b.y <= y) {
+ xs.push(a.x + (y - a.y) / (b.y - a.y) * (b.x - a.x));
+ }
+ }
+ }
+ xs.sort_by(f64::total_cmp);
+ xs.as_chunks::<2>().0.iter().map(|c| (c[0], c[1])).collect()
+}
+
+/// Union of sorted-or-not intervals.
+fn union_intervals(mut v: Vec<(f64, f64)>) -> Vec<(f64, f64)> {
+ v.sort_by(|a, b| a.0.total_cmp(&b.0));
+ let mut out: Vec<(f64, f64)> = Vec::with_capacity(v.len());
+ for (a, b) in v {
+ match out.last_mut() {
+ Some(l) if a <= l.1 => l.1 = l.1.max(b),
+ _ => out.push((a, b)),
+ }
+ }
+ out
+}
+
+/// `a` minus `b` (both unions of disjoint intervals).
+fn subtract_intervals(a: &[(f64, f64)], b: &[(f64, f64)]) -> Vec<(f64, f64)> {
+ let mut out = vec![];
+ for &(mut s, e) in a {
+ for &(c, d) in b {
+ if d <= s || c >= e {
+ continue;
+ }
+ if c > s {
+ out.push((s, c));
+ }
+ s = s.max(d);
+ }
+ if e > s {
+ out.push((s, e));
+ }
+ }
+ out
+}
+
+/// `a` ∩ `b`.
+fn intersect_intervals(a: &[(f64, f64)], b: &[(f64, f64)]) -> Vec<(f64, f64)> {
+ let mut out = vec![];
+ for &(s, e) in a {
+ for &(c, d) in b {
+ let (x, y) = (s.max(c), e.min(d));
+ if y > x {
+ out.push((x, y));
+ }
+ }
+ }
+ out
+}
+
+impl Region {
+ pub(super) fn cells(path: &BezPath, opts: &LayoutOptions, wrap: &[vectorcraft_doc::WrapShape]) -> Vec<Region> {
+ // A frame out of range has no cells, and a wrap shape out of range is left out.
+ let Some(polys) = polygons(path) else { return vec![] };
+ // Every cell shares one copy of the frame's polygons and one copy of the text wrap shapes.
+ let polys: std::sync::Arc<[Vec<Point>]> = polys.into();
+ let wraps: std::sync::Arc<[FlatWrap]> = wrap
+ .iter()
+ .filter_map(|w| Some((polygons(&w.path.to_bezpath())?, w.wrap.offset.max(0.0), w.wrap.invert)))
+ .filter(|w| !w.0.is_empty())
+ .collect();
+ let bbox = path.bounding_box();
+ let rect = polys.len() == 1 && {
+ let area: f64 = polys[0].iter().zip(polys[0].iter().cycle().skip(1)).map(|(a, b)| a.x * b.y - b.x * a.y).sum::<f64>().abs() * 0.5;
+ (area - bbox.area()).abs() <= bbox.area() * 1e-6 + 1e-9
+ };
+ let max = vectorcraft_doc::AreaOptions::MAX_ROWS_COLUMNS;
+ let (rows, cols) = (opts.rows.clamp(1, max), opts.columns.clamp(1, max));
+ let gutter = opts.gutter.max(0.0);
+ let cw = ((bbox.width() - gutter * (cols - 1) as f64) / cols as f64).max(0.0);
+ let rh = ((bbox.height() - gutter * (rows - 1) as f64) / rows as f64).max(0.0);
+ let mut out = Vec::with_capacity(rows * cols);
+ // Text flows down each column, then across (Illustrator's default "by columns").
+ for c in 0..cols {
+ for r in 0..rows {
+ let x0 = bbox.x0 + c as f64 * (cw + gutter);
+ let y0 = bbox.y0 + r as f64 * (rh + gutter);
+ let cell = if rows * cols == 1 { bbox } else { Rect::new(x0, y0, x0 + cw, y0 + rh) };
+ out.push(Region { cell, inset: opts.inset.max(0.0), polys: polys.clone(), rect, wraps: wraps.clone(), shift: 0.0, gap: 0.0 });
+ }
+ }
+ out
+ }
+
+ pub(super) fn top(&self) -> f64 {
+ self.cell.y0 + self.inset
+ }
+ pub(super) fn bottom(&self) -> f64 {
+ self.cell.y1 - self.inset
+ }
+
+ /// Inside intervals (even-odd) of the horizontal line at `y`, minus the wrap objects (or
+ /// inside them, for Invert Wrap). Offsets grow each wrap shape vertically and horizontally.
+ fn intervals(&self, y: f64) -> Vec<(f64, f64)> {
+ let mut iv = if self.polys.is_empty() || self.rect { vec![(self.cell.x0, self.cell.x1)] } else { poly_intervals(&self.polys, y) };
+ for (polys, off, invert) in self.wraps.iter() {
+ let ys = if *off > 0.0 { vec![y - off, y - off * 0.5, y, y + off * 0.5, y + off] } else { vec![y] };
+ let w = union_intervals(ys.into_iter().flat_map(|y| poly_intervals(polys, y)).map(|(a, b)| (a - off, b + off)).collect());
+ iv = if *invert { intersect_intervals(&iv, &w) } else { subtract_intervals(&iv, &w) };
+ }
+ iv
+ }
+
+ /// Widest horizontal span inside the frame (and the cell) over the band `top..bottom`.
+ pub(super) fn span(&self, top: f64, bottom: f64) -> Option<(f64, f64)> {
+ self.spans(top, bottom).into_iter().max_by(|x, y| (x.1 - x.0).total_cmp(&(y.1 - y.0)))
+ }
+
+ /// Every horizontal span inside the frame (and the cell) over the band `top..bottom`, left to
+ /// right (text wraps on both sides of an object).
+ pub(super) fn spans(&self, top: f64, bottom: f64) -> Vec<(f64, f64)> {
+ let clip = |(a, b): (f64, f64)| {
+ let (a, b) = (a.max(self.cell.x0) + self.inset, b.min(self.cell.x1) - self.inset);
+ (b > a).then_some((a, b))
+ };
+ let plain = self.polys.is_empty() || self.rect;
+ if plain && self.wraps.is_empty() {
+ return (self.cell.width() > 0.0).then_some((self.cell.x0, self.cell.x1)).and_then(clip).into_iter().collect();
+ }
+ let fb = if plain {
+ self.cell
+ } else {
+ self.polys.iter().flatten().fold(Rect::new(f64::MAX, f64::MAX, f64::MIN, f64::MIN), |r, p| r.union_pt(*p))
+ };
+ let clamp = |y: f64| if plain { y } else { y.clamp(fb.y0 + 1e-4, fb.y1 - 1e-4) };
+ // Sample the band densely enough for curved frames (circles, blobs).
+ let samples = 5;
+ let mut rows: Vec<Vec<(f64, f64)>> =
+ (0..samples).map(|k| self.intervals(clamp(top + (bottom - top) * k as f64 / (samples - 1) as f64))).collect();
+ let mid = rows.swap_remove(samples / 2);
+ if !self.wraps.is_empty() {
+ // Wrap objects split lines: keep exactly what is free on every sampled row.
+ let free = rows.iter().fold(mid, |acc, r| intersect_intervals(&acc, r));
+ return free.into_iter().filter_map(clip).collect();
+ }
+ mid.into_iter()
+ .filter_map(|(mut a, mut b)| {
+ for o in &rows {
+ let best =
+ o.iter().map(|&(c, d)| (a.max(c), b.min(d))).filter(|(c, d)| d > c).max_by(|x, y| (x.1 - x.0).total_cmp(&(y.1 - y.0)))?;
+ a = best.0;
+ b = best.1;
+ }
+ clip((a, b))
+ })
+ .collect()
+ }
+}
+
+/// The 10,000 cells of a frame in 100 rows and 100 columns share one copy of the frame's polygons
+/// and one copy of the text wrap shapes.
+#[cfg(test)]
+#[test]
+fn the_cells_of_a_frame_share_its_polygons_and_the_wrap_shapes() {
+ let frame = kurbo::Circle::new((0.0, 0.0), 1000.0).to_path(0.1);
+ let square = PathData::from_bezpath(&Rect::new(-10.0, -10.0, 10.0, 10.0).to_path(0.1));
+ let wrap = vectorcraft_doc::WrapShape { path: square, wrap: Default::default() };
+ let cells = Region::cells(&frame, &LayoutOptions { rows: 100, columns: 100, ..LayoutOptions::default() }, &[wrap]);
+ assert_eq!(cells.len(), 10_000);
+ let first = &cells[0];
+ assert!(!first.polys.is_empty() && !first.wraps.is_empty());
+ assert!(cells.iter().all(|c| c.polys.as_ptr() == first.polys.as_ptr() && c.wraps.as_ptr() == first.wraps.as_ptr()));
+}
diff --git a/crates/text/src/layout/ruby.rs b/crates/text/src/layout/ruby.rs
new file mode 100644
index 000000000..c09786bbc
--- /dev/null
+++ b/crates/text/src/layout/ruby.rs
@@ -0,0 +1,304 @@
+use super::driver::layout;
+use super::*;
+
+/// Ruby (furigana): lays each reading out over its base text in line space, grows the line's
+/// ascent/descent so the ruby fits, and moves the lines after it on in the block direction.
+///
+/// Positions are measured from the line's baseline. Vertical type uses the same geometry — ruby
+/// "above" the baseline is right of the column once the lines are turned — with each reading
+/// character set upright along the column (a quarter turn that the final vertical turn undoes).
+/// A reading over a line break is split between the lines, by the base characters' share of it.
+/// A reading wider than its base hangs over the neighbours (`overhang`), or is squeezed to the
+/// base's width. Type on a path is left out (it has no above/below).
+pub(super) fn ruby_layout(cx: &mut Ctx<'_>, t: &TextObject) {
+ use std::collections::BTreeMap;
+
+ let db = cx.db;
+ let text_len = cx.text.len();
+ let n_lines = cx.out.lines.len();
+ if n_lines == 0 || cx.out.glyphs.is_empty() {
+ return;
+ }
+ let base_baselines: Vec<f64> = cx.out.lines.iter().map(|l| l.baseline).collect();
+ let old_ascent: Vec<f64> = cx.out.lines.iter().map(|l| l.ascent).collect();
+ let old_descent: Vec<f64> = cx.out.lines.iter().map(|l| l.descent).collect();
+ // One piece of base text on one line, with the part of the reading that belongs to it.
+ struct Piece {
+ line: usize,
+ x0: f64,
+ x1: f64,
+ run: usize,
+ byte: usize,
+ reading: String,
+ style: CharStyle,
+ position: RubyPosition,
+ align: RubyAlign,
+ base_size: f64,
+ overhang: bool,
+ }
+ let mut pieces: Vec<Piece> = Vec::new();
+ // The glyphs by their byte, to find a span's without a scan of them all for each span.
+ let byte_of = |i: usize| cx.out.glyphs.get(i).map_or(0, |g| g.byte);
+ let mut by_byte: Vec<usize> = (0..cx.out.glyphs.len()).collect();
+ by_byte.sort_by_key(|&i| byte_of(i));
+ let longest = cx.out.glyphs.iter().map(|g| g.len.max(1)).max().unwrap_or(1);
+ for span in &t.ruby {
+ let (start, end) = (span.start.min(text_len), span.end.min(text_len));
+ if start >= end || span.text.trim().is_empty() {
+ continue;
+ }
+ // The base glyphs of the span, by line; a glyph's cluster is its byte range (`len`, or
+ // one byte for generated glyphs). A list marker is not part of the base.
+ let mut by_line: BTreeMap<usize, Vec<usize>> = BTreeMap::new();
+ let hi = by_byte.partition_point(|&i| byte_of(i) < end);
+ let lo = by_byte.partition_point(|&i| byte_of(i).saturating_add(longest) <= start).min(hi);
+ let mut hits: Vec<usize> = by_byte.get(lo..hi).unwrap_or_default().to_vec();
+ // In glyph order, as the scan found them.
+ hits.sort_unstable();
+ for i in hits {
+ let Some(g) = cx.out.glyphs.get(i) else { continue };
+ let b = g.byte.saturating_add(g.len.max(1));
+ if g.byte < end && b > start && cx.out.marker_of(i).is_none() {
+ by_line.entry(g.line).or_default().push(i);
+ }
+ }
+ let total: usize = by_line.values().map(Vec::len).sum();
+ if total == 0 {
+ continue;
+ }
+ let reading: Vec<char> = span.text.trim().chars().collect();
+ let ratio = span.safe_size_percent() / 100.0;
+ // Split the reading by each line's share of the base glyphs: cumulative fractions keep
+ // every character once and in order.
+ let mut taken = 0;
+ let mut done = 0;
+ let lines: Vec<usize> = by_line.keys().copied().collect();
+ for line in &lines {
+ let count = by_line.get(line).map_or(0, Vec::len);
+ done += count;
+ let upto = if reading.is_empty() { 0 } else { (reading.len() * done / total).min(reading.len()) };
+ let part: String = reading.get(taken.min(reading.len())..upto.min(reading.len())).unwrap_or_default().iter().collect();
+ taken = upto;
+ if part.is_empty() {
+ continue;
+ }
+ let glyphs = by_line.get(line).map(Vec::as_slice).unwrap_or_default();
+ let mut x0 = f64::INFINITY;
+ let mut x1 = f64::NEG_INFINITY;
+ let mut base_size: f64 = 0.0;
+ let mut run = 0;
+ let mut byte = start;
+ for (j, &gi) in glyphs.iter().enumerate() {
+ let Some(g) = cx.out.glyphs.get(gi) else { continue };
+ x0 = x0.min(g.origin.x);
+ x1 = x1.max(g.origin.x + g.advance);
+ base_size = base_size.max(cx.style_at(g.byte).size);
+ if j == 0 {
+ run = g.run;
+ byte = g.byte;
+ }
+ }
+ if !(x0.is_finite() && x1.is_finite()) || base_size <= 0.0 {
+ continue;
+ }
+ let mut style = cx.style_at(byte).clone();
+ style.size = base_size * ratio;
+ style.leading = None;
+ style.baseline_shift = 0.0;
+ style.tracking = 0.0;
+ style.kerning = None;
+ pieces.push(Piece {
+ line: *line,
+ x0,
+ x1,
+ run,
+ byte,
+ reading: part,
+ style,
+ position: span.position,
+ align: span.align,
+ base_size,
+ overhang: span.overhang,
+ });
+ }
+ }
+ // Phase A: shape each reading, place it relative to the (unshifted) baseline, and note how
+ // far above/below the baseline its ink reaches.
+ let mut placed: Vec<(usize, Vec<PositionedGlyph>, f64, f64)> = Vec::new(); // (line, glyphs, ascent, descent)
+ for piece in &pieces {
+ let Some(baseline) = base_baselines.get(piece.line).copied() else { continue };
+ let mini = TextObject::point(Point::ZERO, &piece.reading, piece.style.clone());
+ let lay = layout(db, &mini);
+ let Some(first_line) = lay.lines.first() else { continue };
+ let mini_base = first_line.baseline;
+ let mini_asc = first_line.ascent;
+ let mini_desc = first_line.descent;
+ let base_w = (piece.x1 - piece.x0).max(0.0);
+ // Above: the reading's bottom sits on the base's em box top. Below: its top sits on the
+ // base's em box bottom (the line's descent below the baseline).
+ let ruby_y = if piece.position == RubyPosition::Above {
+ baseline - piece.base_size - mini_desc
+ } else {
+ baseline + old_descent.get(piece.line).copied().unwrap_or(0.0) + mini_asc
+ };
+ let dest = |width: f64| match piece.align {
+ RubyAlign::Center => piece.x0 + (base_w - width) * 0.5,
+ RubyAlign::Start => piece.x0,
+ RubyAlign::End => piece.x1 - width,
+ };
+ let mut glyphs: Vec<PositionedGlyph> = Vec::new();
+ if cx.vertical {
+ // Each reading character in its own cell along the column, upright once the lines turn.
+ let cell = (mini_asc + mini_desc).max(piece.style.size * 0.5);
+ let mut clusters: Vec<Vec<&PositionedGlyph>> = Vec::new();
+ for g in &lay.glyphs {
+ match clusters.last_mut() {
+ Some(c) if c.last().is_some_and(|p| p.byte == g.byte && p.len == g.len) => c.push(g),
+ _ => clusters.push(vec![g]),
+ }
+ }
+ let mut ruby_w = clusters.len() as f64 * cell;
+ let mut squeeze = 1.0;
+ if !piece.overhang && ruby_w > base_w + EPS && ruby_w > EPS {
+ squeeze = base_w / ruby_w;
+ ruby_w = base_w;
+ }
+ let x = dest(ruby_w);
+ for (ci, cluster) in clusters.iter().enumerate() {
+ let anchor = Point::new(x + (ci as f64 + 0.5) * cell, ruby_y);
+ let mut box_: Option<Rect> = None;
+ for g in cluster {
+ if g.outline.elements().is_empty() {
+ continue;
+ }
+ let b = g.outline.bounding_box();
+ box_ = Some(box_.map_or(b, |a| a.union(b)));
+ }
+ let centre = box_.map_or(anchor, |b| Point::new((b.x0 + b.x1) * 0.5, (b.y0 + b.y1) * 0.5));
+ let mut m =
+ Affine::rotate_about(-std::f64::consts::FRAC_PI_2, anchor) * Affine::translate((anchor.x - centre.x, anchor.y - centre.y));
+ if squeeze != 1.0 {
+ m = Affine::translate((x, 0.0)) * Affine::scale_non_uniform(squeeze, 1.0) * Affine::translate((-x, 0.0)) * m;
+ }
+ for g in cluster {
+ glyphs.push(ruby_glyph(g, m, piece.run, piece.byte, piece.line));
+ }
+ }
+ } else {
+ // The reading set along the line: the line's extent, centred or aligned to the base.
+ let mut ruby_w = (first_line.x1 - first_line.x0).max(0.0);
+ let mut squeeze = 1.0;
+ if !piece.overhang && ruby_w > base_w + EPS && ruby_w > EPS {
+ squeeze = base_w / ruby_w;
+ ruby_w = base_w;
+ }
+ let x = dest(ruby_w);
+ let mut m = Affine::translate((x - first_line.x0, ruby_y - mini_base));
+ if squeeze != 1.0 {
+ m = Affine::translate((x, 0.0)) * Affine::scale_non_uniform(squeeze, 1.0) * Affine::translate((-x, 0.0)) * m;
+ }
+ for g in &lay.glyphs {
+ glyphs.push(ruby_glyph(g, m, piece.run, piece.byte, piece.line));
+ }
+ }
+ // How far the reading reaches above and below the base line's baseline (its ink).
+ let mut ascent: f64 = 0.0;
+ let mut descent: f64 = 0.0;
+ for g in &glyphs {
+ if g.outline.elements().is_empty() {
+ continue;
+ }
+ let b = g.outline.bounding_box();
+ ascent = ascent.max(baseline - b.y0);
+ descent = descent.max(b.y1 - baseline);
+ }
+ if !glyphs.is_empty() {
+ placed.push((piece.line, glyphs, ascent, descent));
+ }
+ }
+ if placed.is_empty() {
+ return;
+ }
+ // Phase B: grow each line's box to fit its ruby, then move the lines on after it by what they
+ // need in the block direction (the first line too for area type, so the ruby stays inside the
+ // frame; point type's first baseline is its anchor and stays).
+ let mut growth = vec![0.0_f64; n_lines];
+ for (line, _, ascent, descent) in &placed {
+ if let (Some(a), Some(d)) = (old_ascent.get(*line), old_descent.get(*line)) {
+ let grown = (a.max(*ascent) + d.max(*descent)) - (a + d);
+ if grown > 0.0 {
+ let g = growth.get_mut(*line);
+ if let Some(slot) = g {
+ *slot = slot.max(grown);
+ }
+ }
+ }
+ }
+ // A line's ruby grows above it: the line moves on in the block direction by its own growth,
+ // so the line before it keeps its room (for area type the first line moves too, keeping the
+ // ruby inside the frame; point type's first baseline is its anchor and stays).
+ let area = matches!(t.kind, TextKind::Area { .. });
+ let mut shift = vec![0.0_f64; n_lines];
+ let mut cum = 0.0;
+ for i in 0..n_lines {
+ if area || i > 0 {
+ cum += growth.get(i).copied().unwrap_or(0.0);
+ if let Some(s) = shift.get_mut(i) {
+ *s = cum;
+ }
+ }
+ }
+ // Grow the lines' boxes to fit their ruby, then move them on in the block direction.
+ for (line, _, ascent, descent) in &placed {
+ if let Some(l) = cx.out.lines.get_mut(*line) {
+ l.ascent = l.ascent.max(*ascent);
+ l.descent = l.descent.max(*descent);
+ }
+ }
+ for (i, line) in cx.out.lines.iter_mut().enumerate() {
+ line.baseline += shift.get(i).copied().unwrap_or(0.0);
+ }
+ for g in &mut cx.out.glyphs {
+ let s = shift.get(g.line).copied().unwrap_or(0.0);
+ if s != 0.0 {
+ g.origin.y += s;
+ g.outline.apply_affine(Affine::translate((0.0, s)));
+ g.xf = Affine::translate((0.0, s)) * g.xf;
+ }
+ }
+ for (line, glyphs, _, _) in placed {
+ let s = shift.get(line).copied().unwrap_or(0.0);
+ for mut g in glyphs {
+ if s != 0.0 {
+ g.origin.y += s;
+ g.outline.apply_affine(Affine::translate((0.0, s)));
+ }
+ g.line = line;
+ cx.out.ruby.push(g);
+ }
+ }
+}
+
+/// A ruby glyph from one of a reading's laid-out glyphs, moved by `m` into the base text's line
+/// space. It is not a character of the text: `len` 0, the base text's `run` for fill and stroke.
+fn ruby_glyph(g: &PositionedGlyph, m: Affine, run: usize, byte: usize, line: usize) -> PositionedGlyph {
+ PositionedGlyph {
+ outline: m * g.outline.clone(),
+ run,
+ byte,
+ origin: m * g.origin,
+ advance: 0.0,
+ len: 0,
+ angle: 0.0,
+ line,
+ font_id: g.font_id,
+ gid: g.gid,
+ xf: Affine::IDENTITY,
+ rtl: false,
+ scale: 1.0,
+ // Ruby draws outlines only.
+ image: None,
+ colour: None,
+ bend: None,
+ }
+}
diff --git a/crates/text/src/layout/vertical.rs b/crates/text/src/layout/vertical.rs
new file mode 100644
index 000000000..a8ffad796
--- /dev/null
+++ b/crates/text/src/layout/vertical.rs
@@ -0,0 +1,419 @@
+use super::flow::flow;
+use super::region::Region;
+use super::*;
+
+/// System Layout on or Fractional Widths off: each character that takes space advances by a whole
+/// number of points, at least one, so small type does not collapse onto itself. A zero advance (a
+/// tate-chu-yoko continuation, a zero-width mark) stays zero.
+pub(super) fn whole_character_widths(glyphs: &mut [SGlyph]) {
+ for g in glyphs {
+ if g.adv.is_finite() && g.adv > 0.0 {
+ g.adv = g.adv.round().max(1.0);
+ }
+ }
+}
+
+/// Tate-chu-yoko: a horizontal block one em of the column long, squeezed to the em when wider.
+///
+/// Automatic: a run of two or three half-width digits (`10`月, `100`年). A single digit and a
+/// longer number (`2026`) stay on their side.
+///
+/// Manual (Character panel menu › Tate-chu-yoko): any characters marked `tateChuYoko`, including
+/// one character, letters and numbers longer than three digits. Marked characters are taken
+/// before the automatic digit rule.
+/// <https://helpx.adobe.com/illustrator/using/formatting-asian-characters.html>
+pub(super) fn tate_chu_yoko(g: &mut [SGlyph], style: impl Fn(&SGlyph) -> (f64, bool)) {
+ let manual: Vec<bool> = g.iter().map(|gl| style(gl).1).collect();
+ let digits: Vec<bool> = g.iter().map(|gl| gl.inline.is_none() && gl.ch.is_ascii_digit()).collect();
+ let mut i = 0;
+ while i < g.len() {
+ if manual.get(i).copied().unwrap_or(false) {
+ let mut end = i + 1;
+ while manual.get(end).copied().unwrap_or(false) {
+ end += 1;
+ }
+ let em = style(&g[i]).0;
+ place_tcy_block(&mut g[i..end], em);
+ i = end;
+ continue;
+ }
+ if !digits.get(i).copied().unwrap_or(false) {
+ i += 1;
+ continue;
+ }
+ let mut end = i + 1;
+ while digits.get(end).copied().unwrap_or(false) && !manual.get(end).copied().unwrap_or(false) {
+ end += 1;
+ }
+ if (2..=3).contains(&(end - i)) {
+ let em = style(&g[i]).0;
+ place_tcy_block(&mut g[i..end], em);
+ }
+ i = end;
+ }
+}
+
+/// Lay `g` across one em of the column. The first glyph takes the em; the rest share its cell.
+fn place_tcy_block(g: &mut [SGlyph], em: f64) {
+ let width: f64 = g.iter().map(|gl| gl.adv).sum();
+ let squeeze = if width > em && width > 0.0 { em / width } else { 1.0 };
+ let mut ink = 0.0;
+ for (k, gl) in g.iter_mut().enumerate() {
+ let adv = gl.adv;
+ gl.tcy = Some(Tcy { pen: if k == 0 { 0.0 } else { em }, ink, width, squeeze });
+ gl.adv = if k == 0 { em } else { 0.0 };
+ ink += adv;
+ }
+}
+
+/// Half an em of `g`'s size when it is full-width Japanese punctuation of kind `kind` (its
+/// advance an em, give or take a tenth), the space that mojikumi can take off.
+pub(super) fn punct_half(g: &SGlyph, kind: Punct) -> Option<f64> {
+ // A glyph Proportional Metrics re-spaced has no empty half left to take off (#966).
+ if punct(g.ch)? != kind || g.tcy.is_some() || g.proportional {
+ return None;
+ }
+ let em = g.face.units_per_em();
+ ((g.face.advance(g.gid) - em).abs() <= em * 0.1).then_some(em * 0.5 * g.sx)
+}
+
+/// Mojikumi (JLREQ 3.1.4): consecutive punctuation shares one half-em space. A closing bracket,
+/// comma or full stop followed by punctuation loses the space after it; an opening bracket after
+/// another loses the space before it. Returns which glyphs lost the space after them (a line
+/// ending in one takes nothing more off).
+pub(super) fn compress_punctuation(sg: &mut [SGlyph]) -> Vec<bool> {
+ let mut lost_after = vec![false; sg.len()];
+ for j in 1..sg.len() {
+ let (before, after) = sg.split_at_mut(j);
+ let (Some(a), Some(b)) = (before.last_mut(), after.first_mut()) else { continue };
+ if punct(b.ch).is_none() {
+ continue;
+ }
+ if let Some(h) = punct_half(a, Punct::Closing) {
+ a.adv -= h;
+ if let Some(l) = lost_after.get_mut(j - 1) {
+ *l = true;
+ }
+ } else if punct(a.ch) == Some(Punct::Opening)
+ && let Some(h) = punct_half(b, Punct::Opening)
+ {
+ b.adv -= h;
+ b.lead += h;
+ }
+ }
+ lost_after
+}
+
+/// The space between Japanese and Latin letters or digits (JLREQ 3.2.2: a quarter em of the
+/// Japanese characters' size), with Line-end Punctuation Half Width.
+const WAKAN_AKI: f64 = 0.25;
+
+/// A Japanese character for the space next to Latin text: kana and kanji (and full-width
+/// letters, and the iteration and abbreviation marks 々 〆 〇), not punctuation or symbols, nor
+/// Hangul (Korean sets a word space instead).
+fn is_japanese_letter(c: char) -> bool {
+ if matches!(c, '々' | '〆' | '〇') {
+ return true;
+ }
+ is_cjk(c)
+ && !matches!(
+ c as u32,
+ 0x3000..=0x303F | 0x3130..=0x318F | 0xAC00..=0xD7AF | 0xFF01..=0xFF0F | 0xFF1A..=0xFF20 | 0xFF3B..=0xFF40 | 0xFF5B..=0xFF65 | 0xFFA0..=0xFFDC
+ )
+ && c != '・'
+ && punct(c).is_none()
+}
+
+/// A Latin letter or digit (or another script's letter), set proportionally.
+fn is_latin_letter(c: char) -> bool {
+ c.is_alphanumeric() && !is_cjk(c)
+}
+
+/// Mojikumi (JLREQ 3.2.2): a quarter em between a Japanese character and a Latin letter or digit,
+/// either way round, added after the first of the two. Returns what each glyph got after it (taken
+/// off again when the line ends there).
+pub(super) fn space_japanese_and_latin(sg: &mut [SGlyph]) -> Vec<f64> {
+ let mut added = vec![0.0; sg.len()];
+ for j in 1..sg.len() {
+ let (before, after) = sg.split_at_mut(j);
+ let (Some(a), Some(b)) = (before.last_mut(), after.first()) else { continue };
+ if a.tcy.is_some() || b.tcy.is_some() {
+ continue;
+ }
+ let japanese = if is_japanese_letter(a.ch) && is_latin_letter(b.ch) {
+ Some(&*a)
+ } else if is_latin_letter(a.ch) && is_japanese_letter(b.ch) {
+ Some(b)
+ } else {
+ None
+ };
+ if let Some(g) = japanese {
+ let aki = WAKAN_AKI * g.face.units_per_em() * g.sx;
+ a.adv += aki;
+ if let Some(x) = added.get_mut(j - 1) {
+ *x = aki;
+ }
+ }
+ }
+ added
+}
+
+/// The size of `g`'s em, in points.
+pub(super) fn glyph_em(g: &SGlyph) -> f64 {
+ g.face.units_per_em() * g.sy
+}
+
+/// How far up (line space) Character Alignment `a` moves glyph `g` on a line whose largest em is
+/// `line_em`: the glyph's em box top, centre or bottom onto the line's (the em box running from
+/// its centre less half an em to its centre plus half an em above the baseline), or its ICF's top
+/// or bottom (the em box's less the face's [`crate::IcfMargins`]; across a vertical line, its
+/// right and left). Nothing on the Roman baseline, or for the line's largest characters.
+///
+/// An inline graphic has its run's em (whatever its scale): it counts as one of the line's
+/// largest characters only when its run's size is, and moves with the text of its run (its art
+/// stays centred on that text's cap height).
+pub(super) fn align_shift(g: &SGlyph, a: vectorcraft_doc::CharAlign, line_em: f64, vertical: bool) -> f64 {
+ use vectorcraft_doc::CharAlign;
+ let icf = || g.face.icf_margins();
+ let k = match a {
+ CharAlign::RomanBaseline => return 0.0,
+ CharAlign::EmBoxTop => 0.5,
+ CharAlign::EmBoxCenter => 0.0,
+ CharAlign::EmBoxBottom => -0.5,
+ CharAlign::IcfTop => 0.5 - if vertical { icf().right } else { icf().top },
+ CharAlign::IcfBottom => -0.5 + if vertical { icf().left } else { icf().bottom },
+ };
+ (g.face.ideographic_centre() + k) * (line_em - glyph_em(g)).max(0.0)
+}
+
+/// The length an upright glyph takes down the column before tracking and justification: its
+/// vertical advance (the font's vertical metrics), else its advance, at least one em.
+pub(super) fn upright_cell(g: &SGlyph) -> f64 {
+ match g.face.vertical_glyph(g.gid) {
+ Some((advance, _)) => advance * g.sy,
+ None => (g.face.advance(g.gid) * g.sx).max(g.face.units_per_em() * g.sx),
+ }
+}
+
+/// Height above the baseline (line space) of the centre of an upright glyph's `cell`, the point it
+/// turns about: from the font's vertical metrics, the cell hanging from the glyph's vertical origin;
+/// else the centre of the ideographic em box ([`EM_CENTER`] of the size `em`).
+pub(super) fn upright_centre(g: &SGlyph, cell: f64, em: f64) -> f64 {
+ match g.face.vertical_glyph(g.gid) {
+ Some((_, origin)) => origin * g.sy - cell * 0.5,
+ None => EM_CENTER * em,
+ }
+}
+
+/// Height of the centre of the ideographic em box above the baseline, in ems (the em box runs
+/// from 0.12 em below the baseline to 0.88 em above it), for fonts without vertical metrics.
+pub(super) const EM_CENTER: f64 = 0.38;
+
+/// A quarter turn clockwise (y down), exact: line space → text space for vertical type.
+pub(super) const QUARTER_TURN: Affine = Affine::new([0.0, 1.0, -1.0, 0.0, 0.0, 0.0]);
+
+/// Does the glyph stand upright in vertical type? CJK characters and symbols do (their vertical
+/// forms come from the font's `vert` feature); Latin letters, digits and other characters lie on
+/// their side. Brackets, the long vowel mark and similar marks that need a vertical form lie on
+/// their side when the font has none (Unicode's Vertical_Orientation Tr).
+/// Fullwidth !/? instead keep the nominal glyph upright (Tu fallback, UAX #50 §3.1):
+/// <https://www.unicode.org/reports/tr50/#vo>.
+pub(super) fn stands_upright(g: &SGlyph) -> bool {
+ let c = g.ch as u32;
+ let upright = matches!(c,
+ 0x00A7 | 0x00A9 | 0x00AE | 0x00B1 | 0x00BC..=0x00BE | 0x00D7 | 0x00F7
+ | 0x2016 | 0x2020 | 0x2021 | 0x2030 | 0x2031 | 0x203B | 0x203C | 0x2042 | 0x2047..=0x2049 | 0x2051
+ | 0x20DD..=0x20E0 | 0x20E2..=0x20E4 | 0x2100..=0x2101 | 0x2103..=0x2109 | 0x210F | 0x2113 | 0x2116 | 0x2117
+ | 0x211E..=0x2123 | 0x2125 | 0x2127 | 0x2129 | 0x212E | 0x2135..=0x213F | 0x2145..=0x214A | 0x214C | 0x214D | 0x214F..=0x2189
+ | 0x2460..=0x24FF | 0x25A0..=0x27BF | 0x2B12..=0x2B2F | 0x2B50..=0x2B59
+ | 0x1100..=0x11FF | 0x2E80..=0x303F | 0x3040..=0xA4CF | 0xA960..=0xA97F | 0xAC00..=0xD7FF
+ | 0xE000..=0xFAFF | 0xFE10..=0xFE1F | 0xFE30..=0xFE4F | 0xFE50..=0xFE6F | 0xFF00..=0xFFE7
+ | 0x1F000..=0x1FAFF | 0x20000..=0x3FFFF);
+ if !upright {
+ return false;
+ }
+ let needs_vertical_form = matches!(c,
+ 0x3001 | 0x3002 | 0x3008..=0x3011 | 0x3013..=0x301F | 0x3030 | 0x30A0 | 0x30FC
+ | 0xFE50..=0xFE52 | 0xFE59..=0xFE5E | 0xFF08 | 0xFF09 | 0xFF0C | 0xFF0E | 0xFF1A | 0xFF1B
+ | 0xFF3B | 0xFF3D | 0xFF3F | 0xFF5B..=0xFF60 | 0xFFE3);
+ // Without a vertical alternate the shaped glyph is the nominal one.
+ !needs_vertical_form || g.gid != g.face.glyph_for(g.ch)
+}
+
+pub(super) fn finish_bounds(out: &mut TextLayout) {
+ let xf = out.line_xf;
+ let mut b: Option<Rect> = None;
+ let mut add = |r: Rect| b = Some(b.map_or(r, |b| b.union(r)));
+ for g in &out.glyphs {
+ if !g.outline.elements().is_empty() {
+ add(g.outline.bounding_box());
+ }
+ if let Some((image, xf)) = g.placed_image() {
+ add(xf.transform_rect_bbox(image.rect()));
+ }
+ if let Some(b) = g.colour.as_ref().and_then(|c| c.geometric_bounds()) {
+ add(g.xf.transform_rect_bbox(b));
+ }
+ }
+ // Ruby: covered by its line's ascent, but its ink can overhang sideways past the line.
+ for g in &out.ruby {
+ if !g.outline.elements().is_empty() {
+ add(g.outline.bounding_box());
+ }
+ }
+ for i in &out.inlines {
+ add(i.bounds);
+ }
+ if !out.on_path {
+ for l in &out.lines {
+ add(xf.transform_rect_bbox(Rect::new(l.x0.min(l.x1), l.baseline - l.ascent, l.x0.max(l.x1), l.baseline + l.descent)));
+ }
+ }
+ out.bounds = b.unwrap_or_default();
+}
+
+/// Space left in each cell after flowing top-aligned: (space above the first line's ascent, space
+/// below the last line's descent, number of distinct baselines). Cells without lines are `None`.
+fn cell_space(out: &TextLayout, regions: &[Region]) -> Vec<Option<(f64, f64, usize)>> {
+ regions
+ .iter()
+ .enumerate()
+ .map(|(ri, r)| {
+ let mut top = f64::INFINITY;
+ let mut bottom = f64::NEG_INFINITY;
+ let mut baselines: Vec<f64> = vec![];
+ for l in out.lines.iter().filter(|l| l.region == ri) {
+ top = top.min(l.baseline - l.ascent);
+ bottom = bottom.max(l.baseline + l.descent);
+ if !baselines.iter().any(|b| (b - l.baseline).abs() < 1e-6) {
+ baselines.push(l.baseline);
+ }
+ }
+ if baselines.is_empty() || !top.is_finite() || !bottom.is_finite() {
+ return None;
+ }
+ // Never negative: a full (or overflowing) cell stays where top alignment put it.
+ Some(((top - r.top()).max(0.0), (r.bottom() - bottom).max(0.0), baselines.len()))
+ })
+ .collect()
+}
+
+/// Area Type Options "Align" other than Top: move each cell's lines down. Rectangular cells
+/// without text wrap shift their lines (centre: half the space left below the last line;
+/// bottom: all of it; justify: the first line stays, each further line gets an equal share of it).
+/// Other frames give lines different widths at different heights, so the text flows again with
+/// each cell's lines started lower (or spaced wider) until it settles, at most eight passes; a
+/// pass that would push text out of the frame is undone and retried with half the step.
+pub(super) fn align_vertically(cx: &mut Ctx<'_>, paras: &[Range<usize>], t: &TextObject, regions: &mut [Region]) {
+ let align = cx.opts.vertical_align;
+ let plain = regions.iter().all(|r| (r.rect || r.polys.is_empty()) && r.wraps.is_empty());
+ if plain {
+ let space = cell_space(&cx.out, regions);
+ // Each distinct baseline's index within its cell, for justify.
+ let mut seen: Vec<Vec<f64>> = vec![vec![]; regions.len()];
+ let offs: Vec<f64> = cx
+ .out
+ .lines
+ .iter()
+ .map(|l| {
+ let Some(Some((_, below, n))) = space.get(l.region).copied() else { return 0.0 };
+ match align {
+ VerticalAlign::Top => 0.0,
+ VerticalAlign::Center => below * 0.5,
+ VerticalAlign::Bottom => below,
+ VerticalAlign::Justify => {
+ let Some(s) = seen.get_mut(l.region) else { return 0.0 };
+ let k = s.iter().position(|b| (b - l.baseline).abs() < 1e-6).unwrap_or_else(|| {
+ s.push(l.baseline);
+ s.len() - 1
+ });
+ if n > 1 { below * k as f64 / (n - 1) as f64 } else { 0.0 }
+ }
+ }
+ })
+ .collect();
+ for (l, d) in cx.out.lines.iter_mut().zip(&offs) {
+ l.baseline += d;
+ }
+ for g in &mut cx.out.glyphs {
+ let d = offs.get(g.line).copied().unwrap_or(0.0);
+ if d != 0.0 {
+ let m = Affine::translate((0.0, d));
+ g.outline.apply_affine(m);
+ g.xf = m * g.xf;
+ g.origin.y += d;
+ }
+ }
+ // Inline art moves with its glyph's line.
+ for i in &mut cx.out.inlines {
+ let d = cx.out.glyphs.get(i.glyph).and_then(|g| offs.get(g.line)).copied().unwrap_or(0.0);
+ if d != 0.0 {
+ let m = Affine::translate((0.0, d));
+ i.xf = m * i.xf;
+ i.bounds = m.transform_rect_bbox(i.bounds);
+ }
+ }
+ return;
+ }
+ let laid_out = |out: &TextLayout| out.lines.last().map_or(0, |l| l.end);
+ // How much of the measured space a pass takes up: halved after a pass that lost text.
+ let mut step = 1.0;
+ for _ in 0..8 {
+ let space = cell_space(&cx.out, regions);
+ let mut moved = false;
+ let saved: Vec<(f64, f64)> = regions.iter().map(|r| (r.shift, r.gap)).collect();
+ for (r, s) in regions.iter_mut().zip(&space) {
+ let Some((above, below, n)) = *s else { continue };
+ let (shift, gap) = match align {
+ VerticalAlign::Top => (r.shift, r.gap),
+ VerticalAlign::Center => (r.shift + (below - above) * 0.5 * step, r.gap),
+ VerticalAlign::Bottom => (r.shift + below * step, r.gap),
+ VerticalAlign::Justify if n > 1 => (r.shift, r.gap + below * step / (n - 1) as f64),
+ VerticalAlign::Justify => (r.shift, r.gap),
+ };
+ let (shift, gap) = (shift.clamp(0.0, r.cell.height().max(0.0)), gap.clamp(0.0, r.cell.height().max(0.0)));
+ if (shift - r.shift).abs() > 0.25 || (gap - r.gap).abs() > 0.01 {
+ moved = true;
+ }
+ r.shift = shift;
+ r.gap = gap;
+ }
+ if !moved {
+ return;
+ }
+ let before = laid_out(&cx.out);
+ let prev = (
+ std::mem::take(&mut cx.out.glyphs),
+ std::mem::take(&mut cx.out.lines),
+ std::mem::take(&mut cx.out.inlines),
+ std::mem::take(&mut cx.out.markers),
+ std::mem::replace(&mut cx.out.overflow, false),
+ );
+ flow(cx, paras, t, Some(regions));
+ if laid_out(&cx.out) < before {
+ // Text no longer fits (lines got narrower, or flow around a wrap object): undo the
+ // pass and try a smaller step.
+ (cx.out.glyphs, cx.out.lines, cx.out.inlines, cx.out.markers, cx.out.overflow) = prev;
+ for (r, (shift, gap)) in regions.iter_mut().zip(saved) {
+ r.shift = shift;
+ r.gap = gap;
+ }
+ step *= 0.5;
+ if step < 0.1 {
+ return;
+ }
+ }
+ }
+}
+
+#[cfg(test)]
+#[test]
+fn japanese_letters_for_the_latin_space_are_kana_kanji_and_marks_not_hangul_or_punctuation() {
+ for c in ['あ', 'カ', '漢', '々', '〆', '〇', 'A'] {
+ assert!(is_japanese_letter(c), "{c}");
+ }
+ // Hangul in every form: syllables, compatibility jamo (ㄱ ㅏ), half-width jamo (ᄀ).
+ for c in ['한', 'ㄱ', 'ㅏ', '\u{FFA1}', '。', '「', '・', '、', 'a'] {
+ assert!(!is_japanese_letter(c), "{c}");
+ }
+}