Struct FontManager 

pub struct FontManager<T> {
    pub fc_cache: FcFontCache,
    pub parsed_fonts: Arc<Mutex<HashMap<FontId, T>>>,
    pub font_chain_cache: HashMap<FontChainKey, FontFallbackChain>,
    pub embedded_fonts: Mutex<HashMap<u64, FontRef>>,
    pub font_hash_to_families: HashMap<u64, StyleFontFamilyVec>,
    pub registry: Option<Arc<FcFontRegistry>>,
    pub last_resolved_font_stacks_sig: Option<u64>,
}

Fields

fc_cache: FcFontCache

The font-path cache. FcFontCache in rust-fontconfig 4.1 is already a shared handle internally (Arc<RwLock<_>>), so no further Arc<...> wrapping is needed — clones are cheap and all clones see builder writes instantly.

parsed_fonts: Arc<Mutex<HashMap<FontId, T>>>

Holds the actual parsed font (usually with the font bytes attached). Wrapped in Arc so multiple FontManager instances can share the same pool of already-parsed fonts (avoids re-reading from disk).

font_chain_cache: HashMap<FontChainKey, FontFallbackChain>

embedded_fonts: Mutex<HashMap<u64, FontRef>>

Cache for direct FontRefs (embedded fonts like Material Icons) These are fonts referenced via FontStack::Ref that bypass fontconfig

font_hash_to_families: HashMap<u64, StyleFontFamilyVec>

Reverse map: font_family_hash → actual StyleFontFamilyVec. Accumulated across DOMs. Used by font collection and text shaping to resolve compact cache hashes without get_property_slow.

registry: Option<Arc<FcFontRegistry>>

Optional link back to the live FcFontRegistry. When present, chain resolution uses rust_fontconfig::registry::FcFontRegistry::request_and_resolve_with_scripts which lazy-parses system fonts as the DOM requests them (scout-on-demand). None falls back to querying whatever is already in the shared cache.

last_resolved_font_stacks_sig: Option<u64>

FxHash of the prev_font_hashes slice at the moment the last successful collect_and_resolve_font_chains_with_registration call populated font_chain_cache. Lets repeated layouts of the same DOM skip the ~1.5 ms (cold) / ~0.9 ms (warm) chain resolver when the set of font-family hashes has not changed. Cleared whenever font_chain_cache is explicitly emptied.

Implementations

impl<T: ParsedFontTrait> FontManager<T>

pub fn new(fc_cache: FcFontCache) -> Result<Self, LayoutError>

pub fn from_shared(fc_cache: FcFontCache) -> Result<Self, LayoutError>

Create a FontManager sharing the font-path cache handle.

The parsed_fonts pool starts empty. Fonts loaded during the first layout pass are cached and will be available on subsequent calls if you clone the parsed_fonts Arc before creating the next instance. For full sharing, prefer from_arc_shared().

pub fn from_arc_shared( fc_cache: FcFontCache, parsed_fonts: Arc<Mutex<HashMap<FontId, T>>>, ) -> Result<Self, LayoutError>

Create a FontManager sharing both the font-path cache and the already-parsed font data with another FontManager.

This avoids re-reading and re-parsing font files from disk when rendering multiple documents that use the same fonts.

pub fn with_registry(self, registry: Arc<FcFontRegistry>) -> Self

Attach a FcFontRegistry to this FontManager so subsequent chain-resolution calls use the on-demand path (rust_fontconfig::registry::FcFontRegistry::request_and_resolve_with_scripts).

pub fn shared_parsed_fonts(&self) -> Arc<Mutex<HashMap<FontId, T>>>

Get a shareable handle to the parsed-font pool.

Pass this to from_arc_shared() to create a new FontManager that reuses already-parsed fonts.

pub fn set_font_chain_cache( &mut self, chains: HashMap<FontChainKey, FontFallbackChain>, )

Set the font chain cache from externally resolved chains

