DesignCraft: An open-source page and layout design editor written by scratch in pure Rust
UI: CJK interface text from installed fonts, on the Latin baseline
con3codea62188aa9b65
diff --git a/crates/fonts/src/lib.rs b/crates/fonts/src/lib.rsindex c1d744780..43d5837ff 100644--- a/crates/fonts/src/lib.rs+++ b/crates/fonts/src/lib.rs@@ -81,6 +81,16 @@ pub struct ShapedGlyph {}/// An OpenType feature setting: `"liga"`, `"-kern"`, `"ss01"`.+/// Line metrics of the font at `index` of `data`, in font units: (units per em, ascent, descent+/// (negative below the baseline), line gap) — what text layouts such as egui's build lines from.+/// `None` if the font can't be read.+pub fn line_metrics(data: &[u8], index: u32) -> Option<(f32, f32, f32, f32)> {+ use skrifa::MetadataProvider;+ let f = skrifa::FontRef::from_index(data, index).ok()?;+ let m = f.metrics(skrifa::instance::Size::unscaled(), skrifa::instance::LocationRef::default());+ Some((f32::from(m.units_per_em.max(1)), m.ascent, m.descent, m.leading))+}+pub fn feature(tag: &str) -> Option<Feature> {let (on, t) = match tag.strip_prefix('-') {Some(r) => (false, r),diff --git a/crates/ui-egui/src/rtl.rs b/crates/ui-egui/src/rtl.rsindex 2521aae20..79f130043 100644--- a/crates/ui-egui/src/rtl.rs+++ b/crates/ui-egui/src/rtl.rs@@ -300,7 +300,9 @@ mod tests {fn with_fonts(test: impl FnOnce(&egui::Context)) {let ctx = egui::Context::default();- crate::theme::install_fonts(&ctx, "ar");+ // The built-in faces only: installed fonts (the CJK fallbacks) would make the glyphs+ // measured here depend on the machine.+ ctx.set_fonts(crate::theme::font_definitions(designcraft_fonts::CRAFT_FONTS, "ar"));ctx.begin_pass(egui::RawInput { max_texture_side: Some(8192), ..Default::default() });test(&ctx);let mut output = ctx.end_pass();diff --git a/crates/ui-egui/src/theme.rs b/crates/ui-egui/src/theme.rsindex 3dd50180f..eb294d575 100644--- a/crates/ui-egui/src/theme.rs+++ b/crates/ui-egui/src/theme.rs@@ -255,7 +255,125 @@ impl Tokens {/// Install the UI fonts for the interface language `lang` (it orders the CJK fallbacks).pub fn install_fonts(ctx: &egui::Context, lang: &str) {- ctx.set_fonts(font_definitions(designcraft_fonts::CRAFT_FONTS, lang));+ let craft = designcraft_fonts::CRAFT_FONTS;+ let mut defs = font_definitions(craft, lang);+ add_system_fallbacks(&mut defs, &system_ui_fonts(craft), lang);+ ctx.set_fonts(defs);+}++/// An installed font the UI falls back to for a script the built-in faces lack.+pub(crate) struct SystemFont {+ /// "Jpan", "Hans", "Hant" or "Kore".+ script: &'static str,+ family: String,+ bytes: Vec<u8>,+ index: u32,+}++/// Installed UI faces (sans serif) per script, the first one found of each list: macOS, then+/// Windows, then Linux families.+const SYSTEM_UI_FONTS: &[(&str, &[&str])] = &[+ (+ "Jpan",+ &[+ "Hiragino Sans",+ "Hiragino Kaku Gothic ProN",+ "Yu Gothic UI",+ "Yu Gothic",+ "Meiryo",+ "MS Gothic",+ "Noto Sans CJK JP",+ "Noto Sans JP",+ "Source Han Sans JP",+ "IPAexGothic",+ "Droid Sans Fallback",+ ],+ ),+ ("Hans", &["PingFang SC", "Hiragino Sans GB", "Microsoft YaHei", "Noto Sans CJK SC", "Source Han Sans SC", "WenQuanYi Micro Hei"]),+ // Traditional Chinese and Korean: font menus list those families under their native names.+ ("Hant", &["PingFang TC", "Microsoft JhengHei", "Noto Sans CJK TC", "Source Han Sans TC"]),+ ("Kore", &["Apple SD Gothic Neo", "Malgun Gothic", "Noto Sans CJK KR", "Noto Sans KR", "Source Han Sans K", "NanumGothic", "UnDotum"]),+];++/// The installed faces for the CJK scripts `craft` (the built-in craft-fonts) doesn't cover, so+/// the interface shows Japanese and Chinese without the craft-fonts build input, and Korean and+/// Traditional Chinese (font names in the font menus) in any build. egui can't+/// find system fonts itself; the document font scan (not on the web) does.+fn system_ui_fonts(craft: &[designcraft_fonts::CraftFont]) -> Vec<SystemFont> {+ let db = designcraft_fonts::FontDb::global();+ SYSTEM_UI_FONTS+ .iter()+ .filter(|(script, _)| !craft.iter().any(|f| f.scripts.contains(script)))+ .filter_map(|(script, families)| {+ let family = families.iter().find(|f| db.has_family(f))?;+ let face = db.face(family, "Regular");+ // `face` falls back to another family when this one can't be read: keep only the real one.+ (face.family.eq_ignore_ascii_case(family) && !face.data().is_empty()).then(|| SystemFont {+ script,+ family: (*family).to_string(),+ bytes: face.data().to_vec(),+ index: face.index(),+ })+ })+ .collect()+}++/// The UI face every family starts with (Source Sans 3; the semibold shares its line metrics).+const UI_FONT: &[u8] = include_bytes!("../../../assets/fonts/SourceSans3-Regular.ttf");++/// The tweak that puts a fallback face's baseline on the UI face's. egui centres a fallback's+/// line height in the primary's instead (`pos.y = ascent + (line height − its line height) / 2`),+/// so a CJK face with a taller ascent or a larger line gap would sit above or below the Latin+/// text beside it. Shifts are in ems of the font size.+pub(crate) fn baseline_tweak(face: &[u8], index: u32) -> egui::FontTweak {+ let metrics = |data: &[u8], i: u32| {+ designcraft_fonts::line_metrics(data, i).map(|(upem, ascent, descent, gap)| (ascent / upem, (ascent - descent + gap) / upem))+ };+ let shift = match (metrics(UI_FONT, 0), metrics(face, index)) {+ (Some((ap, hp)), Some((af, hf))) => ap - (af + 0.5 * (hp - hf)),+ _ => 0.0,+ };+ egui::FontTweak { y_offset_factor: if shift.is_finite() { shift.clamp(-0.5, 0.5) } else { 0.0 }, ..Default::default() }+}++/// The script whose letterforms the interface language `lang` prefers for Han characters, Kana+/// and Hangul: "Jpan", "Hans", "Hant" or "Kore". Languages without a CJK preference use Japanese+/// forms, the app's default CJK face.+fn cjk_script(lang: &str) -> &'static str {+ match lang {+ "zh" | "zh-hans" | "zh-cn" => "Hans",+ "zh-hant" | "zh-tw" | "zh-hk" => "Hant",+ "ko" => "Kore",+ _ => "Jpan",+ }+}++/// Add installed faces `system` to every family in the interface language's order: the faces of+/// its script (`cjk_script`) go before the built-in CJK faces, so Han characters take that+/// language's forms (Traditional Chinese, Korean); the others go at the end.+pub(crate) fn add_system_fallbacks(fonts: &mut FontDefinitions, system: &[SystemFont], lang: &str) {+ let name = |f: &SystemFont| format!("system-{}", f.family);+ for f in system {+ fonts.font_data.insert(+ name(f),+ Arc::new(FontData { index: f.index, tweak: baseline_tweak(&f.bytes, f.index), ..FontData::from_owned(f.bytes.clone()) }),+ );+ }+ let first = cjk_script(lang);+ let preferred: Vec<String> = system.iter().filter(|f| f.script == first).map(name).collect();+ let rest: Vec<String> = ["Jpan", "Hans", "Hant", "Kore"]+ .iter()+ .filter(|s| **s != first)+ .flat_map(|s| system.iter().filter(move |f| f.script == *s))+ .map(name)+ .collect();+ for (family, stack) in fonts.families.iter_mut() {+ // The Arabic families keep their own order (see `font_definitions`).+ let arabic = matches!(family, FontFamily::Name(n) if n.starts_with("arabic"));+ let at = if arabic { stack.len() } else { stack.iter().position(|n| n.starts_with("craft-")).unwrap_or(stack.len()) };+ stack.splice(at..at, preferred.iter().cloned());+ stack.extend(rest.iter().cloned());+ }}/// The UI fonts: the app's own, then the craft-fonts faces from `craft` (empty without@@ -263,7 +381,7 @@ pub fn install_fonts(ctx: &egui::Context, lang: &str) {/// Simplified Chinese, in the interface language's order, then Arabic. The `arabic` families/// put the Arabic face first for right-to-left runs. egui has no system-font discovery, so/// without craft-fonts CJK and Arabic UI text has no glyphs.-fn font_definitions(craft: &'static [designcraft_fonts::CraftFont], lang: &str) -> FontDefinitions {+pub(crate) fn font_definitions(craft: &'static [designcraft_fonts::CraftFont], lang: &str) -> FontDefinitions {let mut fonts = FontDefinitions::default();let add = |fonts: &mut FontDefinitions, name: &str, data: &'static [u8]| {fonts.font_data.insert(name.into(), Arc::new(FontData::from_static(data)));@@ -281,11 +399,15 @@ fn font_definitions(craft: &'static [designcraft_fonts::CraftFont], lang: &str)let chinese = pick("Hans");let arabic = pick("Arab");let name = |f: &designcraft_fonts::CraftFont| format!("craft-{}-{}", f.family, f.style);- for f in japanese.iter().chain(&chinese).chain(&arabic) {+ for f in japanese.iter().chain(&chinese) {+ // CJK faces sit on the Latin baseline (see `baseline_tweak`).+ fonts.font_data.insert(name(f), Arc::new(FontData { tweak: baseline_tweak(f.bytes, 0), ..FontData::from_static(f.bytes) }));+ }+ for f in &arabic {add(&mut fonts, &name(f), f.bytes);}- // Han characters take the forms of the interface language: Chinese faces first for zh.- let zh = lang.starts_with("zh");+ // Han characters take the forms of the interface language: Chinese faces first for Chinese.+ let zh = matches!(cjk_script(lang), "Hans" | "Hant");for (family, stack) in fonts.families.iter_mut() {let bold = *family == FontFamily::Name("semibold".into());let mut ja = japanese.clone();@@ -406,6 +528,101 @@ mod japanese_font_tests {assert_eq!(stack.iter().find(|n| n.starts_with("craft-")).map(String::as_str), Some("craft-BIZ UDPGothic-Regular"));}+ /// Without craft-fonts, an installed Japanese face gives the interface its glyphs (here a+ /// synthetic stand-in, so the test doesn't depend on the machine's fonts).+ #[test]+ fn installed_fonts_give_japanese_glyphs_without_craft_fonts() {+ let bytes = designcraft_fonts::testing::font_with("DC UI Japanese", &['日', '本', '語']).unwrap();+ let system = [super::SystemFont { script: "Jpan", family: "DC UI Japanese".into(), bytes, index: 0 }];+ let mut defs = super::font_definitions(&[], "ja");+ super::add_system_fallbacks(&mut defs, &system, "ja");+ for family in families() {+ assert_eq!(defs.families[&family].last().map(String::as_str), Some("system-DC UI Japanese"), "{family:?}");+ }+ let ctx = egui::Context::default();+ ctx.set_fonts(defs);+ let mut output = ctx.run_ui(egui::RawInput::default(), |_| {});+ output.textures_delta.clear();+ ctx.fonts_mut(|fonts| {+ let font = egui::FontId::new(13.0, egui::FontFamily::Proportional);+ for ch in "日本語".chars() {+ assert!(fonts.has_glyph(&font, ch), "missing {ch}");+ }+ });+ }++ /// A fallback face with other line metrics lands on the UI face's baseline: egui puts a glyph+ /// at `ascent + (primary line height − its line height) / 2`, plus the tweak.+ #[test]+ fn fallback_faces_share_the_ui_baseline() {+ let ui = designcraft_fonts::line_metrics(super::UI_FONT, 0).unwrap();+ // A synthetic face with a taller ascent and a line gap (Hiragino-like proportions).+ let base = designcraft_fonts::testing::font_with("DC Tall", &['日']).unwrap();+ let tall = designcraft_fonts::testing::with_table_u16(base, b"hhea", 4, 1200u16).unwrap();+ let tall = designcraft_fonts::testing::with_table_u16(tall, b"hhea", 8, 500u16).unwrap();+ let face = designcraft_fonts::line_metrics(&tall, 0).unwrap();+ let tweak = super::baseline_tweak(&tall, 0);+ let em = |m: (f32, f32, f32, f32)| (m.1 / m.0, (m.1 - m.2 + m.3) / m.0);+ let ((ap, hp), (af, hf)) = (em(ui), em(face));+ let baseline = af + 0.5 * (hp - hf) + tweak.y_offset_factor;+ assert!((baseline - ap).abs() < 1e-4, "{baseline} vs {ap}");+ assert!(tweak.y_offset_factor.abs() > 0.01, "the synthetic face needs a shift: {}", tweak.y_offset_factor);+ // The UI face itself needs no shift.+ assert!(super::baseline_tweak(super::UI_FONT, 0).y_offset_factor.abs() < 1e-6);+ }++ /// Korean font names (the font menus show Korean families by their Hangul names) get glyphs+ /// from an installed Korean face, after the Japanese and Chinese ones.+ #[test]+ fn installed_korean_faces_give_hangul_glyphs() {+ let face = |family: &str, chars: &[char], script| super::SystemFont {+ script,+ family: family.into(),+ bytes: designcraft_fonts::testing::font_with(family, chars).unwrap(),+ index: 0,+ };+ let system = [face("DC UI Korean", &['한', '글'], "Kore"), face("DC UI Japanese", &['日'], "Jpan")];+ let mut defs = super::font_definitions(&[], "ja");+ super::add_system_fallbacks(&mut defs, &system, "ja");+ let stack = &defs.families[&egui::FontFamily::Proportional];+ let at = |n: &str| stack.iter().position(|x| x == n).unwrap();+ assert!(at("system-DC UI Japanese") < at("system-DC UI Korean"));+ let ctx = egui::Context::default();+ ctx.set_fonts(defs);+ let mut output = ctx.run_ui(egui::RawInput::default(), |_| {});+ output.textures_delta.clear();+ ctx.fonts_mut(|fonts| {+ let font = egui::FontId::new(13.0, egui::FontFamily::Proportional);+ assert!(fonts.has_glyph(&font, '한') && fonts.has_glyph(&font, '글'));+ });+ }++ /// Han characters take the interface language's forms: its script's installed face comes+ /// before the built-in CJK faces and the other scripts' faces.+ #[test]+ fn interface_language_orders_the_cjk_faces() {+ let face = |family: &str, script| super::SystemFont {+ script,+ family: family.into(),+ bytes: designcraft_fonts::testing::font_with(family, &['日']).unwrap(),+ index: 0,+ };+ let system = [face("DC Ja", "Jpan"), face("DC Hans", "Hans"), face("DC Hant", "Hant"), face("DC Ko", "Kore")];+ for (lang, first) in [("ja", "DC Ja"), ("zh", "DC Hans"), ("zh-hant", "DC Hant"), ("ko", "DC Ko"), ("", "DC Ja")] {+ let mut defs = super::font_definitions(&[], lang);+ // Stand-in for a built-in CJK face (craft-fonts may be absent in this build).+ defs.families.entry(egui::FontFamily::Proportional).or_default().push("craft-Stand-in".into());+ super::add_system_fallbacks(&mut defs, &system, lang);+ let stack = &defs.families[&egui::FontFamily::Proportional];+ let at = |n: &str| stack.iter().position(|x| x == n).unwrap();+ let first_at = at(&format!("system-{first}"));+ assert!(first_at < at("craft-Stand-in"), "{lang}: {stack:?}");+ for f in &system {+ assert!(first_at <= at(&format!("system-{}", f.family)), "{lang}: {stack:?}");+ }+ }+ }+#[test]fn ui_works_without_craft_fonts() {let ctx = ctx_with(&[]);