fontcull-klippa 0.1.1

Subsetting a font file according to provided input. (Vendored fork for fontcull)
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
134
135
136
137
138
139
140
141
142
143
144
145
146

//! impl subset() for Anchor subtable

use crate::{
    offset::SerializeSubset,
    serialize::{SerializeErrorFlags, Serializer},
    CollectVariationIndices, Plan, SubsetFlags, SubsetTable,
};
use fontcull_write_fonts::{
    read::{
        collections::IntSet,
        tables::gpos::{AnchorFormat1, AnchorFormat2, AnchorFormat3, AnchorTable},
    },
    types::Offset16,
};

impl<'a> SubsetTable<'a> for AnchorTable<'_> {
    type ArgsForSubset = ();
    type Output = ();
    fn subset(
        &self,
        plan: &Plan,
        s: &mut Serializer,
        args: Self::ArgsForSubset,
    ) -> Result<Self::Output, SerializeErrorFlags> {
        match self {
            Self::Format1(item) => item.subset(plan, s, args),
            Self::Format2(item) => item.subset(plan, s, args),
            Self::Format3(item) => item.subset(plan, s, args),
        }
    }
}

impl<'a> SubsetTable<'a> for AnchorFormat1<'_> {
    type ArgsForSubset = ();
    type Output = ();
    fn subset(
        &self,
        _plan: &Plan,
        s: &mut Serializer,
        _args: Self::ArgsForSubset,
    ) -> Result<(), SerializeErrorFlags> {
        s.embed_bytes(self.min_table_bytes()).map(|_| ())
    }
}

impl<'a> SubsetTable<'a> for AnchorFormat2<'_> {
    type ArgsForSubset = ();
    type Output = ();
    fn subset(
        &self,
        plan: &Plan,
        s: &mut Serializer,
        _args: Self::ArgsForSubset,
    ) -> Result<(), SerializeErrorFlags> {
        if plan
            .subset_flags
            .contains(SubsetFlags::SUBSET_FLAGS_NO_HINTING)
        {
            // AnchorFormat 2 just containins extra hinting information
            // if hints are being dropped downgrade to format 1.
            s.embed(1_u16)?;
            s.embed(self.x_coordinate())?;
            s.embed(self.y_coordinate()).map(|_| ())
        } else {
            s.embed_bytes(self.min_table_bytes()).map(|_| ())
        }
    }
}

impl<'a> SubsetTable<'a> for AnchorFormat3<'_> {
    type ArgsForSubset = ();
    type Output = ();
    fn subset(
        &self,
        plan: &Plan,
        s: &mut Serializer,
        _args: Self::ArgsForSubset,
    ) -> Result<(), SerializeErrorFlags> {
        let format_pos = s.embed(self.anchor_format())?;
        // TODO: update x/y coordinate when instancing
        s.embed(self.x_coordinate())?;
        s.embed(self.y_coordinate())?;

        // if both offsets are null, then we can downgrade to format 1
        // TODO: downgrade to format1 for instancing if possible
        let mut downgrade_to_format1 = true;
        let snap = s.snapshot();

        let x_device_offset_pos = s.embed(0_u16)?;
        if let Some(x_device) = self
            .x_device()
            .transpose()
            .map_err(|_| SerializeErrorFlags::SERIALIZE_ERROR_READ_ERROR)?
        {
            downgrade_to_format1 = false;
            Offset16::serialize_subset(
                &x_device,
                s,
                plan,
                &plan.layout_varidx_delta_map,
                x_device_offset_pos,
            )?;
        }

        let y_device_offset_pos = s.embed(0_u16)?;
        if let Some(y_device) = self
            .y_device()
            .transpose()
            .map_err(|_| SerializeErrorFlags::SERIALIZE_ERROR_READ_ERROR)?
        {
            downgrade_to_format1 = false;
            Offset16::serialize_subset(
                &y_device,
                s,
                plan,
                &plan.layout_varidx_delta_map,
                y_device_offset_pos,
            )?;
        }

        if downgrade_to_format1 {
            s.revert_snapshot(snap);
            s.copy_assign(format_pos, 1_u16);
        }
        Ok(())
    }
}

impl CollectVariationIndices for AnchorTable<'_> {
    fn collect_variation_indices(&self, plan: &Plan, varidx_set: &mut IntSet<u32>) {
        if let Self::Format3(item) = self {
            item.collect_variation_indices(plan, varidx_set)
        }
    }
}

impl CollectVariationIndices for AnchorFormat3<'_> {
    fn collect_variation_indices(&self, plan: &Plan, varidx_set: &mut IntSet<u32>) {
        if let Some(Ok(x_device)) = self.x_device() {
            x_device.collect_variation_indices(plan, varidx_set);
        }
        if let Some(Ok(y_device)) = self.y_device() {
            y_device.collect_variation_indices(plan, varidx_set);
        }
    }
}