From 935dc0084680a3045b935ba303ab3ea08c38e1e7 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 19:17:13 +0000 Subject: [PATCH 1/4] Share paragraph-wide line composer --- crates/text/src/composer.rs | 364 ++++++++++++++++++++++++++++++++++++ crates/text/src/lib.rs | 3 + 2 files changed, 367 insertions(+) create mode 100644 crates/text/src/composer.rs diff --git a/crates/text/src/composer.rs b/crates/text/src/composer.rs new file mode 100644 index 000000000..d6edd48d3 --- /dev/null +++ b/crates/text/src/composer.rs @@ -0,0 +1,364 @@ +//! Every-line composer: a Knuth–Plass style total-fit line breaker. +//! +//! Boxes are the paragraph's glyphs, glue is its spaces, and penalties are break opportunities +//! after hyphens/dashes/CJK and at hyphenation points. The breaks minimise the sum of squared +//! (badness + penalty) demerits over the whole paragraph, plus a demerit when neighbouring lines +//! fall in fitness classes more than one apart (a tight line next to a loose one). +//! +//! - **Justified** lines: word spacing, letter spacing and glyph scaling may stretch and shrink +//! within the paragraph's Justification options (each glyph's [`Flexibility`]); the badness comes from +//! the stretch/shrink ratio, so loose lines are traded for evenly spaced ones. +//! - **Ragged** lines (left/centre/right aligned): spaces keep their width, so a line never +//! shrinks (it must fit). The badness comes from the line's leftover space measured against a +//! rag zone of a sixth of the line width, so the rag is even rather than full lines followed by +//! a short one, and hyphenating costs less. The last line costs nothing unless it is shorter +//! than a third of the width (a word or two left dangling). + +/// Glyph measurements needed by the paragraph composer. +pub trait Glyph { + fn advance(&self) -> f64; + fn is_space(&self) -> bool; + fn is_soft_hyphen(&self) -> bool; +} + +/// Stretch and shrink available for a glyph. +pub trait Flexibility { + fn stretch(&self) -> f64; + fn shrink(&self) -> f64; +} + +const HYPHEN_PENALTY: f64 = 50.0; +const DOUBLE_HYPHEN_DEMERITS: f64 = 3000.0; +const LINE_PENALTY: f64 = 10.0; +/// Demerits for adjacent lines whose fitness classes differ by more than one. +const ADJ_DEMERITS_JUSTIFIED: f64 = 10_000.0; +const ADJ_DEMERITS_RAGGED: f64 = 1_000.0; +/// Ragged lines only gain from hyphenation by filling the rag, so it costs less than in +/// justified text (where it also evens the word spacing). +const HYPHEN_PENALTY_RAGGED: f64 = 25.0; +/// Ragged text: leftover space is measured in units of this fraction of the line width. +const RAG_ZONE: f64 = 1.0 / 6.0; +/// Ragged text: a last line shorter than this fraction of the width is penalised, by how much +/// shorter it is in units of `SHORT_LAST_ZONE` of the width. +const SHORT_LAST: f64 = 1.0 / 3.0; +const SHORT_LAST_ZONE: f64 = 1.0 / 3.0; +/// Give up (fall back to the single-line composer) beyond this many active breakpoints. +const MAX_ACTIVE: usize = 4096; +const EPS: f64 = 1e-6; + +/// A place a line may end: glyph index `end` (exclusive), plus the width of the hyphen that is +/// added when breaking there (0 = no hyphen). +#[derive(Clone, Copy, Debug, PartialEq)] +pub struct Breakpoint { + pub end: usize, + pub hyphen: f64, +} + +/// How a paragraph is composed. +#[derive(Clone, Copy, Debug)] +pub struct Params { + /// The last line is justified too (Justify All). + pub justify_last: bool, + /// Left/centre/right aligned text: spaces keep their width and lines are scored by their rag. + pub ragged: bool, + /// Maximum stretch ratio (justified) or leftover space in rag zones (ragged) of a line. + pub tolerance: f64, + /// Lines from this index on all have the same width, so their line numbers are interchangeable + /// (keeps the number of active breakpoints small). + pub uniform_from: usize, + /// Hyphen Limit: the most consecutive lines that may end with a hyphen before a hyphenation + /// point is no longer a break; 0 sets no limit. A soft hyphen stays a break and counts. + pub hyphen_limit: usize, +} + +/// The search gave up: it ran past its budget ([`Measure::line`]). +#[derive(Debug)] +pub struct Exhausted; + +/// Where each line of a paragraph goes and how wide it is: the measure a line gets may depend on +/// the lines set above it (their heights move it down a shaped frame, or past a wrap object). +pub trait Measure { + /// What the measure of the next line depends on; breaks reached with equal states are + /// interchangeable from there on. + type State: Clone + PartialEq; + /// The state of the paragraph's first line. + fn first(&mut self) -> Self::State; + /// The width of the line of glyphs `pos..end` set from `state`, and the state of the line + /// after it; `Ok(None)` when the line can't be set (the frame is full), and [`Exhausted`] when + /// the search is to stop. + fn line(&mut self, state: &Self::State, pos: usize, end: usize) -> Result, Exhausted>; + /// Whether a line from `state` longer than `pos..end`, which [`Measure::line`] just measured, + /// may get more room than it. While it may, a line from `state` that is too long, or that + /// can't be set, does not end the reach of `state`. Lines from a state are all as wide by + /// default. + fn may_widen(&mut self, _state: &Self::State, _pos: usize, _end: usize) -> bool { + false + } +} + +/// Line widths by line number: `width(k)` for line `k`, lines from `uniform_from` on all as wide. +struct ByLine<'a> { + width: &'a dyn Fn(usize) -> f64, + uniform_from: usize, +} + +impl Measure for ByLine<'_> { + type State = usize; + fn first(&mut self) -> usize { + 0 + } + fn line(&mut self, &line: &usize, _: usize, _: usize) -> Result, Exhausted> { + Ok(Some(((self.width)(line), (line + 1).min(self.uniform_from)))) + } +} + +struct Node { + pos: usize, + /// The measure of the next line (its line number, clamped to `uniform_from`, for [`compose`]). + state: S, + fitness: u8, + demerits: f64, + /// Lines in a row ending with a hyphen up to this break (at most `hyphen_limit`, or 1 with no + /// limit); 0 when this break has no hyphen. + hyphens: usize, + prev: Option, +} + +/// Fitness class 0 (tight) … 3 (very loose) of a line with adjustment ratio `r`. +fn fitness(r: f64, ragged: bool) -> u8 { + let bounds = if ragged { [0.15, 0.4, 0.75] } else { [-0.5, 0.5, 1.0] }; + if r < bounds[0] { + 0 + } else if r <= bounds[1] { + 1 + } else if r <= bounds[2] { + 2 + } else { + 3 + } +} + +/// Adjustment ratio for a candidate line; `None` means a ragged line is already too long. +fn adjustment_ratio(natural: f64, width: f64, stretch: f64, shrink: f64, last: bool, p: &Params) -> Option { + if p.ragged { + if natural > width + EPS { + return None; + } + return Some(if last && !p.justify_last { + ((width * SHORT_LAST - natural) / (width * SHORT_LAST_ZONE).max(1.0)).max(0.0) + } else { + (width - natural).max(0.0) / (width * RAG_ZONE).max(1.0) + }); + } + Some(if natural < width { + if last && !p.justify_last { + 0.0 + } else if stretch > EPS { + (width - natural) / stretch + } else { + f64::INFINITY + } + } else if natural > width { + if shrink > EPS { (width - natural) / shrink } else { f64::NEG_INFINITY } + } else { + 0.0 + }) +} + +/// Compose the paragraph `g` into lines. `width(k)` is the available width of line `k`; +/// `start_credit(i)` is the width a wrapped line starting at glyph `i` gives back (Mojikumi sets +/// an opening bracket there flush with the line's start); `end_credit(t)` is the width a line whose +/// last character is glyph `t - 1` gives back (Mojikumi sets a closing mark there half width), at +/// most that glyph's advance, and nothing at a hyphenation point; `cands` are the break opportunities +/// in increasing order (the paragraph end is added); `flex` holds how far each glyph may stretch +/// and shrink in a justified line. +/// Returns `(end, hyphen)` per line, or `None` if no set of breaks fits within the tolerance +/// (the caller then falls back to single-line breaking). +pub fn compose( + g: &[G], + width: &dyn Fn(usize) -> f64, + start_credit: &dyn Fn(usize) -> f64, + end_credit: &dyn Fn(usize) -> f64, + cands: &[Breakpoint], + flex: &[F], + p: &Params, +) -> Option> { + compose_with(g, &mut ByLine { width, uniform_from: p.uniform_from }, start_credit, end_credit, cands, flex, p) +} + +/// [`compose`] with each line's width from `measure`, which follows where the lines above it went. +pub fn compose_with( + g: &[G], + measure: &mut M, + start_credit: &dyn Fn(usize) -> f64, + end_credit: &dyn Fn(usize) -> f64, + cands: &[Breakpoint], + flex: &[F], + p: &Params, +) -> Option> { + let n = g.len(); + if n == 0 { + return Some(vec![]); + } + // Prefix sums of advances and of how far the glyphs may stretch and shrink. + let mut w = vec![0.0; n + 1]; + let mut st = vec![0.0; n + 1]; + let mut sh = vec![0.0; n + 1]; + for (i, gl) in g.iter().enumerate() { + let f = flex.get(i); + w[i + 1] = w[i] + gl.advance(); + st[i + 1] = st[i] + f.map_or(0.0, Flexibility::stretch); + sh[i + 1] = sh[i] + f.map_or(0.0, Flexibility::shrink); + } + if !w[n].is_finite() { + return None; + } + // Trailing spaces are dropped at a break. + let trim = |mut b: usize, a: usize| { + while b > a && g.get(b - 1).is_some_and(Glyph::is_space) { + b -= 1; + } + b + }; + let line_end_credit = |t: usize| { + let credit = end_credit(t); + let most = t.checked_sub(1).and_then(|k| g.get(k)).map_or(0.0, |gl| gl.advance().max(0.0)); + if credit.is_finite() { credit.clamp(0.0, most) } else { 0.0 } + }; + let mut all: Vec = cands.iter().copied().filter(|c| c.end > 0 && c.end < n).collect(); + all.push(Breakpoint { end: n, hyphen: 0.0 }); + let (adj_demerits, hyphen_penalty) = + if p.ragged { (ADJ_DEMERITS_RAGGED, HYPHEN_PENALTY_RAGGED) } else { (ADJ_DEMERITS_JUSTIFIED, HYPHEN_PENALTY) }; + let mut nodes = vec![Node { pos: 0, state: measure.first(), fitness: 1, demerits: 0.0, hyphens: 0, prev: None }]; + let mut active: Vec = vec![0]; + for bp in &all { + let last = bp.end == n; + let hyphen = bp.hyphen > 0.0; + // `automatic` is true for a hyphenation point and false for a soft hyphen typed in the text. + let automatic = hyphen && !bp.end.checked_sub(1).and_then(|k| g.get(k)).is_some_and(Glyph::is_soft_hyphen); + let mut best: Vec<(M::State, u8, usize, f64, usize)> = vec![]; // (state, fitness, hyphens, demerits, from) + let mut keep = Vec::with_capacity(active.len()); + for &ai in &active { + let Some(a) = nodes.get(ai) else { continue }; + let t = trim(bp.end, a.pos); + let credit = if a.pos > 0 { start_credit(a.pos) } else { 0.0 }; + // A line that ends with a hyphen ends with it, not with its last character. At most the + // last glyph's advance, so a longer line from the same node is never narrower. + let end = if hyphen || t <= a.pos { 0.0 } else { line_end_credit(t) }; + let natural = w[t] - w[a.pos] - credit - end + bp.hyphen; + // A line that can't be set (no room left in the frame) ends this node's reach, unless a + // longer line may be placed elsewhere (a taller line steps down the frame by its own + // leading). + let Some((lw, next)) = measure.line(&a.state, a.pos, bp.end).ok()? else { + if measure.may_widen(&a.state, a.pos, bp.end) { + keep.push(ai); + } + continue; + }; + // Adjustment ratio, badness and whether the line ends the active node's reach. + let ratio = adjustment_ratio(natural, lw, st[t] - st[a.pos], sh[t] - sh[a.pos], last, p); + let Some(ratio) = ratio.filter(|&r| r >= -1.0 || r.is_nan()) else { + // Too long already; longer lines from this node only get worse, unless they may + // get more room (a taller line set lower down a shaped frame). + if measure.may_widen(&a.state, a.pos, bp.end) { + keep.push(ai); + } + continue; + }; + keep.push(ai); + if automatic && p.hyphen_limit > 0 && a.hyphens >= p.hyphen_limit { + continue; + } + let free_last = last && (p.ragged || !p.justify_last); + // A line that can't stretch at all (no word spaces, nor letter spacing or glyph scaling + // to vary) never fills its measure, however loose the tolerance. + if (ratio > p.tolerance || ratio == f64::INFINITY) && !(last && (p.ragged || (ratio.is_infinite() && p.justify_last))) { + continue; + } + // Justified lines aren't capped: past a ratio of 4.6 (only reached in the unbounded pass) + // a looser line must still score worse than a less loose one. + let cap = if p.ragged { 10_000.0 } else { f64::INFINITY }; + let badness = if ratio.is_finite() { (100.0 * ratio.abs().powi(3)).min(cap) } else { 10_000.0 }; + let penalty = if hyphen { hyphen_penalty } else { 0.0 }; + let mut d = (LINE_PENALTY + badness).powi(2) + penalty * penalty; + if hyphen && a.hyphens > 0 { + d += DOUBLE_HYPHEN_DEMERITS; + } + // A ragged last line's length says nothing about the rag: it keeps its neighbour's class. + let fit = if p.ragged && free_last { a.fitness } else { fitness(ratio, p.ragged) }; + if a.prev.is_some() && fit.abs_diff(a.fitness) > 1 { + d += adj_demerits; + } + let total = a.demerits + d; + // With a limit, breaks reached with different runs of hyphenated lines stay apart. + let hyphens = match (hyphen, p.hyphen_limit) { + (false, _) => 0, + (true, 0) => 1, + (true, limit) => (a.hyphens + 1).min(limit), + }; + match best.iter_mut().find(|b| b.0 == next && b.1 == fit && b.2 == hyphens) { + Some(b) if b.3 <= total => {} + Some(b) => *b = (next, fit, hyphens, total, ai), + None => best.push((next, fit, hyphens, total, ai)), + } + } + active = keep; + for (state, fitness, hyphens, demerits, from) in best { + nodes.push(Node { pos: bp.end, state, fitness, demerits, hyphens, prev: Some(from) }); + active.push(nodes.len() - 1); + } + if active.is_empty() || active.len() > MAX_ACTIVE { + return None; + } + } + let end = nodes.iter().enumerate().filter(|(_, nd)| nd.pos == n && nd.prev.is_some()).min_by(|a, b| a.1.demerits.total_cmp(&b.1.demerits))?.0; + let mut out = vec![]; + let mut cur = Some(end); + while let Some(i) = cur { + let nd = nodes.get(i)?; + if nd.prev.is_some() { + out.push((nd.pos, nd.hyphens > 0)); + } + cur = nd.prev; + if out.len() > n { + return None; + } + } + out.reverse(); + Some(out) +} + +#[cfg(test)] +mod tests { + use super::*; + + struct Unit(char); + impl Glyph for Unit { + fn advance(&self) -> f64 { + 1.0 + } + fn is_space(&self) -> bool { + self.0 == ' ' + } + fn is_soft_hyphen(&self) -> bool { + self.0 == '\u{ad}' + } + } + struct Rigid; + impl Flexibility for Rigid { + fn stretch(&self) -> f64 { + 0.0 + } + fn shrink(&self) -> f64 { + 0.0 + } + } + #[test] + fn composes_ragged_paragraph_and_trims_spaces() { + let glyphs: Vec<_> = "aa bb cc".chars().map(Unit).collect(); + let candidates = [Breakpoint { end: 3, hyphen: 0.0 }, Breakpoint { end: 6, hyphen: 0.0 }]; + let params = Params { justify_last: false, ragged: true, tolerance: 100.0, uniform_from: 0, hyphen_limit: 0 }; + let result = compose(&glyphs, &|_| 3.0, &|_| 0.0, &|_| 0.0, &candidates, &[] as &[Rigid], ¶ms); + assert_eq!(result, Some(vec![(3, false), (6, false), (8, false)])); + } +} diff --git a/crates/text/src/lib.rs b/crates/text/src/lib.rs index ce9c64db5..62e8d0eb7 100644 --- a/crates/text/src/lib.rs +++ b/crates/text/src/lib.rs @@ -26,3 +26,6 @@ pub mod hyphen; pub mod linebreak; #[cfg(feature = "segment")] pub mod segment; + +/// Paragraph-wide line composition with stateful line measurement. +pub mod composer; From b0cbe87bdbad18c5b6d20f2c495234bb207d0505 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 19:18:30 +0000 Subject: [PATCH 2/4] Reject unordered paragraph breaks --- crates/text/src/composer.rs | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/crates/text/src/composer.rs b/crates/text/src/composer.rs index d6edd48d3..905d235b4 100644 --- a/crates/text/src/composer.rs +++ b/crates/text/src/composer.rs @@ -197,6 +197,11 @@ pub fn compose_with( p: &Params, ) -> Option> { let n = g.len(); + // The search assumes increasing break positions when indexing its prefix sums. + // Reject malformed candidates before they can make a later line run backwards. + if cands.windows(2).any(|pair| pair[0].end >= pair[1].end) { + return None; + } if n == 0 { return Some(vec![]); } From 54485a66ceb7a7b6eaa584deee5bb76a85ea310f Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 19:19:04 +0000 Subject: [PATCH 3/4] Test malformed break ordering --- crates/text/src/composer.rs | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/crates/text/src/composer.rs b/crates/text/src/composer.rs index 905d235b4..de1e4f287 100644 --- a/crates/text/src/composer.rs +++ b/crates/text/src/composer.rs @@ -199,7 +199,7 @@ pub fn compose_with( let n = g.len(); // The search assumes increasing break positions when indexing its prefix sums. // Reject malformed candidates before they can make a later line run backwards. - if cands.windows(2).any(|pair| pair[0].end >= pair[1].end) { + if cands.windows(2).any(|pair| pair[0].end > pair[1].end) { return None; } if n == 0 { @@ -358,6 +358,14 @@ mod tests { 0.0 } } + #[test] + fn rejects_breaks_that_move_backwards() { + let glyphs: Vec<_> = "abcd".chars().map(Unit).collect(); + let candidates = [Breakpoint { end: 3, hyphen: 0.0 }, Breakpoint { end: 1, hyphen: 0.0 }]; + let params = Params { justify_last: false, ragged: true, tolerance: 100.0, uniform_from: 0, hyphen_limit: 0 }; + assert_eq!(compose(&glyphs, &|_| 3.0, &|_| 0.0, &|_| 0.0, &candidates, &[] as &[Rigid], ¶ms), None); + } + #[test] fn composes_ragged_paragraph_and_trims_spaces() { let glyphs: Vec<_> = "aa bb cc".chars().map(Unit).collect(); From 5acfead5b6ea10fcc8e295ca6f913c162188dfe9 Mon Sep 17 00:00:00 2001 From: FredApps <153173854+FredApps@users.noreply.github.com> Date: Mon, 16 Nov 2026 07:08:34 +0100 Subject: [PATCH 4/4] text: cover the paragraph composer's justified, hyphen-limit, credit and measure paths --- crates/text/src/composer.rs | 152 ++++++++++++++++++++++++++++++++++++ 1 file changed, 152 insertions(+) diff --git a/crates/text/src/composer.rs b/crates/text/src/composer.rs index de1e4f287..fc2067f3f 100644 --- a/crates/text/src/composer.rs +++ b/crates/text/src/composer.rs @@ -374,4 +374,156 @@ mod tests { let result = compose(&glyphs, &|_| 3.0, &|_| 0.0, &|_| 0.0, &candidates, &[] as &[Rigid], ¶ms); assert_eq!(result, Some(vec![(3, false), (6, false), (8, false)])); } + struct Flex(f64, f64); + impl Flexibility for Flex { + fn stretch(&self) -> f64 { + self.0 + } + fn shrink(&self) -> f64 { + self.1 + } + } + struct Wide(f64); + impl Glyph for Wide { + fn advance(&self) -> f64 { + self.0 + } + fn is_space(&self) -> bool { + false + } + fn is_soft_hyphen(&self) -> bool { + false + } + } + fn justified() -> Params { + Params { justify_last: false, ragged: false, tolerance: 10.0, uniform_from: 0, hyphen_limit: 0 } + } + fn units(text: &str) -> Vec { + text.chars().map(Unit).collect() + } + fn brk(end: usize, hyphen: f64) -> Breakpoint { + Breakpoint { end, hyphen } + } + + #[test] + fn fitness_classes_and_adjustment_ratios() { + assert_eq!([-0.6, 0.0, 0.7, 2.0].map(|r| fitness(r, false)), [0, 1, 2, 3]); + assert_eq!([0.1, 0.3, 0.5, 0.9].map(|r| fitness(r, true)), [0, 1, 2, 3]); + let j = justified(); + assert_eq!(adjustment_ratio(8.0, 10.0, 4.0, 0.0, false, &j), Some(0.5)); + assert_eq!(adjustment_ratio(8.0, 10.0, 0.0, 0.0, false, &j), Some(f64::INFINITY)); + assert_eq!(adjustment_ratio(8.0, 10.0, 4.0, 0.0, true, &j), Some(0.0)); + assert_eq!(adjustment_ratio(12.0, 10.0, 0.0, 4.0, false, &j), Some(-0.5)); + assert_eq!(adjustment_ratio(12.0, 10.0, 0.0, 0.0, false, &j), Some(f64::NEG_INFINITY)); + assert_eq!(adjustment_ratio(10.0, 10.0, 0.0, 0.0, false, &j), Some(0.0)); + let all = Params { justify_last: true, ..j }; + assert_eq!(adjustment_ratio(8.0, 10.0, 4.0, 0.0, true, &all), Some(0.5)); + let ragged = Params { ragged: true, ..j }; + assert_eq!(adjustment_ratio(11.0, 10.0, 0.0, 0.0, false, &ragged), None); + } + + #[test] + fn empty_and_unmeasurable_paragraphs() { + let none: [Unit; 0] = []; + assert_eq!(compose(&none, &|_| 3.0, &|_| 0.0, &|_| 0.0, &[], &[] as &[Rigid], &justified()), Some(vec![])); + let huge = [Wide(f64::INFINITY)]; + assert_eq!(compose(&huge, &|_| 3.0, &|_| 0.0, &|_| 0.0, &[], &[] as &[Rigid], &justified()), None); + } + + #[test] + fn justified_lines_stretch_and_shrink_within_tolerance() { + let glyphs = units("a a b b"); + let flex: Vec<_> = glyphs.iter().map(|g| if g.0 == ' ' { Flex(1.0, 0.5) } else { Flex(0.0, 0.0) }).collect(); + let cands = [brk(4, 0.0)]; + // "a a" (the trailing space is dropped) stretches its inner space to fill 4 units... + let lines = compose(&glyphs, &|_| 4.0, &|_| 0.0, &|_| 0.0, &cands, &flex, &justified()); + assert_eq!(lines, Some(vec![(4, false), (7, false)])); + // ...or shrinks it into 2.75. + let lines = compose(&glyphs, &|_| 2.75, &|_| 0.0, &|_| 0.0, &cands, &flex, &justified()); + assert_eq!(lines, Some(vec![(4, false), (7, false)])); + // Rigid glyphs can't fill a wider line except the last, so there is no fit. + let rigid: Vec<_> = glyphs.iter().map(|_| Rigid).collect(); + assert_eq!(compose(&glyphs, &|_| 4.0, &|_| 0.0, &|_| 0.0, &cands, &rigid, &justified()), None); + // Justify All lets an unstretchable last line through. + let all = Params { justify_last: true, ..justified() }; + let word = units("ab"); + assert_eq!(compose(&word, &|_| 4.0, &|_| 0.0, &|_| 0.0, &[], &[Rigid, Rigid], &all), Some(vec![(2, false)])); + } + + #[test] + fn hyphen_limit_and_soft_hyphens() { + // "ab-cd-ef" with hyphenation points after each pair: every line wants a hyphen. + let glyphs = units("abcdef"); + let cands = [brk(2, 1.0), brk(4, 1.0)]; + let ragged = Params { justify_last: false, ragged: true, tolerance: 100.0, uniform_from: 0, hyphen_limit: 0 }; + let free = compose(&glyphs, &|_| 3.0, &|_| 0.0, &|_| 0.0, &cands, &[] as &[Rigid], &ragged).unwrap(); + assert_eq!(free, vec![(2, true), (4, true), (6, false)]); + // A limit of one hyphenated line in a row forbids the second automatic hyphen. + let limited = Params { hyphen_limit: 1, ..ragged }; + assert_eq!(compose(&glyphs, &|_| 3.0, &|_| 0.0, &|_| 0.0, &cands, &[] as &[Rigid], &limited), None); + // A typed soft hyphen stays a break regardless of the limit. + let soft = units("ab\u{ad}cd\u{ad}ef"); + let cands = [brk(3, 1.0), brk(6, 1.0)]; + let out = compose(&soft, &|_| 4.0, &|_| 0.0, &|_| 0.0, &cands, &[] as &[Rigid], &limited).unwrap(); + assert_eq!(out, vec![(3, true), (6, true), (8, false)]); + } + + #[test] + fn credits_are_clamped_to_the_glyph_and_ignored_when_not_finite() { + let glyphs = units("aa bb"); + let cands = [brk(3, 0.0)]; + let ragged = Params { justify_last: false, ragged: true, tolerance: 100.0, uniform_from: 0, hyphen_limit: 0 }; + for credit in [f64::NAN, 5.0, -1.0] { + let out = compose(&glyphs, &|_| 2.0, &|_| 0.0, &|_| credit, &cands, &[] as &[Rigid], &ragged); + assert_eq!(out, Some(vec![(3, false), (5, false)]), "{credit}"); + } + // A start credit gives a wrapped line room back. + let out = compose(&units("aa bbb"), &|_| 2.0, &|_| 1.0, &|_| 0.0, &cands, &[] as &[Rigid], &ragged); + assert_eq!(out, Some(vec![(3, false), (6, false)])); + } + + /// Two lines of width 2, then the frame is full; a line may widen when the frame says so. + struct Frame { + widen: bool, + calls: usize, + } + impl Measure for Frame { + type State = usize; + fn first(&mut self) -> usize { + 0 + } + fn line(&mut self, &k: &usize, _: usize, _: usize) -> Result, Exhausted> { + self.calls += 1; + if self.calls > 1_000 { + return Err(Exhausted); + } + Ok((k < 2).then_some((2.0, k + 1))) + } + fn may_widen(&mut self, _: &usize, _: usize, _: usize) -> bool { + self.widen + } + } + + #[test] + fn measure_can_end_reach_widen_or_exhaust() { + let ragged = Params { justify_last: false, ragged: true, tolerance: 100.0, uniform_from: 0, hyphen_limit: 0 }; + let two = units("aa bb"); + let cands = [brk(3, 0.0)]; + let mut frame = Frame { widen: false, calls: 0 }; + assert_eq!(compose_with(&two, &mut frame, &|_| 0.0, &|_| 0.0, &cands, &[] as &[Rigid], &ragged), Some(vec![(3, false), (5, false)])); + // A third line can't be set: no fit, whether or not the frame may widen. + let three = units("aa bb cc"); + let cands = [brk(3, 0.0), brk(6, 0.0)]; + for widen in [false, true] { + let mut frame = Frame { widen, calls: 0 }; + assert_eq!(compose_with(&three, &mut frame, &|_| 0.0, &|_| 0.0, &cands, &[] as &[Rigid], &ragged), None); + } + // Too long for the line, but the frame may widen: the node stays active. + let long = units("aaa b"); + let mut frame = Frame { widen: true, calls: 0 }; + assert_eq!(compose_with(&long, &mut frame, &|_| 0.0, &|_| 0.0, &[brk(4, 0.0)], &[] as &[Rigid], &ragged), None); + // The measure may stop the search. + let mut frame = Frame { widen: false, calls: 1_000 }; + assert_eq!(compose_with(&two, &mut frame, &|_| 0.0, &|_| 0.0, &[brk(3, 0.0)], &[] as &[Rigid], &ragged), None); + } }