Skip to content

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

feat(fonts): Font format, classification and PANOSE for the font menus

moppeeer03a8d4b95525
diff --git a/crates/fonts/src/fontdb.rs b/crates/fonts/src/fontdb.rs
index 14441e144..079c0f1b1 100644
--- a/crates/fonts/src/fontdb.rs
+++ b/crates/fonts/src/fontdb.rs
@@ -121,6 +121,8 @@ pub struct FontFace {
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>)>,
+ /// Format, class and PANOSE numbers (the font menus), read on first use.
+ kind: std::sync::OnceLock<crate::kind::FaceKind>,
}
/// A cheap `Copy` handle to a face. Faces are never unloaded, so the handle lives for the rest of
@@ -188,6 +190,32 @@ impl FontFace {
pub fn skrifa(&self) -> Option<skrifa::FontRef<'_>> {
skrifa::FontRef::from_index(self.data(), self.index).ok()
}
+ /// The face's format, class and PANOSE numbers, as the font menus show and filter them.
+ pub fn kind(&self) -> crate::kind::FaceKind {
+ *self.kind.get_or_init(|| {
+ let mut kind = self.skrifa().map(|f| crate::kind::read_kind(&f, &self.family)).unwrap_or_default();
+ // Nothing in the tables or the name: look at the letters.
+ if kind.class == crate::kind::FontClass::Other
+ && let Some(serifs) = has_serifs(self)
+ {
+ kind.class = if serifs { crate::kind::FontClass::Serif } else { crate::kind::FontClass::SansSerif };
+ }
+ kind
+ })
+ }
+ /// When the font file was added (created, else last modified): the font menus' Show Recently
+ /// Added. `None` for fonts without a file.
+ pub fn added(&self) -> Option<std::time::SystemTime> {
+ #[cfg(not(target_arch = "wasm32"))]
+ {
+ let meta = std::fs::metadata(self.source.path()?).ok()?;
+ meta.created().or_else(|_| meta.modified()).ok()
+ }
+ #[cfg(target_arch = "wasm32")]
+ {
+ None
+ }
+ }
pub fn hb(&self) -> Option<harfrust::FontRef<'_>> {
harfrust::FontRef::from_index(self.data(), self.index).ok()
}
@@ -709,6 +737,7 @@ fn make_face(bytes: FontBytes, source: FontSource, index: u32, family: String, s
bmp: std::sync::OnceLock::new(),
em: std::sync::OnceLock::new(),
group: std::sync::OnceLock::new(),
+ kind: std::sync::OnceLock::new(),
})
}
@@ -1432,6 +1461,53 @@ fn over_total() -> String {
format!("over the {} MB the folder's fonts may take in all", MAX_DOCUMENT_FONTS_TOTAL >> 20)
}
+/// Does the face's "l" (else "I") have serifs: much wider at its foot than mid-stem? `None` when
+/// it has neither letter.
+fn has_serifs(face: &FontFace) -> Option<bool> {
+ let gid = ['l', 'I'].into_iter().map(|c| face.glyph_for(c)).find(|g| *g != 0)?;
+ let path = font_outline(face, gid);
+ let bbox = kurbo::Shape::bounding_box(&path);
+ // An empty or degenerate outline (NaN included) says nothing.
+ if bbox.height().is_nan() || bbox.height() <= 1.0 {
+ return None;
+ }
+ let mut edges = Vec::new();
+ let mut last = None;
+ let mut start = None;
+ kurbo::flatten(&path, 1.0, |el| match el {
+ kurbo::PathEl::MoveTo(p) => {
+ last = Some(p);
+ start = Some(p);
+ }
+ kurbo::PathEl::LineTo(p) => {
+ if let Some(a) = last {
+ edges.push((a, p));
+ }
+ last = Some(p);
+ }
+ kurbo::PathEl::ClosePath => {
+ if let (Some(a), Some(b)) = (last, start) {
+ edges.push((a, b));
+ }
+ last = start;
+ }
+ _ => {}
+ });
+ // The outline is y-down: the foot is near bbox.y1 (the baseline).
+ let width_at = |y: f64| {
+ let xs: Vec<f64> = edges
+ .iter()
+ .filter(|(a, b)| (a.y <= y && y < b.y) || (b.y <= y && y < a.y))
+ .map(|(a, b)| a.x + (y - a.y) * (b.x - a.x) / (b.y - a.y))
+ .collect();
+ let (lo, hi) = xs.iter().fold((f64::MAX, f64::MIN), |(lo, hi), x| (lo.min(*x), hi.max(*x)));
+ (hi > lo).then_some(hi - lo)
+ };
+ let foot = width_at(bbox.y1 - bbox.height() * 0.02)?;
+ let stem = width_at(bbox.y0 + bbox.height() * 0.5)?;
+ Some(foot > stem * 1.6)
+}
+
/// Glyph `gid`'s outline as the font draws it, in font units, y-down (flipped).
fn font_outline(face: &FontFace, gid: u32) -> BezPath {
let mut pen = FlipPen(BezPath::new());
diff --git a/crates/fonts/src/kind.rs b/crates/fonts/src/kind.rs
new file mode 100644
index 000000000..6a224bc00
--- /dev/null
+++ b/crates/fonts/src/kind.rs
@@ -0,0 +1,191 @@
+//! What the font menus say about a face: its file format (the icon after the sample), its
+//! classification (the Filters menu) and its PANOSE numbers (Show Similar Fonts).
+
+use skrifa::raw::TableProvider;
+use skrifa::raw::types::Tag;
+
+/// A face's font format, as the font menus show it.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum FontFormat {
+ /// TrueType outlines (`glyf`).
+ TrueType,
+ /// PostScript (CFF) outlines.
+ OpenType,
+ /// A variable font (`fvar`).
+ Variable,
+ /// Colour glyphs (COLR, SVG, bitmaps): emoji and colour fonts.
+ Color,
+}
+
+/// The classes the font menus filter by.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum FontClass {
+ Serif,
+ SlabSerif,
+ SansSerif,
+ Script,
+ Monospaced,
+ Decorative,
+ Symbol,
+ /// Nothing in the font says.
+ Other,
+}
+
+impl FontClass {
+ /// The classes, in the Filters menu's order.
+ pub const ALL: [FontClass; 8] = [
+ FontClass::Serif,
+ FontClass::SlabSerif,
+ FontClass::SansSerif,
+ FontClass::Script,
+ FontClass::Monospaced,
+ FontClass::Decorative,
+ FontClass::Symbol,
+ FontClass::Other,
+ ];
+
+ /// The name the Filters menu shows (English; the UI translates it).
+ pub fn label(self) -> &'static str {
+ match self {
+ FontClass::Serif => "Serif",
+ FontClass::SlabSerif => "Slab Serif",
+ FontClass::SansSerif => "Sans Serif",
+ FontClass::Script => "Script",
+ FontClass::Monospaced => "Monospaced",
+ FontClass::Decorative => "Decorative",
+ FontClass::Symbol => "Symbol",
+ FontClass::Other => "Other",
+ }
+ }
+}
+
+/// A face's format, class and PANOSE numbers.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct FaceKind {
+ pub format: FontFormat,
+ pub class: FontClass,
+ /// The OS/2 table's PANOSE classification (all zero when the font has none).
+ pub panose: [u8; 10],
+}
+
+impl Default for FaceKind {
+ fn default() -> Self {
+ FaceKind { format: FontFormat::TrueType, class: FontClass::Other, panose: [0; 10] }
+ }
+}
+
+/// Read a face's kind from its tables; `family` helps classify fonts whose tables don't say.
+pub fn read_kind(f: &skrifa::FontRef<'_>, family: &str) -> FaceKind {
+ let has = |tag: &[u8; 4]| f.table_data(Tag::new(tag)).is_some();
+ let format = if [b"COLR", b"SVG ", b"CBDT", b"sbix"].iter().any(|t| has(t)) {
+ FontFormat::Color
+ } else if has(b"fvar") {
+ FontFormat::Variable
+ } else if has(b"CFF ") || has(b"CFF2") {
+ FontFormat::OpenType
+ } else {
+ FontFormat::TrueType
+ };
+ let os2 = f.os2().ok();
+ let panose: [u8; 10] = os2.as_ref().and_then(|t| t.panose_10().try_into().ok()).unwrap_or([0; 10]);
+ let ibm = os2.as_ref().map_or(0, |t| (t.s_family_class() >> 8) as u8);
+ let fixed = f.post().ok().is_some_and(|p| p.is_fixed_pitch() != 0);
+ FaceKind { format, class: classify(&panose, ibm, fixed, family), panose }
+}
+
+/// The class from PANOSE (family kind, serif style, proportion), else the IBM family class in OS/2,
+/// else the family name.
+pub fn classify(panose: &[u8; 10], ibm_class: u8, fixed_pitch: bool, family: &str) -> FontClass {
+ let name = family.to_lowercase();
+ let named = |words: &[&str]| words.iter().any(|w| name.contains(w));
+ // PANOSE proportion 9 is monospaced (Latin text).
+ if fixed_pitch || (panose[0] == 2 && panose[3] == 9) || named(&["mono", "courier", " code"]) {
+ return FontClass::Monospaced;
+ }
+ match panose[0] {
+ 3 => return FontClass::Script,
+ 4 => return FontClass::Decorative,
+ 5 => return FontClass::Symbol,
+ 2 => match panose[1] {
+ // Square serifs are slabs; cove, bone, triangle… serifs are serifs.
+ 6 => return FontClass::SlabSerif,
+ 2..=10 => return FontClass::Serif,
+ 11..=15 => return FontClass::SansSerif,
+ _ => {}
+ },
+ _ => {}
+ }
+ match ibm_class {
+ 1 | 2 | 3 | 7 => FontClass::Serif,
+ 4 | 5 => FontClass::SlabSerif,
+ 8 => FontClass::SansSerif,
+ 9 => FontClass::Decorative,
+ 10 => FontClass::Script,
+ 12 => FontClass::Symbol,
+ _ if named(&["slab"]) => FontClass::SlabSerif,
+ _ if named(&["sans", "grotesk", "grotesque", "gothic", "helvetica", "arial"]) => FontClass::SansSerif,
+ _ if named(&["script", "hand", "brush"]) => FontClass::Script,
+ _ if named(&["serif"]) => FontClass::Serif,
+ _ => FontClass::Other,
+ }
+}
+
+/// How unlike two faces look by their PANOSE numbers (0 = alike), counting only the digits both
+/// fonts set; `None` when they share none.
+pub fn panose_distance(a: &[u8; 10], b: &[u8; 10]) -> Option<u32> {
+ let pairs: Vec<(u8, u8)> = a.iter().zip(b).skip(1).filter(|(x, y)| **x > 1 && **y > 1).map(|(x, y)| (*x, *y)).collect();
+ if pairs.is_empty() {
+ return None;
+ }
+ Some(pairs.iter().map(|(x, y)| u32::from(x.abs_diff(*y))).sum::<u32>() * 9 / pairs.len() as u32)
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn classes_come_from_panose_then_the_ibm_class_then_the_name() {
+ let latin = |serif: u8, proportion: u8| [2, serif, 5, proportion, 5, 0, 0, 0, 0, 0];
+ assert_eq!(classify(&latin(2, 3), 0, false, "Garamond"), FontClass::Serif);
+ assert_eq!(classify(&latin(6, 3), 0, false, "Rockwell"), FontClass::SlabSerif);
+ assert_eq!(classify(&latin(11, 3), 0, false, "Inter"), FontClass::SansSerif);
+ assert_eq!(classify(&latin(11, 9), 0, false, "Inter"), FontClass::Monospaced, "proportion 9");
+ assert_eq!(classify(&[3, 0, 0, 0, 0, 0, 0, 0, 0, 0], 0, false, "Brush"), FontClass::Script);
+ assert_eq!(classify(&[0; 10], 8, false, "Untitled"), FontClass::SansSerif, "IBM class 8");
+ assert_eq!(classify(&[0; 10], 0, true, "Untitled"), FontClass::Monospaced, "post.isFixedPitch");
+ assert_eq!(classify(&[0; 10], 0, false, "JetBrains Mono"), FontClass::Monospaced);
+ assert_eq!(classify(&[0; 10], 0, false, "Roboto Slab"), FontClass::SlabSerif);
+ assert_eq!(classify(&[0; 10], 0, false, "Plain"), FontClass::Other);
+ }
+
+ #[test]
+ fn bundled_fonts_are_classified() {
+ let db = crate::FontDb::global();
+ for (family, class) in [
+ ("Source Serif 4", FontClass::Serif),
+ ("Source Sans 3", FontClass::SansSerif),
+ ("Inter", FontClass::SansSerif),
+ ("JetBrains Mono", FontClass::Monospaced),
+ ] {
+ let kind = db.face(family, "Regular").kind();
+ assert_eq!(kind.class, class, "{family}");
+ assert_eq!(kind.format, FontFormat::TrueType, "{family}");
+ }
+ let serif = db.face("Source Serif 4", "Regular").kind().panose;
+ let sans = db.face("Source Sans 3", "Regular").kind().panose;
+ let serif_bold = db.face("Source Serif 4", "Bold").kind().panose;
+ if let (Some(near), Some(far)) = (panose_distance(&serif, &serif_bold), panose_distance(&serif, &sans)) {
+ assert!(near < far, "the bold serif is nearer the serif than the sans is ({near} vs {far})");
+ }
+ }
+
+ #[test]
+ fn panose_distance_counts_shared_digits() {
+ let a = [2, 2, 5, 3, 5, 4, 5, 2, 2, 4];
+ assert_eq!(panose_distance(&a, &a), Some(0));
+ let b = [2, 11, 5, 3, 5, 4, 5, 2, 2, 4];
+ assert!(panose_distance(&a, &b).is_some_and(|d| d > 0));
+ assert_eq!(panose_distance(&a, &[0; 10]), None, "no PANOSE: nothing to compare");
+ }
+}
diff --git a/crates/fonts/src/lib.rs b/crates/fonts/src/lib.rs
index c1d744780..dd4583701 100644
--- a/crates/fonts/src/lib.rs
+++ b/crates/fonts/src/lib.rs
@@ -9,6 +9,7 @@
mod fontdb;
mod group;
+mod kind;
#[cfg(any(test, feature = "testing"))]
pub mod testing;
mod vertical;
@@ -20,6 +21,7 @@ pub use fontdb::{
pub use group::{FamilyInfo, FontGroup, sort_for_menu};
pub use harfrust::Feature;
use harfrust::{Direction, Language, ShapeOptions, Tag, UnicodeBuffer};
+pub use kind::{FaceKind, FontClass, FontFormat, classify, panose_distance};
pub use kurbo::BezPath;
use skrifa::MetadataProvider;
use skrifa::instance::Size;