Files
filmcraft/crates/text/src/layout.rs
T
Brandon Thomas dae3b99e96 Merge pull request #1045 from vbasky/fix/926-underline-baseline
Underline follows baseline shift on whole-style text
2026-10-11 19:06:57 -04:00

1194 lines
49 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! Paragraph layout: font fallback, bidi (UAX #9), shaping (OpenType via harfrust: kerning,
//! ligatures, mark positioning, complex scripts), line breaking (UAX #14), alignment, leading,
//! tracking, baseline shift, all caps / small caps, underline. Results are cached.
//!
//! **Per-character styles** ([`layout_rich`]): [`StyleRun`]s give byte ranges their own
//! [`TextStyle`] (font, size, tracking, baseline shift, faux bold / italic, caps, underline).
//! Runs split shaping items, lines grow to fit the largest run, and every [`Glyph`] carries the
//! index of the style it was set in (`run`: 0 = the base style, `i + 1` = `runs[i]`), so renderers
//! can colour runs.
//!
//! Coordinates are pixels, y down. For **point text** (`ParagraphStyle::width == None`) the
//! origin is the alignment point on the first baseline: x = 0 is the left edge (left / justify),
//! the centre (centre) or the right edge (right). For **area text** (`width == Some(w)`) the
//! origin is the top-left of the text box and lines wrap at `w`.
use std::collections::HashMap;
use std::hash::{Hash, Hasher};
use std::ops::Range;
use std::sync::{Arc, Mutex, OnceLock};
use harfrust::{Direction, Feature, Tag, UnicodeBuffer};
use unicode_bidi::{BidiInfo, Level};
use unicode_segmentation::UnicodeSegmentation;
use crate::fonts::{self, FaceId, Resolved};
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub enum Caps {
#[default]
Normal,
All,
Small,
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub enum Align {
#[default]
Left,
Center,
Right,
Justify,
}
/// Character formatting.
#[derive(Clone, Debug, PartialEq)]
pub struct TextStyle {
pub family: String,
pub style: String,
/// Font size in pixels.
pub size: f32,
/// Tracking in 1/1000 em (added after every cluster).
pub tracking: f32,
/// Metric kerning (`kern`).
pub kerning: bool,
/// Standard ligatures (`liga`, `clig`).
pub ligatures: bool,
/// Baseline shift in pixels (positive = up).
pub baseline_shift: f32,
pub faux_bold: bool,
pub faux_italic: bool,
pub caps: Caps,
pub underline: bool,
}
impl Default for TextStyle {
fn default() -> Self {
Self {
family: fonts::DEFAULT_FAMILY.into(),
style: "Regular".into(),
size: 100.0,
tracking: 0.0,
kerning: true,
ligatures: true,
baseline_shift: 0.0,
faux_bold: false,
faux_italic: false,
caps: Caps::Normal,
underline: false,
}
}
}
/// Paragraph formatting.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct ParagraphStyle {
pub align: Align,
/// Extra line spacing in pixels added to the font's natural line height (Premiere's Leading).
pub leading: f32,
/// Wrap width (area text); None = point text.
pub width: Option<f32>,
/// Box height (area text only): lines that end below it are left out, except the first.
/// None = as tall as the text.
pub height: Option<f32>,
/// Base direction: None = from the first strong character.
pub rtl: Option<bool>,
/// Vertical text: characters stack top to bottom, paragraphs are columns laid out right to
/// left. Alignment applies along the column (Left = top, Center, Right = bottom).
pub vertical: bool,
}
fn hf(h: &mut impl Hasher, v: f32) {
v.to_bits().hash(h);
}
impl Hash for TextStyle {
fn hash<H: Hasher>(&self, h: &mut H) {
self.family.hash(h);
self.style.hash(h);
hf(h, self.size);
hf(h, self.tracking);
hf(h, self.baseline_shift);
(self.kerning, self.ligatures, self.faux_bold, self.faux_italic, self.caps, self.underline).hash(h);
}
}
impl Hash for ParagraphStyle {
fn hash<H: Hasher>(&self, h: &mut H) {
self.align.hash(h);
hf(h, self.leading);
self.width.map(f32::to_bits).hash(h);
self.height.map(f32::to_bits).hash(h);
self.rtl.hash(h);
self.vertical.hash(h);
}
}
/// A positioned glyph. `(x, y)` is the glyph origin on its baseline.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Glyph {
pub face: FaceId,
pub id: u32,
pub x: f32,
pub y: f32,
pub size: f32,
/// Byte offset of the cluster in the source text.
pub cluster: usize,
pub synth_bold: bool,
pub synth_italic: bool,
/// Style the glyph was set in: 0 = the base style, `i + 1` = `runs[i]` of [`layout_rich`].
pub run: u16,
}
/// A byte range of the text set in its own style ([`layout_rich`]). Later runs win where runs
/// overlap; ranges are clamped to the text.
#[derive(Clone, Debug, PartialEq)]
pub struct StyleRun {
pub range: Range<usize>,
pub style: TextStyle,
}
impl Hash for StyleRun {
fn hash<H: Hasher>(&self, h: &mut H) {
self.range.hash(h);
self.style.hash(h);
}
}
/// The styles of one layout: `list[0]` is the base style, `list[i + 1]` is run `i`.
struct Styles<'a> {
list: Vec<&'a TextStyle>,
prim: Vec<Resolved>,
/// Style index of every byte (None = all base style).
per_byte: Option<Vec<u16>>,
}
impl<'a> Styles<'a> {
fn new(text: &str, base: &'a TextStyle, runs: &'a [StyleRun]) -> Self {
let mut list = vec![base];
list.extend(runs.iter().map(|r| &r.style));
let prim = list.iter().map(|s| fonts::resolve(&s.family, &s.style)).collect();
let per_byte = (!runs.is_empty()).then(|| {
let mut v = vec![0u16; text.len() + 1];
for (i, r) in runs.iter().enumerate() {
let (a, b) = (r.range.start.min(text.len()), r.range.end.min(text.len()));
for x in v.iter_mut().take(b).skip(a) {
*x = (i + 1).min(u16::MAX as usize) as u16;
}
}
v
});
Styles { list, prim, per_byte }
}
fn at(&self, byte: usize) -> usize {
self.per_byte.as_ref().and_then(|v| v.get(byte)).map_or(0, |&i| i as usize)
}
fn rich(&self) -> bool {
self.per_byte.is_some()
}
}
/// One laid-out line.
#[derive(Clone, Debug, PartialEq)]
pub struct Line {
/// Byte range in the source text (without the terminating newline).
pub range: Range<usize>,
pub baseline: f32,
/// Left edge and width of the line's content (trailing spaces excluded).
pub x: f32,
pub width: f32,
pub ascent: f32,
pub descent: f32,
pub glyphs: Range<usize>,
/// Caret stops `(byte offset, x)` for every character boundary in the line, by byte offset.
pub carets: Vec<(usize, f32)>,
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Layout {
pub glyphs: Vec<Glyph>,
pub lines: Vec<Line>,
/// Underline rectangles `[x0, y0, x1, y1]`.
pub underlines: Vec<[f32; 4]>,
/// Style index of each underline (parallel to `underlines`; see [`Glyph::run`]).
pub underline_runs: Vec<u16>,
/// Logical bounds `[x0, y0, x1, y1]` (line boxes; area text spans the box width).
pub bounds: [f32; 4],
/// The face requested was missing (substituted).
pub missing_font: bool,
/// Lines were left out because they do not fit the box height.
pub overflow: bool,
pub text_len: usize,
/// Laid out vertically (one line per grapheme; columns right to left).
pub vertical: bool,
}
impl Layout {
/// Line index for a caret at byte `pos`.
pub fn line_of(&self, pos: usize) -> usize {
let mut li = 0;
for (i, l) in self.lines.iter().enumerate() {
if l.range.start <= pos {
li = i;
}
}
li
}
/// Caret position `(x, baseline, line)` for byte offset `pos`.
pub fn caret(&self, pos: usize) -> (f32, f32, usize) {
let li = self.line_of(pos);
let Some(l) = self.lines.get(li) else { return (0.0, 0.0, 0) };
let x = l.carets.iter().min_by_key(|(b, _)| b.abs_diff(pos)).map_or(l.x, |c| c.1);
(x, l.baseline, li)
}
/// Nearest caret byte offset to point `(x, y)`.
pub fn hit(&self, x: f32, y: f32) -> usize {
let d = |l: &Line| {
if self.vertical {
let dx = if x < l.x - l.ascent * 0.5 { l.x - l.ascent * 0.5 - x } else { (x - l.x - l.width - l.ascent * 0.5).max(0.0) };
line_dist(l, y) + dx
} else {
line_dist(l, y)
}
};
let Some(l) = self.lines.iter().min_by(|a, b| d(a).total_cmp(&d(b))) else {
return 0;
};
l.carets.iter().min_by(|a, b| (a.1 - x).abs().total_cmp(&(b.1 - x).abs())).map_or(l.range.start, |c| c.0)
}
/// Selection highlight rectangles `[x0, y0, x1, y1]` for the byte range `a..b`.
pub fn selection_rects(&self, a: usize, b: usize) -> Vec<[f32; 4]> {
let (a, b) = (a.min(b), a.max(b));
let mut out = Vec::new();
for l in &self.lines {
let s = a.max(l.range.start);
let e = b.min(l.range.end);
if s > e || (s == e && !(a < l.range.start && b > l.range.end)) {
continue;
}
let xs: Vec<f32> = l.carets.iter().filter(|(p, _)| *p >= s && *p <= e).map(|c| c.1).collect();
if xs.len() < 2 && b <= l.range.end {
continue;
}
let x0 = xs.iter().copied().fold(f32::MAX, f32::min);
let mut x1 = xs.iter().copied().fold(f32::MIN, f32::max);
if b > l.range.end {
x1 += l.ascent * 0.25; // selected newline
}
out.push([x0.min(x1), l.baseline - l.ascent, x1, l.baseline + l.descent]);
}
out
}
}
fn line_dist(l: &Line, y: f32) -> f32 {
let (t, b) = (l.baseline - l.ascent, l.baseline + l.descent);
if y < t {
t - y
} else if y > b {
y - b
} else {
0.0
}
}
struct ShapedGlyph {
face: FaceId,
id: u32,
cluster: usize,
adv: f32,
dx: f32,
dy: f32,
size: f32,
}
struct Item {
range: Range<usize>,
rtl: bool,
glyphs: Vec<ShapedGlyph>,
/// Style index ([`Styles`]).
style: usize,
}
fn upper_single(c: char) -> char {
let mut u = c.to_uppercase();
match (u.next(), u.next()) {
(Some(x), None) => x,
_ => c,
}
}
const SMALL_CAPS_SCALE: f32 = 0.78;
fn uses_vertical_form(c: char) -> bool {
matches!(c as u32, 0x2E80..=0x9FFF | 0xF900..=0xFAFF | 0xFE10..=0xFE1F | 0xFE30..=0xFE4F | 0xFF00..=0xFFEF | 0x20000..=0x3FFFF)
}
fn shape_item(text: &str, chars: &[(usize, char, char)], rtl: bool, face: FaceId, size: f32, style: &TextStyle, vertical: bool) -> Vec<ShapedGlyph> {
let f = fonts::face(face);
let (Some(font), Some(data)) = (f.font(), f.shaper_data()) else { return Vec::new() };
let shaper = data.shaper(&font).build();
let mut buf = UnicodeBuffer::new();
for &(b, _, sc) in chars {
buf.add(if sc == '\t' { ' ' } else { sc }, b as u32);
}
buf.set_direction(if rtl { Direction::RightToLeft } else { Direction::LeftToRight });
buf.guess_segment_properties();
let mut feats = Vec::new();
if vertical && chars.first().is_some_and(|c| uses_vertical_form(c.1)) {
feats.push(Feature::new(Tag::new(b"vert"), 1, ..));
feats.push(Feature::new(Tag::new(b"vrt2"), 1, ..));
}
if !style.kerning {
feats.push(Feature::new(Tag::new(b"kern"), 0, ..));
}
if !style.ligatures {
feats.push(Feature::new(Tag::new(b"liga"), 0, ..));
feats.push(Feature::new(Tag::new(b"clig"), 0, ..));
}
let out = shaper.shape(buf, harfrust::ShapeOptions::new().features(&feats));
let k = size / f.units_per_em();
let _ = text;
out.glyph_infos()
.iter()
.zip(out.glyph_positions())
.map(|(i, p)| ShapedGlyph {
face,
id: i.glyph_id,
cluster: i.cluster as usize,
adv: p.x_advance as f32 * k,
dx: p.x_offset as f32 * k,
dy: p.y_offset as f32 * k,
size,
})
.collect()
}
struct ParaLine {
range: Range<usize>,
glyphs: Vec<Glyph>,
carets: Vec<(usize, f32)>,
content: f32,
left_trim: f32,
ascent: f32,
descent: f32,
/// Underlined segments `(x0, x1, style)` in line coordinates (rich layouts only).
underlines: Vec<(f32, f32, u16)>,
}
/// Lay out one paragraph (no newlines) whose text starts at byte `base` of the whole string.
fn paragraph(text: &str, base: usize, sty: &Styles, para: &ParagraphStyle) -> Vec<ParaLine> {
let style = sty.list[0];
let primary = sty.prim[0];
let pm = fonts::face(primary.face).metrics(style.size);
if text.is_empty() {
return vec![ParaLine {
range: base..base,
glyphs: vec![],
carets: vec![(base, 0.0)],
content: 0.0,
left_trim: 0.0,
ascent: pm.ascent,
descent: pm.descent,
underlines: Vec::new(),
}];
}
let default_level = para.rtl.map(|r| if r { Level::rtl() } else { Level::ltr() });
let bidi = BidiInfo::new(text, default_level);
let pinfo = &bidi.paragraphs[0];
let base_rtl = pinfo.level.is_rtl();
// per char: (byte, char, shaped char), face, level, small, style
let chars: Vec<(usize, char, char, FaceId, bool, bool, usize)> = text
.char_indices()
.map(|(b, c)| {
let si = sty.at(base + b);
let (sc, small) = match sty.list[si].caps {
Caps::Normal => (c, false),
Caps::All => (upper_single(c), false),
Caps::Small if c.is_lowercase() => (upper_single(c), true),
Caps::Small => (c, false),
};
let pf = sty.prim[si].face;
let face = if sc.is_whitespace() { pf } else { fonts::fallback_for(sc, pf) };
(b, c, sc, face, bidi.levels[b].is_rtl(), small, si)
})
.collect();
// items: runs of equal (face, rtl, small, style)
let mut items: Vec<Item> = Vec::new();
let mut i = 0;
while i < chars.len() {
let (face, rtl, small, si) = (chars[i].3, chars[i].4, chars[i].5, chars[i].6);
let mut j = i + 1;
while j < chars.len() && chars[j].3 == face && chars[j].4 == rtl && chars[j].5 == small && chars[j].6 == si {
j += 1;
}
let st = sty.list[si];
let sub: Vec<(usize, char, char)> = chars[i..j].iter().map(|c| (c.0, c.1, c.2)).collect();
let size = if small { st.size * SMALL_CAPS_SCALE } else { st.size };
let mut glyphs = shape_item(text, &sub, rtl, face, size, st, para.vertical);
// tracking after each cluster
if st.tracking != 0.0 {
let t = st.tracking * st.size / 1000.0;
for k in 0..glyphs.len() {
if k + 1 == glyphs.len() || glyphs[k + 1].cluster != glyphs[k].cluster {
glyphs[k].adv += t;
}
}
}
let end = if j < chars.len() { chars[j].0 } else { text.len() };
items.push(Item { range: chars[i].0..end, rtl, glyphs, style: si });
i = j;
}
// advance per char byte (cluster start)
let mut char_adv = vec![0.0f32; text.len() + 1];
for it in &items {
for g in &it.glyphs {
char_adv[g.cluster.min(text.len())] += g.adv;
}
}
let range_w = |r: Range<usize>| -> f32 { char_adv[r].iter().sum() };
let trailing_ws = |r: &Range<usize>| -> (usize, f32) {
let mut end = r.end;
let mut w = 0.0;
for (b, c) in text[r.clone()].char_indices().rev() {
if !c.is_whitespace() {
break;
}
end = r.start + b;
w += char_adv[r.start + b];
}
(end, w)
};
// line breaking
let mut ranges: Vec<Range<usize>> = Vec::new();
match para.width {
None => ranges.push(0..text.len()),
Some(maxw) => {
let mut start = 0usize;
let mut last_ok: Option<usize> = None;
for (p, _) in unicode_linebreak::linebreaks(text) {
loop {
let r = start..p;
let (ce, _) = trailing_ws(&r);
let w = range_w(start..ce);
if w <= maxw || last_ok.is_none() {
last_ok = Some(p);
break;
}
let Some(b) = last_ok.take() else { break };
ranges.push(start..b);
start = b;
}
}
ranges.push(start..text.len());
ranges.retain(|r| !r.is_empty());
if ranges.is_empty() {
ranges.push(0..text.len());
}
}
}
let nlines = ranges.len();
let mut out = Vec::new();
for (li, r) in ranges.into_iter().enumerate() {
let (ce, tw) = trailing_ws(&r);
let content = range_w(r.start..ce);
// justification
let mut space_extra = 0.0;
if para.align == Align::Justify
&& li + 1 < nlines
&& let Some(maxw) = para.width
{
let spaces = text[r.start..ce].chars().filter(|c| *c == ' ').count();
if spaces > 0 {
space_extra = ((maxw - content) / spaces as f32).max(0.0);
}
}
let (levels, runs) = bidi.visual_runs(pinfo, r.clone());
let mut pen = 0.0f32;
let mut glyphs = Vec::new();
let mut extents: HashMap<usize, (f32, f32, bool)> = HashMap::new();
for run in runs {
let rtl = levels[run.start].is_rtl();
let mut idx: Vec<usize> = (0..items.len()).filter(|&k| items[k].range.start < run.end && items[k].range.end > run.start).collect();
if rtl {
idx.reverse();
}
for k in idx {
let si = items[k].style;
let (st, pr) = (sty.list[si], sty.prim[si]);
for g in items[k].glyphs.iter().filter(|g| run.contains(&g.cluster)) {
let x0 = pen;
glyphs.push(Glyph {
face: g.face,
id: g.id,
x: pen + g.dx,
y: -g.dy - st.baseline_shift,
size: g.size,
cluster: base + g.cluster,
synth_bold: pr.synth_bold || st.faux_bold,
synth_italic: pr.synth_italic || st.faux_italic,
run: si as u16,
});
pen += g.adv;
if space_extra > 0.0 && text[g.cluster..].starts_with(' ') && g.cluster < ce {
pen += space_extra;
}
let e = extents.entry(g.cluster).or_insert((x0, pen, items[k].rtl));
e.0 = e.0.min(x0);
e.1 = e.1.max(pen);
}
}
}
// caret stops for each char boundary in the line
let mut carets = Vec::new();
let mut cluster_starts: Vec<usize> = extents.keys().copied().collect();
cluster_starts.sort_unstable();
let char_bytes: Vec<usize> = text[r.clone()].char_indices().map(|(b, _)| r.start + b).collect();
for (ci, &cs) in cluster_starts.iter().enumerate() {
let (x0, x1, rtl) = extents[&cs];
let next = cluster_starts.get(ci + 1).copied().unwrap_or(r.end);
let members: Vec<usize> = char_bytes.iter().copied().filter(|b| *b >= cs && *b < next).collect();
let n = members.len().max(1) as f32;
for (mi, b) in members.iter().enumerate() {
let f = mi as f32 / n;
let x = if rtl { x1 - (x1 - x0) * f } else { x0 + (x1 - x0) * f };
carets.push((base + b, x));
}
}
// underlined segments of rich layouts: clusters set in an underlined style, merged
let mut underlines: Vec<(f32, f32, u16)> = Vec::new();
if sty.rich() {
let mut segs: Vec<(f32, f32, u16)> = cluster_starts
.iter()
.filter(|&&cs| cs < ce)
.filter_map(|&cs| {
let si = sty.at(base + cs);
sty.list[si].underline.then(|| (extents[&cs].0, extents[&cs].1, si as u16))
})
.collect();
segs.sort_by(|a, b| a.0.total_cmp(&b.0));
for sg in segs {
match underlines.last_mut() {
Some(l) if l.2 == sg.2 && (sg.0 - l.1).abs() < 0.01 => l.1 = l.1.max(sg.1),
_ => underlines.push(sg),
}
}
}
// end of line caret
let end_x = match chars.iter().rev().find(|c| c.0 < r.end && c.0 >= r.start) {
Some(c) => {
let cs = cluster_starts.iter().rev().find(|s| **s <= c.0).copied();
match cs.and_then(|s| extents.get(&s)) {
Some(&(x0, x1, rtl)) => {
if rtl {
x0
} else {
x1
}
}
None => pen,
}
}
None => 0.0,
};
carets.push((base + r.end, end_x));
carets.sort_by_key(|c| c.0);
carets.dedup_by_key(|c| c.0);
let mut asc = pm.ascent;
let mut desc = pm.descent;
for g in &glyphs {
if g.face != primary.face || (sty.rich() && g.size != style.size) {
let m = fonts::face(g.face).metrics(g.size);
asc = asc.max(m.ascent);
desc = desc.max(m.descent);
}
}
let content_w = if space_extra > 0.0 { para.width.unwrap_or(content) } else { content };
out.push(ParaLine {
range: base + r.start..base + r.end,
glyphs,
carets,
content: content_w,
left_trim: if base_rtl { tw } else { 0.0 },
ascent: asc,
descent: desc,
underlines,
});
}
out
}
/// Lay out `text` (paragraphs separated by `\n`).
pub fn layout_uncached(text: &str, style: &TextStyle, para: &ParagraphStyle) -> Layout {
layout_rich_uncached(text, style, &[], para)
}
/// Lay out `text` with per-character style runs (see [`StyleRun`]); `style` is the base style.
pub fn layout_rich_uncached(text: &str, style: &TextStyle, runs: &[StyleRun], para: &ParagraphStyle) -> Layout {
let sty = Styles::new(text, style, runs);
let pm = fonts::face(sty.prim[0].face).metrics(style.size);
let line_h = (pm.ascent + pm.descent + pm.line_gap).max(style.size * 0.5) + para.leading;
let mut lay = Layout { missing_font: sty.prim.iter().any(|p| p.missing), text_len: text.len(), ..Default::default() };
if para.vertical {
return layout_vertical(text, &sty, para, line_h, lay);
}
let mut base = 0usize;
let mut plines = Vec::new();
for p in text.split('\n') {
let p_clean = p.strip_suffix('\r').unwrap_or(p);
plines.extend(paragraph(p_clean, base, &sty, para));
base += p.len() + 1;
}
let rich = sty.rich();
let first_baseline = match (para.width.is_some(), rich) {
(false, _) => 0.0,
(true, false) => pm.ascent,
(true, true) => plines.first().map_or(pm.ascent, |l| l.ascent),
};
let mut baseline = first_baseline;
let mut prev_desc = 0.0f32;
let box_h = para.width.and(para.height);
for (i, pl) in plines.into_iter().enumerate() {
if i > 0 {
// rich text: a line holding a larger run pushes its baseline down
baseline += if rich { line_h.max(prev_desc + pl.ascent + para.leading) } else { line_h };
if box_h.is_some_and(|h| baseline + pl.descent > h + 0.01) {
lay.overflow = true;
break;
}
}
prev_desc = pl.descent;
let shift = match (para.width, para.align) {
(None, Align::Left | Align::Justify) => 0.0,
(None, Align::Center) => -pl.content / 2.0,
(None, Align::Right) => -pl.content,
(Some(_), Align::Left | Align::Justify) => 0.0,
(Some(w), Align::Center) => (w - pl.content) / 2.0,
(Some(w), Align::Right) => w - pl.content,
} - pl.left_trim;
let g0 = lay.glyphs.len();
lay.glyphs.extend(pl.glyphs.into_iter().map(|mut g| {
g.x += shift;
g.y += baseline;
g
}));
let x = shift + pl.left_trim;
if rich {
for (x0, x1, si) in &pl.underlines {
let st = sty.list[*si as usize];
let um = fonts::face(sty.prim[*si as usize].face).metrics(st.size);
let y = baseline - st.baseline_shift + um.underline_pos;
lay.underlines.push([x0 + shift, y, x1 + shift, y + um.underline_thickness]);
lay.underline_runs.push(*si);
}
} else if style.underline && pl.content > 0.0 {
let y = baseline - style.baseline_shift + pm.underline_pos;
lay.underlines.push([x, y, x + pl.content, y + pm.underline_thickness]);
lay.underline_runs.push(0);
}
lay.lines.push(Line {
range: pl.range,
baseline,
x,
width: pl.content,
ascent: pl.ascent,
descent: pl.descent,
glyphs: g0..lay.glyphs.len(),
carets: pl.carets.into_iter().map(|(b, cx)| (b, cx + shift)).collect(),
});
}
let (mut x0, mut x1) = (f32::MAX, f32::MIN);
for l in &lay.lines {
x0 = x0.min(l.x);
x1 = x1.max(l.x + l.width);
}
if let Some(w) = para.width {
x0 = 0.0;
x1 = x1.max(w);
}
if let (Some(first), Some(last)) = (lay.lines.first(), lay.lines.last()) {
lay.bounds = [x0, first.baseline - first.ascent, x1.max(x0), last.baseline + last.descent];
}
if let Some(h) = box_h {
// a sized box is its own bounds, however much text it holds
lay.bounds[1] = 0.0;
lay.bounds[3] = h.max(0.0);
}
lay
}
/// Vertical layout: each grapheme is its own line (so carets, hit testing and selection work
/// unchanged), stacked top to bottom and centred on its column; columns run right to left.
fn layout_vertical(text: &str, sty: &Styles, para: &ParagraphStyle, col_w: f32, mut lay: Layout) -> Layout {
let style = sty.list[0];
let pm = fonts::face(sty.prim[0].face).metrics(style.size);
let row = (pm.ascent + pm.descent).max(style.size * 0.5) + style.tracking * style.size / 1000.0;
let flat = ParagraphStyle { vertical: true, ..Default::default() };
lay.vertical = true;
let rich = sty.rich();
let mut base = 0usize;
let mut ncols = 0usize;
for (c, p) in text.split('\n').enumerate() {
ncols = c + 1;
let p_clean = p.strip_suffix('\r').unwrap_or(p);
let mut cells: Vec<ParaLine> = Vec::new();
if p_clean.is_empty() {
cells.extend(paragraph("", base, sty, &flat));
}
for (off, cluster) in p_clean.grapheme_indices(true) {
cells.extend(paragraph(cluster, base + off, sty, &flat));
}
let h = row * cells.len() as f32;
let y0 = match para.align {
Align::Center => -h / 2.0,
Align::Right => -h,
_ => 0.0,
};
let cx = -(c as f32) * col_w;
for (k, pl) in cells.into_iter().enumerate() {
let baseline = y0 + row * k as f32;
let shift = cx - pl.content / 2.0 - pl.left_trim;
let g0 = lay.glyphs.len();
lay.glyphs.extend(pl.glyphs.into_iter().map(|mut g| {
g.x += shift;
// The alternate glyph hangs from its vertical origin. A horizontal ascent
// is not the top bearing of a vertical punctuation glyph (OpenType VORG/vmtx).
let font = fonts::face(g.face);
if text.get(g.cluster..).and_then(|s| s.chars().next()).is_some_and(uses_vertical_form)
&& let Some(origin) = font.vertical_origin(g.id, g.size)
{
g.y += baseline - pl.ascent + origin;
} else {
g.y += baseline;
}
g
}));
// Underline runs down the column, to the right of the cell (the "below" side of vertical-rl).
let y_top = baseline - pl.ascent;
if rich {
for (_x0, x1, si) in &pl.underlines {
let st = sty.list[*si as usize];
let um = fonts::face(sty.prim[*si as usize].face).metrics(st.size);
let x = *x1 + shift - st.baseline_shift + um.underline_pos;
lay.underlines.push([x, y_top, x + um.underline_thickness, y_top + row]);
lay.underline_runs.push(*si);
}
} else if style.underline && pl.content > 0.0 {
let x = shift + pl.left_trim + pl.content + pm.underline_pos;
lay.underlines.push([x, y_top, x + pm.underline_thickness, y_top + row]);
lay.underline_runs.push(0);
}
lay.lines.push(Line {
range: pl.range,
baseline,
x: shift + pl.left_trim,
width: pl.content,
ascent: pl.ascent,
descent: pl.descent,
glyphs: g0..lay.glyphs.len(),
carets: pl.carets.into_iter().map(|(b, x)| (b, x + shift)).collect(),
});
}
base += p.len() + 1;
}
let (mut y0, mut y1) = (f32::MAX, f32::MIN);
for l in &lay.lines {
y0 = y0.min(l.baseline - l.ascent);
y1 = y1.max(l.baseline + l.descent);
}
lay.bounds = [-(ncols.max(1) as f32 - 0.5) * col_w, y0, col_w / 2.0, y1.max(y0)];
lay
}
fn cache() -> &'static Mutex<HashMap<u64, (u64, Arc<Layout>)>> {
static C: OnceLock<Mutex<HashMap<u64, (u64, Arc<Layout>)>>> = OnceLock::new();
C.get_or_init(Default::default)
}
/// Lay out `text` (cached by text and styles).
pub fn layout(text: &str, style: &TextStyle, para: &ParagraphStyle) -> Arc<Layout> {
layout_rich(text, style, &[], para)
}
/// Lay out `text` with per-character style runs (cached by text, styles and runs).
pub fn layout_rich(text: &str, style: &TextStyle, runs: &[StyleRun], para: &ParagraphStyle) -> Arc<Layout> {
let mut h = std::collections::hash_map::DefaultHasher::new();
text.hash(&mut h);
style.hash(&mut h);
para.hash(&mut h);
runs.hash(&mut h);
let key = h.finish();
static CLOCK: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
let now = CLOCK.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
if let Some(e) = cache().lock().unwrap_or_else(|e| e.into_inner()).get_mut(&key) {
e.0 = now;
return e.1.clone();
}
let l = Arc::new(layout_rich_uncached(text, style, runs, para));
let mut c = cache().lock().unwrap_or_else(|e| e.into_inner());
if c.len() >= 512 {
// evict the oldest quarter
let mut ages: Vec<u64> = c.values().map(|v| v.0).collect();
ages.sort_unstable();
let cut = ages[ages.len() / 4];
c.retain(|_, v| v.0 > cut);
}
c.insert(key, (now, l.clone()));
l
}
/// Width of a single line of `text` (no wrapping).
pub fn measure(text: &str, style: &TextStyle) -> f32 {
let l = layout(text, style, &ParagraphStyle::default());
l.lines.iter().map(|l| l.width).fold(0.0, f32::max)
}
#[cfg(test)]
mod tests {
use super::*;
fn st(size: f32) -> TextStyle {
TextStyle { size, ..Default::default() }
}
#[test]
fn kerning_and_ligatures_change_advances() {
let kern = measure("AVAVAV", &st(100.0));
let nokern = measure("AVAVAV", &TextStyle { kerning: false, ..st(100.0) });
assert!(kern < nokern - 5.0, "kerning tightens AV: {kern} vs {nokern}");
// tracking adds 1/1000 em per cluster
let tracked = measure("AVAVAV", &TextStyle { tracking: 100.0, ..st(100.0) });
assert!((tracked - kern - 6.0 * 10.0).abs() < 0.5, "{tracked} {kern}");
}
#[test]
fn point_text_alignment() {
let l = layout("Hello", &st(50.0), &ParagraphStyle { align: Align::Center, ..Default::default() });
let line = &l.lines[0];
assert!((line.x + line.width / 2.0).abs() < 0.01);
let r = layout("Hello", &st(50.0), &ParagraphStyle { align: Align::Right, ..Default::default() });
assert!((r.lines[0].x + r.lines[0].width).abs() < 0.01);
assert_eq!(l.glyphs.len(), 5);
assert!(l.bounds[1] < -30.0 && l.bounds[3] > 5.0, "{:?}", l.bounds);
}
#[test]
fn wraps_area_text_and_justifies() {
let p = ParagraphStyle { width: Some(300.0), align: Align::Justify, ..Default::default() };
let l = layout("the quick brown fox jumps over the lazy dog again and again", &st(40.0), &p);
assert!(l.lines.len() >= 3, "{}", l.lines.len());
for line in &l.lines[..l.lines.len() - 1] {
assert!((line.width - 300.0).abs() < 0.5, "justified to the box: {}", line.width);
}
// the lines tile the text
assert_eq!(l.lines[0].range.start, 0);
for w in l.lines.windows(2) {
assert_eq!(w[0].range.end, w[1].range.start);
assert!(w[1].baseline > w[0].baseline);
}
let left = layout("the quick brown fox jumps over the lazy dog", &st(40.0), &ParagraphStyle { width: Some(300.0), ..Default::default() });
assert!(left.lines.iter().all(|l| l.width <= 300.0 + 0.01));
}
#[test]
fn a_box_height_leaves_out_the_lines_that_do_not_fit() {
let text = "the quick brown fox jumps over the lazy dog again and again";
let free = layout(text, &st(40.0), &ParagraphStyle { width: Some(300.0), ..Default::default() });
assert!(free.lines.len() >= 3 && !free.overflow);
// room for two lines only
let h = free.lines[1].baseline + free.lines[1].descent + 1.0;
let boxed = layout(text, &st(40.0), &ParagraphStyle { width: Some(300.0), height: Some(h), ..Default::default() });
assert_eq!(boxed.lines.len(), 2);
assert!(boxed.overflow);
assert_eq!(boxed.lines[..], free.lines[..2]);
assert_eq!(boxed.glyphs.len(), free.lines[1].glyphs.end);
assert_eq!(boxed.bounds, [0.0, 0.0, 300.0, h], "the box is the bounds");
assert_eq!(boxed.text_len, text.len());
// a box tall enough for everything hides nothing; a box too short for one line keeps the first
let tall = layout(text, &st(40.0), &ParagraphStyle { width: Some(300.0), height: Some(5000.0), ..Default::default() });
assert_eq!(tall.lines.len(), free.lines.len());
assert!(!tall.overflow);
let tiny = layout(text, &st(40.0), &ParagraphStyle { width: Some(300.0), height: Some(2.0), ..Default::default() });
assert_eq!(tiny.lines.len(), 1);
assert!(tiny.overflow);
// point text has no box: the height is ignored
let point = layout("a\nb\nc", &st(40.0), &ParagraphStyle { height: Some(2.0), ..Default::default() });
assert_eq!(point.lines.len(), 3);
assert!(!point.overflow);
}
#[test]
fn newlines_make_paragraphs_and_leading_adds() {
let l = layout("one\ntwo\n\nfour", &st(30.0), &ParagraphStyle::default());
assert_eq!(l.lines.len(), 4);
assert_eq!(l.lines[1].range, 4..7);
assert_eq!(l.lines[2].range, 8..8);
let gap = l.lines[1].baseline - l.lines[0].baseline;
let l2 = layout("one\ntwo", &st(30.0), &ParagraphStyle { leading: 10.0, ..Default::default() });
assert!((l2.lines[1].baseline - l2.lines[0].baseline - gap - 10.0).abs() < 1e-3);
}
#[test]
fn japanese_vertical_titles_with_an_installed_font() {
// Japanese glyphs come from the craft-fonts (built with CRAFT_FONTS_DIR) or a system font:
// skip where neither is present.
crate::fonts::scan_system();
if !crate::fonts::all_faces().iter().any(|f| "日本語縦書き".chars().all(|c| f.has_char(c))) {
eprintln!("SKIPPED: no Japanese font installed");
return;
}
let l = layout("日本語\n縦書き", &st(40.0), &ParagraphStyle { vertical: true, ..Default::default() });
assert!(l.vertical);
assert_eq!(l.glyphs.len(), 6);
assert!(l.glyphs.iter().all(|g| g.id != 0));
assert!(l.glyphs[1].y > l.glyphs[0].y);
assert!(l.glyphs[3].x < l.glyphs[0].x);
}
#[test]
fn japanese_vertical_punctuation_uses_alternates_at_the_top_right() {
use skrifa::{
MetadataProvider,
instance::{LocationRef, Size},
};
fonts::scan_system();
let face = fonts::all_faces().into_iter().find(|f| {
((f.info.family.contains("Hiragino") && !f.info.family.contains(" GB") && !f.info.family.contains(" TC"))
|| f.info.family.contains("Shippori")
|| f.info.family.contains("BIZ UD"))
&& "国、。「」ー".chars().all(|c| f.has_char(c))
&& (f.has_feature(b"vert") || f.has_feature(b"vrt2"))
});
let Some(face) = face else {
eprintln!("SKIPPED: no Japanese font with vertical alternates available");
return;
};
let style = TextStyle { family: face.info.family.clone(), style: face.info.style.clone(), ..st(48.0) };
let text = "国、。「」ーABC";
let horizontal = layout_uncached(text, &style, &ParagraphStyle::default());
let vertical = layout_uncached(text, &style, &ParagraphStyle { vertical: true, ..Default::default() });
assert_eq!(vertical.glyphs.len(), 9);
assert_eq!(vertical.glyphs[0].id, horizontal.glyphs[0].id);
for i in 1..6 {
assert_ne!(vertical.glyphs[i].id, horizontal.glyphs[i].id, "{}: vertical form for glyph {i}", face.info.family);
}
for i in [1, 2] {
let g = &vertical.glyphs[i];
let line = &vertical.lines[i];
let font = fonts::face(g.face);
let bounds = font.font().unwrap().glyph_metrics(Size::unscaled(), LocationRef::default()).bounds(skrifa::GlyphId::new(g.id)).unwrap();
let scale = g.size / font.units_per_em();
let ink_x = g.x + (bounds.x_min + bounds.x_max) * scale / 2.0;
let ink_y = g.y - (bounds.y_min + bounds.y_max) * scale / 2.0;
let centre_x = line.x + line.width / 2.0;
let cell_top = line.baseline - line.ascent;
assert!(ink_x > centre_x, "{}: punctuation ink on the right ({ink_x}, {centre_x})", face.info.family);
assert!(ink_y < cell_top + g.size / 2.0, "{}: punctuation ink at the top ({ink_y}, {cell_top})", face.info.family);
}
for i in 6..9 {
assert_eq!(vertical.glyphs[i].id, horizontal.glyphs[i].id, "Latin shaping stays unchanged");
}
assert_eq!(layout_uncached(text, &style, &ParagraphStyle::default()), horizontal);
eprintln!("verified vertical punctuation with {} / {}", face.info.family, face.info.style);
}
#[test]
fn vertical_text_stacks_characters_in_columns() {
let p = ParagraphStyle { vertical: true, ..Default::default() };
let l = layout("abc\nde", &st(40.0), &p);
assert!(l.vertical);
assert_eq!(l.lines.len(), 5, "one line per character");
// first column: same centre x, increasing baselines
let cx = |i: usize| l.lines[i].x + l.lines[i].width / 2.0;
assert!((cx(0) - cx(2)).abs() < 1e-3 && l.lines[1].baseline > l.lines[0].baseline && l.lines[2].baseline > l.lines[1].baseline);
// second column is to the left of the first
assert!(cx(3) < cx(0) - 20.0, "{} {}", cx(3), cx(0));
assert_eq!(l.lines[3].range, 4..5);
// taller than wide for a single column
let one = layout("abcdef", &st(40.0), &p);
assert!(one.bounds[3] - one.bounds[1] > 3.0 * (one.bounds[2] - one.bounds[0]), "{:?}", one.bounds);
// hit testing finds the character in the second column
let (x, b, _) = l.caret(4);
assert_eq!(l.hit(x + 1.0, b - 5.0), 4);
// differs from horizontal layout in the cache
let h = layout("abc\nde", &st(40.0), &ParagraphStyle::default());
assert_eq!(h.lines.len(), 2);
}
#[test]
fn vertical_underline_runs_down_the_column() {
let s = TextStyle { underline: true, ..st(60.0) };
let h = layout("A", &s, &ParagraphStyle::default());
let v = layout("A", &s, &ParagraphStyle { vertical: true, ..Default::default() });
assert_eq!(h.underlines.len(), 1);
assert_eq!(v.underlines.len(), 1, "vertical cells get an underline");
let [hx0, hy0, hx1, hy1] = h.underlines[0];
let [vx0, vy0, vx1, vy1] = v.underlines[0];
assert!(hx1 - hx0 > hy1 - hy0, "horizontal underline is a wide strip");
assert!(vy1 - vy0 > vx1 - vx0, "vertical underline is a tall strip");
let runs = [StyleRun { range: 0..1, style: s.clone() }];
let rich = layout_rich("A", &st(60.0), &runs, &ParagraphStyle { vertical: true, ..Default::default() });
assert_eq!(rich.underlines.len(), 1);
assert_eq!(rich.underline_runs, vec![1]);
}
#[test]
fn vertical_cells_keep_combining_marks_with_their_base() {
let style = st(32.0);
let para = ParagraphStyle { vertical: true, ..Default::default() };
let decomposed = layout_uncached("e\u{301}x", &style, &para);
let composed = layout_uncached("éx", &style, &para);
assert_eq!(decomposed.lines.len(), 2, "the combining acute must not get another vertical cell");
assert_eq!(decomposed.lines[0].range, 0..3);
assert_eq!(decomposed.lines[1].range, 3..4);
assert_eq!(decomposed.text_len, 4, "retain the original UTF-8 source offsets");
assert_eq!(
decomposed.glyphs.iter().map(|g| (g.id, g.x, g.y)).collect::<Vec<_>>(),
composed.glyphs.iter().map(|g| (g.id, g.x, g.y)).collect::<Vec<_>>()
);
assert_eq!(decomposed.bounds, composed.bounds);
assert_eq!(decomposed.caret(0).1, decomposed.caret(1).1, "base and combining mark occupy the same cell");
for text in ["葛\u{e0101}x", "👩\u{200d}👧x"] {
let lay = layout_uncached(text, &style, &para);
assert_eq!(lay.lines.len(), 2, "variation selectors and ZWJ sequences stay with their base");
assert_eq!(lay.lines[0].range, 0..text.len() - 1);
assert_eq!(lay.lines[1].range, text.len() - 1..text.len());
}
}
#[test]
fn vertical_kana_keep_decomposed_dakuten_in_the_same_cell() {
fonts::scan_system();
let Some(face) = fonts::all_faces().into_iter().find(|f| {
(f.info.family.contains("Hiragino") || f.info.family.contains("Shippori") || f.info.family.contains("BIZ UD"))
&& "かがはぱ\u{3099}\u{309a}".chars().all(|c| f.has_char(c))
}) else {
eprintln!("SKIPPED: no Japanese font covering combining dakuten/handakuten");
return;
};
let style = TextStyle { family: face.info.family.clone(), style: face.info.style.clone(), ..st(48.0) };
let para = ParagraphStyle { vertical: true, ..Default::default() };
let nfd = layout_uncached("か\u{3099}は\u{309a}", &style, &para);
let nfc = layout_uncached("がぱ", &style, &para);
assert_eq!(nfd.lines.len(), 2);
assert_eq!(nfd.lines[0].range, 0..6);
assert_eq!(nfd.lines[1].range, 6..12);
assert_eq!(nfd.glyphs.iter().map(|g| (g.id, g.x, g.y)).collect::<Vec<_>>(), nfc.glyphs.iter().map(|g| (g.id, g.x, g.y)).collect::<Vec<_>>());
assert_eq!(nfd.bounds, nfc.bounds);
}
#[test]
fn carets_and_hit_testing() {
let l = layout("abc\nde", &st(40.0), &ParagraphStyle::default());
let (x0, _, li0) = l.caret(0);
let (x1, _, _) = l.caret(1);
let (x3, _, _) = l.caret(3);
assert!(x0.abs() < 1e-3 && x1 > x0 && x3 > x1);
assert_eq!(li0, 0);
let (_, b4, li4) = l.caret(4);
assert_eq!(li4, 1);
assert!(b4 > 0.0);
assert_eq!(l.hit(x1 + 1.0, 0.0), 1);
assert_eq!(l.hit(1000.0, b4), 6);
let rects = l.selection_rects(1, 5);
assert_eq!(rects.len(), 2);
}
#[test]
fn bidi_reorders_rtl_runs() {
// Hebrew letters are laid out right-to-left: the first logical letter is rightmost.
let l = layout("ab \u{5d0}\u{5d1}\u{5d2} cd", &st(40.0), &ParagraphStyle::default());
let x_of = |byte: usize| l.glyphs.iter().find(|g| g.cluster == byte).map(|g| g.x).unwrap();
let alef = "ab ".len();
let gimel = alef + 4;
assert!(x_of(alef) > x_of(gimel), "alef right of gimel");
assert!(x_of(0) < x_of(gimel) && x_of(alef) < x_of("ab \u{5d0}\u{5d1}\u{5d2} ".len()));
}
#[test]
fn caps_and_small_caps() {
let s = st(50.0);
let up = measure("HELLO", &s);
let all = measure("hello", &TextStyle { caps: Caps::All, ..s.clone() });
assert!((up - all).abs() < 0.01);
let small = measure("hello", &TextStyle { caps: Caps::Small, ..s.clone() });
assert!(small < up * 0.9 && small > up * 0.6, "{small} {up}");
let l = layout("Hi", &TextStyle { baseline_shift: 10.0, underline: true, ..s }, &ParagraphStyle::default());
assert!((l.glyphs[0].y + 10.0).abs() < 1e-3);
assert_eq!(l.underlines.len(), 1);
}
#[test]
fn ligature_caret_interpolates() {
// Inter has an "fi"-like ligature only via calt in some versions; use "ffi" which most
// fonts ligate. Whatever shaping does, every char boundary has a caret.
let l = layout("office", &st(40.0), &ParagraphStyle::default());
let stops: Vec<usize> = l.lines[0].carets.iter().map(|c| c.0).collect();
assert_eq!(stops, vec![0, 1, 2, 3, 4, 5, 6]);
let xs: Vec<f32> = l.lines[0].carets.iter().map(|c| c.1).collect();
assert!(xs.windows(2).all(|w| w[1] >= w[0]), "{xs:?}");
}
#[test]
fn fallback_font_for_missing_glyphs() {
// Inter lacks Devanagari/Hebrew; Noto Serif lacks Hebrew too → glyphs still produced (notdef)
let l = layout("A\u{3b1}", &TextStyle { family: "Noto Serif".into(), ..st(40.0) }, &ParagraphStyle::default());
assert_eq!(l.glyphs.len(), 2);
assert!(l.glyphs.iter().all(|g| g.id != 0));
}
#[test]
fn style_runs_split_items_and_grow_lines() {
let base = st(40.0);
let big = TextStyle { size: 80.0, ..base.clone() };
let text = "small BIG small";
let plain = layout(text, &base, &ParagraphStyle::default());
let runs = [StyleRun { range: 6..9, style: big.clone() }];
let rich = layout_rich(text, &base, &runs, &ParagraphStyle::default());
// glyphs carry their style index; the run is wider than the plain text
let tagged: Vec<u16> = rich.glyphs.iter().map(|g| g.run).collect();
assert_eq!(tagged.iter().filter(|r| **r == 1).count(), 3, "{tagged:?}");
assert!(rich.glyphs.iter().filter(|g| g.run == 1).all(|g| g.size == 80.0));
assert!(rich.lines[0].width > plain.lines[0].width + 30.0);
assert!(rich.lines[0].ascent > plain.lines[0].ascent * 1.5, "the line grows to the run");
// carets still cover every character boundary
assert_eq!(rich.lines[0].carets.len(), text.len() + 1);
// a line holding a big run moves down from the line above it
let two = layout_rich("next\nBIG", &base, &[StyleRun { range: 5..8, style: big }], &ParagraphStyle::default());
let two_plain = layout("next\nBIG", &base, &ParagraphStyle::default());
assert!(two.lines[1].baseline > two_plain.lines[1].baseline + 10.0);
// no runs: identical to the plain layout
assert_eq!(*layout_rich(text, &base, &[], &ParagraphStyle::default()), *plain);
}
#[test]
fn style_runs_shift_underline_and_track() {
let base = st(40.0);
let text = "ab cd ef";
let runs = [
StyleRun { range: 3..5, style: TextStyle { underline: true, baseline_shift: 10.0, ..base.clone() } },
StyleRun { range: 6..8, style: TextStyle { tracking: 500.0, faux_bold: true, ..base.clone() } },
];
let l = layout_rich(text, &base, &runs, &ParagraphStyle::default());
assert_eq!(l.underlines.len(), 1, "only the underlined run");
assert_eq!(l.underline_runs, vec![1]);
let c = l.glyphs.iter().find(|g| g.cluster == 3).unwrap();
let a = l.glyphs.iter().find(|g| g.cluster == 0).unwrap();
assert!((c.y - (a.y - 10.0)).abs() < 1e-3, "baseline shift per run");
let u = l.underlines[0];
assert!(u[0] >= l.caret(3).0 - 0.01 && u[2] <= l.caret(5).0 + 0.01, "{u:?}");
assert!(l.glyphs.iter().filter(|g| g.run == 2).all(|g| g.synth_bold));
// tracking widens only the tracked run: 2 clusters × 0.5 em
let plain = layout(text, &base, &ParagraphStyle::default());
assert!((l.lines[0].width - plain.lines[0].width - 2.0 * 20.0).abs() < 0.5, "{} {}", l.lines[0].width, plain.lines[0].width);
}
#[test]
fn empty_text_has_a_caret() {
let l = layout("", &st(40.0), &ParagraphStyle::default());
assert_eq!(l.lines.len(), 1);
assert_eq!(l.caret(0).0, 0.0);
assert!(l.bounds[3] > l.bounds[1]);
}
}