use crate::theme::FontStyle;
#[derive(Clone, Copy, Debug)]
pub struct FaceTraits<'a> {
pub families: &'a [&'a str],
pub width: u16,
pub style: FontStyle,
pub weight: u16,
}
#[must_use]
pub fn select_face(
faces: &[FaceTraits<'_>],
family: &str,
weight: u16,
style: FontStyle,
) -> Option<usize> {
let wanted = unicase::UniCase::new(family);
let mut candidates: Vec<(usize, &FaceTraits<'_>)> = faces
.iter()
.enumerate()
.filter(|(_, face)| {
face.families
.iter()
.any(|name| unicase::UniCase::new(*name) == wanted)
})
.collect();
if candidates.is_empty() {
return None;
}
keep_best(&mut candidates, |face| width_rank(face.width));
keep_best(&mut candidates, |face| style_rank(face.style, style));
keep_best(&mut candidates, |face| weight_rank(face.weight, weight));
candidates.first().map(|(index, _)| *index)
}
fn keep_best(
candidates: &mut Vec<(usize, &FaceTraits<'_>)>,
rank: impl Fn(&FaceTraits<'_>) -> (u8, u16),
) {
if let Some(best) = candidates.iter().map(|(_, face)| rank(face)).min() {
candidates.retain(|(_, face)| rank(face) == best);
}
}
fn width_rank(width: u16) -> (u8, u16) {
const NORMAL: u16 = 5;
match width.cmp(&NORMAL) {
std::cmp::Ordering::Equal => (0, 0),
std::cmp::Ordering::Less => (1, NORMAL.saturating_sub(width)),
std::cmp::Ordering::Greater => (2, width),
}
}
fn style_rank(face: FontStyle, wanted: FontStyle) -> (u8, u16) {
let rank = match (wanted, face) {
(w, f) if w == f => 0,
(FontStyle::Italic, FontStyle::Oblique)
| (FontStyle::Oblique, FontStyle::Italic)
| (FontStyle::Normal, FontStyle::Oblique) => 1,
_ => 2,
};
(rank, 0)
}
fn weight_rank(face: u16, wanted: u16) -> (u8, u16) {
let below = wanted.saturating_sub(face);
match wanted {
400..=500 if face >= wanted && face <= 500 => (0, face),
400..=500 if face < wanted => (1, below),
400..=500 => (2, face),
0..=399 if face <= wanted => (0, below),
0..=399 => (1, face),
_ if face >= wanted => (0, face),
_ => (1, below),
}
}
#[must_use]
pub fn is_macos_system_ui_family(family: &str) -> bool {
unicase::UniCase::new(family) == unicase::UniCase::new("SF Pro")
}
#[must_use]
pub fn is_macos_system_mono_family(family: &str) -> bool {
unicase::UniCase::new(family) == unicase::UniCase::new("SF Mono")
}
#[cfg(feature = "system-fonts")]
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct SystemFace {
pub data: std::sync::Arc<[u8]>,
pub index: u32,
pub family: std::sync::Arc<str>,
pub weight: u16,
pub style: FontStyle,
}
#[cfg(feature = "system-fonts")]
fn database() -> &'static fontdb::Database {
static DB: std::sync::OnceLock<fontdb::Database> = std::sync::OnceLock::new();
DB.get_or_init(|| {
let mut db = fontdb::Database::new();
db.load_system_fonts();
db
})
}
#[cfg(feature = "system-fonts")]
fn style_of(style: fontdb::Style) -> FontStyle {
match style {
fontdb::Style::Normal => FontStyle::Normal,
fontdb::Style::Italic => FontStyle::Italic,
fontdb::Style::Oblique => FontStyle::Oblique,
}
}
#[cfg(feature = "system-fonts")]
fn face_in(
db: &fontdb::Database,
family: &str,
weight: u16,
style: FontStyle,
) -> Option<SystemFace> {
let infos: Vec<&fontdb::FaceInfo> = db.faces().collect();
let names: Vec<Vec<&str>> = infos
.iter()
.map(|info| {
info.families
.iter()
.map(|(name, _)| name.as_str())
.collect()
})
.collect();
let traits: Vec<FaceTraits<'_>> = infos
.iter()
.zip(&names)
.map(|(info, names)| FaceTraits {
families: names,
width: info.stretch.to_number(),
style: style_of(info.style),
weight: info.weight.0,
})
.collect();
let chosen = select_face(&traits, family, weight, style)?;
let info = infos.get(chosen)?;
let (data, index) = db.with_face_data(info.id, |data, index| {
(std::sync::Arc::<[u8]>::from(data), index)
})?;
let (recorded, _) = info.families.first()?;
Some(SystemFace {
data,
index,
family: std::sync::Arc::from(recorded.as_str()),
weight: info.weight.0,
style: style_of(info.style),
})
}
#[cfg(feature = "system-fonts")]
#[must_use]
pub fn system_face(family: &str, weight: u16, style: FontStyle) -> Option<SystemFace> {
#[cfg(target_os = "macos")]
{
let italic = matches!(style, FontStyle::Italic | FontStyle::Oblique);
let ui = crate::macos::system_ui_font(italic);
let names_it = is_macos_system_ui_family(family)
|| ui.as_ref().is_some_and(|font| {
unicase::UniCase::new(family) == unicase::UniCase::new(font.family.as_str())
});
if names_it {
return ui.and_then(|font| face_in_file(&font.path, weight, style));
}
}
face_in(database(), family, weight, style)
}
#[cfg(all(feature = "system-fonts", target_os = "macos"))]
fn face_in_file(path: &std::path::Path, weight: u16, style: FontStyle) -> Option<SystemFace> {
let mut db = fontdb::Database::new();
db.load_font_file(path).ok()?;
let recorded = db.faces().next()?.families.first()?.0.clone();
face_in(&db, &recorded, weight, style)
}
#[cfg(feature = "system-fonts")]
#[must_use]
pub fn substitute_family(family: &str) -> Option<String> {
platform_substitute(family)
}
#[cfg(feature = "system-fonts")]
#[must_use]
pub fn substitute_family_cached(family: &str) -> Option<String> {
static ASKED: std::sync::OnceLock<AskedFamilies> = std::sync::OnceLock::new();
asked_once(
ASKED.get_or_init(AskedFamilies::default),
family,
substitute_family,
)
}
#[cfg(feature = "system-fonts")]
type AskedFamilies = std::sync::Mutex<std::collections::HashMap<String, Option<String>>>;
#[cfg(feature = "system-fonts")]
fn asked_once(
asked: &AskedFamilies,
family: &str,
ask: impl FnOnce(&str) -> Option<String>,
) -> Option<String> {
let lock = || {
asked
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
};
let kept = lock().get(family).cloned();
if let Some(answer) = kept {
return answer;
}
let answer = ask(family);
lock().insert(family.to_owned(), answer.clone());
answer
}
#[cfg(all(
feature = "system-fonts",
unix,
not(target_os = "macos"),
not(target_os = "ios"),
not(target_os = "android")
))]
fn platform_substitute(family: &str) -> Option<String> {
let printed = crate::detect::stdout_with_timeout(
"fc-match",
&["--format=%{family[0]}", &fontconfig_family(family)],
crate::detect::SUBPROCESS_TIMEOUT,
)?;
let matched = printed.trim();
if matched.is_empty() || unicase::UniCase::new(matched) == unicase::UniCase::new(family) {
return None;
}
Some(matched.to_owned())
}
#[cfg(all(
feature = "system-fonts",
not(all(
unix,
not(target_os = "macos"),
not(target_os = "ios"),
not(target_os = "android")
))
))]
fn platform_substitute(_family: &str) -> Option<String> {
None
}
#[cfg(all(
feature = "system-fonts",
unix,
not(target_os = "macos"),
not(target_os = "ios"),
not(target_os = "android")
))]
fn fontconfig_family(family: &str) -> String {
let mut pattern = String::with_capacity(family.len());
for c in family.chars() {
if matches!(c, '\\' | '-' | ':' | ',') {
pattern.push('\\');
}
pattern.push(c);
}
pattern
}
#[cfg(test)]
#[allow(
clippy::unwrap_used,
clippy::expect_used,
clippy::panic,
clippy::indexing_slicing,
reason = "a test fails by panicking"
)]
mod tests {
use super::*;
const N: FontStyle = FontStyle::Normal;
const I: FontStyle = FontStyle::Italic;
const O: FontStyle = FontStyle::Oblique;
fn face(
families: &'static [&'static str],
width: u16,
style: FontStyle,
weight: u16,
) -> FaceTraits<'static> {
FaceTraits {
families,
width,
style,
weight,
}
}
#[test]
fn the_family_is_matched_caselessly_and_never_substituted() {
let faces = [face(&["Inter"], 5, N, 400), face(&["Roboto"], 5, N, 400)];
assert_eq!(select_face(&faces, "inter", 400, N), Some(0));
assert_eq!(select_face(&faces, "INTER", 400, N), Some(0));
assert_eq!(select_face(&faces, "Helvetica", 400, N), None);
assert_eq!(select_face(&[], "Inter", 400, N), None);
}
#[test]
fn any_recorded_family_name_matches() {
let faces = [face(&["Segoe UI", "Segoe UI Regular"], 5, N, 400)];
assert_eq!(select_face(&faces, "segoe ui regular", 400, N), Some(0));
}
#[test]
fn width_prefers_normal_then_narrower_descending_then_wider_ascending() {
let normal = [
face(&["F"], 3, N, 400),
face(&["F"], 7, N, 400),
face(&["F"], 5, N, 400),
];
assert_eq!(select_face(&normal, "F", 400, N), Some(2));
let narrow = [
face(&["F"], 2, N, 400),
face(&["F"], 7, N, 400),
face(&["F"], 3, N, 400),
];
assert_eq!(select_face(&narrow, "F", 400, N), Some(2));
let wide = [face(&["F"], 8, N, 400), face(&["F"], 6, N, 400)];
assert_eq!(select_face(&wide, "F", 400, N), Some(1));
}
#[test]
fn style_falls_back_in_the_css_order() {
let no_italic = [face(&["F"], 5, N, 400), face(&["F"], 5, O, 400)];
assert_eq!(select_face(&no_italic, "F", 400, I), Some(1));
let no_oblique = [face(&["F"], 5, N, 400), face(&["F"], 5, I, 400)];
assert_eq!(select_face(&no_oblique, "F", 400, O), Some(1));
let no_normal = [face(&["F"], 5, I, 400), face(&["F"], 5, O, 400)];
assert_eq!(select_face(&no_normal, "F", 400, N), Some(1));
let exact = [face(&["F"], 5, O, 400), face(&["F"], 5, I, 400)];
assert_eq!(select_face(&exact, "F", 400, I), Some(1));
}
#[test]
fn weight_between_400_and_500_climbs_to_500_first() {
let faces = [face(&["F"], 5, N, 300), face(&["F"], 5, N, 450)];
assert_eq!(select_face(&faces, "F", 400, N), Some(1));
let faces = [face(&["F"], 5, N, 600), face(&["F"], 5, N, 300)];
assert_eq!(select_face(&faces, "F", 400, N), Some(1));
let faces = [face(&["F"], 5, N, 400), face(&["F"], 5, N, 500)];
assert_eq!(select_face(&faces, "F", 450, N), Some(1));
let faces = [face(&["F"], 5, N, 700), face(&["F"], 5, N, 400)];
assert_eq!(select_face(&faces, "F", 500, N), Some(1));
}
#[test]
fn weight_below_400_descends_first() {
let faces = [face(&["F"], 5, N, 350), face(&["F"], 5, N, 200)];
assert_eq!(select_face(&faces, "F", 300, N), Some(1));
let faces = [face(&["F"], 5, N, 700), face(&["F"], 5, N, 350)];
assert_eq!(select_face(&faces, "F", 300, N), Some(1));
}
#[test]
fn weight_above_500_ascends_first() {
let faces = [face(&["F"], 5, N, 600), face(&["F"], 5, N, 800)];
assert_eq!(select_face(&faces, "F", 700, N), Some(1));
let faces = [face(&["F"], 5, N, 500), face(&["F"], 5, N, 600)];
assert_eq!(select_face(&faces, "F", 700, N), Some(1));
}
#[test]
fn width_outranks_style_which_outranks_weight() {
let faces = [
face(&["F"], 3, N, 400),
face(&["F"], 5, I, 700),
face(&["F"], 5, I, 400),
];
assert_eq!(select_face(&faces, "F", 400, N), Some(2));
let tie = [face(&["F"], 5, N, 400), face(&["F"], 5, N, 400)];
assert_eq!(select_face(&tie, "F", 400, N), Some(0));
}
#[test]
fn the_macos_system_ui_family_is_sf_pro_caselessly() {
assert!(is_macos_system_ui_family("SF Pro"));
assert!(is_macos_system_ui_family("sf pro"));
assert!(!is_macos_system_ui_family("SF Mono"));
assert!(!is_macos_system_ui_family("SF Pro Text"));
assert!(!is_macos_system_ui_family("Inter"));
}
#[test]
fn the_macos_system_mono_family_is_sf_mono_caselessly() {
assert!(is_macos_system_mono_family("SF Mono"));
assert!(is_macos_system_mono_family("sf mono"));
assert!(!is_macos_system_mono_family("SF Pro"));
assert!(!is_macos_system_mono_family("SF Mono Text"));
assert!(!is_macos_system_mono_family("Menlo"));
}
#[cfg(all(
feature = "system-fonts",
unix,
not(target_os = "macos"),
not(target_os = "ios"),
not(target_os = "android")
))]
#[test]
fn a_fontconfig_family_escapes_the_name_syntax_specials() {
assert_eq!(fontconfig_family("JetBrains Mono"), "JetBrains Mono");
assert_eq!(fontconfig_family("sans-serif"), r"sans\-serif");
assert_eq!(fontconfig_family(r"a\b:c,d-e"), r"a\\b\:c\,d\-e");
assert_eq!(fontconfig_family(r"\\"), r"\\\\");
assert_eq!(fontconfig_family(""), "");
assert_eq!(
fontconfig_family("Noto Sans CJK 日本"),
"Noto Sans CJK 日本"
);
}
#[cfg(feature = "system-fonts")]
#[test]
fn a_family_ask_in_flight_blocks_no_other_look_up() {
use std::sync::mpsc;
use std::time::Duration;
const GENEROUS: Duration = Duration::from_secs(10);
let asked = std::sync::Arc::new(AskedFamilies::default());
asked
.lock()
.unwrap()
.insert("Cached".to_owned(), Some("Cached substitute".to_owned()));
let (started_tx, started) = mpsc::channel();
let (release, release_rx) = mpsc::channel::<()>();
let first = std::thread::spawn({
let asked = asked.clone();
move || {
asked_once(&asked, "First", |_| {
let _ = started_tx.send(());
let _ = release_rx.recv();
Some("First substitute".to_owned())
})
}
});
started
.recv_timeout(GENEROUS)
.expect("the first ask never started");
let (done_tx, done) = mpsc::channel();
let others = std::thread::spawn({
let asked = asked.clone();
move || {
let cached = asked_once(&asked, "Cached", |_| Some("asked again".to_owned()));
let _ = done_tx.send(("Cached", cached));
let second = asked_once(&asked, "Second", |_| Some("Second substitute".to_owned()));
let _ = done_tx.send(("Second", second));
}
});
let while_in_flight: Vec<_> = (0..2)
.map_while(|_| done.recv_timeout(GENEROUS).ok())
.collect();
release.send(()).unwrap();
assert_eq!(first.join().unwrap().as_deref(), Some("First substitute"));
others.join().unwrap();
assert_eq!(
while_in_flight,
[
("Cached", Some("Cached substitute".to_owned())),
("Second", Some("Second substitute".to_owned())),
],
"a look-up waited for another family's ask"
);
assert_eq!(
asked_once(&asked, "First", |_| None).as_deref(),
Some("First substitute"),
"the first ask's answer is kept"
);
}
#[cfg(feature = "system-fonts")]
mod system {
use super::super::*;
#[test]
fn a_missing_family_has_a_substitute_the_system_has() {
let missing = format!("native-theme-no-such-family-{}", std::process::id());
let substitute = substitute_family(&missing);
let fontconfig_platform = cfg!(all(
unix,
not(target_os = "macos"),
not(target_os = "ios"),
not(target_os = "android")
));
let fc_match_runs = std::process::Command::new("fc-match")
.arg("--version")
.output()
.is_ok_and(|output| output.status.success());
if !(fontconfig_platform && fc_match_runs) {
println!(
"a_missing_family_has_a_substitute_the_system_has: fc-match not run here, \
substitute {substitute:?}"
);
assert_eq!(substitute, None);
return;
}
let substitute = substitute.expect("fc-match names a substitute");
assert!(
system_face(&substitute, 400, FontStyle::Normal).is_some(),
"the substitute {substitute:?} has a system face"
);
assert_eq!(substitute_family(&substitute), None);
}
#[test]
fn a_family_no_system_has_is_none() {
assert_eq!(
system_face("native-theme-no-such-family-7f3c1a", 400, FontStyle::Normal),
None
);
}
#[test]
fn a_family_matches_caselessly_and_reports_its_recorded_name() {
let db = database();
let (recorded, weight, style) = db
.faces()
.find_map(|info| {
let (name, _) = info.families.first()?;
name.chars()
.any(char::is_lowercase)
.then(|| (name.clone(), info.weight.0, style_of(info.style)))
})
.expect("the font database holds a face whose family has a lower-case letter");
let asked = recorded.to_uppercase();
assert_ne!(asked, recorded);
let face = system_face(&asked, weight, style)
.expect("the upper-cased family name finds the face");
assert_ne!(
face.family.as_ref(),
asked.as_str(),
"not the spelling asked for"
);
let recorded_by_a_face_of_that_family = db.faces().any(|info| {
info.families
.first()
.is_some_and(|(first, _)| **first == *face.family)
&& info.families.iter().any(|(name, _)| {
unicase::UniCase::new(name.as_str())
== unicase::UniCase::new(recorded.as_str())
})
});
assert!(
recorded_by_a_face_of_that_family,
"the family fontdb records for the face"
);
}
#[test]
fn the_same_query_gives_the_same_face() {
let info = database()
.faces()
.next()
.expect("the font database holds a face");
let (name, _) = info.families.first().expect("a face records a family");
let a = system_face(name, info.weight.0, style_of(info.style));
let b = system_face(name, info.weight.0, style_of(info.style));
assert!(a.is_some());
assert_eq!(a, b);
}
#[cfg(target_os = "macos")]
#[test]
fn the_macos_system_ui_font_is_found_by_its_file() {
let ui = crate::macos::system_ui_font(false)
.expect("Core Text names the system UI font's file");
let expected = {
let mut db = fontdb::Database::new();
db.load_font_file(&ui.path)
.expect("the system UI font's file loads");
db.faces()
.next()
.and_then(|face| face.families.first().map(|(name, _)| name.clone()))
.expect("the file records a family")
};
for asked in ["SF Pro", ui.family.as_str()] {
let face = system_face(asked, 400, FontStyle::Normal)
.unwrap_or_else(|| panic!("{asked} resolves through Core Text"));
assert_eq!(face.family.as_ref(), expected.as_str());
}
}
}
}