DesignCraft: An open-source page and layout design editor written by scratch in pure Rust
UI: the font menu groups fonts by script, CJK fonts by language
aionggc64e538de50e
diff --git a/ROADMAP.md b/ROADMAP.mdindex 508f711b5..bb0c088f8 100644--- a/ROADMAP.md+++ b/ROADMAP.md@@ -66,7 +66,7 @@ DesignCraft aims at full Adobe InDesign parity — and to be better: faster, ope- User dictionary hyphenation exceptions (`hyphenation.addException/removeException/list`, Edit ▸ Spelling ▸ User Dictionary): `ex~am~ple` breaks only at `~`, a plain word never hyphenates.- Frame Fitting Options (`object.fittingOptions`, Object ▸ Fitting ▸ Frame Fitting Options…): Auto-Fit refits on resize, fitting, Align From reference point, crop amounts; IDML FrameFittingOption.- Paragraph borders (per-side weights, colour, tint, offsets) and shading offsets, drawn per column part of split paragraphs (also when overset); Paragraph panel controls; IDML ParagraphBorder*/ParagraphShading*Offset.-- Font menu: search, favourites (stars, Show Favorites Only; `favoriteFonts` preference) and each family previewed in its own face.+- Font menu: search, favourites (stars, Show Favorites Only; `favoriteFonts` preference) and each family previewed in its own face. Western (and other-script) families come first, then Japanese, Simplified Chinese, Traditional Chinese and Korean ones, each group alphabetical and set off by a separator; the group comes from the font's own data (`meta` languages, family names in a CJK language, OS/2 code pages, else what it covers), read once (installed fonts by the font scan, without loading them). CJK families show their native names, the English name on hover; Preferences › Type › Show Font Names in English (`showFontNamesInEnglish`) shows English names throughout. Search matches either name; documents store the English name. Every family list (Character panel, Control bar, Properties, style dialogs, Find Font, Glyphs) follows this order.- Application preferences (engine `Prefs`) now persist across launches (desktop: prefs.json beside ui.json).- View ▸ Fit Selection in Window (⌥⌘=) and Find/Change ▸ Object (`find.objects`, `find.changeObjects`: by fill, stroke, weight, opacity, kind, layer, label).- Custom workspaces (`window.newWorkspace/deleteWorkspace/resetWorkspace`; workspace switcher shows the current one): bars and panel arrangement saved by name.diff --git a/crates/engine/src/cmd/prefs.rs b/crates/engine/src/cmd/prefs.rsindex cfd7f74c1..68a5cf152 100644--- a/crates/engine/src/cmd/prefs.rs+++ b/crates/engine/src/cmd/prefs.rs@@ -48,7 +48,7 @@ pub fn specs() -> Vec<CommandSpec> {"Preferences",[],None,- "{showHiddenCharacters?, typographersQuotes?, polygonSides?, starInset?, scaleStrokes?, dimensionsIncludeStroke?, transformationsAreTotals?, absolutePageNumbers?, highlightHj?, highlightKeeps?, highlightCustomTracking?, highlightSubstitutedFonts?, richBlackOutput?, favoriteFonts?: [family]} → all application preferences",+ "{showHiddenCharacters?, typographersQuotes?, polygonSides?, starInset?, scaleStrokes?, dimensionsIncludeStroke?, transformationsAreTotals?, absolutePageNumbers?, highlightHj?, highlightKeeps?, highlightCustomTracking?, highlightSubstitutedFonts?, richBlackOutput?, favoriteFonts?: [family], showFontNamesInEnglish?} → all application preferences",super::always,|s, p| {let cur = serde_json::to_value(&s.prefs).map_err(|e| bad("prefs.set", e.to_string()))?;@@ -120,6 +120,9 @@ mod tests {let r = s.execute("prefs.set", &json!({"scaleStrokes": false})).unwrap();assert_eq!(r["scaleStrokes"], false);assert!(!s.prefs.scale_strokes);+ assert_eq!(r["showFontNamesInEnglish"], false, "native CJK font names by default");+ s.execute("prefs.set", &json!({"showFontNamesInEnglish": true})).unwrap();+ assert!(s.prefs.show_font_names_in_english);assert!(s.execute("prefs.set", &json!({"nope": 1})).is_err());s.execute("file.new", &json!({})).unwrap();let r = sdiff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rsindex 1512ce326..6d39b0158 100644--- a/crates/engine/src/lib.rs+++ b/crates/engine/src/lib.rs@@ -171,6 +171,9 @@ pub struct Prefs {pub rich_black_output: bool,/// Font menu favourites (family names).pub favorite_fonts: Vec<String>,+ /// Preferences › Type › Show Font Names in English: the font menus show CJK families by their+ /// English names instead of their native ones. Documents store the English name either way.+ pub show_font_names_in_english: bool,/// Preferences › Type › Smart Text Reflow: pages follow the primary text frame's story/// (added while it oversets, empty ones at the end removed).pub smart_text_reflow: bool,@@ -224,6 +227,7 @@ impl Default for Prefs {highlight_substituted_fonts: true,rich_black_output: false,favorite_fonts: Vec::new(),+ show_font_names_in_english: false,smart_text_reflow: true,autocorrect: false,autocorrect_list: default_autocorrect(),diff --git a/crates/fonts/src/fontdb.rs b/crates/fonts/src/fontdb.rsindex 909906b1d..922cf7615 100644--- a/crates/fonts/src/fontdb.rs+++ b/crates/fonts/src/fontdb.rs@@ -12,6 +12,8 @@ use skrifa::raw::FileRef;use skrifa::string::StringId;use skrifa::{GlyphId, MetadataProvider};+use crate::group::{FamilyInfo, FontGroup};+/// The family used when a requested family is unknown (the UI sans).pub const FALLBACK_FAMILY: &str = "Source Sans 3";@@ -117,6 +119,8 @@ pub struct FontFace {bmp: std::sync::OnceLock<Box<[u64]>>,/// The ideographic em box, read on first use.em: std::sync::OnceLock<(f64, f64)>,+ /// The font menu group and native family name, read on first use.+ group: std::sync::OnceLock<(FontGroup, Option<String>)>,}/// A cheap `Copy` handle to a face. Faces are never unloaded, so the handle lives for the rest of@@ -261,6 +265,12 @@ impl FontFace {pub fn em_box(&self) -> (f64, f64) {*self.em.get_or_init(|| crate::vertical::em_box(self))}+ /// The font menu group the font is for and, for a CJK group, its family name in that language+ /// (see [`crate::FamilyInfo`]); read from the font once.+ pub fn menu_group(&self) -> (FontGroup, Option<&str>) {+ let (g, n) = self.group.get_or_init(|| self.skrifa().map(|f| crate::group::classify(&f, &self.family)).unwrap_or_default());+ (*g, n.as_deref())+ }/// Glyph id for `c` (0 = .notdef).pub fn glyph_for(&self, c: char) -> u32 {self.skrifa().and_then(|f| f.charmap().map(c)).map(|g| g.to_u32()).unwrap_or(0)@@ -291,6 +301,19 @@ struct CatalogEntry {family: String,style: String,path: std::path::PathBuf,+ /// The font menu group and native family name, read by the scan.+ group: FontGroup,+ native: Option<String>,+}++/// What the scan reads of one face in a font file: its names and font menu group.+#[cfg(not(target_arch = "wasm32"))]+#[derive(Clone, Debug, PartialEq)]+struct ScannedFace {+ family: String,+ style: String,+ group: FontGroup,+ native: Option<String>,}/// Process-wide font database: the fonts every document shares (bundled, installed, added), and@@ -483,15 +506,19 @@ fn face_names(f: &skrifa::FontRef<'_>) -> Option<(String, String)> {Some((family, style))}-/// (family, style) of every face in the font file at `path`, reading only its table directories-/// and `name` tables: a scan opens hundreds of font files, many of them megabytes long. A-/// variable font is cataloged under its default style; its named instances appear once it loads.+/// The names and font menu group of every face in the font file at `path`, reading only its table+/// directories and the tables that name and classify it (`name`, `OS/2`, `meta`; `cmap` only for a+/// font that declares no language or code page): a scan opens hundreds of font files, many of them+/// megabytes long. A variable font is cataloged under its default style; its named instances+/// appear once it loads.#[cfg(not(target_arch = "wasm32"))]-fn file_face_names(path: &std::path::Path) -> Vec<(String, String)> {+fn file_face_names(path: &std::path::Path) -> Vec<ScannedFace> {use std::io::{Read, Seek, SeekFrom};/// Caps on what a (possibly damaged) file can make the scan read.const MAX_FACES: u32 = 256;const MAX_NAME_TABLE: u32 = 1 << 20;+ const MAX_SMALL_TABLE: u32 = 64 << 10;+ const MAX_CMAP: u32 = 4 << 20;let Ok(mut file) = std::fs::File::open(path) else { return vec![] };let mut read_at = |offset: u64, len: usize| -> Option<Vec<u8>> {let mut buf = vec![0; len];@@ -514,22 +541,31 @@ fn file_face_names(path: &std::path::Path) -> Vec<(String, String)> {let dir = read_at(start.into(), 12)?;let tables = u16::from_be_bytes(dir.get(4..6)?.try_into().ok()?) as usize;let records = read_at(u64::from(start) + 12, tables * 16)?;- let rec = records.as_chunks::<16>().0.iter().find(|r| r.starts_with(b"name"))?;- let (offset, len) = (be32(rec, 8)?, be32(rec, 12)?);- if len > MAX_NAME_TABLE {- return None;- }- let table = read_at(offset.into(), len as usize)?;- // A one-table font holding just the `name` table, to read it as the font itself would.- let mut font = Vec::with_capacity(28 + table.len());- font.extend_from_slice(&0x0001_0000_u32.to_be_bytes());- font.extend_from_slice(&[0, 1, 0, 16, 0, 0, 0, 0]);- font.extend_from_slice(b"name");- for v in [0, 28, len] {- font.extend_from_slice(&u32::to_be_bytes(v));- }- font.extend_from_slice(&table);- face_names(&skrifa::FontRef::new(&font).ok()?)+ // Table `tag`, unless missing or over `max` bytes.+ let mut table = |tag: &[u8; 4], max: u32| -> Option<([u8; 4], Vec<u8>)> {+ let rec = records.as_chunks::<16>().0.iter().find(|r| r.starts_with(tag))?;+ let (offset, len) = (be32(rec, 8)?, be32(rec, 12)?);+ if len > max {+ return None;+ }+ Some((*tag, read_at(offset.into(), len as usize)?))+ };+ // A font holding just these tables, to read them as the font itself would.+ let mut found = vec![table(b"name", MAX_NAME_TABLE)?];+ found.extend(table(b"OS/2", MAX_SMALL_TABLE));+ found.extend(table(b"meta", MAX_SMALL_TABLE));+ let font = crate::group::sfnt(found.clone())?;+ let f = skrifa::FontRef::new(&font).ok()?;+ let (family, style) = face_names(&f)?;+ let (group, native) = match crate::group::declared_group(&f) {+ Some(g) => (g, crate::group::classify(&f, &family).1),+ None => {+ found.extend(table(b"cmap", MAX_CMAP));+ let font = crate::group::sfnt(found)?;+ crate::group::classify(&skrifa::FontRef::new(&font).ok()?, &family)+ }+ };+ Some(ScannedFace { family, style, group, native })}).collect()}@@ -663,6 +699,7 @@ fn make_face(bytes: FontBytes, source: FontSource, index: u32, family: String, sindex,bmp: std::sync::OnceLock::new(),em: std::sync::OnceLock::new(),+ group: std::sync::OnceLock::new(),})}@@ -869,8 +906,8 @@ impl FontDb {if !matches!(ext.as_deref(), Some("ttf" | "otf" | "ttc" | "otc")) {continue;}- for (family, style) in file_face_names(&p) {- found.push(CatalogEntry { family, style, path: p.clone() });+ for f in file_face_names(&p) {+ found.push(CatalogEntry { family: f.family, style: f.style, path: p.clone(), group: f.group, native: f.native });}}}@@ -1150,6 +1187,26 @@ impl ScopedFonts<'_> {v}+ /// The available families as the font menus list them (see [`ScopedFonts::families`]), each+ /// with its group and native name, unsorted ([`crate::sort_for_menu`] orders them).+ pub fn family_infos(&self) -> Vec<FamilyInfo> {+ let mut out: Vec<FamilyInfo> = Vec::new();+ let mut seen = std::collections::HashSet::new();+ for f in self.own().iter().chain(self.db.read_faces().iter()) {+ if seen.insert(f.family.to_lowercase()) {+ let (group, native) = f.menu_group();+ out.push(FamilyInfo { family: f.family.clone(), group, native: native.map(str::to_string) });+ }+ }+ #[cfg(not(target_arch = "wasm32"))]+ for c in self.db.read_catalog().iter() {+ if seen.insert(c.family.to_lowercase()) {+ out.push(FamilyInfo { family: c.family.clone(), group: c.group, native: c.native.clone() });+ }+ }+ out+ }+/// Style names available for `family` (Regular first, then by weight).pub fn styles(&self, family: &str) -> Vec<String> {let mut v: Vec<(bool, f32, String)> = self@@ -1214,11 +1271,17 @@ impl ScopedFonts<'_> {.collect()}- /// Glyph outline in font units, y-down (flipped), cached per (face, glyph).+ /// Glyph outline in font units, y-down (flipped), cached per (face, glyph); see+ /// [`FontDb::outline`].pub fn outline(&self, face: &FontFace, gid: u32) -> Arc<BezPath> {self.db.outline(face, gid)}+ /// See [`FontDb::missing_box`].+ pub fn missing_box(&self, face: &FontFace) -> Option<BezPath> {+ self.db.missing_box(face)+ }+/// `Style {wght:650,wdth:90}`: the named style's font at those axis values, made on first use.fn instance(&self, family: &str, style: &str) -> Option<Arc<FontFace>> {let open = style.find('{')?;diff --git a/crates/fonts/src/group.rs b/crates/fonts/src/group.rsnew file mode 100644index 000000000..039dceada--- /dev/null+++ b/crates/fonts/src/group.rs@@ -0,0 +1,355 @@+//! Font menu groups: the script or CJK language a font is for and its family name in that+//! language, read from the font's own data.++use skrifa::raw::TableProvider;++/// The font menus' groups, in menu order: Western (and other scripts), then Japanese, Simplified+/// Chinese, Traditional Chinese and Korean. The order is InDesign's font menu as recalled, not+/// observed.+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]+pub enum FontGroup {+ #[default]+ Western,+ Japanese,+ ChineseSimplified,+ ChineseTraditional,+ Korean,+}++/// A family as the font menus list it.+#[derive(Clone, Debug, PartialEq)]+pub struct FamilyInfo {+ /// The family name documents store (the English or only name).+ pub family: String,+ pub group: FontGroup,+ /// A CJK family's name in its group's language, when the font has one that differs.+ pub native: Option<String>,+}++impl FamilyInfo {+ /// The name the menus show: the native name unless `english` (Show Font Names in English).+ pub fn label(&self, english: bool) -> &str {+ match &self.native {+ Some(n) if !english => n,+ _ => &self.family,+ }+ }++ /// Does `query` (lowercase) find this family? Either name matches.+ pub fn matches(&self, query: &str) -> bool {+ query.is_empty() || self.family.to_lowercase().contains(query) || self.native.as_ref().is_some_and(|n| n.to_lowercase().contains(query))+ }+}++/// Sort families for a font menu: by group, then by the name shown, ignoring case.+pub fn sort_for_menu(families: &mut [FamilyInfo], english: bool) {+ families.sort_by_cached_key(|f| (f.group, f.label(english).to_lowercase()));+}++/// Language IDs naming a group: Windows (platform 3) and Macintosh (platform 1).+fn group_of_language(platform: u16, language: u16) -> Option<FontGroup> {+ match (platform, language) {+ (3, 0x0411) | (1, 11) => Some(FontGroup::Japanese),+ (3, 0x0804 | 0x1004) | (1, 33) => Some(FontGroup::ChineseSimplified),+ (3, 0x0404 | 0x0C04 | 0x1404) | (1, 19) => Some(FontGroup::ChineseTraditional),+ (3, 0x0412) | (1, 23) => Some(FontGroup::Korean),+ _ => None,+ }+}++/// The group of a `meta` script and language tag (`Jpan`, `ja`, `zh-Hant`, `ko-Kore`, …).+fn group_of_tag(tag: &str) -> Option<FontGroup> {+ let tag = tag.trim().to_ascii_lowercase();+ let parts: Vec<&str> = tag.split(['-', '_']).collect();+ let has = |p: &str| parts.contains(&p);+ let first = parts.first().copied().unwrap_or("");+ if has("jpan") || has("hira") || has("kana") || first == "ja" {+ Some(FontGroup::Japanese)+ } else if has("kore") || has("hang") || first == "ko" {+ Some(FontGroup::Korean)+ } else if has("hant") || (first == "zh" && (has("tw") || has("hk") || has("mo"))) {+ Some(FontGroup::ChineseTraditional)+ } else if has("hans") || first == "zh" {+ Some(FontGroup::ChineseSimplified)+ } else {+ None+ }+}++/// A font file of `tables` (tag, bytes): the table directory, sorted by tag, then the tables, each+/// 4-byte aligned. `None` if there are too many or they are too large to address.+#[cfg(not(target_arch = "wasm32"))]+pub(crate) fn sfnt(mut tables: Vec<([u8; 4], Vec<u8>)>) -> Option<Vec<u8>> {+ tables.sort_by_key(|t| t.0);+ let n = u16::try_from(tables.len()).ok()?;+ let pow = 1u16 << (15 - n.max(1).leading_zeros().min(15));+ let mut out = 0x0001_0000_u32.to_be_bytes().to_vec();+ for v in [n, pow.saturating_mul(16), pow.trailing_zeros() as u16, n.saturating_mul(16).saturating_sub(pow.saturating_mul(16))] {+ out.extend_from_slice(&v.to_be_bytes());+ }+ let mut offset = 12 + 16 * tables.len();+ for (tag, data) in &tables {+ out.extend_from_slice(tag);+ out.extend_from_slice(&0u32.to_be_bytes());+ out.extend_from_slice(&u32::try_from(offset).ok()?.to_be_bytes());+ out.extend_from_slice(&u32::try_from(data.len()).ok()?.to_be_bytes());+ offset = offset.checked_add(data.len().next_multiple_of(4))?;+ }+ for (_, data) in &tables {+ out.extend_from_slice(data);+ out.resize(out.len().next_multiple_of(4), 0);+ }+ Some(out)+}++/// Caps on what a (possibly damaged) font can make classification read.+const MAX_TAGS: usize = 64;+const MAX_RECORDS: usize = 512;++/// The first group in menu order among `found` (the tie order Japanese, Simplified Chinese,+/// Traditional Chinese, Korean).+fn first(found: impl Iterator<Item = FontGroup>) -> Option<FontGroup> {+ found.min()+}++/// The CJK group the font's `meta` table names: `dlng` (the languages it is designed for), else+/// `slng` (the ones it supports).+fn meta_group(f: &skrifa::FontRef<'_>) -> Option<FontGroup> {+ use skrifa::raw::tables::meta::{DLNG, Metadata, SLNG};+ let meta = f.meta().ok()?;+ let tags = |want| {+ let map = meta.data_maps().iter().find(|m| m.tag() == want)?;+ let Ok(Metadata::ScriptLangTags(tags)) = map.data(meta.offset_data()) else { return None };+ first(tags.iter().take(MAX_TAGS).filter_map(|t| group_of_tag(t.ok()?.as_str())))+ };+ tags(DLNG).or_else(|| tags(SLNG))+}++/// The CJK group of the languages the font's `name` table names its family in (style names+/// don't count: fonts translate those into many languages).+fn name_group(f: &skrifa::FontRef<'_>) -> Option<FontGroup> {+ let name = f.name().ok()?;+ first(+ name.name_record()+ .iter()+ .take(MAX_RECORDS)+ .filter(|r| FAMILY_IDS.contains(&r.name_id().to_u16()))+ .filter_map(|r| group_of_language(r.platform_id(), r.language_id())),+ )+}++/// Name IDs of the family name: typographic family, then family.+const FAMILY_IDS: [u16; 2] = [16, 1];++/// From the OS/2 code page ranges: `Some(Some(group))` for the CJK code pages (JIS, Chinese+/// Simplified, Korean Wansung, Chinese Traditional, Korean Johab), `Some(None)` when the font+/// lists code pages but no CJK one, `None` when it lists none.+fn code_page_group(f: &skrifa::FontRef<'_>) -> Option<Option<FontGroup>> {+ let os2 = f.os2().ok()?;+ let (r1, r2) = (os2.ul_code_page_range_1()?, os2.ul_code_page_range_2().unwrap_or(0));+ if r1 == 0 && r2 == 0 {+ return None;+ }+ let bits = [+ (17, FontGroup::Japanese),+ (18, FontGroup::ChineseSimplified),+ (19, FontGroup::Korean),+ (20, FontGroup::ChineseTraditional),+ (21, FontGroup::Korean),+ ];+ Some(first(bits.into_iter().filter(|(b, _)| r1 & (1 << b) != 0).map(|(_, g)| g)))+}++/// The group the font declares: its `meta` languages, then its `name` table's languages, then its+/// code pages (the strongest signal first). `None` when it declares nothing at all: no CJK+/// language and no code pages.+pub(crate) fn declared_group(f: &skrifa::FontRef<'_>) -> Option<FontGroup> {+ if let Some(g) = meta_group(f).or_else(|| name_group(f)) {+ return Some(g);+ }+ code_page_group(f).map(|g| g.unwrap_or(FontGroup::Western))+}++/// The group by what the font covers: kana is Japanese, Hangul Korean, ideographs alone+/// Simplified Chinese.+pub(crate) fn covered_group(f: &skrifa::FontRef<'_>) -> FontGroup {+ use skrifa::MetadataProvider;+ let cmap = f.charmap();+ let any = |cs: &[char]| cs.iter().any(|c| cmap.map(*c).is_some());+ if any(&['あ', 'ア', 'の']) {+ FontGroup::Japanese+ } else if any(&['가', '한', '이']) {+ FontGroup::Korean+ } else if any(&['一', '中', '人']) {+ FontGroup::ChineseSimplified+ } else {+ FontGroup::Western+ }+}++/// The font's group and, for a CJK group, its family name in that language (typographic family,+/// else family) when it differs from `family`.+pub(crate) fn classify(f: &skrifa::FontRef<'_>, family: &str) -> (FontGroup, Option<String>) {+ let group = declared_group(f).unwrap_or_else(|| covered_group(f));+ (group, native_family(f, group).filter(|n| n != family))+}++/// The family name (ID 16, else 1) in `group`'s language, from records whose text decodes.+fn native_family(f: &skrifa::FontRef<'_>, group: FontGroup) -> Option<String> {+ if group == FontGroup::Western {+ return None;+ }+ let name = f.name().ok()?;+ let records = name.name_record();+ FAMILY_IDS.into_iter().find_map(|id| {+ records.iter().take(MAX_RECORDS).find_map(|r| {+ if r.name_id().to_u16() != id || !r.is_unicode() || group_of_language(r.platform_id(), r.language_id()) != Some(group) {+ return None;+ }+ let s: String = r.string(name.string_data()).ok()?.chars().take(256).collect();+ let s = s.trim().to_string();+ (!s.is_empty()).then_some(s)+ })+ })+}++#[cfg(test)]+mod tests {+ use super::*;+ use crate::testing::{font_with, with_code_pages, with_meta, with_names, with_table_len};++ const FAMILY: &str = "DC Test Group";++ fn group_of(font: &[u8]) -> (FontGroup, Option<String>) {+ classify(&skrifa::FontRef::new(font).unwrap(), FAMILY)+ }++ /// A font with only Latin letters, its code pages `range1` (and none in range 2).+ fn latin(range1: u32) -> Vec<u8> {+ with_code_pages(font_with(FAMILY, &['a', 'b']).unwrap(), range1, 0).unwrap()+ }++ /// Windows English family records plus `extra` records.+ fn named(font: &[u8], extra: &[(u16, u16, u16, u16, &str)]) -> Vec<u8> {+ let mut records = vec![(3, 1, 0x409, 1, FAMILY), (3, 1, 0x409, 2, "Regular")];+ records.extend_from_slice(extra);+ with_names(font, &records).unwrap()+ }++ #[test]+ fn code_pages_give_the_group() {+ assert_eq!(group_of(&latin(1)).0, FontGroup::Western, "Latin 1 only");+ for (bit, group) in [+ (17, FontGroup::Japanese),+ (18, FontGroup::ChineseSimplified),+ (19, FontGroup::Korean),+ (20, FontGroup::ChineseTraditional),+ (21, FontGroup::Korean),+ ] {+ assert_eq!(group_of(&latin(1 | 1 << bit)).0, group, "bit {bit}");+ }+ // Several: Japanese, Simplified Chinese, Traditional Chinese, Korean.+ assert_eq!(group_of(&latin(1 << 17 | 1 << 19)).0, FontGroup::Japanese);+ assert_eq!(group_of(&latin(1 << 20 | 1 << 21)).0, FontGroup::ChineseTraditional);+ }++ #[test]+ fn name_languages_give_the_group_and_the_native_name() {+ let jp = named(&latin(1), &[(3, 1, 0x0411, 1, "テスト明朝"), (3, 1, 0x0411, 16, "テスト明朝 Pro")]);+ assert_eq!(group_of(&jp), (FontGroup::Japanese, Some("テスト明朝 Pro".into())), "the typographic family first");+ for (lang, group) in [+ (0x0804, FontGroup::ChineseSimplified),+ (0x1004, FontGroup::ChineseSimplified),+ (0x0404, FontGroup::ChineseTraditional),+ (0x0C04, FontGroup::ChineseTraditional),+ (0x1404, FontGroup::ChineseTraditional),+ (0x0412, FontGroup::Korean),+ ] {+ assert_eq!(group_of(&named(&latin(1), &[(3, 1, lang, 1, "本地名")])), (group, Some("本地名".into())), "{lang:#x}");+ }+ // Macintosh records in a CJK encoding: the language counts, the text doesn't decode.+ assert_eq!(group_of(&named(&latin(1), &[(1, 1, 11, 1, "x")])), (FontGroup::Japanese, None));+ assert_eq!(group_of(&named(&latin(1), &[(1, 3, 23, 1, "x")])).0, FontGroup::Korean);+ // Records in two CJK languages: the menu order decides.+ assert_eq!(group_of(&named(&latin(1), &[(3, 1, 0x0412, 1, "한"), (3, 1, 0x0404, 1, "繁")])).0, FontGroup::ChineseTraditional);+ // Translated style names don't make a Western font CJK.+ assert_eq!(group_of(&named(&latin(1), &[(3, 1, 0x0411, 2, "標準"), (1, 1, 11, 2, "x")])).0, FontGroup::Western);+ // A native name equal to the English one isn't shown twice.+ assert_eq!(group_of(&named(&latin(1), &[(3, 1, 0x0411, 1, FAMILY)])), (FontGroup::Japanese, None));+ }++ #[test]+ fn meta_beats_names_which_beat_code_pages() {+ let all = named(&latin(1 << 17), &[(3, 1, 0x0412, 1, "한글")]);+ assert_eq!(group_of(&all).0, FontGroup::Korean, "the name table over the code pages");+ assert_eq!(group_of(&with_meta(&all, Some("zh-Hant"), None).unwrap()).0, FontGroup::ChineseTraditional, "dlng first");+ assert_eq!(group_of(&with_meta(&all, None, Some("Hans")).unwrap()).0, FontGroup::ChineseSimplified, "slng without dlng");+ assert_eq!(group_of(&with_meta(&all, Some("Kore, Jpan"), Some("Hans")).unwrap()).0, FontGroup::Japanese, "ties in menu order");+ // A meta table naming no CJK language leaves it to the rest.+ assert_eq!(group_of(&with_meta(&all, Some("Latn"), None).unwrap()).0, FontGroup::Korean);+ for (tag, group) in [+ ("ja", FontGroup::Japanese),+ ("ja-Jpan", FontGroup::Japanese),+ ("zh", FontGroup::ChineseSimplified),+ ("zh-Hans", FontGroup::ChineseSimplified),+ ("zh-TW", FontGroup::ChineseTraditional),+ ("zh-HK", FontGroup::ChineseTraditional),+ ("ko", FontGroup::Korean),+ ("Hang", FontGroup::Korean),+ ] {+ assert_eq!(group_of_tag(tag), Some(group), "{tag}");+ }+ assert_eq!(group_of_tag("en-Latn"), None);+ }++ #[test]+ fn coverage_decides_when_the_font_declares_nothing() {+ for (chars, group) in [+ (&['a', 'あ', '一'][..], FontGroup::Japanese),+ (&['a', '한', '一'][..], FontGroup::Korean),+ (&['a', '一'][..], FontGroup::ChineseSimplified),+ (&['a'][..], FontGroup::Western),+ ] {+ let font = with_code_pages(font_with(FAMILY, chars).unwrap(), 0, 0).unwrap();+ assert_eq!(group_of(&font).0, group, "{chars:?}");+ }+ // Code pages without a CJK one: Western, whatever the font covers.+ assert_eq!(group_of(&with_code_pages(font_with(FAMILY, &['一']).unwrap(), 1, 0).unwrap()).0, FontGroup::Western);+ }++ #[test]+ fn damaged_tables_classify_without_panicking() {+ let base = with_meta(&named(&latin(1 << 18), &[(3, 1, 0x0411, 1, "名前")]), Some("Jpan"), None).unwrap();+ for tag in [b"name", b"OS/2", b"meta", b"cmap"] {+ for len in [0, 3, 7, 13, 21, 80] {+ let font = with_table_len(base.clone(), tag, len).unwrap();+ if let Ok(f) = skrifa::FontRef::new(&font) {+ let _ = classify(&f, FAMILY);+ }+ }+ }+ }++ #[test]+ fn menus_list_western_fonts_then_each_cjk_language() {+ let info = |family: &str, group, native: Option<&str>| FamilyInfo { family: family.into(), group, native: native.map(Into::into) };+ let mut fams = vec![+ info("Yu Mincho", FontGroup::Japanese, Some("游明朝")),+ info("Apple SD Gothic Neo", FontGroup::Korean, Some("애플 SD 산돌고딕 Neo")),+ info("Songti SC", FontGroup::ChineseSimplified, Some("宋体-简")),+ info("zapfino", FontGroup::Western, None),+ info("Hiragino Mincho ProN", FontGroup::Japanese, Some("ヒラギノ明朝 ProN")),+ info("PMingLiU", FontGroup::ChineseTraditional, Some("新細明體")),+ info("Arial", FontGroup::Western, None),+ ];+ sort_for_menu(&mut fams, true);+ let order: Vec<&str> = fams.iter().map(|f| f.label(true)).collect();+ assert_eq!(order, ["Arial", "zapfino", "Hiragino Mincho ProN", "Yu Mincho", "Songti SC", "PMingLiU", "Apple SD Gothic Neo"]);+ sort_for_menu(&mut fams, false);+ let order: Vec<&str> = fams.iter().map(|f| f.label(false)).collect();+ assert_eq!(order, ["Arial", "zapfino", "ヒラギノ明朝 ProN", "游明朝", "宋体-简", "新細明體", "애플 SD 산돌고딕 Neo"]);+ // Search finds either name.+ let yu = fams.iter().find(|f| f.family == "Yu Mincho").unwrap();+ assert!(yu.matches("yu min") && yu.matches("游") && yu.matches("") && !yu.matches("songti"));+ }+}diff --git a/crates/fonts/src/lib.rs b/crates/fonts/src/lib.rsindex f8cb9e42f..8f901e96d 100644--- a/crates/fonts/src/lib.rs+++ b/crates/fonts/src/lib.rs@@ -8,6 +8,7 @@#![forbid(unsafe_code)]mod fontdb;+mod group;#[cfg(any(test, feature = "testing"))]pub mod testing;mod vertical;@@ -16,6 +17,7 @@ pub use fontdb::{DOCUMENT_FONTS_FOLDER, DocumentFonts, FALLBACK_FAMILY, FaceRef, FontDb, FontFace, FontSource, MAX_DOCUMENT_FONT_BYTES, MAX_DOCUMENT_FONT_FILES,MAX_DOCUMENT_FONTS_TOTAL, ScopedFonts, base_style, bundled, system_font_dirs,};+pub use group::{FamilyInfo, FontGroup, sort_for_menu};pub use harfrust::Feature;use harfrust::{Direction, Language, ShapeOptions, Tag, UnicodeBuffer};pub use kurbo::BezPath;diff --git a/crates/fonts/src/testing.rs b/crates/fonts/src/testing.rsindex 07361c102..e03ad1b6f 100644--- a/crates/fonts/src/testing.rs+++ b/crates/fonts/src/testing.rs@@ -210,3 +210,54 @@ pub fn with_empty_notdef(mut font: Vec<u8>) -> Option<Vec<u8>> {font.get_mut(loca..loca + width)?.copy_from_slice(&end);Some(font)}++/// `font` with its `name` table replaced by `records`: (platform, encoding, language, name id,+/// text). Text is written as UTF-16BE on the Unicode and Windows platforms, as its bytes on the+/// Macintosh platform. `None` if `font` can't be read.+pub fn with_names(font: &[u8], records: &[(u16, u16, u16, u16, &str)]) -> Option<Vec<u8>> {+ let strings: Vec<Vec<u8>> =+ records.iter().map(|r| if r.0 == 1 { r.4.as_bytes().to_vec() } else { r.4.encode_utf16().flat_map(u16::to_be_bytes).collect() }).collect();+ let count = u16::try_from(records.len()).ok()?;+ let mut name = Vec::new();+ for v in [0u16, count, 6 + 12 * count] {+ name.extend_from_slice(&v.to_be_bytes());+ }+ let mut at = 0usize;+ for (r, s) in records.iter().zip(&strings) {+ for v in [r.0, r.1, r.2, r.3, u16::try_from(s.len()).ok()?, u16::try_from(at).ok()?] {+ name.extend_from_slice(&v.to_be_bytes());+ }+ at += s.len();+ }+ strings.iter().for_each(|s| name.extend_from_slice(s));+ with_tables(font, vec![(*b"name", name)])+}++/// `font` with its OS/2 `ulCodePageRange1` and `ulCodePageRange2` set (the font's OS/2 table must+/// be version 1 or later). `None` if it has none.+pub fn with_code_pages(font: Vec<u8>, range1: u32, range2: u32) -> Option<Vec<u8>> {+ let font = with_table_u16(font, b"OS/2", 78, (range1 >> 16) as u16)?;+ let font = with_table_u16(font, b"OS/2", 80, range1 as u16)?;+ let font = with_table_u16(font, b"OS/2", 82, (range2 >> 16) as u16)?;+ with_table_u16(font, b"OS/2", 84, range2 as u16)+}++/// `font` with a `meta` table holding `dlng` and `slng` script and language tag lists (as written,+/// comma-separated), each when given. `None` if `font` can't be read.+pub fn with_meta(font: &[u8], dlng: Option<&str>, slng: Option<&str>) -> Option<Vec<u8>> {+ let maps: Vec<(&[u8; 4], &str)> = [(b"dlng", dlng), (b"slng", slng)].into_iter().filter_map(|(t, v)| Some((t, v?))).collect();+ let count = u32::try_from(maps.len()).ok()?;+ let mut meta = Vec::new();+ for v in [1u32, 0, 0, count] {+ meta.extend_from_slice(&v.to_be_bytes());+ }+ let mut at = 16 + 12 * maps.len();+ for (tag, v) in &maps {+ meta.extend_from_slice(*tag);+ meta.extend_from_slice(&u32::try_from(at).ok()?.to_be_bytes());+ meta.extend_from_slice(&u32::try_from(v.len()).ok()?.to_be_bytes());+ at += v.len();+ }+ maps.iter().for_each(|(_, v)| meta.extend_from_slice(v.as_bytes()));+ with_tables(font, vec![(*b"meta", meta)])+}diff --git a/crates/fonts/src/tests_sysfonts.rs b/crates/fonts/src/tests_sysfonts.rsindex 2c8a7ae37..a9cda7cdc 100644--- a/crates/fonts/src/tests_sysfonts.rs+++ b/crates/fonts/src/tests_sysfonts.rs@@ -129,8 +129,38 @@ fn a_link_back_to_a_parent_folder_ends_the_scan() {#[test]fn the_scan_reads_names_without_loading_the_font() {let dir = font_dir("names");- assert_eq!(file_face_names(&dir.join("Sysfont-Regular.ttf")), [(FAMILY.to_string(), "Regular".to_string())]);+ let names: Vec<(String, String)> = file_face_names(&dir.join("Sysfont-Regular.ttf")).into_iter().map(|f| (f.family, f.style)).collect();+ assert_eq!(names, [(FAMILY.to_string(), "Regular".to_string())]);assert!(file_face_names(&dir.join("damaged.ttf")).is_empty());assert!(file_face_names(&dir.join("readme.txt")).is_empty());assert!(file_face_names(&dir.join("missing.ttf")).is_empty());}++#[test]+fn font_menus_group_installed_and_loaded_fonts_without_loading_them() {+ use crate::testing::{font_with, with_code_pages, with_names};+ use crate::{FamilyInfo, FontGroup};+ let dir = std::env::temp_dir().join(format!("dc-sysfonts-groups-{}", std::process::id()));+ let _ = std::fs::remove_dir_all(&dir);+ std::fs::create_dir_all(&dir).unwrap();+ let names = |family: &str, lang: u16, native: &str| {+ let font = font_with(family, &['a']).unwrap();+ with_names(&font, &[(3, 1, 0x409, 1, family), (3, 1, 0x409, 2, "Regular"), (3, 1, lang, 1, native)]).unwrap()+ };+ std::fs::write(dir.join("jp.ttf"), names("Groups Mincho", 0x0411, "グループ明朝")).unwrap();+ // Declares nothing (no code pages): its kana make it Japanese, read from the cmap.+ std::fs::write(dir.join("kana.otf"), with_code_pages(font_with("Groups Kana", &['a', 'あ']).unwrap(), 0, 0).unwrap()).unwrap();+ let db = FontDb::with_font_dirs(vec![dir.clone()]);+ db.set_system_fallback(false);+ db.add_font(with_code_pages(font_with("Groups Ming", &['a']).unwrap(), 1 << 20, 0).unwrap());+ let infos = db.scoped(0).family_infos();+ let find = |f: &str| infos.iter().find(|i| i.family == f).cloned().unwrap_or_else(|| panic!("{f} in {infos:?}"));+ assert_eq!(find("Groups Mincho"), FamilyInfo { family: "Groups Mincho".into(), group: FontGroup::Japanese, native: Some("グループ明朝".into()) });+ assert_eq!(find("Groups Kana").group, FontGroup::Japanese);+ assert_eq!(find("Groups Ming").group, FontGroup::ChineseTraditional);+ assert_eq!(find(crate::DEFAULT_FAMILY).group, FontGroup::Western);+ assert!(!db.is_loaded("Groups Mincho"), "the scan read its tables, not the font");+ // Families are listed once.+ assert_eq!(infos.iter().filter(|i| i.family == "Groups Mincho").count(), 1);+ let _ = std::fs::remove_dir_all(&dir);+}diff --git a/crates/render/src/glyphs.rs b/crates/render/src/glyphs.rsindex a28ac9b0a..1bf98426a 100644--- a/crates/render/src/glyphs.rs+++ b/crates/render/src/glyphs.rs@@ -60,9 +60,11 @@ pub fn text_line(db: &ScopedFonts<'_>, family: &str, style: &str, text: &str, helet (asc, desc) = face.vertical_metrics();let baseline = h as f64 / 2.0 + (asc - desc.abs()) / 2.0 * k;let mut x = 1.0;+ // A preview shows what the font draws: not the box DesignCraft draws for a missing glyph.+ let boxed = glyphs.iter().any(|g| g.gid == 0) && db.missing_box(&face).is_some();for g in &glyphs {let outline = db.outline(&face, g.gid);- if !outline.elements().is_empty() {+ if !outline.elements().is_empty() && !(boxed && g.gid == 0) {ctx.set_transform(kurbo::Affine::translate((x + g.x_offset as f64 * k, baseline - g.y_offset as f64 * k)) * kurbo::Affine::scale_non_uniform(k, -k),);diff --git a/crates/ui-egui/Cargo.toml b/crates/ui-egui/Cargo.tomlindex a322157c7..36767afbf 100644--- a/crates/ui-egui/Cargo.toml+++ b/crates/ui-egui/Cargo.toml@@ -29,3 +29,4 @@ log = { workspace = true }[dev-dependencies]# Headless (offscreen wgpu) rendering of the whole window for UI screenshots: `examples/ui_shot.rs`.egui_kittest = { workspace = true, features = ["wgpu", "snapshot"] }+designcraft-fonts = { workspace = true, features = ["testing"] }diff --git a/crates/ui-egui/src/dialogs.rs b/crates/ui-egui/src/dialogs.rsindex 1449110f0..cd292b1ca 100644--- a/crates/ui-egui/src/dialogs.rs+++ b/crates/ui-egui/src/dialogs.rs@@ -518,6 +518,7 @@ fn preferences(app: &crate::DesignApp, ui: &mut egui::Ui, d: &mut Dialog) {"type" => {crate::rtl::label(ui, egui::RichText::new(crate::i18n::tr(&app.ui.language, "Type Options")).font(semibold(12.0)));check(ui, d, "typographersQuotes", crate::i18n::tr(&app.ui.language, "Use Typographer's Quotes"));+ check(ui, d, "showFontNamesInEnglish", crate::i18n::tr(&app.ui.language, "Show Font Names in English"));ui.add_space(6.0);ui.label(crate::rtl::widget(ui,@@ -1513,7 +1514,7 @@ pub fn confirm(app: &mut DesignApp) -> Result<Value, String> {"preferences" => {app.run("prefs.set",- json!({"scaleStrokes": d.b("scaleStrokes"), "dimensionsIncludeStroke": d.b("dimensionsIncludeStroke"), "transformationsAreTotals": d.b("transformationsAreTotals"), "absolutePageNumbers": d.b("absolutePageNumbers"), "highlightHj": d.b("highlightHj"), "highlightKeeps": d.b("highlightKeeps"), "highlightCustomTracking": d.b("highlightCustomTracking"), "highlightSubstitutedFonts": d.b("highlightSubstitutedFonts"), "richBlackOutput": d.b("richBlackOutput"), "typographersQuotes": d.b("typographersQuotes"), "smartTextReflow": d.b("smartTextReflow"),+ json!({"scaleStrokes": d.b("scaleStrokes"), "dimensionsIncludeStroke": d.b("dimensionsIncludeStroke"), "transformationsAreTotals": d.b("transformationsAreTotals"), "absolutePageNumbers": d.b("absolutePageNumbers"), "highlightHj": d.b("highlightHj"), "highlightKeeps": d.b("highlightKeeps"), "highlightCustomTracking": d.b("highlightCustomTracking"), "highlightSubstitutedFonts": d.b("highlightSubstitutedFonts"), "richBlackOutput": d.b("richBlackOutput"), "typographersQuotes": d.b("typographersQuotes"), "showFontNamesInEnglish": d.b("showFontNamesInEnglish"), "smartTextReflow": d.b("smartTextReflow"),"autocorrect": d.b("autocorrect"), "showAddedText": d.b("showAddedText"), "showNoteAnchors": d.b("showNoteAnchors"),"recoveryMinutes": d.n("recoveryMinutes").unwrap_or(0.5),"autocorrectList": d.s("autocorrectText").lines().filter_map(|l| {@@ -1970,14 +1971,13 @@ fn paragraph_style_options(app: &mut DesignApp, ui: &mut egui::Ui, d: &mut Dialo}"chars" => {let fonts = crate::panels::fonts(app);+ let menu = crate::panels::font_menu(app);egui::Grid::new("psc").num_columns(2).spacing([8.0, 6.0]).show(ui, |ui| {crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Font Family:"));let fam = cur(d, "c.fontFamily", &cv["fontFamily"]).as_str().unwrap_or("").to_string();- egui::ComboBox::from_id_salt("psfam").selected_text(&fam).width(200.0).show_ui(ui, |ui| {- for f in fonts.families() {- if ui.selectable_label(f == fam, &f).clicked() {- d.fields.insert("c.fontFamily".into(), json!(f));- }+ egui::ComboBox::from_id_salt("psfam").selected_text(crate::panels::font_label(app, &menu, &fam)).width(200.0).show_ui(ui, |ui| {+ if let Some(f) = crate::panels::font_menu_rows(app, ui, &menu, &fam) {+ d.fields.insert("c.fontFamily".into(), json!(f));}});ui.end_row();@@ -2625,8 +2625,9 @@ fn find_font(app: &mut DesignApp, ui: &mut egui::Ui, d: &mut Dialog) {ui.add_space(8.0);crate::rtl::label(ui, egui::RichText::new(crate::i18n::tr(&app.ui.language, "Replace With")).font(semibold(12.0)));let db = crate::panels::fonts(app);- let families = db.families();- let fam_opts: Vec<(&str, &str)> = families.iter().map(|f| (f.as_str(), f.as_str())).collect();+ let menu = crate::panels::font_menu(app);+ let english = app.session.prefs.show_font_names_in_english;+ let fam_opts: Vec<(&str, &str)> = menu.iter().map(|f| (f.family.as_str(), f.label(english))).collect();egui::Grid::new("ff_to").num_columns(2).spacing([8.0, 6.0]).show(ui, |ui| {crate::rtl::label(ui, crate::i18n::tr(&app.ui.language, "Font Family:"));combo(ui, d, "toFamily", &fam_opts);diff --git a/crates/ui-egui/src/i18n.rs b/crates/ui-egui/src/i18n.rsindex c3c5352de..43979eec7 100644--- a/crates/ui-egui/src/i18n.rs+++ b/crates/ui-egui/src/i18n.rs@@ -2559,6 +2559,16 @@ const TABLE: &[(&str, [&str; 5])] = &[("Interface", ["Interface", "Interface", "Interface", "Interface", "界面"]),("Advanced Type", ["Advanced Type", "Advanced Type", "Advanced Type", "Advanced Type", "高级文字"]),("Composition", ["Composition", "Composition", "Composition", "Composition", "排版"]),+ (+ "Show Font Names in English",+ [+ "Schriftnamen auf Englisch anzeigen",+ "Afficher les noms de police en anglais",+ "Mostrar nombres de fuentes en inglés",+ "フォント名を英語で表示",+ "以英文显示字体名称",+ ],+ ),("Missing Glyphs", ["Fehlende Glyphen", "Glyphes manquants", "Glifos que faltan", "欠落グリフ", "缺失字形"]),("Draw Missing Glyphs from Fallback Fonts",diff --git a/crates/ui-egui/src/i18n/ar.rs b/crates/ui-egui/src/i18n/ar.rsindex 9f8f4e3d1..34375752a 100644--- a/crates/ui-egui/src/i18n/ar.rs+++ b/crates/ui-egui/src/i18n/ar.rs@@ -971,6 +971,7 @@ pub(super) const TABLE: &[(&str, &str)] = &[("Interface", "الواجهة"),("Advanced Type", "إعدادات النص المتقدمة"),("Composition", "تنضيد النص"),+ ("Show Font Names in English", "إظهار أسماء الخطوط بالإنجليزية"),("Missing Glyphs", "الحروف الناقصة"),("Draw Missing Glyphs from Fallback Fonts", "رسم الحروف الناقصة بخطوط بديلة"),("Units & Increments", "الوحدات والزيادات"),diff --git a/crates/ui-egui/src/panels/glyphs.rs b/crates/ui-egui/src/panels/glyphs.rsindex 3755e187c..d0fa75efc 100644--- a/crates/ui-egui/src/panels/glyphs.rs+++ b/crates/ui-egui/src/panels/glyphs.rs@@ -33,12 +33,11 @@ pub fn show(app: &mut DesignApp, ui: &mut egui::Ui) {}let (db, scope) = (super::fonts(app), super::font_scope(app));ui.horizontal(|ui| {- egui::ComboBox::from_id_salt("glyph_family").selected_text(&st.family).width(140.0).show_ui(ui, |ui| {- for f in db.families() {- if ui.selectable_label(f == st.family, &f).clicked() {- st.style = db.styles(&f).into_iter().next().unwrap_or_else(|| "Regular".into());- st.family = f;- }+ let menu = super::font_menu(app);+ egui::ComboBox::from_id_salt("glyph_family").selected_text(super::font_label(app, &menu, &st.family)).width(140.0).show_ui(ui, |ui| {+ if let Some(f) = super::font_menu_rows(app, ui, &menu, &st.family) {+ st.style = db.styles(&f).into_iter().next().unwrap_or_else(|| "Regular".into());+ st.family = f;}});egui::ComboBox::from_id_salt("glyph_style").selected_text(&st.style).width(80.0).show_ui(ui, |ui| {diff --git a/crates/ui-egui/src/panels/mod.rs b/crates/ui-egui/src/panels/mod.rsindex b9bffd839..ef19590a2 100644--- a/crates/ui-egui/src/panels/mod.rs+++ b/crates/ui-egui/src/panels/mod.rs@@ -108,6 +108,44 @@ pub fn fonts(app: &DesignApp) -> designcraft_fonts::ScopedFonts<'static> {designcraft_fonts::FontDb::global().scoped(font_scope(app))}+/// The font menus' families in menu order: Western (and other scripts) first, then Japanese,+/// Simplified Chinese, Traditional Chinese and Korean, each alphabetical by the name shown (CJK+/// families by their native names unless Show Font Names in English).+pub fn font_menu(app: &DesignApp) -> Vec<designcraft_fonts::FamilyInfo> {+ let mut v = fonts(app).family_infos();+ designcraft_fonts::sort_for_menu(&mut v, app.session.prefs.show_font_names_in_english);+ v+}++/// The name the font menus show for `family` (its native name, see [`font_menu`]).+pub fn font_label(app: &DesignApp, menu: &[designcraft_fonts::FamilyInfo], family: &str) -> String {+ let english = app.session.prefs.show_font_names_in_english;+ menu.iter().find(|f| f.family == family).map_or(family, |f| f.label(english)).to_string()+}++/// `menu` as rows of a popup or combo box: the name shown (the English name on hover when they+/// differ), a separator between groups. Returns the family clicked.+pub fn font_menu_rows(app: &DesignApp, ui: &mut egui::Ui, menu: &[designcraft_fonts::FamilyInfo], current: &str) -> Option<String> {+ let english = app.session.prefs.show_font_names_in_english;+ let mut pick = None;+ let mut group = None;+ for f in menu {+ if group.is_some_and(|g| g != f.group) {+ ui.separator();+ }+ group = Some(f.group);+ let label = f.label(english);+ let mut resp = ui.selectable_label(f.family == current, label);+ if label != f.family {+ resp = resp.on_hover_text(&f.family);+ }+ if resp.clicked() {+ pick = Some(f.family.clone());+ }+ }+ pick+}+/// The active document's font scope (0 without a document or fonts of its own).pub fn font_scope(app: &DesignApp) -> u32 {app.session.active().map_or(0, |d| d.doc.font_scope)@@ -201,16 +239,22 @@ fn paint_star(p: &egui::Painter, c: egui::Pos2, r: f32, filled: bool, color: egu/// that family.pub fn font_family_picker(app: &mut DesignApp, ui: &mut egui::Ui, current: &str, width: f32) {let (fonts, scope) = (fonts(app), font_scope(app));- let fams = fonts.families();+ let menu = font_menu(app);+ let english = app.session.prefs.show_font_names_in_english;+ let shown_current = font_label(app, &menu, current);let mut favs = app.session.prefs.favorite_fonts.clone();let mut pick = None;let mut favs_changed = false;let state_id = egui::Id::new("font_menu_state");let (mut query, mut only_favs): (String, bool) = ui.data(|d| d.get_temp(state_id)).unwrap_or_default();let t = crate::theme::Tokens::get(ui.ctx());- egui::ComboBox::from_id_salt("font_family").selected_text(if current.is_empty() { "—" } else { current }).width(width).height(420.0).show_ui(- ui,- |ui| {+ egui::ComboBox::from_id_salt("font_family")+ .selected_text(if current.is_empty() { "—" } else { &shown_current })+ .width(width)+ .height(420.0)+ // The search field, Favorites and the stars keep the menu open; picking a font closes it.+ .close_behavior(egui::PopupCloseBehavior::CloseOnClickOutside)+ .show_ui(ui, |ui| {ui.set_min_width(300.0);ui.horizontal(|ui| {ui.add(@@ -224,13 +268,24 @@ pub fn font_family_picker(app: &mut DesignApp, ui: &mut egui::Ui, current: &str,});let q = query.to_lowercase();let ppp = ui.ctx().pixels_per_point();- let shown: Vec<&String> =- fams.iter().filter(|f| (q.is_empty() || f.to_lowercase().contains(&q)) && (!only_favs || favs.contains(f))).collect();- for f in shown {- let (row, resp) = ui.allocate_exact_size(egui::vec2(ui.available_width(), 24.0), egui::Sense::click());+ let shown: Vec<&designcraft_fonts::FamilyInfo> =+ menu.iter().filter(|f| f.matches(&q) && (!only_favs || favs.contains(&f.family))).collect();+ let mut group = None;+ for info in shown {+ // A separator between the Western fonts and each CJK language's.+ if group.is_some_and(|g| g != info.group) {+ ui.separator();+ }+ group = Some(info.group);+ let f = &info.family;+ let label = info.label(english);+ let (row, mut resp) = ui.allocate_exact_size(egui::vec2(ui.available_width(), 24.0), egui::Sense::click());if !ui.is_rect_visible(row) {continue;}+ if label != f {+ resp = resp.on_hover_text(f);+ }if f == current {ui.painter().rect_filled(row, 0.0, t.row_selected);} else if resp.hovered() {@@ -249,7 +304,7 @@ pub fn font_family_picker(app: &mut DesignApp, ui: &mut egui::Ui, current: &str,}favs_changed = true;}- ui.painter().text(row.min + egui::vec2(22.0, 12.0), egui::Align2::LEFT_CENTER, f, egui::FontId::proportional(12.0), t.text);+ ui.painter().text(row.min + egui::vec2(22.0, 12.0), egui::Align2::LEFT_CENTER, label, egui::FontId::proportional(12.0), t.text);// The name in its own face (rendered once per family and scale).let key = egui::Id::new(("font_preview", f, scope, (ppp * 100.0) as u32, t.text.to_array()));let tex: Option<egui::TextureHandle> = ui.data(|d| d.get_temp(key));@@ -270,10 +325,10 @@ pub fn font_family_picker(app: &mut DesignApp, ui: &mut egui::Ui, current: &str,);if resp.clicked() {pick = Some(f.clone());+ ui.close();}}- },- );+ });ui.data_mut(|d| d.insert_temp(state_id, (query, only_favs)));if favs_changed {let _ = app.run("prefs.set", json!({ "favoriteFonts": favs }));@@ -316,3 +371,29 @@ pub fn para_style_picker(app: &mut DesignApp, ui: &mut egui::Ui, current: &str,let _ = app.run("style.paragraph.apply", json!({"name": n, "clearOverrides": false}));}}++#[cfg(test)]+mod font_menu_tests {+ use designcraft_fonts::FontGroup;+ use designcraft_fonts::testing::{font_with, with_names};++ use super::*;++ #[test]+ fn cjk_fonts_follow_the_western_ones_under_their_native_names() {+ const FAMILY: &str = "DC UI Test Mincho";+ let font = font_with(FAMILY, &['a']).unwrap();+ let font = with_names(&font, &[(3, 1, 0x409, 1, FAMILY), (3, 1, 0x409, 2, "Regular"), (3, 1, 0x0411, 1, "UIテスト明朝")]).unwrap();+ designcraft_fonts::FontDb::global().add_font(font);+ let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());+ let menu = font_menu(&app);+ let at = menu.iter().position(|f| f.family == FAMILY).unwrap();+ assert_eq!(menu[at].group, FontGroup::Japanese);+ assert!(menu[..at].iter().any(|f| f.family == designcraft_fonts::DEFAULT_FAMILY), "Western fonts first");+ assert!(menu.windows(2).all(|w| w[0].group <= w[1].group), "grouped");+ assert_eq!(font_label(&app, &menu, FAMILY), "UIテスト明朝");+ assert_eq!(font_label(&app, &menu, designcraft_fonts::DEFAULT_FAMILY), designcraft_fonts::DEFAULT_FAMILY);+ app.run("prefs.set", json!({"showFontNamesInEnglish": true})).unwrap();+ assert_eq!(font_label(&app, &font_menu(&app), FAMILY), FAMILY);+ }+}diff --git a/crates/ui-egui/src/panels/properties.rs b/crates/ui-egui/src/panels/properties.rsindex 648d7a9bc..8644fe796 100644--- a/crates/ui-egui/src/panels/properties.rs+++ b/crates/ui-egui/src/panels/properties.rs@@ -987,7 +987,7 @@ fn character_section(app: &mut DesignApp, ui: &mut Ui) {let fw = full_width(ui);// Family dropdown with a search segment on the left.let fonts = super::fonts(app);- let fams = fonts.families();+ let menu = super::font_menu(app);let resp = widgets::dropdown(ui, "", fw);let r = resp.rect;icons::paint(ui.painter(), Rect::from_min_size(r.min + vec2(3.0, 3.0), vec2(14.0, 14.0)), "search", t.icon);@@ -995,7 +995,7 @@ fn character_section(app: &mut DesignApp, ui: &mut Ui) {ui.painter().text(r.min + vec2(30.0, 10.5),egui::Align2::LEFT_CENTER,- if fam.is_empty() { "—" } else { &fam },+ if fam.is_empty() { "—".to_string() } else { super::font_label(app, &menu, &fam) },egui::FontId::proportional(11.5),t.text,);@@ -1003,11 +1003,9 @@ fn character_section(app: &mut DesignApp, ui: &mut Ui) {egui::Popup::menu(&resp).show(|ui| {ui.set_min_width(fw);egui::ScrollArea::vertical().max_height(360.0).show(ui, |ui| {- for f in &fams {- if ui.selectable_label(*f == fam, f).clicked() {- pick_fam = Some(f.clone());- ui.close();- }+ if let Some(f) = super::font_menu_rows(app, ui, &menu, &fam) {+ pick_fam = Some(f);+ ui.close();}});});diff --git a/crates/ui-egui/src/taskbar.rs b/crates/ui-egui/src/taskbar.rsindex caafdc1d7..47b05ff92 100644--- a/crates/ui-egui/src/taskbar.rs+++ b/crates/ui-egui/src/taskbar.rs@@ -108,10 +108,13 @@ fn text_controls(app: &mut DesignApp, ui: &mut Ui, in_text: bool) {let fam = c["fontFamily"].as_str().unwrap_or("").to_string();let sty = c["fontStyle"].as_str().unwrap_or("").to_string();let fonts = panels::fonts(app);- let fams = fonts.families();- let cur = fams.iter().position(|f| *f == fam);- if let Some(k) = widgets::dropdown_list(ui, if fam.is_empty() { "—" } else { &fam }, 150.0, &fams, cur) {- let f = fams[k].clone();+ let menu = panels::font_menu(app);+ let english = app.session.prefs.show_font_names_in_english;+ let labels: Vec<String> = menu.iter().map(|f| f.label(english).to_string()).collect();+ let cur = menu.iter().position(|f| f.family == fam);+ let shown = if fam.is_empty() { "—".to_string() } else { panels::font_label(app, &menu, &fam) };+ if let Some(f) = widgets::dropdown_list(ui, &shown, 150.0, &labels, cur).and_then(|k| menu.get(k)) {+ let f = f.family.clone();let styles = fonts.styles(&f);let style = if styles.iter().any(|s| s == "Regular") { "Regular".to_string() } else { styles.first().cloned().unwrap_or_default() };let _ = app.run("type.char", json!({"attrs": {"fontFamily": f, "fontStyle": style}}));diff --git a/docs/cjk.md b/docs/cjk.mdindex 2ca3de2e9..05e50845e 100644--- a/docs/cjk.md+++ b/docs/cjk.md@@ -44,6 +44,7 @@ presets or tables are copied. Our default mojikumi and kinsoku tables are built| Composite fonts | done: model, `style.compositeFont.*`, shaping, IDML, font list, replace and Preflight; no dialog || Languages | Japanese, Korean, Simplified and Traditional Chinese reach the shaper (`locl`), font fallback, line breaking and typographer's quotes; IDML language names are kept as written and recognised in their common spellings and locale codes ("Simplified Chinese", "Chinese (Traditional)", `zh_CN`, `zh-Hant`, `ja_JP`, `ko-KR`) || Missing glyphs | as in InDesign: characters the applied font lacks are drawn as its missing-glyph box (screen and PDF) and listed by Preflight; the document setting Draw Missing Glyphs from Fallback Fonts (Preferences › Composition, off in new documents and IDML imports, on in documents saved before it existed) draws them from fallback fonts instead |+| Font menus | Western families first, then Japanese, Simplified Chinese, Traditional Chinese and Korean groups (from the font's `meta` languages, CJK family names, OS/2 code pages, else its coverage); CJK families under their native names unless Preferences › Type › Show Font Names in English; the order is recalled from InDesign, not observed || CJK fonts | Japanese faces (Shippori Mincho first) from the optional craft-fonts build input, in the font menus for users to apply; fallback by language (with fallback fonts on) (Japanese: the craft-fonts faces, then system fonts; Simplified and Traditional Chinese, Korean: system fonts); document fonts: the fonts of a `Document Fonts` folder beside an opened file belong to that document (composition, export, font menus), ahead of installed fonts of the same name, and are forgotten when it closes; Package copies every font file that draws text, fallback fonts included (licence permitting). Font files stay in memory for the session (reopening a document reuses them) and aren't read on the web || Everything else below | missing |