read-fonts 0.46.0

Reading OpenType font files.
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

//! The [COLR](https://docs.microsoft.com/en-us/typography/opentype/spec/colr) table

#[cfg(feature = "std")]
mod closure;

use super::variations::{DeltaSetIndexMap, ItemVariationStore};

include!("../../generated/generated_colr.rs");

/// Unique paint identifier used for detecting cycles in the paint graph.
pub type PaintId = usize;

impl<'a> Colr<'a> {
    /// Returns the COLRv0 base glyph for the given glyph identifier.
    ///
    /// The return value is a range of layer indices that can be passed to
    /// [`v0_layer`](Self::v0_layer) to retrieve the layer glyph identifiers
    /// and palette color indices.
    pub fn v0_base_glyph(&self, glyph_id: GlyphId) -> Option<Range<usize>> {
        let records = self.base_glyph_records()?.ok()?;
        let glyph_id = glyph_id.try_into().ok()?;
        let ix = records
            .binary_search_by(|rec| rec.glyph_id().cmp(&glyph_id))
            .ok()?;
        let record = records.get(ix)?;
        let start = record.first_layer_index() as usize;
        Some(start..start.checked_add(record.num_layers() as usize)?)
    }

    /// Returns the COLRv0 layer at the given index.
    ///
    /// The layer is represented by a tuple containing the glyph identifier of
    /// the associated outline and the palette color index.
    pub fn v0_layer(&self, index: usize) -> Option<(GlyphId16, u16)> {
        let layer = self.layer_records()?.ok()?.get(index)?;
        Some((layer.glyph_id(), layer.palette_index()))
    }

    /// Returns the COLRv1 base glyph for the given glyph identifier.
    ///
    /// The second value in the tuple is a unique identifier for the paint that
    /// may be used to detect recursion in the paint graph.
    pub fn v1_base_glyph(&self, glyph_id: GlyphId) -> Option<(Paint<'a>, PaintId)> {
        let glyph_id = glyph_id.try_into().ok()?;
        let list = self.base_glyph_list()?.ok()?;
        let records = list.base_glyph_paint_records();
        let ix = records
            .binary_search_by(|rec| rec.glyph_id().cmp(&glyph_id))
            .ok()?;
        let record = records.get(ix)?;
        let offset_data = list.offset_data();
        // Use the address of the paint as an identifier for the recursion
        // blacklist.
        let id = record.paint_offset().to_u32() as usize + offset_data.as_ref().as_ptr() as usize;
        Some((record.paint(offset_data).ok()?, id))
    }

    /// Returns the COLRv1 layer at the given index.
    ///
    /// The second value in the tuple is a unique identifier for the paint that
    /// may be used to detect recursion in the paint graph.
    pub fn v1_layer(&self, index: usize) -> Option<(Paint<'a>, PaintId)> {
        let list = self.layer_list()?.ok()?;
        let offset = list.paint_offsets().get(index)?.get();
        let offset_data = list.offset_data();
        // Use the address of the paint as an identifier for the recursion
        // blacklist.
        let id = offset.to_u32() as usize + offset_data.as_ref().as_ptr() as usize;
        Some((offset.resolve(offset_data).ok()?, id))
    }

    /// Returns the COLRv1 clip box for the given glyph identifier.
    pub fn v1_clip_box(&self, glyph_id: GlyphId) -> Option<ClipBox<'a>> {
        use core::cmp::Ordering;
        let glyph_id: GlyphId16 = glyph_id.try_into().ok()?;
        let list = self.clip_list()?.ok()?;
        let clips = list.clips();
        let ix = clips
            .binary_search_by(|clip| {
                if glyph_id < clip.start_glyph_id() {
                    Ordering::Greater
                } else if glyph_id > clip.end_glyph_id() {
                    Ordering::Less
                } else {
                    Ordering::Equal
                }
            })
            .ok()?;
        let clip = clips.get(ix)?;
        clip.clip_box(list.offset_data()).ok()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use font_test_data::bebuffer::BeBuffer;

    #[test]
    fn paint_glyph2_reads_full_glyph_id() {
        for gid in [0, 0xffff, 0x10000, 0x123456, 0xffffff] {
            let data = BeBuffer::new()
                .push(33u8)
                .push(Offset24::new(Uint24::new(7)))
                .push(GlyphId24::new(gid))
                .extend([2u8, 0, 7, 0x40, 0]);
            let Paint::Glyph2(paint) = Paint::read(FontData::new(&data)).unwrap() else {
                panic!("expected PaintGlyph2");
            };
            assert_eq!(paint.glyph_id().to_u32(), gid);
            assert_eq!(paint.paint_offset().to_u32(), 7);
            let Paint::Solid(solid) = paint.paint().unwrap() else {
                panic!("expected PaintSolid");
            };
            assert_eq!(solid.palette_index(), 7);
            assert_eq!(solid.alpha(), F2Dot14::ONE);
        }
    }

    #[test]
    fn paint_glyph2_rejects_truncated_header_and_child() {
        let data = font_test_data::colr::PAINT_GLYPH2;
        for len in 0..7 {
            assert!(Paint::read(FontData::new(&data[..len])).is_err());
        }
        for len in 7..data.len() {
            let Paint::Glyph2(paint) = Paint::read(FontData::new(&data[..len])).unwrap() else {
                panic!("expected PaintGlyph2");
            };
            assert!(paint.paint().is_err());
        }
    }
}