DesignCraft: An open-source page and layout design editor written by scratch in pure Rust
Text wrap: lines jump an object by whole leadings; a column's first line starts below a top object
aionggb825cf3e1077
diff --git a/crates/compose/src/lib.rs b/crates/compose/src/lib.rsindex 725abb58a..9cc863613 100644--- a/crates/compose/src/lib.rs+++ b/crates/compose/src/lib.rs@@ -691,7 +691,8 @@ pub fn compose(doc: &Document, story: &Story, frames: &[FrameSpec], opts: &Compolet est_asc = base_chars.size * 0.75;let est_tops = Tops { typo_ascent: est_asc, cap: est_asc * 0.72, xh: est_asc * 0.5 };let est_first = cur.next_baseline(f, col, base_leading, est_asc, est_tops, &pp);- let slots = estimate_slots(f, col, est_first, base_leading, base_chars.size, &glyphs[g0..], &pp, line_no);+ let est_jump = cur.jump(f, base_leading, est_asc, est_tops);+ let slots = estimate_slots(f, col, est_first, est_jump, base_leading, base_chars.size, &glyphs[g0..], &pp, line_no);let width = |j: usize| -> f64 {let (x0, x1) = slots.get(j).copied().unwrap_or((col.x0, col.x1));let ind = pp.left_indent + pp.right_indent + if line_no + j == 0 { pp.first_line_indent } else { 0.0 };@@ -711,34 +712,30 @@ pub fn compose(doc: &Document, story: &Story, frames: &[FrameSpec], opts: &Compolet (s, e) = (g0 + b.start, g0 + b.end);let line_glyphs = &glyphs[s..e.max(s)];let (asc, tops, desc, lead) = line_metrics(line_glyphs, &glyphs, s, base_leading, base_chars.size, db, &base_chars);- let mut baseline = cur.next_baseline(f, col, lead, asc, tops, &pp);- // Baseline grid.- if let Some((g_start, inc)) = f.grid- && (pp.grid_align == GridAlign::AllLines || (pp.grid_align == GridAlign::FirstLineOnly && line_no == 0))- && inc > 0.0- {- let n = ((baseline - g_start) / inc - 1e-6).ceil();- baseline = g_start + n * inc;- }- // Wrap: push the line down until a slot exists.+ // Baseline grid: the next grid line at or below.+ let grid = f.grid.filter(|&(_, inc)| {+ inc > 0.0 && (pp.grid_align == GridAlign::AllLines || (pp.grid_align == GridAlign::FirstLineOnly && line_no == 0))+ });+ let snap = |y: f64| grid.map_or(y, |(g_start, inc)| g_start + ((y - g_start) / inc - 1e-6).ceil() * inc);+ let mut baseline = snap(cur.next_baseline(f, col, lead, asc, tops, &pp));+ // Wrap: push the line down to the first position with a slot (back on the grid).let (mut x0, mut x1) = (col.x0, col.x1);if !f.exclusions.is_empty() {+ let jump = cur.jump(f, lead, asc, tops);let mut tries = 0;loop {- match free_slot(f, col, baseline - asc, baseline + desc, base_size) {- Some((a, b)) => {- x0 = a;- x1 = b;- break;- }- None => {- baseline += 1.0;- tries += 1;- if baseline > col.y1 || tries > 4000 {- break;- }- }+ let Some((nb, (a, z))) = wrap_slot(f, col, baseline, asc, desc, jump, base_size) else {+ // No room in this column.+ baseline = baseline.max(col.y1) + 1.0;+ break;+ };+ let pushed = nb > baseline;+ (baseline, x0, x1) = (nb, a, z);+ tries += 1;+ if !pushed || grid.is_none() || tries > 4000 {+ break;}+ baseline = snap(baseline);}}let capped = line_cap[pi] == Some(line_no) && line_no > col_first_line;@@ -1294,24 +1291,36 @@ impl Cursor {fn next_baseline(&self, f: &FrameSpec, col: Rect, lead: f64, asc: f64, tops: Tops, _pp: &ParaProps) -> f64 {match self.last_baseline {Some(b) => b + lead + self.pending,- None => {- let off = match f.opts.first_baseline {- // Vertical frames measure from the ascent.- FirstBaseline::Ascent if f.opts.vertical => asc,- FirstBaseline::CapHeight if f.opts.vertical => asc * 0.72,- FirstBaseline::XHeight if f.opts.vertical => asc * 0.5,- FirstBaseline::Ascent => tops.typo_ascent,- FirstBaseline::CapHeight => tops.cap,- FirstBaseline::XHeight => tops.xh,- FirstBaseline::Leading => lead,- FirstBaseline::Fixed => 0.0,- };- col.y0 + off.max(f.opts.first_baseline_min)- }+ None => col.y0 + first_baseline_offset(f, lead, asc, tops),+ }+ }+ /// How the next line clears a Jump Object wrap: by whole leadings below the line above, or, first+ /// in its column, as at the top of a frame whose top is the wrap bottom.+ fn jump(&self, f: &FrameSpec, lead: f64, asc: f64, tops: Tops) -> Jump {+ match self.last_baseline {+ Some(_) => Jump { top: lead, step: lead },+ None => Jump { top: first_baseline_offset(f, lead, asc, tops), step: 0.0 },}}}+/// The frame's first baseline offset below the top of a column, for a line with leading `lead`,+/// ascent `asc` and first baseline heights `tops`.+fn first_baseline_offset(f: &FrameSpec, lead: f64, asc: f64, tops: Tops) -> f64 {+ let off = match f.opts.first_baseline {+ // Vertical frames measure from the ascent.+ FirstBaseline::Ascent if f.opts.vertical => asc,+ FirstBaseline::CapHeight if f.opts.vertical => asc * 0.72,+ FirstBaseline::XHeight if f.opts.vertical => asc * 0.5,+ FirstBaseline::Ascent => tops.typo_ascent,+ FirstBaseline::CapHeight => tops.cap,+ FirstBaseline::XHeight => tops.xh,+ FirstBaseline::Leading => lead,+ FirstBaseline::Fixed => 0.0,+ };+ off.max(f.opts.first_baseline_min)+}+/// A line's tallest typographic ascender, cap height and x height above its baseline: the/// first baseline offsets.#[derive(Clone, Copy, Default)]@@ -1354,6 +1363,64 @@ fn line_metrics((asc, tops, desc, lead)}+/// How a line clears Jump Object wraps. The line occupies `[baseline − top, baseline]` (its leading,+/// or its first baseline offset at the top of a column) and must not overlap the wrap; it may hang its+/// descenders into the wrap. Below a wrap it moves down from its place in whole `step`s until it clears+/// the wrap bottom (`step` 0: its top lands on the wrap bottom).+#[derive(Clone, Copy, Debug)]+struct Jump {+ top: f64,+ step: f64,+}++/// Slack for float error when a line is tested against a Jump Object wrap's edges.+const JUMP_EPS: f64 = 1e-6;++/// The first baseline at or below `baseline` where a line with ascent `asc` and descent `desc` has a+/// free slot in `col`, and that slot; None if there is none above the column bottom.+///+/// A line under a Jump Object wrap moves below it as `jump` says. Other wraps are rectangles, so the+/// free space only grows where one in the line's band ends: the search jumps from one such bottom+/// edge to the next, and a line that clears a wrap has its top exactly on the wrap's bottom.+fn wrap_slot(f: &FrameSpec, col: Rect, baseline: f64, asc: f64, desc: f64, jump: Jump, size: f64) -> Option<(f64, (f64, f64))> {+ let top = jump.top.max(0.0);+ let mut b = baseline;+ // Each step passes at least one wrap; the cap bounds hostile geometry.+ for _ in 0..4000 {+ let jumped = f+ .exclusions+ .iter()+ .filter(|e| e.mode == WrapMode::JumpObject)+ .map(|e| e.rect)+ .filter(|r| r.x0 < col.x1 && r.x1 > col.x0 && b > r.y0 + JUMP_EPS && b - top < r.y1 - JUMP_EPS)+ .fold(f64::NEG_INFINITY, |m, r| m.max(r.y1));+ b = if jumped > f64::NEG_INFINITY {+ if jump.step > 0.0 {+ // Whole steps from the line's own place (at least one step past the line above).+ baseline + ((jumped + top - baseline - JUMP_EPS / 2.0) / jump.step).ceil().max(0.0) * jump.step+ } else {+ jumped + top+ }+ } else if let Some(slot) = free_slot(f, col, b - asc, b + desc, size) {+ return Some((b, slot));+ } else {+ let (y0, y1) = (b - asc, b + desc);+ let edge = f+ .exclusions+ .iter()+ .filter(|e| e.mode != WrapMode::JumpObject)+ .map(|e| e.rect)+ .filter(|r| r.y0 < y1 && r.y1 > y0)+ .fold(f64::INFINITY, |m, r| m.min(r.y1));+ edge + asc+ };+ if b.is_nan() || b > col.y1 {+ return None;+ }+ }+ None+}+/// Widest free horizontal interval of `col` in the band, or None if blocked.fn free_slot(f: &FrameSpec, col: Rect, y0: f64, y1: f64, size: f64) -> Option<(f64, f64)> {let mut free = vec![(col.x0, col.x1)];@@ -1362,7 +1429,6 @@ fn free_slot(f: &FrameSpec, col: Rect, y0: f64, y1: f64, size: f64) -> Option<(flet overlaps_band = r.y0 < y1 && r.y1 > y0;match ex.mode {WrapMode::JumpToNextColumn if y1 > r.y0 && r.x0 < col.x1 && r.x1 > col.x0 => return None,- WrapMode::JumpObject if overlaps_band && r.x0 < col.x1 && r.x1 > col.x0 => return None,WrapMode::BoundingBox | WrapMode::Contour if overlaps_band => {let mut next = Vec::new();for (a, b) in free {@@ -1386,7 +1452,17 @@ fn free_slot(f: &FrameSpec, col: Rect, y0: f64, y1: f64, size: f64) -> Option<(f}#[allow(clippy::too_many_arguments)]-fn estimate_slots(f: &FrameSpec, col: Rect, first: f64, lead: f64, size: f64, glyphs: &[Glyph], pp: &ParaProps, line_no: usize) -> Vec<(f64, f64)> {+fn estimate_slots(+ f: &FrameSpec,+ col: Rect,+ first: f64,+ jump: Jump,+ lead: f64,+ size: f64,+ glyphs: &[Glyph],+ pp: &ParaProps,+ line_no: usize,+) -> Vec<(f64, f64)> {let _ = (pp, line_no);if f.exclusions.is_empty() {return vec![];@@ -1396,20 +1472,21 @@ fn estimate_slots(f: &FrameSpec, col: Rect, first: f64, lead: f64, size: f64, gllet n = ((total / (col.width().max(10.0) * 0.5)).ceil() as usize + 2).min(2000);let mut v = Vec::with_capacity(n);let mut b = first;+ let mut jump = jump;for _ in 0..n {- let mut tries = 0;- let slot = loop {- if let Some(s) = free_slot(f, col, b - size * 0.8, b + size * 0.25, size) {- break s;+ let slot = match wrap_slot(f, col, b, size * 0.8, size * 0.25, jump, size) {+ Some((nb, s)) => {+ b = nb;+ s}- b += 1.0;- tries += 1;- if b > col.y1 || tries > 4000 {- break (col.x0, col.x1);+ None => {+ b = b.max(col.y1);+ (col.x0, col.x1)}};v.push(slot);b += lead;+ jump = Jump { top: lead, step: lead };}v}diff --git a/crates/compose/src/tests.rs b/crates/compose/src/tests.rsindex 1edef7739..672d5d97e 100644--- a/crates/compose/src/tests.rs+++ b/crates/compose/src/tests.rs@@ -146,6 +146,241 @@ fn wrap_pushes_text_aside() {assert!(below.x0 < 1.0);}+/// Insert rectangles with wrap, given as (bounds, [top, left, bottom, right] offsets, mode).+fn add_wrap_objects(d: &mut Document, objects: &[(Rect, [f64; 4], WrapMode)]) {+ let lid = d.default_layer();+ for &(r, offsets, mode) in objects {+ let id = ItemId(d.alloc());+ let mut it = designcraft_doc::Item::new(id, lid, designcraft_doc::Shape::Rectangle, designcraft_geom::shapes::rectangle(r));+ it.wrap.mode = mode;+ it.wrap.offsets = offsets;+ d.insert_item(SpreadRef::Doc(0), it, None).unwrap();+ }+}++/// 10 pt on 12 pt text in a 288 × 528 frame at (36, 36), with wrap objects.+fn wrap_doc(para: ParaAttrs, objects: &[(Rect, [f64; 4], WrapMode)]) -> (Document, StoryId) {+ let text = [LOREM; 6].join(" ");+ let (mut d, sid, _) = doc_with(&text, Rect::new(36.0, 36.0, 324.0, 564.0), para);+ d.story_mut(sid).unwrap().format_chars(0..text.len(), |f| {+ f.over.size = Some(10.0);+ f.over.leading = Some(designcraft_doc::Leading::Points(12.0));+ });+ add_wrap_objects(&mut d, objects);+ (d, sid)+}++/// The first line whose baseline is below the top of `ex`.+fn first_line_below<'a>(cs: &'a ComposedStory, ex: &Exclusion) -> &'a Line {+ cs.frames[0].lines.iter().find(|l| l.baseline > ex.rect.y0).unwrap()+}++/// 14 pt on 18 pt `text` in a frame from y 62.36 to 532.91 with first baseline offset Leading, so lines+/// sit at 80.36 + n × 18 (the setup measured in InDesign), with Jump Object wraps given as+/// (bounds, [top, left, bottom, right] offsets).+fn jump_doc(text: &str, objects: &[(Rect, [f64; 4])]) -> (Document, StoryId, ItemId) {+ let (mut d, sid, fid) = doc_with(text, Rect::new(36.0, 62.36, 324.0, 532.91), ParaAttrs::default());+ d.story_mut(sid).unwrap().format_chars(0..text.len(), |f| {+ f.over.size = Some(14.0);+ f.over.leading = Some(designcraft_doc::Leading::Points(18.0));+ });+ d.item_mut(fid).unwrap().text_frame_mut().unwrap().options.first_baseline = FirstBaseline::Leading;+ let objects: Vec<_> = objects.iter().map(|&(r, o)| (r, o, WrapMode::JumpObject)).collect();+ add_wrap_objects(&mut d, &objects);+ (d, sid, fid)+}++/// Baselines of the last line above the top of the first wrap and of the first line below it.+fn around_wrap(d: &Document, sid: StoryId) -> (Option<f64>, f64) {+ let specs = frame_specs(d, sid);+ let ex = &specs[0].exclusions[0];+ let cs = compose_story(d, sid, &ComposeOptions::default());+ let lines = &cs.frames[0].lines;+ let above = lines.iter().rev().find(|l| l.baseline <= ex.rect.y0 + 1e-6).map(|l| l.baseline);+ (above, first_line_below(&cs, ex).baseline)+}++fn near(a: f64, b: f64) -> bool {+ (a - b).abs() < 0.01+}++#[test]+fn jump_object_moves_the_next_line_down_by_whole_leadings() {+ // As measured: last baseline above 386.41, wrap bottom 472.77 → 494.40 (6 leadings). Here the last+ // line above is at 386.36 and the wrap ends 86.36 below it.+ let text = [LOREM; 8].join(" ");+ let (d, sid, _) = jump_doc(&text, &[(Rect::new(36.0, 395.0, 200.0, 472.72), [0.0; 4])]);+ let (above, below) = around_wrap(&d, sid);+ assert!(near(above.unwrap(), 386.36), "{above:?}");+ assert!(near(below, 386.36 + 6.0 * 18.0), "{below}");+ // The lines after it keep the leading.+ let cs = compose_story(&d, sid, &ComposeOptions::default());+ let next = cs.frames[0].lines.iter().find(|l| l.baseline > below + 1.0).unwrap();+ assert!(near(next.baseline, below + 18.0));+}++#[test]+fn jump_object_clears_the_wrap_with_the_leading_not_the_ascent() {+ // As measured: last 152.38, wrap bottom 246.90 → 278.38. Clearing the wrap with the line's ascent+ // instead of its leading would put the line one leading higher (here the wrap ends a little higher,+ // as the test font's ascent is larger).+ let text = [LOREM; 8].join(" ");+ let (d, sid, _) = jump_doc(&text, &[(Rect::new(36.0, 160.0, 324.0, 244.0), [0.0; 4])]);+ let (above, below) = around_wrap(&d, sid);+ assert!(near(above.unwrap(), 152.36), "{above:?}");+ assert!(near(below, 152.36 + 7.0 * 18.0), "{below}");+ let cs = compose_story(&d, sid, &ComposeOptions::default());+ let asc = cs.frames[0].lines[0].ascent;+ let by_ascent = (1..).map(|k| 152.36 + k as f64 * 18.0).find(|b| b - asc >= 244.0).unwrap();+ assert!(!near(by_ascent, below), "the case must tell the two rules apart ({asc})");+}++#[test]+fn jump_object_adds_space_before_once() {+ // As measured: a heading at 78.36, then a paragraph with 60 pt space before, wrap bottom 439.71 →+ // 462.36 = 78.36 + 60 + 18 × 18.+ let text = format!("Heading\n{}", [LOREM; 6].join(" "));+ let (mut d, sid, _) = jump_doc(&text, &[(Rect::new(36.0, 90.0, 324.0, 439.71), [0.0; 4])]);+ d.story_mut(sid).unwrap().format_paras(10..10, |p| p.para.space_before = Some(60.0));+ let (above, below) = around_wrap(&d, sid);+ assert!(near(above.unwrap(), 80.36), "{above:?}");+ assert!(near(below, 80.36 + 60.0 + 18.0 * 18.0), "{below}");+}++#[test]+fn jump_object_at_the_frame_top_starts_text_like_a_frame_top() {+ // As measured: wrap bottom 266.83 → first baseline 284.835 (Leading offset: one leading below).+ let text = [LOREM; 8].join(" ");+ let (mut d, sid, fid) = jump_doc(&text, &[(Rect::new(36.0, 50.0, 324.0, 266.83), [0.0; 4])]);+ let cs = compose_story(&d, sid, &ComposeOptions::default());+ let lines = &cs.frames[0].lines;+ assert!(near(lines[0].baseline, 266.83 + 18.0), "{}", lines[0].baseline);+ assert!(near(lines[1].baseline, 266.83 + 36.0), "{}", lines[1].baseline);+ // Ascent offset: the line's ascent below the wrap.+ d.item_mut(fid).unwrap().text_frame_mut().unwrap().options.first_baseline = FirstBaseline::Ascent;+ let cs = compose_story(&d, sid, &ComposeOptions::default());+ let l = &cs.frames[0].lines[0];+ assert!(near(l.baseline, 266.83 + l.ascent), "{} vs {}", l.baseline, l.ascent);+}++#[test]+fn line_above_jump_object_stays_while_its_baseline_is_above_the_wrap() {+ let text = [LOREM; 8].join(" ");+ // The line at 386.36 hangs its descenders into the object and stays.+ let (d, sid, _) = jump_doc(&text, &[(Rect::new(36.0, 386.36, 324.0, 420.0), [0.0; 4])]);+ let (above, below) = around_wrap(&d, sid);+ assert!(near(above.unwrap(), 386.36), "{above:?}");+ assert!(near(below, 440.36), "{below}");+ // A wrap starting just above its baseline makes it jump.+ let (d, sid, _) = jump_doc(&text, &[(Rect::new(36.0, 386.3, 324.0, 420.0), [0.0; 4])]);+ let (above, below) = around_wrap(&d, sid);+ assert!(near(above.unwrap(), 368.36), "{above:?}");+ assert!(near(below, 440.36), "{below}");+}++#[test]+fn negative_jump_offsets_shrink_the_wrap() {+ let text = [LOREM; 8].join(" ");+ let (d, sid, _) = jump_doc(&text, &[(Rect::new(36.0, 300.0, 324.0, 500.0), [-20.0, 0.0, -30.0, 0.0])]);+ let specs = frame_specs(&d, sid);+ let r = specs[0].exclusions[0].rect;+ assert!(near(r.y0, 320.0) && near(r.y1, 470.0), "{r:?}");+ let (above, below) = around_wrap(&d, sid);+ assert!(near(above.unwrap(), 314.36), "{above:?}");+ assert!(near(below, 494.36), "{below}");+}++#[test]+fn jump_object_down_to_the_frame_bottom_sends_text_to_the_next_frame() {+ let text = [LOREM; 8].join(" ");+ let (mut d, sid, a) = jump_doc(&text, &[(Rect::new(36.0, 300.0, 324.0, 540.0), [0.0; 4])]);+ let lid = d.default_layer();+ let (b, _) = d.add_text_frame(SpreadRef::Doc(0), Rect::new(350.0, 62.36, 550.0, 532.91), lid, "", ParaFormat::default()).unwrap();+ d.item_mut(b).unwrap().text_frame_mut().unwrap().options.first_baseline = FirstBaseline::Leading;+ d.thread(a, b).unwrap();+ let cs = compose_story(&d, sid, &ComposeOptions::default());+ let last = cs.frames[0].lines.last().unwrap();+ assert!(near(last.baseline, 296.36), "{}", last.baseline);+ assert!(near(cs.frames[1].lines[0].baseline, 62.36 + 18.0), "{}", cs.frames[1].lines[0].baseline);+ assert_eq!(cs.frames[0].range.end, cs.frames[1].range.start);+}++#[test]+fn full_width_bounding_box_wrap_resumes_exactly_below() {+ // A bounding-box wrap across the whole column leaves no slot: the line jumps it like Jump Object.+ let (d, sid) = wrap_doc(ParaAttrs::default(), &[(Rect::new(20.0, 100.0, 340.0, 150.25), [0.0; 4], WrapMode::BoundingBox)]);+ let specs = frame_specs(&d, sid);+ let cs = compose_story(&d, sid, &ComposeOptions::default());+ let ex = &specs[0].exclusions[0];+ let l = first_line_below(&cs, ex);+ assert!((l.baseline - l.ascent - ex.rect.y1).abs() < 0.01, "{} vs {}", l.baseline - l.ascent, ex.rect.y1);+ // A slot narrower than 1.5 × the size is no slot either.+ let (d, sid) = wrap_doc(ParaAttrs::default(), &[(Rect::new(50.0, 100.0, 340.0, 150.25), [0.0; 4], WrapMode::BoundingBox)]);+ let specs = frame_specs(&d, sid);+ let cs = compose_story(&d, sid, &ComposeOptions::default());+ let ex = &specs[0].exclusions[0];+ let l = first_line_below(&cs, ex);+ assert!((l.baseline - l.ascent - ex.rect.y1).abs() < 0.01, "{} vs {}", l.baseline - l.ascent, ex.rect.y1);+}++#[test]+fn jump_object_keeps_grid_aligned_lines_on_the_grid() {+ // The wrap ends at 166.5, off the 12 pt grid; a second object blocks the grid line the line jumps+ // to, so the line moves on to the grid line after that object.+ let objects = [+ (Rect::new(36.0, 100.0, 200.0, 160.5), [0.0, 0.0, 6.0, 0.0], WrapMode::JumpObject),+ (Rect::new(250.0, 178.0, 324.0, 190.0), [0.0; 4], WrapMode::JumpObject),+ ];+ let (d, sid) = wrap_doc(ParaAttrs { grid_align: Some(GridAlign::AllLines), ..Default::default() }, &objects);+ let specs = frame_specs(&d, sid);+ let (g0, inc) = specs[0].grid.unwrap();+ let cs = compose_story(&d, sid, &ComposeOptions::default());+ let on_grid = |b: f64| (((b - g0) / inc).round() * inc + g0 - b).abs() < 1e-6;+ let lines = &cs.frames[0].lines;+ assert!(lines.iter().all(|l| on_grid(l.baseline)), "{:?}", lines.iter().map(|l| l.baseline).collect::<Vec<_>>());+ let exs = &specs[0].exclusions;+ let l = first_line_below(&cs, &exs[0]);+ // Naive oracle: the first grid line whose leading band clears the objects.+ let clear = |b: f64, exs: &[Exclusion]| exs.iter().all(|e| b <= e.rect.y0 || b - l.leading >= e.rect.y1);+ let want = |exs: &[Exclusion]| (0..).map(|n| g0 + n as f64 * inc).find(|&b| b > exs[0].rect.y0 && clear(b, exs)).unwrap();+ assert!((l.baseline - want(exs)).abs() < 1e-6, "baseline {} should be on grid line {}", l.baseline, want(exs));+ assert!(want(&exs[..1]) < want(exs), "the second object pushed the line again");++ // First line only: a later line of the paragraph jumps by whole leadings from the line above.+ let (d, sid) = wrap_doc(ParaAttrs { grid_align: Some(GridAlign::FirstLineOnly), ..Default::default() }, &objects[..1]);+ let specs = frame_specs(&d, sid);+ let cs = compose_story(&d, sid, &ComposeOptions::default());+ let ex = &specs[0].exclusions[0];+ let l = first_line_below(&cs, ex);+ assert!(!l.first_in_para);+ let above = cs.frames[0].lines.iter().rev().find(|a| a.baseline <= ex.rect.y0).unwrap().baseline;+ let want = (1..).map(|k| above + k as f64 * 12.0).find(|b| b - 12.0 >= ex.rect.y1).unwrap();+ assert!((l.baseline - want).abs() < 1e-6, "{} vs {want}", l.baseline);+}++#[test]+fn hostile_wrap_geometry_terminates() {+ let (d, sid) = wrap_doc(ParaAttrs { grid_align: Some(GridAlign::AllLines), ..Default::default() }, &[]);+ let mut specs = frame_specs(&d, sid);+ let ex = |x0: f64, y0: f64, x1: f64, y1: f64, mode| Exclusion { rect: Rect::new(x0, y0, x1, y1), mode };+ let f = &mut specs[0];+ f.exclusions.push(ex(f64::NAN, f64::NAN, f64::NAN, f64::NAN, WrapMode::JumpObject));+ f.exclusions.push(ex(-1e308, 300.0, 1e308, f64::INFINITY, WrapMode::JumpObject));+ f.exclusions.push(ex(0.0, f64::NEG_INFINITY, 400.0, 40.0, WrapMode::BoundingBox));+ // A wall of overlapping strips, each ending 0.25 pt below the previous.+ for i in 0..3000 {+ let y = 60.0 + i as f64 * 0.25;+ f.exclusions.push(ex(0.0, y, 400.0, y + 1.0, if i % 2 == 0 { WrapMode::JumpObject } else { WrapMode::BoundingBox }));+ }+ f.grid = Some((0.0, 1e-300));+ let story = d.story(sid).unwrap();+ let cs = compose(&d, story, &specs, &ComposeOptions::default());+ assert!(cs.is_overset());+ for l in &cs.frames[0].lines {+ assert!(l.baseline.is_finite() && l.baseline - l.ascent >= 40.0 && l.baseline + l.descent <= 300.0, "{}", l.baseline);+ }+}+#[test]fn paragraph_composer_is_no_worse_than_greedy() {// Sum of squared slack over lines (excluding last) should not exceed the greedy result.