2bc41aeb8602
aki.rs
//! Insert Aki Left and Right (`CharStyle::aki_left`, `CharStyle::aki_right`): space before and
//! after a character in reading order, in thousandths of its em, that wrapping counts, alignment
//! keeps at a line's end and justification does not stretch.
use super::{area, db, point, serif, style};
use crate::*;
use kurbo::Shape;
use vectorcraft_doc::{CharStyle, Justify};
/// Where glyph `byte` is drawn along a horizontal line.
fn drawn_x(l: &TextLayout, byte: usize) -> f64 {
l.glyphs.iter().find(|g| g.byte == byte).map(|g| g.xf.as_coeffs()[4]).unwrap()
}
/// `t` with `f` applied to the style of the character at `byte`.
fn with(t: &TextObject, byte: usize, f: impl Fn(&mut CharStyle)) -> TextObject {
let mut t = t.clone();
let end = edit::next_char(&t.plain_text(), byte);
edit::style_range(&mut t.runs, byte, end, f);
t
}
/// How far each of `bytes` moved along the line from `a` to `b`, laid out in `fonts`.
fn moves_in(fonts: &FontDb, a: &TextObject, b: &TextObject, bytes: &[usize]) -> Vec<f64> {
let (la, lb) = (layout(fonts, a), layout(fonts, b));
bytes.iter().map(|&i| drawn_x(&lb, i) - drawn_x(&la, i)).collect()
}
fn moves(a: &TextObject, b: &TextObject, bytes: &[usize]) -> Vec<f64> {
moves_in(db(), a, b, bytes)
}
fn near(values: &[f64], expected: &[f64]) -> bool {
values.len() == expected.len() && values.iter().zip(expected).all(|(v, e)| (v - e).abs() < 1e-6)
}
#[test]
fn aki_left_spaces_before_a_character_and_aki_right_after_it() {
let plain = point("HOH", style(100.0));
// 250/1000 em of 100 pt before the O: 25 pt, the O and the H after it move.
let left = moves(&plain, &with(&plain, 1, |s| s.aki_left = 250.0), &[0, 1, 2]);
assert!(near(&left, &[0.0, 25.0, 25.0]), "{left:?}");
// After the O: only the H after it moves.
let right = moves(&plain, &with(&plain, 1, |s| s.aki_right = 250.0), &[0, 1, 2]);
assert!(near(&right, &[0.0, 0.0, 25.0]), "{right:?}");
// Both sides add up, and a value above one em is kept to one em.
let both = moves(&plain, &with(&plain, 1, |s| (s.aki_left, s.aki_right) = (250.0, 500.0)), &[0, 1, 2]);
assert!(near(&both, &[0.0, 25.0, 75.0]), "{both:?}");
let most = moves(&plain, &with(&plain, 1, |s| s.aki_right = 5000.0), &[2]);
assert!(near(&most, &[100.0]), "{most:?}");
let not_a_number = moves(&plain, &with(&plain, 1, |s| s.aki_left = f64::NAN), &[1, 2]);
assert!(near(¬_a_number, &[0.0, 0.0]), "{not_a_number:?}");
assert_eq!(aki_space("HOH", 1, &with(&plain, 1, |s| s.aki_left = 500.0).runs[1].style, false), (50.0, 0.0));
}
#[test]
fn aki_takes_the_em_of_the_character_as_tracking_does() {
let narrow = point("HOH", CharStyle { h_scale: 50.0, ..style(100.0) });
let moved = moves(&narrow, &with(&narrow, 1, |s| s.aki_left = 250.0), &[1, 2]);
assert!(near(&moved, &[12.5, 12.5]), "{moved:?}");
}
#[test]
fn optical_kerning_spaces_the_pair_as_without_the_aki() {
let optical = point("AVA", CharStyle { optical_kerning: true, ..style(100.0) });
let moved = moves(&optical, &with(&optical, 1, |s| s.aki_left = 250.0), &[0, 1, 2]);
assert!(near(&moved, &[0.0, 25.0, 25.0]), "{moved:?}");
let moved = moves(&optical, &with(&optical, 0, |s| s.aki_right = 250.0), &[0, 1, 2]);
assert!(near(&moved, &[0.0, 25.0, 25.0]), "{moved:?}");
// A letter with a combining mark: the pair is measured from the letter, not from the mark
// whose advance holds the cluster's Aki.
let marked = point("H\u{301}V", CharStyle { optical_kerning: true, ..style(100.0) });
let after = "H\u{301}".len();
let moved = moves(&marked, &with(&marked, 0, |s| s.aki_right = 1000.0), &[0, after]);
assert!(near(&moved, &[0.0, 100.0]), "{moved:?}");
}
#[test]
fn a_right_aligned_line_keeps_the_aki_after_its_last_character() {
let mut right = point("HOH", style(100.0));
right.para.justify = Justify::Right;
// Unlike the tracking after a line's last character, the Aki is part of the line.
let moved = moves(&right, &with(&right, 2, |s| s.aki_right = 250.0), &[0, 1, 2]);
assert!(near(&moved, &[-25.0, -25.0, -25.0]), "{moved:?}");
let tracked = moves(&right, &with(&right, 2, |s| s.tracking = 250.0), &[0, 2]);
assert!(near(&tracked, &[0.0, 0.0]), "{tracked:?}");
// At the line's start the Aki Left is kept too.
let mut left = point("HOH", style(100.0));
left.para.justify = Justify::Left;
let moved = moves(&left, &with(&left, 0, |s| s.aki_left = 250.0), &[0, 2]);
assert!(near(&moved, &[25.0, 25.0]), "{moved:?}");
}
#[test]
fn a_line_too_wide_with_its_aki_wraps() {
let one = layout(db(), &point("HOH HOH", style(50.0)));
let wide = one.lines[0].x1 - one.lines[0].x0;
let line_of = |t: &TextObject, byte: usize| layout(db(), t).glyphs.iter().find(|g| g.byte == byte).unwrap().line;
let fits = area("HOH HOH", style(50.0), Rect::new(0.0, 0.0, wide + 5.0, 400.0), Justify::Left);
assert_eq!(line_of(&fits, 4), 0, "both words fit");
// 250/1000 em of 50 pt is 12.5 pt, more than the 5 pt the frame has left.
assert_eq!(line_of(&with(&fits, 1, |s| s.aki_right = 250.0), 4), 1, "the second word wraps");
// The Aki after the last letter of a wrapped line stays on that line: the next line starts
// where it did.
let narrow = area("HOH HOH", style(50.0), Rect::new(0.0, 0.0, wide * 0.6, 400.0), Justify::Left);
let spaced = with(&narrow, 2, |s| s.aki_right = 250.0);
assert_eq!((line_of(&narrow, 4), line_of(&spaced, 4)), (1, 1));
let moved = moves(&narrow, &spaced, &[0, 4, 5]);
assert!(near(&moved, &[0.0, 0.0, 0.0]), "{moved:?}");
}
#[test]
fn justification_does_not_stretch_or_narrow_the_aki() {
// Desired Glyph Scaling 150% widens every glyph, and Word Spacing 200% every word space; the Aki
// stays 25 pt wide.
let mut scaled = point("HOH", style(100.0));
scaled.para.justification.glyph_scaling = [150.0, 150.0, 150.0];
let moved = moves(&scaled, &with(&scaled, 0, |s| s.aki_right = 250.0), &[0, 1, 2]);
assert!(near(&moved, &[0.0, 25.0, 25.0]), "{moved:?}");
let moved = moves(&scaled, &with(&scaled, 1, |s| s.aki_left = 250.0), &[1, 2]);
assert!(near(&moved, &[25.0, 25.0]), "{moved:?}");
// A glyph that justification widens to fill the line keeps the Aki before it at its width,
// and its own width, which ligature carets stand in, starts where the glyph is drawn.
let mut filled = area("HOH", style(100.0), Rect::new(0.0, 0.0, 600.0, 400.0), Justify::JustifyAll);
filled.para.justification.glyph_scaling = [100.0, 100.0, 300.0];
let l = layout(db(), &with(&filled, 1, |s| s.aki_left = 250.0));
let g = l.glyphs.iter().find(|g| g.byte == 1).unwrap();
assert!(g.scale > 1.0 + 1e-6, "the glyph is widened: {}", g.scale);
let drawn = g.xf.as_coeffs()[4];
assert!((g.origin.x + g.width_start - drawn).abs() < 1e-6, "{} {} {drawn}", g.origin.x, g.width_start);
let mut spaced = point("H H", style(100.0));
spaced.para.justification.word_spacing = [200.0, 200.0, 200.0];
let moved = moves(&spaced, &with(&spaced, 1, |s| s.aki_right = 250.0), &[0, 2]);
assert!(near(&moved, &[0.0, 25.0]), "{moved:?}");
}
#[test]
fn with_whole_point_widths_the_aki_is_whole_points_and_justification_keeps_it() {
// 250/1000 em of 10 pt is 2.5 pt, set as 3 pt with Fractional Widths off, with or without
// Desired Glyph Scaling 150%.
for scaling in [100.0, 150.0] {
let mut plain = point("HOH", style(10.0));
plain.fractional_widths = false;
plain.para.justification.glyph_scaling = [scaling; 3];
let left = moves(&plain, &with(&plain, 1, |s| s.aki_left = 250.0), &[0, 1, 2]);
assert!(near(&left, &[0.0, 3.0, 3.0]), "Glyph Scaling {scaling}: {left:?}");
let right = moves(&plain, &with(&plain, 1, |s| s.aki_right = 250.0), &[0, 1, 2]);
assert!(near(&right, &[0.0, 0.0, 3.0]), "Glyph Scaling {scaling}: {right:?}");
// 1.5 pt on each side: each side is set as 2 pt.
let both = moves(&plain, &with(&plain, 1, |s| (s.aki_left, s.aki_right) = (150.0, 150.0)), &[0, 1, 2]);
assert!(near(&both, &[0.0, 2.0, 4.0]), "Glyph Scaling {scaling}: {both:?}");
}
}
#[test]
fn a_ligature_and_a_letter_with_its_mark_take_the_aki_of_their_first_character() {
let plain = point("fit", serif(100.0));
let glyphs = |t: &TextObject| layout(db(), t).glyphs.len();
assert_eq!(glyphs(&plain), 2, "the font joins fi");
let spaced = with(&plain, 0, |s| (s.aki_left, s.aki_right) = (250.0, 250.0));
assert_eq!(glyphs(&spaced), 2, "still joined");
let moved = moves(&plain, &spaced, &[0, 2]);
assert!(near(&moved, &[25.0, 50.0]), "{moved:?}");
// On the i alone it is not read: the ligature's first character is the f.
let on_i = with(&plain, 1, |s| s.aki_right = 250.0);
assert_eq!(glyphs(&on_i), 2);
let moved = moves(&plain, &on_i, &[0, 2]);
assert!(near(&moved, &[0.0, 0.0]), "{moved:?}");
// A combining acute after e: the letter's Aki spaces the pair, the mark's own is not read.
let marked = point("e\u{301}a", style(100.0));
let after = "e\u{301}".len();
let moved = moves(&marked, &with(&marked, 0, |s| s.aki_right = 250.0), &[0, after]);
assert!(near(&moved, &[0.0, 25.0]), "{moved:?}");
let moved = moves(&marked, &with(&marked, 1, |s| s.aki_right = 250.0), &[0, after]);
assert!(near(&moved, &[0.0, 0.0]), "{moved:?}");
}
#[test]
fn right_to_left_aki_left_is_on_the_right_of_the_character() {
// Reading order ื ื ื is drawn right to left: Aki Left on ื widens the gap between ื and ื,
// Aki Right the gap between ื and ื.
let fonts = FontDb::global();
let plain = point("ืืื", style(100.0));
let (a, b, c) = (0, "ื".len(), "ืื".len());
let gaps = |t: &TextObject| {
let l = layout(fonts, t);
(drawn_x(&l, a) - drawn_x(&l, b), drawn_x(&l, b) - drawn_x(&l, c))
};
let base = gaps(&plain);
let left = gaps(&with(&plain, b, |s| s.aki_left = 250.0));
assert!((left.0 - base.0 - 25.0).abs() < 1e-6 && (left.1 - base.1).abs() < 1e-6, "{base:?} {left:?}");
let right = gaps(&with(&plain, b, |s| s.aki_right = 250.0));
assert!((right.0 - base.0).abs() < 1e-6 && (right.1 - base.1 - 25.0).abs() < 1e-6, "{base:?} {right:?}");
}
#[test]
fn in_vertical_type_aki_left_is_above_the_character_and_aki_right_below() {
// An upright glyph (ยง) and letters lying on their side: 250/1000 em of 20 pt is 5 pt down the
// column.
for text in ["ยงยง", "ab"] {
let mut plain = point(text, style(20.0));
plain.xf = Affine::IDENTITY;
plain.vertical = true;
let centers = |t: &TextObject| layout(db(), t).glyphs.iter().map(|g| g.outline.bounding_box().center()).collect::<Vec<_>>();
let base = centers(&plain);
let second = edit::next_char(text, 0);
// [first, second] glyph moved down the column, for Aki on one character.
for (spaced, down) in [
(with(&plain, 0, |s| s.aki_left = 250.0), [5.0, 5.0]),
(with(&plain, 0, |s| s.aki_right = 250.0), [0.0, 5.0]),
(with(&plain, second, |s| s.aki_left = 250.0), [0.0, 5.0]),
(with(&plain, second, |s| s.aki_right = 250.0), [0.0, 0.0]),
] {
let moved = centers(&spaced);
for i in 0..2 {
assert!((moved[i].y - base[i].y - down[i]).abs() < 1e-6, "{text} {i}: {base:?} {moved:?}");
assert!((moved[i].x - base[i].x).abs() < 1e-6, "{text} {i}: {base:?} {moved:?}");
}
}
}
}
/// A tate-chu-yoko block takes the Insert Aki of its first character above and below it, and
/// keeps its characters across the column as without it.
#[test]
fn a_tate_chu_yoko_block_is_spaced_by_the_aki_of_its_first_character() {
let mut plain = point("a12b", style(20.0));
plain.xf = Affine::IDENTITY;
plain.vertical = true;
let centers = |t: &TextObject| layout(db(), t).glyphs.iter().map(|g| g.outline.bounding_box().center()).collect::<Vec<_>>();
let base = centers(&plain);
assert_eq!(base.len(), 4);
// [a, 1, 2, b] moved down the column: 250/1000 em of 20 pt is 5 pt.
for (spaced, down) in [
(with(&plain, 1, |s| s.aki_left = 250.0), [0.0, 5.0, 5.0, 5.0]),
(with(&plain, 1, |s| s.aki_right = 250.0), [0.0, 0.0, 0.0, 5.0]),
(with(&plain, 1, |s| (s.aki_left, s.aki_right) = (250.0, 500.0)), [0.0, 5.0, 5.0, 15.0]),
(with(&plain, 2, |s| (s.aki_left, s.aki_right) = (250.0, 500.0)), [0.0; 4]),
] {
let moved = centers(&spaced);
for i in 0..4 {
assert!((moved[i].y - base[i].y - down[i]).abs() < 1e-6, "{i}: {base:?} {moved:?}");
assert!((moved[i].x - base[i].x).abs() < 1e-6, "{i}: {base:?} {moved:?}");
}
}
// With Fractional Widths off, 150/1000 em of 10 pt on each side (1.5 pt) is set as 2 pt above
// the block and 2 pt below it.
let mut whole = point("a12b", style(10.0));
whole.xf = Affine::IDENTITY;
whole.vertical = true;
whole.fractional_widths = false;
let base = centers(&whole);
let moved = centers(&with(&whole, 1, |s| (s.aki_left, s.aki_right) = (150.0, 150.0)));
let down = [0.0, 2.0, 2.0, 4.0];
for i in 0..4 {
assert!((moved[i].y - base[i].y - down[i]).abs() < 1e-6, "{i}: {base:?} {moved:?}");
assert!((moved[i].x - base[i].x).abs() < 1e-6, "{i}: {base:?} {moved:?}");
}
}
No file is open. Choose one in the tree, or press Ctrl+O (โO on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.