Struct FcFontCache 

pub struct FcFontCache { /* private fields */ }

Font cache, initialized at startup

Implementations

impl FcFontCache

pub fn with_memory_fonts( &mut self, fonts: Vec<(FcPattern, FcFont)>, ) -> &mut Self

Adds in-memory font files

pub fn with_memory_font_with_id( &mut self, id: FontId, pattern: FcPattern, font: FcFont, ) -> &mut Self

Adds a memory font with a specific ID (for testing)

pub fn get_font_by_id(&self, id: &FontId) -> Option<FontSource<'_>>

Get font data for a given font ID

pub fn get_metadata_by_id(&self, id: &FontId) -> Option<&FcPattern>

Get metadata directly from an ID

pub fn get_font_bytes(&self, id: &FontId) -> Option<Vec<u8>>

Get font bytes (either from disk or memory)

pub fn build() -> Self

Builds a new font cache from all fonts discovered on the system

Examples found in repository

examples/query.rs (line 5)

fn main() {
    println!("building cache...");
    let cache = FcFontCache::build();
    println!("cache built!");
    let list = cache.list();
    println!("{} fonts:", list.len());
    let fonts = cache.query_all(
        &FcPattern {
            monospace: PatternMatch::True,
            ..Default::default()
        },
        &mut Vec::new(),
    );

    println!("total fonts: {}", fonts.len());

    if let Some(first) = fonts.first() {
        println!("MATCH: {:#?}", first);
    }
}

examples/getfont.rs (line 6)

fn main() {
    let start = Instant::now();
    let cache = FcFontCache::build();
    let end = Instant::now();

    println!("cache list: found {} fonts", cache.list().len());

    let start2 = Instant::now();
    let results = cache.query(
        &FcPattern {
            name: Some(String::from("Gilroy")),
            ..Default::default()
        },
        &mut Vec::new(),
    );
    let end2 = Instant::now();

    println!("built cache in: {:?}", end - start);
    println!("queried in {:?}", end2 - start2);
}

pub fn list(&self) -> Vec<(&FcPattern, FontId)>

Returns the list of fonts and font patterns

Examples found in repository

examples/query.rs (line 7)

fn main() {
    println!("building cache...");
    let cache = FcFontCache::build();
    println!("cache built!");
    let list = cache.list();
    println!("{} fonts:", list.len());
    let fonts = cache.query_all(
        &FcPattern {
            monospace: PatternMatch::True,
            ..Default::default()
        },
        &mut Vec::new(),
    );

    println!("total fonts: {}", fonts.len());

    if let Some(first) = fonts.first() {
        println!("MATCH: {:#?}", first);
    }
}

examples/getfont.rs (line 9)

fn main() {
    let start = Instant::now();
    let cache = FcFontCache::build();
    let end = Instant::now();

    println!("cache list: found {} fonts", cache.list().len());

    let start2 = Instant::now();
    let results = cache.query(
        &FcPattern {
            name: Some(String::from("Gilroy")),
            ..Default::default()
        },
        &mut Vec::new(),
    );
    let end2 = Instant::now();

    println!("built cache in: {:?}", end - start);
    println!("queried in {:?}", end2 - start2);
}

pub fn query( &self, pattern: &FcPattern, trace: &mut Vec<TraceMsg>, ) -> Option<FontMatch>

Queries a font from the in-memory cache, returns the first found font (early return)

Examples found in repository

examples/getfont.rs (lines 12-18)

fn main() {
    let start = Instant::now();
    let cache = FcFontCache::build();
    let end = Instant::now();

    println!("cache list: found {} fonts", cache.list().len());

    let start2 = Instant::now();
    let results = cache.query(
        &FcPattern {
            name: Some(String::from("Gilroy")),
            ..Default::default()
        },
        &mut Vec::new(),
    );
    let end2 = Instant::now();

    println!("built cache in: {:?}", end - start);
    println!("queried in {:?}", end2 - start2);
}

pub fn query_all( &self, pattern: &FcPattern, trace: &mut Vec<TraceMsg>, ) -> Vec<FontMatch>

Queries all fonts matching a pattern

Examples found in repository

examples/query.rs (lines 9-15)

fn main() {
    println!("building cache...");
    let cache = FcFontCache::build();
    println!("cache built!");
    let list = cache.list();
    println!("{} fonts:", list.len());
    let fonts = cache.query_all(
        &FcPattern {
            monospace: PatternMatch::True,
            ..Default::default()
        },
        &mut Vec::new(),
    );

    println!("total fonts: {}", fonts.len());

    if let Some(first) = fonts.first() {
        println!("MATCH: {:#?}", first);
    }
}

pub fn query_for_text( &self, pattern: &FcPattern, text: &str, trace: &mut Vec<TraceMsg>, ) -> Vec<FontMatch>

Find fonts that can render the given text, considering Unicode ranges

pub fn get_memory_font(&self, id: &FontId) -> Option<&FcFont>

Get in-memory font data

Trait Implementations

impl Clone for FcFontCache

fn clone(&self) -> FcFontCache

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for FcFontCache

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

Formats the value using the given formatter.

impl Default for FcFontCache

fn default() -> FcFontCache

Returns the “default value” for a type.