mirror of
https://github.com/storytold/deckcraft.git
synced 2026-10-24 18:46:57 -06:00
1843 lines
84 KiB
Rust
1843 lines
84 KiB
Rust
use super::*;
|
||
use deckcraft_model::Fill;
|
||
use deckcraft_model::defaults;
|
||
use deckcraft_model::text::{Paragraph, Run};
|
||
use deckcraft_model::{LayoutType, Presentation, Xfrm};
|
||
|
||
fn setup(text: &str, w: f64, h: f64) -> (Presentation, Shape) {
|
||
let mut p = Presentation::default();
|
||
let lay = defaults::layout_of_kind(&p, LayoutType::TitleAndContent).unwrap();
|
||
let mut s = defaults::new_slide(&mut p, lay).expect("slide");
|
||
let mut body = s.shapes.remove(1);
|
||
body.xfrm = Some(Xfrm::new(0.0, 0.0, w, h));
|
||
body.text = Some(TextBody::from_text(text));
|
||
s.shapes = vec![body.clone()];
|
||
p.slides = vec![std::sync::Arc::new(s)];
|
||
(p, body)
|
||
}
|
||
|
||
fn lay(p: &Presentation, sh: &Shape, w: f64, h: f64) -> TextLayout {
|
||
let ctx = Ctx::for_slide(p, &p.slides[0]).unwrap();
|
||
layout(&ctx, sh, sh.text.as_ref().unwrap(), &Opts { rect: Rect::new(0.0, 0.0, w, h), fields: &NoFields, prompt_color: None, no_shrink: false })
|
||
}
|
||
|
||
#[test]
|
||
fn wraps_long_text_into_lines() {
|
||
let text = "The quick brown fox jumps over the lazy dog and keeps on running far away";
|
||
let (p, sh) = setup(text, 200.0, 400.0);
|
||
let l = lay(&p, &sh, 200.0, 400.0);
|
||
assert!(l.lines.len() >= 3, "{} lines", l.lines.len());
|
||
for li in &l.lines {
|
||
assert!(li.caret_x.last().unwrap() <= &(200.0 + 0.5), "line too wide: {:?}", li.caret_x.last());
|
||
assert_eq!(li.caret_x.len(), li.end - li.start + 1);
|
||
}
|
||
// Lines cover the text without gaps (spaces at wraps are skipped).
|
||
assert_eq!(l.lines[0].start, 0);
|
||
assert!(!l.runs.is_empty());
|
||
}
|
||
|
||
#[test]
|
||
fn bullets_are_drawn_for_body_text() {
|
||
let (p, sh) = setup("One\nTwo", 600.0, 300.0);
|
||
let l = lay(&p, &sh, 600.0, 300.0);
|
||
// Two text runs + two bullet runs.
|
||
assert!(l.runs.len() >= 4, "{:?}", l.runs);
|
||
assert_eq!(l.para_lines.len(), 2);
|
||
}
|
||
|
||
/// Glyph count and width of `text` laid out in one line of `family` at 40 pt, kern threshold `kern`.
|
||
fn glyphs_and_width(family: &str, text: &str, kern: Option<f64>) -> (usize, f64) {
|
||
let (p, mut sh) = setup(text, 2000.0, 300.0);
|
||
let para = &mut sh.text.as_mut().unwrap().paragraphs[0];
|
||
para.props.bullet = Some(Bullet::None);
|
||
for r in &mut para.runs {
|
||
r.props.font = Some(family.into());
|
||
r.props.size = Some(40.0);
|
||
r.props.kern = kern;
|
||
}
|
||
let l = lay(&p, &sh, 2000.0, 300.0);
|
||
let n = l.runs.iter().map(|r| r.glyphs.len()).sum();
|
||
(n, l.lines[0].extent.1 - l.lines[0].extent.0)
|
||
}
|
||
|
||
/// The first installed or bundled family of `families` for which `pick` holds.
|
||
fn first_family(families: &[&str], pick: impl Fn(&FontFace) -> bool) -> Option<String> {
|
||
let db = FontDb::global();
|
||
families.iter().filter(|f| db.has_family(f)).map(|f| db.face(f, "Regular")).find(|f| pick(f)).map(|f| f.family.clone())
|
||
}
|
||
|
||
const LATIN_FAMILIES: &[&str] = &["Carlito", "Calibri", "DejaVu Sans", "Liberation Sans", "Inter", "Arial", "Cambria", "Times New Roman"];
|
||
|
||
#[test]
|
||
fn latin_text_draws_no_ligatures() {
|
||
// PowerPoint keeps "fi", "ffi" and Calibri's "ti" apart, although the fonts have them as
|
||
// standard ligatures.
|
||
let ligates = |f: &FontFace| deckcraft_fonts::shape(f, "office", &[], |c| c).len() < 6;
|
||
let Some(family) = first_family(LATIN_FAMILIES, ligates) else {
|
||
eprintln!("skipped: no font with an ffi ligature");
|
||
return;
|
||
};
|
||
let (n, _) = glyphs_and_width(&family, "office fifth", Some(0.0));
|
||
assert_eq!(n, 12, "{family}: one glyph per character");
|
||
}
|
||
|
||
#[test]
|
||
fn pairs_are_kerned_only_from_the_kern_size() {
|
||
let kerns = |f: &FontFace| {
|
||
let w = |feat: &[deckcraft_fonts::Feature]| deckcraft_fonts::shape(f, "AVATAR", feat, |c| c).iter().map(|g| g.x_advance).sum::<i32>();
|
||
w(&[]) != w(&deckcraft_fonts::feature("-kern").into_iter().collect::<Vec<_>>())
|
||
};
|
||
let Some(family) = first_family(LATIN_FAMILIES, kerns) else {
|
||
eprintln!("skipped: no font that kerns AVATAR");
|
||
return;
|
||
};
|
||
// `kern` is the smallest size kerned; 0 is no kerning.
|
||
let (_, off) = glyphs_and_width(&family, "AVATAR WAVE", Some(0.0));
|
||
let (_, on) = glyphs_and_width(&family, "AVATAR WAVE", Some(12.0));
|
||
let (_, at) = glyphs_and_width(&family, "AVATAR WAVE", Some(40.0));
|
||
let (_, above) = glyphs_and_width(&family, "AVATAR WAVE", Some(48.0));
|
||
assert!(on < off - 2.0, "{family}: kerned {on} vs {off}");
|
||
assert!((at - on).abs() < 0.01, "kerned at exactly the threshold size");
|
||
assert!((above - off).abs() < 0.01, "40 pt is below a 48 pt threshold");
|
||
}
|
||
|
||
/// Width of the first paragraph "AVATAR WAVE" (kerned from 12 pt) when a second paragraph's run
|
||
/// has character spacing `spc`.
|
||
fn kerned_width_beside_spacing(family: &str, spc: f64) -> f64 {
|
||
let (p, mut sh) = setup("AVATAR WAVE", 2000.0, 300.0);
|
||
let t = sh.text.as_mut().unwrap();
|
||
let mut second = t.paragraphs[0].clone();
|
||
second.runs[0].props.spacing = Some(spc);
|
||
t.paragraphs.push(second);
|
||
for para in &mut t.paragraphs {
|
||
para.props.bullet = Some(Bullet::None);
|
||
for r in &mut para.runs {
|
||
r.props.font = Some(family.into());
|
||
r.props.size = Some(40.0);
|
||
r.props.kern = Some(12.0);
|
||
}
|
||
}
|
||
let l = lay(&p, &sh, 2000.0, 300.0);
|
||
l.lines[0].extent.1 - l.lines[0].extent.0
|
||
}
|
||
|
||
#[test]
|
||
fn character_spacing_in_the_body_keeps_kerning() {
|
||
let kerns = |f: &FontFace| {
|
||
let w = |feat: &[deckcraft_fonts::Feature]| deckcraft_fonts::shape(f, "AVATAR", feat, |c| c).iter().map(|g| g.x_advance).sum::<i32>();
|
||
w(&[]) != w(&deckcraft_fonts::feature("-kern").into_iter().collect::<Vec<_>>())
|
||
};
|
||
let Some(family) = first_family(LATIN_FAMILIES, kerns) else {
|
||
eprintln!("skipped: no font that kerns AVATAR");
|
||
return;
|
||
};
|
||
let (_, off) = glyphs_and_width(&family, "AVATAR WAVE", Some(0.0));
|
||
let (_, on) = glyphs_and_width(&family, "AVATAR WAVE", Some(12.0));
|
||
assert!(on < off);
|
||
// Spacing elsewhere in the box leaves the pairs kerned (Calibri, Segoe UI, Times New Roman in
|
||
// PowerPoint; only Arial drops them).
|
||
for spc in [0.0, 0.5, -1.0, 0.6, 2.0] {
|
||
let w = kerned_width_beside_spacing(&family, spc);
|
||
assert!((w - on).abs() < 0.01, "{family} spc {spc}: {w} vs {on}");
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn ligatures_stay_for_scripts_that_need_them() {
|
||
let has = |f: &[deckcraft_fonts::Feature], tag: &str| f.iter().any(|x| Some(*x) == deckcraft_fonts::feature(tag));
|
||
let cells = |s: &str| {
|
||
s.chars()
|
||
.map(|ch| Cell { ch, style: 0, face: 0, level: 0, glyphs: vec![], adv: 0.0, head: 0, boundary: true, upright: false })
|
||
.collect::<Vec<_>>()
|
||
};
|
||
let latin = shaping_features(&cells("office"), &[], Some(*b"Latn"));
|
||
assert!(has(&latin, "-liga") && has(&latin, "-clig") && has(&latin, "-kern"));
|
||
// Arabic needs its ligatures; emoji sequences are joined by them.
|
||
assert!(!has(&shaping_features(&cells("\u{644}\u{627}"), &[], Some(*b"Arab")), "-liga"));
|
||
assert!(!has(&shaping_features(&cells("a\u{1F469}\u{200D}\u{1F4BB}"), &[], Some(*b"Latn")), "-liga"));
|
||
assert!(!has(&shaping_features(&cells("12"), &[], None), "-liga"));
|
||
}
|
||
|
||
#[test]
|
||
fn only_the_first_character_of_a_bullet_is_drawn() {
|
||
// "••" (seen in the wild) draws one dot in PowerPoint.
|
||
for (char, glyphs) in [("\u{2022}\u{2022}", 1), ("\u{2022}", 1), ("-->", 1)] {
|
||
let (p, mut sh) = setup("One", 600.0, 300.0);
|
||
sh.text.as_mut().unwrap().paragraphs[0].props.bullet = Some(Bullet::Char { char: char.into() });
|
||
let l = lay(&p, &sh, 600.0, 300.0);
|
||
let bullet = l.runs.iter().find(|r| r.chars == (0, 0)).expect("bullet run");
|
||
assert_eq!(bullet.glyphs.len(), glyphs, "{char:?}");
|
||
}
|
||
// The first grapheme cluster is kept whole.
|
||
assert_eq!(map_symbol_bullet("e\u{301}x", None), "e\u{301}");
|
||
}
|
||
|
||
#[test]
|
||
fn shrink_on_overflow() {
|
||
let text = (0..30).map(|i| format!("Line number {i}")).collect::<Vec<_>>().join("\n");
|
||
let (p, sh) = setup(&text, 600.0, 200.0);
|
||
let l = lay(&p, &sh, 600.0, 200.0);
|
||
assert!(l.font_scale < 1.0, "scale {}", l.font_scale);
|
||
assert!(!l.overflow || l.font_scale <= 0.11);
|
||
}
|
||
|
||
#[test]
|
||
fn saved_shrink_scale_is_drawn() {
|
||
// A file saved with fontScale 62.5% and lnSpcReduction 20% draws at that scale even though
|
||
// the text would fit at full size, as PowerPoint draws it.
|
||
let (p, mut sh) = setup("Short", 600.0, 300.0);
|
||
sh.text.as_mut().unwrap().body.autofit = Some(AutoFit::Shrink { font_scale: Some(0.625), line_reduction: 0.2 });
|
||
let l = lay(&p, &sh, 600.0, 300.0);
|
||
assert_eq!((l.font_scale, l.line_reduction), (0.625, 0.2));
|
||
// Text our metrics find overflowing at the saved scale is still drawn at it, as PowerPoint
|
||
// draws it until the text changes; with no saved scale it shrinks to fit.
|
||
let text = (0..30).map(|i| format!("Line number {i}")).collect::<Vec<_>>().join("\n");
|
||
let (p, mut sh) = setup(&text, 600.0, 200.0);
|
||
sh.text.as_mut().unwrap().body.autofit = Some(AutoFit::Shrink { font_scale: Some(0.9), line_reduction: 0.1 });
|
||
let l = lay(&p, &sh, 600.0, 200.0);
|
||
assert_eq!((l.font_scale, l.line_reduction), (0.9, 0.1));
|
||
sh.text.as_mut().unwrap().body.autofit = Some(AutoFit::Shrink { font_scale: Some(1.0), line_reduction: 0.0 });
|
||
let l = lay(&p, &sh, 600.0, 200.0);
|
||
assert!(l.font_scale < 0.9, "{}", l.font_scale);
|
||
// Nonsense saved values are ignored.
|
||
let (p, mut sh) = setup("Short", 600.0, 300.0);
|
||
sh.text.as_mut().unwrap().body.autofit = Some(AutoFit::Shrink { font_scale: Some(f64::NAN), line_reduction: 5.0 });
|
||
let l = lay(&p, &sh, 600.0, 300.0);
|
||
assert_eq!((l.font_scale, l.line_reduction), (1.0, 0.2));
|
||
}
|
||
|
||
/// A body whose file has `<a:normAutofit/>` with no `fontScale` is the schema default 100 %:
|
||
/// PowerPoint draws it as it is, even overflowing. DeckCraft draws it the same (#724).
|
||
#[test]
|
||
fn bare_normautofit_draws_at_full_size() {
|
||
let text = (0..30).map(|i| format!("Line number {i}")).collect::<Vec<_>>().join("\n");
|
||
let (p, mut sh) = setup(&text, 600.0, 200.0);
|
||
sh.text.as_mut().unwrap().body.autofit = Some(AutoFit::Shrink { font_scale: None, line_reduction: 0.0 });
|
||
let l = lay(&p, &sh, 600.0, 200.0);
|
||
assert_eq!(l.font_scale, 1.0, "a body with no saved fontScale draws at 100%");
|
||
assert!(l.overflow, "it overflows, as PowerPoint draws it");
|
||
}
|
||
|
||
#[test]
|
||
fn exact_line_spacing_ends_at_the_last_descent() {
|
||
// 12 pt text at exactly 26.59 pt per line (a table cell PowerPoint sizes to 24.3 pt of text):
|
||
// the baseline at 80 % of the pitch, the text ending at the last line's descent.
|
||
let (p, mut sh) = setup("One\nTwo", 600.0, 300.0);
|
||
for para in &mut sh.text.as_mut().unwrap().paragraphs {
|
||
para.props.line_spacing = Some(Spacing::Pts(26.59));
|
||
para.props.bullet = Some(Bullet::None);
|
||
for r in &mut para.runs {
|
||
r.props.size = Some(12.0);
|
||
}
|
||
}
|
||
let l = lay(&p, &sh, 600.0, 300.0);
|
||
let first = &l.lines[0];
|
||
assert!((first.baseline - first.top - 26.59 * 0.8).abs() < 0.01, "{:?}", first.baseline - first.top);
|
||
// The text ends at the last line's descent: above its full pitch by 20 % of it less the
|
||
// descent (~2.3 pt for 12 pt type).
|
||
let short = (l.lines[1].bottom - l.lines[0].top) - l.content_height;
|
||
assert!(short > 1.0 && short < 26.59 * 0.2, "{short}");
|
||
// Proportional spacing keeps full pitches.
|
||
for para in &mut sh.text.as_mut().unwrap().paragraphs {
|
||
para.props.line_spacing = Some(Spacing::Pct(1.0));
|
||
}
|
||
let l = lay(&p, &sh, 600.0, 300.0);
|
||
assert!((l.content_height - (l.lines[1].bottom - l.lines[0].top)).abs() < 0.01);
|
||
}
|
||
|
||
#[test]
|
||
fn line_spacing_reduction_comes_off_the_percentage() {
|
||
// 90 % line spacing and 10 pt before paragraphs, shrunk with a 20 % line spacing reduction:
|
||
// PowerPoint draws 70 % lines and keeps the 10 pt.
|
||
let (p, mut sh) = setup("One\nTwo\nThree", 600.0, 400.0);
|
||
for (i, para) in sh.text.as_mut().unwrap().paragraphs.iter_mut().enumerate() {
|
||
para.props.line_spacing = Some(Spacing::Pct(0.9));
|
||
para.props.space_before = Some(Spacing::Pts(10.0));
|
||
para.props.bullet = Some(Bullet::None);
|
||
if i == 0 {
|
||
para.runs[0].text.push_str(" wraps onto a second line because this paragraph is long enough to wrap in a narrow box");
|
||
}
|
||
}
|
||
let ctx = Ctx::for_slide(&p, &p.slides[0]).unwrap();
|
||
let body = sh.text.clone().unwrap();
|
||
let bp = resolve::body(&ctx, &sh);
|
||
let opts = Opts { rect: Rect::new(0.0, 0.0, 200.0, 400.0), fields: &NoFields, prompt_color: None, no_shrink: true };
|
||
let full = layout_scaled(&ctx, &sh, &body, &bp, &opts, 1.0, 0.0);
|
||
let reduced = layout_scaled(&ctx, &sh, &body, &bp, &opts, 1.0, 0.2);
|
||
let pitch = |l: &TextLayout| l.lines[1].top - l.lines[0].top;
|
||
// Lines within the first paragraph: 0.7 / 0.9 of the full pitch.
|
||
assert!(full.lines[1].para == 0 && reduced.lines[1].para == 0);
|
||
assert!((pitch(&reduced) / pitch(&full) - 0.7 / 0.9).abs() < 0.005, "{} {}", pitch(&reduced), pitch(&full));
|
||
// The space before the next paragraph is the same 10 pt.
|
||
let gap = |l: &TextLayout| {
|
||
let k = l.lines.iter().position(|x| x.para == 1).unwrap();
|
||
l.lines[k].top - l.lines[k - 1].bottom
|
||
};
|
||
assert!((gap(&full) - 10.0).abs() < 1e-6 && (gap(&reduced) - 10.0).abs() < 1e-6, "{} {}", gap(&full), gap(&reduced));
|
||
}
|
||
|
||
#[test]
|
||
fn shrink_gives_up_at_once_when_even_the_smallest_scale_overflows() {
|
||
// Found by fuzzing: a tiny box with 20,000 paragraphs and shrink on overflow took 15 s to
|
||
// open, laying out the whole body 13 times in a search that could never fit.
|
||
let text = (0..400).map(|i| format!("Line number {i}")).collect::<Vec<_>>().join("\n");
|
||
let (p, sh) = setup(&text, 100.0, 20.0);
|
||
crate::LAYOUT_PASSES.with(|n| n.set(0));
|
||
let l = lay(&p, &sh, 100.0, 20.0);
|
||
assert!(l.overflow && l.font_scale <= 0.11, "scale {}", l.font_scale);
|
||
assert!(crate::LAYOUT_PASSES.with(|n| n.get()) <= 2, "{} passes", crate::LAYOUT_PASSES.with(|n| n.get()));
|
||
// Text that fits somewhere in the range still gets the search.
|
||
let (p, sh) = setup(&(0..12).map(|i| format!("Line number {i}")).collect::<Vec<_>>().join("\n"), 600.0, 200.0);
|
||
let l = lay(&p, &sh, 600.0, 200.0);
|
||
assert!(l.font_scale > 0.11 && l.font_scale < 1.0 && !l.overflow, "scale {} overflow {}", l.font_scale, l.overflow);
|
||
}
|
||
|
||
#[test]
|
||
fn space_before_the_first_paragraph_with_spc_first_last_para() {
|
||
// 10 pt before every paragraph: skipped on the first one, unless the body asks for it.
|
||
let (p, mut sh) = setup("One\nTwo", 600.0, 300.0);
|
||
for para in &mut sh.text.as_mut().unwrap().paragraphs {
|
||
para.props.space_before = Some(Spacing::Pts(10.0));
|
||
para.props.space_after = Some(Spacing::Pts(6.0));
|
||
}
|
||
let plain = lay(&p, &sh, 600.0, 300.0);
|
||
sh.text.as_mut().unwrap().body.space_first_last = Some(true);
|
||
let both = lay(&p, &sh, 600.0, 300.0);
|
||
assert!((both.lines[0].top - plain.lines[0].top - 10.0).abs() < 1e-6);
|
||
assert!((both.content_height - plain.content_height - 16.0).abs() < 1e-6);
|
||
}
|
||
|
||
#[test]
|
||
fn caret_and_hit_roundtrip() {
|
||
let (p, sh) = setup("Hello world", 600.0, 100.0);
|
||
let l = lay(&p, &sh, 600.0, 100.0);
|
||
for ch in 0..=11 {
|
||
let pos = Pos { para: 0, ch };
|
||
let (x, top, bot) = l.caret(pos).unwrap();
|
||
let back = l.hit(Point::new(x + 0.1, (top + bot) / 2.0));
|
||
assert_eq!(back, pos, "at {ch}");
|
||
}
|
||
let r = l.selection_rects(Pos { para: 0, ch: 0 }, Pos { para: 0, ch: 5 });
|
||
assert_eq!(r.len(), 1);
|
||
}
|
||
|
||
/// #101: the text an input method is composing is underlined in place, under the baseline of each
|
||
/// line it occupies, and only over the composed characters.
|
||
#[test]
|
||
fn composition_is_underlined_per_line() {
|
||
let (p, sh) = setup("Hello 한국어 world", 600.0, 100.0);
|
||
let l = lay(&p, &sh, 600.0, 100.0);
|
||
let (a, b) = (Pos { para: 0, ch: 6 }, Pos { para: 0, ch: 9 });
|
||
let u = l.composition_underlines(a, b);
|
||
assert_eq!(u.len(), 1, "{u:?}");
|
||
let (x0, x1, y) = u[0];
|
||
let (cx0, ..) = l.caret(a).unwrap();
|
||
let (cx1, ..) = l.caret(b).unwrap();
|
||
assert!((x0 - cx0).abs() < 0.01 && (x1 - cx1).abs() < 0.01, "{u:?} vs carets {cx0} {cx1}");
|
||
let line = &l.lines[0];
|
||
assert!(y > line.baseline && y <= line.bottom, "under the baseline: {y} ({} – {})", line.baseline, line.bottom);
|
||
// Reversed ends give the same; an empty composition, nothing.
|
||
assert_eq!(l.composition_underlines(b, a), u);
|
||
assert!(l.composition_underlines(a, a).is_empty());
|
||
|
||
// Wrapped: one underline per line.
|
||
let (p, sh) = setup("가나다라마바사아자차카타파하 가나다라마바사아자차카타파하 가나다라마바사", 120.0, 400.0);
|
||
let l = lay(&p, &sh, 120.0, 400.0);
|
||
assert!(l.lines.len() >= 2);
|
||
let u = l.composition_underlines(Pos { para: 0, ch: 0 }, Pos { para: 0, ch: 40 });
|
||
assert!(u.len() >= 2, "{u:?}");
|
||
assert!(u.windows(2).all(|w| w[1].2 > w[0].2), "each lower than the last: {u:?}");
|
||
// Positions past the text never panic.
|
||
let _ = l.composition_underlines(Pos { para: 3, ch: 0 }, Pos { para: 9, ch: 99 });
|
||
}
|
||
|
||
#[test]
|
||
fn alignment_center_and_right() {
|
||
let (p, mut sh) = setup("Hi", 400.0, 100.0);
|
||
sh.text.as_mut().unwrap().paragraphs[0].props.align = Some(Align::Center);
|
||
sh.text.as_mut().unwrap().paragraphs[0].props.bullet = Some(Bullet::None);
|
||
let c = lay(&p, &sh, 400.0, 100.0);
|
||
sh.text.as_mut().unwrap().paragraphs[0].props.align = Some(Align::Right);
|
||
let r = lay(&p, &sh, 400.0, 100.0);
|
||
let cx = c.lines[0].caret_x[0];
|
||
let rx = r.lines[0].caret_x[0];
|
||
assert!(rx > cx && cx > 100.0, "center {cx} right {rx}");
|
||
}
|
||
|
||
#[test]
|
||
fn empty_and_hostile_bodies_never_panic() {
|
||
let (p, mut sh) = setup("", 10.0, 10.0);
|
||
let _ = lay(&p, &sh, 10.0, 10.0);
|
||
let _ = lay(&p, &sh, 0.0, 0.0);
|
||
let t = sh.text.as_mut().unwrap();
|
||
t.paragraphs = vec![Paragraph {
|
||
runs: vec![
|
||
Run::new("\t\u{b}\u{b}🙂 ﷽ 日本語"),
|
||
Run { text: String::new(), props: Default::default(), kind: deckcraft_model::text::RunKind::Break },
|
||
],
|
||
..Default::default()
|
||
}];
|
||
t.paragraphs[0].props.margin_left = Some(-50.0);
|
||
t.paragraphs[0].props.indent = Some(f64::NAN);
|
||
t.paragraphs[0].props.line_spacing = Some(Spacing::Pct(-3.0));
|
||
t.body.columns = Some(1000);
|
||
let l = lay(&p, &sh, 50.0, 50.0);
|
||
let _ = l.hit(Point::new(-100.0, 1e9));
|
||
let _ = l.caret(Pos { para: 99, ch: 99 });
|
||
let _ = l.selection_rects(Pos { para: 5, ch: 0 }, Pos { para: 0, ch: 3 });
|
||
}
|
||
|
||
#[test]
|
||
fn autonum_formats() {
|
||
assert_eq!(autonum("arabicPeriod", 3), "3.");
|
||
assert_eq!(autonum("romanUcPeriod", 4), "IV.");
|
||
assert_eq!(autonum("alphaLcParenR", 2), "b)");
|
||
assert_eq!(autonum("arabicParenBoth", 1), "(1)");
|
||
assert_eq!(autonum("alphaUcPeriod", 27), "AA.");
|
||
assert_eq!(autonum("alphaUcPeriod", u32::MAX).len(), 51); // 50 letters + '.'
|
||
}
|
||
|
||
#[test]
|
||
fn numbered_list_counts() {
|
||
let (p, mut sh) = setup("a\nb\nc", 400.0, 300.0);
|
||
for para in &mut sh.text.as_mut().unwrap().paragraphs {
|
||
para.props.bullet = Some(Bullet::AutoNum { scheme: "arabicPeriod".into(), start_at: 1 });
|
||
}
|
||
let l = lay(&p, &sh, 400.0, 300.0);
|
||
assert!(l.runs.len() >= 6);
|
||
}
|
||
|
||
// ---------- Bidirectional text and Arabic typography ----------
|
||
|
||
const MIXED: &str = "سنة 2024 (Retrait) فقط";
|
||
|
||
/// A one-paragraph body with no bullet, `rtl` and `align` set.
|
||
fn bidi_setup(runs: Vec<Run>, w: f64, rtl: bool, align: Align) -> (Presentation, Shape) {
|
||
let (p, mut sh) = setup("x", w, 300.0);
|
||
let t = sh.text.as_mut().unwrap();
|
||
t.paragraphs = vec![Paragraph { runs, ..Default::default() }];
|
||
let pp = &mut t.paragraphs[0].props;
|
||
pp.rtl = Some(rtl);
|
||
pp.align = Some(align);
|
||
pp.bullet = Some(Bullet::None);
|
||
pp.margin_left = Some(0.0);
|
||
pp.indent = Some(0.0);
|
||
(p, sh)
|
||
}
|
||
|
||
/// Is any face able to draw Arabic here (installed or bundled)? Shaping assertions that need
|
||
/// real Arabic glyphs are skipped without one.
|
||
fn arabic_face() -> Option<Arc<FontFace>> {
|
||
let db = FontDb::global();
|
||
let f = db.cascade(&['\u{0633}'], &[db.face("Inter", "Regular")], "Regular");
|
||
f.covers('\u{0633}').then_some(f)
|
||
}
|
||
|
||
#[test]
|
||
fn rtl_mixed_string_is_reordered_per_line() {
|
||
// An Arabic run (PowerPoint tags typed Arabic `ar-…`): its digits and brackets go with the
|
||
// right-to-left text.
|
||
let mut run = Run::new(MIXED);
|
||
run.props.lang = Some("ar-SA".into());
|
||
let (p, sh) = bidi_setup(vec![run], 2000.0, true, Align::Right);
|
||
let l = lay(&p, &sh, 2000.0, 300.0);
|
||
assert_eq!(l.lines.len(), 1);
|
||
let line = &l.lines[0];
|
||
assert!(line.rtl);
|
||
let n = MIXED.chars().count();
|
||
assert_eq!(line.edges.len(), n);
|
||
assert_eq!(line.caret_x.len(), n + 1);
|
||
let mid = |k: usize| (line.edges[k].0 + line.edges[k].1) / 2.0;
|
||
// Visual order right to left: سنة | 2024 | (Retrait) | فقط.
|
||
assert!(mid(0) > mid(4), "first Arabic word right of the number");
|
||
assert!(mid(4) > mid(10), "number right of the Latin word");
|
||
assert!(mid(10) > mid(19), "Latin right of the last Arabic word");
|
||
// Inside the Arabic words, logical order runs right to left; digits and Latin left to right.
|
||
assert!(mid(0) > mid(1) && mid(1) > mid(2));
|
||
assert!(mid(4) < mid(5) && mid(5) < mid(7));
|
||
assert!(mid(10) < mid(16));
|
||
// The brackets sit outside "Retrait": "(" (logically first) on its right.
|
||
assert!(mid(9) > mid(16) && mid(17) < mid(10));
|
||
// Right-aligned at the start edge S = W - rIns; the downstream caret at 0 is that edge.
|
||
let right_edge = l.inner.x1;
|
||
assert!((line.extent.1 - right_edge).abs() < 0.5, "{} vs {right_edge}", line.extent.1);
|
||
assert!((line.caret_x[0] - line.extent.1).abs() < 0.01);
|
||
// Levels after L1: Arabic odd, digits and Latin even.
|
||
assert_eq!(line.levels[0], 1);
|
||
assert_eq!(line.levels[4], 2);
|
||
assert_eq!(line.levels[10], 2);
|
||
}
|
||
|
||
#[test]
|
||
fn an_english_run_keeps_digits_and_brackets_left_to_right() {
|
||
// The same text in a run without a right-to-left language: PowerPoint keeps "2024 (Retrait) "
|
||
// one left-to-right stretch, its number on the left.
|
||
let (p, sh) = bidi_setup(vec![Run::new(MIXED)], 2000.0, true, Align::Right);
|
||
let l = lay(&p, &sh, 2000.0, 300.0);
|
||
let line = &l.lines[0];
|
||
let mid = |k: usize| (line.edges[k].0 + line.edges[k].1) / 2.0;
|
||
assert!(mid(0) > mid(10), "first Arabic word right of the Latin");
|
||
assert!(mid(4) < mid(10), "number left of the Latin word");
|
||
assert!(mid(9) < mid(10) && mid(17) > mid(16), "brackets around Retrait, unmirrored");
|
||
assert!(mid(19) < mid(4), "last Arabic word on the left");
|
||
}
|
||
|
||
#[test]
|
||
fn rtl_paragraph_starts_at_the_right_with_the_bullet_outside() {
|
||
let (p, mut sh) = bidi_setup(vec![Run::new("مرحبا بكم")], 400.0, true, Align::Right);
|
||
let pp = &mut sh.text.as_mut().unwrap().paragraphs[0].props;
|
||
pp.bullet = Some(Bullet::Char { char: "•".into() });
|
||
pp.margin_left = Some(36.0);
|
||
pp.indent = Some(-36.0);
|
||
let l = lay(&p, &sh, 400.0, 300.0);
|
||
let line = &l.lines[0];
|
||
// Text starts marL from the right edge; the bullet hangs at S - (marL + indent) = S.
|
||
let s_edge = l.inner.x1;
|
||
assert!((line.extent.1 - (s_edge - 36.0)).abs() < 0.5, "text right {} expected {}", line.extent.1, s_edge - 36.0);
|
||
let bullet = l.runs.iter().find(|r| r.chars == (0, 0)).expect("bullet run");
|
||
let bx = bullet.glyphs[0].1;
|
||
assert!(bx > line.extent.1 - 0.5, "bullet {bx} right of the text {}", line.extent.1);
|
||
assert!(bx < s_edge, "bullet inside the box");
|
||
// An LTR paragraph keeps the bullet on the left.
|
||
sh.text.as_mut().unwrap().paragraphs[0].props.rtl = Some(false);
|
||
sh.text.as_mut().unwrap().paragraphs[0].props.align = Some(Align::Left);
|
||
let l = lay(&p, &sh, 400.0, 300.0);
|
||
let bullet = l.runs.iter().find(|r| r.chars == (0, 0)).expect("bullet run");
|
||
assert!(bullet.glyphs[0].1 < l.lines[0].extent.0);
|
||
}
|
||
|
||
#[test]
|
||
fn rtl_left_and_center_alignment() {
|
||
let (p, sh) = bidi_setup(vec![Run::new("سلام")], 400.0, true, Align::Left);
|
||
let l = lay(&p, &sh, 400.0, 300.0);
|
||
assert!((l.lines[0].extent.0 - l.inner.x0).abs() < 0.5, "algn=l is flush left in RTL too");
|
||
let (p, sh) = bidi_setup(vec![Run::new("سلام")], 400.0, true, Align::Center);
|
||
let l = lay(&p, &sh, 400.0, 300.0);
|
||
let c = (l.lines[0].extent.0 + l.lines[0].extent.1) / 2.0;
|
||
assert!((c - (l.inner.x0 + l.inner.x1) / 2.0).abs() < 0.5);
|
||
}
|
||
|
||
#[test]
|
||
fn bidi_caret_stops_round_trip_through_hit_testing() {
|
||
for rtl in [true, false] {
|
||
let (p, sh) = bidi_setup(vec![Run::new(MIXED)], 2000.0, rtl, if rtl { Align::Right } else { Align::Left });
|
||
let l = lay(&p, &sh, 2000.0, 300.0);
|
||
let line = &l.lines[0];
|
||
for (x, ch, aff) in line.visual_stops() {
|
||
let (cx, ..) = l.caret_at(Pos { para: 0, ch }, aff).unwrap();
|
||
assert!((cx - x).abs() < 0.01, "stop {ch} {aff:?}: caret {cx} vs stop {x}");
|
||
}
|
||
// Clicking just inside either side of each grapheme puts the caret on that side.
|
||
for (a, b) in line.graphemes() {
|
||
let Some((x0, x1)) = line.grapheme_box(a, b) else { continue };
|
||
if x1 - x0 < 1.0 {
|
||
continue;
|
||
}
|
||
let y = (line.top + line.bottom) / 2.0;
|
||
for x in [x0 + 0.2, x1 - 0.2] {
|
||
let (pos, aff) = l.hit_affinity(Point::new(x, y));
|
||
let (cx, ..) = l.caret_at(pos, aff).unwrap();
|
||
let side = if x < (x0 + x1) / 2.0 { x0 } else { x1 };
|
||
assert!((cx - side).abs() < 0.01, "rtl={rtl} grapheme {a}: hit {x} -> {pos:?} {aff:?} caret {cx}, expected {side}");
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn visual_movement_walks_the_line_left_to_right() {
|
||
let (p, sh) = bidi_setup(vec![Run::new(MIXED)], 2000.0, true, Align::Right);
|
||
let l = lay(&p, &sh, 2000.0, 300.0);
|
||
let stops = l.lines[0].visual_stops();
|
||
let (x0, ch0, aff0) = stops[0];
|
||
let (mut pos, mut aff) = (Pos { para: 0, ch: ch0 }, aff0);
|
||
let mut xs = vec![x0];
|
||
for _ in 0..200 {
|
||
let (np, na) = l.move_caret(pos, aff, true, MoveMode::Visual);
|
||
if (np, na) == (pos, aff) {
|
||
break;
|
||
}
|
||
(pos, aff) = (np, na);
|
||
xs.push(l.caret_at(pos, aff).unwrap().0);
|
||
}
|
||
assert!(xs.windows(2).all(|w| w[1] > w[0]), "moving right always moves right: {xs:?}");
|
||
let right = l.lines[0].extent.1;
|
||
assert!((xs.last().unwrap() - right).abs() < 0.01, "reaches the right edge");
|
||
// Right arrow at the right edge of an RTL paragraph's only line goes nowhere.
|
||
assert_eq!(l.move_caret(pos, aff, true, MoveMode::Visual).0, pos);
|
||
// Moving left from the right edge in an RTL paragraph is logically forward.
|
||
let (p1, _) = l.move_caret(Pos { para: 0, ch: 0 }, Affinity::Downstream, false, MoveMode::Visual);
|
||
assert_eq!(p1.ch, 1);
|
||
}
|
||
|
||
#[test]
|
||
fn logical_movement_steps_over_harakat() {
|
||
// beh + fatha + teh: the fatha belongs to the beh's grapheme.
|
||
let (p, sh) = bidi_setup(vec![Run::new("\u{0628}\u{064E}\u{062A}")], 400.0, true, Align::Right);
|
||
let l = lay(&p, &sh, 400.0, 300.0);
|
||
let (n1, _) = l.move_caret(Pos { para: 0, ch: 0 }, Affinity::Downstream, true, MoveMode::Logical);
|
||
assert_eq!(n1.ch, 2);
|
||
let (n2, _) = l.move_caret(n1, Affinity::Downstream, false, MoveMode::Logical);
|
||
assert_eq!(n2.ch, 0);
|
||
// No caret stop inside a grapheme.
|
||
assert!(l.lines[0].visual_stops().iter().all(|s| s.1 != 1));
|
||
}
|
||
|
||
#[test]
|
||
fn selection_is_the_union_of_visual_boxes() {
|
||
// LTR paragraph with an Arabic word: visually "ab ةنس cd".
|
||
let (p, sh) = bidi_setup(vec![Run::new("ab سنة cd")], 2000.0, false, Align::Left);
|
||
let l = lay(&p, &sh, 2000.0, 300.0);
|
||
// Logical [1, 5) = "b", " ", "س", "ن": two separate boxes on screen.
|
||
let r = l.selection_rects(Pos { para: 0, ch: 1 }, Pos { para: 0, ch: 5 });
|
||
assert_eq!(r.len(), 2, "{r:?}");
|
||
// The whole line is one box.
|
||
assert_eq!(l.selection_rects(Pos { para: 0, ch: 0 }, Pos { para: 0, ch: 9 }).len(), 1);
|
||
}
|
||
|
||
#[test]
|
||
fn paint_only_style_changes_keep_arabic_joining() {
|
||
let Some(_) = arabic_face() else {
|
||
eprintln!("skipped: no Arabic face available");
|
||
return;
|
||
};
|
||
let word = "سنة";
|
||
let glyphs = |runs: Vec<Run>| {
|
||
let (p, sh) = bidi_setup(runs, 400.0, true, Align::Right);
|
||
let l = lay(&p, &sh, 400.0, 300.0);
|
||
let mut g: Vec<(u32, f64)> = l.runs.iter().flat_map(|r| r.glyphs.iter().map(|g| (g.0, g.1))).collect();
|
||
g.sort_by(|a, b| a.1.total_cmp(&b.1));
|
||
g.into_iter().map(|g| g.0).collect::<Vec<_>>()
|
||
};
|
||
let whole = glyphs(vec![Run::new(word)]);
|
||
let mut red = Run::new("سن");
|
||
red.props.fill = Some(Fill::solid(deckcraft_model::style::ColorRef::rgb(Rgba::from_hex("C00000").unwrap())));
|
||
let split = glyphs(vec![red, Run::new("ة")]);
|
||
assert_eq!(whole, split, "a colour change inside a word keeps the joined forms");
|
||
// And the joined forms differ from the isolated letters.
|
||
let isolated: Vec<u32> = word.chars().map(|c| arabic_face().unwrap().glyph_for(c)).collect();
|
||
assert_ne!(whole.iter().rev().copied().collect::<Vec<_>>(), isolated);
|
||
}
|
||
|
||
#[test]
|
||
fn just_low_stretches_arabic_with_kashida() {
|
||
if arabic_face().is_none() {
|
||
eprintln!("skipped: no Arabic face available");
|
||
return;
|
||
}
|
||
// Tatweel glyphs drawn, counted in each run's own face (the one the layout picked).
|
||
let tatweels = |l: &TextLayout| {
|
||
l.runs
|
||
.iter()
|
||
.map(|r| {
|
||
let tg = r.face.glyph_for('\u{0640}');
|
||
if tg == 0 { 0 } else { r.glyphs.iter().filter(|g| g.0 == tg).count() }
|
||
})
|
||
.sum::<usize>()
|
||
};
|
||
let text = "بسم الله الرحمن الرحيم نستعين به ونستغفره ونتوب إليه";
|
||
let (p, sh) = bidi_setup(vec![Run::new(text)], 220.0, true, Align::JustLow);
|
||
let l = lay(&p, &sh, 220.0, 600.0);
|
||
assert!(l.lines.len() >= 2);
|
||
let first = &l.lines[0];
|
||
let w = l.inner.width();
|
||
assert!((first.extent.1 - first.extent.0 - w).abs() < 0.5, "first line fills the box: {:?} vs {w}", first.extent);
|
||
if l.runs.iter().all(|r| r.face.glyph_for('\u{0640}') == 0) {
|
||
eprintln!("skipped: the Arabic face has no tatweel");
|
||
return;
|
||
}
|
||
assert!(tatweels(&l) > 0, "kashida drawn");
|
||
// The last line isn't stretched and sits at the start (right) edge.
|
||
let last = l.lines.last().unwrap();
|
||
assert!((last.extent.1 - l.inner.x1).abs() < 0.5);
|
||
// Plain justify uses spaces: no tatweel.
|
||
let (p, sh) = bidi_setup(vec![Run::new(text)], 220.0, true, Align::Justify);
|
||
let l = lay(&p, &sh, 220.0, 600.0);
|
||
assert_eq!(tatweels(&l), 0);
|
||
}
|
||
|
||
#[test]
|
||
fn wrapped_rtl_lines_break_in_logical_order() {
|
||
let text = "واحد اثنان ثلاثة أربعة خمسة ستة سبعة ثمانية تسعة عشرة";
|
||
let (p, sh) = bidi_setup(vec![Run::new(text)], 160.0, true, Align::Right);
|
||
let l = lay(&p, &sh, 160.0, 600.0);
|
||
assert!(l.lines.len() >= 2);
|
||
// Lines cover the text in logical order: the first line holds the first words.
|
||
assert_eq!(l.lines[0].start, 0);
|
||
for w in l.lines.windows(2) {
|
||
assert!(w[1].start >= w[0].end);
|
||
}
|
||
for line in &l.lines {
|
||
assert!(line.extent.0 >= l.inner.x0 - 0.5, "line fits: {:?}", line.extent);
|
||
assert!((line.extent.1 - l.inner.x1).abs() < 0.5, "flush right");
|
||
}
|
||
// Upstream affinity at a wrap keeps the caret on the earlier line.
|
||
let end0 = l.lines[0].end;
|
||
assert_eq!(l.line_of_affine(Pos { para: 0, ch: end0 }, Affinity::Upstream), Some(0));
|
||
}
|
||
|
||
#[test]
|
||
fn hostile_bidi_input_never_panics() {
|
||
let nasty = format!("{}\t\u{b}\u{202E}abc\u{2069}{}(]))[ ١٢٣ \u{0640}\u{064E}\u{064E}\u{200D}", "\u{202B}".repeat(200), "\u{2067}".repeat(130));
|
||
for rtl in [true, false] {
|
||
for align in [Align::Left, Align::Right, Align::Center, Align::Justify, Align::JustLow, Align::Distributed] {
|
||
let (p, sh) = bidi_setup(vec![Run::new(nasty.clone()), Run::new(MIXED)], 60.0, rtl, align);
|
||
let l = lay(&p, &sh, 60.0, 60.0);
|
||
for line in &l.lines {
|
||
assert_eq!(line.caret_x.len(), line.end - line.start + 1);
|
||
assert_eq!(line.edges.len(), line.end - line.start);
|
||
}
|
||
let _ = l.hit_affinity(Point::new(-1e9, 1e9));
|
||
let _ = l.selection_rects(Pos { para: 0, ch: 0 }, Pos { para: 0, ch: 9999 });
|
||
let mut pos = (Pos::default(), Affinity::Downstream);
|
||
for i in 0..50 {
|
||
pos = l.move_caret(pos.0, pos.1, i % 3 != 0, if i % 2 == 0 { MoveMode::Visual } else { MoveMode::Logical });
|
||
}
|
||
let _ = l.caret_at(Pos { para: 7, ch: 7 }, Affinity::Upstream);
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Width of `word` laid out in a run with `baseline` (0 = normal, 0.3 = superscript …).
|
||
fn run_width(word: &str, baseline: Option<f64>) -> f64 {
|
||
let mut run = Run::new(word);
|
||
run.props.size = Some(24.0);
|
||
run.props.baseline = baseline;
|
||
let (p, sh) = bidi_setup(vec![run], 2000.0, false, Align::Left);
|
||
let l = lay(&p, &sh, 2000.0, 300.0);
|
||
let line = &l.lines[0];
|
||
line.caret_x.last().unwrap() - line.caret_x.first().unwrap()
|
||
}
|
||
|
||
#[test]
|
||
fn superscript_and_subscript_advance_at_their_drawn_size() {
|
||
// The glyphs are drawn at two thirds of the size; advancing by the full size spread the
|
||
// letters apart ("s u p e r").
|
||
let normal = run_width("superscript", None);
|
||
for b in [Some(0.3), Some(-0.25)] {
|
||
let w = run_width("superscript", b);
|
||
assert!((w / normal - SUB_SUPER).abs() < 0.02, "{b:?}: {w} vs {normal}");
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn superscript_glyphs_sit_inside_their_cells() {
|
||
let mut run = Run::new("super");
|
||
run.props.size = Some(24.0);
|
||
run.props.baseline = Some(0.3);
|
||
let (p, sh) = bidi_setup(vec![run], 2000.0, false, Align::Left);
|
||
let l = lay(&p, &sh, 2000.0, 300.0);
|
||
let line = &l.lines[0];
|
||
let r = l.runs.iter().find(|r| !r.cells.is_empty()).unwrap();
|
||
assert!((r.size - 24.0 * SUB_SUPER).abs() < 1e-6);
|
||
for (g, (ci, _)) in r.glyphs.iter().zip(&r.cells) {
|
||
let (x0, x1) = line.edges[*ci - line.start];
|
||
assert!(g.1 >= x0 - 0.01 && g.1 < x1, "glyph at {} outside its cell {x0}..{x1}", g.1);
|
||
}
|
||
}
|
||
|
||
/// A wrapping numbered paragraph with `marL` and `indent`; returns (bullet x, first line's text
|
||
/// x, second line's text x).
|
||
fn hanging(margin: f64, indent: f64, bullet: Bullet) -> (Option<f64>, f64, f64) {
|
||
let text = "Wrapping words go on and on so the paragraph needs at least two or three lines here";
|
||
let (p, mut sh) = setup(text, 300.0, 300.0);
|
||
let para = &mut sh.text.as_mut().unwrap().paragraphs[0];
|
||
para.props.bullet = Some(bullet);
|
||
para.props.margin_left = Some(margin);
|
||
para.props.indent = Some(indent);
|
||
let l = lay(&p, &sh, 300.0, 300.0);
|
||
assert!(l.lines.len() >= 2, "{} lines", l.lines.len());
|
||
let bx = l.runs.iter().find(|r| r.cells.is_empty() && !r.glyphs.is_empty()).map(|r| r.glyphs[0].1);
|
||
(bx, l.lines[0].caret_x[0], l.lines[1].caret_x[0])
|
||
}
|
||
|
||
#[test]
|
||
fn a_hang_past_the_box_edge_keeps_its_width_on_the_first_line() {
|
||
// PowerPoint, marL 0 / indent -36pt: the number sits at the box's edge, the first line's text
|
||
// 36pt in, and the wrapped lines at the margin (observed with PowerPoint's slide export).
|
||
let num = || Bullet::AutoNum { scheme: "arabicPeriod".into(), start_at: 1 };
|
||
let (bx, first, rest) = hanging(0.0, -36.0, num());
|
||
assert!((first - rest - 36.0).abs() < 0.5, "first {first} rest {rest}");
|
||
assert!((bx.unwrap() - rest).abs() < 0.5, "bullet {bx:?} rest {rest}");
|
||
// marL 18 / indent -54: number at the edge, first line at 54, the rest at 18.
|
||
let (bx, first, rest) = hanging(18.0, -54.0, num());
|
||
assert!((first - rest - 36.0).abs() < 0.5, "first {first} rest {rest}");
|
||
assert!((rest - bx.unwrap() - 18.0).abs() < 0.5, "bullet {bx:?} rest {rest}");
|
||
// A character bullet behaves the same.
|
||
let (_, first, rest) = hanging(0.0, -36.0, Bullet::Char { char: "•".into() });
|
||
assert!((first - rest - 36.0).abs() < 0.5, "first {first} rest {rest}");
|
||
// Without a bullet the first line just starts at the edge.
|
||
let (_, first, rest) = hanging(0.0, -36.0, Bullet::None);
|
||
assert!((first - rest).abs() < 0.5, "first {first} rest {rest}");
|
||
}
|
||
|
||
#[test]
|
||
fn an_ordinary_hang_still_puts_the_text_at_the_margin() {
|
||
let (bx, first, rest) = hanging(36.0, -36.0, Bullet::AutoNum { scheme: "arabicPeriod".into(), start_at: 1 });
|
||
assert!((first - rest).abs() < 0.5, "first {first} rest {rest}");
|
||
assert!((rest - bx.unwrap() - 36.0).abs() < 0.5);
|
||
}
|
||
|
||
#[test]
|
||
fn single_spaced_lines_are_1_2_times_the_size_apart_whatever_the_font() {
|
||
// PowerPoint spaces single-spaced lines 1.2 × the font size apart in every font, with the
|
||
// baseline where the font's Windows ascent/descent split puts it (observed on twenty fonts).
|
||
for size in [18.0, 40.0] {
|
||
let mut run = Run::new("HHH");
|
||
run.props.size = Some(size);
|
||
let (p, mut sh) = bidi_setup(vec![run], 2000.0, false, Align::Left);
|
||
let t = sh.text.as_mut().unwrap();
|
||
t.body.autofit = Some(AutoFit::None);
|
||
let second = t.paragraphs[0].clone();
|
||
t.paragraphs.push(second.clone());
|
||
t.paragraphs.push(second);
|
||
for para in &mut t.paragraphs {
|
||
para.props.line_spacing = Some(Spacing::Pct(1.0));
|
||
para.props.space_before = Some(Spacing::Pts(0.0));
|
||
para.props.space_after = Some(Spacing::Pts(0.0));
|
||
}
|
||
let l = lay(&p, &sh, 2000.0, 600.0);
|
||
assert_eq!(l.lines.len(), 3);
|
||
// Each line is 1.2 × the size tall (the face is not compared across lines: another
|
||
// test's thread can load the family between them, see #252).
|
||
for line in &l.lines {
|
||
assert!((line.bottom - line.top - size * LINE_PITCH).abs() < 1e-6, "{size}: {}", line.bottom - line.top);
|
||
}
|
||
let face = &l.runs[0].face;
|
||
let first = &l.lines[0];
|
||
assert!((first.baseline - first.top - size * LINE_PITCH * face.line_split).abs() < 1e-6);
|
||
}
|
||
}
|
||
|
||
/// The lines of `text` in an Arial-free (whatever face resolves) box `w` wide, as strings.
|
||
fn wrapped(text: &str, w: f64, set: impl Fn(&mut ParaProps)) -> Vec<String> {
|
||
let (p, mut sh) = bidi_setup(vec![Run::new(text)], w, false, Align::Left);
|
||
let t = sh.text.as_mut().unwrap();
|
||
t.body.inset_l = Some(0.0);
|
||
t.body.inset_r = Some(0.0);
|
||
set(&mut t.paragraphs[0].props);
|
||
let l = lay(&p, &sh, w, 600.0);
|
||
let chars: Vec<char> = text.chars().collect();
|
||
l.lines.iter().map(|li| chars[li.start..li.end].iter().collect()).collect()
|
||
}
|
||
|
||
/// Width of `text` on one line.
|
||
fn one_line(text: &str) -> f64 {
|
||
let (p, sh) = bidi_setup(vec![Run::new(text)], 5000.0, false, Align::Left);
|
||
let l = lay(&p, &sh, 5000.0, 300.0);
|
||
l.lines[0].caret_x.last().unwrap() - l.lines[0].caret_x[0]
|
||
}
|
||
|
||
#[test]
|
||
fn a_word_does_not_break_after_a_slash_or_backslash() {
|
||
// PowerPoint (latinLnBrk off, its default) keeps "alpha/beta/gamma" whole and only breaks it
|
||
// where it no longer fits; Unicode line breaking would allow a break after each slash.
|
||
for sep in ["/", "\\"] {
|
||
let text = ["alpha", "beta", "gamma", "delta", "epsilon"].join(sep);
|
||
let w = one_line(&text) * 0.6;
|
||
let lines = wrapped(&text, w, |_| {});
|
||
assert!(lines.len() >= 2, "{lines:?}");
|
||
assert!(lines[0].chars().count() > "alpha/beta".len(), "filled to the edge, not cut at a separator: {lines:?}");
|
||
}
|
||
// latinLnBrk on: Unicode's break after a slash is allowed again.
|
||
let text = "alpha/beta/gamma/delta/epsilon";
|
||
let lines = wrapped(text, one_line(text) * 0.6, |p| p.latin_line_break = Some(true));
|
||
assert!(lines[0].ends_with('/'), "{lines:?}");
|
||
// A slash followed by a space still breaks, and hyphens still break.
|
||
let lines = wrapped("alpha-beta-gamma-delta-epsilon", one_line("alpha-beta-gamma-") + 1.0, |_| {});
|
||
assert_eq!(lines[0], "alpha-beta-gamma-");
|
||
}
|
||
|
||
#[test]
|
||
fn korean_wraps_between_words() {
|
||
let text = "한국어 안녕하세요 반갑습니다 감사합니다";
|
||
let w = one_line("한국어 안녕하세요 반") + 0.5;
|
||
let lines = wrapped(text, w, |_| {});
|
||
assert_eq!(lines.iter().map(|l| l.trim_end()).collect::<Vec<_>>(), ["한국어 안녕하세요", "반갑습니다", "감사합니다"], "{lines:?}");
|
||
// Japanese and Chinese still break between characters.
|
||
let lines = wrapped("日本語の文章は空白なしで続きます", one_line("日本語の文章") + 0.5, |_| {});
|
||
assert_eq!(lines[0], "日本語の文章");
|
||
}
|
||
|
||
#[test]
|
||
fn closing_punctuation_hangs_past_the_end_with_hanging_punct() {
|
||
// PowerPoint (hangingPunct on, as its default text styles set it) lets "。" hang past the
|
||
// edge instead of pulling the character before it onto the next line.
|
||
let text = "白なしで続きます。句読点も含めて。";
|
||
let w = one_line("白なしで続きます") + 0.5;
|
||
let lines = wrapped(text, w, |p| p.hanging_punct = Some(true));
|
||
assert_eq!(lines[0], "白なしで続きます。", "{lines:?}");
|
||
// Without it, "。" can't start a line, so "す。" moves down together.
|
||
let lines = wrapped(text, w, |p| p.hanging_punct = Some(false));
|
||
assert_eq!(lines[0], "白なしで続きま", "{lines:?}");
|
||
}
|
||
|
||
#[test]
|
||
fn emoji_take_a_colour_face_when_one_is_installed() {
|
||
// PowerPoint draws emoji (and ZWJ sequences, skin tones, flags) from the colour emoji font
|
||
// even when the run's font has a plain glyph for some of them. Skipped without an installed
|
||
// colour emoji font.
|
||
let db = FontDb::global();
|
||
let probe = db.cascade(&['😀'], &[], "Regular");
|
||
if !probe.is_color() {
|
||
return;
|
||
}
|
||
for s in ["😀", "👍🏽", "❤\u{FE0F}", "👨\u{200D}👩\u{200D}👧"] {
|
||
let (p, sh) = bidi_setup(vec![Run::new(format!("a{s}b"))], 2000.0, false, Align::Left);
|
||
let l = lay(&p, &sh, 2000.0, 300.0);
|
||
let emoji = l.runs.iter().find(|r| r.cells.iter().any(|(_, c)| !c.is_ascii())).unwrap();
|
||
assert!(emoji.face.is_color(), "{s:?} drawn with {}", emoji.face.family);
|
||
assert!(l.runs.iter().filter(|r| r.cells.iter().all(|(_, c)| c.is_ascii())).all(|r| !r.face.is_color()), "the letters keep a text face");
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn a_bullet_the_text_font_lacks_falls_back_to_a_face_that_has_it() {
|
||
// circleNumDbPlain numbers ①②…: the text font usually has no circled digits; PowerPoint draws
|
||
// them from a fallback font instead of a missing-glyph box. Skipped when no installed or
|
||
// bundled face has ①.
|
||
let db = FontDb::global();
|
||
if !db.cascade(&['①'], &[], "Regular").covers('①') {
|
||
return;
|
||
}
|
||
let (p, mut sh) = setup("One\nTwo", 600.0, 300.0);
|
||
for para in &mut sh.text.as_mut().unwrap().paragraphs {
|
||
para.props.bullet = Some(Bullet::AutoNum { scheme: "circleNumDbPlain".into(), start_at: 1 });
|
||
}
|
||
let l = lay(&p, &sh, 600.0, 300.0);
|
||
let bullets: Vec<_> = l.runs.iter().filter(|r| r.cells.is_empty()).collect();
|
||
assert_eq!(bullets.len(), 2);
|
||
for b in bullets {
|
||
assert!(b.face.covers('①'), "drawn with {}, which lacks the circled digit", b.face.family);
|
||
assert!(b.glyphs.iter().all(|g| g.0 != 0), "no missing-glyph box");
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn symbol_font_bullets_map_by_font() {
|
||
// Wingdings 2 code 0xEA is a star, Wingdings 3 0x7D a right-pointing triangle; plain
|
||
// Wingdings keeps its own table (0xA7 is a small square).
|
||
let star = String::from_utf8(vec![0xEF, 0x83, 0xAA]).unwrap(); // U+F0EA
|
||
assert_eq!(map_symbol_bullet(&star, Some("Wingdings 2")), "★");
|
||
assert_eq!(map_symbol_bullet("\u{7d}", Some("Wingdings 3")), "►");
|
||
assert_eq!(map_symbol_bullet("\u{f0a7}", Some("Wingdings")), "▪");
|
||
assert_eq!(map_symbol_bullet("•", Some("Arial")), "•");
|
||
assert!(is_symbol_font("Wingdings 2") && is_symbol_font("Symbol") && !is_symbol_font("Arial"));
|
||
}
|
||
|
||
#[test]
|
||
fn an_installed_symbol_font_draws_its_own_bullet() {
|
||
// Where the deck's symbol font is installed, its glyph is drawn (as PowerPoint does), not a
|
||
// look-alike. Skipped without Wingdings 2.
|
||
let db = FontDb::global();
|
||
if !db.has_family("Wingdings 2") {
|
||
return;
|
||
}
|
||
let face = db.face("Wingdings 2", "Regular");
|
||
assert_eq!(symbol_font_char(&face, "\u{ea}", Some("Wingdings 2")), Some('\u{f0ea}'));
|
||
assert_eq!(symbol_font_char(&face, "\u{ea}", Some("Arial")), None);
|
||
}
|
||
|
||
#[test]
|
||
fn symbol_font_char_keeps_covered_non_symbol_bullets() {
|
||
// `Bullet::Char.char` is unrestricted text; the PPTX reader stores `buChar` directly. A bullet
|
||
// such as U+2022 • must draw its own covered glyph, never a low-byte remap (0x22 → FOR ALL)
|
||
// to an unrelated Symbol code. Skipped when the face doesn't cover U+2022.
|
||
let db = FontDb::global();
|
||
if !db.has_family("Symbol") {
|
||
eprintln!("skipped: no Symbol font installed");
|
||
return;
|
||
}
|
||
let face = db.face("Symbol", "Regular");
|
||
if !face.covers('•') {
|
||
eprintln!("skipped: installed Symbol face lacks U+2022");
|
||
return;
|
||
}
|
||
assert_eq!(symbol_font_char(&face, "•", Some("Symbol")), Some('•'), "U+2022 draws itself, not a low-byte remap");
|
||
// A real symbol code still takes the mapping.
|
||
let f0de = String::from_utf8(vec![0xEF, 0x83, 0x9E]).unwrap(); // U+F0DE
|
||
assert_eq!(symbol_font_char(&face, &f0de, Some("Symbol")), symbol_font_draw(&face, 0xDE));
|
||
}
|
||
|
||
#[test]
|
||
fn symbol_char_maps_symbol_font_codes() {
|
||
// Inter is not a symbol font, so the codes map to look-alikes.
|
||
let face = FontDb::global().face("Inter", "Regular");
|
||
assert_eq!(symbol_char(&face, "Arial", 'n'), None, "not a symbol font");
|
||
assert_eq!(symbol_char(&face, "Webdings", 'n'), Some('\u{25CF}'));
|
||
assert_eq!(symbol_char(&face, "Webdings", '\u{F06E}'), Some('\u{25CF}'), "the private-use form of the code");
|
||
assert_eq!(symbol_char(&face, "Wingdings", '\u{F06E}'), Some('\u{25A0}'));
|
||
assert_eq!(symbol_char(&face, "Wingdings", '\u{100}'), None, "not a symbol code");
|
||
}
|
||
|
||
#[test]
|
||
fn symbol_font_remaps_private_use_to_real_unicode() {
|
||
// Apple's "Symbol" on macOS has no private-use cmap: it draws the classic Symbol glyphs at
|
||
// their real Unicode points. A document's U+F0xx symbol characters must be remapped to those.
|
||
// Skipped without an installed Symbol face that actually draws the remapped character.
|
||
let db = FontDb::global();
|
||
if !db.has_family("Symbol") {
|
||
eprintln!("skipped: no Symbol font installed");
|
||
return;
|
||
}
|
||
let face = db.face("Symbol", "Regular");
|
||
// U+F0DE is the Symbol font's double arrow (⇒, U+21D2). The face must draw it at the real
|
||
// Unicode point — the PUA code itself only when the face has a private-use cmap (Windows).
|
||
let drawn = symbol_font_draw(&face, 0xDE);
|
||
if face.covers('\u{F0DE}') {
|
||
assert_eq!(drawn, Some('\u{F0DE}'));
|
||
} else {
|
||
assert_eq!(drawn, Some('\u{21D2}'), "Apple Symbol maps U+F0DE to the real double arrow");
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn symbol_font_draw_falls_back_to_ascii() {
|
||
// 0x3C–0x3F are plain ASCII < = > ? in Adobe's symbol encoding (≤ ≥ ∞ sit at 0xA3/0xB3/0xA5 and
|
||
// ∴ at 0x5C), so a document's "a<b" set in Symbol must draw "a<b", not "a≤b". ASCII codes with no
|
||
// table entry draw themselves too: U+F031 is "1", U+F028 "(". Skipped without an installed
|
||
// Symbol face.
|
||
let db = FontDb::global();
|
||
if !db.has_family("Symbol") {
|
||
eprintln!("skipped: no Symbol font installed");
|
||
return;
|
||
}
|
||
let face = db.face("Symbol", "Regular");
|
||
for &code in &[0x3C, 0x3D, 0x3E, 0x3F, 0x31, 0x28, 0x30, 0x2B] {
|
||
let pua = char::from_u32(0xF000 | code).unwrap();
|
||
let ascii = char::from_u32(code).unwrap();
|
||
let drawn = symbol_font_draw(&face, code);
|
||
if face.covers(pua) {
|
||
// Windows Symbol covers its private-use block; that glyph wins.
|
||
assert_eq!(drawn, Some(pua), "the face's private-use glyph wins for 0x{code:02X}");
|
||
} else if face.covers(ascii) {
|
||
// Apple's Symbol (no PUA cmap) draws the ASCII character itself, never a remap of
|
||
// 0x3C–0x3F to ≤ ≥ ∞ ∴.
|
||
assert_eq!(drawn, Some(ascii), "Symbol code 0x{code:02X} must draw its ASCII character");
|
||
} else {
|
||
assert_eq!(drawn, None, "0x{code:02X} has no glyph in this Symbol face");
|
||
}
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn symbol_font_draw_tries_apple_alternatives() {
|
||
// Apple's Symbol maps a few codes differently from Adobe: 0xA4 (fraction slash) to U+2044
|
||
// instead of Adobe's U+2215, and 0xE1/0xF1 (angle brackets) to U+3008/U+3009 instead of
|
||
// U+2329/U+232A. When the installed face doesn't cover the Adobe character, the alternative is
|
||
// tried before giving up. Skipped without an installed Symbol face.
|
||
let db = FontDb::global();
|
||
if !db.has_family("Symbol") {
|
||
eprintln!("skipped: no Symbol font installed");
|
||
return;
|
||
}
|
||
let face = db.face("Symbol", "Regular");
|
||
for &(code, adobe, alt) in &[(0xA4, '\u{2215}', '\u{2044}'), (0xE1, '\u{2329}', '\u{3008}'), (0xF1, '\u{232A}', '\u{3009}')] {
|
||
let pua = char::from_u32(0xF000 | code).unwrap();
|
||
let drawn = symbol_font_draw(&face, code);
|
||
if face.covers(pua) {
|
||
assert_eq!(drawn, Some(pua), "the face's private-use glyph wins for 0x{code:02X}");
|
||
} else if face.covers(adobe) {
|
||
assert_eq!(drawn, Some(adobe), "Adobe U+{:04X} wins for 0x{code:02X} when covered", adobe as u32);
|
||
} else {
|
||
assert_eq!(drawn, Some(alt), "Apple alternative U+{:04X} is tried for 0x{code:02X}", alt as u32);
|
||
}
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn symbol_unicode_maps_the_euro() {
|
||
// Adobe symbol.txt: 20AC A0 # EURO SIGN. The euro is the one currency symbol in the encoding.
|
||
assert_eq!(symbol_unicode(0xA0), Some(0x20AC));
|
||
// Apple alternatives are tried in order for 0xA4/0xE1/0xF1.
|
||
assert_eq!(symbol_unicode_alts(0xA4), &[0x2044u32]);
|
||
assert_eq!(symbol_unicode_alts(0xE1), &[0x3008u32]);
|
||
assert_eq!(symbol_unicode_alts(0xF1), &[0x3009u32]);
|
||
assert_eq!(symbol_unicode_alts(0x44), &[] as &[u32]);
|
||
assert_eq!(symbol_unicode_alts(0x57), &[] as &[u32]);
|
||
assert_eq!(symbol_unicode_alts(0x6D), &[] as &[u32]);
|
||
}
|
||
|
||
/// Every entry of the Adobe Symbol encoding table, in full. Pure and platform-independent: the
|
||
/// table maps a Symbol code to its real Unicode character regardless of any installed font, so this
|
||
/// runs on every machine. Guarded against typos in `symbol_unicode` (e.g. 0x40 must be U+2245, the
|
||
/// congruent sign, not U+22C5 dot operator).
|
||
#[test]
|
||
fn symbol_unicode_table_covers_the_adobe_encoding() {
|
||
// (code, real Unicode) from unicode.org/Public/MAPPINGS/VENDORS/ADOBE/symbol.txt.
|
||
// Only the non-ASCII, non-CUS entries; ASCII codes pass through as themselves and CUS fragment
|
||
// glyphs have no standard Unicode point, so `symbol_unicode` returns None for them.
|
||
let table: &[(u32, u32)] = &[
|
||
// 0x20–0x7E: the few mathematical ones among the ASCII-range characters.
|
||
(0x22, 0x2200),
|
||
(0x24, 0x2203),
|
||
(0x27, 0x220B),
|
||
(0x2A, 0x2217),
|
||
(0x2D, 0x2212),
|
||
(0x40, 0x2245),
|
||
(0x5C, 0x2234),
|
||
(0x5E, 0x22A5),
|
||
(0x7E, 0x223C),
|
||
// 0x41–0x5A: Greek uppercase.
|
||
(0x41, 0x0391),
|
||
(0x42, 0x0392),
|
||
(0x43, 0x03A7),
|
||
(0x44, 0x0394),
|
||
(0x45, 0x0395),
|
||
(0x46, 0x03A6),
|
||
(0x47, 0x0393),
|
||
(0x48, 0x0397),
|
||
(0x49, 0x0399),
|
||
(0x4A, 0x03D1),
|
||
(0x4B, 0x039A),
|
||
(0x4C, 0x039B),
|
||
(0x4D, 0x039C),
|
||
(0x4E, 0x039D),
|
||
(0x4F, 0x039F),
|
||
(0x50, 0x03A0),
|
||
(0x51, 0x0398),
|
||
(0x52, 0x03A1),
|
||
(0x53, 0x03A3),
|
||
(0x54, 0x03A4),
|
||
(0x55, 0x03A5),
|
||
(0x56, 0x03C2),
|
||
(0x57, 0x03A9),
|
||
(0x58, 0x039E),
|
||
(0x59, 0x03A8),
|
||
(0x5A, 0x0396),
|
||
// 0x61–0x7A: Greek lowercase.
|
||
(0x61, 0x03B1),
|
||
(0x62, 0x03B2),
|
||
(0x63, 0x03C7),
|
||
(0x64, 0x03B4),
|
||
(0x65, 0x03B5),
|
||
(0x66, 0x03C6),
|
||
(0x67, 0x03B3),
|
||
(0x68, 0x03B7),
|
||
(0x69, 0x03B9),
|
||
(0x6A, 0x03D5),
|
||
(0x6B, 0x03BA),
|
||
(0x6C, 0x03BB),
|
||
(0x6D, 0x03BC),
|
||
(0x6E, 0x03BD),
|
||
(0x6F, 0x03BF),
|
||
(0x70, 0x03C0),
|
||
(0x71, 0x03B8),
|
||
(0x72, 0x03C1),
|
||
(0x73, 0x03C3),
|
||
(0x74, 0x03C4),
|
||
(0x75, 0x03C5),
|
||
(0x76, 0x03D6),
|
||
(0x77, 0x03C9),
|
||
(0x78, 0x03BE),
|
||
(0x79, 0x03C8),
|
||
(0x7A, 0x03B6),
|
||
// 0xA0–0xAF: euro, Greek upsilon with hook, primes, math, suits and arrows.
|
||
(0xA0, 0x20AC),
|
||
(0xA1, 0x03D2),
|
||
(0xA2, 0x2032),
|
||
(0xA3, 0x2264),
|
||
(0xA4, 0x2215),
|
||
(0xA5, 0x221E),
|
||
(0xA6, 0x0192),
|
||
(0xA7, 0x2663),
|
||
(0xA8, 0x2666),
|
||
(0xA9, 0x2665),
|
||
(0xAA, 0x2660),
|
||
(0xAB, 0x2194),
|
||
(0xAC, 0x2190),
|
||
(0xAD, 0x2191),
|
||
(0xAE, 0x2192),
|
||
(0xAF, 0x2193),
|
||
// 0xB0–0xBC: degree, plus-minus, double prime, math and ellipsis.
|
||
(0xB0, 0x00B0),
|
||
(0xB1, 0x00B1),
|
||
(0xB2, 0x2033),
|
||
(0xB3, 0x2265),
|
||
(0xB4, 0x00D7),
|
||
(0xB5, 0x221D),
|
||
(0xB6, 0x2202),
|
||
(0xB7, 0x2022),
|
||
(0xB8, 0x00F7),
|
||
(0xB9, 0x2260),
|
||
(0xBA, 0x2261),
|
||
(0xBB, 0x2248),
|
||
(0xBC, 0x2026),
|
||
(0xBF, 0x21B5),
|
||
// 0xC0–0xCF: letterlike symbols, set relations.
|
||
(0xC0, 0x2135),
|
||
(0xC1, 0x2111),
|
||
(0xC2, 0x211C),
|
||
(0xC3, 0x2118),
|
||
(0xC4, 0x2297),
|
||
(0xC5, 0x2295),
|
||
(0xC6, 0x2205),
|
||
(0xC7, 0x2229),
|
||
(0xC8, 0x222A),
|
||
(0xC9, 0x2283),
|
||
(0xCA, 0x2287),
|
||
(0xCB, 0x2284),
|
||
(0xCC, 0x2282),
|
||
(0xCD, 0x2286),
|
||
(0xCE, 0x2208),
|
||
(0xCF, 0x2209),
|
||
// 0xD0–0xDF: angle, nabla, product, radical, not, ands, ors, double arrows.
|
||
(0xD0, 0x2220),
|
||
(0xD1, 0x2207),
|
||
(0xD5, 0x220F),
|
||
(0xD6, 0x221A),
|
||
(0xD7, 0x22C5),
|
||
(0xD8, 0x00AC),
|
||
(0xD9, 0x2227),
|
||
(0xDA, 0x2228),
|
||
(0xDB, 0x21D4),
|
||
(0xDC, 0x21D0),
|
||
(0xDD, 0x21D1),
|
||
(0xDE, 0x21D2),
|
||
(0xDF, 0x21D3),
|
||
// 0xE0–0xF5: lozenge, angle brackets, summation, integral.
|
||
(0xE0, 0x25CA),
|
||
(0xE1, 0x2329),
|
||
(0xE5, 0x2211),
|
||
(0xF1, 0x232A),
|
||
(0xF2, 0x222B),
|
||
(0xF3, 0x2320),
|
||
(0xF5, 0x2321),
|
||
];
|
||
for &(code, uni) in table {
|
||
assert_eq!(symbol_unicode(code), Some(uni), "Symbol code 0x{code:02X} must map to U+{uni:04X}");
|
||
}
|
||
// ASCII codes pass through as themselves (symbol_unicode has no entry), and the CUS fragment
|
||
// codes return None: 0x60 radical extender, 0xBD/0xBE arrow extenders, 0xD2–0xD4 serif marks,
|
||
// 0xE2–0xE4 sans-serif marks and the paren/bracket extender run 0xE6–0xFF.
|
||
for code in [
|
||
0x20, 0x21, 0x23, 0x25, 0x26, 0x28, 0x29, 0x2B, 0x2C, 0x2E, 0x2F, 0x30, 0x31, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F, 0x5B, 0x5D, 0x5F,
|
||
0x7B, 0x7C, 0x7D,
|
||
] {
|
||
assert_eq!(symbol_unicode(code), None, "ASCII code 0x{code:02X} has no Symbol remap");
|
||
}
|
||
for code in [
|
||
0x60, 0xBD, 0xBE, 0xD2, 0xD3, 0xD4, 0xE2, 0xE3, 0xE4, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF, 0xF0, 0xF4, 0xF6, 0xF7,
|
||
0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF,
|
||
] {
|
||
assert_eq!(symbol_unicode(code), None, "CUS code 0x{code:02X} has no standard Unicode remap");
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn symbol_font_characters_draw_in_the_sym_font() {
|
||
// PowerPoint stores a Symbol-font character as U+F0xx with `<a:sym typeface="Symbol"/>`:
|
||
// U+F0DE is the Symbol font's double arrow (⇒). It must come from that font, not from
|
||
// whichever installed font happens to map U+F0DE (Wingdings draws an arrow at another angle).
|
||
let symbol = "Symbol";
|
||
let db = FontDb::global();
|
||
// The installed Symbol face draws the code either at the private-use U+F0DE or, when it has no
|
||
// private-use mapping (Apple's Symbol on macOS maps glyphs to real Unicode), at the real
|
||
// character the Symbol font stores the code at. Skip only if neither is covered.
|
||
if !db.has_family(symbol) || !covers_symbol(&db.face(symbol, "Regular"), '\u{F0DE}') {
|
||
eprintln!("skipped: no installed Symbol face draws U+F0DE");
|
||
return;
|
||
}
|
||
let (p, mut sh) = setup("x\u{F0DE}y", 600.0, 300.0);
|
||
let para = &mut sh.text.as_mut().unwrap().paragraphs[0];
|
||
para.props.bullet = Some(Bullet::None);
|
||
para.runs[0].props.font = Some("Arial".into());
|
||
para.runs[0].props.font_sym = Some(symbol.into());
|
||
let l = lay(&p, &sh, 600.0, 300.0);
|
||
let families: Vec<(String, (usize, usize))> = l.runs.iter().map(|r| (r.face.family.clone(), r.chars)).collect();
|
||
assert!(families.iter().any(|(f, c)| f.eq_ignore_ascii_case(symbol) && c.0 == 1), "{families:?}");
|
||
// The letters around it keep the run's font.
|
||
assert!(families.iter().all(|(f, c)| c.0 == 1 || !f.eq_ignore_ascii_case(symbol)), "{families:?}");
|
||
}
|
||
|
||
#[test]
|
||
fn small_capitals_draw_smaller_than_the_capitals_beside_them() {
|
||
let (p, mut sh) = setup("HxHx", 2000.0, 300.0);
|
||
let para = &mut sh.text.as_mut().unwrap().paragraphs[0];
|
||
para.props.bullet = Some(Bullet::None);
|
||
para.runs[0].props.caps = Some(Caps::Small);
|
||
para.runs[0].props.size = Some(40.0);
|
||
let l = lay(&p, &sh, 2000.0, 300.0);
|
||
let sizes: Vec<(usize, f64)> = l.runs.iter().map(|r| (r.glyphs.len(), r.size)).collect();
|
||
// H at 40 pt, x as a capital at 80 % (four runs: the size changes at every letter).
|
||
assert_eq!(sizes, vec![(1, 40.0), (1, 32.0), (1, 40.0), (1, 32.0)]);
|
||
}
|
||
|
||
#[test]
|
||
fn capitals_keep_characters_whose_capital_is_a_sequence() {
|
||
assert_eq!(caps_char('a'), 'A');
|
||
assert_eq!(caps_char('dž'), 'DŽ');
|
||
// PowerPoint draws "ß", "fi" and "ʼn" unchanged in all caps.
|
||
assert_eq!(caps_char('ß'), 'ß');
|
||
assert_eq!(caps_char('\u{FB01}'), '\u{FB01}');
|
||
assert_eq!(caps_char('ʼn'), 'ʼn');
|
||
let (p, mut sh) = setup("aß", 2000.0, 300.0);
|
||
let para = &mut sh.text.as_mut().unwrap().paragraphs[0];
|
||
para.runs[0].props.caps = Some(Caps::All);
|
||
let l = lay(&p, &sh, 2000.0, 300.0);
|
||
let r = l.runs.iter().find(|r| !r.cells.is_empty()).unwrap();
|
||
let face = &r.face;
|
||
if face.covers('ß') {
|
||
assert_eq!(r.glyphs[1].0, face.glyph_for('ß'), "ß is not drawn as S");
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn transparent_text_is_faded_once() {
|
||
let (p, mut sh) = setup("Faded", 2000.0, 300.0);
|
||
let run = &mut sh.text.as_mut().unwrap().paragraphs[0].runs[0];
|
||
run.props.fill = Some(deckcraft_model::Fill::solid(
|
||
deckcraft_model::ColorRef::rgb(deckcraft_color::Rgba::rgb(255, 0, 0)).with(deckcraft_color::ColorTransform::Alpha(40000)),
|
||
));
|
||
let l = lay(&p, &sh, 2000.0, 300.0);
|
||
let r = l.runs.iter().find(|r| !r.cells.is_empty()).unwrap();
|
||
// 60 % transparency: 40 % opaque in all, not 40 % of 40 %.
|
||
let opacity = r.color.a as f64 / 255.0 * r.alpha;
|
||
assert!((opacity - 0.4).abs() < 0.01, "{opacity}");
|
||
}
|
||
|
||
/// One paragraph `text` with tab stops `tabs` (position, `algn`), no bullet or indent.
|
||
fn tabbed(text: &str, tabs: &[(f64, &str)], w: f64) -> TextLayout {
|
||
let (p, mut sh) = setup(text, w, 300.0);
|
||
let para = &mut sh.text.as_mut().unwrap().paragraphs[0];
|
||
for r in &mut para.runs {
|
||
r.props.size = Some(18.0);
|
||
}
|
||
let pp = &mut para.props;
|
||
pp.bullet = Some(Bullet::None);
|
||
pp.margin_left = Some(0.0);
|
||
pp.indent = Some(0.0);
|
||
pp.default_tab = Some(72.0);
|
||
pp.tabs = Some(tabs.iter().map(|(pos, a)| deckcraft_model::text::TabStop { pos: *pos, align: a.to_string() }).collect());
|
||
lay(&p, &sh, w, 300.0)
|
||
}
|
||
|
||
#[test]
|
||
fn tab_stops_align_the_text_after_them() {
|
||
let x0 = |l: &TextLayout| l.inner.x0;
|
||
// Right: the text ends at the stop. Centre: centred on it. Decimal: the "." at the stop.
|
||
let l = tabbed("a\tright", &[(200.0, "r")], 600.0);
|
||
assert!((l.lines[0].extent.1 - x0(&l) - 200.0).abs() < 0.01, "{:?}", l.lines[0].extent);
|
||
let l = tabbed("a\tmid", &[(200.0, "ctr")], 600.0);
|
||
let (s, e) = (l.lines[0].edges[2].0, l.lines[0].edges[4].1);
|
||
assert!(((s + e) / 2.0 - x0(&l) - 200.0).abs() < 0.01);
|
||
let l = tabbed("x\t1234.567", &[(150.0, "dec")], 600.0);
|
||
assert!((l.lines[0].edges[6].0 - x0(&l) - 150.0).abs() < 0.01, "the point sits at the stop");
|
||
// Text without a point ends at a decimal stop.
|
||
let l = tabbed("x\t12,5", &[(150.0, "dec")], 600.0);
|
||
assert!((l.lines[0].extent.1 - x0(&l) - 150.0).abs() < 0.01);
|
||
// Text wider than the room before a right stop starts where the tab is; it never moves back.
|
||
let l = tabbed("x\twider than the gap", &[(20.0, "r")], 600.0);
|
||
assert!((l.lines[0].edges[2].0 - l.lines[0].edges[0].1).abs() < 0.01);
|
||
// A left stop and then default stops every 72 pt.
|
||
let l = tabbed("a\tb\tc", &[(30.0, "l")], 600.0);
|
||
assert!((l.lines[0].edges[2].0 - x0(&l) - 30.0).abs() < 0.01);
|
||
assert!((l.lines[0].edges[4].0 - x0(&l) - 72.0).abs() < 0.01);
|
||
}
|
||
|
||
#[test]
|
||
fn a_tab_past_the_end_moves_to_the_next_line() {
|
||
// PowerPoint: "abcdefghij\tk\tl\tm…" in a narrow box puts the tab that doesn't fit on the next
|
||
// line, so the text after it lands on that line's first stop.
|
||
let l = tabbed("abcdefghij\tk", &[], 130.0);
|
||
assert_eq!(l.lines.len(), 2);
|
||
assert_eq!(l.lines[1].start, 10, "the tab starts the second line: {:?}", l.lines.iter().map(|x| (x.start, x.end, x.extent)).collect::<Vec<_>>());
|
||
assert!((l.lines[1].edges[1].0 - l.inner.x0 - 72.0).abs() < 0.01);
|
||
}
|
||
|
||
/// Underline decorations of "ab cd" underlined `u` at 40 pt.
|
||
fn underline_decos(u: &str) -> (TextLayout, Vec<Deco>) {
|
||
let (p, mut sh) = setup("ab cd", 2000.0, 300.0);
|
||
let para = &mut sh.text.as_mut().unwrap().paragraphs[0];
|
||
para.props.bullet = Some(Bullet::None);
|
||
para.runs[0].props.size = Some(40.0);
|
||
para.runs[0].props.underline = Some(u.into());
|
||
let l = lay(&p, &sh, 2000.0, 300.0);
|
||
let d = l.decos.iter().filter(|d| !d.behind).cloned().collect();
|
||
(l, d)
|
||
}
|
||
|
||
#[test]
|
||
fn underlines_sit_at_the_font_underline_in_their_style() {
|
||
let (l, sng) = underline_decos("sng");
|
||
let r = l.runs.iter().find(|r| !r.cells.is_empty()).unwrap();
|
||
let k = 40.0 / r.face.upem;
|
||
let base = l.lines[0].baseline;
|
||
assert_eq!(sng.len(), 1);
|
||
assert!((sng[0].rect.y0 - base - r.face.underline.0 * k).abs() < 0.01, "top at the font's underline position");
|
||
assert!((sng[0].rect.height() - (r.face.underline.1 * k).max(0.5)).abs() < 0.01);
|
||
let t = sng[0].rect.height();
|
||
// Double: two thin lines spanning from one thickness above the single line to its bottom.
|
||
let (_, dbl) = underline_decos("dbl");
|
||
assert_eq!(dbl.len(), 2);
|
||
assert!((dbl[0].rect.y0 - (sng[0].rect.y0 - t)).abs() < 0.01 && (dbl[1].rect.y1 - sng[0].rect.y1).abs() < 0.01);
|
||
// Heavy is thicker; dotted is dots as long as the line is thick.
|
||
let (_, heavy) = underline_decos("heavy");
|
||
assert!(heavy[0].rect.height() > t * 1.4);
|
||
let (_, dotted) = underline_decos("dotted");
|
||
assert_eq!(dotted[0].line, DecoLine::Dashed(Dash::Dot));
|
||
let pieces = dotted[0].pieces();
|
||
assert!(pieces.len() > 3);
|
||
assert!((pieces[0].width() - t).abs() < 0.01 && (pieces[1].x0 - pieces[0].x1 - t).abs() < 0.01);
|
||
// Wavy: a zigzag between the box's top and bottom.
|
||
let (_, wavy) = underline_decos("wavy");
|
||
let (pts, w) = wavy[0].wave().expect("a wave");
|
||
assert!(pts.len() > 4 && w > 0.0 && w < t);
|
||
assert!(pts[0].y < pts[1].y);
|
||
// "words" underlines the spaces too, as PowerPoint draws it: one line.
|
||
let (_, words) = underline_decos("words");
|
||
assert_eq!(words.len(), 1);
|
||
}
|
||
|
||
#[test]
|
||
fn no_break_after_a_zero_width_space_or_before_an_em_dash() {
|
||
let (allowed, _) = break_opportunities("ab\u{200B}cd", false);
|
||
assert!(!allowed[3], "PowerPoint does not break after a zero-width space");
|
||
let (allowed, _) = break_opportunities("ab\u{2014}cd", false);
|
||
assert!(!allowed[2] && allowed[3], "an em dash ends a line, never starts one");
|
||
}
|
||
|
||
#[test]
|
||
fn a_line_broken_at_a_soft_hyphen_shows_a_hyphen() {
|
||
let (p, mut sh) = setup("Soft\u{AD}hyphenated\u{AD}words", 150.0, 300.0);
|
||
let para = &mut sh.text.as_mut().unwrap().paragraphs[0];
|
||
para.props.bullet = Some(Bullet::None);
|
||
para.runs[0].props.size = Some(24.0);
|
||
let l = lay(&p, &sh, 150.0, 300.0);
|
||
assert!(l.lines.len() >= 2);
|
||
let first = &l.lines[0];
|
||
let shy = first.end - 1;
|
||
assert_eq!(first.end, 5, "breaks after the soft hyphen: {:?}", l.lines.iter().map(|x| (x.start, x.end)).collect::<Vec<_>>());
|
||
let (x0, x1) = first.edges[shy - first.start];
|
||
assert!(x1 - x0 > 2.0, "the hyphen takes room");
|
||
let r = l.runs.iter().find(|r| r.cells.iter().any(|c| c.0 == shy)).expect("a glyph for the soft hyphen");
|
||
assert_eq!(r.glyphs[r.cells.iter().position(|c| c.0 == shy).unwrap()].0, r.face.glyph_for('-'));
|
||
// Soft hyphens draw only where a line ends; in a wide box, nowhere.
|
||
let ends: Vec<usize> = l.lines.iter().map(|x| x.end.saturating_sub(1)).collect();
|
||
for r in &l.runs {
|
||
for (g, c) in r.glyphs.iter().zip(&r.cells) {
|
||
assert!(c.1 != '\u{AD}' || ends.contains(&c.0) || g.0 != r.face.glyph_for('-'), "mid-line soft hyphen drawn");
|
||
}
|
||
}
|
||
let wide = lay(&p, &sh, 2000.0, 300.0);
|
||
assert_eq!(wide.lines.len(), 1);
|
||
assert!(wide.runs.iter().all(|r| r.cells.iter().all(|c| c.1 != '\u{AD}' || r.glyphs.iter().all(|g| g.0 != r.face.glyph_for('-')))));
|
||
}
|
||
|
||
#[test]
|
||
fn small_kana_and_closing_brackets_follow_powerpoint_kinsoku() {
|
||
// "っ" and "ー" never start a line: the character before them moves down too.
|
||
let w = one_line("あいうえお") + 0.5;
|
||
for (text, first) in [("あいうえおっかき", "あいうえ"), ("あいうえおーかき", "あいうえ"), ("あいうえおかき", "あいうえお")]
|
||
{
|
||
let lines = wrapped(text, w, |p| p.hanging_punct = Some(true));
|
||
assert_eq!(lines[0], first, "{text}: {lines:?}");
|
||
}
|
||
// A closing bracket doesn't hang like "。" does: "「。」" overflowing by "」" moves down whole.
|
||
let w = one_line("あいうえ「。") + 0.5;
|
||
let lines = wrapped("あいうえ「。」かき", w, |p| p.hanging_punct = Some(true));
|
||
assert_eq!(lines[0], "あいうえ", "{lines:?}");
|
||
}
|
||
|
||
#[test]
|
||
fn autonumber_schemes_follow_powerpoint() {
|
||
// As PowerPoint's export draws them (start values as in the probe deck).
|
||
for (scheme, n, want) in [
|
||
("ea1ChsPlain", 4, "四"),
|
||
("ea1ChsPeriod", 10, "十．"),
|
||
("ea1ChtPeriod", 21, "二十一．"),
|
||
("ea1JpnKorPeriod", 10, "一〇．"),
|
||
("ea1JpnChsDbPeriod", 13, "一三．"),
|
||
("arabicDbPlain", 10, "１０"),
|
||
("arabicDbPeriod", 13, "１３．"),
|
||
("circleNumDbPlain", 13, "⑬"),
|
||
("circleNumWdWhitePlain", 13, "③"),
|
||
("circleNumWdBlackPlain", 2, "❷"),
|
||
("thaiAlphaPeriod", 1, "ก."),
|
||
("thaiAlphaParenR", 4, "ง)"),
|
||
("thaiAlphaParenBoth", 7, "(ช)"),
|
||
("thaiNumPeriod", 10, "๑๐."),
|
||
("hindiAlphaPeriod", 4, "ई."),
|
||
("hindiAlpha1Period", 1, "क."),
|
||
("hindiNumParenR", 13, "१३)"),
|
||
("hebrew2Minus", 1, "א-"),
|
||
("arabic1Minus", 13, "ش-"),
|
||
("arabic2Minus", 10, "ي-"),
|
||
("arabicPlain", 10, "10"),
|
||
] {
|
||
assert_eq!(autonum(scheme, n), want, "{scheme} {n}");
|
||
}
|
||
assert_eq!(chinese_num(105), "一百零五");
|
||
assert_eq!(chinese_num(20), "二十");
|
||
// Past the end of an alphabet the letter doubles, like "aa".
|
||
assert_eq!(autonum("hebrew2Minus", 23), "אא-");
|
||
assert_eq!(autonum("thaiAlphaPeriod", 0), ".");
|
||
}
|
||
|
||
#[test]
|
||
fn east_asian_vertical_text_marks_cjk_upright() {
|
||
let (p, mut sh) = setup("日本、ABC 12", 300.0, 600.0);
|
||
sh.text.as_mut().unwrap().body.vert = Some(deckcraft_model::text::TextDir::EaVertical);
|
||
let l = lay(&p, &sh, 300.0, 600.0);
|
||
assert_eq!(l.rotation, 90.0);
|
||
let upright: Vec<bool> = l
|
||
.runs
|
||
.iter()
|
||
.filter(|r| !r.cells.is_empty())
|
||
.flat_map(|r| r.cells.iter().map(move |c| (c.1, r.upright)))
|
||
.filter(|(c, _)| *c != ' ')
|
||
.map(|(_, u)| u)
|
||
.collect();
|
||
assert_eq!(upright, vec![true, true, true, false, false, false, false, false]);
|
||
// In vert nothing stands upright.
|
||
sh.text.as_mut().unwrap().body.vert = Some(deckcraft_model::text::TextDir::Vertical);
|
||
let l = lay(&p, &sh, 300.0, 600.0);
|
||
assert!(l.runs.iter().all(|r| !r.upright));
|
||
assert!(is_upright('あ') && is_upright('、') && is_upright('Ａ') && !is_upright('A') && !is_upright('1'));
|
||
}
|
||
|
||
#[test]
|
||
fn mongolian_lines_run_left_to_right_and_stacked_letters_stand_one_em_apart() {
|
||
let (p, mut sh) = setup("one\ntwo", 200.0, 400.0);
|
||
sh.text.as_mut().unwrap().body.vert = Some(deckcraft_model::text::TextDir::Vertical);
|
||
let v = lay(&p, &sh, 200.0, 400.0);
|
||
sh.text.as_mut().unwrap().body.vert = Some(deckcraft_model::text::TextDir::MongolianVertical);
|
||
let m = lay(&p, &sh, 200.0, 400.0);
|
||
assert_eq!(m.rotation, 90.0);
|
||
// In layout space (turned a quarter turn) vert puts the first line at the top, which shows on
|
||
// the right; mongolianVert mirrors the line places, so the first line shows on the left.
|
||
assert!(v.lines[0].top < v.lines[1].top);
|
||
assert!(m.lines[0].top > m.lines[1].top);
|
||
let mid = (m.inner.y0 + m.inner.y1) / 2.0;
|
||
assert!(((m.lines[0].top + m.lines[0].bottom) / 2.0 - mid + ((v.lines[0].top + v.lines[0].bottom) / 2.0 - mid)).abs() < 0.01);
|
||
// Stacked: every letter upright, one em apart.
|
||
let (p, mut sh) = setup("Lil", 200.0, 400.0);
|
||
let t = sh.text.as_mut().unwrap();
|
||
t.body.vert = Some(deckcraft_model::text::TextDir::Stacked);
|
||
t.paragraphs[0].runs[0].props.size = Some(20.0);
|
||
let s = lay(&p, &sh, 200.0, 400.0);
|
||
assert!(s.runs.iter().filter(|r| !r.cells.is_empty()).all(|r| r.upright));
|
||
// Its lines run left to right too.
|
||
let (p2, mut sh2) = setup("one\ntwo", 200.0, 400.0);
|
||
sh2.text.as_mut().unwrap().body.vert = Some(deckcraft_model::text::TextDir::Stacked);
|
||
let st = lay(&p2, &sh2, 200.0, 400.0);
|
||
assert!(st.lines[0].top > st.lines[1].top);
|
||
// wordArtVertRtl stacks the same way with lines from right to left.
|
||
sh2.text.as_mut().unwrap().body.vert = Some(deckcraft_model::text::TextDir::StackedRtl);
|
||
let sr = lay(&p2, &sh2, 200.0, 400.0);
|
||
assert!(sr.lines[0].top < sr.lines[1].top);
|
||
assert!(sr.runs.iter().filter(|r| !r.cells.is_empty()).all(|r| r.upright));
|
||
let e = &s.lines[0].edges;
|
||
assert!((e[1].1 - e[1].0 - 20.0).abs() < 0.01 && (e[2].1 - e[2].0 - 20.0).abs() < 0.01, "{e:?}");
|
||
}
|
||
|
||
#[test]
|
||
fn symbols_after_an_emoji_keep_a_text_face() {
|
||
// "✅ ⚠ ™": PowerPoint draws ✅ (emoji presentation) in colour and the symbols after it as text.
|
||
let db = FontDb::global();
|
||
if !db.cascade(&['✅'], &[], "Regular").is_color() {
|
||
return;
|
||
}
|
||
let (p, sh) = bidi_setup(vec![Run::new("✅ ⚠ ™")], 2000.0, false, Align::Left);
|
||
let l = lay(&p, &sh, 2000.0, 300.0);
|
||
for r in &l.runs {
|
||
for (_, c) in &r.cells {
|
||
assert_eq!(r.face.is_color(), *c == '✅', "{c:?} drawn with {}", r.face.family);
|
||
}
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn fallback_faces_do_not_move_the_baseline() {
|
||
// PowerPoint keeps a line's baseline and pitch from the run's own font when an emoji, a symbol
|
||
// or a script the font lacks is drawn from another face.
|
||
let base = |text: &str| {
|
||
let (p, sh) = bidi_setup(vec![Run::new(text)], 2000.0, false, Align::Left);
|
||
let l = lay(&p, &sh, 2000.0, 300.0);
|
||
(l.lines[0].baseline, l.lines[0].bottom)
|
||
};
|
||
let plain = base("Hxg Hxg");
|
||
for text in ["Hxg \u{1F600} Hxg", "Hxg \u{0E2A}\u{0E27}\u{0E31}\u{0E2A}", "Hxg \u{222B}\u{2211}"] {
|
||
let b = base(text);
|
||
assert!((b.0 - plain.0).abs() < 0.01 && (b.1 - plain.1).abs() < 0.01, "{text:?}: {b:?} vs {plain:?}");
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn strikethrough_sits_at_the_font_strikeout_position() {
|
||
let (p, mut sh) = setup("Struck", 2000.0, 300.0);
|
||
let para = &mut sh.text.as_mut().unwrap().paragraphs[0];
|
||
para.props.bullet = Some(Bullet::None);
|
||
para.runs[0].props.size = Some(96.0);
|
||
para.runs[0].props.strike = Some(Strike::Single);
|
||
let l = lay(&p, &sh, 2000.0, 300.0);
|
||
let r = l.runs.iter().find(|r| !r.cells.is_empty()).unwrap();
|
||
let k = 96.0 / r.face.upem;
|
||
let d = l.decos.iter().find(|d| !d.behind).expect("a strikethrough");
|
||
assert!((l.lines[0].baseline - d.rect.y0 - r.face.strikeout.0 * k).abs() < 0.01, "top at the strikeout position");
|
||
assert!((d.rect.height() - (r.face.strikeout.1 * k).max(0.5)).abs() < 0.01);
|
||
}
|
||
|
||
#[test]
|
||
fn rtl_columns_start_on_the_right_and_just_anchoring_sits_at_the_bottom() {
|
||
let text = "word ".repeat(200);
|
||
let (p, mut sh) = setup(&text, 400.0, 200.0);
|
||
let t = sh.text.as_mut().unwrap();
|
||
t.body.columns = Some(2);
|
||
t.body.col_spacing = Some(20.0);
|
||
t.paragraphs[0].runs[0].props.size = Some(12.0);
|
||
let ltr = lay(&p, &sh, 400.0, 200.0);
|
||
sh.text.as_mut().unwrap().body.rtl_col = Some(true);
|
||
let rtl = lay(&p, &sh, 400.0, 200.0);
|
||
let first = |l: &TextLayout| l.lines.iter().find(|x| x.column == 0).map(|x| x.extent.0).unwrap();
|
||
let second = |l: &TextLayout| l.lines.iter().find(|x| x.column == 1).map(|x| x.extent.0).unwrap();
|
||
assert!(first(<r) < second(<r));
|
||
assert!(first(&rtl) > second(&rtl), "with rtlCol the first column is on the right");
|
||
// anchor="just" and "dist" draw like "b".
|
||
let (p, mut sh) = setup("one line", 400.0, 300.0);
|
||
sh.text.as_mut().unwrap().body.anchor = Some(Anchor::Bottom);
|
||
let b = lay(&p, &sh, 400.0, 300.0).lines[0].top;
|
||
for a in [Anchor::Justified, Anchor::Distributed] {
|
||
sh.text.as_mut().unwrap().body.anchor = Some(a);
|
||
assert!((lay(&p, &sh, 400.0, 300.0).lines[0].top - b).abs() < 0.01, "{a:?}");
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn stacked_combining_marks_take_a_face_that_draws_them() {
|
||
// A letter with marks the run's font lacks draws in a face that has them all (no boxes).
|
||
let db = FontDb::global();
|
||
let cluster = ['Z', '\u{0334}', '\u{0321}', '\u{031B}'];
|
||
let run_face = db.face("Inter", "Regular");
|
||
let f = db.cascade(&cluster, std::slice::from_ref(&run_face), "Regular");
|
||
if !deckcraft_fonts::covers_cluster(&run_face, &cluster) && ["DejaVu Sans", "Segoe UI"].iter().any(|fam| db.has_family(fam)) {
|
||
// Make sure a face with the marks is loaded, then the cluster must take one.
|
||
for fam in ["DejaVu Sans", "Segoe UI"] {
|
||
if db.has_family(fam) {
|
||
let _ = db.face(fam, "Regular");
|
||
}
|
||
}
|
||
let f = db.cascade(&cluster, std::slice::from_ref(&run_face), "Regular");
|
||
assert!(deckcraft_fonts::covers_cluster(&f, &cluster), "{} lacks the marks", f.family);
|
||
}
|
||
let _ = f;
|
||
}
|
||
|
||
/// #736: `anchorCtr` centres the text block horizontally, whatever the paragraphs' own
|
||
/// alignment, and overflowing content centres symmetrically past both edges.
|
||
#[test]
|
||
fn anchorctr_centres_the_text_block() {
|
||
let text = "The shape is top - center - overriding paragraph right alignment.";
|
||
// The block's centre: (min left + max right) over the laid-out lines, in box coordinates.
|
||
let block_centre = |l: &TextLayout| -> f64 {
|
||
// Empty lines carry no ink and sit where their alignment left them: not part of the block.
|
||
let ink = l.lines.iter().filter(|li| li.end > li.start);
|
||
let (min, max) = ink.fold((f64::INFINITY, f64::NEG_INFINITY), |(a, b), li| (a.min(li.extent.0), b.max(li.extent.1)));
|
||
(min + max) / 2.0
|
||
};
|
||
let para = |align: Option<Align>, text: &str| Paragraph {
|
||
props: ParaProps { align, ..Default::default() },
|
||
runs: vec![Run::new(text)],
|
||
..Default::default()
|
||
};
|
||
let anchored =
|
||
|paragraphs: Vec<Paragraph>| TextBody { body: BodyProps { anchor_ctr: Some(true), ..Default::default() }, paragraphs, ..Default::default() };
|
||
// One right-aligned line in a wide box: the block is centred, not pushed past the right edge.
|
||
let body_right = anchored(vec![para(Some(Align::Right), text)]);
|
||
let (p, mut sh) = setup("", 828.0, 104.0);
|
||
sh.text = Some(body_right);
|
||
let l = lay(&p, &sh, 828.0, 104.0);
|
||
assert!((block_centre(&l) - 414.0).abs() <= 1.0, "right-aligned: centre {}, want 414", block_centre(&l));
|
||
// Left-aligned text centres the same way.
|
||
let body_left = anchored(vec![para(None, text)]);
|
||
let (p, mut sh) = setup("", 828.0, 104.0);
|
||
sh.text = Some(body_left);
|
||
let l = lay(&p, &sh, 828.0, 104.0);
|
||
assert!((block_centre(&l) - 414.0).abs() <= 1.0, "left-aligned: centre {}, want 414", block_centre(&l));
|
||
// A trailing empty paragraph carries no ink and must not skew the block.
|
||
let body_empty = anchored(vec![para(Some(Align::Right), text), para(None, "")]);
|
||
let (p, mut sh) = setup("", 828.0, 104.0);
|
||
sh.text = Some(body_empty);
|
||
let l = lay(&p, &sh, 828.0, 104.0);
|
||
assert!((block_centre(&l) - 414.0).abs() <= 1.0, "trailing empty paragraph: centre {}, want 414", block_centre(&l));
|
||
// Mixed alignments: the drawn block (not either alignment edge) is what centres.
|
||
let body_mixed = anchored(vec![para(Some(Align::Right), text), para(None, "short")]);
|
||
let (p, mut sh) = setup("", 828.0, 104.0);
|
||
sh.text = Some(body_mixed);
|
||
let l = lay(&p, &sh, 828.0, 104.0);
|
||
assert!((block_centre(&l) - 414.0).abs() <= 1.0, "mixed: centre {}, want 414", block_centre(&l));
|
||
// Content wider than the box overflows symmetrically past both edges (no wrap).
|
||
let body_wide = TextBody {
|
||
body: BodyProps { anchor_ctr: Some(true), wrap: Some(false), ..Default::default() },
|
||
paragraphs: vec![para(Some(Align::Right), text)],
|
||
..Default::default()
|
||
};
|
||
let (p, mut sh) = setup("", 300.0, 104.0);
|
||
sh.text = Some(body_wide);
|
||
let l = lay(&p, &sh, 300.0, 104.0);
|
||
assert!((block_centre(&l) - 150.0).abs() <= 2.0, "overflowing: centre {}, want 150", block_centre(&l));
|
||
// Control: without anchorCtr a right-aligned line still ends at the box's right edge.
|
||
let body_control = TextBody { body: BodyProps::default(), paragraphs: vec![para(Some(Align::Right), text)], ..Default::default() };
|
||
let (p, mut sh) = setup(text, 828.0, 104.0);
|
||
sh.text = Some(body_control);
|
||
let l = lay(&p, &sh, 828.0, 104.0);
|
||
assert!(
|
||
l.lines.iter().all(|li| li.extent.1 > 810.0),
|
||
"control: right-aligned at the box edge, got {:?}",
|
||
l.lines.iter().map(|li| li.extent).collect::<Vec<_>>()
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn empty_bullets_reserve_the_typed_indent_without_becoming_content() {
|
||
for rtl in [false, true] {
|
||
for level in [0, 1, 2] {
|
||
let (p, mut sh) = setup("First\n", 600.0, 300.0);
|
||
for para in &mut sh.text.as_mut().unwrap().paragraphs {
|
||
para.level = level;
|
||
para.props.rtl = Some(rtl);
|
||
para.props.align = Some(if rtl { Align::Right } else { Align::Left });
|
||
}
|
||
let empty = lay(&p, &sh, 600.0, 300.0);
|
||
assert_eq!(empty.empty_bullets.len(), 1);
|
||
assert_eq!(empty.empty_bullets[0].para, 1);
|
||
assert!(empty.runs.iter().all(|r| r.para == 0), "empty bullet must not be exported");
|
||
let caret = empty.caret(Pos { para: 1, ch: 0 }).unwrap();
|
||
let bx = empty.empty_bullets[0].glyphs[0].1;
|
||
assert!(if rtl { bx >= caret.0 } else { bx < caret.0 });
|
||
deckcraft_model::edit::insert(sh.text.as_mut().unwrap(), (1, 0), if rtl { "אבג" } else { "Next" }, None);
|
||
let typed = lay(&p, &sh, 600.0, 300.0);
|
||
assert!(typed.empty_bullets.is_empty());
|
||
let after = typed.caret(Pos { para: 1, ch: 0 }).unwrap();
|
||
assert!(
|
||
(caret.0 - after.0).abs() < 1e-6 && (caret.1 - after.1).abs() < 1e-6 && (caret.2 - after.2).abs() < 1e-6,
|
||
"typing must not move the line's start: {caret:?} vs {after:?}"
|
||
);
|
||
}
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn empty_numbered_paragraph_previews_the_next_number_without_consuming_it() {
|
||
let (p, mut sh) = setup("One\n\nTwo", 600.0, 300.0);
|
||
for para in &mut sh.text.as_mut().unwrap().paragraphs {
|
||
para.props.bullet = Some(Bullet::AutoNum { scheme: "arabicPeriod".into(), start_at: 4 });
|
||
}
|
||
let l = lay(&p, &sh, 600.0, 300.0);
|
||
let preview = &l.empty_bullets[0];
|
||
let next = l.runs.iter().find(|r| r.para == 2 && r.cells.is_empty()).unwrap();
|
||
let ids = |r: &GlyphRun| r.glyphs.iter().map(|g| g.0).collect::<Vec<_>>();
|
||
assert_eq!(preview.para, 1);
|
||
assert_eq!(ids(preview), ids(next), "both should use 5.");
|
||
let expected = measure_str(&preview.face, preview.size, "5.").1;
|
||
assert_eq!(ids(preview), expected.iter().map(|g| g.0).collect::<Vec<_>>());
|
||
}
|
||
|
||
#[test]
|
||
fn empty_plain_paragraphs_and_soft_breaks_have_no_bullet_preview() {
|
||
let (p, mut sh) = setup("", 600.0, 300.0);
|
||
sh.text.as_mut().unwrap().paragraphs[0].props.bullet = Some(Bullet::None);
|
||
assert!(lay(&p, &sh, 600.0, 300.0).empty_bullets.is_empty());
|
||
sh.text = Some(TextBody::from_text("First"));
|
||
deckcraft_model::edit::insert(sh.text.as_mut().unwrap(), (0, 5), "\u{b}", None);
|
||
let l = lay(&p, &sh, 600.0, 300.0);
|
||
assert_eq!(l.lines.len(), 2);
|
||
assert!(l.empty_bullets.is_empty(), "a soft line break is not a new list item");
|
||
}
|
||
|
||
/// A run of `text` at `size` points.
|
||
fn sized_run(text: &str, size: f64) -> Run {
|
||
let mut r = Run::new(text);
|
||
r.props.size = Some(size);
|
||
r
|
||
}
|
||
|
||
/// A line break whose own run properties are `size` points.
|
||
fn sized_break(size: f64) -> Run {
|
||
let mut r = Run { text: String::new(), props: Default::default(), kind: deckcraft_model::text::RunKind::Break };
|
||
r.props.size = Some(size);
|
||
r
|
||
}
|
||
|
||
/// The height one line of `size`-point text takes in this shape: the yardstick the empty-line
|
||
/// tests measure against, so they do not depend on the test font's ascent and descent.
|
||
fn one_line_height(p: &Presentation, sh: &mut Shape, size: f64) -> f64 {
|
||
sh.text.as_mut().unwrap().paragraphs = vec![Paragraph { runs: vec![sized_run("X", size)], ..Default::default() }];
|
||
let l = lay(p, sh, 400.0, 400.0);
|
||
l.lines[0].bottom - l.lines[0].top
|
||
}
|
||
|
||
#[test]
|
||
fn an_empty_line_is_sized_by_the_break_that_ends_it() {
|
||
// PowerPoint sizes an empty line by the mark that closes it, not by the paragraph's first
|
||
// run (#780). Case A of the report: 40pt text, a 40pt break, a 10pt break, 40pt text, so
|
||
// the empty second line is a 10pt line and not a 40pt one.
|
||
let (p, mut sh) = setup("x", 400.0, 400.0);
|
||
let (h10, h40, h60, h20) = (
|
||
one_line_height(&p, &mut sh, 10.0),
|
||
one_line_height(&p, &mut sh, 40.0),
|
||
one_line_height(&p, &mut sh, 60.0),
|
||
one_line_height(&p, &mut sh, 20.0),
|
||
);
|
||
let put = |sh: &mut Shape, runs: Vec<Run>| {
|
||
sh.text.as_mut().unwrap().paragraphs = vec![Paragraph { runs, ..Default::default() }];
|
||
};
|
||
|
||
put(&mut sh, vec![sized_run("A1", 40.0), sized_break(40.0), sized_break(10.0), sized_run("A2", 40.0)]);
|
||
let a = lay(&p, &sh, 400.0, 400.0);
|
||
assert_eq!(a.lines.len(), 3, "{:?}", a.lines.iter().map(|l| l.top).collect::<Vec<_>>());
|
||
let empty_a = a.lines[2].top - a.lines[1].top;
|
||
assert!((empty_a - h10).abs() < 0.5, "a 10pt break should give a 10pt line ({h10}), got {empty_a}");
|
||
assert!((empty_a - h40).abs() > 1.0, "and not the 40pt first run's line ({h40})");
|
||
|
||
// Case C: a 60pt break closing the empty line of a 20pt paragraph pushes the third line
|
||
// down, the opposite direction from the first run's size -- so this cannot pass by the old
|
||
// behaviour under a different font.
|
||
put(&mut sh, vec![sized_run("C1", 20.0), sized_break(20.0), sized_break(60.0), sized_run("C2", 20.0)]);
|
||
let c = lay(&p, &sh, 400.0, 400.0);
|
||
let empty_c = c.lines[2].top - c.lines[1].top;
|
||
assert!((empty_c - h60).abs() < 0.5, "a 60pt break should give a 60pt line ({h60}), got {empty_c}");
|
||
assert!((empty_c - h20).abs() > 1.0, "and not the 20pt first run's line ({h20})");
|
||
}
|
||
|
||
#[test]
|
||
fn an_empty_last_line_is_sized_by_the_paragraph_mark() {
|
||
// Case B: 40pt text and a trailing 40pt break, with the paragraph mark at 10pt. No break
|
||
// closes the empty last line, so it takes the mark's size.
|
||
let (p, mut sh) = setup("x", 400.0, 400.0);
|
||
let (h10, h40) = (one_line_height(&p, &mut sh, 10.0), one_line_height(&p, &mut sh, 40.0));
|
||
{
|
||
let t = sh.text.as_mut().unwrap();
|
||
let mut para = Paragraph { runs: vec![sized_run("B1", 40.0), sized_break(40.0)], ..Default::default() };
|
||
para.end_props.size = Some(10.0);
|
||
t.paragraphs = vec![para];
|
||
}
|
||
let l = lay(&p, &sh, 400.0, 400.0);
|
||
assert_eq!(l.lines.len(), 2, "the trailing break leaves an empty last line");
|
||
let h = l.lines[1].bottom - l.lines[1].top;
|
||
assert!((h - h10).abs() < 0.5, "a 10pt paragraph mark should give {h10}, got {h}");
|
||
assert!((h - h40).abs() > 1.0, "and not the 40pt first run's line ({h40})");
|
||
}
|
||
|
||
#[test]
|
||
fn an_empty_paragraph_keeps_its_paragraph_mark_height() {
|
||
// Case D, the control: an empty *paragraph* already took `end_props` before this change,
|
||
// through `lead`, and must be unaffected by it.
|
||
let (p, mut sh) = setup("x", 400.0, 400.0);
|
||
let h10 = one_line_height(&p, &mut sh, 10.0);
|
||
{
|
||
let t = sh.text.as_mut().unwrap();
|
||
let mut empty = Paragraph::default();
|
||
empty.end_props.size = Some(10.0);
|
||
t.paragraphs = vec![
|
||
Paragraph { runs: vec![sized_run("D1", 40.0)], ..Default::default() },
|
||
empty,
|
||
Paragraph { runs: vec![sized_run("D2", 40.0)], ..Default::default() },
|
||
];
|
||
}
|
||
let l = lay(&p, &sh, 400.0, 400.0);
|
||
assert_eq!(l.lines.len(), 3);
|
||
let h = l.lines[1].bottom - l.lines[1].top;
|
||
assert!((h - h10).abs() < 0.5, "a 10pt empty paragraph should give {h10}, got {h}");
|
||
}
|