Skip to content

DesignCraft: An open-source page and layout design editor written by scratch in pure Rust

Fonts: installed fonts are found by name whatever ran before

japbcoelho48e409e214ce
diff --git a/crates/fonts/src/fontdb.rs b/crates/fonts/src/fontdb.rs
index ac3ac5a61..97ba6d94a 100644
--- a/crates/fonts/src/fontdb.rs
+++ b/crates/fonts/src/fontdb.rs
@@ -1,4 +1,5 @@
-//! Font database: bundled OFL fonts, user fonts, optional system font catalog, outline cache.
+//! Font database: bundled OFL fonts, user fonts, the installed system fonts (cataloged the first
+//! time a lookup needs them, native only), outline cache.
use std::collections::HashMap;
use std::sync::atomic::{AtomicU32, Ordering};
@@ -223,7 +224,14 @@ pub struct FontDb {
outlines: Mutex<HashMap<(u32, u32), Arc<BezPath>>>,
#[cfg(not(target_arch = "wasm32"))]
catalog: RwLock<Vec<CatalogEntry>>,
- /// System fallback state: scanned yet, and characters no system font covers.
+ /// The folders the system font scan reads (the platform's font folders for [`FontDb::global`]).
+ #[cfg_attr(target_arch = "wasm32", allow(dead_code))]
+ font_dirs: Vec<std::path::PathBuf>,
+ /// Set once the font folders have been scanned. Lookups by family name wait for the first
+ /// scan, so what they find doesn't depend on what ran before them.
+ #[cfg(not(target_arch = "wasm32"))]
+ cataloged: std::sync::OnceLock<()>,
+ /// System fallback state: enabled, and characters no system font covers.
#[cfg(not(target_arch = "wasm32"))]
sys: Mutex<SysFallback>,
}
@@ -232,7 +240,6 @@ pub struct FontDb {
#[derive(Default)]
struct SysFallback {
enabled: bool,
- scanned: bool,
misses: std::collections::HashSet<char>,
}
@@ -273,6 +280,93 @@ fn name(font: &skrifa::FontRef<'_>, ids: &[StringId]) -> Option<String> {
ids.iter().find_map(|id| font.localized_strings(*id).english_or_first().map(|s| s.to_string()).filter(|s| !s.is_empty()))
}
+/// A face's family and style names (the default instance's style for a variable font).
+fn face_names(f: &skrifa::FontRef<'_>) -> Option<(String, String)> {
+ let family = name(f, &[StringId::TYPOGRAPHIC_FAMILY_NAME, StringId::FAMILY_NAME])?;
+ let style = name(f, &[StringId::TYPOGRAPHIC_SUBFAMILY_NAME, StringId::SUBFAMILY_NAME]).unwrap_or_else(|| "Regular".into());
+ 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.
+#[cfg(not(target_arch = "wasm32"))]
+fn file_face_names(path: &std::path::Path) -> Vec<(String, String)> {
+ 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;
+ 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];
+ file.seek(SeekFrom::Start(offset)).ok()?;
+ file.read_exact(&mut buf).ok()?;
+ Some(buf)
+ };
+ let be32 = |b: &[u8], at: usize| b.get(at..at + 4).and_then(|s| s.try_into().ok()).map(u32::from_be_bytes);
+ let Some(head) = read_at(0, 12) else { return vec![] };
+ // A collection lists where each face's table directory starts.
+ let starts: Vec<u32> = if head.starts_with(b"ttcf") {
+ let n = be32(&head, 8).unwrap_or(0).min(MAX_FACES) as usize;
+ read_at(12, n * 4).map(|b| b.as_chunks::<4>().0.iter().map(|c| u32::from_be_bytes(*c)).collect()).unwrap_or_default()
+ } else {
+ vec![0]
+ };
+ starts
+ .into_iter()
+ .filter_map(|start| {
+ 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()?)
+ })
+ .collect()
+}
+
+/// The platform's font folders (the system's and the user's), scanned by [`FontDb::global`].
+/// Empty on wasm.
+pub fn system_font_dirs() -> Vec<std::path::PathBuf> {
+ let mut dirs: Vec<std::path::PathBuf> = Vec::new();
+ if cfg!(target_arch = "wasm32") {
+ return dirs;
+ }
+ let home = std::env::var_os("HOME").map(std::path::PathBuf::from);
+ if cfg!(target_os = "macos") {
+ dirs.extend(["/System/Library/Fonts", "/Library/Fonts"].map(Into::into));
+ if let Some(h) = &home {
+ dirs.push(h.join("Library/Fonts"));
+ }
+ } else if cfg!(windows) {
+ let root = std::env::var_os("WINDIR").map(std::path::PathBuf::from).unwrap_or_else(|| "C:\\Windows".into());
+ dirs.push(root.join("Fonts"));
+ if let Some(l) = std::env::var_os("LOCALAPPDATA") {
+ dirs.push(std::path::PathBuf::from(l).join("Microsoft\\Windows\\Fonts"));
+ }
+ } else {
+ dirs.extend(["/usr/share/fonts", "/usr/local/share/fonts"].map(Into::into));
+ if let Some(h) = &home {
+ dirs.push(h.join(".fonts"));
+ dirs.push(h.join(".local/share/fonts"));
+ }
+ }
+ dirs
+}
+
/// One face found in a font file: index, family, style and (variable fonts) the named instance's
/// axis settings.
type Found = (u32, String, String, Vec<([u8; 4], f32)>);
@@ -288,7 +382,7 @@ fn enumerate_faces(data: &[u8]) -> Vec<Found> {
let mut out = Vec::new();
for i in 0..count {
let Ok(f) = skrifa::FontRef::from_index(data, i) else { continue };
- let Some(family) = name(&f, &[StringId::TYPOGRAPHIC_FAMILY_NAME, StringId::FAMILY_NAME]) else { continue };
+ let Some((family, style)) = face_names(&f) else { continue };
let axes = f.axes();
let mut named = Vec::new();
for ni in f.named_instances().iter() {
@@ -300,7 +394,6 @@ fn enumerate_faces(data: &[u8]) -> Vec<Found> {
named.push((i, style, coords));
}
if named.is_empty() {
- let style = name(&f, &[StringId::TYPOGRAPHIC_SUBFAMILY_NAME, StringId::SUBFAMILY_NAME]).unwrap_or_else(|| "Regular".into());
out.push((i, family, style, Vec::new()));
} else {
out.extend(named.into_iter().map(|(i, s, c)| (i, family.clone(), s, c)));
@@ -400,7 +493,8 @@ fn style_italic(style: &str) -> bool {
}
impl FontDb {
- fn new_bundled() -> Self {
+ /// A database holding the bundled fonts, whose system font scan reads `font_dirs`.
+ pub fn with_font_dirs(font_dirs: Vec<std::path::PathBuf>) -> Self {
let mut faces = Vec::new();
for data in BUNDLED {
for (i, family, style, coords) in enumerate_faces(data) {
@@ -414,6 +508,9 @@ impl FontDb {
outlines: Mutex::new(HashMap::new()),
#[cfg(not(target_arch = "wasm32"))]
catalog: RwLock::new(Vec::new()),
+ font_dirs,
+ #[cfg(not(target_arch = "wasm32"))]
+ cataloged: std::sync::OnceLock::new(),
#[cfg(not(target_arch = "wasm32"))]
sys: Mutex::new(SysFallback { enabled: true, ..Default::default() }),
}
@@ -430,21 +527,30 @@ impl FontDb {
let _ = on;
}
- /// Process-wide database preloaded with the bundled fonts.
+ /// Process-wide database: the bundled fonts, then the installed system fonts, cataloged the
+ /// first time a lookup by family name needs them (or ahead of time by
+ /// [`FontDb::scan_in_background`]).
pub fn global() -> &'static FontDb {
static DB: std::sync::OnceLock<FontDb> = std::sync::OnceLock::new();
- DB.get_or_init(FontDb::new_bundled)
+ DB.get_or_init(|| FontDb::with_font_dirs(system_font_dirs()))
}
fn read_faces(&self) -> std::sync::RwLockReadGuard<'_, Vec<Arc<FontFace>>> {
self.faces.read().unwrap_or_else(|e| e.into_inner())
}
+ /// The system font catalog, scanned first if it hasn't been yet.
+ #[cfg(not(target_arch = "wasm32"))]
+ fn read_catalog(&self) -> std::sync::RwLockReadGuard<'_, Vec<CatalogEntry>> {
+ self.ensure_catalog();
+ self.catalog.read().unwrap_or_else(|e| e.into_inner())
+ }
+
/// Family names available (loaded plus cataloged system fonts), sorted and deduplicated.
pub fn families(&self) -> Vec<String> {
let mut v: Vec<String> = self.read_faces().iter().map(|f| f.family.clone()).collect();
#[cfg(not(target_arch = "wasm32"))]
- v.extend(self.catalog.read().unwrap_or_else(|e| e.into_inner()).iter().map(|c| c.family.clone()));
+ v.extend(self.read_catalog().iter().map(|c| c.family.clone()));
v.sort_by_key(|a| a.to_lowercase());
v.dedup_by(|a, b| a.eq_ignore_ascii_case(b));
v
@@ -459,7 +565,7 @@ impl FontDb {
.map(|f| (f.italic, f.weight, f.style.clone()))
.collect();
#[cfg(not(target_arch = "wasm32"))]
- for c in self.catalog.read().unwrap_or_else(|e| e.into_inner()).iter() {
+ for c in self.read_catalog().iter() {
if c.family.eq_ignore_ascii_case(family) && !v.iter().any(|(_, _, s)| s.eq_ignore_ascii_case(&c.style)) {
v.push((style_italic(&c.style), style_weight(&c.style), c.style.clone()));
}
@@ -486,34 +592,47 @@ impl FontDb {
added
}
- /// Scan the platform's font directories and catalog the faces found (native only; not called by
- /// default). Font data is loaded lazily when a cataloged family is first resolved. Returns the
- /// number of faces cataloged.
+ /// Catalog the installed fonts unless that has been done: the first caller scans the font
+ /// folders, any other waits for that scan to finish.
#[cfg(not(target_arch = "wasm32"))]
- pub fn load_system_fonts(&self) -> usize {
- let mut dirs: Vec<std::path::PathBuf> = Vec::new();
- let home = std::env::var_os("HOME").map(std::path::PathBuf::from);
- if cfg!(target_os = "macos") {
- dirs.extend(["/System/Library/Fonts", "/Library/Fonts"].map(Into::into));
- if let Some(h) = &home {
- dirs.push(h.join("Library/Fonts"));
- }
- } else if cfg!(windows) {
- let root = std::env::var_os("WINDIR").map(std::path::PathBuf::from).unwrap_or_else(|| "C:\\Windows".into());
- dirs.push(root.join("Fonts"));
- if let Some(l) = std::env::var_os("LOCALAPPDATA") {
- dirs.push(std::path::PathBuf::from(l).join("Microsoft\\Windows\\Fonts"));
- }
- } else {
- dirs.extend(["/usr/share/fonts", "/usr/local/share/fonts"].map(Into::into));
- if let Some(h) = &home {
- dirs.push(h.join(".fonts"));
- dirs.push(h.join(".local/share/fonts"));
- }
+ fn ensure_catalog(&self) {
+ self.cataloged.get_or_init(|| {
+ self.scan_font_dirs();
+ });
+ }
+
+ /// Catalog the installed fonts on a background thread, so the first lookup by family name
+ /// (opening a file, the font menus) doesn't wait for the scan. A no-op once they are
+ /// cataloged, and on wasm.
+ pub fn scan_in_background(&'static self) {
+ #[cfg(not(target_arch = "wasm32"))]
+ if self.cataloged.get().is_none() {
+ // A failed spawn leaves the scan to the first lookup that needs it.
+ let _ = std::thread::Builder::new().name("font-scan".into()).spawn(move || self.ensure_catalog());
}
+ }
+
+ /// Scan the font folders again (fonts installed or removed since), cataloging the faces
+ /// found (native only). Font data is loaded when a cataloged family is first resolved.
+ /// Returns the number of faces cataloged.
+ #[cfg(not(target_arch = "wasm32"))]
+ pub fn load_system_fonts(&self) -> usize {
+ // The first scan, or a rescan once it is done (never both at once).
+ let mut first = None;
+ self.cataloged.get_or_init(|| first = Some(self.scan_font_dirs()));
+ first.unwrap_or_else(|| self.scan_font_dirs())
+ }
+
+ #[cfg(not(target_arch = "wasm32"))]
+ fn scan_font_dirs(&self) -> usize {
let mut found = Vec::new();
- let mut stack = dirs;
+ let mut stack = self.font_dirs.clone();
+ // Each folder once, however links lead back to it.
+ let mut visited = std::collections::HashSet::new();
while let Some(d) = stack.pop() {
+ if !visited.insert(std::fs::canonicalize(&d).unwrap_or_else(|_| d.clone())) {
+ continue;
+ }
let Ok(rd) = std::fs::read_dir(&d) else { continue };
for e in rd.flatten() {
let p = e.path();
@@ -525,8 +644,7 @@ impl FontDb {
if !matches!(ext.as_deref(), Some("ttf" | "otf" | "ttc" | "otc")) {
continue;
}
- let Ok(data) = std::fs::read(&p) else { continue };
- for (_, family, style, _) in enumerate_faces(&data) {
+ for (family, style) in file_face_names(&p) {
found.push(CatalogEntry { family, style, path: p.clone() });
}
}
@@ -537,11 +655,13 @@ impl FontDb {
n
}
+ /// Load the files of the installed `family`. Returns whether any face was added.
#[cfg(not(target_arch = "wasm32"))]
fn load_cataloged(&self, family: &str) -> bool {
let paths: Vec<std::path::PathBuf> = {
- let cat = self.catalog.read().unwrap_or_else(|e| e.into_inner());
+ let cat = self.read_catalog();
let mut p: Vec<_> = cat.iter().filter(|c| c.family.eq_ignore_ascii_case(family)).map(|c| c.path.clone()).collect();
+ p.sort();
p.dedup();
p
};
@@ -555,7 +675,7 @@ impl FontDb {
}
/// Resolve a family + style to a face, falling back to the closest style of the family, then to
- /// Source Sans 3 Regular.
+ /// Source Sans 3 Regular. Installed system fonts are found by name whatever ran before.
pub fn face(&self, family: &str, style: &str) -> Arc<FontFace> {
if let Some(f) = self.find(family, style) {
return f;
@@ -572,8 +692,19 @@ impl FontDb {
.unwrap_or_else(last_resort_face)
}
- /// Is `family` available (loaded)?
+ /// Is `family` available (loaded, or installed on the system)?
pub fn has_family(&self, family: &str) -> bool {
+ if self.is_loaded(family) {
+ return true;
+ }
+ #[cfg(not(target_arch = "wasm32"))]
+ if self.read_catalog().iter().any(|c| c.family.eq_ignore_ascii_case(family)) {
+ return true;
+ }
+ false
+ }
+
+ fn is_loaded(&self, family: &str) -> bool {
self.read_faces().iter().any(|f| f.family.eq_ignore_ascii_case(family))
}
@@ -676,22 +807,15 @@ impl FontDb {
return false;
}
{
- let mut sys = self.sys.lock().unwrap_or_else(|e| e.into_inner());
+ let sys = self.sys.lock().unwrap_or_else(|e| e.into_inner());
if !sys.enabled || sys.misses.contains(&c) {
return false;
}
- if !sys.scanned {
- sys.scanned = true;
- if self.catalog.read().unwrap_or_else(|e| e.into_inner()).is_empty() {
- drop(sys);
- self.load_system_fonts();
- }
- }
}
let covered = |db: &FontDb| db.read_faces().iter().any(|f| f.covers(c));
- let cataloged: Vec<String> = self.catalog.read().unwrap_or_else(|e| e.into_inner()).iter().map(|e| e.family.clone()).collect();
+ let cataloged: Vec<String> = self.read_catalog().iter().map(|e| e.family.clone()).collect();
for fam in SYSTEM_FALLBACKS {
- if !self.has_family(fam) && cataloged.iter().any(|f| f.eq_ignore_ascii_case(fam)) {
+ if !self.is_loaded(fam) && cataloged.iter().any(|f| f.eq_ignore_ascii_case(fam)) {
self.load_cataloged(fam);
if covered(self) {
return true;
@@ -757,3 +881,8 @@ impl OutlinePen for FlipPen {
self.0.close_path();
}
}
+
+#[cfg(test)]
+#[cfg(not(target_arch = "wasm32"))]
+#[path = "tests_sysfonts.rs"]
+mod tests_sysfonts;
diff --git a/crates/fonts/src/lib.rs b/crates/fonts/src/lib.rs
index 60114e370..7c4bdf699 100644
--- a/crates/fonts/src/lib.rs
+++ b/crates/fonts/src/lib.rs
@@ -9,7 +9,7 @@
mod fontdb;
-pub use fontdb::{FALLBACK_FAMILY, FaceRef, FontDb, FontFace, JAPANESE_FALLBACK, base_style, bundled};
+pub use fontdb::{FALLBACK_FAMILY, FaceRef, FontDb, FontFace, JAPANESE_FALLBACK, base_style, bundled, system_font_dirs};
pub use harfrust::Feature;
use harfrust::{Direction, ShapeOptions, Tag, UnicodeBuffer};
pub use kurbo::BezPath;
diff --git a/crates/fonts/src/tests_sysfonts.rs b/crates/fonts/src/tests_sysfonts.rs
new file mode 100644
index 000000000..2c8a7ae37
--- /dev/null
+++ b/crates/fonts/src/tests_sysfonts.rs
@@ -0,0 +1,136 @@
+//! Installed system fonts: found by family name by every lookup, whatever ran before it (#22).
+
+use std::path::{Path, PathBuf};
+
+use super::*;
+
+const FAMILY: &str = "Sysfont Sans3";
+
+/// A bundled Source Sans 3 file renamed [`FAMILY`] (as long as the original name).
+fn renamed(file: &str) -> Vec<u8> {
+ let mut data = std::fs::read(Path::new(env!("CARGO_MANIFEST_DIR")).join("../../assets/fonts").join(file)).unwrap();
+ let utf16 = |s: &str| s.encode_utf16().flat_map(u16::to_be_bytes).collect::<Vec<u8>>();
+ for (from, to) in [(utf16("Source Sans 3"), utf16(FAMILY)), (b"Source Sans 3".to_vec(), FAMILY.as_bytes().to_vec())] {
+ let mut i = 0;
+ while let Some(at) = data[i..].windows(from.len()).position(|w| w == from) {
+ data[i + at..i + at + to.len()].copy_from_slice(&to);
+ i += at + to.len();
+ }
+ }
+ data
+}
+
+/// The fonts in `faces` as one collection (TTC) file.
+fn collection(faces: &[Vec<u8>]) -> Vec<u8> {
+ let mut out = b"ttcf".to_vec();
+ out.extend_from_slice(&0x0001_0000_u32.to_be_bytes());
+ out.extend_from_slice(&(faces.len() as u32).to_be_bytes());
+ let mut base = 12 + 4 * faces.len();
+ for f in faces {
+ out.extend_from_slice(&(base as u32).to_be_bytes());
+ base += f.len();
+ }
+ for f in faces {
+ // Table offsets count from the start of the collection.
+ let start = out.len() as u32;
+ let mut f = f.clone();
+ let tables = u16::from_be_bytes([f[4], f[5]]) as usize;
+ for r in 0..tables {
+ let at = 12 + r * 16 + 8;
+ let off = u32::from_be_bytes(f[at..at + 4].try_into().unwrap()) + start;
+ f[at..at + 4].copy_from_slice(&off.to_be_bytes());
+ }
+ out.extend_from_slice(&f);
+ }
+ out
+}
+
+/// A font folder (with a subfolder, a damaged font and a file that isn't a font) holding
+/// [`FAMILY`] Regular and Bold.
+fn font_dir(name: &str) -> PathBuf {
+ let dir = std::env::temp_dir().join(format!("dc-sysfonts-{}-{name}", std::process::id()));
+ let _ = std::fs::remove_dir_all(&dir);
+ std::fs::create_dir_all(dir.join("Sub")).unwrap();
+ std::fs::write(dir.join("Sysfont-Regular.ttf"), renamed("SourceSans3-Regular.ttf")).unwrap();
+ std::fs::write(dir.join("Sub/Sysfont-Bold.TTF"), renamed("SourceSans3-Bold.ttf")).unwrap();
+ std::fs::write(dir.join("damaged.ttf"), b"ttcf\0\x01\0\0\xff\xff\xff\xff").unwrap();
+ std::fs::write(dir.join("readme.txt"), FAMILY).unwrap();
+ dir
+}
+
+fn has(list: &[String], family: &str) -> bool {
+ list.iter().any(|f| f == family)
+}
+
+#[test]
+fn every_lookup_by_name_finds_installed_fonts_in_a_fresh_database() {
+ let dir = font_dir("fresh");
+ // Each lookup is the first thing a new database is asked. A folder listed twice is read once.
+ let db = || FontDb::with_font_dirs(vec![dir.clone(), dir.join("Sub/..")]);
+ let f = db().face("sysfont sans3", "Bold");
+ assert_eq!((f.family.as_str(), f.style.as_str()), (FAMILY, "Bold"));
+ assert!(db().has_family(FAMILY));
+ assert!(has(&db().families(), FAMILY));
+ assert_eq!(db().styles(FAMILY), ["Regular", "Bold"]);
+ assert_eq!(db().load_system_fonts(), 2);
+ // Missing fonts stay missing.
+ let db = db();
+ assert!(!db.has_family("No Such Font"));
+ assert_eq!(db.face("No Such Font", "Regular").family, FALLBACK_FAMILY);
+}
+
+#[test]
+fn the_scan_reads_collections_and_loads_fonts_only_when_used() {
+ let dir = font_dir("collection");
+ std::fs::remove_file(dir.join("Sysfont-Regular.ttf")).unwrap();
+ std::fs::remove_file(dir.join("Sub/Sysfont-Bold.TTF")).unwrap();
+ std::fs::write(dir.join("Sysfont.ttc"), collection(&[renamed("SourceSans3-Regular.ttf"), renamed("SourceSans3-Bold.ttf")])).unwrap();
+ let db = FontDb::with_font_dirs(vec![dir.clone()]);
+ assert_eq!(db.styles(FAMILY), ["Regular", "Bold"]);
+ // Cataloged, not loaded.
+ assert!(!db.is_loaded(FAMILY));
+ let bold = db.face(FAMILY, "Bold");
+ assert_eq!((bold.style.as_str(), bold.index()), ("Bold", 1));
+ assert_eq!(db.face(FAMILY, "Regular").index(), 0, "the collection's faces load together");
+}
+
+#[test]
+fn rescanning_finds_fonts_installed_since() {
+ let dir = font_dir("rescan");
+ let later = dir.join("Later");
+ let db = FontDb::with_font_dirs(vec![later.clone()]);
+ assert!(!db.has_family(FAMILY));
+ std::fs::create_dir_all(&later).unwrap();
+ std::fs::copy(dir.join("Sysfont-Regular.ttf"), later.join("Sysfont-Regular.ttf")).unwrap();
+ assert!(!db.has_family(FAMILY), "the folders are scanned once, not on every miss");
+ assert_eq!(db.load_system_fonts(), 1);
+ assert!(db.has_family(FAMILY) && has(&db.families(), FAMILY));
+}
+
+#[test]
+fn a_background_scan_serves_the_first_lookup() {
+ let dir = font_dir("background");
+ let db: &'static FontDb = Box::leak(Box::new(FontDb::with_font_dirs(vec![dir])));
+ db.scan_in_background();
+ // Waits for the scan when it is still running.
+ assert!(has(&db.families(), FAMILY));
+ assert_eq!(db.load_system_fonts(), 2, "a rescan catalogs the two faces again");
+}
+
+#[cfg(unix)]
+#[test]
+fn a_link_back_to_a_parent_folder_ends_the_scan() {
+ let dir = font_dir("loop");
+ std::os::unix::fs::symlink(&dir, dir.join("Sub/loop")).unwrap();
+ let db = FontDb::with_font_dirs(vec![dir]);
+ assert_eq!(db.load_system_fonts(), 2);
+}
+
+#[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())]);
+ 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());
+}
diff --git a/crates/fonts/tests/system_fonts.rs b/crates/fonts/tests/system_fonts.rs
new file mode 100644
index 000000000..62310c34b
--- /dev/null
+++ b/crates/fonts/tests/system_fonts.rs
@@ -0,0 +1,23 @@
+//! A new session finds the installed system fonts by family name (#22). One test in its own
+//! process, so the process-wide database starts fresh, as it does when the app starts.
+// Integration tests: unwrapping and panicking on failure is fine here, unlike in shipped code.
+#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
+
+use designcraft_fonts::{FontDb, system_font_dirs};
+
+#[test]
+fn a_fresh_session_finds_installed_fonts_by_name() {
+ let bundled = FontDb::with_font_dirs(vec![]).families();
+ let probe = FontDb::with_font_dirs(system_font_dirs());
+ probe.load_system_fonts();
+ // An installed family that isn't bundled and that loads.
+ let installed = probe.families();
+ let Some(family) = installed.iter().filter(|f| !bundled.contains(f)).find(|f| probe.face(f, "Regular").family == **f) else {
+ eprintln!("no system fonts installed: nothing to check");
+ return;
+ };
+ // The first lookup in the session: nothing has scanned the font folders yet.
+ assert!(FontDb::global().has_family(family));
+ assert_eq!(&FontDb::global().face(family, "Regular").family, family);
+ assert!(FontDb::global().families().contains(family));
+}
diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs
index 13d37c09c..0f106b023 100644
--- a/crates/ui-egui/src/lib.rs
+++ b/crates/ui-egui/src/lib.rs
@@ -367,6 +367,8 @@ pub struct DesignApp {
impl DesignApp {
pub fn new(session: Session, services: Services) -> Self {
+ // The font menus and the first file opened need the installed fonts: catalog them now.
+ designcraft_fonts::FontDb::global().scan_in_background();
DesignApp {
session,
ui: UiState::default(),