mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-10-28 19:57:05 -06:00
125 lines
6.7 KiB
Rust
125 lines
6.7 KiB
Rust
//! A zero width joiner or non-joiner between characters that the style's font lacks is shaped with
|
|
//! those characters, in their fallback face. The Unicode Standard describes both joiners under
|
|
//! Cursive Connection and Ligatures
|
|
//! (https://www.unicode.org/versions/latest/core-spec/chapter-23/), and Microsoft's OpenType shaping
|
|
//! specifications for Devanagari and Bengali include them in a syllable after a halant
|
|
//! (https://learn.microsoft.com/en-us/typography/script-development/devanagari,
|
|
//! https://learn.microsoft.com/en-us/typography/script-development/bengali).
|
|
//! No font is committed: the tests use installed faces and print SKIPPED when none is found, except
|
|
//! the check of the half-form test's face filter, which builds its faces in code.
|
|
use crate::*;
|
|
use kurbo::Point;
|
|
use std::sync::Arc;
|
|
use vectorcraft_doc::CharStyle;
|
|
|
|
const ZWNJ: char = '\u{200C}';
|
|
const ZWJ: char = '\u{200D}';
|
|
|
|
/// A Latin face that maps both joiners but not `c`, and the face that the fallback gives for `c`,
|
|
/// which must pass `suits`. Which face the fallback gives depends on the faces loaded so far, so the
|
|
/// tests compare with that face.
|
|
fn joiner_test_faces(test: &str, c: char, suits: impl Fn(&FontFace) -> bool) -> Option<(Arc<FontFace>, Arc<FontFace>)> {
|
|
let db = FontDb::global();
|
|
let faces = ["Source Sans 3", "Helvetica", "Arial", "Times New Roman", "Liberation Sans", "DejaVu Sans"]
|
|
.into_iter()
|
|
.filter_map(|name| db.face(name, "Regular").filter(|face| face.family == name))
|
|
.filter(|primary| primary.covers(ZWNJ) && primary.covers(ZWJ) && !primary.covers(c))
|
|
.find_map(|primary| db.fallback_for(c, primary.id()).filter(|f| suits(f)).map(|fallback| (primary, fallback)));
|
|
if let Some((primary, fallback)) = &faces {
|
|
let path = fallback.path().map_or_else(|| "bundled font".to_string(), |p| p.display().to_string());
|
|
eprintln!("ASSERTIONS RUN: {test}; {} {} with the fallback {} {} ({path})", primary.family, primary.style, fallback.family, fallback.style);
|
|
} else {
|
|
eprintln!("SKIPPED: {test}; no installed Latin face maps both joiners and falls back to a face for {c} with the lookups it needs");
|
|
}
|
|
faces
|
|
}
|
|
|
|
fn layout_in(face: &FontFace, text: &str, tracking: f64) -> TextLayout {
|
|
layout_in_db(FontDb::global(), face, text, tracking)
|
|
}
|
|
|
|
fn layout_in_db(db: &FontDb, face: &FontFace, text: &str, tracking: f64) -> TextLayout {
|
|
let st = CharStyle { font_family: face.family.clone(), font_style: face.style.clone(), size: 20.0, tracking, ..CharStyle::default() };
|
|
layout(db, &TextObject::point(Point::ZERO, text, st))
|
|
}
|
|
|
|
/// Ka + halant + ZWJ + Ssa: the half form of Ka before a full Ssa.
|
|
fn ka_half_ssa() -> String {
|
|
format!("क्{ZWJ}ष")
|
|
}
|
|
|
|
/// Whether `layout` of [`ka_half_ssa`] in `face` starts with a glyph other than Ka's and the
|
|
/// halant's (Ka's half form) and ends with Ssa's.
|
|
fn starts_with_a_half_form(face: &FontFace, layout: &TextLayout) -> bool {
|
|
let half = layout.glyphs.first().map(|g| g.gid);
|
|
half.is_some_and(|gid| gid != face.glyph_for('क') && gid != face.glyph_for('\u{094D}'))
|
|
&& layout.glyphs.last().map(|g| g.gid) == Some(face.glyph_for('ष'))
|
|
}
|
|
|
|
/// Whether `face` can serve the half-form test: its GSUB script list contains `dev2` or `deva`, and
|
|
/// [`ka_half_ssa`] set in `face` alone, in `db`, is drawn in `face` with Ka's half form.
|
|
fn forms_a_ka_half_form(db: &FontDb, face: &FontFace) -> bool {
|
|
use skrifa::raw::TableProvider;
|
|
let devanagari = face
|
|
.skrifa()
|
|
.and_then(|f| f.gsub().ok())
|
|
.and_then(|gsub| gsub.script_list().ok())
|
|
.is_some_and(|list| list.script_records().iter().any(|r| matches!(&r.script_tag().to_be_bytes(), b"dev2" | b"deva")));
|
|
let l = layout_in_db(db, face, &ka_half_ssa(), 0.0);
|
|
devanagari && l.glyphs.iter().all(|g| g.font_id == face.id()) && starts_with_a_half_form(face, &l)
|
|
}
|
|
|
|
/// `text` set in `primary` is drawn, spaced and stepped through exactly as `text` set in `fallback`.
|
|
fn assert_shaped_as_in_the_fallback(primary: &FontFace, fallback: &FontFace, text: &str) {
|
|
for tracking in [0.0, 200.0] {
|
|
let (mixed, single) = (layout_in(primary, text, tracking), layout_in(fallback, text, tracking));
|
|
// The caret stops where it stops in the fallback face.
|
|
assert_eq!(caret_horizontal(&mixed, 0, true), caret_horizontal(&single, 0, true), "{text:?} with tracking {tracking}");
|
|
// Tracking adds no extra space around the joiner.
|
|
let width = |l: &TextLayout| l.glyphs.iter().map(|g| g.advance).sum::<f64>();
|
|
assert_eq!(width(&mixed), width(&single), "{text:?} with tracking {tracking}");
|
|
let glyphs = |l: &TextLayout| l.glyphs.iter().map(|g| (g.font_id, g.gid, g.byte, g.len, g.origin, g.advance)).collect::<Vec<_>>();
|
|
assert_eq!(glyphs(&mixed), glyphs(&single), "{text:?} with tracking {tracking}");
|
|
assert!(mixed.glyphs.iter().all(|g| g.font_id == fallback.id()), "{text:?}: {:?}", mixed.glyphs);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn a_zero_width_non_joiner_in_devanagari_is_shaped_with_the_letters_around_it() {
|
|
let test = "a_zero_width_non_joiner_in_devanagari_is_shaped_with_the_letters_around_it";
|
|
let Some((primary, fallback)) = joiner_test_faces(test, 'क', |_| true) else { return };
|
|
// Ka + halant + ZWNJ + Ssa: Ka keeps its explicit halant instead of forming the KaSsa conjunct.
|
|
let s = format!("क्{ZWNJ}ष");
|
|
assert_shaped_as_in_the_fallback(&primary, &fallback, &s);
|
|
}
|
|
|
|
#[test]
|
|
fn a_zero_width_non_joiner_in_bangla_is_shaped_with_the_letters_around_it() {
|
|
let test = "a_zero_width_non_joiner_in_bangla_is_shaped_with_the_letters_around_it";
|
|
let Some((primary, fallback)) = joiner_test_faces(test, 'ক', |_| true) else { return };
|
|
let s = format!("ক্{ZWNJ}ষ");
|
|
assert_shaped_as_in_the_fallback(&primary, &fallback, &s);
|
|
}
|
|
|
|
#[test]
|
|
fn a_zero_width_joiner_in_devanagari_asks_for_a_half_form() {
|
|
let test = "a_zero_width_joiner_in_devanagari_asks_for_a_half_form";
|
|
let Some((primary, fallback)) = joiner_test_faces(test, 'क', |f| forms_a_ka_half_form(FontDb::global(), f)) else { return };
|
|
let s = ka_half_ssa();
|
|
assert_shaped_as_in_the_fallback(&primary, &fallback, &s);
|
|
let l = layout_in(&primary, &s, 0.0);
|
|
assert!(starts_with_a_half_form(&fallback, &l), "no half form: {:?}", l.glyphs);
|
|
}
|
|
|
|
#[test]
|
|
fn a_devanagari_face_without_a_half_form_is_not_used_for_the_half_form_test() {
|
|
use crate::test_fonts::{HALF_FORM_FAMILY, half_form_font};
|
|
for half in [false, true] {
|
|
let db = FontDb::with_font_dirs(vec![]);
|
|
db.add_font(half_form_font(half).unwrap());
|
|
let face = db.face(HALF_FORM_FAMILY, "Regular").unwrap();
|
|
// Both faces list `dev2`; only the one with a `half` feature forms Ka's half form.
|
|
assert_eq!(forms_a_ka_half_form(&db, &face), half, "half feature {half}");
|
|
}
|
|
}
|