mirror of
https://github.com/storytold/wordcraft.git
synced 2026-11-19 08:55:26 +00:00
#2702: a missing font is drawn in its font table's altName, as Word does
A missing font is drawn in its font table altName, as Word does. The DOCX reader half lives in craft-libs#1426; this is the fonts, layout and settings half. Originally authored by @Nghiathan13 in #2711.
This commit is contained in:
1 parent
c3fe680a0f
commit
c3be9f094f
6 files changed
+330
-41
No files matched your search
@@ -128,6 +128,15 @@ pub struct Settings {
|
||||
/// draws one that isn't installed in a serif face.
|
||||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||
pub roman_fonts: Vec<String>,
|
||||
/// Fonts the font table classes as modern (fixed pitch, `w:family w:val="modern"`): Word draws
|
||||
/// one that isn't installed, and whose alternate isn't either, in a serif face (#2702). Not
|
||||
/// the East Asian ones (`w:charset` 80, 81, 86, 88: MS Gothic, SimHei…).
|
||||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||
pub modern_fonts: Vec<String>,
|
||||
/// Alternate names the document's font table gives its fonts (`w:font/w:altName`), as (font,
|
||||
/// alternate): Word draws a font that isn't installed in its alternate when that one is.
|
||||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||
pub font_alt_names: Vec<(String, String)>,
|
||||
/// `w:doNotUseHTMLParagraphAutoSpacing`: the space between two paragraphs is the first's space
|
||||
/// after plus the second's space before, not the larger of the two.
|
||||
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
||||
@@ -325,6 +334,8 @@ impl Default for Settings {
|
||||
protect_hash: Vec::new(),
|
||||
compat_mode: COMPAT_MODE_CURRENT,
|
||||
roman_fonts: Vec::new(),
|
||||
modern_fonts: Vec::new(),
|
||||
font_alt_names: Vec::new(),
|
||||
sum_paragraph_spacing: false,
|
||||
do_not_expand_shift_return: false,
|
||||
allow_space_of_same_style_in_table: false,
|
||||
|
||||
+70
-12
@@ -40,6 +40,23 @@ pub fn has_named_substitutes(family: &str) -> bool {
|
||||
|
||||
const SANS: &[&str] = &["Carlito", "Helvetica Neue", "Arial", "Liberation Sans", "Noto Sans", "DejaVu Sans", "Source Sans 3"];
|
||||
|
||||
/// Serif faces known by name with no open clone of their own (lowercase): they take the generic
|
||||
/// serif list, but as fonts we know, not by a guess from the name ([`has_own_substitutes`]).
|
||||
const KNOWN_SERIFS: &[&str] = &[
|
||||
"cambria",
|
||||
"cambria math",
|
||||
"georgia",
|
||||
"garamond",
|
||||
"constantia",
|
||||
"baskerville old face",
|
||||
"century",
|
||||
"century schoolbook",
|
||||
"bookman old style",
|
||||
"sitka text",
|
||||
"sitka",
|
||||
"aptos serif",
|
||||
];
|
||||
|
||||
/// [`substitutes`], and whether they were chosen for this family by name.
|
||||
fn substitutes_by_name(family: &str) -> (&'static [&'static str], bool) {
|
||||
if family.contains(';') {
|
||||
@@ -149,18 +166,7 @@ fn substitutes_by_name(family: &str) -> (&'static [&'static str], bool) {
|
||||
"courier new" | "courier" | "consolas" | "lucida console" | "cascadia code" | "cascadia mono" => (MONO, true),
|
||||
"symbol" | "wingdings" | "wingdings 2" | "wingdings 3" | "segoe ui symbol" | "webdings" => (SYMBOL, true),
|
||||
// Serif faces with no open clone of their own: the generic serif list, as for any font.
|
||||
"cambria"
|
||||
| "cambria math"
|
||||
| "georgia"
|
||||
| "garamond"
|
||||
| "constantia"
|
||||
| "baskerville old face"
|
||||
| "century"
|
||||
| "century schoolbook"
|
||||
| "bookman old style"
|
||||
| "sitka text"
|
||||
| "sitka"
|
||||
| "aptos serif" => (SERIF, false),
|
||||
_ if KNOWN_SERIFS.contains(&f.as_str()) => (SERIF, false),
|
||||
_ if f.contains("mono") || f.contains("code") => (MONO, false),
|
||||
_ if f.contains("serif") && !f.contains("sans") => (SERIF, false),
|
||||
_ => (SANS, false),
|
||||
@@ -207,6 +213,22 @@ pub fn charset_base_family(family: &str) -> &str {
|
||||
.map_or(family, str::trim_end)
|
||||
}
|
||||
|
||||
/// Whether `family` (or the font its charset name stands for) has substitutes of its own: Times
|
||||
/// New Roman, Book Antiqua, Courier New, the symbol, Hebrew and Persian fonts, or a serif face we
|
||||
/// know (Georgia, Garamond…), rather than the generic list a font we don't know gets, also when
|
||||
/// its name only suggests one ("… Mono", "… Serif").
|
||||
pub fn has_own_substitutes(family: &str) -> bool {
|
||||
let base = charset_base_family(family);
|
||||
has_named_substitutes(base) || KNOWN_SERIFS.contains(&base.to_ascii_lowercase().as_str())
|
||||
}
|
||||
|
||||
/// Whether `family` has substitutes of its own ([`has_own_substitutes`]) and one of them is
|
||||
/// installed, so [`resolve`] draws it in a face chosen for it rather than the generic fallback.
|
||||
pub fn has_installed_substitute(family: &str) -> bool {
|
||||
let base = charset_base_family(family);
|
||||
has_own_substitutes(base) && substitute(FontDb::global(), base).is_some()
|
||||
}
|
||||
|
||||
/// Fonts made to measure alike (the same advance widths and line height), so text drawn in one
|
||||
/// wraps and paginates as in the others: Carlito for Calibri, Caladea for Cambria, Liberation and
|
||||
/// Croscore fonts for Arial, Times New Roman and Courier New, the Palatino look-alikes for Palatino
|
||||
@@ -848,6 +870,42 @@ mod tests {
|
||||
assert_eq!(substitutes(charset_base_family("Times New Roman Cyr")), substitutes("Times New Roman"));
|
||||
}
|
||||
|
||||
/// #2702 review: an alternate counts as drawable only when one of its own substitutes is
|
||||
/// installed; a font without a list of its own never does.
|
||||
#[test]
|
||||
fn installed_substitutes_are_the_fonts_own_and_installed() {
|
||||
let db = FontDb::global();
|
||||
for f in ["Times New Roman", "Wingdings", "Courier New", "Book Antiqua"] {
|
||||
let any = substitutes(f).iter().any(|s| db.has_family(s));
|
||||
assert_eq!(has_installed_substitute(f), any, "{f}");
|
||||
}
|
||||
for f in ["No Such Brand Font", ""] {
|
||||
assert!(!has_installed_substitute(f), "{f}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fonts_known_by_name_have_their_own_substitutes() {
|
||||
for f in [
|
||||
"Times New Roman",
|
||||
"times",
|
||||
"Times New Roman Cyr",
|
||||
"Book Antiqua",
|
||||
"Palatino Linotype",
|
||||
"Courier New",
|
||||
"Arial",
|
||||
"Georgia",
|
||||
"Wingdings",
|
||||
"David",
|
||||
] {
|
||||
assert!(has_own_substitutes(f), "{f}");
|
||||
}
|
||||
// A name that only suggests a list ("… Mono", "… Serif") isn't a font we know.
|
||||
for f in ["No Such Brand Font", "NewCenturySchlbk", "", "Brand Serif", "Foo Mono", "Source Code Pro"] {
|
||||
assert!(!has_own_substitutes(f), "{f}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pcl6_symbol_has_symbols_line_metrics() {
|
||||
assert_eq!(symbol_font_metrics("Symbol (PCL6)"), symbol_font_metrics("Symbol"));
|
||||
|
||||
@@ -214,7 +214,9 @@ impl<'a> Builder<'a> {
|
||||
if let Some(f) = missing.latin.filter(|_| asks_latin) {
|
||||
self.note_substituted(f, drawn);
|
||||
}
|
||||
if let Some(f) = missing.east_asian.filter(|_| !in_ea_font && sub.chars().any(east_asian)) {
|
||||
// A missing East Asian font has no face of its own: CJK text drawn in the East Asian
|
||||
// face is in its font table alternate (#2702) and still asks for it.
|
||||
if let Some(f) = missing.east_asian.filter(|_| sub.chars().any(east_asian)) {
|
||||
self.note_substituted(f, drawn);
|
||||
}
|
||||
}
|
||||
@@ -248,25 +250,29 @@ impl<'a> Builder<'a> {
|
||||
let rc_cs: Option<Arc<ResolvedChar>> = text.chars().any(|c| rc.uses_complex(c)).then(|| Arc::new(rc.complex()));
|
||||
let family = lookup_family(self.env.doc, &rc.font);
|
||||
let resolved = wordcraft_fonts::word::resolve(family, rc.bold, rc.italic);
|
||||
// The requested font is missing when it was substituted, or when another family stands in
|
||||
// for it: its font table alternate (#2702), which may itself be installed.
|
||||
let requested_missing = resolved.substituted || !family.eq_ignore_ascii_case(&rc.font);
|
||||
let primary = resolved.face;
|
||||
// Symbol-font characters are laid out as their Unicode equivalents.
|
||||
let sym = SymbolRun::of(&rc.font, &resolved);
|
||||
let show = |c: char| sym.map_or(c, |m| m.show(c));
|
||||
// A font isn't installed when it was substituted, or looked up as a missing roman font.
|
||||
// A font isn't installed when it was substituted, or looked up as a missing roman font or
|
||||
// its font table alternate (#2702).
|
||||
let resolved_cs = rc_cs.as_ref().map(|r| {
|
||||
let family = lookup_family(self.env.doc, &r.font);
|
||||
let resolved = wordcraft_fonts::word::resolve(family, r.bold, r.italic);
|
||||
(resolved.face, resolved.substituted || family != r.font)
|
||||
(resolved.face, resolved.substituted || !family.eq_ignore_ascii_case(&r.font))
|
||||
});
|
||||
let primary_cs = resolved_cs.map(|(face, _)| face);
|
||||
// Chinese, Japanese and Korean characters use the run's East Asian font (`w:eastAsia`) when
|
||||
// it is installed and has them.
|
||||
let wanted_ea = rc
|
||||
.font_ea
|
||||
.as_deref()
|
||||
.filter(|f| !f.eq_ignore_ascii_case(&rc.font) && text.chars().any(east_asian))
|
||||
.map(|f| (f, wordcraft_fonts::word::resolve(f, rc.bold, rc.italic)));
|
||||
let primary_ea = wanted_ea.filter(|(_, r)| !r.substituted).map(|(_, r)| r.face);
|
||||
// it, or the font table alternate it is drawn in (#2702), is installed and has them.
|
||||
let wanted_ea = rc.font_ea.as_deref().filter(|f| !f.eq_ignore_ascii_case(&rc.font) && text.chars().any(east_asian)).map(|f| {
|
||||
let family = lookup_family(self.env.doc, f);
|
||||
let resolved = wordcraft_fonts::word::resolve(family, rc.bold, rc.italic);
|
||||
(f, resolved, resolved.substituted || !family.eq_ignore_ascii_case(f))
|
||||
});
|
||||
let primary_ea = wanted_ea.filter(|(_, r, _)| !r.substituted).map(|(_, r, _)| r.face);
|
||||
// The levels by byte of `text`, from `lbase` on.
|
||||
let (levels, lbase): (&[u8], usize) = match dir {
|
||||
Dir::Para => (&self.levels, base),
|
||||
@@ -278,7 +284,7 @@ impl<'a> Builder<'a> {
|
||||
// A missing Thai font: one face for the run's Thai and Latin text (#1549). A run with its
|
||||
// own complex-script font keeps that font for the Thai letters.
|
||||
let run_face: Option<FaceRef> = if primary_cs.is_none_or(|f| f.id() == primary.id()) {
|
||||
thai_run_face(&rc.font, resolved.substituted, primary, text, rc.bold, rc.italic)
|
||||
thai_run_face(&rc.font, requested_missing, primary, text, rc.bold, rc.italic)
|
||||
} else {
|
||||
None
|
||||
};
|
||||
@@ -314,9 +320,9 @@ impl<'a> Builder<'a> {
|
||||
context: &context,
|
||||
});
|
||||
let missing = MissingFonts {
|
||||
latin: (resolved.substituted || family != rc.font).then_some(rc.font.as_str()),
|
||||
latin: requested_missing.then_some(rc.font.as_str()),
|
||||
complex: rc_cs.as_ref().filter(|_| resolved_cs.is_some_and(|(_, missing)| missing)).map(|r| r.font.as_str()),
|
||||
east_asian: wanted_ea.filter(|(_, r)| r.substituted).map(|(f, _)| f),
|
||||
east_asian: wanted_ea.filter(|(_, _, missing)| *missing).map(|(f, _, _)| f),
|
||||
names_east_asian: wanted_ea.is_some(),
|
||||
};
|
||||
self.note_missing_fonts(text, &segs, (primary, primary_cs, primary_ea), &missing);
|
||||
|
||||
@@ -124,23 +124,52 @@ pub(crate) fn remap_range(map_starts: &[usize], orig_of: &[usize], orig_len: usi
|
||||
/// as roman (measured in Word; Calibri otherwise, which our own substitutes already match).
|
||||
pub(super) const MISSING_ROMAN_FONT: &str = "Cambria";
|
||||
|
||||
/// The family to look `font` up as: [`MISSING_ROMAN_FONT`] for a missing roman font, else `font`.
|
||||
/// A missing Thai font keeps its name: it is drawn in a Thai face, not in Cambria (#1549).
|
||||
/// A font with substitutes of its own keeps them: Times New Roman is roman in every font table,
|
||||
/// and where it isn't installed Liberation Serif has its metrics; Word never meets it missing.
|
||||
pub(super) fn lookup_family<'f>(doc: &Document, font: &'f str) -> &'f str {
|
||||
/// The family to look `font` up as. A font that isn't installed is drawn, as Word draws it
|
||||
/// (measured in Word 2024, #2702):
|
||||
/// 1. in the alternate the font table names for it (`w:altName`), when that one can be drawn:
|
||||
/// installed, or a font one of whose own substitutes is installed. That comes before the
|
||||
/// family class: a roman font with an installed alternate is drawn in the alternate;
|
||||
/// 2. in [`MISSING_ROMAN_FONT`] when the font table classes it as roman, or as modern with an
|
||||
/// alternate that can't be drawn either (a modern font with no alternate, and a swiss one with
|
||||
/// or without, take the generic substitutes, as Calibri does in Word). Not for a Thai font
|
||||
/// (drawn in a Thai face, #1549), a symbol font, or a font with substitutes of its own (Times
|
||||
/// New Roman is roman in every font table, and where it isn't installed Liberation Serif has
|
||||
/// its metrics; Word never meets it missing);
|
||||
/// 3. else as `font`, which [`wordcraft_fonts::word::resolve`] substitutes.
|
||||
pub(super) fn lookup_family<'f>(doc: &'f Document, font: &'f str) -> &'f str {
|
||||
let settings = &doc.settings;
|
||||
// A fallback list (`Liberation Serif;Times New Roman`) is in a class when one of its
|
||||
// candidates is.
|
||||
let listed = |list: &[String]| {
|
||||
!list.is_empty() && font.split(';').map(str::trim).filter(|f| !f.is_empty()).any(|f| list.iter().any(|r| r.eq_ignore_ascii_case(f)))
|
||||
};
|
||||
let alternate = settings.font_alt_names.iter().find(|(f, _)| f.eq_ignore_ascii_case(font)).map(|(_, alt)| alt.as_str());
|
||||
let roman = listed(&settings.roman_fonts);
|
||||
if alternate.is_none() && !roman {
|
||||
return font;
|
||||
}
|
||||
let db = wordcraft_fonts::FontDb::global();
|
||||
let roman = !doc.settings.roman_fonts.is_empty()
|
||||
&& font.split(';').map(str::trim).filter(|f| !f.is_empty()).any(|f| doc.settings.roman_fonts.iter().any(|r| r.eq_ignore_ascii_case(f)));
|
||||
if roman
|
||||
let installed = |f: &str| db.has_family(f) || db.has_family(wordcraft_fonts::word::charset_base_family(f));
|
||||
// A fallback list is there when one of its candidates is.
|
||||
let missing = if font.contains(';') { wordcraft_fonts::word::resolve(font, false, false).substituted } else { !installed(font) };
|
||||
if !missing {
|
||||
return font;
|
||||
}
|
||||
// Calibri has no list of its own because the generic sans list is its (Carlito first).
|
||||
let drawable =
|
||||
|f: &&str| !f.is_empty() && (installed(f) || wordcraft_fonts::word::has_installed_substitute(f) || f.eq_ignore_ascii_case("Calibri"));
|
||||
// ECMA-376 calls the alternate a comma-separated list, but Word reads the whole value as one
|
||||
// name (MS-OE376 2.1.264), so a value with a comma names a font that isn't there.
|
||||
if let Some(alt) = alternate.map(str::trim).filter(drawable) {
|
||||
return alt;
|
||||
}
|
||||
let modern_alternate_missing = alternate.is_some() && listed(&settings.modern_fonts);
|
||||
// Thai, symbol and fonts with substitutes of their own keep their name: those substitutes
|
||||
// draw them, Cambria wouldn't.
|
||||
if (roman || modern_alternate_missing)
|
||||
&& !wordcraft_fonts::word::is_thai_family(font)
|
||||
&& !wordcraft_doc::symbol_fonts::is_symbol_font(font)
|
||||
&& !wordcraft_fonts::word::has_named_substitutes(font)
|
||||
&& if font.contains(';') {
|
||||
wordcraft_fonts::word::resolve(font, false, false).substituted
|
||||
} else {
|
||||
!db.has_family(font) && !db.has_family(wordcraft_fonts::word::charset_base_family(font))
|
||||
}
|
||||
{
|
||||
MISSING_ROMAN_FONT
|
||||
} else {
|
||||
@@ -150,9 +179,10 @@ pub(super) fn lookup_family<'f>(doc: &Document, font: &'f str) -> &'f str {
|
||||
|
||||
/// One face for a run in a Thai font that isn't installed (#1549): Word substitutes one font
|
||||
/// (Cordia New) for the whole run, so the Latin letters, digits and ฿ keep the Thai letters' face
|
||||
/// and size. `None` unless `font` is a Thai family, it was substituted, and its substitute
|
||||
/// `primary` lacks some of the run's Thai or Latin characters; then the first face covering all of
|
||||
/// them, if one does. Other families keep Latin text in their own substitute, as Word does.
|
||||
/// and size. `None` unless `font` is a Thai family, it was substituted (or drawn in its font
|
||||
/// table alternate, #2702), and its stand-in `primary` lacks some of the run's Thai or Latin
|
||||
/// characters; then the first face covering all of them, if one does. Other families keep Latin
|
||||
/// text in their own substitute, as Word does.
|
||||
pub(crate) fn thai_run_face(font: &str, substituted: bool, primary: FaceRef, text: &str, bold: bool, italic: bool) -> Option<FaceRef> {
|
||||
if !substituted || !wordcraft_fonts::word::is_thai_family(font) {
|
||||
return None;
|
||||
|
||||
@@ -1429,6 +1429,93 @@ fn a_missing_roman_font_is_drawn_as_word_draws_it() {
|
||||
assert_ne!(face(false), cambria);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_missing_font_is_drawn_in_its_font_table_alternate() {
|
||||
crate::test_fonts();
|
||||
// Measured in Word 2024 and Word for Windows 16.0.20527 (#2702): a font that isn't installed is
|
||||
// drawn in the alternate its font table names (`w:altName`), before the roman rule; an
|
||||
// alternate that can't be drawn either leaves the family class in charge: Cambria for a roman
|
||||
// or modern font, the generic substitutes (Calibri in Word) for a swiss one.
|
||||
#[derive(Clone, Copy)]
|
||||
enum Family {
|
||||
Swiss,
|
||||
Roman,
|
||||
Modern,
|
||||
}
|
||||
let face_of = |alt: Option<&str>, family: Family| {
|
||||
let mut d = Document::from_text("Lanterns");
|
||||
if let Some(alt) = alt {
|
||||
d.settings.font_alt_names = vec![("No Such Brand Font".into(), alt.into())];
|
||||
}
|
||||
match family {
|
||||
Family::Roman => d.settings.roman_fonts = vec!["No Such Brand Font".into()],
|
||||
Family::Modern => d.settings.modern_fonts = vec!["No Such Brand Font".into()],
|
||||
Family::Swiss => {}
|
||||
}
|
||||
let p = d.para_mut(StoryRef::Body, &Path::top(0)).unwrap();
|
||||
p.runs[0].props.font = Some("No Such Brand Font".into());
|
||||
let l = lay(&d);
|
||||
let Some(Placed::Lines { para, .. }) = l.pages[0].items.iter().find(|i| matches!(i, Placed::Lines { .. })) else { panic!("no text") };
|
||||
let first = para.clusters.first().expect("a cluster");
|
||||
para.styles[first.style as usize].face
|
||||
};
|
||||
let face = |alt: Option<&str>, roman: bool| face_of(alt, if roman { Family::Roman } else { Family::Swiss });
|
||||
let resolve = |f: &str| wordcraft_fonts::word::resolve(f, false, false).face;
|
||||
let (courier, times, calibri, cambria) = (resolve("Courier New"), resolve("Times New Roman"), resolve("Calibri"), resolve("Cambria"));
|
||||
let generic = face(None, false);
|
||||
// Serif and sans faces are bundled, so these differ on any machine.
|
||||
assert_ne!(times, generic);
|
||||
assert_ne!(cambria, generic);
|
||||
// A, B: a missing font with an alternate.
|
||||
assert_eq!(face(Some("Times New Roman"), false), times);
|
||||
assert_eq!(face(Some("Courier New"), false), courier);
|
||||
// go_math (docxide-pdf corpus): Museo Sans 300 → Calibri.
|
||||
assert_eq!(face(Some("Calibri"), false), calibri);
|
||||
// D: the alternate beats the roman rule.
|
||||
assert_eq!(face(Some("Times New Roman"), true), times);
|
||||
assert_eq!(face(Some("Courier New"), true), courier);
|
||||
// E: an alternate that is missing too, with no substitutes of its own: the roman rule, or the
|
||||
// generic substitutes for a font that isn't roman.
|
||||
assert_eq!(face(Some("No Such Alternate"), true), cambria);
|
||||
assert_eq!(face(Some("No Such Alternate"), false), generic);
|
||||
// Word reads a value with a comma as one name, not a list (MS-OE376 2.1.264): no font is
|
||||
// called that, so the roman rule or the generic substitutes draw it.
|
||||
assert_eq!(face(Some("No Such Alternate, Times New Roman"), false), generic);
|
||||
assert_eq!(face(Some("No Such Alternate, Times New Roman"), true), cambria);
|
||||
// A modern font: its installed alternate draws it, a missing alternate leaves it in Cambria,
|
||||
// and with no alternate at all it takes the generic substitutes (Calibri in Word).
|
||||
assert_eq!(face_of(Some("Courier New"), Family::Modern), courier);
|
||||
assert_eq!(face_of(Some("No Such Alternate"), Family::Modern), cambria);
|
||||
assert_eq!(face_of(None, Family::Modern), generic);
|
||||
// An alternate that names another missing font with an alternate of its own: the chain isn't
|
||||
// followed.
|
||||
let mut d = Document::from_text("Lanterns");
|
||||
d.settings.font_alt_names = vec![("No Such Brand Font".into(), "No Such Alternate".into()), ("No Such Alternate".into(), "Courier New".into())];
|
||||
let p = d.para_mut(StoryRef::Body, &Path::top(0)).unwrap();
|
||||
p.runs[0].props.font = Some("No Such Brand Font".into());
|
||||
let l = lay(&d);
|
||||
let Some(Placed::Lines { para, .. }) = l.pages[0].items.iter().find(|i| matches!(i, Placed::Lines { .. })) else { panic!("no text") };
|
||||
let first = para.clusters.first().expect("a cluster");
|
||||
assert_eq!(para.styles[first.style as usize].face, generic, "the chain isn't followed");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_installed_font_ignores_its_font_table_alternate() {
|
||||
// The alternate is only for a font that isn't there: an installed (here bundled) font keeps its
|
||||
// own face.
|
||||
let font = wordcraft_fonts::FALLBACK_FAMILY;
|
||||
let mut d = Document::from_text("Lanterns");
|
||||
d.settings.font_alt_names = vec![(font.into(), "Times New Roman".into())];
|
||||
let p = d.para_mut(StoryRef::Body, &Path::top(0)).unwrap();
|
||||
p.runs[0].props.font = Some(font.into());
|
||||
let l = lay(&d);
|
||||
let Some(Placed::Lines { para, .. }) = l.pages[0].items.iter().find(|i| matches!(i, Placed::Lines { .. })) else { panic!("no text") };
|
||||
let first = para.clusters.first().expect("a cluster");
|
||||
let own = wordcraft_fonts::word::resolve(font, false, false).face;
|
||||
assert_ne!(own, wordcraft_fonts::word::resolve("Times New Roman", false, false).face);
|
||||
assert_eq!(para.styles[first.style as usize].face, own);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_missing_roman_font_with_its_own_substitute_keeps_it() {
|
||||
crate::test_fonts();
|
||||
@@ -10634,6 +10721,52 @@ fn east_asian_text_takes_the_asian_font_and_latin_text_the_latin_font() {
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_missing_east_asian_font_is_drawn_in_its_font_table_alternate() {
|
||||
crate::test_fonts();
|
||||
// #2702 for the run's East Asian font (`w:eastAsia`): one that isn't installed is drawn in the
|
||||
// alternate its font table names, when that one is installed and has the characters. Take an
|
||||
// installed CJK font other than the one fallback would pick anyway, so the test tells them apart.
|
||||
let resolve = |f: &str| wordcraft_fonts::word::resolve(f, false, false);
|
||||
let fallback = wordcraft_fonts::FontDb::global().fallback_for('你', 0).map(|f| f.family.clone());
|
||||
let Some(asian) = wordcraft_fonts::FontDb::global().east_asian_families().into_iter().find(|f| {
|
||||
let r = resolve(f);
|
||||
Some(f) != fallback.as_ref() && !r.substituted && r.face.covers('你') && r.face.covers('好')
|
||||
}) else {
|
||||
eprintln!("skipped: no second Chinese font installed");
|
||||
return;
|
||||
};
|
||||
let missing = "No Such East Asian Font 2702";
|
||||
let text = "Hello 你好";
|
||||
let faces = |alternate: bool| {
|
||||
let mut d = Document::from_text(text);
|
||||
if alternate {
|
||||
d.settings.font_alt_names = vec![(missing.into(), asian.clone())];
|
||||
}
|
||||
d.format_range(&Pos::body(0, 0), &Pos::body(0, text.len()), &|c| {
|
||||
c.font = Some(wordcraft_doc::styles::BODY_FONT.into());
|
||||
c.font_ea = Some(missing.into());
|
||||
})
|
||||
.unwrap();
|
||||
let l = lay(&d);
|
||||
let para =
|
||||
l.pages.iter().flat_map(|p| p.items.iter()).find_map(|it| if let Placed::Lines { para, .. } = it { Some(para) } else { None }).unwrap();
|
||||
let drawn = para
|
||||
.clusters
|
||||
.iter()
|
||||
.filter(|c| text.get(c.start..c.end).and_then(|s| s.chars().next()).is_some_and(|ch| !ch.is_ascii()))
|
||||
.map(|c| para.styles[c.style as usize].face.id())
|
||||
.collect::<Vec<_>>();
|
||||
(drawn, l.substituted_fonts())
|
||||
};
|
||||
let asian_face = resolve(&asian).face.id();
|
||||
let (with, reported) = faces(true);
|
||||
assert!(!with.is_empty() && with.iter().all(|f| *f == asian_face), "你好 in the alternate {asian}");
|
||||
// Drawn in an installed alternate, the font asked for is still missing (#4770).
|
||||
assert!(reported.iter().any(|(f, _)| f == missing), "{reported:?}");
|
||||
assert!(faces(false).0.iter().all(|f| *f != asian_face), "without the alternate, fallback picks another font");
|
||||
}
|
||||
|
||||
/// A page total in the footer ("Page X of Y") is filled in after pagination, so it doesn't make
|
||||
/// the body lay out a second time; one in the body still does.
|
||||
#[test]
|
||||
|
||||
@@ -167,6 +167,57 @@ fn a_missing_thai_font_draws_the_whole_run_in_one_thai_face() {
|
||||
}
|
||||
}
|
||||
|
||||
/// Body paragraph 0 of `text` at 16 pt, its run set in `font` whose font table alternate
|
||||
/// (`w:altName`) is `alt`, and the face of every cluster: (cluster start, face).
|
||||
fn cluster_faces_with_alternate(text: &str, font: &str, alt: &str) -> Vec<(usize, wordcraft_fonts::FaceRef)> {
|
||||
let mut d = Document::from_text(text);
|
||||
d.settings.font_alt_names = vec![(font.into(), alt.into())];
|
||||
let p = d.para_mut(StoryRef::Body, &Path::top(0)).unwrap();
|
||||
p.runs[0].props.font = Some(font.into());
|
||||
p.runs[0].props.size = Some(16.0);
|
||||
let l = lay(&d);
|
||||
let pl = para_layout(&l, 0);
|
||||
pl.clusters.iter().map(|c| (c.start, pl.styles[c.style as usize].face)).collect()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_missing_thai_font_with_a_latin_alternate_still_draws_the_run_in_one_face() {
|
||||
if !thai_font_installed() {
|
||||
eprintln!("skipped: no Thai font installed");
|
||||
return;
|
||||
}
|
||||
// #2702 draws a missing font in its font table alternate. When the font is Thai and the
|
||||
// installed alternate has no Thai letters, the run still takes one face for its Thai and
|
||||
// Latin text (#1549), not the alternate for the Latin and per-letter fallback for the Thai.
|
||||
let alt = "Source Sans 3";
|
||||
let alt_face = wordcraft_fonts::word::resolve(alt, false, false).face;
|
||||
assert!(!alt_face.covers('\u{0E19}'), "{} has no Thai, so the run must move", alt_face.family);
|
||||
let db = wordcraft_fonts::FontDb::global();
|
||||
// One face for the run needs a Thai font with Latin letters and digits too.
|
||||
let thai_latin = thai_latin_font_installed();
|
||||
if !thai_latin {
|
||||
eprintln!("skipped the one-face cases: no Thai font with Latin letters installed");
|
||||
}
|
||||
for font in ["TH Sarabun New", "Angsana New"] {
|
||||
if !thai_latin || db.has_family(font) {
|
||||
continue;
|
||||
}
|
||||
let faces = cluster_faces_with_alternate(THAI_RUN, font, alt);
|
||||
let first = faces[0].1;
|
||||
let names: Vec<&str> = faces.iter().map(|(_, f)| f.family.as_str()).collect();
|
||||
assert!(faces.iter().all(|(_, f)| f.id() == first.id()), "{font} (alternate {alt}): one face for the run, not {names:?}");
|
||||
assert!(first.covers('\u{0E19}') && first.covers('D') && first.covers('1') && first.covers('\u{0E3F}'), "{font} → {}", first.family);
|
||||
// A Latin-only run in the same font is drawn in the alternate, as #2702 has it.
|
||||
let latin = cluster_faces_with_alternate("Lanterns 1,250", font, alt);
|
||||
assert!(latin.iter().all(|(_, f)| f.id() == alt_face.id()), "{font}: Latin text in {alt}");
|
||||
}
|
||||
// A missing Latin font with the same alternate isn't Thai: its Latin text stays in the
|
||||
// alternate and only the Thai letters fall back.
|
||||
let faces = cluster_faces_with_alternate("Hello \u{0E2A}\u{0E27}\u{0E31}\u{0E2A}\u{0E14}\u{0E35}", "No Such Latin Font 2702", alt);
|
||||
assert!(faces.iter().filter(|(at, _)| *at < 5).all(|(_, f)| f.id() == alt_face.id()), "Hello stays in {alt}");
|
||||
assert!(faces.iter().any(|(at, f)| *at >= 6 && f.id() != alt_face.id()), "the Thai letters fall back");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_thai_substitute_without_latin_hands_the_run_to_one_face_covering_it() {
|
||||
crate::test_fonts();
|
||||
|
||||
Reference in new issue
Block a user