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.offset_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        let Some(data) = TableDataRef::new(data.as_bytes()) else {
34            return Err(ReadError::OutOfBounds);
35        };
36        Ok(Self { data })
37    }
38}
39
40/// The fields at the start of the table, which are read directly.
41#[derive(Clone, Copy, bytemuck :: AnyBitPattern)]
42#[repr(C, packed)]
43#[doc(hidden)]
44pub struct VheaFixedHeader {
45    pub version: BigEndian<Version16Dot16>,
46    pub ascender: BigEndian<FWord>,
47    pub descender: BigEndian<FWord>,
48    pub line_gap: BigEndian<FWord>,
49    pub advance_height_max: BigEndian<UfWord>,
50    pub min_top_side_bearing: BigEndian<FWord>,
51    pub min_bottom_side_bearing: BigEndian<FWord>,
52    pub y_max_extent: BigEndian<FWord>,
53    pub caret_slope_rise: BigEndian<i16>,
54    pub caret_slope_run: BigEndian<i16>,
55    pub caret_offset: BigEndian<i16>,
56    pub reserved1: BigEndian<i16>,
57    pub reserved2: BigEndian<i16>,
58    pub reserved3: BigEndian<i16>,
59    pub reserved4: BigEndian<i16>,
60    pub metric_data_format: BigEndian<i16>,
61    pub number_of_long_ver_metrics: BigEndian<u16>,
62}
63
64#[allow(clippy::absurd_extreme_comparisons)]
65const _: () = assert!(std::mem::size_of::<VheaFixedHeader>() <= Vhea::MIN_SIZE);
66
67/// The [vhea](https://docs.microsoft.com/en-us/typography/opentype/spec/vhea) Vertical Header Table
68#[derive(Clone)]
69pub struct Vhea<'a> {
70    data: TableDataRef<'a, VheaFixedHeader>,
71}
72
73#[allow(clippy::needless_lifetimes)]
74impl<'a> Vhea<'a> {
75    pub const MIN_SIZE: usize = (Version16Dot16::RAW_BYTE_LEN
76        + FWord::RAW_BYTE_LEN
77        + FWord::RAW_BYTE_LEN
78        + FWord::RAW_BYTE_LEN
79        + UfWord::RAW_BYTE_LEN
80        + FWord::RAW_BYTE_LEN
81        + FWord::RAW_BYTE_LEN
82        + FWord::RAW_BYTE_LEN
83        + i16::RAW_BYTE_LEN
84        + i16::RAW_BYTE_LEN
85        + i16::RAW_BYTE_LEN
86        + i16::RAW_BYTE_LEN
87        + i16::RAW_BYTE_LEN
88        + i16::RAW_BYTE_LEN
89        + i16::RAW_BYTE_LEN
90        + i16::RAW_BYTE_LEN
91        + u16::RAW_BYTE_LEN);
92    basic_table_impls!(impl_the_methods);
93
94    /// The major/minor version (1, 0 or 1, 1)
95    pub fn version(&self) -> Version16Dot16 {
96        self.data.header().version.get()
97    }
98
99    /// Typographic ascent.
100    pub fn ascender(&self) -> FWord {
101        self.data.header().ascender.get()
102    }
103
104    /// Typographic descent.
105    pub fn descender(&self) -> FWord {
106        self.data.header().descender.get()
107    }
108
109    /// Typographic line gap. Negative LineGap values are treated as
110    /// zero in some legacy platform implementations.
111    pub fn line_gap(&self) -> FWord {
112        self.data.header().line_gap.get()
113    }
114
115    /// Maximum advance height value in 'vmtx' table.
116    pub fn advance_height_max(&self) -> UfWord {
117        self.data.header().advance_height_max.get()
118    }
119
120    /// Minimum top sidebearing value in 'vmtx' table for glyphs with
121    /// contours (empty glyphs should be ignored).
122    pub fn min_top_side_bearing(&self) -> FWord {
123        self.data.header().min_top_side_bearing.get()
124    }
125
126    /// Minimum bottom sidebearing value
127    pub fn min_bottom_side_bearing(&self) -> FWord {
128        self.data.header().min_bottom_side_bearing.get()
129    }
130
131    /// Defined as max( tsb + (yMax-yMin)).
132    pub fn y_max_extent(&self) -> FWord {
133        self.data.header().y_max_extent.get()
134    }
135
136    /// Used to calculate the slope of the cursor (rise/run); 1 for
137    /// vertical caret, 0 for horizontal.
138    pub fn caret_slope_rise(&self) -> i16 {
139        self.data.header().caret_slope_rise.get()
140    }
141
142    /// 0 for vertical caret, 1 for horizontal.
143    pub fn caret_slope_run(&self) -> i16 {
144        self.data.header().caret_slope_run.get()
145    }
146
147    /// The amount by which a slanted highlight on a glyph needs to be
148    /// shifted to produce the best appearance. Set to 0 for
149    /// non-slanted fonts
150    pub fn caret_offset(&self) -> i16 {
151        self.data.header().caret_offset.get()
152    }
153
154    /// 0 for current format.
155    pub fn metric_data_format(&self) -> i16 {
156        self.data.header().metric_data_format.get()
157    }
158
159    /// Number of advance heights in the vertical metrics (`vmtx`) table.
160    pub fn number_of_long_ver_metrics(&self) -> u16 {
161        self.data.header().number_of_long_ver_metrics.get()
162    }
163
164    pub fn version_byte_range(&self) -> Range<usize> {
165        let start = 0;
166        let end = start + Version16Dot16::RAW_BYTE_LEN;
167        start..end
168    }
169
170    pub fn ascender_byte_range(&self) -> Range<usize> {
171        let start = self.version_byte_range().end;
172        let end = start + FWord::RAW_BYTE_LEN;
173        start..end
174    }
175
176    pub fn descender_byte_range(&self) -> Range<usize> {
177        let start = self.ascender_byte_range().end;
178        let end = start + FWord::RAW_BYTE_LEN;
179        start..end
180    }
181
182    pub fn line_gap_byte_range(&self) -> Range<usize> {
183        let start = self.descender_byte_range().end;
184        let end = start + FWord::RAW_BYTE_LEN;
185        start..end
186    }
187
188    pub fn advance_height_max_byte_range(&self) -> Range<usize> {
189        let start = self.line_gap_byte_range().end;
190        let end = start + UfWord::RAW_BYTE_LEN;
191        start..end
192    }
193
194    pub fn min_top_side_bearing_byte_range(&self) -> Range<usize> {
195        let start = self.advance_height_max_byte_range().end;
196        let end = start + FWord::RAW_BYTE_LEN;
197        start..end
198    }
199
200    pub fn min_bottom_side_bearing_byte_range(&self) -> Range<usize> {
201        let start = self.min_top_side_bearing_byte_range().end;
202        let end = start + FWord::RAW_BYTE_LEN;
203        start..end
204    }
205
206    pub fn y_max_extent_byte_range(&self) -> Range<usize> {
207        let start = self.min_bottom_side_bearing_byte_range().end;
208        let end = start + FWord::RAW_BYTE_LEN;
209        start..end
210    }
211
212    pub fn caret_slope_rise_byte_range(&self) -> Range<usize> {
213        let start = self.y_max_extent_byte_range().end;
214        let end = start + i16::RAW_BYTE_LEN;
215        start..end
216    }
217
218    pub fn caret_slope_run_byte_range(&self) -> Range<usize> {
219        let start = self.caret_slope_rise_byte_range().end;
220        let end = start + i16::RAW_BYTE_LEN;
221        start..end
222    }
223
224    pub fn caret_offset_byte_range(&self) -> Range<usize> {
225        let start = self.caret_slope_run_byte_range().end;
226        let end = start + i16::RAW_BYTE_LEN;
227        start..end
228    }
229
230    pub fn reserved1_byte_range(&self) -> Range<usize> {
231        let start = self.caret_offset_byte_range().end;
232        let end = start + i16::RAW_BYTE_LEN;
233        start..end
234    }
235
236    pub fn reserved2_byte_range(&self) -> Range<usize> {
237        let start = self.reserved1_byte_range().end;
238        let end = start + i16::RAW_BYTE_LEN;
239        start..end
240    }
241
242    pub fn reserved3_byte_range(&self) -> Range<usize> {
243        let start = self.reserved2_byte_range().end;
244        let end = start + i16::RAW_BYTE_LEN;
245        start..end
246    }
247
248    pub fn reserved4_byte_range(&self) -> Range<usize> {
249        let start = self.reserved3_byte_range().end;
250        let end = start + i16::RAW_BYTE_LEN;
251        start..end
252    }
253
254    pub fn metric_data_format_byte_range(&self) -> Range<usize> {
255        let start = self.reserved4_byte_range().end;
256        let end = start + i16::RAW_BYTE_LEN;
257        start..end
258    }
259
260    pub fn number_of_long_ver_metrics_byte_range(&self) -> Range<usize> {
261        let start = self.metric_data_format_byte_range().end;
262        let end = start + u16::RAW_BYTE_LEN;
263        start..end
264    }
265}
266
267const _: () = assert!(FontData::default_data_long_enough(Vhea::MIN_SIZE));
268
269impl Default for Vhea<'_> {
270    fn default() -> Self {
271        Self {
272            data: TableDataRef::new(FontData::default_table_data().as_bytes())
273                .unwrap_or_else(|| unreachable!("the default data covers MIN_SIZE")),
274        }
275    }
276}
277
278impl<'a> MinByteRange<'a> for VheaExtended<'a> {
279    fn min_byte_range(&self) -> Range<usize> {
280        0..self.number_of_long_ver_metrics_byte_range().end
281    }
282    fn min_table_bytes(&self) -> &'a [u8] {
283        let range = self.min_byte_range();
284        self.offset_data().as_bytes().get(range).unwrap_or_default()
285    }
286}
287
288impl TopLevelTable for VheaExtended<'_> {
289    /// `VHEA`
290    const TAG: Tag = Tag::new(b"VHEA");
291}
292
293impl ReadArgs for VheaExtended<'_> {
294    type Args = ();
295}
296
297impl<'a> FontRead<'a> for VheaExtended<'a> {
298    fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {
299        #[allow(clippy::absurd_extreme_comparisons)]
300        if data.len() < Self::MIN_SIZE {
301            return Err(ReadError::OutOfBounds);
302        }
303        let Some(data) = TableDataRef::new(data.as_bytes()) else {
304            return Err(ReadError::OutOfBounds);
305        };
306        Ok(Self { data })
307    }
308}
309
310/// The fields at the start of the table, which are read directly.
311#[derive(Clone, Copy, bytemuck :: AnyBitPattern)]
312#[repr(C, packed)]
313#[doc(hidden)]
314pub struct VheaExtendedFixedHeader {
315    pub version: BigEndian<Version16Dot16>,
316    pub ascender: BigEndian<FWord>,
317    pub descender: BigEndian<FWord>,
318    pub line_gap: BigEndian<FWord>,
319    pub advance_height_max: BigEndian<FWord>,
320    pub min_top_side_bearing: BigEndian<FWord>,
321    pub min_bottom_side_bearing: BigEndian<FWord>,
322    pub y_max_extent: BigEndian<FWord>,
323    pub caret_slope_rise: BigEndian<i16>,
324    pub caret_slope_run: BigEndian<i16>,
325    pub caret_offset: BigEndian<i16>,
326    pub reserved1: BigEndian<i16>,
327    pub reserved2: BigEndian<i16>,
328    pub reserved3: BigEndian<i16>,
329    pub reserved4: BigEndian<i16>,
330    pub metric_data_format: BigEndian<i16>,
331    pub number_of_long_ver_metrics: BigEndian<u32>,
332}
333
334#[allow(clippy::absurd_extreme_comparisons)]
335const _: () = assert!(std::mem::size_of::<VheaExtendedFixedHeader>() <= VheaExtended::MIN_SIZE);
336
337/// VHEA header table (ISO/IEC 14496-22:2026, 5.6.13).
338#[derive(Clone)]
339pub struct VheaExtended<'a> {
340    data: TableDataRef<'a, VheaExtendedFixedHeader>,
341}
342
343#[allow(clippy::needless_lifetimes)]
344impl<'a> VheaExtended<'a> {
345    pub const MIN_SIZE: usize = (Version16Dot16::RAW_BYTE_LEN
346        + FWord::RAW_BYTE_LEN
347        + FWord::RAW_BYTE_LEN
348        + FWord::RAW_BYTE_LEN
349        + FWord::RAW_BYTE_LEN
350        + FWord::RAW_BYTE_LEN
351        + FWord::RAW_BYTE_LEN
352        + FWord::RAW_BYTE_LEN
353        + i16::RAW_BYTE_LEN
354        + i16::RAW_BYTE_LEN
355        + i16::RAW_BYTE_LEN
356        + i16::RAW_BYTE_LEN
357        + i16::RAW_BYTE_LEN
358        + i16::RAW_BYTE_LEN
359        + i16::RAW_BYTE_LEN
360        + i16::RAW_BYTE_LEN
361        + u32::RAW_BYTE_LEN);
362    basic_table_impls!(impl_the_methods);
363
364    pub fn version(&self) -> Version16Dot16 {
365        self.data.header().version.get()
366    }
367
368    pub fn ascender(&self) -> FWord {
369        self.data.header().ascender.get()
370    }
371
372    pub fn descender(&self) -> FWord {
373        self.data.header().descender.get()
374    }
375
376    pub fn line_gap(&self) -> FWord {
377        self.data.header().line_gap.get()
378    }
379
380    pub fn advance_height_max(&self) -> FWord {
381        self.data.header().advance_height_max.get()
382    }
383
384    pub fn min_top_side_bearing(&self) -> FWord {
385        self.data.header().min_top_side_bearing.get()
386    }
387
388    pub fn min_bottom_side_bearing(&self) -> FWord {
389        self.data.header().min_bottom_side_bearing.get()
390    }
391
392    pub fn y_max_extent(&self) -> FWord {
393        self.data.header().y_max_extent.get()
394    }
395
396    pub fn caret_slope_rise(&self) -> i16 {
397        self.data.header().caret_slope_rise.get()
398    }
399
400    pub fn caret_slope_run(&self) -> i16 {
401        self.data.header().caret_slope_run.get()
402    }
403
404    pub fn caret_offset(&self) -> i16 {
405        self.data.header().caret_offset.get()
406    }
407
408    pub fn metric_data_format(&self) -> i16 {
409        self.data.header().metric_data_format.get()
410    }
411
412    /// Number of long metric records in VMTX.
413    pub fn number_of_long_ver_metrics(&self) -> u32 {
414        self.data.header().number_of_long_ver_metrics.get()
415    }
416
417    pub fn version_byte_range(&self) -> Range<usize> {
418        let start = 0;
419        let end = start + Version16Dot16::RAW_BYTE_LEN;
420        start..end
421    }
422
423    pub fn ascender_byte_range(&self) -> Range<usize> {
424        let start = self.version_byte_range().end;
425        let end = start + FWord::RAW_BYTE_LEN;
426        start..end
427    }
428
429    pub fn descender_byte_range(&self) -> Range<usize> {
430        let start = self.ascender_byte_range().end;
431        let end = start + FWord::RAW_BYTE_LEN;
432        start..end
433    }
434
435    pub fn line_gap_byte_range(&self) -> Range<usize> {
436        let start = self.descender_byte_range().end;
437        let end = start + FWord::RAW_BYTE_LEN;
438        start..end
439    }
440
441    pub fn advance_height_max_byte_range(&self) -> Range<usize> {
442        let start = self.line_gap_byte_range().end;
443        let end = start + FWord::RAW_BYTE_LEN;
444        start..end
445    }
446
447    pub fn min_top_side_bearing_byte_range(&self) -> Range<usize> {
448        let start = self.advance_height_max_byte_range().end;
449        let end = start + FWord::RAW_BYTE_LEN;
450        start..end
451    }
452
453    pub fn min_bottom_side_bearing_byte_range(&self) -> Range<usize> {
454        let start = self.min_top_side_bearing_byte_range().end;
455        let end = start + FWord::RAW_BYTE_LEN;
456        start..end
457    }
458
459    pub fn y_max_extent_byte_range(&self) -> Range<usize> {
460        let start = self.min_bottom_side_bearing_byte_range().end;
461        let end = start + FWord::RAW_BYTE_LEN;
462        start..end
463    }
464
465    pub fn caret_slope_rise_byte_range(&self) -> Range<usize> {
466        let start = self.y_max_extent_byte_range().end;
467        let end = start + i16::RAW_BYTE_LEN;
468        start..end
469    }
470
471    pub fn caret_slope_run_byte_range(&self) -> Range<usize> {
472        let start = self.caret_slope_rise_byte_range().end;
473        let end = start + i16::RAW_BYTE_LEN;
474        start..end
475    }
476
477    pub fn caret_offset_byte_range(&self) -> Range<usize> {
478        let start = self.caret_slope_run_byte_range().end;
479        let end = start + i16::RAW_BYTE_LEN;
480        start..end
481    }
482
483    pub fn reserved1_byte_range(&self) -> Range<usize> {
484        let start = self.caret_offset_byte_range().end;
485        let end = start + i16::RAW_BYTE_LEN;
486        start..end
487    }
488
489    pub fn reserved2_byte_range(&self) -> Range<usize> {
490        let start = self.reserved1_byte_range().end;
491        let end = start + i16::RAW_BYTE_LEN;
492        start..end
493    }
494
495    pub fn reserved3_byte_range(&self) -> Range<usize> {
496        let start = self.reserved2_byte_range().end;
497        let end = start + i16::RAW_BYTE_LEN;
498        start..end
499    }
500
501    pub fn reserved4_byte_range(&self) -> Range<usize> {
502        let start = self.reserved3_byte_range().end;
503        let end = start + i16::RAW_BYTE_LEN;
504        start..end
505    }
506
507    pub fn metric_data_format_byte_range(&self) -> Range<usize> {
508        let start = self.reserved4_byte_range().end;
509        let end = start + i16::RAW_BYTE_LEN;
510        start..end
511    }
512
513    pub fn number_of_long_ver_metrics_byte_range(&self) -> Range<usize> {
514        let start = self.metric_data_format_byte_range().end;
515        let end = start + u32::RAW_BYTE_LEN;
516        start..end
517    }
518}
519
520const _: () = assert!(FontData::default_data_long_enough(VheaExtended::MIN_SIZE));
521
522impl Default for VheaExtended<'_> {
523    fn default() -> Self {
524        Self {
525            data: TableDataRef::new(FontData::default_table_data().as_bytes())
526                .unwrap_or_else(|| unreachable!("the default data covers MIN_SIZE")),
527        }
528    }
529}