Skip to main content

read_fonts/generated/
generated_vhea.rs

1// THIS FILE IS AUTOGENERATED.
2// Any changes to this file will be overwritten.
3// For more information about how codegen works, see font-codegen/README.md
4
5#[allow(unused_imports)]
6use crate::codegen_prelude::*;
7
8impl<'a> MinByteRange<'a> for Vhea<'a> {
9    fn min_byte_range(&self) -> Range<usize> {
10        0..self.number_of_long_ver_metrics_byte_range().end
11    }
12    fn min_table_bytes(&self) -> &'a [u8] {
13        let range = self.min_byte_range();
14        self.data.as_bytes().get(range).unwrap_or_default()
15    }
16}
17
18impl TopLevelTable for Vhea<'_> {
19    /// `vhea`
20    const TAG: Tag = Tag::new(b"vhea");
21}
22
23impl ReadArgs for Vhea<'_> {
24    type Args = ();
25}
26
27impl<'a> FontRead<'a> for Vhea<'a> {
28    fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {
29        #[allow(clippy::absurd_extreme_comparisons)]
30        if data.len() < Self::MIN_SIZE {
31            return Err(ReadError::OutOfBounds);
32        }
33        Ok(Self { data })
34    }
35}
36
37/// The [vhea](https://docs.microsoft.com/en-us/typography/opentype/spec/vhea) Vertical Header Table
38#[derive(Clone)]
39pub struct Vhea<'a> {
40    data: FontData<'a>,
41}
42
43#[allow(clippy::needless_lifetimes)]
44impl<'a> Vhea<'a> {
45    pub const MIN_SIZE: usize = (Version16Dot16::RAW_BYTE_LEN
46        + FWord::RAW_BYTE_LEN
47        + FWord::RAW_BYTE_LEN
48        + FWord::RAW_BYTE_LEN
49        + UfWord::RAW_BYTE_LEN
50        + FWord::RAW_BYTE_LEN
51        + FWord::RAW_BYTE_LEN
52        + FWord::RAW_BYTE_LEN
53        + i16::RAW_BYTE_LEN
54        + i16::RAW_BYTE_LEN
55        + i16::RAW_BYTE_LEN
56        + i16::RAW_BYTE_LEN
57        + i16::RAW_BYTE_LEN
58        + i16::RAW_BYTE_LEN
59        + i16::RAW_BYTE_LEN
60        + i16::RAW_BYTE_LEN
61        + u16::RAW_BYTE_LEN);
62    basic_table_impls!(impl_the_methods);
63
64    /// The major/minor version (1, 0 or 1, 1)
65    pub fn version(&self) -> Version16Dot16 {
66        let range = self.version_byte_range();
67        self.data.read_at(range.start).ok().unwrap()
68    }
69
70    /// Typographic ascent.
71    pub fn ascender(&self) -> FWord {
72        let range = self.ascender_byte_range();
73        self.data.read_at(range.start).ok().unwrap()
74    }
75
76    /// Typographic descent.
77    pub fn descender(&self) -> FWord {
78        let range = self.descender_byte_range();
79        self.data.read_at(range.start).ok().unwrap()
80    }
81
82    /// Typographic line gap. Negative LineGap values are treated as
83    /// zero in some legacy platform implementations.
84    pub fn line_gap(&self) -> FWord {
85        let range = self.line_gap_byte_range();
86        self.data.read_at(range.start).ok().unwrap()
87    }
88
89    /// Maximum advance height value in 'vmtx' table.
90    pub fn advance_height_max(&self) -> UfWord {
91        let range = self.advance_height_max_byte_range();
92        self.data.read_at(range.start).ok().unwrap()
93    }
94
95    /// Minimum top sidebearing value in 'vmtx' table for glyphs with
96    /// contours (empty glyphs should be ignored).
97    pub fn min_top_side_bearing(&self) -> FWord {
98        let range = self.min_top_side_bearing_byte_range();
99        self.data.read_at(range.start).ok().unwrap()
100    }
101
102    /// Minimum bottom sidebearing value
103    pub fn min_bottom_side_bearing(&self) -> FWord {
104        let range = self.min_bottom_side_bearing_byte_range();
105        self.data.read_at(range.start).ok().unwrap()
106    }
107
108    /// Defined as max( tsb + (yMax-yMin)).
109    pub fn y_max_extent(&self) -> FWord {
110        let range = self.y_max_extent_byte_range();
111        self.data.read_at(range.start).ok().unwrap()
112    }
113
114    /// Used to calculate the slope of the cursor (rise/run); 1 for
115    /// vertical caret, 0 for horizontal.
116    pub fn caret_slope_rise(&self) -> i16 {
117        let range = self.caret_slope_rise_byte_range();
118        self.data.read_at(range.start).ok().unwrap()
119    }
120
121    /// 0 for vertical caret, 1 for horizontal.
122    pub fn caret_slope_run(&self) -> i16 {
123        let range = self.caret_slope_run_byte_range();
124        self.data.read_at(range.start).ok().unwrap()
125    }
126
127    /// The amount by which a slanted highlight on a glyph needs to be
128    /// shifted to produce the best appearance. Set to 0 for
129    /// non-slanted fonts
130    pub fn caret_offset(&self) -> i16 {
131        let range = self.caret_offset_byte_range();
132        self.data.read_at(range.start).ok().unwrap()
133    }
134
135    /// 0 for current format.
136    pub fn metric_data_format(&self) -> i16 {
137        let range = self.metric_data_format_byte_range();
138        self.data.read_at(range.start).ok().unwrap()
139    }
140
141    /// Number of advance heights in the vertical metrics (`vmtx`) table.
142    pub fn number_of_long_ver_metrics(&self) -> u16 {
143        let range = self.number_of_long_ver_metrics_byte_range();
144        self.data.read_at(range.start).ok().unwrap()
145    }
146
147    pub fn version_byte_range(&self) -> Range<usize> {
148        let start = 0;
149        let end = start + Version16Dot16::RAW_BYTE_LEN;
150        start..end
151    }
152
153    pub fn ascender_byte_range(&self) -> Range<usize> {
154        let start = self.version_byte_range().end;
155        let end = start + FWord::RAW_BYTE_LEN;
156        start..end
157    }
158
159    pub fn descender_byte_range(&self) -> Range<usize> {
160        let start = self.ascender_byte_range().end;
161        let end = start + FWord::RAW_BYTE_LEN;
162        start..end
163    }
164
165    pub fn line_gap_byte_range(&self) -> Range<usize> {
166        let start = self.descender_byte_range().end;
167        let end = start + FWord::RAW_BYTE_LEN;
168        start..end
169    }
170
171    pub fn advance_height_max_byte_range(&self) -> Range<usize> {
172        let start = self.line_gap_byte_range().end;
173        let end = start + UfWord::RAW_BYTE_LEN;
174        start..end
175    }
176
177    pub fn min_top_side_bearing_byte_range(&self) -> Range<usize> {
178        let start = self.advance_height_max_byte_range().end;
179        let end = start + FWord::RAW_BYTE_LEN;
180        start..end
181    }
182
183    pub fn min_bottom_side_bearing_byte_range(&self) -> Range<usize> {
184        let start = self.min_top_side_bearing_byte_range().end;
185        let end = start + FWord::RAW_BYTE_LEN;
186        start..end
187    }
188
189    pub fn y_max_extent_byte_range(&self) -> Range<usize> {
190        let start = self.min_bottom_side_bearing_byte_range().end;
191        let end = start + FWord::RAW_BYTE_LEN;
192        start..end
193    }
194
195    pub fn caret_slope_rise_byte_range(&self) -> Range<usize> {
196        let start = self.y_max_extent_byte_range().end;
197        let end = start + i16::RAW_BYTE_LEN;
198        start..end
199    }
200
201    pub fn caret_slope_run_byte_range(&self) -> Range<usize> {
202        let start = self.caret_slope_rise_byte_range().end;
203        let end = start + i16::RAW_BYTE_LEN;
204        start..end
205    }
206
207    pub fn caret_offset_byte_range(&self) -> Range<usize> {
208        let start = self.caret_slope_run_byte_range().end;
209        let end = start + i16::RAW_BYTE_LEN;
210        start..end
211    }
212
213    pub fn reserved1_byte_range(&self) -> Range<usize> {
214        let start = self.caret_offset_byte_range().end;
215        let end = start + i16::RAW_BYTE_LEN;
216        start..end
217    }
218
219    pub fn reserved2_byte_range(&self) -> Range<usize> {
220        let start = self.reserved1_byte_range().end;
221        let end = start + i16::RAW_BYTE_LEN;
222        start..end
223    }
224
225    pub fn reserved3_byte_range(&self) -> Range<usize> {
226        let start = self.reserved2_byte_range().end;
227        let end = start + i16::RAW_BYTE_LEN;
228        start..end
229    }
230
231    pub fn reserved4_byte_range(&self) -> Range<usize> {
232        let start = self.reserved3_byte_range().end;
233        let end = start + i16::RAW_BYTE_LEN;
234        start..end
235    }
236
237    pub fn metric_data_format_byte_range(&self) -> Range<usize> {
238        let start = self.reserved4_byte_range().end;
239        let end = start + i16::RAW_BYTE_LEN;
240        start..end
241    }
242
243    pub fn number_of_long_ver_metrics_byte_range(&self) -> Range<usize> {
244        let start = self.metric_data_format_byte_range().end;
245        let end = start + u16::RAW_BYTE_LEN;
246        start..end
247    }
248}
249
250const _: () = assert!(FontData::default_data_long_enough(Vhea::MIN_SIZE));
251
252impl Default for Vhea<'_> {
253    fn default() -> Self {
254        Self {
255            data: FontData::default_table_data(),
256        }
257    }
258}
259
260#[cfg(feature = "experimental_traverse")]
261impl<'a> SomeTable<'a> for Vhea<'a> {
262    fn type_name(&self) -> &str {
263        "Vhea"
264    }
265    fn get_field(&self, idx: usize) -> Option<Field<'a>> {
266        match idx {
267            0usize => Some(Field::new("version", self.version())),
268            1usize => Some(Field::new("ascender", self.ascender())),
269            2usize => Some(Field::new("descender", self.descender())),
270            3usize => Some(Field::new("line_gap", self.line_gap())),
271            4usize => Some(Field::new("advance_height_max", self.advance_height_max())),
272            5usize => Some(Field::new(
273                "min_top_side_bearing",
274                self.min_top_side_bearing(),
275            )),
276            6usize => Some(Field::new(
277                "min_bottom_side_bearing",
278                self.min_bottom_side_bearing(),
279            )),
280            7usize => Some(Field::new("y_max_extent", self.y_max_extent())),
281            8usize => Some(Field::new("caret_slope_rise", self.caret_slope_rise())),
282            9usize => Some(Field::new("caret_slope_run", self.caret_slope_run())),
283            10usize => Some(Field::new("caret_offset", self.caret_offset())),
284            11usize => Some(Field::new("metric_data_format", self.metric_data_format())),
285            12usize => Some(Field::new(
286                "number_of_long_ver_metrics",
287                self.number_of_long_ver_metrics(),
288            )),
289            _ => None,
290        }
291    }
292}
293
294#[cfg(feature = "experimental_traverse")]
295#[allow(clippy::needless_lifetimes)]
296impl<'a> std::fmt::Debug for Vhea<'a> {
297    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
298        (self as &dyn SomeTable<'a>).fmt(f)
299    }
300}