1use std::path::PathBuf;
25
26pub const FONT_EXTS: [&str; 3] = ["ttf", "otf", "ttc"];
28
29#[derive(Debug, Clone, PartialEq, Eq)]
31pub struct FontNames {
32 pub family: String,
35 pub postscript: Option<String>,
37}
38
39fn u16be(data: &[u8], off: usize) -> Option<u16> {
40 Some(u16::from_be_bytes(data.get(off..off + 2)?.try_into().ok()?))
41}
42
43fn u32be(data: &[u8], off: usize) -> Option<u32> {
44 Some(u32::from_be_bytes(data.get(off..off + 4)?.try_into().ok()?))
45}
46
47#[must_use]
51pub fn parse_font_names(data: &[u8]) -> Option<FontNames> {
52 let base = if u32be(data, 0)? == u32::from_be_bytes(*b"ttcf") {
54 u32be(data, 12)? as usize
55 } else {
56 0
57 };
58 let version = u32be(data, base)?;
59 let known = [
60 0x0001_0000, u32::from_be_bytes(*b"OTTO"), u32::from_be_bytes(*b"true"), ];
64 if !known.contains(&version) {
65 return None;
66 }
67 let num_tables = u16be(data, base + 4)? as usize;
68 let mut name_table = None;
69 for i in 0..num_tables {
70 let rec = base + 12 + i * 16;
71 if u32be(data, rec)? == u32::from_be_bytes(*b"name") {
72 let off = u32be(data, rec + 8)? as usize;
73 let len = u32be(data, rec + 12)? as usize;
74 name_table = Some(data.get(off..off.checked_add(len)?)?);
75 break;
76 }
77 }
78 let name = name_table?;
79 let count = u16be(name, 2)? as usize;
80 let storage = u16be(name, 4)? as usize;
81
82 let mut family16: Option<(u8, String)> = None;
85 let mut family1: Option<(u8, String)> = None;
86 let mut postscript: Option<(u8, String)> = None;
87 for i in 0..count {
88 let rec = 6 + i * 12;
89 let platform = u16be(name, rec)?;
90 let encoding = u16be(name, rec + 2)?;
91 let language = u16be(name, rec + 4)?;
92 let name_id = u16be(name, rec + 6)?;
93 let len = u16be(name, rec + 8)? as usize;
94 let off = u16be(name, rec + 10)? as usize;
95 if !matches!(name_id, 1 | 6 | 16) {
96 continue;
97 }
98 let Some(bytes) = name.get(storage + off..storage + off + len) else {
99 continue;
100 };
101 let (decoded, score) = match platform {
102 3 | 0 => {
104 let units: Vec<u16> = bytes
110 .as_chunks::<2>()
111 .0
112 .iter()
113 .map(|c| u16::from_be_bytes(*c))
114 .collect();
115 let s = String::from_utf16_lossy(&units);
116 let score = if platform == 3 && language == 0x0409 {
117 3
118 } else if platform == 3 {
119 2
120 } else {
121 1
122 };
123 (s, score)
124 }
125 1 if encoding == 0 => (bytes.iter().map(|&b| b as char).collect(), 0),
127 _ => continue,
128 };
129 let decoded = decoded.trim().to_string();
130 if decoded.is_empty() {
131 continue;
132 }
133 let slot = match name_id {
134 16 => &mut family16,
135 1 => &mut family1,
136 _ => &mut postscript,
137 };
138 if slot.as_ref().is_none_or(|(s, _)| score > *s) {
139 *slot = Some((score, decoded));
140 }
141 }
142 let family = family16.or(family1)?.1;
143 Some(FontNames {
144 family,
145 postscript: postscript.map(|(_, s)| s),
146 })
147}
148
149#[must_use]
153pub fn font_ident(family: &str) -> String {
154 let mut s: String = family
155 .chars()
156 .map(|c| {
157 let c = c.to_ascii_lowercase();
158 if c.is_ascii_alphanumeric() || c == '_' {
159 c
160 } else {
161 '_'
162 }
163 })
164 .collect();
165 if !s.chars().next().is_some_and(|c| c.is_ascii_alphabetic()) {
166 s.insert(0, 'r');
167 }
168 s
169}
170
171#[must_use]
175pub fn font_dir() -> Option<PathBuf> {
176 if let Ok(root) = std::env::var("DAY_FONT_ROOT") {
177 let p = PathBuf::from(root);
178 if p.is_dir() {
179 return Some(p);
180 }
181 }
182 if let Ok(exe) = std::env::current_exe()
183 && let Some(dir) = exe.parent()
184 {
185 for rel in ["../Resources/fonts", "Resources/fonts", "fonts"] {
186 let p = dir.join(rel);
187 if p.is_dir() {
188 return Some(p);
189 }
190 }
191 }
192 None
193}
194
195#[must_use]
198pub fn bundled_fonts() -> Vec<PathBuf> {
199 let Some(dir) = font_dir() else {
200 return Vec::new();
201 };
202 font_files_in(&dir)
203}
204
205#[must_use]
207pub fn font_files_in(dir: &std::path::Path) -> Vec<PathBuf> {
208 let mut out = Vec::new();
209 let Ok(entries) = std::fs::read_dir(dir) else {
210 return out;
211 };
212 for e in entries.flatten() {
213 let p = e.path();
214 let ext = p
215 .extension()
216 .and_then(|x| x.to_str())
217 .map(str::to_ascii_lowercase);
218 if p.is_file() && ext.is_some_and(|x| FONT_EXTS.contains(&x.as_str())) {
219 out.push(p);
220 }
221 }
222 out.sort();
223 out
224}
225
226#[must_use]
230pub fn resolve_font_file(family: &str) -> Option<PathBuf> {
231 for path in bundled_fonts() {
232 let Ok(bytes) = std::fs::read(&path) else {
233 continue;
234 };
235 if let Some(names) = parse_font_names(&bytes)
236 && (names.family.eq_ignore_ascii_case(family)
237 || names
238 .postscript
239 .as_deref()
240 .is_some_and(|ps| ps.eq_ignore_ascii_case(family)))
241 {
242 return Some(path);
243 }
244 }
245 None
246}
247
248#[cfg(test)]
249mod tests {
250 use super::*;
251
252 fn sfnt_with_names(records: &[(u16, u16, u16, u16, bool, &str)]) -> Vec<u8> {
255 let mut strings: Vec<u8> = Vec::new();
256 let mut recs: Vec<u8> = Vec::new();
257 for &(plat, enc, lang, id, utf16, value) in records {
258 let start = strings.len() as u16;
259 if utf16 {
260 for u in value.encode_utf16() {
261 strings.extend_from_slice(&u.to_be_bytes());
262 }
263 } else {
264 strings.extend(value.bytes());
265 }
266 let len = strings.len() as u16 - start;
267 for v in [plat, enc, lang, id, len, start] {
268 recs.extend_from_slice(&v.to_be_bytes());
269 }
270 }
271 let mut name = Vec::new();
272 name.extend_from_slice(&0u16.to_be_bytes()); name.extend_from_slice(&(records.len() as u16).to_be_bytes());
274 name.extend_from_slice(&((6 + recs.len()) as u16).to_be_bytes()); name.extend(recs);
276 name.extend(strings);
277
278 let mut font = Vec::new();
279 font.extend_from_slice(&0x0001_0000u32.to_be_bytes()); font.extend_from_slice(&1u16.to_be_bytes()); font.extend_from_slice(&[0; 6]); let name_off = 12 + 16; font.extend_from_slice(b"name");
284 font.extend_from_slice(&0u32.to_be_bytes()); font.extend_from_slice(&(name_off as u32).to_be_bytes());
286 font.extend_from_slice(&(name.len() as u32).to_be_bytes());
287 font.extend(name);
288 font
289 }
290
291 #[test]
292 fn parses_family_and_postscript() {
293 let font = sfnt_with_names(&[
294 (1, 0, 0, 1, false, "Mac Family"),
295 (3, 1, 0x0409, 1, true, "Win Family"),
296 (3, 1, 0x0409, 6, true, "WinFamily-Regular"),
297 ]);
298 let names = parse_font_names(&font).unwrap();
299 assert_eq!(names.family, "Win Family"); assert_eq!(names.postscript.as_deref(), Some("WinFamily-Regular"));
301 }
302
303 #[test]
304 fn typographic_family_wins() {
305 let font = sfnt_with_names(&[
306 (3, 1, 0x0409, 1, true, "Legacy Light"),
307 (3, 1, 0x0409, 16, true, "Legacy"),
308 ]);
309 assert_eq!(parse_font_names(&font).unwrap().family, "Legacy");
310 }
311
312 #[test]
313 fn rejects_non_fonts() {
314 assert!(parse_font_names(b"not a font at all").is_none());
315 assert!(parse_font_names(&[]).is_none());
316 }
317
318 #[test]
319 fn ident_rules() {
320 assert_eq!(font_ident("Special Elite"), "special_elite");
321 assert_eq!(font_ident("Pacifico"), "pacifico");
322 assert_eq!(font_ident("3of9"), "r3of9");
323 }
324}