Skip to content

DesignCraft: An open-source page and layout design editor written by scratch in pure Rust

Merge #293: Text: a word longer than the line breaks at the column edge; a line that exactly fills the measure fits

aiongg92f4a05888ea
diff --cc crates/compose/src/breaker.rs
index 783d5eed1,d0a32ab32..bf2c23450
--- a/crates/compose/src/breaker.rs
+++ b/crates/compose/src/breaker.rs
@@@ -154,29 -146,17 +154,32 @@@ struct Item
auto: bool,
/// Breaks: optical hang of the glyph ending the line. Boxes: hang of the glyph starting one.
hang: f64,
+ edge_elastic: [f64; 2],
+ start_elastic: [f64; 2],
/// Auto hyphenation points: index of the break opportunity before the word (or `NONE`).
zone_from: usize,
+ /// An emergency break inside a word wider than the measure.
+ emergency: bool,
}
const NONE: usize = usize::MAX;
impl Item {
fn boxed(w: f64, st: [f64; 3], sh: [f64; 3]) -> Item {
- Item { kind: Kind::Box, w, st, sh, p: 0.0, flagged: false, auto: false, hang: 0.0, zone_from: NONE, emergency: false }
+ Item {
+ kind: Kind::Box,
+ w,
+ st,
+ sh,
+ p: 0.0,
+ flagged: false,
+ auto: false,
+ hang: 0.0,
+ edge_elastic: [0.0; 2],
+ start_elastic: [0.0; 2],
+ zone_from: NONE,
++ emergency: false,
+ }
}
fn glue(w: f64, st: f64, sh: f64) -> Item {
Item {
@@@ -188,25 -168,12 +191,27 @@@
flagged: false,
auto: false,
hang: 0.0,
+ edge_elastic: [0.0; 2],
+ start_elastic: [0.0; 2],
zone_from: NONE,
+ emergency: false,
}
}
fn penalty(w: f64, p: f64, flagged: bool) -> Item {
- Item { kind: Kind::Penalty, w, st: [0.0; 3], sh: [0.0; 3], p, flagged, auto: false, hang: 0.0, zone_from: NONE, emergency: false }
+ Item {
+ kind: Kind::Penalty,
+ w,
+ st: [0.0; 3],
+ sh: [0.0; 3],
+ p,
+ flagged,
+ auto: false,
+ hang: 0.0,
+ edge_elastic: [0.0; 2],
+ start_elastic: [0.0; 2],
+ zone_from: NONE,
++ emergency: false,
+ }
}
}
@@@ -449,9 -421,49 +472,49 @@@ pub fn knuth_plass(glyphs: &[Glyph], hy
return b;
}
}
- greedy(glyphs, hyph_after, sp, width)
+ greedy(glyphs, hyph_after, sp, width, &|_, _, _| 0.0)
}
+ /// Glyphs after which a word wider than `measure` may take an emergency break, or `None` when every
+ /// word fits. A word is a run of boxes between two break opportunities (so a word with hyphenation
+ /// points only gets emergency breaks where a part between them is still too wide), measured at
+ /// its narrowest (fully shrunk) width. Emergency breaks respect no-break text and kinsoku.
+ fn overlong_words(items: &[Item], ig: &[usize], glyphs: &[Glyph], measure: f64) -> Option<Vec<bool>> {
+ let mut out: Option<Vec<bool>> = None;
+ let mut seg: Option<(usize, usize)> = None;
+ let mut w = 0.0;
+ for (k, it) in items.iter().enumerate() {
+ match it.kind {
+ Kind::Box => {
+ let g = ig.get(k).copied().unwrap_or(0);
+ seg = Some(seg.map_or((g, g), |(a, _)| (a, g)));
+ w += it.w - it.sh.iter().sum::<f64>();
+ }
+ Kind::Penalty if it.p >= INF => {}
+ Kind::Glue | Kind::Penalty => {
+ if let Some((a, b)) = seg.take()
+ && w > measure + FIT_EPS
+ {
+ let marks = out.get_or_insert_with(|| vec![false; glyphs.len()]);
+ for i in a..b {
+ let (Some(g), Some(next)) = (glyphs.get(i), glyphs.get(i + 1)) else { continue };
+ let ok = !g.no_break
+ && g.break_after != Some(false)
+ && next.ch != SOFT_HYPHEN
+ && !is_forced(next.ch)
+ && kinsoku_allows(g.ch, next.ch);
+ if let Some(m) = marks.get_mut(i) {
+ *m = ok;
+ }
+ }
+ }
+ w = 0.0;
+ }
+ }
+ }
+ out
+ }
+
/// Upper bound on the hyphen-count states tracked per breakpoint.
const MAX_HYPHEN_STATES: usize = 8;
@@@ -525,9 -525,15 +588,17 @@@ fn kp_pass
y[t] = sy[b][t] - n.ty[t];
z[t] = sz[b][t] - n.tz[t];
}
+ y[0] = (y[0] + it.edge_elastic[0]).max(0.0);
+ z[0] = (z[0] + it.edge_elastic[1]).max(0.0);
- let (r, feasible) = tiered_ratio(target - l, y, z);
+ // A line that overruns its measure by a rounding error fits exactly.
+ let d = target - l;
+ let d = if d < 0.0 && d > -FIT_EPS { 0.0 } else { d };
+ let (mut r, feasible) = tiered_ratio(d, y, z);
+ if it.emergency && sp.justify && r > 0.0 {
+ // A piece of an overlong word usually has no elastic material: rate it by the
+ // space it leaves, so the fullest piece wins (the break at the last glyph that fits).
+ r = d / target;
+ }
if feasible && !forced {
keep.push(a);
} else {
@@@ -749,26 -737,13 +820,26 @@@ pub fn greedy
shrink += sp.space_elastic(g).1;
}
last_ok = Some((i, false));
- if x <= w {
++ if x <= w + FIT_EPS {
+ last_natural = last_ok;
+ }
last_space = Some((i, x));
x += g.adv;
i += 1;
continue;
}
let hang_r = right_hang(g, sp);
- if x + g.adv - hang_r > w + shrink + FIT_EPS
+ let adv = if g.ch == '\t' { tab(line, x, i) } else { g.adv };
+ let end_shrink = crate::mojikumi::end_elastic(g, sp.justify, sp.kinsoku_priority != 3)[1];
+ let available = shrink + sp.box_elastic(g).1.iter().sum::<f64>() + end_shrink;
+ if sp.kinsoku_priority == 2
- && x + adv - hang_r > w
++ && x + adv - hang_r > w + FIT_EPS
+ && let Some((end, hyphen)) = last_natural
+ {
+ brk = Some((end, hyphen, false));
+ break;
+ }
- if x + adv - hang_r > w + available.max(0.0)
++ if x + adv - hang_r > w + available.max(0.0) + FIT_EPS
&& i > start
&& (last_ok.is_some() || glyphs.get(i - 1).is_none_or(|p| p.break_after != Some(false) && !p.no_break))
{
@@@ -790,12 -767,9 +861,12 @@@
|| g.break_after.unwrap_or_else(|| cjk_break(g, &glyphs[i + 1], sp))
{
last_ok = Some((i + 1, false));
- if x - hang_r <= w {
++ if x - hang_r <= w + FIT_EPS {
+ last_natural = last_ok;
+ }
} else if hyph_after[i] && may_hyphenate(hyphens) {
let hy = hyphen_width(g, &mut hy_cache) * if sp.optical { 1.0 - hang('-').1 } else { 1.0 };
- if x + hy <= w + shrink {
+ if x + hy <= w + shrink + FIT_EPS {
last_ok = Some((i + 1, true));
}
}
diff --cc crates/compose/src/lib.rs
index e9fa9ac45,e9a08ad18..a1776c451
--- a/crates/compose/src/lib.rs
+++ b/crates/compose/src/lib.rs
@@@ -2340,15 -1662,12 +2340,20 @@@ fn layout_line
}
}
}
+ if (justify_this || squeeze_last) && (extra >= 0.0 || sp.kinsoku_priority != 3) {
+ extra = mojikumi::distribute(line.get_mut(seg..).unwrap_or_default(), extra, add.get_mut(seg..).unwrap_or_default());
+ }
if (justify_this || squeeze_last) && !spaces.is_empty() {
- distribute(&line, &spaces, extra, sp, &mut add, &mut scale);
- } else if justify_this && spaces.is_empty() && line.len() > 1 && !last && extra < 0.0 {
+ let rebased: Vec<usize> = spaces.iter().map(|&i| i - seg).collect();
+ let (seg_line, seg_add, seg_scale) =
+ (line.get(seg..).unwrap_or(&[]), add.get_mut(seg..).unwrap_or(&mut []), scale.get_mut(seg..).unwrap_or(&mut []));
+ distribute(seg_line, &rebased, extra, sp, seg_add, seg_scale);
++ } else if justify_this && spaces.is_empty() && line.len() > seg + 1 && !last && extra < 0.0 {
+ // An overfull single word shrinks only as far as the minimum letter spacing and glyph scaling allow.
- distribute(&line, &[], extra, sp, &mut add, &mut scale);
- } else if justify_this && spaces.is_empty() && line.len() > 1 && !last {
++ let (seg_line, seg_add, seg_scale) =
++ (line.get(seg..).unwrap_or(&[]), add.get_mut(seg..).unwrap_or(&mut []), scale.get_mut(seg..).unwrap_or(&mut []));
++ distribute(seg_line, &[], extra, sp, seg_add, seg_scale);
+ } else if justify_this && spaces.is_empty() && line.len() > seg + 1 && !last {
// Single word: Single Word Justification.
match pp.single_word_justify {
Align::FullyJustified => {
diff --cc crates/compose/src/tests.rs
index 8e8ff16f5,41ce1454c..fc982e398
--- a/crates/compose/src/tests.rs
+++ b/crates/compose/src/tests.rs
@@@ -3183,932 -1890,55 +3183,985 @@@ fn vertical_lines_fit_the_em_box()
}
}
+/// A drop cap set in one of the document's own fonts measures its side bearing in that font.
+#[test]
+fn drop_cap_in_a_document_font_aligns_its_left_edge() {
+ use designcraft_geom::Shape as _;
+ const FAMILY: &str = "DocFont Drop Cap";
+ let text = format!("Once {LOREM}");
+ let mut chars: Vec<char> = text.chars().collect();
+ chars.sort_unstable();
+ chars.dedup();
+ let folder = std::env::temp_dir().join(format!("dc-compose-dropcap-docfont-{}", std::process::id()));
+ std::fs::create_dir_all(&folder).unwrap();
+ std::fs::write(folder.join("dropcap.ttf"), designcraft_fonts::testing::font_with_glyph(FAMILY, &chars, 'O').unwrap()).unwrap();
+ let scope = designcraft_fonts::FontDb::global().load_document_fonts(&folder).scope;
+ let para = ParaAttrs { left_indent: Some(10.0), ..drop_cap(2, 1) };
+ let (mut d, sid, _) = doc_with(&text, Rect::new(0.0, 0.0, 300.0, 1000.0), para);
+ d.font_scope = scope;
+ d.story_mut(sid).unwrap().format_chars(0..text.len(), |f| f.over.font_family = Some(FAMILY.into()));
+ let cs = compose_story(&d, sid, &ComposeOptions::default());
+ let dc = &all_lines(&cs)[0].glyphs[0];
+ assert_eq!(dc.face.family, FAMILY);
+ let ink_left = dc.x + designcraft_fonts::FontDb::global().outline(dc.face.get(), dc.gid).bounding_box().x0 * dc.sx;
+ assert!(ink_left - dc.x > 0.5, "the O has a visible side bearing");
+ assert!((ink_left - 10.0).abs() < 1e-6, "ink at {ink_left}");
+ let _ = std::fs::remove_dir_all(&folder);
+}
+
+#[test]
+fn embedded_text_frames_compose_and_footnotes_retain_object_sources() {
+ use designcraft_doc::{AnchorPosition, AnchoredObject};
+ let (mut d, body, _) = doc_with("Body", Rect::new(20.0, 20.0, 400.0, 600.0), ParaAttrs::default());
+ let (fid, child) =
+ d.add_text_frame(SpreadRef::Doc(0), Rect::new(0.0, 0.0, 80.0, 40.0), d.default_layer(), "Embedded", ParaFormat::default()).unwrap();
+ let item = d.item(fid).unwrap().clone();
+ d.spread_mut(SpreadRef::Doc(0)).unwrap().items.retain(|i| i.id != fid);
+ let story = d.story_mut(body).unwrap();
+ story.insert_note(4, "Note", ParaFormat::default());
+ Arc::make_mut(&mut story.notes[0]).text.insert_object(0, AnchoredObject::new(item, AnchorPosition::Inline { y_offset: 0.0 }));
+ d.check().unwrap();
+ let child_cs = compose_story(&d, child, &ComposeOptions::default());
+ assert!(!child_cs.is_overset());
+ assert!(!child_cs.frame(fid).unwrap().lines.is_empty());
+ let cs = compose_story(&d, body, &ComposeOptions::default());
+ assert!(!cs.is_overset());
+ let note = &cs.frames[0].notes[0];
+ assert_eq!(note.text.story, StoryId(0));
+ assert_eq!(note.text.frames[0].objects[0].object.item.id, fid);
+
+ let cache = Cache::new();
+ assert!(!cache.get(&d, child, None).is_overset());
+ let note = Arc::make_mut(&mut d.story_mut(body).unwrap().notes[0]);
+ let anchor = Arc::make_mut(&mut note.text.objects[0]);
+ let original_path = anchor.item.path.clone();
+ anchor.item.path = designcraft_geom::shapes::rectangle(Rect::new(0.0, 0.0, 80.0, 1.0));
+ assert!(cache.get(&d, child, None).is_overset(), "embedded frame geometry must invalidate cached composition");
+ Arc::make_mut(&mut Arc::make_mut(&mut d.story_mut(body).unwrap().notes[0]).text.objects[0]).item.path = original_path;
+
+ // A reference back into the owning story must be rejected before rendering.
+ let mut cycle = d.anchored_item(fid).unwrap().clone();
+ cycle.id = ItemId(d.alloc());
+ cycle.text_frame_mut().unwrap().story = body;
+ d.story_mut(body).unwrap().frames.push(cycle.id);
+ d.story_mut(child).unwrap().insert_object(0, AnchoredObject::new(cycle, AnchorPosition::Inline { y_offset: 0.0 }));
+ assert!(d.check().unwrap_err().to_string().contains("cyclic"));
+}
+
+#[test]
+fn inline_object_only_line_does_not_reserve_phantom_font_descent() {
+ use designcraft_doc::{AnchorPosition, AnchoredObject, Item, Shape};
+ let (mut d, sid, _) = doc_with("", Rect::new(0.0, 0.0, 10.0, 15.0), ParaAttrs::default());
+ let item = Item::new(ItemId(d.alloc()), d.default_layer(), Shape::Rectangle, designcraft_geom::shapes::rectangle(Rect::new(0.0, 0.0, 7.0, 9.0)));
+ d.story_mut(sid).unwrap().insert_object(0, AnchoredObject::new(item, AnchorPosition::Inline { y_offset: 5.0 }));
+ let cs = compose_story(&d, sid, &ComposeOptions::default());
+ assert!(!cs.is_overset());
+ assert_eq!(cs.frames[0].objects.len(), 1);
+ assert_eq!(cs.frames[0].lines[0].descent, 0.0);
+ // Genuine geometric overflow must still be reported.
+ d.story_mut(sid).unwrap().objects[0] =
+ Arc::new(AnchoredObject::new(cs.frames[0].objects[0].object.item.clone(), AnchorPosition::Inline { y_offset: 7.0 }));
+ assert!(compose_story(&d, sid, &ComposeOptions::default()).is_overset());
+}
+
+#[test]
+fn composite_metrics_and_character_mappings_apply_inside_footnotes() {
+ use designcraft_doc::cjk::{CompositeFont, CompositeFontEntry};
+ let (mut d, sid, _) = doc_with("Body", Rect::new(0.0, 0.0, 300.0, 300.0), ParaAttrs::default());
+ d.styles_mut().composite_fonts.push(CompositeFont {
+ name: "Mixed".into(),
+ entries: vec![
+ CompositeFontEntry { family: "Source Serif 4".into(), ..Default::default() },
+ CompositeFontEntry {
+ characters: "12".into(),
+ family: "Source Sans 3".into(),
+ relative_size: 0.8,
+ horizontal_scale: 0.9,
+ vertical_scale: 1.1,
+ baseline_shift: 0.1,
+ scale_option: false,
+ ..Default::default()
+ },
+ CompositeFontEntry { characters: "2".into(), family: "Inter".into(), ..Default::default() },
+ ],
+ });
+ let story = d.story_mut(sid).unwrap();
+ story.insert_note(4, "A12", ParaFormat::default());
+ let note = Arc::make_mut(&mut story.notes[0]);
+ note.text.format_chars(0..3, |f| f.over.font_family = Some("CompositeFont/Mixed".into()));
+ let cs = compose_story(&d, sid, &ComposeOptions::default());
+ let note = &cs.frames[0].notes[0];
+ let glyphs = &note.text.frames[0].lines[0].glyphs;
+ let a = glyphs.iter().find(|g| g.byte == 0 && g.len > 0).unwrap();
+ let one = glyphs.iter().find(|g| g.byte == 1 && g.len > 0).unwrap();
+ let two = glyphs.iter().find(|g| g.byte == 2 && g.len > 0).unwrap();
+ assert_eq!(a.face.family, "Source Serif 4");
+ assert_eq!(one.face.family, "Source Sans 3");
+ assert_eq!(two.face.family, "Inter");
+ let style = &note.text.styles[one.style as usize];
+ assert!((style.size - 9.6).abs() < 1e-8);
+ assert!(!note.text.styles.iter().any(|s| s.missing_font));
+}
+
+#[test]
+fn generated_note_labels_resolve_composite_components_and_keep_one_anchor() {
+ use designcraft_doc::cjk::{CompositeFont, CompositeFontEntry};
+ let (mut d, sid, _) = doc_with("Body", Rect::new(0.0, 0.0, 300.0, 300.0), ParaAttrs::default());
+ d.styles_mut().composite_fonts.push(CompositeFont {
+ name: "Generated Mixed".into(),
+ entries: vec![
+ CompositeFontEntry { family: "Source Serif 4".into(), ..Default::default() },
+ CompositeFontEntry { characters: "[]".into(), family: "Inter".into(), relative_size: 0.8, ..Default::default() },
+ ],
+ });
+ d.footnote_options.affix_in = designcraft_doc::notes::AffixIn::Both;
+ d.footnote_options.prefix = "[".into();
+ d.footnote_options.suffix = "]".into();
+ let story = d.story_mut(sid).unwrap();
+ story.insert_note(4, "Note", ParaFormat::default());
+ story.format_chars(4..7, |f| f.over.font_family = Some("Generated Mixed".into()));
+ let cs = compose_story(&d, sid, &ComposeOptions::default());
+ let glyphs: Vec<_> = cs.frames[0].lines.iter().flat_map(|l| &l.glyphs).filter(|g| g.byte == 4).collect();
+ assert_eq!(glyphs.iter().filter(|g| g.len > 0).count(), 1);
+ assert_eq!(glyphs.iter().map(|g| g.rendered_char).collect::<String>(), "[1]");
+ assert!(glyphs.iter().all(|g| g.gid != 0));
+ assert!(glyphs.iter().filter(|g| matches!(g.rendered_char, '[' | ']')).all(|g| g.face.family == "Inter"));
+ assert_eq!(glyphs.iter().find(|g| g.rendered_char == '1').unwrap().face.family, "Source Serif 4");
+ assert_eq!(cs.frames[0].notes.len(), 1);
+}
+
+#[test]
+fn generated_note_labels_use_coverage_fallback() {
+ let font = designcraft_fonts::testing::font_with("Generated Label Coverage", &['\u{E888}']).unwrap();
+ designcraft_fonts::FontDb::global().add_font(font);
+ let (mut d, sid, _) = doc_with("Body", Rect::new(0.0, 0.0, 300.0, 300.0), ParaAttrs::default());
+ d.footnote_options.affix_in = designcraft_doc::notes::AffixIn::Both;
+ d.footnote_options.prefix = "\u{E888}".into();
+ d.footnote_options.suffix = "".into();
+ d.settings.glyph_fallback = true;
+ d.story_mut(sid).unwrap().insert_note(4, "Note", ParaFormat::default());
+ let cs = compose_story(&d, sid, &ComposeOptions::default());
+ let glyph = cs.frames[0].lines.iter().flat_map(|l| &l.glyphs).find(|g| g.rendered_char == '\u{E888}').unwrap();
+ assert_ne!(glyph.gid, 0);
+ assert_eq!(glyph.face.family, "Generated Label Coverage");
+}
+
+#[test]
+fn mojikumi_custom_pairs_change_positions_and_breaks_without_font_scaling() {
+ use designcraft_doc::cjk::{MojikumiAki, MojikumiTable};
+ let (mut d, sid, _) = doc_with(
+ "A1A1A1",
+ Rect::new(0.0, 0.0, 55.0, 300.0),
+ ParaAttrs { hyphenate: Some(false), composer: Some(Composer::SingleLine), ..Default::default() },
+ );
+ let before = compose_story(&d, sid, &ComposeOptions::default());
+ Arc::make_mut(&mut d.styles).mojikumi_tables.push(MojikumiTable {
+ name: "Synthetic".into(),
+ based_on: "SimpChineseDefault".into(),
+ overrides: vec![
+ MojikumiAki { target_class: 18, side_class: 25, after: true, minimum: 1.0, desired: 1.0, maximum: 1.0, ..Default::default() },
+ MojikumiAki { target_class: 25, side_class: 18, after: true, minimum: 1.0, desired: 1.0, maximum: 1.0, ..Default::default() },
+ ],
+ });
+ d.story_mut(sid).unwrap().paras[0].para.mojikumi = Some("MojikumiTable/Synthetic".into());
+ let after = compose_story(&d, sid, &ComposeOptions::default());
+ assert!(all_lines(&after).len() > all_lines(&before).len());
+ let a = &all_lines(&after)[0].glyphs;
+ let b = &all_lines(&before)[0].glyphs;
+ assert!((a[1].x - b[1].x - 12.0).abs() < 0.001);
+ assert_eq!(a[0].sx, b[0].sx);
+ assert!(all_lines(&after).iter().all(|l| l.end_x <= l.x1 + 0.01));
+}
+
+#[test]
+fn mojikumi_paragraph_indent_adds_to_paragraph_settings_and_rounds_no_glyphs() {
+ use designcraft_doc::cjk::{MojikumiAki, MojikumiTable};
+ let (mut d, sid, _) = doc_with(
+ "ABC",
+ Rect::new(0.0, 0.0, 200.0, 100.0),
+ ParaAttrs { first_line_indent: Some(7.0), mojikumi: Some("MojikumiTable/Indent".into()), ..Default::default() },
+ );
+ Arc::make_mut(&mut d.styles).mojikumi_tables.push(MojikumiTable {
+ name: "Indent".into(),
+ based_on: "SimpChineseDefault".into(),
+ overrides: vec![MojikumiAki {
+ target_class: 18,
+ side_class: 23,
+ after: false,
+ minimum: 2.0,
+ desired: 2.0,
+ maximum: 2.0,
+ ..Default::default()
+ }],
+ });
+ let cs = compose_story(&d, sid, &ComposeOptions::default());
+ let line = all_lines(&cs)[0];
+ assert!((line.glyphs[0].x - 31.0).abs() < 0.001, "{}", line.glyphs[0].x);
+ assert_eq!(line.glyphs.len(), 3);
+}
+
+#[test]
+fn mojikumi_justifies_cjk_without_spaces_and_respects_fixed_spacing() {
+ use designcraft_doc::cjk::{MojikumiAki, MojikumiTable};
+ let (mut d, sid, _) = doc_with(
+ "A1A1",
+ Rect::new(0.0, 0.0, 100.0, 100.0),
+ ParaAttrs { align: Some(Align::FullyJustified), mojikumi: Some("MojikumiTable/Elastic".into()), ..Default::default() },
+ );
+ Arc::make_mut(&mut d.styles).mojikumi_tables.push(MojikumiTable {
+ name: "Elastic".into(),
+ based_on: "SimpChineseDefault".into(),
+ overrides: vec![MojikumiAki {
+ target_class: 18,
+ side_class: 25,
+ after: true,
+ minimum: 0.0,
+ desired: 0.0,
+ maximum: 5.0,
+ priority: 1,
+ ..Default::default()
+ }],
+ });
+ let cs = compose_story(&d, sid, &ComposeOptions::default());
+ assert!((all_lines(&cs)[0].end_x - 100.0).abs() < 0.001, "{}", all_lines(&cs)[0].end_x);
+}
+
+#[test]
+fn mojikumi_fixed_pairs_are_not_stretched_by_single_word_justification() {
+ use designcraft_doc::cjk::{MojikumiAki, MojikumiTable};
+ let (mut d, sid, _) = doc_with(
+ "A1A1",
+ Rect::new(0.0, 0.0, 150.0, 100.0),
+ ParaAttrs { align: Some(Align::FullyJustified), mojikumi: Some("MojikumiTable/Fixed".into()), ..Default::default() },
+ );
+ Arc::make_mut(&mut d.styles).mojikumi_tables.push(MojikumiTable {
+ name: "Fixed".into(),
+ based_on: "SimpChineseDefault".into(),
+ overrides: [(18, 25), (25, 18)]
+ .into_iter()
+ .map(|(target_class, side_class)| MojikumiAki {
+ target_class,
+ side_class,
+ after: true,
+ minimum: 0.25,
+ desired: 0.25,
+ maximum: 0.25,
+ ..Default::default()
+ })
+ .collect(),
+ });
+ let cs = compose_story(&d, sid, &ComposeOptions::default());
+ let line = all_lines(&cs)[0];
+ assert!(line.end_x < 100.0, "Fixed spacing was stretched: {}", line.end_x);
+ d.story_mut(sid).unwrap().paras[0].para.align = Some(Align::Left);
+ let ragged = compose_story(&d, sid, &ComposeOptions::default());
+ assert_eq!(line.end_x, all_lines(&ragged)[0].end_x);
+}
+
+#[test]
+fn mojikumi_kinsoku_push_in_and_push_out_select_different_legal_breaks() {
+ use designcraft_doc::cjk::{MojikumiAki, MojikumiTable};
+ let text = "甲乙丙丁戊己庚辛";
+ let (mut d, sid, _) = doc_with(
+ text,
+ Rect::new(0.0, 0.0, 45.0, 300.0),
+ ParaAttrs {
+ composer: Some(Composer::SingleLine),
+ mojikumi: Some("MojikumiTable/Compress".into()),
+ kinsoku_type: Some("KinsokuPushInFirst".into()),
+ ..Default::default()
+ },
+ );
+ Arc::make_mut(&mut d.styles).mojikumi_tables.push(MojikumiTable {
+ name: "Compress".into(),
+ based_on: "SimpChineseDefault".into(),
+ overrides: vec![MojikumiAki {
+ target_class: 12,
+ side_class: 12,
+ after: true,
+ minimum: 0.0,
+ desired: 1.0,
+ maximum: 1.0,
+ priority: 1,
+ ..Default::default()
+ }],
+ });
+ let inside = compose_story(&d, sid, &ComposeOptions::default());
+ d.story_mut(sid).unwrap().paras[0].para.kinsoku_type = Some("KinsokuPushOutFirst".into());
+ let outside = compose_story(&d, sid, &ComposeOptions::default());
+ assert!(all_lines(&inside)[0].range.end > all_lines(&outside)[0].range.end);
+ for cs in [&inside, &outside] {
+ assert!(all_lines(cs).iter().all(|l| l.end_x <= l.x1 + 0.01));
+ }
+}
+
+#[test]
+fn mojikumi_priority_and_elastic_line_start_are_used_in_placement() {
+ use designcraft_doc::cjk::{MojikumiAki, MojikumiTable};
+ let (mut d, sid, _) = doc_with("A1B2", Rect::new(0.0, 0.0, 45.0, 100.0), ParaAttrs::default());
+ let natural = compose_story(&d, sid, &ComposeOptions::default());
+ let middle_gap = all_lines(&natural)[0].glyphs[2].x - all_lines(&natural)[0].glyphs[1].x;
+ Arc::make_mut(&mut d.styles).mojikumi_tables.push(MojikumiTable {
+ name: "Priority".into(),
+ based_on: "SimpChineseDefault".into(),
+ overrides: vec![
+ MojikumiAki {
+ target_class: 18,
+ side_class: 25,
+ after: true,
+ minimum: 0.0,
+ desired: 0.0,
+ maximum: 10.0,
+ priority: 1,
+ ..Default::default()
+ },
+ MojikumiAki {
+ target_class: 25,
+ side_class: 18,
+ after: true,
+ minimum: 0.0,
+ desired: 0.0,
+ maximum: 10.0,
+ priority: 2,
+ ..Default::default()
+ },
+ ],
+ });
+ let para = &mut d.story_mut(sid).unwrap().paras[0].para;
+ para.mojikumi = Some("MojikumiTable/Priority".into());
+ para.align = Some(Align::FullyJustified);
+ let result = compose_story(&d, sid, &ComposeOptions::default());
+ let line = all_lines(&result)[0];
+ assert!((line.end_x - 45.0).abs() < 0.001);
+ assert!((line.glyphs[2].x - line.glyphs[1].x - middle_gap).abs() < 0.001, "Priority 2 was used before priority 1 was exhausted");
+
+ let (mut d, sid, _) = doc_with(
+ "A",
+ Rect::new(0.0, 0.0, 30.0, 100.0),
+ ParaAttrs { mojikumi: Some("MojikumiTable/Start".into()), align: Some(Align::FullyJustified), ..Default::default() },
+ );
+ Arc::make_mut(&mut d.styles).mojikumi_tables.push(MojikumiTable {
+ name: "Start".into(),
+ based_on: "SimpChineseDefault".into(),
+ overrides: vec![MojikumiAki {
+ target_class: 18,
+ side_class: 23,
+ after: false,
+ minimum: 0.0,
+ desired: 0.0,
+ maximum: 5.0,
+ priority: 1,
+ ..Default::default()
+ }],
+ });
+ let result = compose_story(&d, sid, &ComposeOptions::default());
+ let line = all_lines(&result)[0];
+ assert!((line.end_x - 30.0).abs() < 0.001);
+ assert!(line.glyphs[0].x > 10.0, "Leading gap must move the first outline too");
+}
+
+#[test]
+fn mojikumi_equal_priority_shares_leading_and_internal_space() {
+ use designcraft_doc::cjk::{MojikumiAki, MojikumiTable};
+ let (mut d, sid, _) = doc_with("A1", Rect::new(0.0, 0.0, 40.0, 100.0), ParaAttrs::default());
+ let natural = compose_story(&d, sid, &ComposeOptions::default());
+ let old = all_lines(&natural)[0];
+ let extra = 40.0 - old.end_x;
+ let old_second = old.glyphs[1].x;
+ Arc::make_mut(&mut d.styles).mojikumi_tables.push(MojikumiTable {
+ name: "Shared".into(),
+ based_on: "SimpChineseDefault".into(),
+ overrides: [(18, 23, false), (18, 25, true)]
+ .into_iter()
+ .map(|(target_class, side_class, after)| MojikumiAki {
+ target_class,
+ side_class,
+ after,
+ maximum: 10.0,
+ priority: 1,
+ ..Default::default()
+ })
+ .collect(),
+ });
+ let para = &mut d.story_mut(sid).unwrap().paras[0].para;
+ para.mojikumi = Some("MojikumiTable/Shared".into());
+ para.align = Some(Align::FullyJustified);
+ let result = compose_story(&d, sid, &ComposeOptions::default());
+ let line = all_lines(&result)[0];
+ assert!((line.glyphs[0].x - extra / 2.0).abs() < 0.001);
+ assert!((line.glyphs[1].x - old_second - extra).abs() < 0.001);
+ assert!((line.end_x - 40.0).abs() < 0.001);
+}
+
+#[test]
+fn mojikumi_nonfloating_and_leading_only_compression_fit_ragged_lines() {
+ use designcraft_doc::cjk::{MojikumiAki, MojikumiTable};
+ for composer in [Composer::SingleLine, Composer::Paragraph] {
+ for leading in [true, false] {
+ let (mut d, sid, _) = doc_with(
+ "A",
+ Rect::new(0.0, 0.0, 15.0, 100.0),
+ ParaAttrs { composer: Some(composer), mojikumi: Some("MojikumiTable/Endpoint".into()), ..Default::default() },
+ );
+ Arc::make_mut(&mut d.styles).mojikumi_tables.push(MojikumiTable {
+ name: "Endpoint".into(),
+ based_on: "SimpChineseDefault".into(),
+ overrides: vec![MojikumiAki {
+ target_class: 18,
+ side_class: if leading { 23 } else { 22 },
+ after: !leading,
+ minimum: 0.0,
+ desired: 1.0,
+ maximum: 1.0,
+ priority: 1,
+ does_not_float: true,
+ }],
+ });
+ let result = compose_story(&d, sid, &ComposeOptions::default());
+ let line = all_lines(&result)[0];
+ assert!(line.end_x <= 15.0, "{composer:?}, leading={leading}: {}", line.end_x);
+ assert!(line.glyphs[0].x.abs() < 0.001, "Discrete leading gap must reach its endpoint");
+ }
+ }
+}
+
+// ---------- span columns ----------
+
+/// A story of `before` body paragraphs, a heading spanning all columns, and `after` body
+/// paragraphs, in a three-column frame. Returns the heading's paragraph index.
+fn span_doc(before: usize, after: usize, rect: Rect) -> (Document, StoryId, ItemId, usize) {
+ let mut paras: Vec<&str> = vec![LOREM; before];
+ paras.push("A heading across the columns");
+ paras.extend(vec![LOREM; after]);
+ let (mut d, sid, fid) = doc_with(&paras.join("\n"), rect, ParaAttrs::default());
+ d.item_mut(fid).unwrap().text_frame_mut().unwrap().options.columns = 3;
+ d.story_mut(sid).unwrap().paras[before].para.span_columns = Some(SpanColumns::Span(0));
+ (d, sid, fid, before)
+}
+
+/// The line's leading slot (glyph ascent and descent may reach into the neighbouring lines).
+fn line_box(l: &Line) -> (f64, f64) {
+ (l.baseline - 0.75 * l.leading, l.baseline + 0.25 * l.leading)
+}
+
+/// No two lines of a frame share any area.
+fn assert_no_overlap(ft: &FrameText) {
+ for (i, a) in ft.lines.iter().enumerate() {
+ for b in &ft.lines[i + 1..] {
+ let ((at, ab), (bt, bb)) = (line_box(a), line_box(b));
+ let x_overlap = a.x0 < b.x1 - 0.5 && b.x0 < a.x1 - 0.5;
+ let y_overlap = at < bb - 0.5 && bt < ab - 0.5;
+ assert!(
+ !(x_overlap && y_overlap),
+ "lines overlap: para {} col {} y {:.1}..{:.1} and para {} col {} y {:.1}..{:.1}",
+ a.para,
+ a.column,
+ at,
+ ab,
+ b.para,
+ b.column,
+ bt,
+ bb
+ );
+ }
+ }
+}
+
+#[test]
+fn mojikumi_places_custom_gap_after_combining_marks() {
+ use designcraft_doc::cjk::{MojikumiAki, MojikumiTable};
+ let (mut d, sid, _) = doc_with("A\u{0323}\u{0301}1", Rect::new(0.0, 0.0, 200.0, 100.0), ParaAttrs::default());
+ let natural = compose_story(&d, sid, &ComposeOptions::default());
+ let old = &all_lines(&natural)[0].glyphs;
+ assert!(old.len() >= 3, "Exercise a cluster with a separate combining glyph");
+ Arc::make_mut(&mut d.styles).mojikumi_tables.push(MojikumiTable {
+ name: "Clusters".into(),
+ based_on: "SimpChineseDefault".into(),
+ overrides: vec![MojikumiAki {
+ target_class: 18,
+ side_class: 25,
+ after: true,
+ minimum: 1.0,
+ desired: 1.0,
+ maximum: 1.0,
+ ..Default::default()
+ }],
+ });
+ d.story_mut(sid).unwrap().paras[0].para.mojikumi = Some("MojikumiTable/Clusters".into());
+ let result = compose_story(&d, sid, &ComposeOptions::default());
+ let new = &all_lines(&result)[0].glyphs;
+ assert_eq!(new.len(), old.len());
+ for (before, after) in old.iter().zip(new) {
+ let expected = if before.rendered_char == '1' { 12.0 } else { 0.0 };
+ assert!((after.x - before.x - expected).abs() < 0.001, "Glyph {:?} moved incorrectly", before.rendered_char);
+ }
+}
+
+#[test]
+fn mojikumi_does_not_restore_fullwidth_blanks_to_narrow_tracked_punctuation() {
+ let family = "Mojikumi Narrow Body";
+ let font = designcraft_fonts::testing::font_mapping(family, &[('(', 'i'), ('A', 'A')]).unwrap();
+ designcraft_fonts::FontDb::global().add_font(font);
+ let (mut d, sid, _) = doc_with("(A", Rect::new(0.0, 0.0, 200.0, 100.0), ParaAttrs::default());
+ d.story_mut(sid).unwrap().format_chars(0.."(A".len(), |f| {
+ f.over.font_family = Some(family.into());
+ f.over.tracking = Some(1000.0);
+ });
+ let natural = compose_story(&d, sid, &ComposeOptions::default());
+ d.story_mut(sid).unwrap().paras[0].para.mojikumi = Some("SimpChineseDefault".into());
+ let result = compose_story(&d, sid, &ComposeOptions::default());
+ for (a, b) in all_lines(&natural)[0].glyphs.iter().zip(&all_lines(&result)[0].glyphs) {
+ assert!((a.x - b.x).abs() < 0.001);
+ assert!((a.adv - b.adv).abs() < 0.001);
+ }
+}
+
+fn ruled(text: &str, rect: Rect, columns: u32, edit: impl FnOnce(&mut Document, StoryId)) -> (Document, ItemId, Vec<Rect>) {
+ let (mut d, sid, fid) = doc_with(text, rect, ParaAttrs::default());
+ {
+ let o = &mut d.item_mut(fid).unwrap().text_frame_mut().unwrap().options;
+ o.columns = columns;
+ o.gutter = 12.0;
+ o.inset = [10.0, 6.0, 20.0, 6.0];
+ o.column_rule = true;
+ o.column_rule_weight = 2.0;
+ o.column_rule_color = "[Black]".into();
+ }
+ edit(&mut d, sid);
+ let cs = compose_story(&d, sid, &ComposeOptions::default());
+ let rules = cs.frames[0].decos.iter().filter(|dc| dc.color == "[Black]").map(|dc| dc.rect).collect();
+ (d, fid, rules)
+}
+
+#[test]
+fn column_rules_sit_in_the_gutters_inside_the_insets() {
+ // Two columns in 0..300 with 6 pt side insets: the gutter is centred on 150.
+ let (_, _, rules) = ruled("Text", Rect::new(0.0, 0.0, 300.0, 200.0), 2, |_, _| {});
+ assert_eq!(rules.len(), 1, "{rules:?}");
+ let r = rules[0];
+ assert!((r.center().x - 150.0).abs() < 1e-9 && (r.width() - 2.0).abs() < 1e-9, "{r:?}");
+ assert!((r.y0 - 10.0).abs() < 1e-9 && (r.y1 - 180.0).abs() < 1e-9, "{r:?}");
+ // Three columns: one rule per gutter, each centred between its two columns.
+ let (_, _, rules) = ruled("Text", Rect::new(0.0, 0.0, 300.0, 200.0), 3, |_, _| {});
+ assert_eq!(rules.len(), 2, "{rules:?}");
+ let w = (288.0 - 24.0) / 3.0;
+ for (i, r) in rules.iter().enumerate() {
+ let edge = 6.0 + w * (i + 1) as f64 + 12.0 * i as f64;
+ assert!((r.center().x - (edge + 6.0)).abs() < 1e-9, "{i}: {r:?}");
+ }
+ // Off, or a single column: no rule.
+ let (_, _, rules) = ruled("Text", Rect::new(0.0, 0.0, 300.0, 200.0), 1, |_, _| {});
+ assert!(rules.is_empty());
+ let (_, _, rules) = ruled("Text", Rect::new(0.0, 0.0, 300.0, 200.0), 2, |d, sid| {
+ let fid = d.story(sid).unwrap().frames[0];
+ d.item_mut(fid).unwrap().text_frame_mut().unwrap().options.column_rule = false;
+ });
+ assert!(rules.is_empty());
+}
+
+#[test]
+fn column_rules_centre_on_unequal_gutters_and_ignore_bad_weights() {
+ let cols = [Rect::new(200.0, 0.0, 300.0, 50.0), Rect::new(0.0, 0.0, 100.0, 50.0), Rect::new(110.0, 0.0, 180.0, 50.0)];
+ let weight = |w: f64| TextFrameOptions { column_rule_weight: w, ..Default::default() };
+ let rules = column_rule_rects(&cols, &[], &weight(1.0));
+ let centres: Vec<f64> = rules.iter().map(|r| r.center().x).collect();
+ assert_eq!(centres, [105.0, 190.0]);
+ assert!(column_rule_rects(&cols, &[], &weight(f64::NAN)).is_empty());
+ assert!(column_rule_rects(&cols, &[], &weight(-1.0)).is_empty());
+ assert!((column_rule_rects(&cols, &[], &weight(1e12))[0].width() - 1000.0).abs() < 1e-9);
+}
+
+#[test]
+fn column_rules_in_right_to_left_and_vertical_frames() {
+ let (_, _, rules) = ruled("نص", Rect::new(0.0, 0.0, 300.0, 200.0), 2, |d, sid| {
+ d.story_mut(sid).unwrap().direction = designcraft_doc::TextDirection::RightToLeft;
+ });
+ assert_eq!(rules.len(), 1);
+ assert!((rules[0].center().x - 150.0).abs() < 1e-9, "{rules:?}");
+ // Vertical type: the columns stack top to bottom, so the rule runs across the frame.
+ let (d, fid, rules) = ruled("縦書き", Rect::new(100.0, 100.0, 400.0, 300.0), 2, |d, sid| d.story_mut(sid).unwrap().vertical = true);
+ assert_eq!(rules.len(), 1);
+ let r = d.text_xf(d.item(fid).unwrap()).transform_rect_bbox(rules[0]);
+ // Text area: x 106..394, y 110..280; the gutter is centred on y 195.
+ assert!((r.x0 - 106.0).abs() < 1e-6 && (r.x1 - 394.0).abs() < 1e-6, "{r:?}");
+ assert!((r.center().y - 195.0).abs() < 1e-6 && (r.height() - 2.0).abs() < 1e-6, "{r:?}");
+}
+
+#[test]
+fn column_rules_break_around_paragraphs_that_span_columns() {
+ let text = format!("A heading that spans both columns\n{LOREM} {LOREM}");
+ let (d, fid, rules) = ruled(&text, Rect::new(0.0, 0.0, 300.0, 400.0), 2, |d, sid| {
+ d.story_mut(sid).unwrap().paras[0].para.span_columns = Some(designcraft_doc::SpanColumns::Span(0));
+ });
+ let sid = d.item(fid).unwrap().text_frame().unwrap().story;
+ let cs = compose_story(&d, sid, &ComposeOptions::default());
+ let span: Vec<&Line> = cs.frames[0].lines.iter().filter(|l| l.para == 0).collect();
+ assert!(!span.is_empty() && span.iter().all(|l| l.x0 < 150.0 && l.x1 > 150.0), "the heading spans");
+ let (top, bottom) = (span[0].baseline - span[0].ascent, span[span.len() - 1].baseline + span[span.len() - 1].descent);
+ assert!(!rules.is_empty());
+ for r in &rules {
+ assert!(r.y1 <= top + 1e-9 || r.y0 >= bottom - 1e-9, "rule {r:?} cuts the span {top}..{bottom}");
+ }
+ // The rule resumes below the span and runs to the bottom of the columns.
+ assert!(rules.iter().any(|r| (r.y0 - bottom).abs() < 1e-9 && (r.y1 - 380.0).abs() < 1e-9), "{rules:?}");
+}
+
+#[test]
+fn column_rules_take_their_offset_insets_and_tint() {
+ let (d, fid, rules) = ruled("Text", Rect::new(0.0, 0.0, 300.0, 200.0), 2, |d, sid| {
+ let fid = d.story(sid).unwrap().frames[0];
+ let o = &mut d.item_mut(fid).unwrap().text_frame_mut().unwrap().options;
+ o.column_rule_offset = 3.0;
+ o.column_rule_top_inset = 15.0;
+ o.column_rule_bottom_inset = 25.0;
+ o.column_rule_tint = 0.4;
+ });
+ // Gutter centre 150 moved 3 pt; columns 10..180 shortened to 25..155.
+ assert_eq!(rules.len(), 1, "{rules:?}");
+ let r = rules[0];
+ assert!((r.center().x - 153.0).abs() < 1e-9 && (r.y0 - 25.0).abs() < 1e-9 && (r.y1 - 155.0).abs() < 1e-9, "{r:?}");
+ let sid = d.item(fid).unwrap().text_frame().unwrap().story;
+ let cs = compose_story(&d, sid, &ComposeOptions::default());
+ assert!(cs.frames[0].decos.iter().any(|dc| dc.rect == r && (dc.tint - 0.4).abs() < 1e-6));
+ // Insets that meet leave no rule.
+ let (_, _, rules) = ruled("Text", Rect::new(0.0, 0.0, 300.0, 200.0), 2, |d, sid| {
+ let fid = d.story(sid).unwrap().frames[0];
+ let o = &mut d.item_mut(fid).unwrap().text_frame_mut().unwrap().options;
+ o.column_rule_top_inset = 100.0;
+ o.column_rule_bottom_inset = 100.0;
+ });
+ assert!(rules.is_empty(), "{rules:?}");
+}
+
+/// The heading spans the frame; text before it sits above it and text after it below it.
+fn assert_span_layout(ft: &FrameText, h: usize) {
+ let heading: Vec<&Line> = ft.lines.iter().filter(|l| l.para == h).collect();
+ assert!(!heading.is_empty());
+ let (c0, cn) = (ft.columns[0], ft.columns[ft.columns.len() - 1]);
+ for l in &heading {
+ assert!((l.x0 - c0.x0.min(cn.x0)).abs() < 1e-6 && (l.x1 - c0.x1.max(cn.x1)).abs() < 1e-6, "heading spans {}..{}", l.x0, l.x1);
+ }
+ let top = heading.iter().map(|l| line_box(l).0).fold(f64::INFINITY, f64::min);
+ let bottom = heading.iter().map(|l| line_box(l).1).fold(f64::NEG_INFINITY, f64::max);
+ for l in ft.lines.iter().filter(|l| l.para < h) {
+ assert!(line_box(l).1 <= top + 0.5, "para {} col {} ends at {} below the heading top {top}", l.para, l.column, line_box(l).1);
+ }
+ for l in ft.lines.iter().filter(|l| l.para > h) {
+ assert!(line_box(l).0 >= bottom - 0.5, "para {} col {} starts at {} above the heading bottom {bottom}", l.para, l.column, line_box(l).0);
+ }
+ assert_no_overlap(ft);
+}
+
+#[test]
+fn text_after_a_spanning_paragraph_flows_below_it() {
+ let (d, sid, _, h) = span_doc(2, 3, Rect::new(0.0, 0.0, 540.0, 300.0));
+ let cs = compose_story(&d, sid, &ComposeOptions::default());
+ assert!(!cs.is_overset());
+ let ft = &cs.frames[0];
+ assert_span_layout(ft, h);
+ // The text before is balanced across the three columns above the heading.
+ let before: Vec<&Line> = ft.lines.iter().filter(|l| l.para < h).collect();
+ let per_col = |c: u32| before.iter().filter(|l| l.column == c).count();
+ let counts = [per_col(0), per_col(1), per_col(2)];
+ assert!(counts.iter().all(|&n| n > 0), "{counts:?}");
+ assert!(counts.iter().max().unwrap() - counts.iter().min().unwrap() <= 1, "{counts:?}");
+ // The text after starts right below the heading in every column, on the same baseline.
+ let bottom = ft.lines.iter().filter(|l| l.para == h).map(|l| l.baseline).fold(f64::NEG_INFINITY, f64::max);
+ let firsts: Vec<f64> = (0..3).map(|c| ft.lines.iter().find(|l| l.para > h && l.column == c).map(|l| l.baseline).unwrap()).collect();
+ for b in &firsts {
+ assert!(*b > bottom && *b < bottom + 40.0, "{firsts:?} after {bottom}");
+ }
+ assert!((firsts[1] - firsts[2]).abs() < 1e-6, "{firsts:?}");
+}
+
+#[test]
+fn spanning_heading_kept_with_next_and_spanning_two_of_three_columns() {
+ let (mut d, sid, _, h) = span_doc(2, 3, Rect::new(0.0, 0.0, 540.0, 300.0));
+ d.story_mut(sid).unwrap().paras[h].para.keep_with_next = Some(2);
+ let cs = compose_story(&d, sid, &ComposeOptions::default());
+ assert!(!cs.is_overset());
+ assert_span_layout(&cs.frames[0], h);
+ // Spanning two of three columns: the third column beside the heading stays empty.
+ d.story_mut(sid).unwrap().paras[h].para.span_columns = Some(SpanColumns::Span(2));
+ let cs = compose_story(&d, sid, &ComposeOptions::default());
+ let ft = &cs.frames[0];
+ let heading = ft.lines.iter().find(|l| l.para == h).unwrap();
+ assert!((heading.x0 - ft.columns[0].x0).abs() < 1e-6 && (heading.x1 - ft.columns[1].x1).abs() < 1e-6);
+ assert_no_overlap(ft);
+ let bottom = heading.baseline + 0.25 * heading.leading;
+ assert!(ft.lines.iter().filter(|l| l.para > h).all(|l| line_box(l).0 >= bottom - 0.5));
+ assert!((0..3).all(|c| ft.lines.iter().any(|l| l.para > h && l.column == c)));
+}
+
+#[test]
+fn spanning_paragraph_at_the_top_and_end_of_a_frame() {
+ let (d, sid, _, h) = span_doc(0, 4, Rect::new(0.0, 0.0, 540.0, 300.0));
+ let cs = compose_story(&d, sid, &ComposeOptions::default());
+ assert!(!cs.is_overset());
+ let ft = &cs.frames[0];
+ assert_span_layout(ft, h);
+ assert!(ft.lines[0].para == h && ft.lines[0].baseline < 20.0);
+ assert!((1..3).all(|c| ft.lines.iter().any(|l| l.column == c)));
+
+ let (d, sid, _, h) = span_doc(3, 0, Rect::new(0.0, 0.0, 540.0, 300.0));
+ let cs = compose_story(&d, sid, &ComposeOptions::default());
+ assert!(!cs.is_overset());
+ assert_span_layout(&cs.frames[0], h);
+}
+
+#[test]
+fn text_after_a_spanning_paragraph_threads_into_the_next_frame() {
+ let (mut d, sid, f1, h) = span_doc(2, 8, Rect::new(0.0, 0.0, 540.0, 200.0));
+ let lid = d.default_layer();
+ let (f2, _) = d.add_text_frame(SpreadRef::Doc(0), Rect::new(0.0, 300.0, 540.0, 700.0), lid, "", ParaFormat::default()).unwrap();
+ d.item_mut(f2).unwrap().text_frame_mut().unwrap().options.columns = 3;
+ d.thread(f1, f2).unwrap();
+ let cs = compose_story(&d, sid, &ComposeOptions::default());
+ assert!(!cs.is_overset(), "overset at {:?}", cs.overset_at);
+ assert_span_layout(&cs.frames[0], h);
+ let (a, b) = (&cs.frames[0], &cs.frames[1]);
+ assert!((0..3).all(|c| a.lines.iter().any(|l| l.para > h && l.column == c)));
+ assert!(!b.lines.is_empty() && b.lines[0].para > h && b.lines[0].baseline < 320.0);
+ assert_no_overlap(b);
+ // Every line of the story is set once, in order.
+ let lines = all_lines(&cs);
+ for w in lines.windows(2) {
+ assert!(w[1].range.start >= w[0].range.end, "{:?} then {:?}", w[0].range, w[1].range);
+ }
+ assert_eq!(lines.last().unwrap().range.end, d.story(sid).unwrap().text.len());
+}
+
+#[test]
+fn spanning_paragraph_in_rtl_and_vertical_frames() {
+ let (mut d, sid, _, h) = span_doc(2, 4, Rect::new(0.0, 0.0, 540.0, 500.0));
+ d.story_mut(sid).unwrap().direction = designcraft_doc::TextDirection::RightToLeft;
+ let cs = compose_story(&d, sid, &ComposeOptions::default());
+ assert!(!cs.is_overset());
+ assert_span_layout(&cs.frames[0], h);
+
+ let (mut d, sid, _, h) = span_doc(2, 4, Rect::new(0.0, 0.0, 540.0, 540.0));
+ d.story_mut(sid).unwrap().vertical = true;
+ let cs = compose_story(&d, sid, &ComposeOptions::default());
+ assert!(!cs.frames[0].lines.is_empty());
+ assert_no_overlap(&cs.frames[0]);
+ assert!(cs.frames[0].lines.iter().any(|l| l.para == h));
+}
+
+/// A heading spanning the columns mid-frame: text above it is balanced over the columns, text
+/// after it flows below it, and each gutter's rule stops above the heading and resumes below it.
+#[test]
+fn column_rules_break_around_a_spanning_paragraph_between_bands() {
+ let (mut d, sid, fid, h) = span_doc(2, 4, Rect::new(0.0, 0.0, 450.0, 700.0));
+ {
+ let o = &mut d.item_mut(fid).unwrap().text_frame_mut().unwrap().options;
+ o.column_rule = true;
+ o.column_rule_weight = 1.0;
+ o.column_rule_color = "[Black]".into();
+ }
+ let cs = compose_story(&d, sid, &ComposeOptions::default());
+ let ft = &cs.frames[0];
+ assert_no_overlap(ft);
+ let span: Vec<&Line> = ft.lines.iter().filter(|l| l.para == h).collect();
+ assert!(!span.is_empty());
+ let top = span.iter().map(|l| l.baseline - l.ascent).fold(f64::INFINITY, f64::min);
+ let bottom = span.iter().map(|l| l.baseline + l.descent).fold(f64::NEG_INFINITY, f64::max);
+ assert!(ft.lines.iter().any(|l| l.para < h), "text above the heading");
+ assert!(ft.lines.iter().any(|l| l.para > h && l.column > 0 && l.baseline > bottom), "text after the heading flows below it");
+ let rules: Vec<Rect> = ft.decos.iter().filter(|dc| dc.color == "[Black]").map(|dc| dc.rect).collect();
+ let mut gutters: Vec<f64> = rules.iter().map(|r| r.center().x).collect();
+ gutters.sort_by(f64::total_cmp);
+ gutters.dedup_by(|a, b| (*a - *b).abs() < 1e-6);
+ assert_eq!(gutters.len(), 2, "{rules:?}");
+ for x in gutters {
+ let here: Vec<&Rect> = rules.iter().filter(|r| (r.center().x - x).abs() < 1e-6).collect();
+ assert!(here.iter().all(|r| r.y1 <= top + 1e-9 || r.y0 >= bottom - 1e-9), "a rule cuts the heading {top}..{bottom}: {here:?}");
+ assert!(here.iter().any(|r| r.y1 <= top + 1e-9), "rule above the heading at {x}: {here:?}");
+ assert!(here.iter().any(|r| (r.y0 - bottom).abs() < 1e-9), "rule resumes below the heading at {x}: {here:?}");
+ }
+}
+
+#[test]
+fn justified_line_with_a_tab_justifies_the_text_after_its_last_tab() {
+ // InDesign justifies only the text after a line's last (left) tab; tab stops stay aligned.
+ let stop = |align| designcraft_doc::TabStop { position: 100.0, align, leader: String::new(), align_on: String::new() };
+ let text = "Name\t42 and some words\u{2028}more";
+ let x_of = |l: &Line, byte: usize| l.glyphs.iter().find(|g| g.byte == byte && g.len > 0).map(|g| g.x).unwrap();
+ let left = ParaAttrs { align: Some(Align::LeftJustified), tabs: Some(vec![stop(TabAlign::Left)]), ..Default::default() };
+ let (d, sid, _) = doc_with(text, Rect::new(0.0, 0.0, 300.0, 100.0), left.clone());
+ let cs = compose_story(&d, sid, &ComposeOptions::default());
+ let l = all_lines(&cs)[0];
+ assert!((l.end_x - l.x1).abs() < 0.6, "line with a left tab ends at {} not {}", l.end_x, l.x1);
+ assert!((x_of(l, 5) - 100.0).abs() < 0.5, "text after the tab starts at the stop: {}", x_of(l, 5));
+ let (d, sid, _) = doc_with(text, Rect::new(0.0, 0.0, 300.0, 100.0), ParaAttrs { align: Some(Align::Left), ..left });
+ let ragged = compose_story(&d, sid, &ComposeOptions::default());
+ let r = all_lines(&ragged)[0];
+ for byte in 0..4 {
+ assert!((x_of(l, byte) - x_of(r, byte)).abs() < 1e-6, "text before the tab keeps its natural position");
+ }
+
+ // After a right tab the line stays as set.
+ let right = ParaAttrs { align: Some(Align::LeftJustified), tabs: Some(vec![stop(TabAlign::Right)]), ..Default::default() };
+ let (d, sid, _) = doc_with("Name\t42\u{2028}more", Rect::new(0.0, 0.0, 300.0, 100.0), right);
+ let cs = compose_story(&d, sid, &ComposeOptions::default());
+ let l = all_lines(&cs)[0];
+ assert!((l.end_x - 100.0).abs() < 0.5, "right-tab line ends at its stop: {}", l.end_x);
+
+ // A footnote's number and tab separator: its first line is justified like the others.
+ let (mut d, sid, fid) = doc_with("Body text.", Rect::new(0.0, 0.0, 200.0, 400.0), ParaAttrs::default());
+ let note = ParaFormat { para: ParaAttrs { align: Some(Align::LeftJustified), ..Default::default() }, ..Default::default() };
+ d.story_mut(sid).unwrap().insert_note(4, LOREM, note);
+ let cs = compose_story(&d, sid, &ComposeOptions::default());
+ let n = &cs.frame(fid).unwrap().notes[0];
+ let lines = all_lines(&n.text);
+ assert!(lines.len() > 2);
+ for l in &lines[..lines.len() - 1] {
+ assert!((l.end_x - l.x1).abs() < 0.6, "footnote line ends at {} not {}", l.end_x, l.x1);
+ }
+ assert!((x_of(lines[0], 0) - 36.0).abs() < 0.5, "note text starts at the default tab stop: {}", x_of(lines[0], 0));
+}
+
+#[test]
+fn mojikumi_justification_after_a_tab_keeps_the_text_before_it() {
+ // Justification (mojikumi included) adjusts only the text after a line's last tab.
+ use designcraft_doc::cjk::{MojikumiAki, MojikumiTable};
+ let stop = designcraft_doc::TabStop { position: 100.0, align: TabAlign::Left, leader: String::new(), align_on: String::new() };
+ let compose = |align| {
+ let para =
+ ParaAttrs { align: Some(align), mojikumi: Some("MojikumiTable/Elastic".into()), tabs: Some(vec![stop.clone()]), ..Default::default() };
+ let (mut d, sid, _) = doc_with("A1A1\tA1A1", Rect::new(0.0, 0.0, 300.0, 100.0), para);
+ Arc::make_mut(&mut d.styles).mojikumi_tables.push(MojikumiTable {
+ name: "Elastic".into(),
+ based_on: "SimpChineseDefault".into(),
+ overrides: vec![MojikumiAki {
+ target_class: 18,
+ side_class: 25,
+ after: true,
+ minimum: 0.0,
+ desired: 0.0,
+ maximum: 5.0,
+ priority: 1,
+ ..Default::default()
+ }],
+ });
+ compose_story(&d, sid, &ComposeOptions::default())
+ };
+ let justified = compose(Align::FullyJustified);
+ let ragged = compose(Align::Left);
+ let (l, r) = (all_lines(&justified)[0], all_lines(&ragged)[0]);
+ assert!(l.end_x > r.end_x + 1.0, "the text after the tab stretches: {} vs {}", l.end_x, r.end_x);
+ let x_of = |l: &Line, byte: usize| l.glyphs.iter().find(|g| g.byte == byte && g.len > 0).map(|g| g.x).unwrap();
+ for byte in 0..5 {
+ assert!((x_of(l, byte) - x_of(r, byte)).abs() < 1e-6, "byte {byte} before the tab moved: {} vs {}", x_of(l, byte), x_of(r, byte));
+ }
+}
+
+#[test]
+fn list_first_line_wraps_at_the_column_edge_after_its_label() {
+ use designcraft_doc::{ListType, TabStop};
+ // A hanging indent (left 18, first line −18): the label sits at the column start, a tab
+ // after it reaches the left indent (an implicit stop when no explicit stop comes first), and
+ // the first line wraps at the same right edge as the others.
+ let right_edge = |l: &Line, source: &str| {
+ let space = |g: &&PlacedGlyph| g.len > 0 && source.get(g.byte..).and_then(|s| s.chars().next()).is_some_and(char::is_whitespace);
+ l.glyphs.iter().filter(|g| g.visible && !space(g)).map(|g| g.x + g.adv).fold(0.0, f64::max)
+ };
+ let text_start = |l: &Line| l.glyphs.iter().find(|g| g.len > 0 && g.visible).map_or(f64::NAN, |g| g.x);
+ let stop = |position: f64| TabStop { position, align: TabAlign::Left, leader: String::new(), align_on: String::new() };
+ let text = format!("{LOREM}\n{LOREM}");
+ // (list, separator, explicit tab stops, where line 0's text starts past the column start:
+ // None = right after the label, wherever that is).
+ let cases = [
+ (ListType::Bullets, "\t", None, Some(18.0)),
+ (ListType::Numbers, "\t", None, Some(18.0)),
+ (ListType::Numbers, "\t", Some(vec![stop(12.0)]), Some(12.0)),
+ (ListType::Numbers, "\t", Some(vec![stop(30.0)]), Some(18.0)),
+ (ListType::Bullets, " ", None, None),
+ (ListType::Numbers, "\u{2003}", None, None),
+ ];
+ // Justified too: only the text after the tab stretches (#284).
+ for (align, (list, sep, tabs, first_at)) in [Align::Left, Align::LeftJustified].into_iter().flat_map(|a| cases.clone().map(|c| (a, c))) {
+ let para = ParaAttrs {
+ align: Some(align),
+ list_type: Some(list),
+ list_separator: Some(sep.into()),
+ left_indent: Some(18.0),
+ first_line_indent: Some(-18.0),
+ tabs: tabs.clone(),
+ ..Default::default()
+ };
+ let (d, sid, _) = doc_with(&text, Rect::new(36.0, 36.0, 300.0, 400.0), para);
+ let cs = compose_story(&d, sid, &ComposeOptions::default());
+ let col = cs.frames[0].columns[0];
+ let lines = &cs.frames[0].lines;
+ let what = format!("{align:?} {list:?} {sep:?} {tabs:?}");
+ assert!(lines.len() >= 6, "{what}: {} lines", lines.len());
+ for (i, l) in lines.iter().enumerate() {
+ let right = right_edge(l, &text);
+ assert!(right <= col.x1 + 0.01, "{what}: line {i} ends at {right}, past the column's {}", col.x1);
+ let start = text_start(l) - col.x0;
+ if !l.first_in_para {
+ assert!((start - 18.0).abs() < 0.01, "{what}: line {i} text starts at {start}, not the left indent");
+ } else if let Some(at) = first_at {
+ assert!((start - at).abs() < 0.01, "{what}: line {i} text starts at {start}, not {at}");
+ } else {
+ assert!(start > 0.0, "{what}: line {i} text starts at {start}");
+ }
+ if l.first_in_para {
+ assert!(l.glyphs.first().is_some_and(|g| g.len == 0 && (g.x - col.x0).abs() < 0.01), "{what}: the label leads line {i}");
+ }
+ }
+ }
+}
++
+ /// Lines of `text` set in a frame `width` wide, with `tracking` on every character.
+ fn tracked_lines(text: &str, width: f64, para: ParaAttrs, tracking: f64) -> Vec<Line> {
+ let (mut d, sid, _) = doc_with(text, Rect::new(0.0, 0.0, width, 4000.0), para);
+ d.story_mut(sid).unwrap().format_chars(0..text.len(), |f| f.over.tracking = Some(tracking));
+ let cs = compose_story(&d, sid, &ComposeOptions::default());
+ assert!(!cs.is_overset(), "overset at width {width}");
+ all_lines(&cs).into_iter().cloned().collect()
+ }
+
+ #[test]
+ fn a_word_longer_than_the_line_breaks_at_the_column_edge() {
+ use designcraft_doc::Composer;
+ let word = "n".repeat(60);
+ let long = format!("Then {word} and on");
+ for tracking in [0.0, 740.0] {
+ // Natural advances, from one unbroken line.
+ let natural: HashMap<usize, f64> =
+ tracked_lines(&long, 1e5, ParaAttrs::default(), tracking)[0].glyphs.iter().map(|g| (g.byte, g.adv)).collect();
+ for composer in [Composer::Paragraph, Composer::SingleLine] {
+ for align in [Align::Left, Align::LeftJustified] {
+ let para = ParaAttrs { composer: Some(composer), align: Some(align), hyphenate: Some(false), ..Default::default() };
+ let lines = tracked_lines(&long, 72.0, para, tracking);
+ let what = format!("{composer:?} {align:?} tracking {tracking}");
+ assert!(lines.len() >= 4, "{what}: {} lines", lines.len());
+ for l in &lines {
+ let ink: Vec<_> = l.glyphs.iter().filter(|g| g.visible && g.adv > 0.0).collect();
+ let right = ink.iter().map(|g| g.x + g.adv.min(natural[&g.byte])).fold(l.x0, f64::max);
+ assert!(l.end_x <= l.x1 + 0.02 && right <= l.x1 + 0.02, "{what}: line {:?} ends at {} past {}", l.range, l.end_x, l.x1);
+ for w in ink.windows(2) {
+ assert!(w[1].x >= w[0].x + natural[&w[0].byte] - 1e-6, "{what}: glyphs overlap at {}", w[1].byte);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ #[test]
+ fn a_line_that_exactly_fills_the_measure_fits() {
+ use designcraft_doc::Composer;
+ let text = "#knowyourplastic";
+ let one = &tracked_lines(text, 1e5, ParaAttrs::default(), 0.0)[0];
+ // The measure a rounding error short of the natural width.
+ let width = one.end_x - one.x0 - 0.005;
+ for composer in [Composer::Paragraph, Composer::SingleLine] {
+ for align in [Align::Left, Align::LeftJustified] {
+ let para = ParaAttrs { composer: Some(composer), align: Some(align), ..Default::default() };
+ let lines = tracked_lines(text, width, para, 0.0);
+ assert_eq!(lines.len(), 1, "{composer:?} {align:?}: {:?}", lines.iter().map(|l| l.range.clone()).collect::<Vec<_>>());
+ }
+ }
+ }