SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Sketch text: measure a line with the rule that draws it (#4813) (#4815)
CamWightd557c09c3b5a
diff --git a/crates/sketch/src/font_tests.rs b/crates/sketch/src/font_tests.rsindex 11a45fa3cd..8de9066d28 100644--- a/crates/sketch/src/font_tests.rs+++ b/crates/sketch/src/font_tests.rs@@ -293,6 +293,33 @@ fn a_text_that_the_font_makes_too_large_is_refused() {std::fs::write(&path, font).unwrap();assert_eq!(text_geometry_in(Some(&path), &"H".repeat(66), Vec2::ZERO, 5.0, 0.0).unwrap().len(), 66 * 300);assert!(matches!(text_geometry_in(Some(&path), &"H".repeat(67), Vec2::ZERO, 5.0, 0.0), Err(SketchError::TooLarge)));+ // Too large to draw, not to measure: 67 times one H.+ let font = font_data(Some(&path)).unwrap();+ let m = TextMetrics::new(&font, &TextStyle::default()).unwrap();+ let (one, all) = (m.line_width("H", 5.0).unwrap(), m.line_width(&"H".repeat(67), 5.0).unwrap());+ assert!(one > 0.0 && (all - 67.0 * one).abs() < 1e-12 * all, "{one} {all}");+}++#[test]+fn a_font_file_is_measured_by_its_own_tables() {+ let folder = Folder::new("metrics");+ let font = font_data(Some(&folder.font())).unwrap();+ let m = TextMetrics::new(&font, &TextStyle::default()).unwrap();+ // Its H is 700 units tall, so at 7 mm a unit is 0.01 mm; ascender 800, descender -200 and no line gap put lines+ // 10 mm apart; H, I and O advance 700, 200 and 900 units.+ assert!((m.scale(7.0).unwrap() - 0.01).abs() < 1e-15);+ assert!((m.line_pitch(7.0).unwrap() - 10.0).abs() < 1e-12);+ assert!((m.line_width("HIO", 7.0).unwrap() - 18.0).abs() < 1e-12);+ // It has neither an x nor a `?`: an x is left out, taking no room and drawing nothing, but it is named.+ assert_eq!(m.line_width("HxI", 7.0).unwrap(), m.line_width("HI", 7.0).unwrap());+ assert_eq!(m.missing("xHx"), ['x', 'x']);+ let draw = |text: &str| text_geometry_in(Some(&folder.font()), text, Vec2::ZERO, 7.0, 0.0).unwrap();+ assert_eq!(draw("HxI"), draw("HI"));+ assert!(draw("xx").is_empty() && m.line_width("xx", 7.0).unwrap() == 0.0);+ // A face the file does not have (it is no collection) is an error.+ let mut elsewhere = font.clone();+ elsewhere.index = 1;+ assert!(TextMetrics::new(&elsewhere, &TextStyle::default()).is_err());}#[test]diff --git a/crates/sketch/src/lib.rs b/crates/sketch/src/lib.rsindex 66ee6b015d..c009dbf57e 100644--- a/crates/sketch/src/lib.rs+++ b/crates/sketch/src/lib.rs@@ -69,7 +69,7 @@ pub use solver::{Analysis, CONSISTENT, DrivingValues, Hold, MAX_COMPONENT_VARS, SolveReport, SolveStatus, constraint_residual, determined_by, measure_dimension,move_line_towards, move_point_towards, solve, solve_after_edit, solve_after_value_edit, solve_holding, solve_with,};-pub use text::{MAX_TEXT_CHARS, TextAlign, TextStyle, text_geometry, text_geometry_in, text_geometry_styled};+pub use text::{MAX_TEXT_CHARS, TextAlign, TextMetrics, TextStyle, text_geometry, text_geometry_in, text_geometry_styled};pub use thin::{MAX_THIN_SEGMENTS, thin_wall_regions};pub use wire::{MAX_FIT_POINTS, MAX_WIRE_POINTS, Wire, WireSpace, fit_polyline};diff --git a/crates/sketch/src/text.rs b/crates/sketch/src/text.rsindex 5e218294e7..7327fb680f 100644--- a/crates/sketch/src/text.rs+++ b/crates/sketch/src/text.rs@@ -4,12 +4,13 @@//! holes of A, B, 8…) are loops inside its outline; profile detection makes them holes.//!//! The default font is embedded (Liberation Sans, SIL OFL 1.1; see `assets/fonts/liberation-sans/OFL.txt` and-//! ATTRIBUTION.md); [`crate::fonts`] finds others by file path or installed family name.+//! ATTRIBUTION.md); [`crate::fonts`] finds others by file path or installed family name. [`TextMetrics`] measures+//! text by the rule that draws it.use serde::{Deserialize, Serialize};use solidcraft_geom::{Ring, Vec2};-use crate::fonts::font_data_styled;+use crate::fonts::{FontData, font_data_styled};use crate::link::{LinkGeom, LinkKind, LinkSource, MAX_LINK_ENTITIES};use crate::model::{Result, Sketch, SketchError};@@ -160,6 +161,99 @@ const SLANT_DEG: f64 = 12.0;const MAX_LETTER_SPACING: f64 = 1e5;const LINE_SPACING_RANGE: (f64, f64) = (0.05, 100.0);+/// A capital height (mm) text can be set at: finite, above a micrometre and below a kilometre.+fn check_height(height: f64) -> Result<()> {+ if height.is_finite() && height > 1e-6 && height < 1e6 { Ok(()) } else { Err(SketchError::Invalid("text height must be positive".into())) }+}++/// A style's spacing: a finite letter spacing of at most [`MAX_LETTER_SPACING`] either way, and a line spacing in+/// [`LINE_SPACING_RANGE`].+fn check_spacing(style: &TextStyle) -> Result<()> {+ if !(style.letter_spacing.is_finite() && style.letter_spacing.abs() <= MAX_LETTER_SPACING) {+ return Err(SketchError::Invalid("the letter spacing must be a finite length".into()));+ }+ if !(style.line_spacing.is_finite() && (LINE_SPACING_RANGE.0..=LINE_SPACING_RANGE.1).contains(&style.line_spacing)) {+ return Err(SketchError::Invalid(format!(+ "the line spacing must be between {} and {} times the font's",+ LINE_SPACING_RANGE.0, LINE_SPACING_RANGE.1+ )));+ }+ Ok(())+}++/// How a font sets text in a style, read once from its face: the scale for a capital height, the distance between+/// lines, the width of a line and the characters the font has no glyph for. Sketch text is laid out with it, so a+/// line measures what it draws. Kerning stays off, as in sketch text.+pub struct TextMetrics<'a> {+ face: ttf_parser::Face<'a>,+ /// The capital height, in font units.+ cap: f64,+ /// The distance between baselines in font units: ascender to descender, plus the line gap (none when not positive).+ pitch: f64,+ /// What a character the font lacks is set as: its `?`, when it has one.+ fallback: Option<ttf_parser::GlyphId>,+ letter_spacing: f64,+ line_spacing: f64,+}++impl<'a> TextMetrics<'a> {+ /// The face of `font` set in `style`: its letter and line spacing (its bold and italic chose the face).+ pub fn new(font: &'a FontData, style: &TextStyle) -> Result<TextMetrics<'a>> {+ check_spacing(style)?;+ let face = ttf_parser::Face::parse(font.bytes(), font.index).map_err(|e| SketchError::Invalid(format!("font: {e}")))?;+ Ok(TextMetrics {+ cap: cap_height(&face),+ pitch: f64::from(face.ascender()) - f64::from(face.descender()) + f64::from(face.line_gap()),+ fallback: face.glyph_index('?'),+ letter_spacing: style.letter_spacing,+ line_spacing: style.line_spacing,+ face,+ })+ }++ /// Millimetres per font unit at a capital height of `height` mm.+ pub fn scale(&self, height: f64) -> Result<f64> {+ check_height(height)?;+ Ok(height / self.cap)+ }++ /// The distance between baselines (mm) at a capital height of `height` mm: the font's own (one and a half heights+ /// when it gives none) times the line spacing.+ pub fn line_pitch(&self, height: f64) -> Result<f64> {+ let k = self.scale(height)?;+ let own = if self.pitch > 0.0 { self.pitch * k } else { height * 1.5 };+ Ok(own * self.line_spacing)+ }++ /// The width (mm) of one line at a capital height of `height` mm, as it is drawn: from its first glyph's origin to+ /// the end of its last glyph's advance. A line break in it is a character like any other.+ pub fn line_width(&self, line: &str, height: f64) -> Result<f64> {+ let k = self.scale(height)?;+ Ok(self.glyphs(line, k).last().map(|(_, x, advance)| x + advance).unwrap_or(0.0))+ }++ /// The characters of one line the font has no glyph for, in order and each time they come: those its character map+ /// lacks (set as its `?`, or left out when it has none) and those it sends to its missing-glyph box (`.notdef`, drawn+ /// as it is).+ pub fn missing(&self, line: &str) -> Vec<char> {+ line.chars().filter(|ch| self.face.glyph_index(*ch).is_none_or(|g| g.0 == 0)).collect()+ }++ /// The one rule that lays out a line, at `k` mm per font unit: each glyph, where its origin is along the line and+ /// its advance. No kerning; a character the font lacks is set as its `?` (left out when it has none either); the+ /// letter spacing goes between glyphs, not after the last.+ fn glyphs(&self, line: &str, k: f64) -> impl Iterator<Item = (ttf_parser::GlyphId, f64, f64)> {+ let mut pen = 0.0f64;+ line.chars().filter_map(move |ch| {+ let gid = self.face.glyph_index(ch).or(self.fallback)?;+ let advance = f64::from(self.face.glyph_hor_advance(gid).unwrap_or(0)) * k;+ let x = pen;+ pen += advance + self.letter_spacing;+ Some((gid, x, advance))+ })+ }+}+/// Outline geometry of `text` in the built-in font (see [`text_geometry_in`]).pub fn text_geometry(text: &str, at: Vec2, height: f64, angle: f64) -> Result<Vec<LinkGeom>> {text_geometry_in(None, text, at, height, angle)@@ -187,52 +281,28 @@ pub fn text_geometry_styled(if text.chars().count() > MAX_TEXT_CHARS {return Err(SketchError::TooLarge);}- if !(height.is_finite() && height > 1e-6 && height < 1e6 && angle.is_finite() && at.is_finite()) {- return Err(SketchError::Invalid("text height must be positive".into()));- }- if !(style.letter_spacing.is_finite() && style.letter_spacing.abs() <= MAX_LETTER_SPACING) {- return Err(SketchError::Invalid("the letter spacing must be a finite length".into()));- }- if !(style.line_spacing.is_finite() && (LINE_SPACING_RANGE.0..=LINE_SPACING_RANGE.1).contains(&style.line_spacing)) {- return Err(SketchError::Invalid(format!(- "the line spacing must be between {} and {} times the font's",- LINE_SPACING_RANGE.0, LINE_SPACING_RANGE.1- )));+ // The numbers first: finding an installed font can mean reading its folders.+ check_height(height)?;+ if !(angle.is_finite() && at.is_finite()) {+ return Err(SketchError::Invalid("the text's place and angle must be finite".into()));}+ check_spacing(style)?;let (data, slant) = font_data_styled(font, style.bold, style.italic)?;- let face = ttf_parser::Face::parse(data.bytes(), data.index).map_err(|e| SketchError::Invalid(format!("font: {e}")))?;- let k = height / cap_height(&face);- let line_gap = f64::from(face.ascender()) - f64::from(face.descender()) + f64::from(face.line_gap());- let line_gap = if line_gap > 0.0 { line_gap * k } else { height * 1.5 } * style.line_spacing;+ let metrics = TextMetrics::new(&data, style)?;+ let (k, pitch) = (metrics.scale(height)?, metrics.line_pitch(height)?);let shear = if slant { SLANT_DEG.to_radians().tan() } else { 0.0 };- // Each line's glyphs (glyph, where its origin is along the line, its advance) and width.- let lines: Vec<(Vec<(ttf_parser::GlyphId, f64, f64)>, f64)> = text- .split('\n')- .map(|line| {- let mut pen = 0.0f64;- let mut glyphs = Vec::new();- for ch in line.chars() {- let Some(gid) = face.glyph_index(ch).or_else(|| face.glyph_index('?')) else { continue };- let advance = f64::from(face.glyph_hor_advance(gid).unwrap_or(0)) * k;- glyphs.push((gid, pen, advance));- pen += advance + style.letter_spacing;- }- let width = glyphs.last().map(|(_, x, advance)| x + advance).unwrap_or(0.0);- (glyphs, width)- })- .collect();let along = path.map(|pts| Path::new(pts, style.reverse)).transpose()?;let anchor = along.as_ref().map(|p| p.anchor(style.align)).unwrap_or(0.0);let (sin, cos) = angle.sin_cos();let mut out = Vec::new();- for (row, (glyphs, width)) in lines.iter().enumerate() {- let base_y = -(row as f64) * line_gap;+ for (row, line) in text.split('\n').enumerate() {+ let base_y = -(row as f64) * pitch;let start = match style.align {TextAlign::Left => 0.0,- TextAlign::Center => -width / 2.0,- TextAlign::Right => -width,+ TextAlign::Center => -metrics.line_width(line, height)? / 2.0,+ TextAlign::Right => -metrics.line_width(line, height)?,};- for &(gid, x, advance) in glyphs {+ for (gid, x, advance) in metrics.glyphs(line, k) {// The glyph's frame: its origin on the baseline and the way the baseline runs.let (origin, dir) = match &along {None => {@@ -250,7 +320,7 @@ pub fn text_geometry_styled(origin + dir * (gx + gy * shear) + up * gy});let mut ob = Outline { out: Vec::new(), start: origin, cur: origin, map };- let _ = face.outline_glyph(gid, &mut ob);+ let _ = metrics.face.outline_glyph(gid, &mut ob);out.extend(ob.out);// A font can give a glyph any number of points: stop where the link would be refused anyway.if out.len() > MAX_LINK_ENTITIES {diff --git a/crates/sketch/src/text_style_tests.rs b/crates/sketch/src/text_style_tests.rsindex e4dc2d259a..14b9431dd6 100644--- a/crates/sketch/src/text_style_tests.rs+++ b/crates/sketch/src/text_style_tests.rs@@ -1,10 +1,10 @@//! Text styles: alignment, letter and line spacing, a made-up italic, a bold the font lacks, and-//! text that follows a curve of its sketch.+//! text that follows a curve of its sketch; and text measured (`TextMetrics`) by the rule that draws it.use solidcraft_geom::Vec2;use super::*;-use crate::{CurveKind, Sketch};+use crate::{CurveKind, Sketch, font_data};fn v(x: f64, y: f64) -> Vec2 {Vec2::new(x, y)@@ -187,6 +187,45 @@ fn a_style_is_saved_only_when_it_is_not_plain_and_reads_back() {assert_eq!(serde_json::from_value::<LinkSource>(old).unwrap(), plain);}+/// What pins an outline exactly: how many pieces it has, its first and last point, and the sum of all its points.+fn pin(g: &[LinkGeom]) -> (usize, Vec2, Vec2, Vec2) {+ let pts = points(g);+ let sum = pts.iter().fold(Vec2::ZERO, |s, p| s + *p);+ (g.len(), pts.first().copied().unwrap_or_default(), pts.last().copied().unwrap_or_default(), sum)+}++#[test]+fn the_outlines_of_styled_texts_stay_exactly_as_they_were() {+ // Pinned before `TextMetrics` took over the layout (#4813): curves and a descender; spacing, a blank line, a made-up+ // italic and an angle; a path; glyphs the font lacks (`?`, and U+FFFF, which its character map sends to `.notdef`);+ // line breaks at both ends.+ let arc: Vec<Vec2> = (0..=90).map(|i| v(40.0 * f64::from(i).to_radians().cos(), 40.0 * f64::from(i).to_radians().sin())).collect();+ let spaced = TextStyle { italic: true, align: TextAlign::Center, letter_spacing: 0.75, line_spacing: 1.5, ..TextStyle::default() };+ let on_arc = TextStyle { align: TextAlign::Right, path: Some("arc".into()), ..TextStyle::default() };+ let missing = TextStyle { align: TextAlign::Right, letter_spacing: -0.5, ..TextStyle::default() };+ let cases: [(&str, Vec2, f64, f64, &TextStyle, Option<&[Vec2]>); 5] = [+ ("Hg", v(5.0, -3.0), 10.0, 0.0, &TextStyle::default(), None),+ ("Ab\n\nC", v(1.0, 2.0), 7.0, 0.3, &spaced, None),+ ("Hi", Vec2::ZERO, 5.0, 0.0, &on_arc, Some(&arc)),+ ("x\u{5b57}y\u{ffff}", v(-2.0, 0.5), 4.0, -1.0, &missing, None),+ ("\nH\n", Vec2::ZERO, 3.5, 0.0, &TextStyle::default(), None),+ ];+ let pins: Vec<_> = cases+ .iter()+ .map(|(text, at, height, angle, style, path)| pin(&text_geometry_styled(None, text, *at, *height, *angle, style, *path).unwrap()))+ .collect();+ assert_eq!(+ pins,+ [+ (45, v(12.955997161107167, -3.0), v(21.330731014904188, 0.8396025550035482), v(2070.968772178849, 45.508161816891416)),+ (58, v(0.235951166654778, 1.7636519993743809), v(11.036554267036463, -25.010425523555526), v(777.6105726380807, -898.3264755185471)),+ (20, v(39.918286168688034, 2.884686538489657), v(39.984307910534746, 1.1283251324010486), v(1709.968158829435, 122.02595165962421)),+ (66, v(-7.205346806960301, 8.606847326667703), v(-0.7406630833657615, 5.5426375007981274), v(-709.3625374614094, 1175.3199400202661)),+ (12, v(2.784599006387509, -5.849893541518807), v(2.784599006387509, -5.849893541518807), v(44.11639460610361, -97.83108587650818)),+ ]+ );+}+#[test]fn on_a_closed_curve_left_alignment_starts_at_the_top() {let r = 30.0;@@ -195,3 +234,154 @@ fn on_a_closed_curve_left_alignment_starts_at_the_top() {// It runs clockwise from the top: to the right of it, coming down.assert!(lo.x > -1.0 && hi.x > 10.0 && hi.y > r, "{lo:?} {hi:?}");}++/// The built-in font, Liberation Sans, as its own tables give it: 2048 units per em, a capital height of 1409 units,+/// ascender 1854, descender -434 and line gap 67 (2355 units from baseline to baseline); `0` and `?` advance 1139+/// units, `H` 1479, `A` and `V` 1366. At a capital height of 1409 mm a unit is a millimetre.+const CAP: f64 = 1409.0;++#[test]+fn text_is_measured_by_the_fonts_own_tables() {+ let font = font_data(None).unwrap();+ let m = TextMetrics::new(&font, &TextStyle::default()).unwrap();+ assert_eq!((m.scale(CAP).unwrap(), m.line_pitch(CAP).unwrap()), (1.0, 2355.0));+ assert_eq!((m.line_width("0", CAP).unwrap(), m.line_width("H0", CAP).unwrap()), (1139.0, 1479.0 + 1139.0));+ assert_eq!(m.line_width("", CAP).unwrap(), 0.0);+ // No kerning: the font's own pair for A and V (152 units closer) is not used, in measured or drawn text.+ assert_eq!(m.line_width("AV", CAP).unwrap(), 2.0 * 1366.0);+ // At 3.5 mm, a parts list's text: 5.850 mm between lines, 2.829 mm a digit.+ assert!((m.line_pitch(3.5).unwrap() - 5.850).abs() < 5e-4 && (m.line_width("0", 3.5).unwrap() - 2.829).abs() < 5e-4);+}++#[test]+fn letter_spacing_goes_between_letters_only_and_line_spacing_scales_the_pitch() {+ let font = font_data(None).unwrap();+ let spaced = TextMetrics::new(&font, &TextStyle { letter_spacing: 2.5, line_spacing: 1.5, ..TextStyle::default() }).unwrap();+ // One letter has no gap, three have two.+ assert_eq!(spaced.line_width("0", CAP).unwrap(), 1139.0);+ assert_eq!(spaced.line_width("000", CAP).unwrap(), 3.0 * 1139.0 + 2.0 * 2.5);+ assert_eq!(spaced.line_pitch(CAP).unwrap(), 1.5 * 2355.0);+ // Closer than the letters are wide, each starts left of the one before and the line measures less than nothing.+ let tight = TextMetrics::new(&font, &TextStyle { letter_spacing: -2000.0, ..TextStyle::default() }).unwrap();+ assert_eq!(tight.line_width("000", CAP).unwrap(), 3.0 * 1139.0 - 2.0 * 2000.0);+}++#[test]+fn the_characters_a_font_lacks_are_named_in_order_each_time() {+ let font = font_data(None).unwrap();+ let m = TextMetrics::new(&font, &TextStyle::default()).unwrap();+ // It has no 字, tab or emoji; its character map sends U+FFFF to its missing-glyph box.+ assert_eq!(m.missing("a\u{5b57}b\t\u{5b57}\u{ffff}\u{1f600}c"), ['\u{5b57}', '\t', '\u{5b57}', '\u{ffff}', '\u{1f600}']);+ assert!(m.missing("").is_empty() && m.missing("Hello, w\u{f6}rld \u{20ac} 0?").is_empty());+ // Only characters it lacks: each is set, drawn and measured as `?`, which is why they are named.+ assert_eq!(m.line_width("\u{5b57}\u{5b57}", CAP).unwrap(), 2.0 * 1139.0);+ assert_eq!(styled("\u{5b57}", &TextStyle::default(), None), styled("?", &TextStyle::default(), None));+ // The box is drawn and measured as it is (1536 units), as before.+ assert_eq!(m.line_width("\u{ffff}", CAP).unwrap(), 1536.0);+}++#[test]+fn a_line_too_long_to_draw_is_still_measured() {+ // A hundred times the characters a text may have, in one pass.+ let font = font_data(None).unwrap();+ let m = TextMetrics::new(&font, &TextStyle::default()).unwrap();+ let long = "0".repeat(100 * MAX_TEXT_CHARS);+ assert!(matches!(text_geometry(&long, Vec2::ZERO, 1.0, 0.0), Err(SketchError::TooLarge)));+ assert_eq!(m.line_width(&long, CAP).unwrap(), 100_000.0 * 1139.0);+ assert!(m.missing(&long).is_empty());+}++#[test]+fn line_breaks_at_the_ends_are_empty_lines() {+ let font = font_data(None).unwrap();+ let m = TextMetrics::new(&font, &TextStyle::default()).unwrap();+ // Three lines: the H stands on the second baseline, one measured pitch below the first.+ assert_eq!(extent(&styled("\nH\n", &TextStyle::default(), None)).0.y, -m.line_pitch(10.0).unwrap());+ assert!(styled("\n", &TextStyle::default(), None).is_empty());+}++#[test]+fn sizes_and_spacings_a_text_refuses_are_refused_by_its_measure() {+ let font = font_data(None).unwrap();+ let m = TextMetrics::new(&font, &TextStyle::default()).unwrap();+ // A capital height above a micrometre and below a kilometre.+ for h in [0.0, -1.0, 1e-6, 1e6, f64::NAN, f64::INFINITY, f64::NEG_INFINITY] {+ assert!(m.scale(h).is_err() && m.line_pitch(h).is_err() && m.line_width("H", h).is_err(), "{h}");+ assert!(text_geometry("H", Vec2::ZERO, h, 0.0).is_err(), "{h}");+ }+ for h in [2e-6, 999_999.0] {+ let width = m.line_width(&"W".repeat(MAX_TEXT_CHARS), h).unwrap();+ assert!(width.is_finite() && width > 0.0 && m.line_pitch(h).unwrap().is_finite(), "{h}");+ }+ // The spacing a text accepts, at its bounds and just past them.+ for (letter_spacing, line_spacing, ok) in [+ (MAX_LETTER_SPACING, LINE_SPACING_RANGE.0, true),+ (-MAX_LETTER_SPACING, LINE_SPACING_RANGE.1, true),+ (MAX_LETTER_SPACING * (1.0 + 1e-12), 1.0, false),+ (f64::NAN, 1.0, false),+ (0.0, LINE_SPACING_RANGE.0 * (1.0 - 1e-12), false),+ (0.0, LINE_SPACING_RANGE.1 * (1.0 + 1e-12), false),+ (0.0, f64::INFINITY, false),+ ] {+ let style = TextStyle { letter_spacing, line_spacing, ..TextStyle::default() };+ assert_eq!(TextMetrics::new(&font, &style).is_ok(), ok, "{style:?}");+ assert_eq!(text_geometry_styled(None, "H", Vec2::ZERO, 10.0, 0.0, &style, None).is_ok(), ok, "{style:?}");+ }+}++#[test]+fn a_line_measures_what_it_draws() {+ // Right-aligned, a line ends at the anchor: its outline is the left-aligned one moved back by its measured width+ // (centred, by half of it). The next line stands one measured pitch below.+ for style in [TextStyle::default(), TextStyle { italic: true, letter_spacing: -0.4, line_spacing: 1.3, ..TextStyle::default() }] {+ let (font, _) = font_data_styled(None, style.bold, style.italic).unwrap();+ let m = TextMetrics::new(&font, &style).unwrap();+ for line in ["Hg", "W i d e ", "x\u{5b57}y\u{ffff}?", "0"] {+ let width = m.line_width(line, 10.0).unwrap();+ let left = points(&styled(line, &style, None));+ for (align, by) in [(TextAlign::Center, -width / 2.0), (TextAlign::Right, -width)] {+ let moved = points(&styled(line, &TextStyle { align, ..style.clone() }, None));+ let same = moved.len() == left.len() && left.iter().zip(&moved).all(|(p, q)| (*p + v(by, 0.0)).dist(*q) < 1e-9);+ assert!(same, "{line:?} {align:?} {style:?}");+ }+ }+ let two = points(&styled("Hg\nHg", &style, None));+ let (first, second) = two.split_at(two.len() / 2);+ let pitch = m.line_pitch(10.0).unwrap();+ assert!(first.iter().zip(second).all(|(p, q)| (*p - v(0.0, pitch)).dist(*q) < 1e-9), "{style:?}");+ }+}++#[test]+fn hostile_lines_are_measured_as_they_are_drawn_or_refused_alike() {+ // Characters the font has and lacks (字, a tab, U+FFFF, an emoji, NUL, a carriage return), a lone combining accent,+ // sizes and spacings at and past their bounds: never a panic, the measure refuses what the text refuses, and what+ // it measures is what is drawn.+ let chars = ['H', 'g', ' ', '?', '\u{e9}', '\u{301}', '\u{5b57}', '\t', '\u{ffff}', '\u{1f600}', '\0', '\r'];+ let lacks = ['\u{5b57}', '\t', '\u{ffff}', '\u{1f600}', '\0', '\r'];+ let heights = [0.0, -1.0, 1e-6, 2e-6, 0.5, 10.0, 999_999.0, 1e6, f64::NAN, f64::INFINITY];+ let letter = [0.0, -0.5, 3.0, -1e5, 1e5, 1.5e5, f64::NAN];+ let lines = [1.0, 0.05, 100.0, 0.04, 101.0, f64::INFINITY];+ let mut rnd = crate::tests::Lcg(4813);+ let mut pick = |n: usize| ((rnd.next() * n as f64) as usize).min(n - 1);+ let font = font_data(None).unwrap();+ for _ in 0..1000 {+ let line: String = (0..pick(10)).map(|_| chars[pick(chars.len())]).collect();+ let height = heights[pick(heights.len())];+ let style = TextStyle { letter_spacing: letter[pick(letter.len())], line_spacing: lines[pick(lines.len())], ..TextStyle::default() };+ let measured = TextMetrics::new(&font, &style).and_then(|m| Ok((m.line_width(&line, height)?, m.line_pitch(height)?, m.missing(&line))));+ let right_aligned = TextStyle { align: TextAlign::Right, ..style.clone() };+ let drawn = [&style, &right_aligned].map(|s| text_geometry_styled(None, &line, Vec2::ZERO, height, 0.0, s, None));+ let (Ok((width, pitch, missing)), [Ok(left), Ok(right)]) = (&measured, &drawn) else {+ assert!(measured.is_err() && drawn.iter().all(|d| d.is_err()), "{line:?} {height} {style:?}");+ continue;+ };+ assert!(width.is_finite() && pitch.is_finite() && *pitch > 0.0, "{line:?} {height} {style:?}");+ assert_eq!(*missing, line.chars().filter(|c| lacks.contains(c)).collect::<Vec<_>>());+ let (left, right, tol) = (points(left), points(right), 1e-12 * (1.0 + width.abs() + 2.0 * height));+ assert!(+ left.len() == right.len() && left.iter().zip(&right).all(|(p, q)| (*p - v(*width, 0.0)).dist(*q) <= tol),+ "{line:?} {height} {style:?}"+ );+ }+}