This should be called with the result of resolve_font_chains() or collect_and_resolve_font_chains() from solver3::getters.

pub fn set_font_chain_cache_with_sig( &mut self, chains: HashMap<FontChainKey, FontFallbackChain>, sig: Option<u64>, )

Set the font chain cache and record the input signature so subsequent layouts with the same prev_font_hashes skip the resolver. Pass sig = None if the caller cannot compute a reliable signature — equivalent to the single-arg set_font_chain_cache.

pub fn merge_font_chain_cache( &mut self, chains: HashMap<FontChainKey, FontFallbackChain>, )

Merge additional font chains into the existing cache

Useful when processing multiple DOMs that may have different font requirements.

pub fn get_font_chain_cache(&self) -> &HashMap<FontChainKey, FontFallbackChain>

Get a reference to the font chain cache

pub fn get_embedded_font_by_hash(&self, font_hash: u64) -> Option<FontRef>

Get an embedded font by its hash (used for WebRender registration) Returns the FontRef if it exists in the embedded_fonts cache.

pub fn get_font_by_hash(&self, font_hash: u64) -> Option<T>

Get a parsed font by its hash (used for WebRender registration) Returns the parsed font if it exists in the parsed_fonts cache.

pub fn register_embedded_font(&self, font_ref: &FontRef)

Register an embedded FontRef for later lookup by hash This is called when using FontStack::Ref during shaping

pub fn get_loaded_fonts(&self) -> LoadedFonts<T>

Get a snapshot of all currently loaded fonts

This returns a copy of all parsed fonts, which can be passed to the shaper. No locking is required after this call - the returned HashMap is independent.

NOTE: This should be called AFTER loading all required fonts for a layout pass.

pub fn get_loaded_font_ids(&self) -> HashSet<FontId>

Get the set of FontIds that are currently loaded

This is useful for computing which fonts need to be loaded (diff with required fonts).

pub fn insert_font(&self, font_id: FontId, font: T) -> Option<T>

Insert a loaded font into the cache

Returns the old font if one was already present for this FontId.

pub fn insert_fonts(&self, fonts: impl IntoIterator<Item = (FontId, T)>)

Insert multiple loaded fonts into the cache

This is more efficient than calling insert_font multiple times because it only acquires the lock once.

pub fn load_missing_for_chains<F>( &self, chains: &ResolvedFontChains, load_fn: F, ) -> Vec<(FontId, String)>

where F: Fn(Arc<FontBytes>, usize) -> Result<T, LayoutError>,

One-shot helper that resolves “what fonts does chains need that this manager hasn’t loaded yet” and loads them via the supplied load_fn closure (typically PathLoader::load_font_shared for the production lazy-decode path). Updates parsed_fonts in place and returns any failures for the caller to log.

Replaces the same four-step collect → compute_diff → load_from_disk → insert_fonts dance previously inlined in LayoutWindow::layout_document, the CPU rasterizer pre-fill in cpurender.rs, and FontContext::load_fonts_for_chains.

pub fn remove_font(&self, font_id: &FontId) -> Option<T>

Remove a font from the cache

Returns the removed font if it was present.

impl FontManager<FontRef>

pub fn new_with_fc_cache(fc_cache: FcFontCache) -> Result<Self, LayoutError>

pub fn evict_unused(&self, idle: Duration) -> usize

Evict the cached LocaGlyf for every face that hasn’t had a get_or_decode_glyph call within the last idle duration. Only LocaGlyfState::Deferred faces (the production lazy path) can be evicted — they keep their source Arc<[u8]> so the next glyph access re-parses cheaply. LocaGlyfState::Loaded faces from the eager path stay put.

Returns the number of faces evicted. Embedders can call this from a memory-pressure hook or on a timer; servo-shot exposes it via --azul-evict-after-each for measurement.

Trait Implementations

impl<T: Debug> Debug for FontManager<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.