1use crate::theme::FontStyle;
16
17#[derive(Clone, Copy, Debug)]
19pub struct FaceTraits<'a> {
20 pub families: &'a [&'a str],
22 pub width: u16,
24 pub style: FontStyle,
26 pub weight: u16,
28}
29
30#[must_use]
52pub fn select_face(
53 faces: &[FaceTraits<'_>],
54 family: &str,
55 weight: u16,
56 style: FontStyle,
57) -> Option<usize> {
58 let wanted = unicase::UniCase::new(family);
59 let mut candidates: Vec<(usize, &FaceTraits<'_>)> = faces
60 .iter()
61 .enumerate()
62 .filter(|(_, face)| {
63 face.families
64 .iter()
65 .any(|name| unicase::UniCase::new(*name) == wanted)
66 })
67 .collect();
68 if candidates.is_empty() {
69 return None;
70 }
71 keep_best(&mut candidates, |face| width_rank(face.width));
72 keep_best(&mut candidates, |face| style_rank(face.style, style));
73 keep_best(&mut candidates, |face| weight_rank(face.weight, weight));
74 candidates.first().map(|(index, _)| *index)
75}
76
77fn keep_best(
79 candidates: &mut Vec<(usize, &FaceTraits<'_>)>,
80 rank: impl Fn(&FaceTraits<'_>) -> (u8, u16),
81) {
82 if let Some(best) = candidates.iter().map(|(_, face)| rank(face)).min() {
83 candidates.retain(|(_, face)| rank(face) == best);
84 }
85}
86
87fn width_rank(width: u16) -> (u8, u16) {
89 const NORMAL: u16 = 5;
90 match width.cmp(&NORMAL) {
91 std::cmp::Ordering::Equal => (0, 0),
92 std::cmp::Ordering::Less => (1, NORMAL.saturating_sub(width)),
93 std::cmp::Ordering::Greater => (2, width),
94 }
95}
96
97fn style_rank(face: FontStyle, wanted: FontStyle) -> (u8, u16) {
99 let rank = match (wanted, face) {
100 (w, f) if w == f => 0,
101 (FontStyle::Italic, FontStyle::Oblique)
102 | (FontStyle::Oblique, FontStyle::Italic)
103 | (FontStyle::Normal, FontStyle::Oblique) => 1,
104 _ => 2,
105 };
106 (rank, 0)
107}
108
109fn weight_rank(face: u16, wanted: u16) -> (u8, u16) {
111 let below = wanted.saturating_sub(face);
112 match wanted {
113 400..=500 if face >= wanted && face <= 500 => (0, face),
114 400..=500 if face < wanted => (1, below),
115 400..=500 => (2, face),
116 0..=399 if face <= wanted => (0, below),
117 0..=399 => (1, face),
118 _ if face >= wanted => (0, face),
119 _ => (1, below),
120 }
121}
122
123#[must_use]
130pub fn is_macos_system_ui_family(family: &str) -> bool {
131 unicase::UniCase::new(family) == unicase::UniCase::new("SF Pro")
132}
133
134#[must_use]
146pub fn is_macos_system_mono_family(family: &str) -> bool {
147 unicase::UniCase::new(family) == unicase::UniCase::new("SF Mono")
148}
149
150#[cfg(feature = "system-fonts")]
152#[derive(Clone, Debug, PartialEq, Eq)]
153pub struct SystemFace {
154 pub data: std::sync::Arc<[u8]>,
157 pub index: u32,
159 pub family: std::sync::Arc<str>,
164 pub weight: u16,
166 pub style: FontStyle,
168}
169
170#[cfg(feature = "system-fonts")]
174fn database() -> &'static fontdb::Database {
175 static DB: std::sync::OnceLock<fontdb::Database> = std::sync::OnceLock::new();
176 DB.get_or_init(|| {
177 let mut db = fontdb::Database::new();
178 db.load_system_fonts();
179 db
180 })
181}
182
183#[cfg(feature = "system-fonts")]
184fn style_of(style: fontdb::Style) -> FontStyle {
185 match style {
186 fontdb::Style::Normal => FontStyle::Normal,
187 fontdb::Style::Italic => FontStyle::Italic,
188 fontdb::Style::Oblique => FontStyle::Oblique,
189 }
190}
191
192#[cfg(feature = "system-fonts")]
194fn face_in(
195 db: &fontdb::Database,
196 family: &str,
197 weight: u16,
198 style: FontStyle,
199) -> Option<SystemFace> {
200 let infos: Vec<&fontdb::FaceInfo> = db.faces().collect();
201 let names: Vec<Vec<&str>> = infos
202 .iter()
203 .map(|info| {
204 info.families
205 .iter()
206 .map(|(name, _)| name.as_str())
207 .collect()
208 })
209 .collect();
210 let traits: Vec<FaceTraits<'_>> = infos
211 .iter()
212 .zip(&names)
213 .map(|(info, names)| FaceTraits {
214 families: names,
215 width: info.stretch.to_number(),
216 style: style_of(info.style),
217 weight: info.weight.0,
218 })
219 .collect();
220 let chosen = select_face(&traits, family, weight, style)?;
221 let info = infos.get(chosen)?;
222 let (data, index) = db.with_face_data(info.id, |data, index| {
223 (std::sync::Arc::<[u8]>::from(data), index)
224 })?;
225 let (recorded, _) = info.families.first()?;
226 Some(SystemFace {
227 data,
228 index,
229 family: std::sync::Arc::from(recorded.as_str()),
230 weight: info.weight.0,
231 style: style_of(info.style),
232 })
233}
234
235#[cfg(feature = "system-fonts")]
255#[must_use]
256pub fn system_face(family: &str, weight: u16, style: FontStyle) -> Option<SystemFace> {
257 #[cfg(target_os = "macos")]
258 {
259 let italic = matches!(style, FontStyle::Italic | FontStyle::Oblique);
260 let ui = crate::macos::system_ui_font(italic);
261 let names_it = is_macos_system_ui_family(family)
262 || ui.as_ref().is_some_and(|font| {
263 unicase::UniCase::new(family) == unicase::UniCase::new(font.family.as_str())
264 });
265 if names_it {
266 return ui.and_then(|font| face_in_file(&font.path, weight, style));
267 }
268 }
269 face_in(database(), family, weight, style)
270}
271
272#[cfg(all(feature = "system-fonts", target_os = "macos"))]
275fn face_in_file(path: &std::path::Path, weight: u16, style: FontStyle) -> Option<SystemFace> {
276 let mut db = fontdb::Database::new();
277 db.load_font_file(path).ok()?;
278 let recorded = db.faces().next()?.families.first()?.0.clone();
279 face_in(&db, &recorded, weight, style)
280}
281
282#[cfg(feature = "system-fonts")]
306#[must_use]
307pub fn substitute_family(family: &str) -> Option<String> {
308 platform_substitute(family)
309}
310
311#[cfg(feature = "system-fonts")]
322#[must_use]
323pub fn substitute_family_cached(family: &str) -> Option<String> {
324 static ASKED: std::sync::OnceLock<AskedFamilies> = std::sync::OnceLock::new();
325 asked_once(
326 ASKED.get_or_init(AskedFamilies::default),
327 family,
328 substitute_family,
329 )
330}
331
332#[cfg(feature = "system-fonts")]
334type AskedFamilies = std::sync::Mutex<std::collections::HashMap<String, Option<String>>>;
335
336#[cfg(feature = "system-fonts")]
347fn asked_once(
348 asked: &AskedFamilies,
349 family: &str,
350 ask: impl FnOnce(&str) -> Option<String>,
351) -> Option<String> {
352 let lock = || {
353 asked
354 .lock()
355 .unwrap_or_else(std::sync::PoisonError::into_inner)
356 };
357 let kept = lock().get(family).cloned();
358 if let Some(answer) = kept {
359 return answer;
360 }
361 let answer = ask(family);
362 lock().insert(family.to_owned(), answer.clone());
363 answer
364}
365
366#[cfg(all(
367 feature = "system-fonts",
368 unix,
369 not(target_os = "macos"),
370 not(target_os = "ios"),
371 not(target_os = "android")
372))]
373fn platform_substitute(family: &str) -> Option<String> {
374 let printed = crate::detect::stdout_with_timeout(
375 "fc-match",
376 &["--format=%{family[0]}", &fontconfig_family(family)],
377 crate::detect::SUBPROCESS_TIMEOUT,
378 )?;
379 let matched = printed.trim();
380 if matched.is_empty() || unicase::UniCase::new(matched) == unicase::UniCase::new(family) {
381 return None;
382 }
383 Some(matched.to_owned())
384}
385
386#[cfg(all(
387 feature = "system-fonts",
388 not(all(
389 unix,
390 not(target_os = "macos"),
391 not(target_os = "ios"),
392 not(target_os = "android")
393 ))
394))]
395fn platform_substitute(_family: &str) -> Option<String> {
396 None
397}
398
399#[cfg(all(
406 feature = "system-fonts",
407 unix,
408 not(target_os = "macos"),
409 not(target_os = "ios"),
410 not(target_os = "android")
411))]
412fn fontconfig_family(family: &str) -> String {
413 let mut pattern = String::with_capacity(family.len());
414 for c in family.chars() {
415 if matches!(c, '\\' | '-' | ':' | ',') {
416 pattern.push('\\');
417 }
418 pattern.push(c);
419 }
420 pattern
421}
422
423#[cfg(test)]
424#[allow(
425 clippy::unwrap_used,
426 clippy::expect_used,
427 clippy::panic,
428 clippy::indexing_slicing,
429 reason = "a test fails by panicking"
430)]
431mod tests {
432 use super::*;
433
434 const N: FontStyle = FontStyle::Normal;
435 const I: FontStyle = FontStyle::Italic;
436 const O: FontStyle = FontStyle::Oblique;
437
438 fn face(
439 families: &'static [&'static str],
440 width: u16,
441 style: FontStyle,
442 weight: u16,
443 ) -> FaceTraits<'static> {
444 FaceTraits {
445 families,
446 width,
447 style,
448 weight,
449 }
450 }
451
452 #[test]
456 fn the_family_is_matched_caselessly_and_never_substituted() {
457 let faces = [face(&["Inter"], 5, N, 400), face(&["Roboto"], 5, N, 400)];
458 assert_eq!(select_face(&faces, "inter", 400, N), Some(0));
459 assert_eq!(select_face(&faces, "INTER", 400, N), Some(0));
460 assert_eq!(select_face(&faces, "Helvetica", 400, N), None);
461 assert_eq!(select_face(&[], "Inter", 400, N), None);
462 }
463
464 #[test]
466 fn any_recorded_family_name_matches() {
467 let faces = [face(&["Segoe UI", "Segoe UI Regular"], 5, N, 400)];
468 assert_eq!(select_face(&faces, "segoe ui regular", 400, N), Some(0));
469 }
470
471 #[test]
474 fn width_prefers_normal_then_narrower_descending_then_wider_ascending() {
475 let normal = [
476 face(&["F"], 3, N, 400),
477 face(&["F"], 7, N, 400),
478 face(&["F"], 5, N, 400),
479 ];
480 assert_eq!(select_face(&normal, "F", 400, N), Some(2));
481 let narrow = [
482 face(&["F"], 2, N, 400),
483 face(&["F"], 7, N, 400),
484 face(&["F"], 3, N, 400),
485 ];
486 assert_eq!(select_face(&narrow, "F", 400, N), Some(2));
487 let wide = [face(&["F"], 8, N, 400), face(&["F"], 6, N, 400)];
488 assert_eq!(select_face(&wide, "F", 400, N), Some(1));
489 }
490
491 #[test]
494 fn style_falls_back_in_the_css_order() {
495 let no_italic = [face(&["F"], 5, N, 400), face(&["F"], 5, O, 400)];
496 assert_eq!(select_face(&no_italic, "F", 400, I), Some(1));
497 let no_oblique = [face(&["F"], 5, N, 400), face(&["F"], 5, I, 400)];
498 assert_eq!(select_face(&no_oblique, "F", 400, O), Some(1));
499 let no_normal = [face(&["F"], 5, I, 400), face(&["F"], 5, O, 400)];
500 assert_eq!(select_face(&no_normal, "F", 400, N), Some(1));
501 let exact = [face(&["F"], 5, O, 400), face(&["F"], 5, I, 400)];
502 assert_eq!(select_face(&exact, "F", 400, I), Some(1));
503 }
504
505 #[test]
511 fn weight_between_400_and_500_climbs_to_500_first() {
512 let faces = [face(&["F"], 5, N, 300), face(&["F"], 5, N, 450)];
513 assert_eq!(select_face(&faces, "F", 400, N), Some(1));
514 let faces = [face(&["F"], 5, N, 600), face(&["F"], 5, N, 300)];
515 assert_eq!(select_face(&faces, "F", 400, N), Some(1));
516 let faces = [face(&["F"], 5, N, 400), face(&["F"], 5, N, 500)];
517 assert_eq!(select_face(&faces, "F", 450, N), Some(1));
518 let faces = [face(&["F"], 5, N, 700), face(&["F"], 5, N, 400)];
519 assert_eq!(select_face(&faces, "F", 500, N), Some(1));
520 }
521
522 #[test]
525 fn weight_below_400_descends_first() {
526 let faces = [face(&["F"], 5, N, 350), face(&["F"], 5, N, 200)];
527 assert_eq!(select_face(&faces, "F", 300, N), Some(1));
528 let faces = [face(&["F"], 5, N, 700), face(&["F"], 5, N, 350)];
529 assert_eq!(select_face(&faces, "F", 300, N), Some(1));
530 }
531
532 #[test]
535 fn weight_above_500_ascends_first() {
536 let faces = [face(&["F"], 5, N, 600), face(&["F"], 5, N, 800)];
537 assert_eq!(select_face(&faces, "F", 700, N), Some(1));
538 let faces = [face(&["F"], 5, N, 500), face(&["F"], 5, N, 600)];
539 assert_eq!(select_face(&faces, "F", 700, N), Some(1));
540 }
541
542 #[test]
544 fn width_outranks_style_which_outranks_weight() {
545 let faces = [
546 face(&["F"], 3, N, 400),
547 face(&["F"], 5, I, 700),
548 face(&["F"], 5, I, 400),
549 ];
550 assert_eq!(select_face(&faces, "F", 400, N), Some(2));
551 let tie = [face(&["F"], 5, N, 400), face(&["F"], 5, N, 400)];
552 assert_eq!(select_face(&tie, "F", 400, N), Some(0));
553 }
554
555 #[test]
558 fn the_macos_system_ui_family_is_sf_pro_caselessly() {
559 assert!(is_macos_system_ui_family("SF Pro"));
560 assert!(is_macos_system_ui_family("sf pro"));
561 assert!(!is_macos_system_ui_family("SF Mono"));
562 assert!(!is_macos_system_ui_family("SF Pro Text"));
563 assert!(!is_macos_system_ui_family("Inter"));
564 }
565
566 #[test]
569 fn the_macos_system_mono_family_is_sf_mono_caselessly() {
570 assert!(is_macos_system_mono_family("SF Mono"));
571 assert!(is_macos_system_mono_family("sf mono"));
572 assert!(!is_macos_system_mono_family("SF Pro"));
573 assert!(!is_macos_system_mono_family("SF Mono Text"));
574 assert!(!is_macos_system_mono_family("Menlo"));
575 }
576
577 #[cfg(all(
581 feature = "system-fonts",
582 unix,
583 not(target_os = "macos"),
584 not(target_os = "ios"),
585 not(target_os = "android")
586 ))]
587 #[test]
588 fn a_fontconfig_family_escapes_the_name_syntax_specials() {
589 assert_eq!(fontconfig_family("JetBrains Mono"), "JetBrains Mono");
590 assert_eq!(fontconfig_family("sans-serif"), r"sans\-serif");
591 assert_eq!(fontconfig_family(r"a\b:c,d-e"), r"a\\b\:c\,d\-e");
592 assert_eq!(fontconfig_family(r"\\"), r"\\\\");
593 assert_eq!(fontconfig_family(""), "");
594 assert_eq!(
595 fontconfig_family("Noto Sans CJK 日本"),
596 "Noto Sans CJK 日本"
597 );
598 }
599
600 #[cfg(feature = "system-fonts")]
605 #[test]
606 fn a_family_ask_in_flight_blocks_no_other_look_up() {
607 use std::sync::mpsc;
608 use std::time::Duration;
609 const GENEROUS: Duration = Duration::from_secs(10);
610
611 let asked = std::sync::Arc::new(AskedFamilies::default());
612 asked
613 .lock()
614 .unwrap()
615 .insert("Cached".to_owned(), Some("Cached substitute".to_owned()));
616
617 let (started_tx, started) = mpsc::channel();
618 let (release, release_rx) = mpsc::channel::<()>();
619 let first = std::thread::spawn({
620 let asked = asked.clone();
621 move || {
622 asked_once(&asked, "First", |_| {
623 let _ = started_tx.send(());
624 let _ = release_rx.recv();
625 Some("First substitute".to_owned())
626 })
627 }
628 });
629 started
630 .recv_timeout(GENEROUS)
631 .expect("the first ask never started");
632
633 let (done_tx, done) = mpsc::channel();
634 let others = std::thread::spawn({
635 let asked = asked.clone();
636 move || {
637 let cached = asked_once(&asked, "Cached", |_| Some("asked again".to_owned()));
638 let _ = done_tx.send(("Cached", cached));
639 let second = asked_once(&asked, "Second", |_| Some("Second substitute".to_owned()));
640 let _ = done_tx.send(("Second", second));
641 }
642 });
643 let while_in_flight: Vec<_> = (0..2)
644 .map_while(|_| done.recv_timeout(GENEROUS).ok())
645 .collect();
646
647 release.send(()).unwrap();
648 assert_eq!(first.join().unwrap().as_deref(), Some("First substitute"));
649 others.join().unwrap();
650 assert_eq!(
651 while_in_flight,
652 [
653 ("Cached", Some("Cached substitute".to_owned())),
654 ("Second", Some("Second substitute".to_owned())),
655 ],
656 "a look-up waited for another family's ask"
657 );
658 assert_eq!(
659 asked_once(&asked, "First", |_| None).as_deref(),
660 Some("First substitute"),
661 "the first ask's answer is kept"
662 );
663 }
664
665 #[cfg(feature = "system-fonts")]
666 mod system {
667 use super::super::*;
668
669 #[test]
674 fn a_missing_family_has_a_substitute_the_system_has() {
675 let missing = format!("native-theme-no-such-family-{}", std::process::id());
676 let substitute = substitute_family(&missing);
677 let fontconfig_platform = cfg!(all(
678 unix,
679 not(target_os = "macos"),
680 not(target_os = "ios"),
681 not(target_os = "android")
682 ));
683 let fc_match_runs = std::process::Command::new("fc-match")
684 .arg("--version")
685 .output()
686 .is_ok_and(|output| output.status.success());
687 if !(fontconfig_platform && fc_match_runs) {
688 println!(
689 "a_missing_family_has_a_substitute_the_system_has: fc-match not run here, \
690 substitute {substitute:?}"
691 );
692 assert_eq!(substitute, None);
693 return;
694 }
695 let substitute = substitute.expect("fc-match names a substitute");
696 assert!(
697 system_face(&substitute, 400, FontStyle::Normal).is_some(),
698 "the substitute {substitute:?} has a system face"
699 );
700 assert_eq!(substitute_family(&substitute), None);
701 }
702
703 #[test]
705 fn a_family_no_system_has_is_none() {
706 assert_eq!(
707 system_face("native-theme-no-such-family-7f3c1a", 400, FontStyle::Normal),
708 None
709 );
710 }
711
712 #[test]
718 fn a_family_matches_caselessly_and_reports_its_recorded_name() {
719 let db = database();
720 let (recorded, weight, style) = db
721 .faces()
722 .find_map(|info| {
723 let (name, _) = info.families.first()?;
724 name.chars()
725 .any(char::is_lowercase)
726 .then(|| (name.clone(), info.weight.0, style_of(info.style)))
727 })
728 .expect("the font database holds a face whose family has a lower-case letter");
729 let asked = recorded.to_uppercase();
730 assert_ne!(asked, recorded);
731 let face = system_face(&asked, weight, style)
732 .expect("the upper-cased family name finds the face");
733 assert_ne!(
734 face.family.as_ref(),
735 asked.as_str(),
736 "not the spelling asked for"
737 );
738 let recorded_by_a_face_of_that_family = db.faces().any(|info| {
739 info.families
740 .first()
741 .is_some_and(|(first, _)| **first == *face.family)
742 && info.families.iter().any(|(name, _)| {
743 unicase::UniCase::new(name.as_str())
744 == unicase::UniCase::new(recorded.as_str())
745 })
746 });
747 assert!(
748 recorded_by_a_face_of_that_family,
749 "the family fontdb records for the face"
750 );
751 }
752
753 #[test]
755 fn the_same_query_gives_the_same_face() {
756 let info = database()
757 .faces()
758 .next()
759 .expect("the font database holds a face");
760 let (name, _) = info.families.first().expect("a face records a family");
761 let a = system_face(name, info.weight.0, style_of(info.style));
762 let b = system_face(name, info.weight.0, style_of(info.style));
763 assert!(a.is_some());
764 assert_eq!(a, b);
765 }
766
767 #[cfg(target_os = "macos")]
775 #[test]
776 fn the_macos_system_ui_font_is_found_by_its_file() {
777 let ui = crate::macos::system_ui_font(false)
778 .expect("Core Text names the system UI font's file");
779 let expected = {
780 let mut db = fontdb::Database::new();
781 db.load_font_file(&ui.path)
782 .expect("the system UI font's file loads");
783 db.faces()
784 .next()
785 .and_then(|face| face.families.first().map(|(name, _)| name.clone()))
786 .expect("the file records a family")
787 };
788 for asked in ["SF Pro", ui.family.as_str()] {
789 let face = system_face(asked, 400, FontStyle::Normal)
790 .unwrap_or_else(|| panic!("{asked} resolves through Core Text"));
791 assert_eq!(face.family.as_ref(), expected.as_str());
792 }
793 }
794 }
795}