freya-html 0.5.0

HTML + CSS rendering for Freya using Blitz
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

use std::{
    cell::RefCell,
    collections::VecDeque,
    rc::Rc,
    sync::Arc,
};

use freya_core::prelude::{
    Bytes,
    GlobalContexts,
};
use freya_engine::prelude::Typeface;
use parley::fontique::{
    Blob,
    Collection,
    CollectionOptions,
    GenericFamily,
    SourceCache,
};

pub(crate) fn font_context(fonts: &[Bytes]) -> blitz_dom::FontContext {
    let mut context = match GlobalContexts::try_get() {
        Some(contexts) => contexts.get_context_or_insert(system_font_context),
        None => system_font_context(),
    };

    if fonts.is_empty() {
        return context;
    }

    let mut family_ids = Vec::new();
    for data in fonts {
        let decoded = blitz_dom::decode_font_bytes(data).into_owned();
        let registered = context
            .collection
            .register_fonts(Blob::new(Arc::new(decoded) as _), None);
        family_ids.extend(registered.into_iter().map(|(family_id, _)| family_id));
    }
    for generic in [
        GenericFamily::SansSerif,
        GenericFamily::Serif,
        GenericFamily::Monospace,
        GenericFamily::SystemUi,
    ] {
        context
            .collection
            .append_generic_families(generic, family_ids.iter().copied());
    }
    context
}

fn system_font_context() -> blitz_dom::FontContext {
    let mut context = blitz_dom::FontContext {
        source_cache: SourceCache::new_shared(),
        collection: Collection::new(CollectionOptions {
            shared: false,
            system_fonts: !cfg!(target_os = "emscripten"),
        }),
    };
    context
        .collection
        .register_fonts(Blob::new(Arc::new(blitz_dom::BULLET_FONT) as _), None);
    context
}

struct CachedTypeface {
    font: peniko::FontData,
    normalized_coords: Vec<i16>,
    typeface: Typeface,
}

#[derive(Clone, Default)]
pub(crate) struct TypefaceCache {
    resources: Rc<RefCell<VecDeque<CachedTypeface>>>,
}

impl TypefaceCache {
    pub(crate) fn get() -> Self {
        match GlobalContexts::try_get() {
            Some(contexts) => contexts.get_context_or_insert(Self::default),
            None => Self::default(),
        }
    }

    pub(crate) fn read(
        &self,
        font: &peniko::FontData,
        normalized_coords: &[i16],
    ) -> Option<Typeface> {
        let mut resources = self.resources.borrow_mut();
        let index = resources.iter().position(|entry| {
            entry.font.index == font.index
                && entry.font.data.id() == font.data.id()
                && entry.normalized_coords == normalized_coords
        })?;
        let entry = resources.remove(index)?;
        let typeface = entry.typeface.clone();
        resources.push_back(entry);
        Some(typeface)
    }

    pub(crate) fn insert(
        &self,
        font: peniko::FontData,
        normalized_coords: &[i16],
        typeface: Typeface,
    ) {
        let mut resources = self.resources.borrow_mut();
        if resources.len() == 32 {
            resources.pop_front();
        }
        resources.push_back(CachedTypeface {
            font,
            normalized_coords: normalized_coords.to_vec(),
            typeface,
        });
    }
}