VectorCraft: An open-source, vector art tool written by scratch in pure Rust
refactor(text): move fontdb.rs items to fontdb/{build,cache,db,dirs,face,glyph_pen,lookup,names,scan,traits,wanted}.rs
aionggde14f93c05cb
diff --git a/crates/text/src/fontdb.rs b/crates/text/src/fontdb.rsindex 33b645d53..6eca651bb 100644--- a/crates/text/src/fontdb.rs+++ b/crates/text/src/fontdb.rs@@ -17,472 +17,53 @@ use crate::GlyphImage;use crate::colr::ColourContent;use vectorcraft_doc::color::Color;-/// The family used when a requested family is unknown (Illustrator's Myriad Pro analogue).-pub const FALLBACK_FAMILY: &str = "Source Sans 3";--/// The fonts every database starts with (feature `bundled-fonts`, on by default).-#[cfg(feature = "bundled-fonts")]-static BUNDLED: &[&[u8]] = &[- include_bytes!("../../../assets/fonts/SourceSans3-Regular.ttf"),- include_bytes!("../../../assets/fonts/SourceSans3-Semibold.ttf"),- include_bytes!("../../../assets/fonts/SourceSans3-Bold.ttf"),- include_bytes!("../../../assets/fonts/SourceSans3-It.ttf"),- include_bytes!("../../../assets/fonts/SourceSerif4-Regular.ttf"),- include_bytes!("../../../assets/fonts/Inter-Regular.ttf"),- include_bytes!("../../../assets/fonts/Inter-Medium.ttf"),- include_bytes!("../../../assets/fonts/Inter-SemiBold.ttf"),- include_bytes!("../../../assets/fonts/JetBrainsMono-Regular.ttf"),-];-/// Without `bundled-fonts` a database starts with none: the embedder adds its fonts-/// ([`FontDb::add_font`]); until then text has no glyphs.-#[cfg(not(feature = "bundled-fonts"))]-static BUNDLED: &[&[u8]] = &[];--/// An axis setting of a variable font: the axis tag (`wght`) and its value in user units (700).-pub type Variation = ([u8; 4], f32);--/// Caps on what a (possibly damaged) variable font can make the database read: axes per font and-/// named instances listed per face.-const MAX_AXES: usize = 64;-const MAX_INSTANCES: usize = 512;--/// One axis of a variable font's design space, as its `fvar` table lists it: the tag (`wght`), its-/// name in the font's name table (`Weight`; the tag when it has none) and its range and default,-/// in the axis's own units.-#[derive(Clone, Debug, PartialEq)]-pub struct VariationAxis {- pub tag: [u8; 4],- pub name: String,- pub min: f32,- pub default: f32,- pub max: f32,- /// The font asks for the axis not to be shown to users (the `fvar` hidden flag).- pub hidden: bool,-}--/// Faces of variable fonts instanced at axis settings their named instances don't have-/// ([`FontDb::instance`]). Each setting of a face keeps its id for the life of the process, so a-/// laid-out glyph's face can be found again ([`FontDb::face_by_id`]) after the built face was-/// dropped to bound the memory the cache holds.-#[derive(Default)]-struct Instances {- /// The id of each face and setting.- ids: HashMap<InstanceKey, u32>,- /// What each id is: the face it was instanced from and its axis settings.- recipes: HashMap<u32, (u32, Vec<Variation>)>,- /// The instanced faces built, by id; dropped all at once when [`MAX_LIVE_INSTANCES`] are held.- live: HashMap<u32, Arc<FontFace>>,-}--/// A face instanced at axis settings: the id of the face, and the settings by tag, as bits.-type InstanceKey = (u32, Vec<([u8; 4], u32)>);--/// How many instanced faces [`Instances::live`] holds at most.-pub(crate) const MAX_LIVE_INSTANCES: usize = 256;--#[derive(Clone)]-enum FontBytes {- Static(&'static [u8]),- Owned(Arc<Vec<u8>>),-}--/// One loaded font face.-pub struct FontFace {- /// Every name the face answers to (normalized), in every language its name table has.- keys: FaceKeys,- /// Its kind, for font menus' filters.- pub traits: FontTraits,- id: u32,- /// Typographic family name (e.g. "Source Sans 3").- pub family: String,- /// Non-English family name from the name table (`ヒラギノ角ゴシック`), when the font has one.- /// Used when Preferences › Type › Show Font Names in English is off.- pub native_family: Option<String>,- /// Typographic style name (e.g. "Semibold", "Italic").- pub style: String,- /// The font's version string (name ID 5, e.g. "Version 7.200"; empty when it has none). Two- /// installed versions of one family and style are told apart by it (see [`FontDb::face_version`]).- pub version: String,- /// usWeightClass-style weight (400 = regular).- pub weight: f32,- pub italic: bool,- bytes: FontBytes,- index: u32,- /// The file the face was read from (cataloged system fonts); `None` for the bundled fonts and- /// fonts added as bytes.- path: Option<std::path::PathBuf>,- pub(crate) upem: f64,- /// Ascender in font units (positive = up).- pub(crate) ascent: f64,- /// Descender in font units (positive = down).- pub(crate) descent: f64,- /// Cap height and x height in font units (estimated from the ascent when the font has no OS/2- /// values).- pub(crate) cap_height: f64,- pub(crate) x_height: f64,- /// Underline and strikeout: (offset from the baseline up to the line's top, thickness), in- /// font units (the `post` and OS/2 tables', else a common placement).- pub(crate) underline: (f64, f64),- pub(crate) strikeout: (f64, f64),- pub(crate) shaper: harfrust::ShaperData,- /// The axis settings of the variable font's named instance this face is (user units: `wght`- /// 700); empty for a static face or a variable font's default instance.- variations: Vec<Variation>,- /// [`Self::variations`] in the font's normalized design space (outlines and metrics).- location: Location,- /// [`Self::variations`] for the shaper (advances, kerning, feature variations).- pub(crate) instance: Option<harfrust::ShaperInstance>,- /// [`Self::ideographic_centre`], read once: layout asks for it per glyph.- ideographic_centre: std::sync::OnceLock<f64>,- /// [`Self::icf_margins`], read once.- icf_margins: std::sync::OnceLock<IcfMargins>,- /// Has `sbix` or `CBDT` strikes: colour bitmap glyphs ([`FontDb::glyph_image`]).- colour_bitmaps: bool,- /// Has `COLR` colour glyphs ([`FontDb::glyph_colour`]).- colour_layers: bool,- /// Has an `SVG ` table: OpenType SVG glyphs ([`FontDb::glyph_colour`]).- svg_glyphs: bool,-}--/// Where the ideographic character face (ICF) lies inside the ideographic em box: its distance-/// from each edge of the em box, in ems. `top` and `bottom` along a horizontal line, `right` and-/// `left` across a vertical one.-#[derive(Clone, Copy, Debug, Default, PartialEq)]-pub struct IcfMargins {- pub top: f64,- pub bottom: f64,- pub right: f64,- pub left: f64,-}--impl std::fmt::Debug for FontFace {- fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {- write!(f, "FontFace({} {})", self.family, self.style)- }-}--impl FontFace {- pub(crate) fn data(&self) -> &[u8] {- match &self.bytes {- FontBytes::Static(b) => b,- FontBytes::Owned(v) => v.as_slice(),- }- }- pub(crate) fn skrifa(&self) -> Option<skrifa::FontRef<'_>> {- skrifa::FontRef::from_index(self.data(), self.index).ok()- }- pub(crate) fn hb(&self) -> Option<harfrust::FontRef<'_>> {- harfrust::FontRef::from_index(self.data(), self.index).ok()- }- /// The face's index in its font file (collections hold several).- pub(crate) fn index(&self) -> u32 {- self.index- }- /// Where in a variable font's design space the face's outlines and metrics are taken (the- /// default location for a static face).- pub(crate) fn location(&self) -> LocationRef<'_> {- LocationRef::from(&self.location)- }- /// The axis settings of the variable font's named instance this face is (`wght` 700 for- /// Bold), in user units; empty for a static face and a variable font's default instance.- /// The face's file holds the whole variable font: exporters that embed it pass these on.- pub fn variations(&self) -> &[Variation] {- &self.variations- }- /// The variation axes of the face's font (its `fvar` table, at most 64); none for a static- /// face.- pub fn axes(&self) -> Vec<VariationAxis> {- let Some(f) = self.skrifa() else { return vec![] };- f.axes()- .iter()- .take(MAX_AXES)- .map(|a| {- let tag = a.tag().to_be_bytes();- let fallback = || String::from_utf8_lossy(&tag).trim().to_string();- let name = name(&f, &[a.name_id()]).unwrap_or_else(fallback);- VariationAxis { tag, name, min: a.min_value(), default: a.default_value(), max: a.max_value(), hidden: a.is_hidden() }- })- .collect()- }- /// The face's setting of axis `tag`: its named instance's ([`Self::variations`]), else the- /// axis default. `None` when the font has no such axis.- pub fn axis_value(&self, tag: [u8; 4]) -> Option<f32> {- let axis = self.axes().into_iter().find(|a| a.tag == tag)?;- Some(self.variations.iter().find(|(t, _)| *t == tag).map_or(axis.default, |(_, v)| *v))- }- /// Unique id of this face within the process.- pub fn id(&self) -> u32 {- self.id- }- /// Does the face map `c` to a glyph?- pub fn covers(&self, c: char) -> bool {- self.skrifa().is_some_and(|f| f.charmap().map(c).is_some())- }- /// Units per em.- pub fn units_per_em(&self) -> f64 {- self.upem- }- /// (ascent, descent) in font units, both positive.- pub fn vertical_metrics(&self) -> (f64, f64) {- (self.ascent, self.descent)- }- /// The line gap the font asks for between lines, in font units (from the same table as- /// [`vertical_metrics`](Self::vertical_metrics); 0 when it has none).- pub fn line_gap(&self) -> f64 {- self.skrifa().map_or(0.0, |f| f64::from(f.metrics(Size::unscaled(), self.location()).leading)).max(0.0)- }- /// Every mapped character and its glyph id, sorted by code point (the Glyphs panel).- pub fn chars(&self) -> Vec<(char, u32)> {- let Some(f) = self.skrifa() else { return vec![] };- let mut v: Vec<(char, u32)> = f.charmap().mappings().filter_map(|(cp, g)| char::from_u32(cp).map(|c| (c, g.to_u32()))).collect();- v.sort_unstable_by_key(|x| x.0);- v.dedup_by_key(|x| x.0);- v- }- /// Advance width of glyph `gid` in font units.- pub fn advance(&self, gid: u32) -> f64 {- self.skrifa()- .and_then(|f| f.glyph_metrics(Size::unscaled(), self.location()).advance_width(GlyphId::new(gid)))- .map(|a| a as f64)- .unwrap_or(self.upem * 0.5)- }- /// Glyph `gid` set upright in vertical type, from the font's vertical metrics: (its advance down- /// the column, the height above the baseline of its vertical origin, the top of its cell), in- /// font units. The origin is the `VORG` table's, else the glyph's top plus its top side bearing.- /// `None` when the font has no vertical metrics (`vhea`/`vmtx`), or they make no sense.- pub fn vertical_glyph(&self, gid: u32) -> Option<(f64, f64)> {- use skrifa::raw::TableProvider;- let f = self.skrifa()?;- let vmtx = f.vmtx().ok()?;- let g = GlyphId::new(gid);- let advance = f64::from(vmtx.advance(g)?);- let origin = match f.vorg() {- Ok(vorg) => f64::from(vorg.vertical_origin_y(g)),- Err(_) => {- let top = f.glyph_metrics(Size::unscaled(), self.location()).bounds(g).map_or(self.ascent, |b| f64::from(b.y_max));- top + f64::from(vmtx.side_bearing(g)?)- }- };- let em = self.upem;- // A glyph's cell is somewhere between a tenth of an em and a few ems, its top within a few- // ems of the baseline: anything else is a damaged table.- (advance > em * 0.1 && advance < em * 4.0 && origin.abs() < em * 4.0).then_some((advance, origin))- }- /// Height above the baseline of the centre of the face's ideographic em box, in ems: from its- /// vertical metrics (an ideograph's cell), else the usual 0.38 (the box running from 0.12 em- /// below the baseline to 0.88 em above it).- pub fn ideographic_centre(&self) -> f64 {- *self.ideographic_centre.get_or_init(|| {- let gid = ['国', 'あ', '一'].into_iter().map(|c| self.glyph_for(c)).find(|g| *g != 0);- gid.and_then(|g| self.vertical_glyph(g)).map_or(0.38, |(advance, origin)| (origin - advance * 0.5) / self.upem)- })- }- /// The ideographic character face as margins inside the em box ([`IcfMargins`]): from the- /// font's BASE table as the OpenType baseline tags define it (`icfb`, `icft` against `ideo`,- /// `idtp`), else, as that definition allows, from the bounds of some ideographs and kana- /// averaged, else none (the ICF is the em box).- /// <https://learn.microsoft.com/en-us/typography/opentype/spec/baselinetags>- pub fn icf_margins(&self) -> IcfMargins {- *self.icf_margins.get_or_init(|| self.icf_from_base().or_else(|| self.icf_from_glyphs()).unwrap_or_default())- }-- /// [`Self::icf_margins`] from the BASE table: the ICF's bottom edge `icfb` (top edge `icft`, else- /// as far below the em box top) against the em box `ideo` .. `idtp` (else the OS/2 typographic- /// descender, and one em above it); across vertical lines, `icfb` and `icft` of the vertical- /// axis against 0 .. `idtp` (else the horizontal margin, and one em).- pub(crate) fn icf_from_base(&self) -> Option<IcfMargins> {- use skrifa::raw::TableProvider;- let f = self.skrifa()?;- let base = f.base().ok()?;- let em = self.upem;- let h = base_values(base.horiz_axis()?.ok()?)?;- let icfb = *h.get(b"icfb")?;- let em_bottom = match h.get(b"ideo") {- Some(v) => *v,- None => f64::from(f.os2().ok()?.s_typo_descender()),- };- let em_top = h.get(b"idtp").copied().unwrap_or(em_bottom + em);- let margin = icfb - em_bottom;- let icf_top = h.get(b"icft").copied().unwrap_or(em_top - margin);- let v = base.vert_axis().and_then(Result::ok).and_then(base_values).unwrap_or_default();- let icf_left = v.get(b"icfb").copied().unwrap_or(margin);- let em_right = v.get(b"idtp").copied().unwrap_or(em);- let icf_right = v.get(b"icft").copied().unwrap_or(em_right - icf_left);- let m = IcfMargins { top: (em_top - icf_top) / em, bottom: margin / em, right: (em_right - icf_right) / em, left: icf_left / em };- // Inside the em box, short of its middle: anything else is a damaged table.- [m.top, m.bottom, m.right, m.left].iter().all(|x| (0.0..0.5).contains(x)).then_some(m)- }-- /// [`Self::icf_margins`] from the ink of some ideographs and kana: each edge's margin to the em- /// box (its centre [`Self::ideographic_centre`], one em high and wide), averaged.- pub(crate) fn icf_from_glyphs(&self) -> Option<IcfMargins> {- let f = self.skrifa()?;- let metrics = f.glyph_metrics(Size::unscaled(), self.location());- let em = self.upem;- let (em_bottom, em_top) = ((self.ideographic_centre() - 0.5) * em, (self.ideographic_centre() + 0.5) * em);- let boxes: Vec<_> = ['国', '東', '永', '書', 'あ', 'ア']- .into_iter()- .map(|c| self.glyph_for(c))- .filter(|g| *g != 0)- .filter_map(|g| metrics.bounds(GlyphId::new(g)))- .collect();- if boxes.is_empty() {- return None;- }- let n = boxes.len() as f64;- let mean = |v: &dyn Fn(&skrifa::metrics::BoundingBox) -> f32| boxes.iter().map(|b| f64::from(v(b))).sum::<f64>() / n;- let m = IcfMargins {- top: (em_top - mean(&|b| b.y_max)) / em,- bottom: (mean(&|b| b.y_min) - em_bottom) / em,- right: (em - mean(&|b| b.x_max)) / em,- left: mean(&|b| b.x_min) / em,- };- [m.top, m.bottom, m.right, m.left].iter().all(|x| (0.0..0.5).contains(x)).then_some(m)- }-- /// Glyph id for `c` (0 = .notdef).- pub fn glyph_for(&self, c: char) -> u32 {- self.skrifa().and_then(|f| f.charmap().map(c)).map(|g| g.to_u32()).unwrap_or(0)- }- /// The file the face was read from (cataloged system fonts).- pub fn path(&self) -> Option<&std::path::Path> {- self.path.as_deref()- }- /// The bytes of the face's font file (a collection holds several faces).- pub fn file_data(&self) -> &[u8] {- self.data()- }- /// The embedding permissions of the OS/2 table (`fsType`; 0, installable, when it has none).- pub fn fs_type(&self) -> u16 {- use skrifa::raw::TableProvider;- self.skrifa().and_then(|f| f.os2().ok()).map_or(0, |t| t.fs_type())- }- /// May the font file be copied along with a document? Its license allows embedding its- /// outlines, as exports check it ([`Self::embedding`]).- pub fn embeddable(&self) -> bool {- self.embedding() != crate::embed::Embedding::Forbidden- }- /// The face's index in its font file ([`Self::file_data`]; collections hold several).- pub fn face_index(&self) -> u32 {- self.index- }- /// The face's PostScript name, as PostScript files name fonts (`SourceSans3-Bold`): name ID 6;- /// for a named instance of a variable font (whose name ID 6 is the default instance's), its- /// prefix and style (`SourceSans3-Semibold`). Without one, its family and style.- pub fn postscript_name(&self) -> String {- let squeeze = |s: &str| -> String { s.chars().filter(|c| c.is_ascii_graphic() && !"[](){}<>/%".contains(*c)).collect() };- let own = self.skrifa().and_then(|f| localized(&f, StringId::POSTSCRIPT_NAME).into_iter().map(|(_, s)| s).next()).map(|s| squeeze(&s));- match own.filter(|s| !s.is_empty()) {- Some(name) if self.variations.is_empty() => name,- own => {- let prefix = own.as_deref().and_then(|n| n.split('-').next()).map_or_else(|| squeeze(&self.family), str::to_string);- format!("{prefix}-{}", squeeze(&self.style))- }- }- }- /// Are the face's outlines TrueType (`glyf`), not PostScript (`CFF `)?- pub fn is_truetype(&self) -> bool {- use skrifa::raw::TableProvider;- self.skrifa().is_some_and(|f| f.glyf().is_ok())- }-}--/// One installed family found by the system font scan: its name and the file of each style.-#[derive(Debug, Default)]-struct CatalogFamily {- name: String,- /// Non-English family name from the name table, when the scan found one.- native: Option<String>,- faces: Vec<CatalogFace>,- /// The family's kind (from its first face found); variable when any face found is.- traits: Option<FontTraits>,-}--/// One style of an installed family: a face, or a named instance of a variable font.-#[derive(Debug)]-#[cfg_attr(target_arch = "wasm32", allow(dead_code))]-struct CatalogFace {- style: String,- path: PathBuf,- /// Weight and italic as the style lists them (by its name, or a named instance's axes).- weight: f32,- italic: bool,-}--/// The installed fonts by ASCII-lowercased family name (lookups ignore ASCII case, as-/// [`FontDb::face`] does). Always empty on wasm, which has no system fonts.-type Catalog = HashMap<String, CatalogFamily>;--/// The installed faces' (family, style) by normalized PostScript name ([`norm`]).-type PostScriptNames = HashMap<String, (String, String)>;--/// Maps the family and style [`FontDb::canonical`] was asked for to its answer, for names that-/// are neither a loaded nor an installed family.-type CanonicalNames = HashMap<(String, String), (String, String)>;--/// [`FontDb::glyph_image`]'s answers by face and glyph.-type GlyphImages = GlyphCache<(u32, u32), Arc<GlyphImage>>;-/// [`FontDb::glyph_colour`]'s answers by face and glyph, and the text's fill and stroke colours for-/// glyphs that paint with them.-type GlyphColours = GlyphCache<(u32, u32, Option<TextColours>), ColourContent>;-/// The text's fill and stroke colours, as a cache key ([`Color::key`]).-type TextColours = ([u32; 5], Option<[u32; 5]>);--/// What a glyph's colour content (an image, layers) takes of memory, in bytes.-trait Weight {- fn bytes(&self) -> usize;-}--impl Weight for Arc<GlyphImage> {- fn bytes(&self) -> usize {- self.blob.bytes.len()- }-}--impl Weight for ColourContent {- fn bytes(&self) -> usize {- match self {- ColourContent::Image(i) => i.bytes(),- // Roughly what a path node with its outline and fill takes.- ColourContent::Art(art) => {- let mut nodes = 0;- art.walk(&mut |_| nodes += 1);- nodes * 512- }- }- }-}--/// The colour content of glyphs ([`FontDb::glyph_image`], [`FontDb::glyph_colour`]) kept by-/// face, glyph and what else it depends on, and its bytes in all.-struct GlyphCache<K, V> {- kept: HashMap<K, Option<V>>,- bytes: usize,-}--impl<K, V> Default for GlyphCache<K, V> {- fn default() -> Self {- Self { kept: HashMap::new(), bytes: 0 }- }-}--impl<K: std::hash::Hash + Eq, V: Weight> GlyphCache<K, V> {- /// Keeps `value` (or that there is none), first letting go of all it keeps when that would- /// take more than [`IMAGE_CACHE_MAX`] glyphs or [`IMAGE_CACHE_BYTES`]. A glyph it keeps- /// already, which another thread looked up meanwhile, stays as it is.- fn keep(&mut self, key: K, value: Option<V>) {- if self.kept.contains_key(&key) {- return;- }- let bytes = value.as_ref().map_or(0, Weight::bytes);- if self.kept.len() >= IMAGE_CACHE_MAX || self.bytes.saturating_add(bytes) > IMAGE_CACHE_BYTES {- self.kept.clear();- self.bytes = 0;- }- self.bytes += bytes;- self.kept.insert(key, value);- }-}+mod build;+mod cache;+mod db;+mod dirs;+mod face;+mod glyph_pen;+mod lookup;+mod names;+mod scan;+mod traits;+mod wanted;++pub use build::style_weight;+#[cfg(test)]+use cache::GlyphCache;+use cache::{CanonicalNames, Catalog, GlyphColours, GlyphImages, PostScriptNames};+#[cfg(all(not(target_arch = "wasm32"), test))]+pub(crate) use dirs::fonts_outside;+#[cfg(test)]+pub(crate) use dirs::sfnt_of;+pub use dirs::{+ PlatformFontFiles, app_font_dir, set_app_font_dir, set_platform_font_files, set_user_font_dirs, set_user_font_dirs_confined, system_font_dirs,+ user_font_dirs,+};+use face::Instances;+#[cfg(test)]+pub(crate) use face::MAX_LIVE_INSTANCES;+pub use face::{FALLBACK_FAMILY, FontFace, IcfMargins};+pub(crate) use glyph_pen::FlipPen;+#[cfg(not(target_arch = "wasm32"))]+use names::SysFallback;+#[cfg(test)]+pub use names::THAI_FAMILIES;+#[cfg(test)]+use names::{native_family_name, norm, pick_native_label};+#[cfg(all(not(target_arch = "wasm32"), test))]+pub(crate) use scan::file_face_names_within;+#[cfg(test)]+use scan::{MAX_FACES, enumerate_faces};+pub use scan::{is_font_file, is_suitcase};+use traits::Alias;+#[cfg(test)]+use traits::{FaceKeys, face_names};+pub use traits::{FontClass, FontMatch, FontTraits};+#[cfg(test)]+pub(crate) use traits::{alias_lists, face_styles, on_faces_published};+pub use wanted::{WantedFont, WantedFonts};/// Process-wide font database.pub struct FontDb {@@ -556,75 +137,6 @@ fn modified(path: &Path) -> Option<std::time::SystemTime> {std::fs::metadata(path).and_then(|m| m.modified()).ok()}-#[cfg(not(target_arch = "wasm32"))]-#[derive(Default)]-struct SysFallback {- enabled: bool,- misses: std::collections::HashSet<char>,- /// Counts the scans of the font folders: a search that a scan overtook doesn't record its miss.- scans: u64,-}--/// Fonts made for Thai, tried first (when installed) for Thai the font in use lacks: Windows-/// (Leelawadee UI; Tahoma before Windows 8), macOS (Thonburi, Sukhumvit Set) and Linux (Noto,-/// TLWG).-pub const THAI_FAMILIES: &[&str] = &[- "Leelawadee UI",- "Leelawadee",- "Tahoma",- "Thonburi",- "Sukhumvit Set",- "Noto Sans Thai",- "Noto Sans Thai UI",- "Noto Sans Thai Looped",- "Waree",- "Loma",- "Garuda",-];--/// The families tried first for character `c`, in a script whose text only fonts made for it set-/// well (Thai, Lao, Khmer, Myanmar); none for other characters.-fn script_families(c: char) -> &'static [&'static str] {- use unicode_script::{Script, UnicodeScript};- match c.script() {- Script::Thai => THAI_FAMILIES,- Script::Lao => &["Lao UI", "Leelawadee UI", "Lao Sangam MN", "Noto Sans Lao", "Noto Sans Lao UI", "Phetsarath OT"],- Script::Khmer => &["Khmer UI", "Khmer Sangam MN", "Noto Sans Khmer", "Noto Sans Khmer UI", "Khmer OS"],- Script::Myanmar => &["Myanmar Text", "Myanmar Sangam MN", "Noto Sans Myanmar", "Noto Sans Myanmar UI", "Padauk"],- _ => &[],- }-}--/// Families tried (when installed) for characters the loaded fonts lack: CJK, symbols, emoji.-#[cfg(not(target_arch = "wasm32"))]-const SYSTEM_FALLBACKS: &[&str] = &[- "Helvetica Neue",- "Arial",- "Segoe UI",- "Noto Sans",- "DejaVu Sans",- "PingFang SC",- "Hiragino Sans",- "Hiragino Kaku Gothic ProN",- "Apple SD Gothic Neo",- "Heiti SC",- "STHeiti",- "Microsoft YaHei",- "Yu Gothic",- "Malgun Gothic",- "Noto Sans CJK SC",- "Noto Sans CJK JP",- "Arial Unicode MS",- "Apple Symbols",- "Segoe UI Symbol",- "Noto Sans Symbols",- "Noto Sans Symbols2",- "Noto Emoji",- "Segoe UI Emoji",- "Apple Color Emoji",- "Noto Color Emoji",-];-static NEXT_ID: AtomicU32 = AtomicU32::new(1);const OUTLINE_CACHE_MAX: usize = 50_000;/// The most glyph images [`FontDb::glyph_image`] keeps (each a PNG of some 10–60 KB).@@ -635,2072 +147,9 @@ const IMAGE_CACHE_BYTES: usize = 64 << 20;/// them before it keeps the next one.const CANONICAL_CACHE_MAX: usize = 4_096;-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()))-}--/// The most distinct legacy family (and style) names of a font used as keys.-const MAX_LEGACY_NAMES: usize = 64;--/// Every localized string of `id`, with its language.-fn localized(font: &skrifa::FontRef<'_>, id: StringId) -> Vec<(Option<String>, String)> {- font.localized_strings(id).map(|s| (s.language().map(str::to_owned), s.to_string())).filter(|(_, s)| !s.is_empty()).collect()-}--/// Whether a name-table language tag is English (Illustrator's "Show Font Names in English").-fn is_english_lang(lang: Option<&str>) -> bool {- lang.is_some_and(|l| {- let l = l.to_ascii_lowercase();- l == "en" || l == "eng" || l.starts_with("en-") || l.starts_with("en_")- })-}--/// A non-English family label from the name table, for Preferences › Type › Show Font Names in-/// English (off). Prefers a record whose language isn't English; else any label that differs from-/// `english` and isn't plain ASCII. `None` when the font has no other name.-fn pick_native_label(english: &str, pairs: &[(Option<String>, String)]) -> Option<String> {- pairs- .iter()- .find(|(lang, s)| !s.eq_ignore_ascii_case(english) && !is_english_lang(lang.as_deref()))- .or_else(|| pairs.iter().find(|(_, s)| !s.eq_ignore_ascii_case(english) && !s.is_ascii()))- .map(|(_, s)| s.clone())-}--/// The family's native-language name from the font (typographic, else legacy), when it has one.-fn native_family_name(font: &skrifa::FontRef<'_>, english: &str) -> Option<String> {- pick_native_label(english, &localized(font, StringId::TYPOGRAPHIC_FAMILY_NAME))- .or_else(|| pick_native_label(english, &localized(font, StringId::FAMILY_NAME)))-}--/// Every localized string of `id`.-fn all_names(font: &skrifa::FontRef<'_>, id: StringId) -> Vec<String> {- localized(font, id).into_iter().map(|(_, s)| s).collect()-}--/// The names a face answers to besides its (English) family and style, normalized ([`norm`]):-/// its family in every language (typographic, else legacy: `ヒラギノ角ゴシック`), its style likewise-/// (`ミディアム`), its legacy family names (`Hiragino Sans W3`) with their legacy styles, paired per-/// language record (the Mac and Windows records of a face differ), its full names (name ID 4),-/// and its PostScript names (`HiraginoSans-W3`, as PDF and `.ai` files name fonts).-#[derive(Clone, Debug, Default)]-struct FaceKeys {- families: Vec<String>,- styles: Vec<String>,- legacy: Vec<(String, String)>,- full_names: Vec<String>,- postscript: Vec<String>,-}--impl FaceKeys {- fn of(font: &skrifa::FontRef<'_>, family: &str, style: &str) -> Self {- let (typo_family, typo_style) = (all_names(font, StringId::TYPOGRAPHIC_FAMILY_NAME), all_names(font, StringId::TYPOGRAPHIC_SUBFAMILY_NAME));- let (mut legacy_family, mut legacy_style) = (localized(font, StringId::FAMILY_NAME), localized(font, StringId::SUBFAMILY_NAME));- // Records repeat (platforms, encodings) and are paired below: once each, and no more than a- // font has any use for, or the pairs multiply.- for names in [&mut legacy_family, &mut legacy_style] {- names.sort();- names.dedup();- names.truncate(MAX_LEGACY_NAMES);- }- // Without typographic names, the legacy ones are the family's.- let family_names: Vec<&str> = if typo_family.is_empty() {- legacy_family.iter().map(|(_, f)| f.as_str()).collect()- } else {- typo_family.iter().map(String::as_str).collect()- };- let mut families: Vec<String> = std::iter::once(family).chain(family_names).map(norm).collect();- // A legacy style only names the face beside its legacy family when the font has a- // typographic style: every weight of `Hiragino Sans` is `Regular` in its own legacy family.- let style_names: Vec<&str> = if typo_style.is_empty() {- legacy_style.iter().map(|(_, s)| s.as_str()).collect()- } else {- typo_style.iter().map(String::as_str).collect()- };- let mut styles: Vec<String> = std::iter::once(style).chain(style_names).map(norm).collect();- let mut legacy: Vec<(String, String)> = if typo_family.is_empty() {- vec![]- } else {- legacy_family- .iter()- .flat_map(|(lf, f)| legacy_style.iter().filter(move |(ls, _)| ls == lf).map(move |(_, s)| (norm(f), norm(s))))- .filter(|(f, s)| !f.is_empty() && !s.is_empty())- .collect()- };- let mut postscript: Vec<String> = all_names(font, StringId::POSTSCRIPT_NAME).iter().map(|n| norm(n)).collect();- let mut full_names: Vec<String> = all_names(font, StringId::FULL_NAME).iter().map(|n| norm(n)).collect();- for v in [&mut families, &mut styles, &mut full_names, &mut postscript] {- v.retain(|k| !k.is_empty());- v.sort();- v.dedup();- }- legacy.sort();- legacy.dedup();- FaceKeys { families, styles, legacy, full_names, postscript }- }-}--/// A font's kind, for filtering font menus: the classification of its OS/2 table (IBM family-/// class, PANOSE) and, for CJK fonts whose tables seldom say, its names (明朝, ゴシック, 丸…).-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]-pub enum FontClass {- /// Serif (Latin) or Mincho (CJK).- Serif,- /// Sans serif (Latin) or Gothic (CJK).- Sans,- /// Rounded sans / Maru Gothic.- Rounded,- /// Script, handwriting, brush (楷書・行書・教科書…).- Script,- Monospaced,- /// Decorative, display, symbol and pictorial fonts.- Decorative,- #[default]- Other,-}--impl FontClass {- /// The kinds a font menu filters by (all but `Other`).- pub const ALL: [FontClass; 6] =- [FontClass::Serif, FontClass::Sans, FontClass::Rounded, FontClass::Script, FontClass::Monospaced, FontClass::Decorative];-}--/// What a font menu filters on: whether a family sets Japanese or Thai, its kind, and whether it-/// is a variable font.-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]-pub struct FontTraits {- pub japanese: bool,- /// Its character map has Thai (ก and า).- pub thai: bool,- pub class: FontClass,- /// The face has variation axes (an `fvar` table of at most 64 axes); for a family, one of- /// its faces has.- pub variable: bool,-}--impl FontTraits {- /// From a face's OS/2 and `fvar` tables (when it has them) and names.- fn of(font: &skrifa::FontRef<'_>, keys: &FaceKeys) -> Self {- use skrifa::raw::TableProvider;- let os2 = font.os2().ok();- let names: Vec<&str> = keys.families.iter().chain(&keys.postscript).map(String::as_str).collect();- let named = |words: &[&str]| names.iter().any(|n| words.iter().any(|w| n.contains(w)));- let has_japanese_name = keys.families.iter().any(|k| k.chars().any(|c| matches!(c as u32, 0x3040..=0x30FF | 0x4E00..=0x9FFF)));- let (class_id, panose, ranges2, codepages) = match &os2 {- Some(o) => (o.s_family_class(), o.panose_10().to_vec(), o.ul_unicode_range_2(), o.ul_code_page_range_1().unwrap_or(0)),- None => (0, vec![], 0, 0),- };- // Hiragana (bit 49) or Katakana (bit 50) in the Unicode ranges, or the JIS code page.- let japanese = ranges2 & (0b11 << 17) != 0 || codepages & (1 << 17) != 0 || has_japanese_name;- let thai = ['\u{0E01}', '\u{0E32}'].iter().all(|c| font.charmap().map(*c).is_some());- let family_type = panose.first().copied().unwrap_or(0);- let serif_style = panose.get(1).copied().unwrap_or(0);- let proportion = panose.get(3).copied().unwrap_or(0);- let ibm = (class_id >> 8) as u8;- let class = if named(&["丸", "maru", "rounded", "round"]) || japanese && named(&["jun"]) {- FontClass::Rounded- } else if named(&[- "楷書",- "行書",- "草書",- "隷書",- "教科書",- "毛筆",- "筆",- "kaisho",- "gyosho",- "sosho",- "reisho",- "kyokasho",- "brush",- "script",- "hand",- "kaiti",- "xingkai",- "libian",- ]) {- FontClass::Script- } else if named(&["mono", "code", "courier", "menlo", "consol"]) {- FontClass::Monospaced- } else if named(&[- "明朝",- "mincho",- "ryumin",- "hiramin",- "yumin",- "kozmin",- "serif",- "songti",- "simsun",- "stsong",- "fangsong",- "myungjo",- "times",- "georgia",- "garamond",- "baskerville",- "bodoni",- "caslon",- "palatino",- "didot",- "century",- "cambria",- "minion",- "charter",- "hoefler",- ]) && !named(&["sansserif", "sans"])- {- FontClass::Serif- } else if named(&[- "ゴシック",- "gothic",- "goth",- "sans",- "kakugo",- "kaku",- "heiti",- "helvetica",- "arial",- "grotesk",- "grotesque",- "futura",- "gill",- "verdana",- "tahoma",- "frutiger",- "avenir",- "geneva",- "lucidagrande",- "inter",- "roboto",- "optima",- "pingfang",- ]) {- FontClass::Sans- } else if family_type == 2 && proportion == 9 {- FontClass::Monospaced- } else if family_type == 3 || ibm == 10 {- FontClass::Script- } else if family_type == 4 || family_type == 5 || ibm == 9 || ibm == 12 {- FontClass::Decorative- } else if matches!(ibm, 1..=5 | 7) || family_type == 2 && (2..=10).contains(&serif_style) {- FontClass::Serif- } else if ibm == 8 || family_type == 2 && (11..=13).contains(&serif_style) {- FontClass::Sans- } else {- FontClass::Other- };- let variable = (1..=MAX_AXES).contains(&font.axes().len());- FontTraits { japanese, thai, class, variable }- }-}--/// What a name other than a family's own one stands for ([`FontDb::canonical`]).-#[derive(Clone, Debug)]-struct Alias {- /// The family's own name.- family: String,- /// The face the name names, for legacy family names, full names and PostScript names.- style: Option<String>,- /// A legacy family name's legacy style (`Regular` beside `Hiragino Sans W3`).- paired: Option<String>,-}--impl Alias {- /// The aliases of a face `family` / `style` with `keys`, by normalized name.- fn of(family: &str, style: &str, keys: &FaceKeys) -> Vec<(String, Alias)> {- #[cfg(test)]- ALIAS_LISTS.with(|c| c.set(c.get() + 1));- let mut v: Vec<(String, Alias)> =- keys.families.iter().map(|k| (k.clone(), Alias { family: family.to_string(), style: None, paired: None })).collect();- v.extend(- keys.legacy- .iter()- .map(|(f, s)| (f.clone(), Alias { family: family.to_string(), style: Some(style.to_string()), paired: Some(s.clone()) })),- );- v.extend(- keys.postscript- .iter()- .chain(&keys.full_names)- .map(|k| (k.clone(), Alias { family: family.to_string(), style: Some(style.to_string()), paired: None })),- );- v- }-}--#[cfg(test)]-thread_local! {- /// Tests: counts the faces whose aliases ([`Alias::of`]) were listed on this thread.- static ALIAS_LISTS: std::cell::Cell<u64> = const { std::cell::Cell::new(0) };-}--/// Tests: returns how many faces' aliases were listed on this thread.-#[cfg(test)]-pub(crate) fn alias_lists() -> u64 {- ALIAS_LISTS.with(std::cell::Cell::get)-}--#[cfg(test)]-thread_local! {- /// Tests: run on this thread each time it publishes faces to a database, to look the database- /// up at exactly that point (as another thread could).- static ON_FACES_PUBLISHED: std::cell::RefCell<Option<Box<dyn FnMut()>>> = const { std::cell::RefCell::new(None) };-}--/// Tests: run `hook` each time this thread publishes faces to a database.-#[cfg(test)]-pub(crate) fn on_faces_published(hook: Option<Box<dyn FnMut()>>) {- ON_FACES_PUBLISHED.with(|h| *h.borrow_mut() = hook);-}--#[cfg(test)]-fn faces_published() {- // Taken out while it runs, so a hook that adds faces itself doesn't run again.- if let Some(mut hook) = ON_FACES_PUBLISHED.with(|h| h.borrow_mut().take()) {- hook();- ON_FACES_PUBLISHED.with(|h| {- h.borrow_mut().get_or_insert(hook);- });- }-}--/// How a requested family and style resolved ([`FontDb::resolve`]).-#[derive(Clone, Copy, Debug, PartialEq, Eq)]-pub enum FontMatch {- /// The face of that family and style (by any of its names, in any language).- Exact,- /// The family is there but not the style: its closest style stands in.- Style,- /// The family is unknown: the fallback family stands in.- Missing,-}--impl FontMatch {- pub fn as_str(self) -> &'static str {- match self {- FontMatch::Exact => "exact",- FontMatch::Style => "substitute",- FontMatch::Missing => "missing",- }- }-}--/// A face's (family, style) names.-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))-}--/// One style a font file offers: one of its faces, or a named instance of a variable font-/// (Figtree's `Figtree[wght].ttf` holds Light, the default, and Regular to Black as instances).-#[derive(Clone, Debug)]-pub(crate) struct FaceStyle {- family: String,- /// See [`FontFace::native_family`].- native_family: Option<String>,- style: String,- keys: FaceKeys,- /// A named instance's axis settings (user units); empty for the face itself.- variations: Vec<Variation>,- /// A named instance's weight (its `wght` setting); `None` for the face itself (its OS/2 table- /// says) or an instance of a font without a weight axis.- weight: Option<f32>,- /// A named instance is italic (by its `ital` or `slnt` setting, or its name).- italic: bool,- /// Its kind, for font menus' filters (the face's, shared by its named instances).- traits: FontTraits,-}--/// The styles of a face: the face itself, then its named instances when it is a variable font.-pub(crate) fn face_styles(f: &skrifa::FontRef<'_>) -> Vec<FaceStyle> {- let Some((family, style)) = face_names(f) else { return vec![] };- let native_family = native_family_name(f, &family);- let mut keys = FaceKeys::of(f, &family, &style);- let traits = FontTraits::of(f, &keys);- let (mut instances, renamed) = named_instances(f, &family, &style, &mut keys, native_family.clone());- for i in &mut instances {- i.traits = traits;- }- // A variable font's default face renders at its `wght` default, whatever its name table and- // OS/2 table say (Noto Sans Hebrew: named `Light`, weight class 300, default instance Regular- // at 400): weigh it so, and name it by its default instance when that is another weight.- let weight = f- .axes()- .iter()- .find(|a| a.tag().to_be_bytes() == *b"wght")- .map(|a| a.default_value())- .filter(|w| w.is_finite())- .map(|w| w.clamp(1.0, 1000.0));- let style = renamed.unwrap_or(style);- let face = FaceStyle { family, native_family, style, keys, variations: vec![], weight, italic: false, traits };- std::iter::once(face).chain(instances).collect()-}--/// The named instances of a variable font face (its `fvar` table) as styles of the face's family,-/// named by their subfamily names, without the default instance (the face itself) and without-/// names already taken. The default instance's name, when it isn't the face's style name (a face-/// `Regular` whose default instance is `Book`), names the face too (`keys`). Damaged tables give-/// fewer instances or none; the counts read are capped.-fn named_instances(- f: &skrifa::FontRef<'_>,- family: &str,- style: &str,- keys: &mut FaceKeys,- native_family: Option<String>,-) -> (Vec<FaceStyle>, Option<String>) {- let axes = f.axes();- if axes.is_empty() || axes.len() > MAX_AXES {- return (vec![], None);- }- let tags: Vec<Tag> = axes.iter().map(|a| a.tag()).collect();- let defaults: Vec<f32> = axes.iter().map(|a| a.default_value()).collect();- let is_default = |coords: &[f32]| coords.len() == defaults.len() && coords.iter().zip(&defaults).all(|(c, d)| (c - d).abs() < 1e-3);- // The face renders as its default instance. When that instance is another weight than the- // name table says (`Light` face, Regular default instance), the instance names the face.- let renamed = tags.iter().any(|t| t.to_be_bytes() == *b"wght").then(|| {- f.named_instances()- .iter()- .take(MAX_INSTANCES)- .filter(|inst| is_default(&inst.user_coords().take(MAX_AXES).collect::<Vec<f32>>()))- .find_map(|inst| name(f, &[inst.subfamily_name_id()]))- .filter(|d| style_weight(d) != style_weight(style))- });- let renamed = renamed.flatten();- // Instances without a PostScript name of their own are named `<prefix>-<style>` (Adobe- // Technical Note #5902), as PDF and `.ai` files name them.- let prefix = name(f, &[StringId::VARIATIONS_POSTSCRIPT_NAME_PREFIX]).unwrap_or_else(|| family.to_string());- if let Some(new) = &renamed {- let old = norm(style);- keys.styles.retain(|k| *k != old);- keys.styles.push(norm(new));- }- let mut taken = vec![norm(renamed.as_deref().unwrap_or(style))];- let mut out = Vec::new();- for inst in f.named_instances().iter().take(MAX_INSTANCES) {- let coords: Vec<f32> = inst.user_coords().take(MAX_AXES).collect();- if coords.len() != tags.len() || coords.iter().any(|c| !c.is_finite()) {- continue;- }- let Some(style) = name(f, &[inst.subfamily_name_id()]) else { continue };- let ns = norm(&style);- if ns.is_empty() || taken.contains(&ns) {- continue;- }- // The default instance is the face itself.- if coords.iter().zip(&defaults).all(|(c, d)| (c - d).abs() < 1e-3) {- keys.styles.push(ns.clone());- keys.postscript.push(norm(&format!("{prefix}{style}")));- taken.push(ns);- continue;- }- taken.push(ns);- let axis = |tag: &[u8; 4]| tags.iter().zip(&coords).find(|(t, _)| t.to_be_bytes() == *tag).map(|(_, v)| *v);- let weight = axis(b"wght").map(|w| w.clamp(1.0, 1000.0));- let italic = style_italic(&style) || axis(b"ital").is_some_and(|v| v >= 0.5) || axis(b"slnt").is_some_and(|v| v != 0.0);- let mut styles: Vec<String> = std::iter::once(style.clone()).chain(all_names(f, inst.subfamily_name_id())).map(|s| norm(&s)).collect();- let mut postscript: Vec<String> = inst.postscript_name_id().map(|id| all_names(f, id)).unwrap_or_default().iter().map(|n| norm(n)).collect();- postscript.push(norm(&format!("{prefix}{style}")));- for v in [&mut styles, &mut postscript] {- v.retain(|k| !k.is_empty());- v.sort();- v.dedup();- }- // Name ID 4 describes the default face, not every named instance of its variable font.- let keys = FaceKeys { families: keys.families.clone(), styles, legacy: vec![], full_names: vec![], postscript };- let variations = tags.iter().zip(&coords).map(|(t, v)| (t.to_be_bytes(), *v)).collect();- out.push(FaceStyle {- family: family.to_string(),- native_family: native_family.clone(),- style,- keys,- variations,- weight,- italic,- traits: FontTraits::default(),- });- }- (out, renamed)-}--/// The most faces read from a (possibly damaged) collection.-const MAX_FACES: u32 = 256;--/// Parse every face in `data` (a font file or collection) and the named instances of its variable-/// ones. Returns each style with the index of its face.-fn enumerate_faces(data: &[u8]) -> Vec<(u32, FaceStyle)> {- let count = match FileRef::new(data) {- Ok(FileRef::Font(_)) => 1,- Ok(FileRef::Collection(c)) => c.len().min(MAX_FACES),- Err(_) => 0,- };- (0..count)- .filter_map(|i| Some((i, skrifa::FontRef::from_index(data, i).ok()?)))- .flat_map(|(i, f)| face_styles(&f).into_iter().map(move |s| (i, s)))- .collect()-}--/// The font files held by the file at `path`: its contents, or for a suitcase font the fonts in-/// its resource fork ([`crate::suitcase`]). None when it can't be read.-#[cfg(not(target_arch = "wasm32"))]-fn font_files(path: &Path) -> Vec<Vec<u8>> {- if crate::suitcase::is_suitcase(path) {- return crate::suitcase::read_fonts(path);- }- std::fs::read(path).into_iter().collect()-}--/// The tables holding glyphs the font engine draws: TrueType, CFF, CFF2 and VARC outlines, and-/// `sbix` and `CBDT` colour bitmaps. A face with none of them (outlines in Apple's `hvgl` table,-/// monochrome bitmaps only) draws nothing.-#[cfg(not(target_arch = "wasm32"))]-const OUTLINE_TABLES: [&[u8; 4]; 6] = [b"glyf", b"CFF ", b"CFF2", b"VARC", b"sbix", b"CBDT"];--/// The styles of every face in the font file at `path` ([`face_styles`]), reading only its table-/// directories and `name`, `fvar` and `OS/2` tables: a scan opens hundreds of font files, many of-/// them megabytes long. Faces without outlines the font engine draws (no [`OUTLINE_TABLES`] table)-/// are left out.-#[cfg(not(target_arch = "wasm32"))]-fn file_face_names(path: &Path) -> Vec<FaceStyle> {- file_face_names_within(path, MAX_FACES, u64::MAX)-}--/// [`file_face_names`], reading at most `max_faces` faces and `max_read` bytes of the file in all.-/// A suitcase font's resource fork is read whole when it is at most `max_read` bytes long, and the-/// limits then apply to each of its fonts; a longer fork gives none.-#[cfg(not(target_arch = "wasm32"))]-pub(crate) fn file_face_names_within(path: &Path, max_faces: u32, max_read: u64) -> Vec<FaceStyle> {- if crate::suitcase::is_suitcase(path) {- if crate::suitcase::fork_len(path) > max_read {- return vec![];- }- return crate::suitcase::read_fonts(path)- .into_iter()- .flat_map(|font| reader_face_names_within(std::io::Cursor::new(font), max_faces, max_read))- .collect();- }- match std::fs::File::open(path) {- Ok(file) => reader_face_names_within(file, max_faces, max_read),- Err(_) => vec![],- }-}--/// [`file_face_names_within`] for the font file `file` reads.-#[cfg(not(target_arch = "wasm32"))]-fn reader_face_names_within(mut file: impl std::io::Read + std::io::Seek, max_faces: u32, max_read: u64) -> Vec<FaceStyle> {- use std::io::SeekFrom;- /// The largest table read from a (possibly damaged) file.- const MAX_NAME_TABLE: u32 = 1 << 20;- let mut read = 0u64;- let mut read_at = |offset: u64, len: usize| -> Option<Vec<u8>> {- read = read.checked_add(u64::try_from(len).ok()?).filter(|r| *r <= max_read)?;- 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)?;- if !records.as_chunks::<16>().0.iter().any(|r| OUTLINE_TABLES.iter().any(|t| r.starts_with(*t))) {- return None;- }- let mut table = |tag: &[u8; 4]| -> Option<Vec<u8>> {- let rec: &[u8] = records.as_chunks::<16>().0.iter().find(|r| r.starts_with(tag))?;- let (offset, len) = (be32(rec, 8)?, be32(rec, 12)?);- if len > MAX_NAME_TABLE {- return None;- }- read_at(offset.into(), len as usize)- };- let name = table(b"name")?;- // A variable font's named instances are styles too.- let fvar = table(b"fvar");- // Its OS/2 table (the font's classification, for the menus' filters), when it has one.- let os2 = table(b"OS/2");- // A font holding just these tables, to read them as the font itself would.- let mut tables: Vec<(&[u8; 4], &[u8])> = vec![(b"name", &name)];- if let Some(fvar) = &fvar {- tables.push((b"fvar", fvar));- }- if let Some(os2) = &os2 {- tables.push((b"OS/2", os2));- }- let font = sfnt_of(&tables)?;- Some(face_styles(&skrifa::FontRef::new(&font).ok()?))- })- .flatten()- .collect()-}--/// Whether the file at `path` is a font file by its extension (`.ttf`, `.otf`, `.ttc` or `.otc`,-/// in any case), as the font scan reads the files in a folder.-pub fn is_font_file(path: &Path) -> bool {- path.extension().and_then(|e| e.to_str()).is_some_and(|e| ["ttf", "otf", "ttc", "otc"].iter().any(|x| e.eq_ignore_ascii_case(x)))-}--/// Whether the file at `path` is a suitcase font ([`crate::suitcase`]): on macOS, a file with-/// nothing in its data and its fonts in its resource fork. Never on the web.-pub fn is_suitcase(path: &Path) -> bool {- #[cfg(not(target_arch = "wasm32"))]- {- crate::suitcase::is_suitcase(path)- }- #[cfg(target_arch = "wasm32")]- {- let _ = path;- false- }-}--/// A font a document names that isn't available, to look for in font files ([`WantedFonts`]).-#[derive(Clone, Debug, PartialEq, Eq)]-pub struct WantedFont {- pub family: String,- pub style: String,- /// When the family is installed but not the style ([`FontMatch::Style`]): the family of the- /// face [`FontDb::resolve`] gives instead. `None` when the family is missing.- pub installed: Option<String>,-}--/// Fonts to look for in font files: [`WantedFonts::provided_by`] tells which of them a file-/// provides.-#[derive(Debug, Default)]-#[cfg_attr(target_arch = "wasm32", allow(dead_code))]-pub struct WantedFonts {- fonts: Vec<WantedFont>,- /// The indexes of the fonts by every name a face could answer to them by: the family as given- /// and the installed family (ASCII-lowercased), and the family normalized ([`norm`]).- by_name: HashMap<String, Vec<usize>>,-}--impl WantedFonts {- /// The most faces and bytes of one file a search reads.- #[cfg(not(target_arch = "wasm32"))]- const SEARCH_FACES: u32 = 64;- #[cfg(not(target_arch = "wasm32"))]- const SEARCH_READ: u64 = 8 << 20;-- pub fn new(fonts: &[WantedFont]) -> Self {- let mut by_name: HashMap<String, Vec<usize>> = HashMap::new();- for (i, w) in fonts.iter().enumerate() {- let mut names = vec![w.family.to_ascii_lowercase(), norm(&w.family)];- names.extend(w.installed.as_ref().map(|c| c.to_ascii_lowercase()));- names.sort();- names.dedup();- for n in names.into_iter().filter(|n| !n.is_empty()) {- by_name.entry(n).or_default().push(i);- }- }- Self { fonts: fonts.to_vec(), by_name }- }-- pub fn len(&self) -> usize {- self.fonts.len()- }-- pub fn is_empty(&self) -> bool {- self.fonts.is_empty()- }-- /// The indexes of the fonts that the font file at `path` provides: copied into a folder the- /// font scan reads, the file makes [`FontDb::resolve`] find each of them exactly, in one of its- /// faces or a variable font's named instances. The file is read as the scan reads it (its- /// table directories and its `name`, `fvar` and `OS/2` tables), at most 64 faces and 8 MB of- /// it, when it is a font file by its extension ([`is_font_file`]) or a suitcase font whose- /// resource fork is at most 8 MB long. Sorted; none on the web.- pub fn provided_by(&self, path: &Path) -> Vec<usize> {- #[cfg(not(target_arch = "wasm32"))]- {- if !is_font_file(path) && !crate::suitcase::is_suitcase(path) {- return Vec::new();- }- let faces = file_face_names_within(path, Self::SEARCH_FACES, Self::SEARCH_READ);- self.provided_by_faces(&faces)- }- #[cfg(target_arch = "wasm32")]- {- let _ = path;- Vec::new()- }- }-- /// [`Self::provided_by`] for the faces of a file.- #[cfg_attr(target_arch = "wasm32", allow(dead_code))]- fn provided_by_faces(&self, faces: &[FaceStyle]) -> Vec<usize> {- let mut candidates: Vec<usize> = Vec::new();- for f in faces {- let names = std::iter::once(f.family.to_ascii_lowercase())- .chain(f.keys.families.iter().cloned())- .chain(f.keys.legacy.iter().map(|(family, _)| family.clone()))- .chain(f.keys.full_names.iter().cloned())- .chain(f.keys.postscript.iter().cloned());- for n in names {- candidates.extend(self.by_name.get(&n).into_iter().flatten());- }- }- candidates.sort_unstable();- candidates.dedup();- candidates.retain(|i| self.fonts.get(*i).is_some_and(|w| provides(w, faces)));- candidates- }-}--/// Whether the faces of a font file, cataloged by a rescan, make [`FontDb::resolve`] find `w`-/// exactly in one of them: [`FontDb::canonical`] and [`FontDb::find`] over these faces, as they-/// would run once the file is cataloged.-#[cfg_attr(target_arch = "wasm32", allow(dead_code))]-fn provides(w: &WantedFont, faces: &[FaceStyle]) -> bool {- let sk = norm(&w.style);- // A face of `family` with the style among its style names, as `find` looks for it once the- // family's files are loaded.- let styled = |family: &str| faces.iter().any(|f| f.family.eq_ignore_ascii_case(family) && f.keys.styles.contains(&sk));- let named_as_given = faces.iter().any(|f| f.family.eq_ignore_ascii_case(&w.family));- if let Some(installed) = &w.installed {- // A family cataloged by the name as given is found by it.- if named_as_given && !w.family.eq_ignore_ascii_case(installed) {- return styled(&w.family);- }- // The installed family is loaded: a face of it is loaded from the file only when its own- // style is the one asked for (`is_cataloged`).- return faces.iter().any(|f| f.family.eq_ignore_ascii_case(installed) && norm(&f.style) == sk);- }- if named_as_given {- return styled(&w.family);- }- let key = norm(&w.family);- if key.is_empty() {- return false;- }- // Another of a family's names keeps the style asked for.- if let Some(f) = faces.iter().find(|f| f.keys.families.contains(&key)) {- return styled(&f.family);- }- // A legacy family with its legacy style, a full name or a PostScript name names its face- // whatever style is asked for.- if faces.iter().any(|f| {- f.keys.legacy.iter().any(|(family, style)| *family == key && *style == sk)- || f.keys.full_names.contains(&key)- || f.keys.postscript.contains(&key)- }) {- return true;- }- // A legacy family with another style: that style of the family.- faces.iter().find(|f| f.keys.legacy.iter().any(|(family, _)| *family == key)).is_some_and(|f| styled(&f.family))-}--/// A font file holding `tables` (tag, data), sorted by tag as table directories are.-#[cfg(any(test, not(target_arch = "wasm32")))]-pub(crate) fn sfnt_of(tables: &[(&[u8; 4], &[u8])]) -> Option<Vec<u8>> {- let mut tables = tables.to_vec();- tables.sort_by_key(|t| *t.0);- let n = u16::try_from(tables.len()).ok()?;- let mut font = Vec::new();- font.extend_from_slice(&0x0001_0000_u32.to_be_bytes());- for v in [n, 0, 0, 0] {- font.extend_from_slice(&v.to_be_bytes());- }- let mut offset = 12 + 16 * tables.len();- for (tag, data) in &tables {- font.extend_from_slice(*tag);- for v in [0, u32::try_from(offset).ok()?, u32::try_from(data.len()).ok()?] {- font.extend_from_slice(&v.to_be_bytes());- }- offset += data.len().next_multiple_of(4);- }- for (_, data) in &tables {- font.extend_from_slice(data);- font.resize(font.len().next_multiple_of(4), 0);- }- Some(font)-}--/// Lists the font files the platform's font service knows, for [`set_platform_font_files`].-pub type PlatformFontFiles = fn() -> Vec<String>;--/// What lists the platform's font files, set by the app ([`set_platform_font_files`]).-#[cfg(not(target_arch = "wasm32"))]-static PLATFORM_FONT_FILES: std::sync::OnceLock<PlatformFontFiles> = std::sync::OnceLock::new();--/// Have [`system_font_dirs`] add the font files `list` gives (full paths) outside the font-/// folders, asked again by each scan and each check for installed fonts-/// ([`FontDb::installed_fonts_changed`]). The desktop app lists DirectWrite's system font-/// collection on Windows: fonts a font service such as Adobe Fonts loads in place, from files-/// outside the font folders and unknown to the registry (#579). On macOS it lists the fonts-/// CoreText's font manager has available, which apps and font managers can register from any-/// folder. Only the first call counts.-pub fn set_platform_font_files(list: PlatformFontFiles) {- #[cfg(not(target_arch = "wasm32"))]- // A second call keeps the first lister, as documented.- let _ = PLATFORM_FONT_FILES.set(list);- #[cfg(target_arch = "wasm32")]- let _ = list;-}--/// Folders the user adds to the font scan (Preferences › Type › Additional Fonts Folder, #683),-/// read with their subfolders after the platform's.-#[cfg(not(target_arch = "wasm32"))]-static USER_FONT_DIRS: std::sync::RwLock<Vec<PathBuf>> = std::sync::RwLock::new(Vec::new());--/// Have [`system_font_dirs`] also read `dirs` (#683), so the fonts in them are listed and used as-/// if installed. The next check for installed fonts ([`FontDb::installed_fonts_changed`]) then-/// reports the change, and a scan catalogs them.-pub fn set_user_font_dirs(dirs: Vec<PathBuf>) {- set_user_font_dirs_confined(dirs, false);-}--/// [`set_user_font_dirs`]; `confined` when a caller confined to some folders (automation) chose-/// them: the scan then reads only what is inside them, not files or folders that links in them-/// lead to elsewhere, since the caller could plant such a link.-pub fn set_user_font_dirs_confined(dirs: Vec<PathBuf>, confined: bool) {- #[cfg(not(target_arch = "wasm32"))]- {- *USER_FONT_DIRS.write().unwrap_or_else(std::sync::PoisonError::into_inner) = dirs;- USER_FONT_DIRS_CONFINED.store(confined, std::sync::atomic::Ordering::Relaxed);- }- #[cfg(target_arch = "wasm32")]- let _ = (dirs, confined);-}--/// Whether [`USER_FONT_DIRS`] were chosen by a confined caller ([`set_user_font_dirs_confined`]).-#[cfg(not(target_arch = "wasm32"))]-static USER_FONT_DIRS_CONFINED: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);--/// The folders, as found on disk, that the scan reads only the inside of-/// ([`set_user_font_dirs_confined`]).-#[cfg(not(target_arch = "wasm32"))]-fn confined_font_dirs() -> Vec<PathBuf> {- if !USER_FONT_DIRS_CONFINED.load(std::sync::atomic::Ordering::Relaxed) {- return vec![];- }- user_font_dirs().iter().filter_map(|d| std::fs::canonicalize(d).ok()).collect()-}--/// The folders [`set_user_font_dirs`] added (none on wasm).-pub fn user_font_dirs() -> Vec<PathBuf> {- #[cfg(not(target_arch = "wasm32"))]- return USER_FONT_DIRS.read().unwrap_or_else(std::sync::PoisonError::into_inner).clone();- #[cfg(target_arch = "wasm32")]- Vec::new()-}--/// VectorCraft's own Fonts folder, set by the app ([`set_app_font_dir`]).-#[cfg(not(target_arch = "wasm32"))]-static APP_FONT_DIR: std::sync::OnceLock<PathBuf> = std::sync::OnceLock::new();--/// Have [`system_font_dirs`] read `dir` with its subfolders: VectorCraft's own Fonts folder, which-/// `text.addFontFiles` copies font files into. The desktop app and `vectorcraft-cli` set it before-/// the first scan, as they install [`set_platform_font_files`]. A folder that doesn't exist yet is-/// read once it does. Only the first call counts. Ignored on wasm.-pub fn set_app_font_dir(dir: PathBuf) {- #[cfg(not(target_arch = "wasm32"))]- // A second call keeps the first folder, as documented.- let _ = APP_FONT_DIR.set(dir);- #[cfg(target_arch = "wasm32")]- let _ = dir;-}--/// The folder [`set_app_font_dir`] set: none before that, and none on wasm.-pub fn app_font_dir() -> Option<&'static Path> {- #[cfg(not(target_arch = "wasm32"))]- return APP_FONT_DIR.get().map(PathBuf::as_path);- #[cfg(target_arch = "wasm32")]- None-}--/// The platform's font folders (the system's and the user's), VectorCraft's own Fonts folder-/// ([`set_app_font_dir`]), the font files known to the platform outside them (on Windows those-/// registered with it, and those [`set_platform_font_files`] lists) and the folders the user added-/// ([`set_user_font_dirs`]), scanned by [`FontDb::global`].-pub fn system_font_dirs() -> Vec<PathBuf> {- let mut dirs: Vec<PathBuf> = Vec::new();- if cfg!(target_arch = "wasm32") {- return dirs;- }- let home = std::env::var_os("HOME").map(PathBuf::from);- if cfg!(target_os = "macos") {- dirs.extend(["/System/Library/Fonts", "/Library/Fonts", "/Network/Library/Fonts"].map(Into::into));- if let Some(h) = &home {- dirs.push(h.join("Library/Fonts"));- }- // Fonts macOS downloads on demand (Yu Gothic, Yu Mincho, Tsukushi Maru Gothic…): one- // asset folder per font, under a catalog folder whose number changes with macOS.- for e in std::fs::read_dir("/System/Library/AssetsV2").into_iter().flatten().flatten() {- if e.file_name().to_string_lossy().starts_with("com_apple_MobileAsset_Font") {- dirs.push(e.path());- }- }- } else if cfg!(windows) {- let root = std::env::var_os("WINDIR").map(PathBuf::from).unwrap_or_else(|| "C:\\Windows".into());- dirs.push(root.join("Fonts"));- // Fonts installed for the current user only (what Install does without administrator rights).- if let Some(l) = std::env::var_os("LOCALAPPDATA") {- dirs.push(PathBuf::from(l).join("Microsoft\\Windows\\Fonts"));- }- #[cfg(windows)]- dirs.extend(registered_font_files(&dirs));- } else {- dirs.extend(["/usr/share/fonts", "/usr/local/share/fonts"].map(Into::into));- // The XDG data folders' `fonts` (fontconfig's user folder; Flatpak, Snap, NixOS and Guix- // list their own data folders), relative paths ignored as the XDG spec says.- let xdg = |var| std::env::var_os(var).map(|v| std::env::split_paths(&v).filter(|p| p.is_absolute()).collect::<Vec<_>>()).unwrap_or_default();- let data_home = xdg("XDG_DATA_HOME").into_iter().next().or_else(|| home.as_ref().map(|h| h.join(".local/share")));- dirs.extend(data_home.iter().cloned().chain(xdg("XDG_DATA_DIRS")).map(|d| d.join("fonts")));- if let Some(h) = &home {- dirs.push(h.join(".fonts"));- }- // In a Flatpak sandbox, the host's fonts (system, local and the user's).- dirs.extend(["/run/host/fonts", "/run/host/local-fonts", "/run/host/user-fonts"].map(Into::into));- // The folders fontconfig is set up with outside those: packages add their own (TeX fonts- // under `/usr/share/texmf/fonts`, #1529), and `fc-list` and other apps show their fonts.- let config_home = xdg("XDG_CONFIG_HOME").into_iter().next().or_else(|| home.as_ref().map(|h| h.join(".config")));- let places = crate::fontconfig::Places { home: home.clone(), data_home, config_home };- for dir in crate::fontconfig::font_dirs(&crate::fontconfig::root(), &places) {- if !dirs.iter().any(|known| dir.starts_with(known)) {- dirs.push(dir);- }- }- }- dirs.extend(app_font_dir().map(Path::to_path_buf));- #[cfg(not(target_arch = "wasm32"))]- if let Some(list) = PLATFORM_FONT_FILES.get() {- let files = fonts_outside(list(), &dirs);- dirs.extend(files);- }- dirs.extend(user_font_dirs());- dirs-}--/// The registry key listing the fonts installed on Windows (for all users under the local-/// machine's key, for the current user under theirs): one value per face, holding its file's-/// name in the Windows font folder or its full path.-#[cfg(windows)]-const REGISTERED_FONTS: &str = r"Software\Microsoft\Windows NT\CurrentVersion\Fonts";--/// The font files registered with Windows outside `font_dirs` (fonts installed as shortcuts to-/// where they are, or by programs into their own folders), which apps find by the registry.-#[cfg(windows)]-fn registered_font_files(font_dirs: &[PathBuf]) -> Vec<PathBuf> {- use windows_registry::{CURRENT_USER, LOCAL_MACHINE};- let values = [LOCAL_MACHINE, CURRENT_USER].into_iter().filter_map(|root| root.open(REGISTERED_FONTS).ok()).flat_map(|key| {- // A value that isn't a string isn't a font file.- key.values().map(|vs| vs.filter_map(|(_, v)| String::try_from(v).ok()).collect::<Vec<_>>()).unwrap_or_default()- });- fonts_outside(values, font_dirs)-}--/// The full paths among `registered` (font registrations' data) that aren't in `font_dirs`-/// (ignoring case, as Windows paths do), sorted and deduplicated. File names alone are files in-/// the Windows font folder, which is scanned anyway. The count is capped.-#[cfg(not(target_arch = "wasm32"))]-pub(crate) fn fonts_outside(registered: impl IntoIterator<Item = String>, font_dirs: &[PathBuf]) -> Vec<PathBuf> {- const MAX_REGISTERED: usize = 1 << 16;- let lower = |p: &Path| PathBuf::from(p.to_string_lossy().to_lowercase());- let dirs: Vec<PathBuf> = font_dirs.iter().map(|d| lower(d)).collect();- let mut files: Vec<PathBuf> = registered- .into_iter()- .take(MAX_REGISTERED)- .map(PathBuf::from)- .filter(|p| p.is_absolute() && !dirs.iter().any(|d| lower(p).starts_with(d)))- .collect();- files.sort();- files.dedup();- files-}--/// `face` at the axis settings `variations` (user units), as face `id`: its names, kind, italic-/// and file, and its weight the `wght` setting when there is one.-fn instanced(face: &FontFace, variations: Vec<Variation>, id: u32) -> Option<FontFace> {- let weight = variations.iter().find(|(t, _)| t == b"wght").map_or(face.weight, |(_, v)| *v);- let spec = FaceStyle {- family: face.family.clone(),- native_family: face.native_family.clone(),- style: face.style.clone(),- keys: face.keys.clone(),- variations,- weight: Some(weight),- italic: face.italic,- traits: face.traits,- };- let mut f = make_face(face.bytes.clone(), face.index, spec, face.path.clone())?;- f.id = id;- Some(f)-}--fn make_face(bytes: FontBytes, index: u32, spec: FaceStyle, path: Option<std::path::PathBuf>) -> Option<FontFace> {- let data: &[u8] = match &bytes {- FontBytes::Static(b) => b,- FontBytes::Owned(v) => v.as_slice(),- };- let f = skrifa::FontRef::from_index(data, index).ok()?;- let FaceStyle { family, native_family, style, keys, variations, weight, italic, traits } = spec;- let version = name(&f, &[StringId::VERSION_STRING]).unwrap_or_default();- // A named instance: outlines, metrics and advances at its axis settings.- let location = if variations.is_empty() { Location::default() } else { f.axes().location(variations.iter().map(|(t, v)| (Tag::new(t), *v))) };- let m = f.metrics(Size::unscaled(), &location);- let a = f.attributes();- let hb = harfrust::FontRef::from_index(data, index).ok()?;- let shaper = harfrust::ShaperData::new(&hb);- let instance =- (!variations.is_empty()).then(|| harfrust::ShaperInstance::from_variations(&hb, variations.iter().map(|(t, v)| (harfrust::Tag::new(t), *v))));- let upem = m.units_per_em.max(1) as f64;- let x_height = m.x_height.map(|v| v as f64).filter(|v| *v > 0.0).unwrap_or(m.ascent as f64 * 0.5);- let decoration = |d: Option<skrifa::metrics::Decoration>, fallback: (f64, f64)| {- d.map(|d| (f64::from(d.offset), f64::from(d.thickness))).filter(|(o, t)| o.is_finite() && *t > 0.0 && t.is_finite()).unwrap_or(fallback)- };- let underline = decoration(m.underline, (-0.075 * upem, 0.05 * upem));- let strikeout = decoration(m.strikeout, (x_height * 0.5 + 0.025 * upem, 0.05 * upem));- let colour_bitmaps = crate::bitmap::has_colour_bitmaps(&f);- let colour_layers = crate::colr::has_colour_layers(&f);- let svg_glyphs = crate::svg_glyph::has_svg_glyphs(&f);- Some(FontFace {- keys,- traits,- id: NEXT_ID.fetch_add(1, Ordering::Relaxed),- family,- native_family,- style,- version,- weight: weight.unwrap_or(a.weight.value()),- italic: italic || !matches!(a.style, skrifa::attribute::Style::Normal),- variations,- location,- instance,- upem,- ascent: m.ascent as f64,- descent: -(m.descent as f64),- cap_height: m.cap_height.map(|v| v as f64).filter(|v| *v > 0.0).unwrap_or(m.ascent as f64 * 0.72),- x_height,- underline,- strikeout,- shaper,- bytes,- index,- path,- ideographic_centre: std::sync::OnceLock::new(),- icf_margins: std::sync::OnceLock::new(),- colour_bitmaps,- colour_layers,- svg_glyphs,- })-}--/// An axis of a BASE table: its default baseline values for Han ideographs (`hani`), else kana-/// (`kana`), else its first script, by tag, in font units.-fn base_values(axis: skrifa::raw::tables::base::Axis<'_>) -> Option<HashMap<[u8; 4], f64>> {- let tags = axis.base_tag_list()?.ok()?;- let list = axis.base_script_list().ok()?;- let records = list.base_script_records();- let record =- [b"hani", b"kana"].into_iter().find_map(|t| records.iter().find(|r| r.base_script_tag() == Tag::new(t))).or_else(|| records.first())?;- let values = record.base_script(list.offset_data()).ok()?.base_values()?.ok()?;- let mut out = HashMap::new();- for (tag, coord) in tags.baseline_tags().iter().zip(values.base_coords().iter()) {- if let Ok(c) = coord {- out.insert(tag.get().to_be_bytes(), f64::from(c.coordinate()));- }- }- Some(out)-}--/// `s` lowercased, without anything but letters and digits.-fn norm_chars(s: &str) -> impl Iterator<Item = char> + '_ {- s.chars().filter(|c| c.is_alphanumeric()).flat_map(char::to_lowercase)-}--fn norm(s: &str) -> String {- norm_chars(s).collect()-}--/// Weight implied by a style name (400 = regular). Japanese faces number their weights W0–W9-/// (Hiragino, Morisawa…), W6 weighing 600 as its weight class does (#2873).-pub fn style_weight(style: &str) -> f32 {- let numbered = style.split(|c: char| !c.is_ascii_alphanumeric()).find_map(|part| match part.as_bytes() {- [b'W' | b'w', d @ b'0'..=b'9'] => Some(f32::from(d - b'0') * 100.0),- _ => None,- });- if let Some(w) = numbered {- return w.max(100.0);- }- let s = norm(style);- const TABLE: &[(&str, f32)] = &[- ("extralight", 200.0),- ("ultralight", 200.0),- ("semibold", 600.0),- ("demibold", 600.0),- ("extrabold", 800.0),- ("ultrabold", 800.0),- ("hairline", 100.0),- ("thin", 100.0),- ("light", 300.0),- ("medium", 500.0),- ("bold", 700.0),- ("black", 900.0),- ("heavy", 900.0),- ];- TABLE.iter().find(|(k, _)| s.contains(k)).map(|(_, w)| *w).unwrap_or(400.0)-}--fn style_italic(style: &str) -> bool {- let s = norm(style);- s.contains("italic") || s.contains("oblique") || s == "it"-}--/// How far `face` is from the style asked for: its weight difference, and a penalty for the wrong-/// slant. The penalty is less than the weight gap between Regular and Bold (and Bold and Black),-/// so Bold Italic asked of a family with Bold and Italic faces only gets the Bold (#2491).-fn style_distance(face: &FontFace, weight: f32, italic: bool) -> f32 {- (face.weight - weight).abs() + if face.italic != italic { 250.0 } else { 0.0 }-}-/// [`FontDb::menu_family_list`], with the [`FontDb::family_list`] it was built from.type MenuFamilies = (Arc<[String]>, Arc<[String]>);-impl FontDb {- /// A database holding the bundled fonts, whose system font scan reads `font_dirs` (folders,- /// read with their subfolders, and font files).- pub fn with_font_dirs(font_dirs: Vec<PathBuf>) -> Self {- Self::new(FontPaths::Fixed(font_dirs))- }-- /// Same scan paths as [`FontDb::global`] (platform lister and font folders), for tests.- #[cfg(test)]- pub(crate) fn for_system_scan_test() -> Self {- Self::new(FontPaths::System)- }-- fn new(font_paths: FontPaths) -> Self {- let mut faces = Vec::new();- // Bundled fonts first, then explicitly supplied craft-fonts faces: Japanese (Mincho- // first), Arabic, Thai, then remaining faces in manifest order. Existing script fallback- // priorities stay ahead of the additional families users can now pick by name.- let craft = crate::craft_fonts::document_fonts().into_iter().map(|f| f.bytes);- for data in BUNDLED.iter().copied().chain(craft) {- for (i, spec) in enumerate_faces(data) {- if let Some(f) = make_face(FontBytes::Static(data), i, spec, None) {- faces.push(Arc::new(f));- }- }- }- Self {- faces: RwLock::new(faces),- outlines: Mutex::new(HashMap::new()),- images: Mutex::new(GlyphCache::default()),- colours: Mutex::new(GlyphCache::default()),- catalog: RwLock::new(Catalog::new()),- postscript: RwLock::new(PostScriptNames::new()),- font_paths,- aliases: RwLock::new(HashMap::new()),- canonical_cache: Mutex::new(CanonicalNames::new()),- #[cfg(not(target_arch = "wasm32"))]- cataloged: std::sync::OnceLock::new(),- #[cfg(not(target_arch = "wasm32"))]- version_scanned: RwLock::new(std::collections::HashSet::new()),- family_cache: Mutex::new(None),- menu_cache: Mutex::new(None),- generation: AtomicU64::new(0),- #[cfg(not(target_arch = "wasm32"))]- sys: Mutex::new(SysFallback { enabled: true, ..Default::default() }),- #[cfg(not(target_arch = "wasm32"))]- stamp: Mutex::new(None),- instances: Mutex::new(Instances::default()),- }- }-- /// Enable or disable the lazy system-font fallback for characters the loaded fonts lack- /// (native only; on by default).- pub fn set_system_fallback(&self, on: bool) {- #[cfg(not(target_arch = "wasm32"))]- {- self.sys.lock().unwrap_or_else(|e| e.into_inner()).enabled = on;- }- #[cfg(target_arch = "wasm32")]- let _ = on;- }-- /// 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(FontPaths::System))- }-- fn read_faces(&self) -> std::sync::RwLockReadGuard<'_, Vec<Arc<FontFace>>> {- self.faces.read().unwrap_or_else(|e| e.into_inner())- }-- fn read_catalog(&self) -> std::sync::RwLockReadGuard<'_, Catalog> {- self.ensure_catalog();- self.catalog.read().unwrap_or_else(|e| e.into_inner())- }-- /// Fonts were added or the catalog changed: cached family lists and [`FontDb::canonical`]'s- /// answers are stale.- fn changed(&self) {- *self.family_cache.lock().unwrap_or_else(|e| e.into_inner()) = None;- self.canonical_cache.lock().unwrap_or_else(|e| e.into_inner()).clear();- self.generation.fetch_add(1, Ordering::Relaxed);- }-- /// A number that changes whenever the available fonts do (fonts added, system fonts- /// rescanned): lists built from [`FontDb::family_list`] are current while it doesn't.- pub fn generation(&self) -> u64 {- self.generation.load(Ordering::Relaxed)- }-- /// Family names available (loaded plus installed system fonts), sorted and deduplicated.- pub fn families(&self) -> Vec<String> {- self.family_list().to_vec()- }-- /// [`FontDb::families`], shared: cheap to call every frame.- pub fn family_list(&self) -> Arc<[String]> {- let catalog = self.read_catalog();- let mut cache = self.family_cache.lock().unwrap_or_else(|e| e.into_inner());- if let Some(list) = cache.as_ref() {- return list.clone();- }- let mut v: Vec<String> = self.read_faces().iter().map(|f| f.family.clone()).collect();- v.extend(catalog.values().map(|c| c.name.clone()));- v.sort_by_key(|a| a.to_lowercase());- v.dedup_by(|a, b| a.eq_ignore_ascii_case(b));- let list: Arc<[String]> = v.into();- *cache = Some(list.clone());- list- }-- /// The families font menus and lists show: [`FontDb::family_list`] without the system's hidden- /// families, whose names start with "." (macOS keeps ".SF NS", ".LastResort" and others for its- /// own interface, and Mac apps don't list them). Those still resolve by name, for documents and- /// fallbacks that name them. Cheap to call every frame.- pub fn menu_family_list(&self) -> Arc<[String]> {- let all = self.family_list();- let mut cache = self.menu_cache.lock().unwrap_or_else(|e| e.into_inner());- if let Some((from, list)) = cache.as_ref()- && Arc::ptr_eq(from, &all)- {- return list.clone();- }- let list: Arc<[String]> = all.iter().filter(|f| !f.starts_with('.')).cloned().collect();- *cache = Some((all, list.clone()));- list- }-- /// How a font menu labels `family`: the English name when `english` is on (Preferences › Type ›- /// Show Font Names in English, the default), else the font's native-language name when it has- /// one. The document and commands still use the English family ([`Self::canonical`]).- pub fn family_display_name(&self, family: &str, english: bool) -> String {- let (family, _) = self.canonical(family, "");- if english {- return family;- }- if let Some(native) = self.read_faces().iter().find(|f| f.family.eq_ignore_ascii_case(&family)).and_then(|f| f.native_family.clone()) {- return native;- }- if let Some(native) = self.read_catalog().get(&family.to_ascii_lowercase()).and_then(|c| c.native.clone()) {- return native;- }- family- }-- /// Style names available for `family`: upright styles by weight, then italics.- pub fn styles(&self, family: &str) -> Vec<String> {- let (family, _) = self.canonical(family, "");- let family = family.as_str();- let mut v: Vec<(bool, f32, String)> = Vec::new();- // Each style once, as its first loaded version describes it (versions can disagree on weight).- for f in self.read_faces().iter().filter(|f| f.family.eq_ignore_ascii_case(family)) {- if !v.iter().any(|(_, _, s)| s.eq_ignore_ascii_case(&f.style)) {- v.push((f.italic, f.weight, f.style.clone()));- }- }- if let Some(c) = self.read_catalog().get(&family.to_ascii_lowercase()) {- for cf in &c.faces {- if !v.iter().any(|(_, _, s)| s.eq_ignore_ascii_case(&cf.style)) {- v.push((cf.italic, cf.weight, cf.style.clone()));- }- }- }- v.sort_by(|a, b| a.0.cmp(&b.0).then(a.1.total_cmp(&b.1)).then(a.2.cmp(&b.2)));- v.dedup_by(|a, b| a.2 == b.2);- v.into_iter().map(|t| t.2).collect()- }-- /// Add a user font (TTF/OTF/TTC bytes). Returns the number of faces added (0 if unparseable or- /// every face was already present).- pub fn add_font(&self, bytes: Vec<u8>) -> usize {- self.add_font_from(bytes, None)- }-- /// [`FontDb::add_font`] for the bytes of the file at `path` (when known).- fn add_font_from(&self, bytes: Vec<u8>, path: Option<&Path>) -> usize {- self.add_fonts([(bytes, path.map(Path::to_path_buf))])- }-- /// Add the faces of `files` (each file's bytes, and the file when known) all at once: a lookup- /// on another thread finds all of them or none, never a family with only some of its styles- /// loaded, whose nearest style it would take instead (Arial Bold Italic, the first of Arial's- /// files, for upright Regular text). Returns the number of faces added.- fn add_fonts(&self, files: impl IntoIterator<Item = (Vec<u8>, Option<PathBuf>)>) -> usize {- // Another version of a family and style is kept: a document may name it (the first one- // loaded stays the one the family and style alone resolve to).- let same = |f: &FontFace, family: &str, style: &str, version: &str| {- f.family.eq_ignore_ascii_case(family) && f.style.eq_ignore_ascii_case(style) && f.version == version- };- let mut made: Vec<FontFace> = Vec::new();- for (bytes, path) in files {- let data = Arc::new(bytes);- for (i, spec) in enumerate_faces(&data) {- let version = skrifa::FontRef::from_index(&data, i).ok().and_then(|f| name(&f, &[StringId::VERSION_STRING])).unwrap_or_default();- let present = |f: &FontFace| same(f, &spec.family, &spec.style, &version);- if self.read_faces().iter().any(|f| present(f)) || made.iter().any(present) {- continue;- }- if let Some(f) = make_face(FontBytes::Owned(data.clone()), i, spec, path.clone()) {- made.push(f);- }- }- }- let mut faces = self.faces.write().unwrap_or_else(std::sync::PoisonError::into_inner);- let before = faces.len();- for f in made {- // Another thread may have added the same face meanwhile.- if !faces.iter().any(|g| same(g, &f.family, &f.style, &f.version)) {- faces.push(Arc::new(f));- }- }- let added = faces.len() - before;- drop(faces);- #[cfg(test)]- faces_published();- if added > 0 {- self.changed();- }- added- }-- /// Catalog the installed fonts unless that has been done: the first caller scans the font- /// folders, any other waits for that scan to finish. A no-op on wasm.- fn ensure_catalog(&self) {- #[cfg(not(target_arch = "wasm32"))]- 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. Faces- /// loaded from files the scan no longer finds are dropped. 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())- }-- /// Whether fonts were installed or removed since the last scan (a font folder or font file it- /// read changed, or a new one is to be read), for [`FontDb::load_system_fonts`] to catalog- /// them. Costs a look at each folder the scan read, not a scan. `false` before the first scan- /// and on wasm.- pub fn installed_fonts_changed(&self) -> bool {- #[cfg(not(target_arch = "wasm32"))]- {- let paths = self.font_paths.get();- let stamp = self.stamp.lock().unwrap_or_else(|e| e.into_inner());- stamp.as_ref().is_some_and(|s| s.paths != paths || s.modified.iter().any(|(p, t)| modified(p) != *t))- }- #[cfg(target_arch = "wasm32")]- false- }-- #[cfg(not(target_arch = "wasm32"))]- fn scan_font_dirs(&self) -> usize {- // Files may have been installed since: other versions are looked for again.- self.version_scanned.write().unwrap_or_else(|e| e.into_inner()).clear();- let mut catalog = Catalog::new();- let mut aliases: HashMap<String, Vec<Alias>> = HashMap::new();- let mut postscript = PostScriptNames::new();- let mut n = 0;- let paths = self.font_paths.get();- let mut modified_at = Vec::new();- // Each file with whether it was named by itself rather than found in a folder.- let mut files = Vec::new();- let mut stack = paths.clone();- // Each folder once, however links lead back to it.- let mut visited = std::collections::HashSet::new();- let confined = confined_font_dirs();- let inside_confined = |p: &Path| std::fs::canonicalize(p).is_ok_and(|r| confined.iter().any(|root| r.starts_with(root)));- while let Some(d) = stack.pop() {- if !visited.insert(std::fs::canonicalize(&d).unwrap_or_else(|_| d.clone())) {- continue;- }- // In a confined folder, a link is followed only to somewhere inside one.- let in_confined = !confined.is_empty() && inside_confined(&d);- // Before listing it: a font installed meanwhile changes it after this.- modified_at.push((d.clone(), modified(&d)));- // Not a folder: a font file named by itself (or nothing, yet).- let Ok(rd) = std::fs::read_dir(&d) else {- files.push((d, true));- continue;- };- for e in rd.flatten() {- let p = e.path();- if in_confined && e.file_type().is_ok_and(|t| t.is_symlink()) && !inside_confined(&p) {- continue;- }- if p.is_dir() {- stack.push(p);- } else {- files.push((p, false));- }- }- }- for (p, named) in files {- // A file named by itself is a font whatever its name (font services keep fonts in- // files without an extension); one of a folder's only with a font's extension, or- // a suitcase font (whose fonts are in its resource fork, whatever its name).- if !named && !is_font_file(&p) && !crate::suitcase::is_suitcase(&p) {- continue;- }- for FaceStyle { family, native_family, style, keys, weight, italic, traits, .. } in file_face_names(&p) {- for (k, a) in Alias::of(&family, &style, &keys) {- aliases.entry(k).or_default().push(a);- }- // `keys.postscript` is normalized ([`norm`]), as `by_postscript_name` looks it up.- for ps in &keys.postscript {- postscript.insert(ps.clone(), (family.clone(), style.clone()));- }- let entry = catalog.entry(family.to_ascii_lowercase()).or_default();- let kind = entry.traits.get_or_insert(traits);- kind.variable |= traits.variable;- if entry.name.is_empty() {- entry.name = family;- }- if entry.native.is_none() {- entry.native = native_family;- }- let (weight, italic) = (weight.unwrap_or_else(|| style_weight(&style)), italic || style_italic(&style));- entry.faces.push(CatalogFace { style, path: p.clone(), weight, italic });- n += 1;- }- }- log::debug!("cataloged {n} system font faces");- let installed: std::collections::HashSet<PathBuf> = catalog.values().flat_map(|c| c.faces.iter().map(|cf| cf.path.clone())).collect();- *self.stamp.lock().unwrap_or_else(|e| e.into_inner()) = Some(ScanStamp { paths, modified: modified_at });- *self.catalog.write().unwrap_or_else(|e| e.into_inner()) = catalog;- *self.aliases.write().unwrap_or_else(|e| e.into_inner()) = aliases;- *self.postscript.write().unwrap_or_else(|e| e.into_inner()) = postscript;- // Faces loaded from a file this scan did not catalog (the font was removed, or its folder- // is no longer read) are dropped with their outlines. A family with no face left and no- // cataloged file leaves the lists, and type set in it resolves to the fallback font. A face- // without a file (bundled, or added as bytes) stays.- let mut dropped = std::collections::HashSet::new();- self.faces.write().unwrap_or_else(|e| e.into_inner()).retain(|f| {- let keep = f.path.as_ref().is_none_or(|p| installed.contains(p));- if !keep {- dropped.insert(f.id);- }- keep- });- if !dropped.is_empty() {- log::debug!("dropped {} font faces whose files are no longer installed", dropped.len());- self.outlines.lock().unwrap_or_else(|e| e.into_inner()).retain(|(id, _), _| !dropped.contains(id));- }- // A font installed since may cover the characters no font did: they are looked for again.- {- let mut sys = self.sys.lock().unwrap_or_else(|e| e.into_inner());- sys.scans = sys.scans.wrapping_add(1);- sys.misses.clear();- }- self.changed();- n- }-- /// The family's own name and the style for a name given in a document: any of a family's- /// names (`ヒラギノ角ゴシック` is Hiragino Sans), a legacy family name (`Hiragino Sans W6` with its- /// legacy style names the W6 face), a full name (name ID 4) or a PostScript name- /// (`HiraginoSans-W6`, as PDF and `.ai` files name fonts). Case and anything but letters and- /// digits are ignored. An unknown name is returned unchanged.- pub fn canonical(&self, family: &str, style: &str) -> (String, String) {- if self.is_loaded(family) || self.read_catalog().contains_key(&family.to_ascii_lowercase()) {- return (family.to_string(), style.to_string());- }- // The lock is held until the answer is kept, and [`FontDb::changed`] waits for it: an- // answer found from the fonts before a change is cleared by that change.- let mut cache = self.canonical_cache.lock().unwrap_or_else(|e| e.into_inner());- let key = (family.to_string(), style.to_string());- if let Some(answer) = cache.get(&key) {- return answer.clone();- }- let answer = self.canonical_alias(family, style);- if cache.len() >= CANONICAL_CACHE_MAX {- cache.clear();- }- cache.insert(key, answer.clone());- answer- }-- /// Finds [`FontDb::canonical`]'s answer for a name that is neither a loaded nor an installed- /// family among the loaded faces' and the installed fonts' other names.- fn canonical_alias(&self, family: &str, style: &str) -> (String, String) {- let key = norm(family);- let mut found: Vec<Alias> =- self.read_faces().iter().flat_map(|f| Alias::of(&f.family, &f.style, &f.keys)).filter(|(k, _)| *k == key).map(|(_, a)| a).collect();- if let Some(v) = self.aliases.read().unwrap_or_else(|e| e.into_inner()).get(&key) {- found.extend(v.iter().cloned());- }- let ns = norm(style);- // A family and style split from a PostScript name by an importer that didn't have the font- // (`Honoka-Mincho` → Honoka, Mincho): once it is installed, the face of that PostScript- // name, which is its own family and style (ほのか明朝, Regular).- if found.is_empty() && !ns.is_empty() {- let joined = format!("{key}{ns}");- let face = |a: &Alias| a.paired.is_none() && a.style.is_some();- let ps =- self.read_faces().iter().flat_map(|f| Alias::of(&f.family, &f.style, &f.keys)).find(|(k, a)| *k == joined && face(a)).map(|(_, a)| a);- let ps = ps.or_else(|| {- self.aliases.read().unwrap_or_else(std::sync::PoisonError::into_inner).get(&joined).and_then(|v| v.iter().find(|a| face(a)).cloned())- });- if let Some(a) = ps {- return (a.family, a.style.unwrap_or_else(|| style.to_string()));- }- }- // A family name keeps the style asked for; a legacy pair names its face; a full or- // PostScript name its face whatever style is asked for.- if let Some(a) = found.iter().find(|a| a.style.is_none()) {- return (a.family.clone(), style.to_string());- }- if let Some(a) = found.iter().find(|a| a.paired.as_ref().is_some_and(|p| *p == ns) || a.paired.is_none()) {- return (a.family.clone(), a.style.clone().unwrap_or_else(|| style.to_string()));- }- match found.first() {- Some(a) => (a.family.clone(), style.to_string()),- None => (family.to_string(), style.to_string()),- }- }-- /// The kind of `family` (whether it sets Japanese, its class), for font menu filters: from a- /// loaded face, else from the system font scan. Variable when any of its faces, loaded or- /// scanned, is: a family may install static files beside a variable one. Cheap: no font file- /// is read, and a loaded family doesn't start the scan.- pub fn family_traits(&self, family: &str) -> FontTraits {- let loaded = {- let faces = self.read_faces();- let mut of_family = faces.iter().filter(|f| f.family.eq_ignore_ascii_case(family));- of_family.next().map(|first| FontTraits { variable: first.traits.variable || of_family.any(|f| f.traits.variable), ..first.traits })- };- let scanned = |catalog: &Catalog| catalog.get(&family.to_ascii_lowercase()).and_then(|c| c.traits);- match loaded {- None => scanned(&self.read_catalog()).unwrap_or_default(),- Some(traits) if traits.variable => traits,- Some(traits) => {- let variable = scanned(&self.catalog.read().unwrap_or_else(std::sync::PoisonError::into_inner)).is_some_and(|t| t.variable);- FontTraits { variable, ..traits }- }- }- }-- /// [`face`](Self::face) by any of the family's names ([`canonical`](Self::canonical)), and how- /// it matched.- pub fn resolve(&self, family: &str, style: &str) -> Option<(Arc<FontFace>, FontMatch)> {- let (family, style) = self.canonical(family, style);- let f = self.face(&family, &style)?;- let m = if !f.family.eq_ignore_ascii_case(&family) {- FontMatch::Missing- } else if norm(&f.style) == norm(&style) || f.keys.styles.contains(&norm(&style)) {- FontMatch::Exact- } else {- FontMatch::Style- };- Some((f, m))- }-- /// The installed face whose PostScript name is `name` (`HiraginoSans-W3`; any case), loaded- /// from the system fonts if need be. `None` when no installed font has the name.- pub fn find_postscript(&self, name: &str) -> Option<Arc<FontFace>> {- let key = norm(name);- if key.is_empty() {- return None;- }- let loaded = |db: &FontDb| db.read_faces().iter().find(|f| f.keys.postscript.contains(&key)).cloned();- if let Some(f) = loaded(self) {- return Some(f);- }- self.ensure_catalog();- let face = self.aliases.read().unwrap_or_else(|e| e.into_inner()).get(&key).and_then(|v| {- v.iter().find(|a| a.paired.is_none() && a.style.is_some()).map(|a| (a.family.clone(), a.style.clone().unwrap_or_default()))- });- let (family, style) = face?;- self.face(&family, &style)?;- loaded(self)- }-- /// The (family, style) of the installed face whose PostScript name is `name` (ignoring ASCII- /// case). Documents name fonts this way, and a family can hold hyphens- /// ("Rounded-X-Mplus-1c-black" is Rounded-X M+ 1c, black), so the name can't be split.- pub fn by_postscript_name(&self, name: &str) -> Option<(String, String)> {- self.ensure_catalog();- self.postscript.read().unwrap_or_else(|e| e.into_inner()).get(&norm(name)).cloned()- }-- /// Load the files of the installed `family`, adding all their faces at once- /// ([`Self::add_fonts`]). Returns whether the family is loaded now: by this call, or by another- /// thread meanwhile.- #[cfg(not(target_arch = "wasm32"))]- fn load_cataloged(&self, family: &str) -> bool {- let mut paths: Vec<PathBuf> =- self.read_catalog().get(&family.to_ascii_lowercase()).map(|c| c.faces.iter().map(|cf| cf.path.clone()).collect()).unwrap_or_default();- paths.sort();- paths.dedup();- let files = paths.into_iter().flat_map(|p| font_files(&p).into_iter().map(move |data| (data, Some(p.clone()))));- self.add_fonts(files) > 0 || self.is_loaded(family)- }-- /// Resolve a family + style to a face, falling back to the closest style of the family, then to- /// Source Sans 3 Regular. Installed system fonts are found by name whatever ran before. `None`- /// only if no font at all is loaded (the bundled fonts failed to parse, or were left out with- /// the `bundled-fonts` feature and none was added), in which case text has no glyphs.- pub fn face(&self, family: &str, style: &str) -> Option<Arc<FontFace>> {- let (family, style) = self.canonical(family, style);- let (family, style) = (family.as_str(), style.as_str());- let found = self.find(family, style);- if found.as_ref().is_some_and(|f| norm(&f.style) == norm(style)) {- return found;- }- // The family, or this style of it, is installed but not loaded yet. Looked for again- // whether or not this call loaded it: another thread may have just done so (then this- // load adds nothing, but the face is there).- #[cfg(not(target_arch = "wasm32"))]- if found.is_none() || self.is_cataloged(family, style) {- self.load_cataloged(family);- if let Some(f) = self.find(family, style) {- return Some(f);- }- }- found- .or_else(|| self.find(FALLBACK_FAMILY, style))- .or_else(|| self.find(FALLBACK_FAMILY, "Regular"))- .or_else(|| self.read_faces().first().cloned())- }-- /// [`FontDb::face`] in version `version` of the family and style (a [`FontFace::version`]), when- /// that version is installed; otherwise (or without a version) the face [`FontDb::face`] gives.- pub fn face_version(&self, family: &str, style: &str, version: Option<&str>) -> Option<Arc<FontFace>> {- let face = self.face(family, style)?;- let Some(version) = version.filter(|v| *v != face.version) else { return Some(face) };- let same =- |f: &&Arc<FontFace>| f.family.eq_ignore_ascii_case(&face.family) && f.style.eq_ignore_ascii_case(&face.style) && f.version == version;- if let Some(f) = self.read_faces().iter().find(same) {- return Some(f.clone());- }- // Not loaded: the family's installed files may hold it (the catalog doesn't list versions).- self.load_family_files(&face.family);- let found = self.read_faces().iter().find(same).cloned();- Some(found.unwrap_or(face))- }-- /// Every installed version of `face`'s family and style, `face` itself first.- pub fn versions(&self, face: &Arc<FontFace>) -> Vec<Arc<FontFace>> {- self.load_family_files(&face.family);- let mut out = vec![face.clone()];- out.extend(- self.read_faces()- .iter()- .filter(|f| f.family.eq_ignore_ascii_case(&face.family) && f.style.eq_ignore_ascii_case(&face.style) && f.id != face.id)- .cloned(),- );- out- }-- /// Load the installed files of `family` once (other versions of faces already loaded from- /// elsewhere); a no-op on wasm, where no fonts are installed.- fn load_family_files(&self, family: &str) {- #[cfg(not(target_arch = "wasm32"))]- {- let key = family.to_ascii_lowercase();- if self.version_scanned.write().unwrap_or_else(|e| e.into_inner()).insert(key) {- self.load_cataloged(family);- }- }- #[cfg(target_arch = "wasm32")]- let _ = family;- }-- /// Is `style` of `family` among the installed fonts?- #[cfg(not(target_arch = "wasm32"))]- fn is_cataloged(&self, family: &str, style: &str) -> bool {- let ns = norm(style);- self.read_catalog().get(&family.to_ascii_lowercase()).is_some_and(|c| c.faces.iter().any(|cf| norm(&cf.style) == ns))- }-- /// The loaded face with [`FontFace::id`] `id` (the face a laid-out glyph came from), an- /// instanced face ([`Self::instance`]) included.- pub fn face_by_id(&self, id: u32) -> Option<Arc<FontFace>> {- let loaded = self.read_faces().iter().find(|f| f.id == id).cloned();- loaded.or_else(|| self.instance_by_id(id))- }-- /// The face of character style `st`: [`Self::face_version`] of its font, instanced at its- /// Variable Font settings ([`Self::instance`]).- pub fn style_face(&self, st: &vectorcraft_doc::CharStyle) -> Option<Arc<FontFace>> {- let face = self.face_version(&st.font_family, &st.font_style, st.font_version.as_deref())?;- Some(self.instance(&face, &st.font_axes))- }-- /// `face` with the axis settings `axes` (by tag, in the axes' own units) in place of its own,- /// each clamped to its axis's range: its outlines, metrics and advances taken there, and its- /// file embedded instanced there. Tags the font has no axis for are left out. `face` itself- /// when that changes no setting, and for a static face.- pub fn instance(&self, face: &Arc<FontFace>, axes: &std::collections::BTreeMap<String, f64>) -> Arc<FontFace> {- if axes.is_empty() {- return face.clone();- }- let font_axes = face.axes();- let mut variations = face.variations.clone();- for (tag, value) in axes {- let Some(axis) = font_axes.iter().find(|a| a.tag.as_slice() == tag.as_bytes()) else { continue };- if !value.is_finite() {- continue;- }- let v = (*value as f32).clamp(axis.min.min(axis.max), axis.max.max(axis.min));- match variations.iter_mut().find(|(t, _)| *t == axis.tag) {- Some(setting) => setting.1 = v,- None => variations.push((axis.tag, v)),- }- }- // Every axis at the setting it has in `face`: nothing to instance.- let at = |vs: &[Variation], a: &VariationAxis| vs.iter().find(|(t, _)| *t == a.tag).map_or(a.default, |(_, v)| *v);- if font_axes.iter().all(|a| at(&variations, a) == at(&face.variations, a)) {- return face.clone();- }- variations.sort_by_key(|(t, _)| *t);- let key = (face.id, variations.iter().map(|(t, v)| (*t, v.to_bits())).collect::<Vec<_>>());- let mut inst = self.instances.lock().unwrap_or_else(|e| e.into_inner());- let id = match inst.ids.get(&key) {- Some(id) => *id,- None => {- let id = NEXT_ID.fetch_add(1, Ordering::Relaxed);- inst.ids.insert(key, id);- inst.recipes.insert(id, (face.id, variations.clone()));- id- }- };- if let Some(f) = inst.live.get(&id) {- return f.clone();- }- let Some(built) = instanced(face, variations, id) else { return face.clone() };- let built = Arc::new(built);- if inst.live.len() >= MAX_LIVE_INSTANCES {- inst.live.clear();- }- inst.live.insert(id, built.clone());- built- }-- /// The instanced face with id `id` ([`Self::instance`]), built again when it was dropped.- fn instance_by_id(&self, id: u32) -> Option<Arc<FontFace>> {- let (base, variations) = {- let inst = self.instances.lock().unwrap_or_else(|e| e.into_inner());- if let Some(f) = inst.live.get(&id) {- return Some(f.clone());- }- inst.recipes.get(&id).cloned()?- };- let base = self.read_faces().iter().find(|f| f.id == base).cloned()?;- let built = Arc::new(instanced(&base, variations, id)?);- let mut inst = self.instances.lock().unwrap_or_else(|e| e.into_inner());- if inst.live.len() >= MAX_LIVE_INSTANCES {- inst.live.clear();- }- Some(inst.live.entry(id).or_insert(built).clone())- }-- /// The available family `name` names, ignoring case and anything but letters and digits, as- /// PostScript names write families ("MicrosoftYaHei" is Microsoft YaHei).- pub fn find_family(&self, name: &str) -> Option<String> {- self.family_list().iter().find(|f| norm_chars(f).eq(norm_chars(name))).cloned()- }-- /// Is `family` available (loaded, or installed on the system)?- pub fn has_family(&self, family: &str) -> bool {- let (family, _) = self.canonical(family, "");- self.is_loaded(&family) || self.read_catalog().contains_key(&family.to_ascii_lowercase())- }-- pub(crate) fn is_loaded(&self, family: &str) -> bool {- self.read_faces().iter().any(|f| f.family.eq_ignore_ascii_case(family))- }-- pub(crate) fn find(&self, family: &str, style: &str) -> Option<Arc<FontFace>> {- let faces = self.read_faces();- let cands: Vec<&Arc<FontFace>> = faces.iter().filter(|f| f.family.eq_ignore_ascii_case(family)).collect();- if cands.is_empty() {- return None;- }- let ns = norm(style);- if let Some(f) = cands.iter().find(|f| norm(&f.style) == ns) {- return Some((*f).clone());- }- // Another of a face's style names: in another language, or a variable font's default- // instance's name.- if let Some(f) = cands.iter().find(|f| f.keys.styles.contains(&ns)) {- return Some((*f).clone());- }- let (tw, ti) = (style_weight(style), style_italic(style));- cands.iter().min_by(|a, b| style_distance(a, tw, ti).total_cmp(&style_distance(b, tw, ti))).map(|f| (*f).clone())- }-- /// [`fallback_for_style`](Self::fallback_for_style) for upright Regular text.- pub(crate) fn fallback_for(&self, c: char, exclude: u32) -> Option<Arc<FontFace>> {- self.fallback_for_style(c, exclude, 400.0, false)- }-- /// First family (fallback family first, then load order) with a face that covers `c`, in that- /// family's face nearest `weight` and `italic`; on native, system fonts are loaded lazily the- /// first time no loaded face covers a character (#2491).- pub(crate) fn fallback_for_style(&self, c: char, exclude: u32, weight: f32, italic: bool) -> Option<Arc<FontFace>> {- // Thai (Lao, Khmer, Myanmar) takes a font made for it, when one is installed, rather than- // whichever face covering it happened to load first (a display face, say).- let prefer = script_families(c);- if let Some(f) = self.family_fallback(c, exclude, prefer, weight, italic) {- return Some(f);- }- #[cfg(not(target_arch = "wasm32"))]- if self.load_families(c, prefer)- && let Some(f) = self.family_fallback(c, exclude, prefer, weight, italic)- {- return Some(f);- }- if let Some(f) = self.loaded_fallback(c, exclude, weight, italic) {- return Some(f);- }- #[cfg(not(target_arch = "wasm32"))]- self.system_fallback(c);- // Another lookup may have loaded the face while this one searched. Loading no new- // faces does not mean no face covers the character (as with `face`'s catalog lookup).- self.loaded_fallback(c, exclude, weight, italic)- }-- /// A face that covers `c`, for text drawn outside the canvas (the app's own UI): the loaded- /// fonts first, then (native) an installed one, loaded on demand. Characters no font covers- /// are remembered, so they are looked for once.- pub fn face_covering(&self, c: char) -> Option<Arc<FontFace>> {- self.fallback_for(c, 0)- }-- /// The loaded face of the first of `families` that covers `c`, nearest `weight` and `italic`.- fn family_fallback(&self, c: char, exclude: u32, families: &[&str], weight: f32, italic: bool) -> Option<Arc<FontFace>> {- let faces = self.read_faces();- families.iter().find_map(|fam| {- faces- .iter()- .filter(|f| f.id != exclude && f.family.eq_ignore_ascii_case(fam) && f.covers(c))- .min_by(|a, b| style_distance(a, weight, italic).total_cmp(&style_distance(b, weight, italic)))- .cloned()- })- }-- /// Load the first of the installed `families` not loaded yet that covers `c` (with system- /// fallback on). Returns whether one was loaded.- #[cfg(not(target_arch = "wasm32"))]- fn load_families(&self, c: char, families: &[&str]) -> bool {- if families.is_empty() || !self.sys.lock().unwrap_or_else(|e| e.into_inner()).enabled {- return false;- }- families.iter().any(|fam| !self.is_loaded(fam) && self.load_cataloged(fam) && self.family_fallback(c, 0, &[fam], 400.0, false).is_some())- }-- /// The first loaded family (the fallback family, then load order) with a face covering `c`,- /// and in it the face nearest `weight` and `italic`.- fn loaded_fallback(&self, c: char, exclude: u32, weight: f32, italic: bool) -> Option<Arc<FontFace>> {- let faces = self.read_faces();- let mut families: Vec<&str> = Vec::new();- for f in faces.iter().filter(|f| f.id != exclude && f.covers(c)) {- if !families.iter().any(|fam| fam.eq_ignore_ascii_case(&f.family)) {- families.push(&f.family);- }- }- // Stable: the fallback family first, the others in load order.- families.sort_by_key(|fam| !fam.eq_ignore_ascii_case(FALLBACK_FAMILY));- let fam = families.first()?;- faces- .iter()- .filter(|f| f.id != exclude && f.family.eq_ignore_ascii_case(fam) && f.covers(c))- .min_by(|a, b| style_distance(a, weight, italic).total_cmp(&style_distance(b, weight, italic)))- .cloned()- }-- /// Load a system font covering `c` (preferred fallback families first, then any cataloged- /// file under 40 MB). Returns true if one was loaded. Misses are remembered.- #[cfg(not(target_arch = "wasm32"))]- fn system_fallback(&self, c: char) -> bool {- if c.is_control() || c.is_whitespace() {- return false;- }- {- let sys = self.sys.lock().unwrap_or_else(|e| e.into_inner());- if !sys.enabled || sys.misses.contains(&c) {- return false;- }- }- // The first scan done before its count is read, so the first miss is remembered too.- self.ensure_catalog();- let scans = self.sys.lock().unwrap_or_else(|e| e.into_inner()).scans;- let covered = |db: &FontDb| db.read_faces().iter().any(|f| f.covers(c));- for fam in SYSTEM_FALLBACKS {- if !self.is_loaded(fam) && self.load_cataloged(fam) && covered(self) {- return true;- }- }- let mut paths: Vec<PathBuf> = self.read_catalog().values().flat_map(|c| c.faces.iter().map(|cf| cf.path.clone())).collect();- paths.sort();- paths.dedup();- for p in paths {- if std::fs::metadata(&p).map(|m| m.len() > 40 << 20).unwrap_or(true) {- continue;- }- for data in font_files(&p) {- let hit =- enumerate_faces(&data).iter().any(|(i, _)| skrifa::FontRef::from_index(&data, *i).is_ok_and(|f| f.charmap().map(c).is_some()));- if hit && self.add_font_from(data, Some(&p)) > 0 && covered(self) {- return true;- }- }- }- let mut sys = self.sys.lock().unwrap_or_else(|e| e.into_inner());- if sys.scans == scans {- sys.misses.insert(c);- }- false- }-- /// Glyph outline in font units, y-down (flipped), cached per (face, glyph).- pub fn outline(&self, face: &FontFace, gid: u32) -> Arc<BezPath> {- let key = (face.id, gid);- if let Some(p) = self.outlines.lock().unwrap_or_else(|e| e.into_inner()).get(&key) {- return p.clone();- }- let mut pen = FlipPen(BezPath::new());- if let Some(f) = face.skrifa()- && let Some(g) = f.outline_glyphs().get(GlyphId::new(gid))- {- let _ = g.draw(DrawSettings::unhinted(Size::unscaled(), face.location()), &mut pen);- }- let p = Arc::new(pen.0);- let mut cache = self.outlines.lock().unwrap_or_else(|e| e.into_inner());- if cache.len() >= OUTLINE_CACHE_MAX {- cache.clear();- }- cache.insert(key, p.clone());- p- }-- /// Glyph `gid`'s colour bitmap (`sbix`, `CBDT`) in `face`, cached per (face, glyph).- pub fn glyph_image(&self, face: &FontFace, gid: u32) -> Option<Arc<GlyphImage>> {- if !face.colour_bitmaps {- return None;- }- let key = (face.id, gid);- if let Some(i) = self.images.lock().unwrap_or_else(std::sync::PoisonError::into_inner).kept.get(&key) {- return i.clone();- }- let image = face.skrifa().and_then(|f| crate::bitmap::glyph_image(&f, face.upem, gid)).map(Arc::new);- self.images.lock().unwrap_or_else(std::sync::PoisonError::into_inner).keep(key, image.clone());- image- }-- /// Is glyph `gid` of face `face_id` drawn from its SVG document (it has one, and no COLR- /// layers, which come first)? Writers that draw a font's own glyphs can draw COLR and bitmap- /// glyphs, not always SVG ones.- pub fn is_svg_glyph(&self, face_id: u32, gid: u32) -> bool {- let Some(face) = self.face_by_id(face_id) else { return false };- face.skrifa().is_some_and(|f| svg_drawn(&face, &f, gid) && crate::svg_glyph::has_document(&f, gid))- }-- /// Glyph `gid`'s colour content in `face`, from its COLR layers or else its SVG document, in- /// the text's `foreground` (fill) and `stroke` colours where it uses them; cached per (face,- /// glyph), and per text colours for the glyphs that paint with them.- pub(crate) fn glyph_colour(&self, face: &FontFace, gid: u32, foreground: Color, stroke: Option<Color>) -> Option<ColourContent> {- if !face.colour_layers && !face.svg_glyphs {- return None;- }- let f = face.skrifa()?;- // COLR first; SVG for glyphs without COLR layers (those whose layers don't read keep their- // outlines, as in fonts without SVG).- let svg = svg_drawn(face, &f, gid);- // Kept without colours, or by the text's colours it uses: the fill, and for SVG art the- // stroke too.- let coloured = Some((foreground.key(), stroke.filter(|_| svg).map(|c| c.key())));- {- let cache = self.colours.lock().unwrap_or_else(std::sync::PoisonError::into_inner);- if let Some(c) = [None, coloured].iter().find_map(|k| cache.kept.get(&(face.id, gid, *k))) {- return c.clone();- }- }- let (content, used) = if svg {- let (art, used) = crate::svg_glyph::svg_glyph(&f, gid, face.upem, foreground, stroke);- (art.map(ColourContent::Art), used)- } else {- crate::colr::colour_glyph(&f, face.location(), face.upem, gid, foreground)- };- let key = (face.id, gid, if used { coloured } else { None });- self.colours.lock().unwrap_or_else(std::sync::PoisonError::into_inner).keep(key, content.clone());- content- }-}--/// Is glyph `gid` of `face` (as `font`) drawn from an SVG document, if it has one: the face has-/// SVG glyphs, and the glyph no COLR layers, which come first.-fn svg_drawn(face: &FontFace, font: &skrifa::FontRef<'_>, gid: u32) -> bool {- face.svg_glyphs && !crate::colr::has_colour_glyph(font, gid)-}--/// A pen drawing outlines y down, as text space has them.-pub(crate) struct FlipPen(pub(crate) BezPath);--impl OutlinePen for FlipPen {- fn move_to(&mut self, x: f32, y: f32) {- self.0.move_to((x as f64, -y as f64));- }- fn line_to(&mut self, x: f32, y: f32) {- self.0.line_to((x as f64, -y as f64));- }- fn quad_to(&mut self, cx0: f32, cy0: f32, x: f32, y: f32) {- self.0.quad_to((cx0 as f64, -cy0 as f64), (x as f64, -y as f64));- }- fn curve_to(&mut self, cx0: f32, cy0: f32, cx1: f32, cy1: f32, x: f32, y: f32) {- self.0.curve_to((cx0 as f64, -cy0 as f64), (cx1 as f64, -cy1 as f64), (x as f64, -y as f64));- }- fn close(&mut self) {- self.0.close_path();- }-}-#[cfg(test)]mod alias_tests {use super::*;diff --git a/crates/text/src/fontdb/build.rs b/crates/text/src/fontdb/build.rsnew file mode 100644index 000000000..a4745e56d--- /dev/null+++ b/crates/text/src/fontdb/build.rs@@ -0,0 +1,140 @@+use super::face::{FontBytes, FontFace, Variation};+use super::names::{name, norm};+use super::traits::FaceStyle;+use super::*;++/// `face` at the axis settings `variations` (user units), as face `id`: its names, kind, italic+/// and file, and its weight the `wght` setting when there is one.+pub(super) fn instanced(face: &FontFace, variations: Vec<Variation>, id: u32) -> Option<FontFace> {+ let weight = variations.iter().find(|(t, _)| t == b"wght").map_or(face.weight, |(_, v)| *v);+ let spec = FaceStyle {+ family: face.family.clone(),+ native_family: face.native_family.clone(),+ style: face.style.clone(),+ keys: face.keys.clone(),+ variations,+ weight: Some(weight),+ italic: face.italic,+ traits: face.traits,+ };+ let mut f = make_face(face.bytes.clone(), face.index, spec, face.path.clone())?;+ f.id = id;+ Some(f)+}++pub(super) fn make_face(bytes: FontBytes, index: u32, spec: FaceStyle, path: Option<std::path::PathBuf>) -> Option<FontFace> {+ let data: &[u8] = match &bytes {+ FontBytes::Static(b) => b,+ FontBytes::Owned(v) => v.as_slice(),+ };+ let f = skrifa::FontRef::from_index(data, index).ok()?;+ let FaceStyle { family, native_family, style, keys, variations, weight, italic, traits } = spec;+ let version = name(&f, &[StringId::VERSION_STRING]).unwrap_or_default();+ // A named instance: outlines, metrics and advances at its axis settings.+ let location = if variations.is_empty() { Location::default() } else { f.axes().location(variations.iter().map(|(t, v)| (Tag::new(t), *v))) };+ let m = f.metrics(Size::unscaled(), &location);+ let a = f.attributes();+ let hb = harfrust::FontRef::from_index(data, index).ok()?;+ let shaper = harfrust::ShaperData::new(&hb);+ let instance =+ (!variations.is_empty()).then(|| harfrust::ShaperInstance::from_variations(&hb, variations.iter().map(|(t, v)| (harfrust::Tag::new(t), *v))));+ let upem = m.units_per_em.max(1) as f64;+ let x_height = m.x_height.map(|v| v as f64).filter(|v| *v > 0.0).unwrap_or(m.ascent as f64 * 0.5);+ let decoration = |d: Option<skrifa::metrics::Decoration>, fallback: (f64, f64)| {+ d.map(|d| (f64::from(d.offset), f64::from(d.thickness))).filter(|(o, t)| o.is_finite() && *t > 0.0 && t.is_finite()).unwrap_or(fallback)+ };+ let underline = decoration(m.underline, (-0.075 * upem, 0.05 * upem));+ let strikeout = decoration(m.strikeout, (x_height * 0.5 + 0.025 * upem, 0.05 * upem));+ let colour_bitmaps = crate::bitmap::has_colour_bitmaps(&f);+ let colour_layers = crate::colr::has_colour_layers(&f);+ let svg_glyphs = crate::svg_glyph::has_svg_glyphs(&f);+ Some(FontFace {+ keys,+ traits,+ id: NEXT_ID.fetch_add(1, Ordering::Relaxed),+ family,+ native_family,+ style,+ version,+ weight: weight.unwrap_or(a.weight.value()),+ italic: italic || !matches!(a.style, skrifa::attribute::Style::Normal),+ variations,+ location,+ instance,+ upem,+ ascent: m.ascent as f64,+ descent: -(m.descent as f64),+ cap_height: m.cap_height.map(|v| v as f64).filter(|v| *v > 0.0).unwrap_or(m.ascent as f64 * 0.72),+ x_height,+ underline,+ strikeout,+ shaper,+ bytes,+ index,+ path,+ ideographic_centre: std::sync::OnceLock::new(),+ icf_margins: std::sync::OnceLock::new(),+ colour_bitmaps,+ colour_layers,+ svg_glyphs,+ })+}++/// An axis of a BASE table: its default baseline values for Han ideographs (`hani`), else kana+/// (`kana`), else its first script, by tag, in font units.+pub(super) fn base_values(axis: skrifa::raw::tables::base::Axis<'_>) -> Option<HashMap<[u8; 4], f64>> {+ let tags = axis.base_tag_list()?.ok()?;+ let list = axis.base_script_list().ok()?;+ let records = list.base_script_records();+ let record =+ [b"hani", b"kana"].into_iter().find_map(|t| records.iter().find(|r| r.base_script_tag() == Tag::new(t))).or_else(|| records.first())?;+ let values = record.base_script(list.offset_data()).ok()?.base_values()?.ok()?;+ let mut out = HashMap::new();+ for (tag, coord) in tags.baseline_tags().iter().zip(values.base_coords().iter()) {+ if let Ok(c) = coord {+ out.insert(tag.get().to_be_bytes(), f64::from(c.coordinate()));+ }+ }+ Some(out)+}++/// Weight implied by a style name (400 = regular). Japanese faces number their weights W0–W9+/// (Hiragino, Morisawa…), W6 weighing 600 as its weight class does (#2873).+pub fn style_weight(style: &str) -> f32 {+ let numbered = style.split(|c: char| !c.is_ascii_alphanumeric()).find_map(|part| match part.as_bytes() {+ [b'W' | b'w', d @ b'0'..=b'9'] => Some(f32::from(d - b'0') * 100.0),+ _ => None,+ });+ if let Some(w) = numbered {+ return w.max(100.0);+ }+ let s = norm(style);+ const TABLE: &[(&str, f32)] = &[+ ("extralight", 200.0),+ ("ultralight", 200.0),+ ("semibold", 600.0),+ ("demibold", 600.0),+ ("extrabold", 800.0),+ ("ultrabold", 800.0),+ ("hairline", 100.0),+ ("thin", 100.0),+ ("light", 300.0),+ ("medium", 500.0),+ ("bold", 700.0),+ ("black", 900.0),+ ("heavy", 900.0),+ ];+ TABLE.iter().find(|(k, _)| s.contains(k)).map(|(_, w)| *w).unwrap_or(400.0)+}++pub(super) fn style_italic(style: &str) -> bool {+ let s = norm(style);+ s.contains("italic") || s.contains("oblique") || s == "it"+}++/// How far `face` is from the style asked for: its weight difference, and a penalty for the wrong+/// slant. The penalty is less than the weight gap between Regular and Bold (and Bold and Black),+/// so Bold Italic asked of a family with Bold and Italic faces only gets the Bold (#2491).+pub(super) fn style_distance(face: &FontFace, weight: f32, italic: bool) -> f32 {+ (face.weight - weight).abs() + if face.italic != italic { 250.0 } else { 0.0 }+}diff --git a/crates/text/src/fontdb/cache.rs b/crates/text/src/fontdb/cache.rsnew file mode 100644index 000000000..e6d711075--- /dev/null+++ b/crates/text/src/fontdb/cache.rs@@ -0,0 +1,101 @@+use super::traits::FontTraits;+use super::*;++/// One installed family found by the system font scan: its name and the file of each style.+#[derive(Debug, Default)]+pub(super) struct CatalogFamily {+ pub(super) name: String,+ /// Non-English family name from the name table, when the scan found one.+ pub(super) native: Option<String>,+ pub(super) faces: Vec<CatalogFace>,+ /// The family's kind (from its first face found); variable when any face found is.+ pub(super) traits: Option<FontTraits>,+}++/// One style of an installed family: a face, or a named instance of a variable font.+#[derive(Debug)]+#[cfg_attr(target_arch = "wasm32", allow(dead_code))]+pub(super) struct CatalogFace {+ pub(super) style: String,+ pub(super) path: PathBuf,+ /// Weight and italic as the style lists them (by its name, or a named instance's axes).+ pub(super) weight: f32,+ pub(super) italic: bool,+}++/// The installed fonts by ASCII-lowercased family name (lookups ignore ASCII case, as+/// [`FontDb::face`] does). Always empty on wasm, which has no system fonts.+pub(super) type Catalog = HashMap<String, CatalogFamily>;++/// The installed faces' (family, style) by normalized PostScript name ([`norm`]).+pub(super) type PostScriptNames = HashMap<String, (String, String)>;++/// Maps the family and style [`FontDb::canonical`] was asked for to its answer, for names that+/// are neither a loaded nor an installed family.+pub(super) type CanonicalNames = HashMap<(String, String), (String, String)>;++/// [`FontDb::glyph_image`]'s answers by face and glyph.+pub(super) type GlyphImages = GlyphCache<(u32, u32), Arc<GlyphImage>>;++/// [`FontDb::glyph_colour`]'s answers by face and glyph, and the text's fill and stroke colours for+/// glyphs that paint with them.+pub(super) type GlyphColours = GlyphCache<(u32, u32, Option<TextColours>), ColourContent>;++/// The text's fill and stroke colours, as a cache key ([`Color::key`]).+pub(super) type TextColours = ([u32; 5], Option<[u32; 5]>);++/// What a glyph's colour content (an image, layers) takes of memory, in bytes.+pub(super) trait Weight {+ fn bytes(&self) -> usize;+}++impl Weight for Arc<GlyphImage> {+ fn bytes(&self) -> usize {+ self.blob.bytes.len()+ }+}++impl Weight for ColourContent {+ fn bytes(&self) -> usize {+ match self {+ ColourContent::Image(i) => i.bytes(),+ // Roughly what a path node with its outline and fill takes.+ ColourContent::Art(art) => {+ let mut nodes = 0;+ art.walk(&mut |_| nodes += 1);+ nodes * 512+ }+ }+ }+}++/// The colour content of glyphs ([`FontDb::glyph_image`], [`FontDb::glyph_colour`]) kept by+/// face, glyph and what else it depends on, and its bytes in all.+pub(super) struct GlyphCache<K, V> {+ pub(super) kept: HashMap<K, Option<V>>,+ pub(super) bytes: usize,+}++impl<K, V> Default for GlyphCache<K, V> {+ fn default() -> Self {+ Self { kept: HashMap::new(), bytes: 0 }+ }+}++impl<K: std::hash::Hash + Eq, V: Weight> GlyphCache<K, V> {+ /// Keeps `value` (or that there is none), first letting go of all it keeps when that would+ /// take more than [`IMAGE_CACHE_MAX`] glyphs or [`IMAGE_CACHE_BYTES`]. A glyph it keeps+ /// already, which another thread looked up meanwhile, stays as it is.+ pub(super) fn keep(&mut self, key: K, value: Option<V>) {+ if self.kept.contains_key(&key) {+ return;+ }+ let bytes = value.as_ref().map_or(0, Weight::bytes);+ if self.kept.len() >= IMAGE_CACHE_MAX || self.bytes.saturating_add(bytes) > IMAGE_CACHE_BYTES {+ self.kept.clear();+ self.bytes = 0;+ }+ self.bytes += bytes;+ self.kept.insert(key, value);+ }+}diff --git a/crates/text/src/fontdb/db.rs b/crates/text/src/fontdb/db.rsnew file mode 100644index 000000000..84b3e7e51--- /dev/null+++ b/crates/text/src/fontdb/db.rs@@ -0,0 +1,395 @@+use super::build::make_face;+#[cfg(not(target_arch = "wasm32"))]+use super::build::{style_italic, style_weight};+#[cfg(not(target_arch = "wasm32"))]+use super::cache::CatalogFace;+use super::cache::{CanonicalNames, Catalog, GlyphCache, PostScriptNames};+#[cfg(not(target_arch = "wasm32"))]+use super::dirs::confined_font_dirs;+use super::face::{BUNDLED, FontBytes, FontFace, Instances};+#[cfg(not(target_arch = "wasm32"))]+use super::names::SysFallback;+use super::names::name;+use super::scan::enumerate_faces;+#[cfg(not(target_arch = "wasm32"))]+use super::scan::{file_face_names, is_font_file};+#[cfg(test)]+use super::traits::faces_published;+#[cfg(not(target_arch = "wasm32"))]+use super::traits::{Alias, FaceStyle};+use super::*;++impl FontDb {+ /// A database holding the bundled fonts, whose system font scan reads `font_dirs` (folders,+ /// read with their subfolders, and font files).+ pub fn with_font_dirs(font_dirs: Vec<PathBuf>) -> Self {+ Self::new(FontPaths::Fixed(font_dirs))+ }++ /// Same scan paths as [`FontDb::global`] (platform lister and font folders), for tests.+ #[cfg(test)]+ pub(crate) fn for_system_scan_test() -> Self {+ Self::new(FontPaths::System)+ }++ fn new(font_paths: FontPaths) -> Self {+ let mut faces = Vec::new();+ // Bundled fonts first, then explicitly supplied craft-fonts faces: Japanese (Mincho+ // first), Arabic, Thai, then remaining faces in manifest order. Existing script fallback+ // priorities stay ahead of the additional families users can now pick by name.+ let craft = crate::craft_fonts::document_fonts().into_iter().map(|f| f.bytes);+ for data in BUNDLED.iter().copied().chain(craft) {+ for (i, spec) in enumerate_faces(data) {+ if let Some(f) = make_face(FontBytes::Static(data), i, spec, None) {+ faces.push(Arc::new(f));+ }+ }+ }+ Self {+ faces: RwLock::new(faces),+ outlines: Mutex::new(HashMap::new()),+ images: Mutex::new(GlyphCache::default()),+ colours: Mutex::new(GlyphCache::default()),+ catalog: RwLock::new(Catalog::new()),+ postscript: RwLock::new(PostScriptNames::new()),+ font_paths,+ aliases: RwLock::new(HashMap::new()),+ canonical_cache: Mutex::new(CanonicalNames::new()),+ #[cfg(not(target_arch = "wasm32"))]+ cataloged: std::sync::OnceLock::new(),+ #[cfg(not(target_arch = "wasm32"))]+ version_scanned: RwLock::new(std::collections::HashSet::new()),+ family_cache: Mutex::new(None),+ menu_cache: Mutex::new(None),+ generation: AtomicU64::new(0),+ #[cfg(not(target_arch = "wasm32"))]+ sys: Mutex::new(SysFallback { enabled: true, ..Default::default() }),+ #[cfg(not(target_arch = "wasm32"))]+ stamp: Mutex::new(None),+ instances: Mutex::new(Instances::default()),+ }+ }++ /// Enable or disable the lazy system-font fallback for characters the loaded fonts lack+ /// (native only; on by default).+ pub fn set_system_fallback(&self, on: bool) {+ #[cfg(not(target_arch = "wasm32"))]+ {+ self.sys.lock().unwrap_or_else(|e| e.into_inner()).enabled = on;+ }+ #[cfg(target_arch = "wasm32")]+ let _ = on;+ }++ /// 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(FontPaths::System))+ }++ pub(super) fn read_faces(&self) -> std::sync::RwLockReadGuard<'_, Vec<Arc<FontFace>>> {+ self.faces.read().unwrap_or_else(|e| e.into_inner())+ }++ pub(super) fn read_catalog(&self) -> std::sync::RwLockReadGuard<'_, Catalog> {+ self.ensure_catalog();+ self.catalog.read().unwrap_or_else(|e| e.into_inner())+ }++ /// Fonts were added or the catalog changed: cached family lists and [`FontDb::canonical`]'s+ /// answers are stale.+ pub(super) fn changed(&self) {+ *self.family_cache.lock().unwrap_or_else(|e| e.into_inner()) = None;+ self.canonical_cache.lock().unwrap_or_else(|e| e.into_inner()).clear();+ self.generation.fetch_add(1, Ordering::Relaxed);+ }++ /// A number that changes whenever the available fonts do (fonts added, system fonts+ /// rescanned): lists built from [`FontDb::family_list`] are current while it doesn't.+ pub fn generation(&self) -> u64 {+ self.generation.load(Ordering::Relaxed)+ }++ /// Family names available (loaded plus installed system fonts), sorted and deduplicated.+ pub fn families(&self) -> Vec<String> {+ self.family_list().to_vec()+ }++ /// [`FontDb::families`], shared: cheap to call every frame.+ pub fn family_list(&self) -> Arc<[String]> {+ let catalog = self.read_catalog();+ let mut cache = self.family_cache.lock().unwrap_or_else(|e| e.into_inner());+ if let Some(list) = cache.as_ref() {+ return list.clone();+ }+ let mut v: Vec<String> = self.read_faces().iter().map(|f| f.family.clone()).collect();+ v.extend(catalog.values().map(|c| c.name.clone()));+ v.sort_by_key(|a| a.to_lowercase());+ v.dedup_by(|a, b| a.eq_ignore_ascii_case(b));+ let list: Arc<[String]> = v.into();+ *cache = Some(list.clone());+ list+ }++ /// The families font menus and lists show: [`FontDb::family_list`] without the system's hidden+ /// families, whose names start with "." (macOS keeps ".SF NS", ".LastResort" and others for its+ /// own interface, and Mac apps don't list them). Those still resolve by name, for documents and+ /// fallbacks that name them. Cheap to call every frame.+ pub fn menu_family_list(&self) -> Arc<[String]> {+ let all = self.family_list();+ let mut cache = self.menu_cache.lock().unwrap_or_else(|e| e.into_inner());+ if let Some((from, list)) = cache.as_ref()+ && Arc::ptr_eq(from, &all)+ {+ return list.clone();+ }+ let list: Arc<[String]> = all.iter().filter(|f| !f.starts_with('.')).cloned().collect();+ *cache = Some((all, list.clone()));+ list+ }++ /// How a font menu labels `family`: the English name when `english` is on (Preferences › Type ›+ /// Show Font Names in English, the default), else the font's native-language name when it has+ /// one. The document and commands still use the English family ([`Self::canonical`]).+ pub fn family_display_name(&self, family: &str, english: bool) -> String {+ let (family, _) = self.canonical(family, "");+ if english {+ return family;+ }+ if let Some(native) = self.read_faces().iter().find(|f| f.family.eq_ignore_ascii_case(&family)).and_then(|f| f.native_family.clone()) {+ return native;+ }+ if let Some(native) = self.read_catalog().get(&family.to_ascii_lowercase()).and_then(|c| c.native.clone()) {+ return native;+ }+ family+ }++ /// Style names available for `family`: upright styles by weight, then italics.+ pub fn styles(&self, family: &str) -> Vec<String> {+ let (family, _) = self.canonical(family, "");+ let family = family.as_str();+ let mut v: Vec<(bool, f32, String)> = Vec::new();+ // Each style once, as its first loaded version describes it (versions can disagree on weight).+ for f in self.read_faces().iter().filter(|f| f.family.eq_ignore_ascii_case(family)) {+ if !v.iter().any(|(_, _, s)| s.eq_ignore_ascii_case(&f.style)) {+ v.push((f.italic, f.weight, f.style.clone()));+ }+ }+ if let Some(c) = self.read_catalog().get(&family.to_ascii_lowercase()) {+ for cf in &c.faces {+ if !v.iter().any(|(_, _, s)| s.eq_ignore_ascii_case(&cf.style)) {+ v.push((cf.italic, cf.weight, cf.style.clone()));+ }+ }+ }+ v.sort_by(|a, b| a.0.cmp(&b.0).then(a.1.total_cmp(&b.1)).then(a.2.cmp(&b.2)));+ v.dedup_by(|a, b| a.2 == b.2);+ v.into_iter().map(|t| t.2).collect()+ }++ /// Add a user font (TTF/OTF/TTC bytes). Returns the number of faces added (0 if unparseable or+ /// every face was already present).+ pub fn add_font(&self, bytes: Vec<u8>) -> usize {+ self.add_font_from(bytes, None)+ }++ /// [`FontDb::add_font`] for the bytes of the file at `path` (when known).+ pub(super) fn add_font_from(&self, bytes: Vec<u8>, path: Option<&Path>) -> usize {+ self.add_fonts([(bytes, path.map(Path::to_path_buf))])+ }++ /// Add the faces of `files` (each file's bytes, and the file when known) all at once: a lookup+ /// on another thread finds all of them or none, never a family with only some of its styles+ /// loaded, whose nearest style it would take instead (Arial Bold Italic, the first of Arial's+ /// files, for upright Regular text). Returns the number of faces added.+ pub(super) fn add_fonts(&self, files: impl IntoIterator<Item = (Vec<u8>, Option<PathBuf>)>) -> usize {+ // Another version of a family and style is kept: a document may name it (the first one+ // loaded stays the one the family and style alone resolve to).+ let same = |f: &FontFace, family: &str, style: &str, version: &str| {+ f.family.eq_ignore_ascii_case(family) && f.style.eq_ignore_ascii_case(style) && f.version == version+ };+ let mut made: Vec<FontFace> = Vec::new();+ for (bytes, path) in files {+ let data = Arc::new(bytes);+ for (i, spec) in enumerate_faces(&data) {+ let version = skrifa::FontRef::from_index(&data, i).ok().and_then(|f| name(&f, &[StringId::VERSION_STRING])).unwrap_or_default();+ let present = |f: &FontFace| same(f, &spec.family, &spec.style, &version);+ if self.read_faces().iter().any(|f| present(f)) || made.iter().any(present) {+ continue;+ }+ if let Some(f) = make_face(FontBytes::Owned(data.clone()), i, spec, path.clone()) {+ made.push(f);+ }+ }+ }+ let mut faces = self.faces.write().unwrap_or_else(std::sync::PoisonError::into_inner);+ let before = faces.len();+ for f in made {+ // Another thread may have added the same face meanwhile.+ if !faces.iter().any(|g| same(g, &f.family, &f.style, &f.version)) {+ faces.push(Arc::new(f));+ }+ }+ let added = faces.len() - before;+ drop(faces);+ #[cfg(test)]+ faces_published();+ if added > 0 {+ self.changed();+ }+ added+ }++ /// Catalog the installed fonts unless that has been done: the first caller scans the font+ /// folders, any other waits for that scan to finish. A no-op on wasm.+ pub(super) fn ensure_catalog(&self) {+ #[cfg(not(target_arch = "wasm32"))]+ 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. Faces+ /// loaded from files the scan no longer finds are dropped. 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())+ }++ /// Whether fonts were installed or removed since the last scan (a font folder or font file it+ /// read changed, or a new one is to be read), for [`FontDb::load_system_fonts`] to catalog+ /// them. Costs a look at each folder the scan read, not a scan. `false` before the first scan+ /// and on wasm.+ pub fn installed_fonts_changed(&self) -> bool {+ #[cfg(not(target_arch = "wasm32"))]+ {+ let paths = self.font_paths.get();+ let stamp = self.stamp.lock().unwrap_or_else(|e| e.into_inner());+ stamp.as_ref().is_some_and(|s| s.paths != paths || s.modified.iter().any(|(p, t)| modified(p) != *t))+ }+ #[cfg(target_arch = "wasm32")]+ false+ }++ #[cfg(not(target_arch = "wasm32"))]+ fn scan_font_dirs(&self) -> usize {+ // Files may have been installed since: other versions are looked for again.+ self.version_scanned.write().unwrap_or_else(|e| e.into_inner()).clear();+ let mut catalog = Catalog::new();+ let mut aliases: HashMap<String, Vec<Alias>> = HashMap::new();+ let mut postscript = PostScriptNames::new();+ let mut n = 0;+ let paths = self.font_paths.get();+ let mut modified_at = Vec::new();+ // Each file with whether it was named by itself rather than found in a folder.+ let mut files = Vec::new();+ let mut stack = paths.clone();+ // Each folder once, however links lead back to it.+ let mut visited = std::collections::HashSet::new();+ let confined = confined_font_dirs();+ let inside_confined = |p: &Path| std::fs::canonicalize(p).is_ok_and(|r| confined.iter().any(|root| r.starts_with(root)));+ while let Some(d) = stack.pop() {+ if !visited.insert(std::fs::canonicalize(&d).unwrap_or_else(|_| d.clone())) {+ continue;+ }+ // In a confined folder, a link is followed only to somewhere inside one.+ let in_confined = !confined.is_empty() && inside_confined(&d);+ // Before listing it: a font installed meanwhile changes it after this.+ modified_at.push((d.clone(), modified(&d)));+ // Not a folder: a font file named by itself (or nothing, yet).+ let Ok(rd) = std::fs::read_dir(&d) else {+ files.push((d, true));+ continue;+ };+ for e in rd.flatten() {+ let p = e.path();+ if in_confined && e.file_type().is_ok_and(|t| t.is_symlink()) && !inside_confined(&p) {+ continue;+ }+ if p.is_dir() {+ stack.push(p);+ } else {+ files.push((p, false));+ }+ }+ }+ for (p, named) in files {+ // A file named by itself is a font whatever its name (font services keep fonts in+ // files without an extension); one of a folder's only with a font's extension, or+ // a suitcase font (whose fonts are in its resource fork, whatever its name).+ if !named && !is_font_file(&p) && !crate::suitcase::is_suitcase(&p) {+ continue;+ }+ for FaceStyle { family, native_family, style, keys, weight, italic, traits, .. } in file_face_names(&p) {+ for (k, a) in Alias::of(&family, &style, &keys) {+ aliases.entry(k).or_default().push(a);+ }+ // `keys.postscript` is normalized ([`norm`]), as `by_postscript_name` looks it up.+ for ps in &keys.postscript {+ postscript.insert(ps.clone(), (family.clone(), style.clone()));+ }+ let entry = catalog.entry(family.to_ascii_lowercase()).or_default();+ let kind = entry.traits.get_or_insert(traits);+ kind.variable |= traits.variable;+ if entry.name.is_empty() {+ entry.name = family;+ }+ if entry.native.is_none() {+ entry.native = native_family;+ }+ let (weight, italic) = (weight.unwrap_or_else(|| style_weight(&style)), italic || style_italic(&style));+ entry.faces.push(CatalogFace { style, path: p.clone(), weight, italic });+ n += 1;+ }+ }+ log::debug!("cataloged {n} system font faces");+ let installed: std::collections::HashSet<PathBuf> = catalog.values().flat_map(|c| c.faces.iter().map(|cf| cf.path.clone())).collect();+ *self.stamp.lock().unwrap_or_else(|e| e.into_inner()) = Some(ScanStamp { paths, modified: modified_at });+ *self.catalog.write().unwrap_or_else(|e| e.into_inner()) = catalog;+ *self.aliases.write().unwrap_or_else(|e| e.into_inner()) = aliases;+ *self.postscript.write().unwrap_or_else(|e| e.into_inner()) = postscript;+ // Faces loaded from a file this scan did not catalog (the font was removed, or its folder+ // is no longer read) are dropped with their outlines. A family with no face left and no+ // cataloged file leaves the lists, and type set in it resolves to the fallback font. A face+ // without a file (bundled, or added as bytes) stays.+ let mut dropped = std::collections::HashSet::new();+ self.faces.write().unwrap_or_else(|e| e.into_inner()).retain(|f| {+ let keep = f.path.as_ref().is_none_or(|p| installed.contains(p));+ if !keep {+ dropped.insert(f.id);+ }+ keep+ });+ if !dropped.is_empty() {+ log::debug!("dropped {} font faces whose files are no longer installed", dropped.len());+ self.outlines.lock().unwrap_or_else(|e| e.into_inner()).retain(|(id, _), _| !dropped.contains(id));+ }+ // A font installed since may cover the characters no font did: they are looked for again.+ {+ let mut sys = self.sys.lock().unwrap_or_else(|e| e.into_inner());+ sys.scans = sys.scans.wrapping_add(1);+ sys.misses.clear();+ }+ self.changed();+ n+ }+}diff --git a/crates/text/src/fontdb/dirs.rs b/crates/text/src/fontdb/dirs.rsnew file mode 100644index 000000000..2b39edbc1--- /dev/null+++ b/crates/text/src/fontdb/dirs.rs@@ -0,0 +1,220 @@+use super::*;++/// A font file holding `tables` (tag, data), sorted by tag as table directories are.+#[cfg(any(test, not(target_arch = "wasm32")))]+pub(crate) fn sfnt_of(tables: &[(&[u8; 4], &[u8])]) -> Option<Vec<u8>> {+ let mut tables = tables.to_vec();+ tables.sort_by_key(|t| *t.0);+ let n = u16::try_from(tables.len()).ok()?;+ let mut font = Vec::new();+ font.extend_from_slice(&0x0001_0000_u32.to_be_bytes());+ for v in [n, 0, 0, 0] {+ font.extend_from_slice(&v.to_be_bytes());+ }+ let mut offset = 12 + 16 * tables.len();+ for (tag, data) in &tables {+ font.extend_from_slice(*tag);+ for v in [0, u32::try_from(offset).ok()?, u32::try_from(data.len()).ok()?] {+ font.extend_from_slice(&v.to_be_bytes());+ }+ offset += data.len().next_multiple_of(4);+ }+ for (_, data) in &tables {+ font.extend_from_slice(data);+ font.resize(font.len().next_multiple_of(4), 0);+ }+ Some(font)+}++/// Lists the font files the platform's font service knows, for [`set_platform_font_files`].+pub type PlatformFontFiles = fn() -> Vec<String>;++/// What lists the platform's font files, set by the app ([`set_platform_font_files`]).+#[cfg(not(target_arch = "wasm32"))]+static PLATFORM_FONT_FILES: std::sync::OnceLock<PlatformFontFiles> = std::sync::OnceLock::new();++/// Have [`system_font_dirs`] add the font files `list` gives (full paths) outside the font+/// folders, asked again by each scan and each check for installed fonts+/// ([`FontDb::installed_fonts_changed`]). The desktop app lists DirectWrite's system font+/// collection on Windows: fonts a font service such as Adobe Fonts loads in place, from files+/// outside the font folders and unknown to the registry (#579). On macOS it lists the fonts+/// CoreText's font manager has available, which apps and font managers can register from any+/// folder. Only the first call counts.+pub fn set_platform_font_files(list: PlatformFontFiles) {+ #[cfg(not(target_arch = "wasm32"))]+ // A second call keeps the first lister, as documented.+ let _ = PLATFORM_FONT_FILES.set(list);+ #[cfg(target_arch = "wasm32")]+ let _ = list;+}++/// Folders the user adds to the font scan (Preferences › Type › Additional Fonts Folder, #683),+/// read with their subfolders after the platform's.+#[cfg(not(target_arch = "wasm32"))]+static USER_FONT_DIRS: std::sync::RwLock<Vec<PathBuf>> = std::sync::RwLock::new(Vec::new());++/// Have [`system_font_dirs`] also read `dirs` (#683), so the fonts in them are listed and used as+/// if installed. The next check for installed fonts ([`FontDb::installed_fonts_changed`]) then+/// reports the change, and a scan catalogs them.+pub fn set_user_font_dirs(dirs: Vec<PathBuf>) {+ set_user_font_dirs_confined(dirs, false);+}++/// [`set_user_font_dirs`]; `confined` when a caller confined to some folders (automation) chose+/// them: the scan then reads only what is inside them, not files or folders that links in them+/// lead to elsewhere, since the caller could plant such a link.+pub fn set_user_font_dirs_confined(dirs: Vec<PathBuf>, confined: bool) {+ #[cfg(not(target_arch = "wasm32"))]+ {+ *USER_FONT_DIRS.write().unwrap_or_else(std::sync::PoisonError::into_inner) = dirs;+ USER_FONT_DIRS_CONFINED.store(confined, std::sync::atomic::Ordering::Relaxed);+ }+ #[cfg(target_arch = "wasm32")]+ let _ = (dirs, confined);+}++/// Whether [`USER_FONT_DIRS`] were chosen by a confined caller ([`set_user_font_dirs_confined`]).+#[cfg(not(target_arch = "wasm32"))]+static USER_FONT_DIRS_CONFINED: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);++/// The folders, as found on disk, that the scan reads only the inside of+/// ([`set_user_font_dirs_confined`]).+#[cfg(not(target_arch = "wasm32"))]+pub(super) fn confined_font_dirs() -> Vec<PathBuf> {+ if !USER_FONT_DIRS_CONFINED.load(std::sync::atomic::Ordering::Relaxed) {+ return vec![];+ }+ user_font_dirs().iter().filter_map(|d| std::fs::canonicalize(d).ok()).collect()+}++/// The folders [`set_user_font_dirs`] added (none on wasm).+pub fn user_font_dirs() -> Vec<PathBuf> {+ #[cfg(not(target_arch = "wasm32"))]+ return USER_FONT_DIRS.read().unwrap_or_else(std::sync::PoisonError::into_inner).clone();+ #[cfg(target_arch = "wasm32")]+ Vec::new()+}++/// VectorCraft's own Fonts folder, set by the app ([`set_app_font_dir`]).+#[cfg(not(target_arch = "wasm32"))]+static APP_FONT_DIR: std::sync::OnceLock<PathBuf> = std::sync::OnceLock::new();++/// Have [`system_font_dirs`] read `dir` with its subfolders: VectorCraft's own Fonts folder, which+/// `text.addFontFiles` copies font files into. The desktop app and `vectorcraft-cli` set it before+/// the first scan, as they install [`set_platform_font_files`]. A folder that doesn't exist yet is+/// read once it does. Only the first call counts. Ignored on wasm.+pub fn set_app_font_dir(dir: PathBuf) {+ #[cfg(not(target_arch = "wasm32"))]+ // A second call keeps the first folder, as documented.+ let _ = APP_FONT_DIR.set(dir);+ #[cfg(target_arch = "wasm32")]+ let _ = dir;+}++/// The folder [`set_app_font_dir`] set: none before that, and none on wasm.+pub fn app_font_dir() -> Option<&'static Path> {+ #[cfg(not(target_arch = "wasm32"))]+ return APP_FONT_DIR.get().map(PathBuf::as_path);+ #[cfg(target_arch = "wasm32")]+ None+}++/// The platform's font folders (the system's and the user's), VectorCraft's own Fonts folder+/// ([`set_app_font_dir`]), the font files known to the platform outside them (on Windows those+/// registered with it, and those [`set_platform_font_files`] lists) and the folders the user added+/// ([`set_user_font_dirs`]), scanned by [`FontDb::global`].+pub fn system_font_dirs() -> Vec<PathBuf> {+ let mut dirs: Vec<PathBuf> = Vec::new();+ if cfg!(target_arch = "wasm32") {+ return dirs;+ }+ let home = std::env::var_os("HOME").map(PathBuf::from);+ if cfg!(target_os = "macos") {+ dirs.extend(["/System/Library/Fonts", "/Library/Fonts", "/Network/Library/Fonts"].map(Into::into));+ if let Some(h) = &home {+ dirs.push(h.join("Library/Fonts"));+ }+ // Fonts macOS downloads on demand (Yu Gothic, Yu Mincho, Tsukushi Maru Gothic…): one+ // asset folder per font, under a catalog folder whose number changes with macOS.+ for e in std::fs::read_dir("/System/Library/AssetsV2").into_iter().flatten().flatten() {+ if e.file_name().to_string_lossy().starts_with("com_apple_MobileAsset_Font") {+ dirs.push(e.path());+ }+ }+ } else if cfg!(windows) {+ let root = std::env::var_os("WINDIR").map(PathBuf::from).unwrap_or_else(|| "C:\\Windows".into());+ dirs.push(root.join("Fonts"));+ // Fonts installed for the current user only (what Install does without administrator rights).+ if let Some(l) = std::env::var_os("LOCALAPPDATA") {+ dirs.push(PathBuf::from(l).join("Microsoft\\Windows\\Fonts"));+ }+ #[cfg(windows)]+ dirs.extend(registered_font_files(&dirs));+ } else {+ dirs.extend(["/usr/share/fonts", "/usr/local/share/fonts"].map(Into::into));+ // The XDG data folders' `fonts` (fontconfig's user folder; Flatpak, Snap, NixOS and Guix+ // list their own data folders), relative paths ignored as the XDG spec says.+ let xdg = |var| std::env::var_os(var).map(|v| std::env::split_paths(&v).filter(|p| p.is_absolute()).collect::<Vec<_>>()).unwrap_or_default();+ let data_home = xdg("XDG_DATA_HOME").into_iter().next().or_else(|| home.as_ref().map(|h| h.join(".local/share")));+ dirs.extend(data_home.iter().cloned().chain(xdg("XDG_DATA_DIRS")).map(|d| d.join("fonts")));+ if let Some(h) = &home {+ dirs.push(h.join(".fonts"));+ }+ // In a Flatpak sandbox, the host's fonts (system, local and the user's).+ dirs.extend(["/run/host/fonts", "/run/host/local-fonts", "/run/host/user-fonts"].map(Into::into));+ // The folders fontconfig is set up with outside those: packages add their own (TeX fonts+ // under `/usr/share/texmf/fonts`, #1529), and `fc-list` and other apps show their fonts.+ let config_home = xdg("XDG_CONFIG_HOME").into_iter().next().or_else(|| home.as_ref().map(|h| h.join(".config")));+ let places = crate::fontconfig::Places { home: home.clone(), data_home, config_home };+ for dir in crate::fontconfig::font_dirs(&crate::fontconfig::root(), &places) {+ if !dirs.iter().any(|known| dir.starts_with(known)) {+ dirs.push(dir);+ }+ }+ }+ dirs.extend(app_font_dir().map(Path::to_path_buf));+ #[cfg(not(target_arch = "wasm32"))]+ if let Some(list) = PLATFORM_FONT_FILES.get() {+ let files = fonts_outside(list(), &dirs);+ dirs.extend(files);+ }+ dirs.extend(user_font_dirs());+ dirs+}++/// The registry key listing the fonts installed on Windows (for all users under the local+/// machine's key, for the current user under theirs): one value per face, holding its file's+/// name in the Windows font folder or its full path.+#[cfg(windows)]+const REGISTERED_FONTS: &str = r"Software\Microsoft\Windows NT\CurrentVersion\Fonts";++/// The font files registered with Windows outside `font_dirs` (fonts installed as shortcuts to+/// where they are, or by programs into their own folders), which apps find by the registry.+#[cfg(windows)]+fn registered_font_files(font_dirs: &[PathBuf]) -> Vec<PathBuf> {+ use windows_registry::{CURRENT_USER, LOCAL_MACHINE};+ let values = [LOCAL_MACHINE, CURRENT_USER].into_iter().filter_map(|root| root.open(REGISTERED_FONTS).ok()).flat_map(|key| {+ // A value that isn't a string isn't a font file.+ key.values().map(|vs| vs.filter_map(|(_, v)| String::try_from(v).ok()).collect::<Vec<_>>()).unwrap_or_default()+ });+ fonts_outside(values, font_dirs)+}++/// The full paths among `registered` (font registrations' data) that aren't in `font_dirs`+/// (ignoring case, as Windows paths do), sorted and deduplicated. File names alone are files in+/// the Windows font folder, which is scanned anyway. The count is capped.+#[cfg(not(target_arch = "wasm32"))]+pub(crate) fn fonts_outside(registered: impl IntoIterator<Item = String>, font_dirs: &[PathBuf]) -> Vec<PathBuf> {+ const MAX_REGISTERED: usize = 1 << 16;+ let lower = |p: &Path| PathBuf::from(p.to_string_lossy().to_lowercase());+ let dirs: Vec<PathBuf> = font_dirs.iter().map(|d| lower(d)).collect();+ let mut files: Vec<PathBuf> = registered+ .into_iter()+ .take(MAX_REGISTERED)+ .map(PathBuf::from)+ .filter(|p| p.is_absolute() && !dirs.iter().any(|d| lower(p).starts_with(d)))+ .collect();+ files.sort();+ files.dedup();+ files+}diff --git a/crates/text/src/fontdb/face.rs b/crates/text/src/fontdb/face.rsnew file mode 100644index 000000000..5f1973ccd--- /dev/null+++ b/crates/text/src/fontdb/face.rs@@ -0,0 +1,376 @@+use super::build::base_values;+use super::names::{localized, name};+use super::traits::{FaceKeys, FontTraits};+use super::*;++/// The family used when a requested family is unknown (Illustrator's Myriad Pro analogue).+pub const FALLBACK_FAMILY: &str = "Source Sans 3";++/// The fonts every database starts with (feature `bundled-fonts`, on by default).+#[cfg(feature = "bundled-fonts")]+pub(super) static BUNDLED: &[&[u8]] = &[+ include_bytes!("../../../../assets/fonts/SourceSans3-Regular.ttf"),+ include_bytes!("../../../../assets/fonts/SourceSans3-Semibold.ttf"),+ include_bytes!("../../../../assets/fonts/SourceSans3-Bold.ttf"),+ include_bytes!("../../../../assets/fonts/SourceSans3-It.ttf"),+ include_bytes!("../../../../assets/fonts/SourceSerif4-Regular.ttf"),+ include_bytes!("../../../../assets/fonts/Inter-Regular.ttf"),+ include_bytes!("../../../../assets/fonts/Inter-Medium.ttf"),+ include_bytes!("../../../../assets/fonts/Inter-SemiBold.ttf"),+ include_bytes!("../../../../assets/fonts/JetBrainsMono-Regular.ttf"),+];++/// Without `bundled-fonts` a database starts with none: the embedder adds its fonts+/// ([`FontDb::add_font`]); until then text has no glyphs.+#[cfg(not(feature = "bundled-fonts"))]+pub(super) static BUNDLED: &[&[u8]] = &[];++/// An axis setting of a variable font: the axis tag (`wght`) and its value in user units (700).+pub type Variation = ([u8; 4], f32);++/// Caps on what a (possibly damaged) variable font can make the database read: axes per font and+/// named instances listed per face.+pub(super) const MAX_AXES: usize = 64;++pub(super) const MAX_INSTANCES: usize = 512;++/// One axis of a variable font's design space, as its `fvar` table lists it: the tag (`wght`), its+/// name in the font's name table (`Weight`; the tag when it has none) and its range and default,+/// in the axis's own units.+#[derive(Clone, Debug, PartialEq)]+pub struct VariationAxis {+ pub tag: [u8; 4],+ pub name: String,+ pub min: f32,+ pub default: f32,+ pub max: f32,+ /// The font asks for the axis not to be shown to users (the `fvar` hidden flag).+ pub hidden: bool,+}++/// Faces of variable fonts instanced at axis settings their named instances don't have+/// ([`FontDb::instance`]). Each setting of a face keeps its id for the life of the process, so a+/// laid-out glyph's face can be found again ([`FontDb::face_by_id`]) after the built face was+/// dropped to bound the memory the cache holds.+#[derive(Default)]+pub(super) struct Instances {+ /// The id of each face and setting.+ pub(super) ids: HashMap<InstanceKey, u32>,+ /// What each id is: the face it was instanced from and its axis settings.+ pub(super) recipes: HashMap<u32, (u32, Vec<Variation>)>,+ /// The instanced faces built, by id; dropped all at once when [`MAX_LIVE_INSTANCES`] are held.+ pub(super) live: HashMap<u32, Arc<FontFace>>,+}++/// A face instanced at axis settings: the id of the face, and the settings by tag, as bits.+pub(super) type InstanceKey = (u32, Vec<([u8; 4], u32)>);++/// How many instanced faces [`Instances::live`] holds at most.+pub(crate) const MAX_LIVE_INSTANCES: usize = 256;++#[derive(Clone)]+pub(super) enum FontBytes {+ Static(&'static [u8]),+ Owned(Arc<Vec<u8>>),+}++/// One loaded font face.+pub struct FontFace {+ /// Every name the face answers to (normalized), in every language its name table has.+ pub(super) keys: FaceKeys,+ /// Its kind, for font menus' filters.+ pub traits: FontTraits,+ pub(super) id: u32,+ /// Typographic family name (e.g. "Source Sans 3").+ pub family: String,+ /// Non-English family name from the name table (`ヒラギノ角ゴシック`), when the font has one.+ /// Used when Preferences › Type › Show Font Names in English is off.+ pub native_family: Option<String>,+ /// Typographic style name (e.g. "Semibold", "Italic").+ pub style: String,+ /// The font's version string (name ID 5, e.g. "Version 7.200"; empty when it has none). Two+ /// installed versions of one family and style are told apart by it (see [`FontDb::face_version`]).+ pub version: String,+ /// usWeightClass-style weight (400 = regular).+ pub weight: f32,+ pub italic: bool,+ pub(super) bytes: FontBytes,+ pub(super) index: u32,+ /// The file the face was read from (cataloged system fonts); `None` for the bundled fonts and+ /// fonts added as bytes.+ pub(super) path: Option<std::path::PathBuf>,+ pub(crate) upem: f64,+ /// Ascender in font units (positive = up).+ pub(crate) ascent: f64,+ /// Descender in font units (positive = down).+ pub(crate) descent: f64,+ /// Cap height and x height in font units (estimated from the ascent when the font has no OS/2+ /// values).+ pub(crate) cap_height: f64,+ pub(crate) x_height: f64,+ /// Underline and strikeout: (offset from the baseline up to the line's top, thickness), in+ /// font units (the `post` and OS/2 tables', else a common placement).+ pub(crate) underline: (f64, f64),+ pub(crate) strikeout: (f64, f64),+ pub(crate) shaper: harfrust::ShaperData,+ /// The axis settings of the variable font's named instance this face is (user units: `wght`+ /// 700); empty for a static face or a variable font's default instance.+ pub(super) variations: Vec<Variation>,+ /// [`Self::variations`] in the font's normalized design space (outlines and metrics).+ pub(super) location: Location,+ /// [`Self::variations`] for the shaper (advances, kerning, feature variations).+ pub(crate) instance: Option<harfrust::ShaperInstance>,+ /// [`Self::ideographic_centre`], read once: layout asks for it per glyph.+ pub(super) ideographic_centre: std::sync::OnceLock<f64>,+ /// [`Self::icf_margins`], read once.+ pub(super) icf_margins: std::sync::OnceLock<IcfMargins>,+ /// Has `sbix` or `CBDT` strikes: colour bitmap glyphs ([`FontDb::glyph_image`]).+ pub(super) colour_bitmaps: bool,+ /// Has `COLR` colour glyphs ([`FontDb::glyph_colour`]).+ pub(super) colour_layers: bool,+ /// Has an `SVG ` table: OpenType SVG glyphs ([`FontDb::glyph_colour`]).+ pub(super) svg_glyphs: bool,+}++/// Where the ideographic character face (ICF) lies inside the ideographic em box: its distance+/// from each edge of the em box, in ems. `top` and `bottom` along a horizontal line, `right` and+/// `left` across a vertical one.+#[derive(Clone, Copy, Debug, Default, PartialEq)]+pub struct IcfMargins {+ pub top: f64,+ pub bottom: f64,+ pub right: f64,+ pub left: f64,+}++impl std::fmt::Debug for FontFace {+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {+ write!(f, "FontFace({} {})", self.family, self.style)+ }+}++impl FontFace {+ pub(crate) fn data(&self) -> &[u8] {+ match &self.bytes {+ FontBytes::Static(b) => b,+ FontBytes::Owned(v) => v.as_slice(),+ }+ }+ pub(crate) fn skrifa(&self) -> Option<skrifa::FontRef<'_>> {+ skrifa::FontRef::from_index(self.data(), self.index).ok()+ }+ pub(crate) fn hb(&self) -> Option<harfrust::FontRef<'_>> {+ harfrust::FontRef::from_index(self.data(), self.index).ok()+ }+ /// The face's index in its font file (collections hold several).+ pub(crate) fn index(&self) -> u32 {+ self.index+ }+ /// Where in a variable font's design space the face's outlines and metrics are taken (the+ /// default location for a static face).+ pub(crate) fn location(&self) -> LocationRef<'_> {+ LocationRef::from(&self.location)+ }+ /// The axis settings of the variable font's named instance this face is (`wght` 700 for+ /// Bold), in user units; empty for a static face and a variable font's default instance.+ /// The face's file holds the whole variable font: exporters that embed it pass these on.+ pub fn variations(&self) -> &[Variation] {+ &self.variations+ }+ /// The variation axes of the face's font (its `fvar` table, at most 64); none for a static+ /// face.+ pub fn axes(&self) -> Vec<VariationAxis> {+ let Some(f) = self.skrifa() else { return vec![] };+ f.axes()+ .iter()+ .take(MAX_AXES)+ .map(|a| {+ let tag = a.tag().to_be_bytes();+ let fallback = || String::from_utf8_lossy(&tag).trim().to_string();+ let name = name(&f, &[a.name_id()]).unwrap_or_else(fallback);+ VariationAxis { tag, name, min: a.min_value(), default: a.default_value(), max: a.max_value(), hidden: a.is_hidden() }+ })+ .collect()+ }+ /// The face's setting of axis `tag`: its named instance's ([`Self::variations`]), else the+ /// axis default. `None` when the font has no such axis.+ pub fn axis_value(&self, tag: [u8; 4]) -> Option<f32> {+ let axis = self.axes().into_iter().find(|a| a.tag == tag)?;+ Some(self.variations.iter().find(|(t, _)| *t == tag).map_or(axis.default, |(_, v)| *v))+ }+ /// Unique id of this face within the process.+ pub fn id(&self) -> u32 {+ self.id+ }+ /// Does the face map `c` to a glyph?+ pub fn covers(&self, c: char) -> bool {+ self.skrifa().is_some_and(|f| f.charmap().map(c).is_some())+ }+ /// Units per em.+ pub fn units_per_em(&self) -> f64 {+ self.upem+ }+ /// (ascent, descent) in font units, both positive.+ pub fn vertical_metrics(&self) -> (f64, f64) {+ (self.ascent, self.descent)+ }+ /// The line gap the font asks for between lines, in font units (from the same table as+ /// [`vertical_metrics`](Self::vertical_metrics); 0 when it has none).+ pub fn line_gap(&self) -> f64 {+ self.skrifa().map_or(0.0, |f| f64::from(f.metrics(Size::unscaled(), self.location()).leading)).max(0.0)+ }+ /// Every mapped character and its glyph id, sorted by code point (the Glyphs panel).+ pub fn chars(&self) -> Vec<(char, u32)> {+ let Some(f) = self.skrifa() else { return vec![] };+ let mut v: Vec<(char, u32)> = f.charmap().mappings().filter_map(|(cp, g)| char::from_u32(cp).map(|c| (c, g.to_u32()))).collect();+ v.sort_unstable_by_key(|x| x.0);+ v.dedup_by_key(|x| x.0);+ v+ }+ /// Advance width of glyph `gid` in font units.+ pub fn advance(&self, gid: u32) -> f64 {+ self.skrifa()+ .and_then(|f| f.glyph_metrics(Size::unscaled(), self.location()).advance_width(GlyphId::new(gid)))+ .map(|a| a as f64)+ .unwrap_or(self.upem * 0.5)+ }+ /// Glyph `gid` set upright in vertical type, from the font's vertical metrics: (its advance down+ /// the column, the height above the baseline of its vertical origin, the top of its cell), in+ /// font units. The origin is the `VORG` table's, else the glyph's top plus its top side bearing.+ /// `None` when the font has no vertical metrics (`vhea`/`vmtx`), or they make no sense.+ pub fn vertical_glyph(&self, gid: u32) -> Option<(f64, f64)> {+ use skrifa::raw::TableProvider;+ let f = self.skrifa()?;+ let vmtx = f.vmtx().ok()?;+ let g = GlyphId::new(gid);+ let advance = f64::from(vmtx.advance(g)?);+ let origin = match f.vorg() {+ Ok(vorg) => f64::from(vorg.vertical_origin_y(g)),+ Err(_) => {+ let top = f.glyph_metrics(Size::unscaled(), self.location()).bounds(g).map_or(self.ascent, |b| f64::from(b.y_max));+ top + f64::from(vmtx.side_bearing(g)?)+ }+ };+ let em = self.upem;+ // A glyph's cell is somewhere between a tenth of an em and a few ems, its top within a few+ // ems of the baseline: anything else is a damaged table.+ (advance > em * 0.1 && advance < em * 4.0 && origin.abs() < em * 4.0).then_some((advance, origin))+ }+ /// Height above the baseline of the centre of the face's ideographic em box, in ems: from its+ /// vertical metrics (an ideograph's cell), else the usual 0.38 (the box running from 0.12 em+ /// below the baseline to 0.88 em above it).+ pub fn ideographic_centre(&self) -> f64 {+ *self.ideographic_centre.get_or_init(|| {+ let gid = ['国', 'あ', '一'].into_iter().map(|c| self.glyph_for(c)).find(|g| *g != 0);+ gid.and_then(|g| self.vertical_glyph(g)).map_or(0.38, |(advance, origin)| (origin - advance * 0.5) / self.upem)+ })+ }+ /// The ideographic character face as margins inside the em box ([`IcfMargins`]): from the+ /// font's BASE table as the OpenType baseline tags define it (`icfb`, `icft` against `ideo`,+ /// `idtp`), else, as that definition allows, from the bounds of some ideographs and kana+ /// averaged, else none (the ICF is the em box).+ /// <https://learn.microsoft.com/en-us/typography/opentype/spec/baselinetags>+ pub fn icf_margins(&self) -> IcfMargins {+ *self.icf_margins.get_or_init(|| self.icf_from_base().or_else(|| self.icf_from_glyphs()).unwrap_or_default())+ }++ /// [`Self::icf_margins`] from the BASE table: the ICF's bottom edge `icfb` (top edge `icft`, else+ /// as far below the em box top) against the em box `ideo` .. `idtp` (else the OS/2 typographic+ /// descender, and one em above it); across vertical lines, `icfb` and `icft` of the vertical+ /// axis against 0 .. `idtp` (else the horizontal margin, and one em).+ pub(crate) fn icf_from_base(&self) -> Option<IcfMargins> {+ use skrifa::raw::TableProvider;+ let f = self.skrifa()?;+ let base = f.base().ok()?;+ let em = self.upem;+ let h = base_values(base.horiz_axis()?.ok()?)?;+ let icfb = *h.get(b"icfb")?;+ let em_bottom = match h.get(b"ideo") {+ Some(v) => *v,+ None => f64::from(f.os2().ok()?.s_typo_descender()),+ };+ let em_top = h.get(b"idtp").copied().unwrap_or(em_bottom + em);+ let margin = icfb - em_bottom;+ let icf_top = h.get(b"icft").copied().unwrap_or(em_top - margin);+ let v = base.vert_axis().and_then(Result::ok).and_then(base_values).unwrap_or_default();+ let icf_left = v.get(b"icfb").copied().unwrap_or(margin);+ let em_right = v.get(b"idtp").copied().unwrap_or(em);+ let icf_right = v.get(b"icft").copied().unwrap_or(em_right - icf_left);+ let m = IcfMargins { top: (em_top - icf_top) / em, bottom: margin / em, right: (em_right - icf_right) / em, left: icf_left / em };+ // Inside the em box, short of its middle: anything else is a damaged table.+ [m.top, m.bottom, m.right, m.left].iter().all(|x| (0.0..0.5).contains(x)).then_some(m)+ }++ /// [`Self::icf_margins`] from the ink of some ideographs and kana: each edge's margin to the em+ /// box (its centre [`Self::ideographic_centre`], one em high and wide), averaged.+ pub(crate) fn icf_from_glyphs(&self) -> Option<IcfMargins> {+ let f = self.skrifa()?;+ let metrics = f.glyph_metrics(Size::unscaled(), self.location());+ let em = self.upem;+ let (em_bottom, em_top) = ((self.ideographic_centre() - 0.5) * em, (self.ideographic_centre() + 0.5) * em);+ let boxes: Vec<_> = ['国', '東', '永', '書', 'あ', 'ア']+ .into_iter()+ .map(|c| self.glyph_for(c))+ .filter(|g| *g != 0)+ .filter_map(|g| metrics.bounds(GlyphId::new(g)))+ .collect();+ if boxes.is_empty() {+ return None;+ }+ let n = boxes.len() as f64;+ let mean = |v: &dyn Fn(&skrifa::metrics::BoundingBox) -> f32| boxes.iter().map(|b| f64::from(v(b))).sum::<f64>() / n;+ let m = IcfMargins {+ top: (em_top - mean(&|b| b.y_max)) / em,+ bottom: (mean(&|b| b.y_min) - em_bottom) / em,+ right: (em - mean(&|b| b.x_max)) / em,+ left: mean(&|b| b.x_min) / em,+ };+ [m.top, m.bottom, m.right, m.left].iter().all(|x| (0.0..0.5).contains(x)).then_some(m)+ }++ /// Glyph id for `c` (0 = .notdef).+ pub fn glyph_for(&self, c: char) -> u32 {+ self.skrifa().and_then(|f| f.charmap().map(c)).map(|g| g.to_u32()).unwrap_or(0)+ }+ /// The file the face was read from (cataloged system fonts).+ pub fn path(&self) -> Option<&std::path::Path> {+ self.path.as_deref()+ }+ /// The bytes of the face's font file (a collection holds several faces).+ pub fn file_data(&self) -> &[u8] {+ self.data()+ }+ /// The embedding permissions of the OS/2 table (`fsType`; 0, installable, when it has none).+ pub fn fs_type(&self) -> u16 {+ use skrifa::raw::TableProvider;+ self.skrifa().and_then(|f| f.os2().ok()).map_or(0, |t| t.fs_type())+ }+ /// May the font file be copied along with a document? Its license allows embedding its+ /// outlines, as exports check it ([`Self::embedding`]).+ pub fn embeddable(&self) -> bool {+ self.embedding() != crate::embed::Embedding::Forbidden+ }+ /// The face's index in its font file ([`Self::file_data`]; collections hold several).+ pub fn face_index(&self) -> u32 {+ self.index+ }+ /// The face's PostScript name, as PostScript files name fonts (`SourceSans3-Bold`): name ID 6;+ /// for a named instance of a variable font (whose name ID 6 is the default instance's), its+ /// prefix and style (`SourceSans3-Semibold`). Without one, its family and style.+ pub fn postscript_name(&self) -> String {+ let squeeze = |s: &str| -> String { s.chars().filter(|c| c.is_ascii_graphic() && !"[](){}<>/%".contains(*c)).collect() };+ let own = self.skrifa().and_then(|f| localized(&f, StringId::POSTSCRIPT_NAME).into_iter().map(|(_, s)| s).next()).map(|s| squeeze(&s));+ match own.filter(|s| !s.is_empty()) {+ Some(name) if self.variations.is_empty() => name,+ own => {+ let prefix = own.as_deref().and_then(|n| n.split('-').next()).map_or_else(|| squeeze(&self.family), str::to_string);+ format!("{prefix}-{}", squeeze(&self.style))+ }+ }+ }+ /// Are the face's outlines TrueType (`glyf`), not PostScript (`CFF `)?+ pub fn is_truetype(&self) -> bool {+ use skrifa::raw::TableProvider;+ self.skrifa().is_some_and(|f| f.glyf().is_ok())+ }+}diff --git a/crates/text/src/fontdb/glyph_pen.rs b/crates/text/src/fontdb/glyph_pen.rsnew file mode 100644index 000000000..1a45e0b95--- /dev/null+++ b/crates/text/src/fontdb/glyph_pen.rs@@ -0,0 +1,29 @@+use super::face::FontFace;+use super::*;++/// Is glyph `gid` of `face` (as `font`) drawn from an SVG document, if it has one: the face has+/// SVG glyphs, and the glyph no COLR layers, which come first.+pub(super) fn svg_drawn(face: &FontFace, font: &skrifa::FontRef<'_>, gid: u32) -> bool {+ face.svg_glyphs && !crate::colr::has_colour_glyph(font, gid)+}++/// A pen drawing outlines y down, as text space has them.+pub(crate) struct FlipPen(pub(crate) BezPath);++impl OutlinePen for FlipPen {+ fn move_to(&mut self, x: f32, y: f32) {+ self.0.move_to((x as f64, -y as f64));+ }+ fn line_to(&mut self, x: f32, y: f32) {+ self.0.line_to((x as f64, -y as f64));+ }+ fn quad_to(&mut self, cx0: f32, cy0: f32, x: f32, y: f32) {+ self.0.quad_to((cx0 as f64, -cy0 as f64), (x as f64, -y as f64));+ }+ fn curve_to(&mut self, cx0: f32, cy0: f32, cx1: f32, cy1: f32, x: f32, y: f32) {+ self.0.curve_to((cx0 as f64, -cy0 as f64), (cx1 as f64, -cy1 as f64), (x as f64, -y as f64));+ }+ fn close(&mut self) {+ self.0.close_path();+ }+}diff --git a/crates/text/src/fontdb/lookup.rs b/crates/text/src/fontdb/lookup.rsnew file mode 100644index 000000000..a5758b884--- /dev/null+++ b/crates/text/src/fontdb/lookup.rs@@ -0,0 +1,545 @@+use super::build::{instanced, style_distance, style_italic, style_weight};+use super::cache::Catalog;+use super::face::{FALLBACK_FAMILY, FontFace, MAX_LIVE_INSTANCES, Variation, VariationAxis};+use super::glyph_pen::{FlipPen, svg_drawn};+#[cfg(not(target_arch = "wasm32"))]+use super::names::SYSTEM_FALLBACKS;+use super::names::{norm, norm_chars, script_families};+#[cfg(not(target_arch = "wasm32"))]+use super::scan::{enumerate_faces, font_files};+use super::traits::{Alias, FontMatch, FontTraits};+use super::*;++impl FontDb {+ /// The family's own name and the style for a name given in a document: any of a family's+ /// names (`ヒラギノ角ゴシック` is Hiragino Sans), a legacy family name (`Hiragino Sans W6` with its+ /// legacy style names the W6 face), a full name (name ID 4) or a PostScript name+ /// (`HiraginoSans-W6`, as PDF and `.ai` files name fonts). Case and anything but letters and+ /// digits are ignored. An unknown name is returned unchanged.+ pub fn canonical(&self, family: &str, style: &str) -> (String, String) {+ if self.is_loaded(family) || self.read_catalog().contains_key(&family.to_ascii_lowercase()) {+ return (family.to_string(), style.to_string());+ }+ // The lock is held until the answer is kept, and [`FontDb::changed`] waits for it: an+ // answer found from the fonts before a change is cleared by that change.+ let mut cache = self.canonical_cache.lock().unwrap_or_else(|e| e.into_inner());+ let key = (family.to_string(), style.to_string());+ if let Some(answer) = cache.get(&key) {+ return answer.clone();+ }+ let answer = self.canonical_alias(family, style);+ if cache.len() >= CANONICAL_CACHE_MAX {+ cache.clear();+ }+ cache.insert(key, answer.clone());+ answer+ }++ /// Finds [`FontDb::canonical`]'s answer for a name that is neither a loaded nor an installed+ /// family among the loaded faces' and the installed fonts' other names.+ fn canonical_alias(&self, family: &str, style: &str) -> (String, String) {+ let key = norm(family);+ let mut found: Vec<Alias> =+ self.read_faces().iter().flat_map(|f| Alias::of(&f.family, &f.style, &f.keys)).filter(|(k, _)| *k == key).map(|(_, a)| a).collect();+ if let Some(v) = self.aliases.read().unwrap_or_else(|e| e.into_inner()).get(&key) {+ found.extend(v.iter().cloned());+ }+ let ns = norm(style);+ // A family and style split from a PostScript name by an importer that didn't have the font+ // (`Honoka-Mincho` → Honoka, Mincho): once it is installed, the face of that PostScript+ // name, which is its own family and style (ほのか明朝, Regular).+ if found.is_empty() && !ns.is_empty() {+ let joined = format!("{key}{ns}");+ let face = |a: &Alias| a.paired.is_none() && a.style.is_some();+ let ps =+ self.read_faces().iter().flat_map(|f| Alias::of(&f.family, &f.style, &f.keys)).find(|(k, a)| *k == joined && face(a)).map(|(_, a)| a);+ let ps = ps.or_else(|| {+ self.aliases.read().unwrap_or_else(std::sync::PoisonError::into_inner).get(&joined).and_then(|v| v.iter().find(|a| face(a)).cloned())+ });+ if let Some(a) = ps {+ return (a.family, a.style.unwrap_or_else(|| style.to_string()));+ }+ }+ // A family name keeps the style asked for; a legacy pair names its face; a full or+ // PostScript name its face whatever style is asked for.+ if let Some(a) = found.iter().find(|a| a.style.is_none()) {+ return (a.family.clone(), style.to_string());+ }+ if let Some(a) = found.iter().find(|a| a.paired.as_ref().is_some_and(|p| *p == ns) || a.paired.is_none()) {+ return (a.family.clone(), a.style.clone().unwrap_or_else(|| style.to_string()));+ }+ match found.first() {+ Some(a) => (a.family.clone(), style.to_string()),+ None => (family.to_string(), style.to_string()),+ }+ }++ /// The kind of `family` (whether it sets Japanese, its class), for font menu filters: from a+ /// loaded face, else from the system font scan. Variable when any of its faces, loaded or+ /// scanned, is: a family may install static files beside a variable one. Cheap: no font file+ /// is read, and a loaded family doesn't start the scan.+ pub fn family_traits(&self, family: &str) -> FontTraits {+ let loaded = {+ let faces = self.read_faces();+ let mut of_family = faces.iter().filter(|f| f.family.eq_ignore_ascii_case(family));+ of_family.next().map(|first| FontTraits { variable: first.traits.variable || of_family.any(|f| f.traits.variable), ..first.traits })+ };+ let scanned = |catalog: &Catalog| catalog.get(&family.to_ascii_lowercase()).and_then(|c| c.traits);+ match loaded {+ None => scanned(&self.read_catalog()).unwrap_or_default(),+ Some(traits) if traits.variable => traits,+ Some(traits) => {+ let variable = scanned(&self.catalog.read().unwrap_or_else(std::sync::PoisonError::into_inner)).is_some_and(|t| t.variable);+ FontTraits { variable, ..traits }+ }+ }+ }++ /// [`face`](Self::face) by any of the family's names ([`canonical`](Self::canonical)), and how+ /// it matched.+ pub fn resolve(&self, family: &str, style: &str) -> Option<(Arc<FontFace>, FontMatch)> {+ let (family, style) = self.canonical(family, style);+ let f = self.face(&family, &style)?;+ let m = if !f.family.eq_ignore_ascii_case(&family) {+ FontMatch::Missing+ } else if norm(&f.style) == norm(&style) || f.keys.styles.contains(&norm(&style)) {+ FontMatch::Exact+ } else {+ FontMatch::Style+ };+ Some((f, m))+ }++ /// The installed face whose PostScript name is `name` (`HiraginoSans-W3`; any case), loaded+ /// from the system fonts if need be. `None` when no installed font has the name.+ pub fn find_postscript(&self, name: &str) -> Option<Arc<FontFace>> {+ let key = norm(name);+ if key.is_empty() {+ return None;+ }+ let loaded = |db: &FontDb| db.read_faces().iter().find(|f| f.keys.postscript.contains(&key)).cloned();+ if let Some(f) = loaded(self) {+ return Some(f);+ }+ self.ensure_catalog();+ let face = self.aliases.read().unwrap_or_else(|e| e.into_inner()).get(&key).and_then(|v| {+ v.iter().find(|a| a.paired.is_none() && a.style.is_some()).map(|a| (a.family.clone(), a.style.clone().unwrap_or_default()))+ });+ let (family, style) = face?;+ self.face(&family, &style)?;+ loaded(self)+ }++ /// The (family, style) of the installed face whose PostScript name is `name` (ignoring ASCII+ /// case). Documents name fonts this way, and a family can hold hyphens+ /// ("Rounded-X-Mplus-1c-black" is Rounded-X M+ 1c, black), so the name can't be split.+ pub fn by_postscript_name(&self, name: &str) -> Option<(String, String)> {+ self.ensure_catalog();+ self.postscript.read().unwrap_or_else(|e| e.into_inner()).get(&norm(name)).cloned()+ }++ /// Load the files of the installed `family`, adding all their faces at once+ /// ([`Self::add_fonts`]). Returns whether the family is loaded now: by this call, or by another+ /// thread meanwhile.+ #[cfg(not(target_arch = "wasm32"))]+ fn load_cataloged(&self, family: &str) -> bool {+ let mut paths: Vec<PathBuf> =+ self.read_catalog().get(&family.to_ascii_lowercase()).map(|c| c.faces.iter().map(|cf| cf.path.clone()).collect()).unwrap_or_default();+ paths.sort();+ paths.dedup();+ let files = paths.into_iter().flat_map(|p| font_files(&p).into_iter().map(move |data| (data, Some(p.clone()))));+ self.add_fonts(files) > 0 || self.is_loaded(family)+ }++ /// Resolve a family + style to a face, falling back to the closest style of the family, then to+ /// Source Sans 3 Regular. Installed system fonts are found by name whatever ran before. `None`+ /// only if no font at all is loaded (the bundled fonts failed to parse, or were left out with+ /// the `bundled-fonts` feature and none was added), in which case text has no glyphs.+ pub fn face(&self, family: &str, style: &str) -> Option<Arc<FontFace>> {+ let (family, style) = self.canonical(family, style);+ let (family, style) = (family.as_str(), style.as_str());+ let found = self.find(family, style);+ if found.as_ref().is_some_and(|f| norm(&f.style) == norm(style)) {+ return found;+ }+ // The family, or this style of it, is installed but not loaded yet. Looked for again+ // whether or not this call loaded it: another thread may have just done so (then this+ // load adds nothing, but the face is there).+ #[cfg(not(target_arch = "wasm32"))]+ if found.is_none() || self.is_cataloged(family, style) {+ self.load_cataloged(family);+ if let Some(f) = self.find(family, style) {+ return Some(f);+ }+ }+ found+ .or_else(|| self.find(FALLBACK_FAMILY, style))+ .or_else(|| self.find(FALLBACK_FAMILY, "Regular"))+ .or_else(|| self.read_faces().first().cloned())+ }++ /// [`FontDb::face`] in version `version` of the family and style (a [`FontFace::version`]), when+ /// that version is installed; otherwise (or without a version) the face [`FontDb::face`] gives.+ pub fn face_version(&self, family: &str, style: &str, version: Option<&str>) -> Option<Arc<FontFace>> {+ let face = self.face(family, style)?;+ let Some(version) = version.filter(|v| *v != face.version) else { return Some(face) };+ let same =+ |f: &&Arc<FontFace>| f.family.eq_ignore_ascii_case(&face.family) && f.style.eq_ignore_ascii_case(&face.style) && f.version == version;+ if let Some(f) = self.read_faces().iter().find(same) {+ return Some(f.clone());+ }+ // Not loaded: the family's installed files may hold it (the catalog doesn't list versions).+ self.load_family_files(&face.family);+ let found = self.read_faces().iter().find(same).cloned();+ Some(found.unwrap_or(face))+ }++ /// Every installed version of `face`'s family and style, `face` itself first.+ pub fn versions(&self, face: &Arc<FontFace>) -> Vec<Arc<FontFace>> {+ self.load_family_files(&face.family);+ let mut out = vec![face.clone()];+ out.extend(+ self.read_faces()+ .iter()+ .filter(|f| f.family.eq_ignore_ascii_case(&face.family) && f.style.eq_ignore_ascii_case(&face.style) && f.id != face.id)+ .cloned(),+ );+ out+ }++ /// Load the installed files of `family` once (other versions of faces already loaded from+ /// elsewhere); a no-op on wasm, where no fonts are installed.+ fn load_family_files(&self, family: &str) {+ #[cfg(not(target_arch = "wasm32"))]+ {+ let key = family.to_ascii_lowercase();+ if self.version_scanned.write().unwrap_or_else(|e| e.into_inner()).insert(key) {+ self.load_cataloged(family);+ }+ }+ #[cfg(target_arch = "wasm32")]+ let _ = family;+ }++ /// Is `style` of `family` among the installed fonts?+ #[cfg(not(target_arch = "wasm32"))]+ fn is_cataloged(&self, family: &str, style: &str) -> bool {+ let ns = norm(style);+ self.read_catalog().get(&family.to_ascii_lowercase()).is_some_and(|c| c.faces.iter().any(|cf| norm(&cf.style) == ns))+ }++ /// The loaded face with [`FontFace::id`] `id` (the face a laid-out glyph came from), an+ /// instanced face ([`Self::instance`]) included.+ pub fn face_by_id(&self, id: u32) -> Option<Arc<FontFace>> {+ let loaded = self.read_faces().iter().find(|f| f.id == id).cloned();+ loaded.or_else(|| self.instance_by_id(id))+ }++ /// The face of character style `st`: [`Self::face_version`] of its font, instanced at its+ /// Variable Font settings ([`Self::instance`]).+ pub fn style_face(&self, st: &vectorcraft_doc::CharStyle) -> Option<Arc<FontFace>> {+ let face = self.face_version(&st.font_family, &st.font_style, st.font_version.as_deref())?;+ Some(self.instance(&face, &st.font_axes))+ }++ /// `face` with the axis settings `axes` (by tag, in the axes' own units) in place of its own,+ /// each clamped to its axis's range: its outlines, metrics and advances taken there, and its+ /// file embedded instanced there. Tags the font has no axis for are left out. `face` itself+ /// when that changes no setting, and for a static face.+ pub fn instance(&self, face: &Arc<FontFace>, axes: &std::collections::BTreeMap<String, f64>) -> Arc<FontFace> {+ if axes.is_empty() {+ return face.clone();+ }+ let font_axes = face.axes();+ let mut variations = face.variations.clone();+ for (tag, value) in axes {+ let Some(axis) = font_axes.iter().find(|a| a.tag.as_slice() == tag.as_bytes()) else { continue };+ if !value.is_finite() {+ continue;+ }+ let v = (*value as f32).clamp(axis.min.min(axis.max), axis.max.max(axis.min));+ match variations.iter_mut().find(|(t, _)| *t == axis.tag) {+ Some(setting) => setting.1 = v,+ None => variations.push((axis.tag, v)),+ }+ }+ // Every axis at the setting it has in `face`: nothing to instance.+ let at = |vs: &[Variation], a: &VariationAxis| vs.iter().find(|(t, _)| *t == a.tag).map_or(a.default, |(_, v)| *v);+ if font_axes.iter().all(|a| at(&variations, a) == at(&face.variations, a)) {+ return face.clone();+ }+ variations.sort_by_key(|(t, _)| *t);+ let key = (face.id, variations.iter().map(|(t, v)| (*t, v.to_bits())).collect::<Vec<_>>());+ let mut inst = self.instances.lock().unwrap_or_else(|e| e.into_inner());+ let id = match inst.ids.get(&key) {+ Some(id) => *id,+ None => {+ let id = NEXT_ID.fetch_add(1, Ordering::Relaxed);+ inst.ids.insert(key, id);+ inst.recipes.insert(id, (face.id, variations.clone()));+ id+ }+ };+ if let Some(f) = inst.live.get(&id) {+ return f.clone();+ }+ let Some(built) = instanced(face, variations, id) else { return face.clone() };+ let built = Arc::new(built);+ if inst.live.len() >= MAX_LIVE_INSTANCES {+ inst.live.clear();+ }+ inst.live.insert(id, built.clone());+ built+ }++ /// The instanced face with id `id` ([`Self::instance`]), built again when it was dropped.+ fn instance_by_id(&self, id: u32) -> Option<Arc<FontFace>> {+ let (base, variations) = {+ let inst = self.instances.lock().unwrap_or_else(|e| e.into_inner());+ if let Some(f) = inst.live.get(&id) {+ return Some(f.clone());+ }+ inst.recipes.get(&id).cloned()?+ };+ let base = self.read_faces().iter().find(|f| f.id == base).cloned()?;+ let built = Arc::new(instanced(&base, variations, id)?);+ let mut inst = self.instances.lock().unwrap_or_else(|e| e.into_inner());+ if inst.live.len() >= MAX_LIVE_INSTANCES {+ inst.live.clear();+ }+ Some(inst.live.entry(id).or_insert(built).clone())+ }++ /// The available family `name` names, ignoring case and anything but letters and digits, as+ /// PostScript names write families ("MicrosoftYaHei" is Microsoft YaHei).+ pub fn find_family(&self, name: &str) -> Option<String> {+ self.family_list().iter().find(|f| norm_chars(f).eq(norm_chars(name))).cloned()+ }++ /// Is `family` available (loaded, or installed on the system)?+ pub fn has_family(&self, family: &str) -> bool {+ let (family, _) = self.canonical(family, "");+ self.is_loaded(&family) || self.read_catalog().contains_key(&family.to_ascii_lowercase())+ }++ pub(crate) fn is_loaded(&self, family: &str) -> bool {+ self.read_faces().iter().any(|f| f.family.eq_ignore_ascii_case(family))+ }++ pub(crate) fn find(&self, family: &str, style: &str) -> Option<Arc<FontFace>> {+ let faces = self.read_faces();+ let cands: Vec<&Arc<FontFace>> = faces.iter().filter(|f| f.family.eq_ignore_ascii_case(family)).collect();+ if cands.is_empty() {+ return None;+ }+ let ns = norm(style);+ if let Some(f) = cands.iter().find(|f| norm(&f.style) == ns) {+ return Some((*f).clone());+ }+ // Another of a face's style names: in another language, or a variable font's default+ // instance's name.+ if let Some(f) = cands.iter().find(|f| f.keys.styles.contains(&ns)) {+ return Some((*f).clone());+ }+ let (tw, ti) = (style_weight(style), style_italic(style));+ cands.iter().min_by(|a, b| style_distance(a, tw, ti).total_cmp(&style_distance(b, tw, ti))).map(|f| (*f).clone())+ }++ /// [`fallback_for_style`](Self::fallback_for_style) for upright Regular text.+ pub(crate) fn fallback_for(&self, c: char, exclude: u32) -> Option<Arc<FontFace>> {+ self.fallback_for_style(c, exclude, 400.0, false)+ }++ /// First family (fallback family first, then load order) with a face that covers `c`, in that+ /// family's face nearest `weight` and `italic`; on native, system fonts are loaded lazily the+ /// first time no loaded face covers a character (#2491).+ pub(crate) fn fallback_for_style(&self, c: char, exclude: u32, weight: f32, italic: bool) -> Option<Arc<FontFace>> {+ // Thai (Lao, Khmer, Myanmar) takes a font made for it, when one is installed, rather than+ // whichever face covering it happened to load first (a display face, say).+ let prefer = script_families(c);+ if let Some(f) = self.family_fallback(c, exclude, prefer, weight, italic) {+ return Some(f);+ }+ #[cfg(not(target_arch = "wasm32"))]+ if self.load_families(c, prefer)+ && let Some(f) = self.family_fallback(c, exclude, prefer, weight, italic)+ {+ return Some(f);+ }+ if let Some(f) = self.loaded_fallback(c, exclude, weight, italic) {+ return Some(f);+ }+ #[cfg(not(target_arch = "wasm32"))]+ self.system_fallback(c);+ // Another lookup may have loaded the face while this one searched. Loading no new+ // faces does not mean no face covers the character (as with `face`'s catalog lookup).+ self.loaded_fallback(c, exclude, weight, italic)+ }++ /// A face that covers `c`, for text drawn outside the canvas (the app's own UI): the loaded+ /// fonts first, then (native) an installed one, loaded on demand. Characters no font covers+ /// are remembered, so they are looked for once.+ pub fn face_covering(&self, c: char) -> Option<Arc<FontFace>> {+ self.fallback_for(c, 0)+ }++ /// The loaded face of the first of `families` that covers `c`, nearest `weight` and `italic`.+ fn family_fallback(&self, c: char, exclude: u32, families: &[&str], weight: f32, italic: bool) -> Option<Arc<FontFace>> {+ let faces = self.read_faces();+ families.iter().find_map(|fam| {+ faces+ .iter()+ .filter(|f| f.id != exclude && f.family.eq_ignore_ascii_case(fam) && f.covers(c))+ .min_by(|a, b| style_distance(a, weight, italic).total_cmp(&style_distance(b, weight, italic)))+ .cloned()+ })+ }++ /// Load the first of the installed `families` not loaded yet that covers `c` (with system+ /// fallback on). Returns whether one was loaded.+ #[cfg(not(target_arch = "wasm32"))]+ fn load_families(&self, c: char, families: &[&str]) -> bool {+ if families.is_empty() || !self.sys.lock().unwrap_or_else(|e| e.into_inner()).enabled {+ return false;+ }+ families.iter().any(|fam| !self.is_loaded(fam) && self.load_cataloged(fam) && self.family_fallback(c, 0, &[fam], 400.0, false).is_some())+ }++ /// The first loaded family (the fallback family, then load order) with a face covering `c`,+ /// and in it the face nearest `weight` and `italic`.+ fn loaded_fallback(&self, c: char, exclude: u32, weight: f32, italic: bool) -> Option<Arc<FontFace>> {+ let faces = self.read_faces();+ let mut families: Vec<&str> = Vec::new();+ for f in faces.iter().filter(|f| f.id != exclude && f.covers(c)) {+ if !families.iter().any(|fam| fam.eq_ignore_ascii_case(&f.family)) {+ families.push(&f.family);+ }+ }+ // Stable: the fallback family first, the others in load order.+ families.sort_by_key(|fam| !fam.eq_ignore_ascii_case(FALLBACK_FAMILY));+ let fam = families.first()?;+ faces+ .iter()+ .filter(|f| f.id != exclude && f.family.eq_ignore_ascii_case(fam) && f.covers(c))+ .min_by(|a, b| style_distance(a, weight, italic).total_cmp(&style_distance(b, weight, italic)))+ .cloned()+ }++ /// Load a system font covering `c` (preferred fallback families first, then any cataloged+ /// file under 40 MB). Returns true if one was loaded. Misses are remembered.+ #[cfg(not(target_arch = "wasm32"))]+ fn system_fallback(&self, c: char) -> bool {+ if c.is_control() || c.is_whitespace() {+ return false;+ }+ {+ let sys = self.sys.lock().unwrap_or_else(|e| e.into_inner());+ if !sys.enabled || sys.misses.contains(&c) {+ return false;+ }+ }+ // The first scan done before its count is read, so the first miss is remembered too.+ self.ensure_catalog();+ let scans = self.sys.lock().unwrap_or_else(|e| e.into_inner()).scans;+ let covered = |db: &FontDb| db.read_faces().iter().any(|f| f.covers(c));+ for fam in SYSTEM_FALLBACKS {+ if !self.is_loaded(fam) && self.load_cataloged(fam) && covered(self) {+ return true;+ }+ }+ let mut paths: Vec<PathBuf> = self.read_catalog().values().flat_map(|c| c.faces.iter().map(|cf| cf.path.clone())).collect();+ paths.sort();+ paths.dedup();+ for p in paths {+ if std::fs::metadata(&p).map(|m| m.len() > 40 << 20).unwrap_or(true) {+ continue;+ }+ for data in font_files(&p) {+ let hit =+ enumerate_faces(&data).iter().any(|(i, _)| skrifa::FontRef::from_index(&data, *i).is_ok_and(|f| f.charmap().map(c).is_some()));+ if hit && self.add_font_from(data, Some(&p)) > 0 && covered(self) {+ return true;+ }+ }+ }+ let mut sys = self.sys.lock().unwrap_or_else(|e| e.into_inner());+ if sys.scans == scans {+ sys.misses.insert(c);+ }+ false+ }++ /// Glyph outline in font units, y-down (flipped), cached per (face, glyph).+ pub fn outline(&self, face: &FontFace, gid: u32) -> Arc<BezPath> {+ let key = (face.id, gid);+ if let Some(p) = self.outlines.lock().unwrap_or_else(|e| e.into_inner()).get(&key) {+ return p.clone();+ }+ let mut pen = FlipPen(BezPath::new());+ if let Some(f) = face.skrifa()+ && let Some(g) = f.outline_glyphs().get(GlyphId::new(gid))+ {+ let _ = g.draw(DrawSettings::unhinted(Size::unscaled(), face.location()), &mut pen);+ }+ let p = Arc::new(pen.0);+ let mut cache = self.outlines.lock().unwrap_or_else(|e| e.into_inner());+ if cache.len() >= OUTLINE_CACHE_MAX {+ cache.clear();+ }+ cache.insert(key, p.clone());+ p+ }++ /// Glyph `gid`'s colour bitmap (`sbix`, `CBDT`) in `face`, cached per (face, glyph).+ pub fn glyph_image(&self, face: &FontFace, gid: u32) -> Option<Arc<GlyphImage>> {+ if !face.colour_bitmaps {+ return None;+ }+ let key = (face.id, gid);+ if let Some(i) = self.images.lock().unwrap_or_else(std::sync::PoisonError::into_inner).kept.get(&key) {+ return i.clone();+ }+ let image = face.skrifa().and_then(|f| crate::bitmap::glyph_image(&f, face.upem, gid)).map(Arc::new);+ self.images.lock().unwrap_or_else(std::sync::PoisonError::into_inner).keep(key, image.clone());+ image+ }++ /// Is glyph `gid` of face `face_id` drawn from its SVG document (it has one, and no COLR+ /// layers, which come first)? Writers that draw a font's own glyphs can draw COLR and bitmap+ /// glyphs, not always SVG ones.+ pub fn is_svg_glyph(&self, face_id: u32, gid: u32) -> bool {+ let Some(face) = self.face_by_id(face_id) else { return false };+ face.skrifa().is_some_and(|f| svg_drawn(&face, &f, gid) && crate::svg_glyph::has_document(&f, gid))+ }++ /// Glyph `gid`'s colour content in `face`, from its COLR layers or else its SVG document, in+ /// the text's `foreground` (fill) and `stroke` colours where it uses them; cached per (face,+ /// glyph), and per text colours for the glyphs that paint with them.+ pub(crate) fn glyph_colour(&self, face: &FontFace, gid: u32, foreground: Color, stroke: Option<Color>) -> Option<ColourContent> {+ if !face.colour_layers && !face.svg_glyphs {+ return None;+ }+ let f = face.skrifa()?;+ // COLR first; SVG for glyphs without COLR layers (those whose layers don't read keep their+ // outlines, as in fonts without SVG).+ let svg = svg_drawn(face, &f, gid);+ // Kept without colours, or by the text's colours it uses: the fill, and for SVG art the+ // stroke too.+ let coloured = Some((foreground.key(), stroke.filter(|_| svg).map(|c| c.key())));+ {+ let cache = self.colours.lock().unwrap_or_else(std::sync::PoisonError::into_inner);+ if let Some(c) = [None, coloured].iter().find_map(|k| cache.kept.get(&(face.id, gid, *k))) {+ return c.clone();+ }+ }+ let (content, used) = if svg {+ let (art, used) = crate::svg_glyph::svg_glyph(&f, gid, face.upem, foreground, stroke);+ (art.map(ColourContent::Art), used)+ } else {+ crate::colr::colour_glyph(&f, face.location(), face.upem, gid, foreground)+ };+ let key = (face.id, gid, if used { coloured } else { None });+ self.colours.lock().unwrap_or_else(std::sync::PoisonError::into_inner).keep(key, content.clone());+ content+ }+}diff --git a/crates/text/src/fontdb/names.rs b/crates/text/src/fontdb/names.rsnew file mode 100644index 000000000..b027e2a37--- /dev/null+++ b/crates/text/src/fontdb/names.rs@@ -0,0 +1,121 @@+use super::*;++#[cfg(not(target_arch = "wasm32"))]+#[derive(Default)]+pub(super) struct SysFallback {+ pub(super) enabled: bool,+ pub(super) misses: std::collections::HashSet<char>,+ /// Counts the scans of the font folders: a search that a scan overtook doesn't record its miss.+ pub(super) scans: u64,+}++/// Fonts made for Thai, tried first (when installed) for Thai the font in use lacks: Windows+/// (Leelawadee UI; Tahoma before Windows 8), macOS (Thonburi, Sukhumvit Set) and Linux (Noto,+/// TLWG).+pub const THAI_FAMILIES: &[&str] = &[+ "Leelawadee UI",+ "Leelawadee",+ "Tahoma",+ "Thonburi",+ "Sukhumvit Set",+ "Noto Sans Thai",+ "Noto Sans Thai UI",+ "Noto Sans Thai Looped",+ "Waree",+ "Loma",+ "Garuda",+];++/// The families tried first for character `c`, in a script whose text only fonts made for it set+/// well (Thai, Lao, Khmer, Myanmar); none for other characters.+pub(super) fn script_families(c: char) -> &'static [&'static str] {+ use unicode_script::{Script, UnicodeScript};+ match c.script() {+ Script::Thai => THAI_FAMILIES,+ Script::Lao => &["Lao UI", "Leelawadee UI", "Lao Sangam MN", "Noto Sans Lao", "Noto Sans Lao UI", "Phetsarath OT"],+ Script::Khmer => &["Khmer UI", "Khmer Sangam MN", "Noto Sans Khmer", "Noto Sans Khmer UI", "Khmer OS"],+ Script::Myanmar => &["Myanmar Text", "Myanmar Sangam MN", "Noto Sans Myanmar", "Noto Sans Myanmar UI", "Padauk"],+ _ => &[],+ }+}++/// Families tried (when installed) for characters the loaded fonts lack: CJK, symbols, emoji.+#[cfg(not(target_arch = "wasm32"))]+pub(super) const SYSTEM_FALLBACKS: &[&str] = &[+ "Helvetica Neue",+ "Arial",+ "Segoe UI",+ "Noto Sans",+ "DejaVu Sans",+ "PingFang SC",+ "Hiragino Sans",+ "Hiragino Kaku Gothic ProN",+ "Apple SD Gothic Neo",+ "Heiti SC",+ "STHeiti",+ "Microsoft YaHei",+ "Yu Gothic",+ "Malgun Gothic",+ "Noto Sans CJK SC",+ "Noto Sans CJK JP",+ "Arial Unicode MS",+ "Apple Symbols",+ "Segoe UI Symbol",+ "Noto Sans Symbols",+ "Noto Sans Symbols2",+ "Noto Emoji",+ "Segoe UI Emoji",+ "Apple Color Emoji",+ "Noto Color Emoji",+];++pub(super) 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()))+}++/// The most distinct legacy family (and style) names of a font used as keys.+pub(super) const MAX_LEGACY_NAMES: usize = 64;++/// Every localized string of `id`, with its language.+pub(super) fn localized(font: &skrifa::FontRef<'_>, id: StringId) -> Vec<(Option<String>, String)> {+ font.localized_strings(id).map(|s| (s.language().map(str::to_owned), s.to_string())).filter(|(_, s)| !s.is_empty()).collect()+}++/// Whether a name-table language tag is English (Illustrator's "Show Font Names in English").+fn is_english_lang(lang: Option<&str>) -> bool {+ lang.is_some_and(|l| {+ let l = l.to_ascii_lowercase();+ l == "en" || l == "eng" || l.starts_with("en-") || l.starts_with("en_")+ })+}++/// A non-English family label from the name table, for Preferences › Type › Show Font Names in+/// English (off). Prefers a record whose language isn't English; else any label that differs from+/// `english` and isn't plain ASCII. `None` when the font has no other name.+pub(super) fn pick_native_label(english: &str, pairs: &[(Option<String>, String)]) -> Option<String> {+ pairs+ .iter()+ .find(|(lang, s)| !s.eq_ignore_ascii_case(english) && !is_english_lang(lang.as_deref()))+ .or_else(|| pairs.iter().find(|(_, s)| !s.eq_ignore_ascii_case(english) && !s.is_ascii()))+ .map(|(_, s)| s.clone())+}++/// The family's native-language name from the font (typographic, else legacy), when it has one.+pub(super) fn native_family_name(font: &skrifa::FontRef<'_>, english: &str) -> Option<String> {+ pick_native_label(english, &localized(font, StringId::TYPOGRAPHIC_FAMILY_NAME))+ .or_else(|| pick_native_label(english, &localized(font, StringId::FAMILY_NAME)))+}++/// Every localized string of `id`.+pub(super) fn all_names(font: &skrifa::FontRef<'_>, id: StringId) -> Vec<String> {+ localized(font, id).into_iter().map(|(_, s)| s).collect()+}++/// `s` lowercased, without anything but letters and digits.+pub(super) fn norm_chars(s: &str) -> impl Iterator<Item = char> + '_ {+ s.chars().filter(|c| c.is_alphanumeric()).flat_map(char::to_lowercase)+}++pub(super) fn norm(s: &str) -> String {+ norm_chars(s).collect()+}diff --git a/crates/text/src/fontdb/scan.rs b/crates/text/src/fontdb/scan.rsnew file mode 100644index 000000000..321b282ea--- /dev/null+++ b/crates/text/src/fontdb/scan.rs@@ -0,0 +1,235 @@+use super::build::{style_italic, style_weight};+#[cfg(not(target_arch = "wasm32"))]+use super::dirs::sfnt_of;+use super::face::{MAX_AXES, MAX_INSTANCES};+use super::names::{all_names, name, norm};+use super::traits::{FaceKeys, FaceStyle, FontTraits, face_styles};+use super::*;++/// The named instances of a variable font face (its `fvar` table) as styles of the face's family,+/// named by their subfamily names, without the default instance (the face itself) and without+/// names already taken. The default instance's name, when it isn't the face's style name (a face+/// `Regular` whose default instance is `Book`), names the face too (`keys`). Damaged tables give+/// fewer instances or none; the counts read are capped.+pub(super) fn named_instances(+ f: &skrifa::FontRef<'_>,+ family: &str,+ style: &str,+ keys: &mut FaceKeys,+ native_family: Option<String>,+) -> (Vec<FaceStyle>, Option<String>) {+ let axes = f.axes();+ if axes.is_empty() || axes.len() > MAX_AXES {+ return (vec![], None);+ }+ let tags: Vec<Tag> = axes.iter().map(|a| a.tag()).collect();+ let defaults: Vec<f32> = axes.iter().map(|a| a.default_value()).collect();+ let is_default = |coords: &[f32]| coords.len() == defaults.len() && coords.iter().zip(&defaults).all(|(c, d)| (c - d).abs() < 1e-3);+ // The face renders as its default instance. When that instance is another weight than the+ // name table says (`Light` face, Regular default instance), the instance names the face.+ let renamed = tags.iter().any(|t| t.to_be_bytes() == *b"wght").then(|| {+ f.named_instances()+ .iter()+ .take(MAX_INSTANCES)+ .filter(|inst| is_default(&inst.user_coords().take(MAX_AXES).collect::<Vec<f32>>()))+ .find_map(|inst| name(f, &[inst.subfamily_name_id()]))+ .filter(|d| style_weight(d) != style_weight(style))+ });+ let renamed = renamed.flatten();+ // Instances without a PostScript name of their own are named `<prefix>-<style>` (Adobe+ // Technical Note #5902), as PDF and `.ai` files name them.+ let prefix = name(f, &[StringId::VARIATIONS_POSTSCRIPT_NAME_PREFIX]).unwrap_or_else(|| family.to_string());+ if let Some(new) = &renamed {+ let old = norm(style);+ keys.styles.retain(|k| *k != old);+ keys.styles.push(norm(new));+ }+ let mut taken = vec![norm(renamed.as_deref().unwrap_or(style))];+ let mut out = Vec::new();+ for inst in f.named_instances().iter().take(MAX_INSTANCES) {+ let coords: Vec<f32> = inst.user_coords().take(MAX_AXES).collect();+ if coords.len() != tags.len() || coords.iter().any(|c| !c.is_finite()) {+ continue;+ }+ let Some(style) = name(f, &[inst.subfamily_name_id()]) else { continue };+ let ns = norm(&style);+ if ns.is_empty() || taken.contains(&ns) {+ continue;+ }+ // The default instance is the face itself.+ if coords.iter().zip(&defaults).all(|(c, d)| (c - d).abs() < 1e-3) {+ keys.styles.push(ns.clone());+ keys.postscript.push(norm(&format!("{prefix}{style}")));+ taken.push(ns);+ continue;+ }+ taken.push(ns);+ let axis = |tag: &[u8; 4]| tags.iter().zip(&coords).find(|(t, _)| t.to_be_bytes() == *tag).map(|(_, v)| *v);+ let weight = axis(b"wght").map(|w| w.clamp(1.0, 1000.0));+ let italic = style_italic(&style) || axis(b"ital").is_some_and(|v| v >= 0.5) || axis(b"slnt").is_some_and(|v| v != 0.0);+ let mut styles: Vec<String> = std::iter::once(style.clone()).chain(all_names(f, inst.subfamily_name_id())).map(|s| norm(&s)).collect();+ let mut postscript: Vec<String> = inst.postscript_name_id().map(|id| all_names(f, id)).unwrap_or_default().iter().map(|n| norm(n)).collect();+ postscript.push(norm(&format!("{prefix}{style}")));+ for v in [&mut styles, &mut postscript] {+ v.retain(|k| !k.is_empty());+ v.sort();+ v.dedup();+ }+ // Name ID 4 describes the default face, not every named instance of its variable font.+ let keys = FaceKeys { families: keys.families.clone(), styles, legacy: vec![], full_names: vec![], postscript };+ let variations = tags.iter().zip(&coords).map(|(t, v)| (t.to_be_bytes(), *v)).collect();+ out.push(FaceStyle {+ family: family.to_string(),+ native_family: native_family.clone(),+ style,+ keys,+ variations,+ weight,+ italic,+ traits: FontTraits::default(),+ });+ }+ (out, renamed)+}++/// The most faces read from a (possibly damaged) collection.+pub(super) const MAX_FACES: u32 = 256;++/// Parse every face in `data` (a font file or collection) and the named instances of its variable+/// ones. Returns each style with the index of its face.+pub(super) fn enumerate_faces(data: &[u8]) -> Vec<(u32, FaceStyle)> {+ let count = match FileRef::new(data) {+ Ok(FileRef::Font(_)) => 1,+ Ok(FileRef::Collection(c)) => c.len().min(MAX_FACES),+ Err(_) => 0,+ };+ (0..count)+ .filter_map(|i| Some((i, skrifa::FontRef::from_index(data, i).ok()?)))+ .flat_map(|(i, f)| face_styles(&f).into_iter().map(move |s| (i, s)))+ .collect()+}++/// The font files held by the file at `path`: its contents, or for a suitcase font the fonts in+/// its resource fork ([`crate::suitcase`]). None when it can't be read.+#[cfg(not(target_arch = "wasm32"))]+pub(super) fn font_files(path: &Path) -> Vec<Vec<u8>> {+ if crate::suitcase::is_suitcase(path) {+ return crate::suitcase::read_fonts(path);+ }+ std::fs::read(path).into_iter().collect()+}++/// The tables holding glyphs the font engine draws: TrueType, CFF, CFF2 and VARC outlines, and+/// `sbix` and `CBDT` colour bitmaps. A face with none of them (outlines in Apple's `hvgl` table,+/// monochrome bitmaps only) draws nothing.+#[cfg(not(target_arch = "wasm32"))]+const OUTLINE_TABLES: [&[u8; 4]; 6] = [b"glyf", b"CFF ", b"CFF2", b"VARC", b"sbix", b"CBDT"];++/// The styles of every face in the font file at `path` ([`face_styles`]), reading only its table+/// directories and `name`, `fvar` and `OS/2` tables: a scan opens hundreds of font files, many of+/// them megabytes long. Faces without outlines the font engine draws (no [`OUTLINE_TABLES`] table)+/// are left out.+#[cfg(not(target_arch = "wasm32"))]+pub(super) fn file_face_names(path: &Path) -> Vec<FaceStyle> {+ file_face_names_within(path, MAX_FACES, u64::MAX)+}++/// [`file_face_names`], reading at most `max_faces` faces and `max_read` bytes of the file in all.+/// A suitcase font's resource fork is read whole when it is at most `max_read` bytes long, and the+/// limits then apply to each of its fonts; a longer fork gives none.+#[cfg(not(target_arch = "wasm32"))]+pub(crate) fn file_face_names_within(path: &Path, max_faces: u32, max_read: u64) -> Vec<FaceStyle> {+ if crate::suitcase::is_suitcase(path) {+ if crate::suitcase::fork_len(path) > max_read {+ return vec![];+ }+ return crate::suitcase::read_fonts(path)+ .into_iter()+ .flat_map(|font| reader_face_names_within(std::io::Cursor::new(font), max_faces, max_read))+ .collect();+ }+ match std::fs::File::open(path) {+ Ok(file) => reader_face_names_within(file, max_faces, max_read),+ Err(_) => vec![],+ }+}++/// [`file_face_names_within`] for the font file `file` reads.+#[cfg(not(target_arch = "wasm32"))]+fn reader_face_names_within(mut file: impl std::io::Read + std::io::Seek, max_faces: u32, max_read: u64) -> Vec<FaceStyle> {+ use std::io::SeekFrom;+ /// The largest table read from a (possibly damaged) file.+ const MAX_NAME_TABLE: u32 = 1 << 20;+ let mut read = 0u64;+ let mut read_at = |offset: u64, len: usize| -> Option<Vec<u8>> {+ read = read.checked_add(u64::try_from(len).ok()?).filter(|r| *r <= max_read)?;+ 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)?;+ if !records.as_chunks::<16>().0.iter().any(|r| OUTLINE_TABLES.iter().any(|t| r.starts_with(*t))) {+ return None;+ }+ let mut table = |tag: &[u8; 4]| -> Option<Vec<u8>> {+ let rec: &[u8] = records.as_chunks::<16>().0.iter().find(|r| r.starts_with(tag))?;+ let (offset, len) = (be32(rec, 8)?, be32(rec, 12)?);+ if len > MAX_NAME_TABLE {+ return None;+ }+ read_at(offset.into(), len as usize)+ };+ let name = table(b"name")?;+ // A variable font's named instances are styles too.+ let fvar = table(b"fvar");+ // Its OS/2 table (the font's classification, for the menus' filters), when it has one.+ let os2 = table(b"OS/2");+ // A font holding just these tables, to read them as the font itself would.+ let mut tables: Vec<(&[u8; 4], &[u8])> = vec![(b"name", &name)];+ if let Some(fvar) = &fvar {+ tables.push((b"fvar", fvar));+ }+ if let Some(os2) = &os2 {+ tables.push((b"OS/2", os2));+ }+ let font = sfnt_of(&tables)?;+ Some(face_styles(&skrifa::FontRef::new(&font).ok()?))+ })+ .flatten()+ .collect()+}++/// Whether the file at `path` is a font file by its extension (`.ttf`, `.otf`, `.ttc` or `.otc`,+/// in any case), as the font scan reads the files in a folder.+pub fn is_font_file(path: &Path) -> bool {+ path.extension().and_then(|e| e.to_str()).is_some_and(|e| ["ttf", "otf", "ttc", "otc"].iter().any(|x| e.eq_ignore_ascii_case(x)))+}++/// Whether the file at `path` is a suitcase font ([`crate::suitcase`]): on macOS, a file with+/// nothing in its data and its fonts in its resource fork. Never on the web.+pub fn is_suitcase(path: &Path) -> bool {+ #[cfg(not(target_arch = "wasm32"))]+ {+ crate::suitcase::is_suitcase(path)+ }+ #[cfg(target_arch = "wasm32")]+ {+ let _ = path;+ false+ }+}diff --git a/crates/text/src/fontdb/traits.rs b/crates/text/src/fontdb/traits.rsnew file mode 100644index 000000000..2d6b8c6e1--- /dev/null+++ b/crates/text/src/fontdb/traits.rs@@ -0,0 +1,363 @@+use super::face::{MAX_AXES, Variation};+use super::names::{MAX_LEGACY_NAMES, all_names, localized, name, native_family_name, norm};+use super::scan::named_instances;+use super::*;++/// The names a face answers to besides its (English) family and style, normalized ([`norm`]):+/// its family in every language (typographic, else legacy: `ヒラギノ角ゴシック`), its style likewise+/// (`ミディアム`), its legacy family names (`Hiragino Sans W3`) with their legacy styles, paired per+/// language record (the Mac and Windows records of a face differ), its full names (name ID 4),+/// and its PostScript names (`HiraginoSans-W3`, as PDF and `.ai` files name fonts).+#[derive(Clone, Debug, Default)]+pub(super) struct FaceKeys {+ pub(super) families: Vec<String>,+ pub(super) styles: Vec<String>,+ pub(super) legacy: Vec<(String, String)>,+ pub(super) full_names: Vec<String>,+ pub(super) postscript: Vec<String>,+}++impl FaceKeys {+ pub(super) fn of(font: &skrifa::FontRef<'_>, family: &str, style: &str) -> Self {+ let (typo_family, typo_style) = (all_names(font, StringId::TYPOGRAPHIC_FAMILY_NAME), all_names(font, StringId::TYPOGRAPHIC_SUBFAMILY_NAME));+ let (mut legacy_family, mut legacy_style) = (localized(font, StringId::FAMILY_NAME), localized(font, StringId::SUBFAMILY_NAME));+ // Records repeat (platforms, encodings) and are paired below: once each, and no more than a+ // font has any use for, or the pairs multiply.+ for names in [&mut legacy_family, &mut legacy_style] {+ names.sort();+ names.dedup();+ names.truncate(MAX_LEGACY_NAMES);+ }+ // Without typographic names, the legacy ones are the family's.+ let family_names: Vec<&str> = if typo_family.is_empty() {+ legacy_family.iter().map(|(_, f)| f.as_str()).collect()+ } else {+ typo_family.iter().map(String::as_str).collect()+ };+ let mut families: Vec<String> = std::iter::once(family).chain(family_names).map(norm).collect();+ // A legacy style only names the face beside its legacy family when the font has a+ // typographic style: every weight of `Hiragino Sans` is `Regular` in its own legacy family.+ let style_names: Vec<&str> = if typo_style.is_empty() {+ legacy_style.iter().map(|(_, s)| s.as_str()).collect()+ } else {+ typo_style.iter().map(String::as_str).collect()+ };+ let mut styles: Vec<String> = std::iter::once(style).chain(style_names).map(norm).collect();+ let mut legacy: Vec<(String, String)> = if typo_family.is_empty() {+ vec![]+ } else {+ legacy_family+ .iter()+ .flat_map(|(lf, f)| legacy_style.iter().filter(move |(ls, _)| ls == lf).map(move |(_, s)| (norm(f), norm(s))))+ .filter(|(f, s)| !f.is_empty() && !s.is_empty())+ .collect()+ };+ let mut postscript: Vec<String> = all_names(font, StringId::POSTSCRIPT_NAME).iter().map(|n| norm(n)).collect();+ let mut full_names: Vec<String> = all_names(font, StringId::FULL_NAME).iter().map(|n| norm(n)).collect();+ for v in [&mut families, &mut styles, &mut full_names, &mut postscript] {+ v.retain(|k| !k.is_empty());+ v.sort();+ v.dedup();+ }+ legacy.sort();+ legacy.dedup();+ FaceKeys { families, styles, legacy, full_names, postscript }+ }+}++/// A font's kind, for filtering font menus: the classification of its OS/2 table (IBM family+/// class, PANOSE) and, for CJK fonts whose tables seldom say, its names (明朝, ゴシック, 丸…).+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]+pub enum FontClass {+ /// Serif (Latin) or Mincho (CJK).+ Serif,+ /// Sans serif (Latin) or Gothic (CJK).+ Sans,+ /// Rounded sans / Maru Gothic.+ Rounded,+ /// Script, handwriting, brush (楷書・行書・教科書…).+ Script,+ Monospaced,+ /// Decorative, display, symbol and pictorial fonts.+ Decorative,+ #[default]+ Other,+}++impl FontClass {+ /// The kinds a font menu filters by (all but `Other`).+ pub const ALL: [FontClass; 6] =+ [FontClass::Serif, FontClass::Sans, FontClass::Rounded, FontClass::Script, FontClass::Monospaced, FontClass::Decorative];+}++/// What a font menu filters on: whether a family sets Japanese or Thai, its kind, and whether it+/// is a variable font.+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]+pub struct FontTraits {+ pub japanese: bool,+ /// Its character map has Thai (ก and า).+ pub thai: bool,+ pub class: FontClass,+ /// The face has variation axes (an `fvar` table of at most 64 axes); for a family, one of+ /// its faces has.+ pub variable: bool,+}++impl FontTraits {+ /// From a face's OS/2 and `fvar` tables (when it has them) and names.+ fn of(font: &skrifa::FontRef<'_>, keys: &FaceKeys) -> Self {+ use skrifa::raw::TableProvider;+ let os2 = font.os2().ok();+ let names: Vec<&str> = keys.families.iter().chain(&keys.postscript).map(String::as_str).collect();+ let named = |words: &[&str]| names.iter().any(|n| words.iter().any(|w| n.contains(w)));+ let has_japanese_name = keys.families.iter().any(|k| k.chars().any(|c| matches!(c as u32, 0x3040..=0x30FF | 0x4E00..=0x9FFF)));+ let (class_id, panose, ranges2, codepages) = match &os2 {+ Some(o) => (o.s_family_class(), o.panose_10().to_vec(), o.ul_unicode_range_2(), o.ul_code_page_range_1().unwrap_or(0)),+ None => (0, vec![], 0, 0),+ };+ // Hiragana (bit 49) or Katakana (bit 50) in the Unicode ranges, or the JIS code page.+ let japanese = ranges2 & (0b11 << 17) != 0 || codepages & (1 << 17) != 0 || has_japanese_name;+ let thai = ['\u{0E01}', '\u{0E32}'].iter().all(|c| font.charmap().map(*c).is_some());+ let family_type = panose.first().copied().unwrap_or(0);+ let serif_style = panose.get(1).copied().unwrap_or(0);+ let proportion = panose.get(3).copied().unwrap_or(0);+ let ibm = (class_id >> 8) as u8;+ let class = if named(&["丸", "maru", "rounded", "round"]) || japanese && named(&["jun"]) {+ FontClass::Rounded+ } else if named(&[+ "楷書",+ "行書",+ "草書",+ "隷書",+ "教科書",+ "毛筆",+ "筆",+ "kaisho",+ "gyosho",+ "sosho",+ "reisho",+ "kyokasho",+ "brush",+ "script",+ "hand",+ "kaiti",+ "xingkai",+ "libian",+ ]) {+ FontClass::Script+ } else if named(&["mono", "code", "courier", "menlo", "consol"]) {+ FontClass::Monospaced+ } else if named(&[+ "明朝",+ "mincho",+ "ryumin",+ "hiramin",+ "yumin",+ "kozmin",+ "serif",+ "songti",+ "simsun",+ "stsong",+ "fangsong",+ "myungjo",+ "times",+ "georgia",+ "garamond",+ "baskerville",+ "bodoni",+ "caslon",+ "palatino",+ "didot",+ "century",+ "cambria",+ "minion",+ "charter",+ "hoefler",+ ]) && !named(&["sansserif", "sans"])+ {+ FontClass::Serif+ } else if named(&[+ "ゴシック",+ "gothic",+ "goth",+ "sans",+ "kakugo",+ "kaku",+ "heiti",+ "helvetica",+ "arial",+ "grotesk",+ "grotesque",+ "futura",+ "gill",+ "verdana",+ "tahoma",+ "frutiger",+ "avenir",+ "geneva",+ "lucidagrande",+ "inter",+ "roboto",+ "optima",+ "pingfang",+ ]) {+ FontClass::Sans+ } else if family_type == 2 && proportion == 9 {+ FontClass::Monospaced+ } else if family_type == 3 || ibm == 10 {+ FontClass::Script+ } else if family_type == 4 || family_type == 5 || ibm == 9 || ibm == 12 {+ FontClass::Decorative+ } else if matches!(ibm, 1..=5 | 7) || family_type == 2 && (2..=10).contains(&serif_style) {+ FontClass::Serif+ } else if ibm == 8 || family_type == 2 && (11..=13).contains(&serif_style) {+ FontClass::Sans+ } else {+ FontClass::Other+ };+ let variable = (1..=MAX_AXES).contains(&font.axes().len());+ FontTraits { japanese, thai, class, variable }+ }+}++/// What a name other than a family's own one stands for ([`FontDb::canonical`]).+#[derive(Clone, Debug)]+pub(super) struct Alias {+ /// The family's own name.+ pub(super) family: String,+ /// The face the name names, for legacy family names, full names and PostScript names.+ pub(super) style: Option<String>,+ /// A legacy family name's legacy style (`Regular` beside `Hiragino Sans W3`).+ pub(super) paired: Option<String>,+}++impl Alias {+ /// The aliases of a face `family` / `style` with `keys`, by normalized name.+ pub(super) fn of(family: &str, style: &str, keys: &FaceKeys) -> Vec<(String, Alias)> {+ #[cfg(test)]+ ALIAS_LISTS.with(|c| c.set(c.get() + 1));+ let mut v: Vec<(String, Alias)> =+ keys.families.iter().map(|k| (k.clone(), Alias { family: family.to_string(), style: None, paired: None })).collect();+ v.extend(+ keys.legacy+ .iter()+ .map(|(f, s)| (f.clone(), Alias { family: family.to_string(), style: Some(style.to_string()), paired: Some(s.clone()) })),+ );+ v.extend(+ keys.postscript+ .iter()+ .chain(&keys.full_names)+ .map(|k| (k.clone(), Alias { family: family.to_string(), style: Some(style.to_string()), paired: None })),+ );+ v+ }+}++#[cfg(test)]+thread_local! {+ /// Tests: counts the faces whose aliases ([`Alias::of`]) were listed on this thread.+ static ALIAS_LISTS: std::cell::Cell<u64> = const { std::cell::Cell::new(0) };+}++/// Tests: returns how many faces' aliases were listed on this thread.+#[cfg(test)]+pub(crate) fn alias_lists() -> u64 {+ ALIAS_LISTS.with(std::cell::Cell::get)+}++#[cfg(test)]+thread_local! {+ /// Tests: run on this thread each time it publishes faces to a database, to look the database+ /// up at exactly that point (as another thread could).+ static ON_FACES_PUBLISHED: std::cell::RefCell<Option<Box<dyn FnMut()>>> = const { std::cell::RefCell::new(None) };+}++/// Tests: run `hook` each time this thread publishes faces to a database.+#[cfg(test)]+pub(crate) fn on_faces_published(hook: Option<Box<dyn FnMut()>>) {+ ON_FACES_PUBLISHED.with(|h| *h.borrow_mut() = hook);+}++#[cfg(test)]+pub(super) fn faces_published() {+ // Taken out while it runs, so a hook that adds faces itself doesn't run again.+ if let Some(mut hook) = ON_FACES_PUBLISHED.with(|h| h.borrow_mut().take()) {+ hook();+ ON_FACES_PUBLISHED.with(|h| {+ h.borrow_mut().get_or_insert(hook);+ });+ }+}++/// How a requested family and style resolved ([`FontDb::resolve`]).+#[derive(Clone, Copy, Debug, PartialEq, Eq)]+pub enum FontMatch {+ /// The face of that family and style (by any of its names, in any language).+ Exact,+ /// The family is there but not the style: its closest style stands in.+ Style,+ /// The family is unknown: the fallback family stands in.+ Missing,+}++impl FontMatch {+ pub fn as_str(self) -> &'static str {+ match self {+ FontMatch::Exact => "exact",+ FontMatch::Style => "substitute",+ FontMatch::Missing => "missing",+ }+ }+}++/// A face's (family, style) names.+pub(super) 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))+}++/// One style a font file offers: one of its faces, or a named instance of a variable font+/// (Figtree's `Figtree[wght].ttf` holds Light, the default, and Regular to Black as instances).+#[derive(Clone, Debug)]+pub(crate) struct FaceStyle {+ pub(super) family: String,+ /// See [`FontFace::native_family`].+ pub(super) native_family: Option<String>,+ pub(super) style: String,+ pub(super) keys: FaceKeys,+ /// A named instance's axis settings (user units); empty for the face itself.+ pub(super) variations: Vec<Variation>,+ /// A named instance's weight (its `wght` setting); `None` for the face itself (its OS/2 table+ /// says) or an instance of a font without a weight axis.+ pub(super) weight: Option<f32>,+ /// A named instance is italic (by its `ital` or `slnt` setting, or its name).+ pub(super) italic: bool,+ /// Its kind, for font menus' filters (the face's, shared by its named instances).+ pub(super) traits: FontTraits,+}++/// The styles of a face: the face itself, then its named instances when it is a variable font.+pub(crate) fn face_styles(f: &skrifa::FontRef<'_>) -> Vec<FaceStyle> {+ let Some((family, style)) = face_names(f) else { return vec![] };+ let native_family = native_family_name(f, &family);+ let mut keys = FaceKeys::of(f, &family, &style);+ let traits = FontTraits::of(f, &keys);+ let (mut instances, renamed) = named_instances(f, &family, &style, &mut keys, native_family.clone());+ for i in &mut instances {+ i.traits = traits;+ }+ // A variable font's default face renders at its `wght` default, whatever its name table and+ // OS/2 table say (Noto Sans Hebrew: named `Light`, weight class 300, default instance Regular+ // at 400): weigh it so, and name it by its default instance when that is another weight.+ let weight = f+ .axes()+ .iter()+ .find(|a| a.tag().to_be_bytes() == *b"wght")+ .map(|a| a.default_value())+ .filter(|w| w.is_finite())+ .map(|w| w.clamp(1.0, 1000.0));+ let style = renamed.unwrap_or(style);+ let face = FaceStyle { family, native_family, style, keys, variations: vec![], weight, italic: false, traits };+ std::iter::once(face).chain(instances).collect()+}diff --git a/crates/text/src/fontdb/wanted.rs b/crates/text/src/fontdb/wanted.rsnew file mode 100644index 000000000..d06f129e4--- /dev/null+++ b/crates/text/src/fontdb/wanted.rs@@ -0,0 +1,141 @@+use super::names::norm;+#[cfg(not(target_arch = "wasm32"))]+use super::scan::{file_face_names_within, is_font_file};+use super::traits::FaceStyle;+use super::*;++/// A font a document names that isn't available, to look for in font files ([`WantedFonts`]).+#[derive(Clone, Debug, PartialEq, Eq)]+pub struct WantedFont {+ pub family: String,+ pub style: String,+ /// When the family is installed but not the style ([`FontMatch::Style`]): the family of the+ /// face [`FontDb::resolve`] gives instead. `None` when the family is missing.+ pub installed: Option<String>,+}++/// Fonts to look for in font files: [`WantedFonts::provided_by`] tells which of them a file+/// provides.+#[derive(Debug, Default)]+#[cfg_attr(target_arch = "wasm32", allow(dead_code))]+pub struct WantedFonts {+ fonts: Vec<WantedFont>,+ /// The indexes of the fonts by every name a face could answer to them by: the family as given+ /// and the installed family (ASCII-lowercased), and the family normalized ([`norm`]).+ by_name: HashMap<String, Vec<usize>>,+}++impl WantedFonts {+ /// The most faces and bytes of one file a search reads.+ #[cfg(not(target_arch = "wasm32"))]+ const SEARCH_FACES: u32 = 64;+ #[cfg(not(target_arch = "wasm32"))]+ const SEARCH_READ: u64 = 8 << 20;++ pub fn new(fonts: &[WantedFont]) -> Self {+ let mut by_name: HashMap<String, Vec<usize>> = HashMap::new();+ for (i, w) in fonts.iter().enumerate() {+ let mut names = vec![w.family.to_ascii_lowercase(), norm(&w.family)];+ names.extend(w.installed.as_ref().map(|c| c.to_ascii_lowercase()));+ names.sort();+ names.dedup();+ for n in names.into_iter().filter(|n| !n.is_empty()) {+ by_name.entry(n).or_default().push(i);+ }+ }+ Self { fonts: fonts.to_vec(), by_name }+ }++ pub fn len(&self) -> usize {+ self.fonts.len()+ }++ pub fn is_empty(&self) -> bool {+ self.fonts.is_empty()+ }++ /// The indexes of the fonts that the font file at `path` provides: copied into a folder the+ /// font scan reads, the file makes [`FontDb::resolve`] find each of them exactly, in one of its+ /// faces or a variable font's named instances. The file is read as the scan reads it (its+ /// table directories and its `name`, `fvar` and `OS/2` tables), at most 64 faces and 8 MB of+ /// it, when it is a font file by its extension ([`is_font_file`]) or a suitcase font whose+ /// resource fork is at most 8 MB long. Sorted; none on the web.+ pub fn provided_by(&self, path: &Path) -> Vec<usize> {+ #[cfg(not(target_arch = "wasm32"))]+ {+ if !is_font_file(path) && !crate::suitcase::is_suitcase(path) {+ return Vec::new();+ }+ let faces = file_face_names_within(path, Self::SEARCH_FACES, Self::SEARCH_READ);+ self.provided_by_faces(&faces)+ }+ #[cfg(target_arch = "wasm32")]+ {+ let _ = path;+ Vec::new()+ }+ }++ /// [`Self::provided_by`] for the faces of a file.+ #[cfg_attr(target_arch = "wasm32", allow(dead_code))]+ fn provided_by_faces(&self, faces: &[FaceStyle]) -> Vec<usize> {+ let mut candidates: Vec<usize> = Vec::new();+ for f in faces {+ let names = std::iter::once(f.family.to_ascii_lowercase())+ .chain(f.keys.families.iter().cloned())+ .chain(f.keys.legacy.iter().map(|(family, _)| family.clone()))+ .chain(f.keys.full_names.iter().cloned())+ .chain(f.keys.postscript.iter().cloned());+ for n in names {+ candidates.extend(self.by_name.get(&n).into_iter().flatten());+ }+ }+ candidates.sort_unstable();+ candidates.dedup();+ candidates.retain(|i| self.fonts.get(*i).is_some_and(|w| provides(w, faces)));+ candidates+ }+}++/// Whether the faces of a font file, cataloged by a rescan, make [`FontDb::resolve`] find `w`+/// exactly in one of them: [`FontDb::canonical`] and [`FontDb::find`] over these faces, as they+/// would run once the file is cataloged.+#[cfg_attr(target_arch = "wasm32", allow(dead_code))]+fn provides(w: &WantedFont, faces: &[FaceStyle]) -> bool {+ let sk = norm(&w.style);+ // A face of `family` with the style among its style names, as `find` looks for it once the+ // family's files are loaded.+ let styled = |family: &str| faces.iter().any(|f| f.family.eq_ignore_ascii_case(family) && f.keys.styles.contains(&sk));+ let named_as_given = faces.iter().any(|f| f.family.eq_ignore_ascii_case(&w.family));+ if let Some(installed) = &w.installed {+ // A family cataloged by the name as given is found by it.+ if named_as_given && !w.family.eq_ignore_ascii_case(installed) {+ return styled(&w.family);+ }+ // The installed family is loaded: a face of it is loaded from the file only when its own+ // style is the one asked for (`is_cataloged`).+ return faces.iter().any(|f| f.family.eq_ignore_ascii_case(installed) && norm(&f.style) == sk);+ }+ if named_as_given {+ return styled(&w.family);+ }+ let key = norm(&w.family);+ if key.is_empty() {+ return false;+ }+ // Another of a family's names keeps the style asked for.+ if let Some(f) = faces.iter().find(|f| f.keys.families.contains(&key)) {+ return styled(&f.family);+ }+ // A legacy family with its legacy style, a full name or a PostScript name names its face+ // whatever style is asked for.+ if faces.iter().any(|f| {+ f.keys.legacy.iter().any(|(family, style)| *family == key && *style == sk)+ || f.keys.full_names.contains(&key)+ || f.keys.postscript.contains(&key)+ }) {+ return true;+ }+ // A legacy family with another style: that style of the family.+ faces.iter().find(|f| f.keys.legacy.iter().any(|(family, _)| *family == key)).is_some_and(|f| styled(&f.family))+}