Skip to main content

read_fonts/generated/
generated_hhea.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 Hhea<'a> {
9    fn min_byte_range(&self) -> Range<usize> {
10        0..self.number_of_h_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 Hhea<'_> {
19    /// `hhea`
20    const TAG: Tag = Tag::new(b"hhea");
21}
22
23impl ReadArgs for Hhea<'_> {
24    type Args = ();
25}
26
27impl<'a> FontRead<'a> for Hhea<'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 HheaFixedHeader {
45    pub version: BigEndian<MajorMinor>,
46    pub ascender: BigEndian<FWord>,
47    pub descender: BigEndian<FWord>,
48    pub line_gap: BigEndian<FWord>,
49    pub advance_width_max: BigEndian<UfWord>,
50    pub min_left_side_bearing: BigEndian<FWord>,
51    pub min_right_side_bearing: BigEndian<FWord>,
52    pub x_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_h_metrics: BigEndian<u16>,
62}
63
64#[allow(clippy::absurd_extreme_comparisons)]
65const _: () = assert!(std::mem::size_of::<HheaFixedHeader>() <= Hhea::MIN_SIZE);
66
67/// [hhea](https://docs.microsoft.com/en-us/typography/opentype/spec/hhea) Horizontal Header Table
68#[derive(Clone)]
69pub struct Hhea<'a> {
70    data: TableDataRef<'a, HheaFixedHeader>,
71}
72
73#[allow(clippy::needless_lifetimes)]
74impl<'a> Hhea<'a> {
75    pub const MIN_SIZE: usize = (MajorMinor::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)
95    pub fn version(&self) -> MajorMinor {
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 width value in 'hmtx' table.
116    pub fn advance_width_max(&self) -> UfWord {
117        self.data.header().advance_width_max.get()
118    }
119
120    /// Minimum left sidebearing value in 'hmtx' table for glyphs with
121    /// contours (empty glyphs should be ignored).
122    pub fn min_left_side_bearing(&self) -> FWord {
123        self.data.header().min_left_side_bearing.get()
124    }
125
126    /// Minimum right sidebearing value; calculated as min(aw - (lsb +
127    /// xMax - xMin)) for glyphs with contours (empty glyphs should be ignored).
128    pub fn min_right_side_bearing(&self) -> FWord {
129        self.data.header().min_right_side_bearing.get()
130    }
131
132    /// Max(lsb + (xMax-xMin))
133    pub fn x_max_extent(&self) -> FWord {
134        self.data.header().x_max_extent.get()
135    }
136
137    /// Used to calculate the slope of the cursor (rise/run); 1 for
138    /// vertical caret, 0 for horizontal.
139    pub fn caret_slope_rise(&self) -> i16 {
140        self.data.header().caret_slope_rise.get()
141    }
142
143    /// 0 for vertical caret, 1 for horizontal.
144    pub fn caret_slope_run(&self) -> i16 {
145        self.data.header().caret_slope_run.get()
146    }
147
148    /// The amount by which a slanted highlight on a glyph needs to be
149    /// shifted to produce the best appearance. Set to 0 for
150    /// non-slanted fonts
151    pub fn caret_offset(&self) -> i16 {
152        self.data.header().caret_offset.get()
153    }
154
155    /// 0 for current format.
156    pub fn metric_data_format(&self) -> i16 {
157        self.data.header().metric_data_format.get()
158    }
159
160    /// Number of hMetric entries in 'hmtx' table
161    pub fn number_of_h_metrics(&self) -> u16 {
162        self.data.header().number_of_h_metrics.get()
163    }
164
165    pub fn version_byte_range(&self) -> Range<usize> {
166        let start = 0;
167        let end = start + MajorMinor::RAW_BYTE_LEN;
168        start..end
169    }
170
171    pub fn ascender_byte_range(&self) -> Range<usize> {
172        let start = self.version_byte_range().end;
173        let end = start + FWord::RAW_BYTE_LEN;
174        start..end
175    }
176
177    pub fn descender_byte_range(&self) -> Range<usize> {
178        let start = self.ascender_byte_range().end;
179        let end = start + FWord::RAW_BYTE_LEN;
180        start..end
181    }
182
183    pub fn line_gap_byte_range(&self) -> Range<usize> {
184        let start = self.descender_byte_range().end;
185        let end = start + FWord::RAW_BYTE_LEN;
186        start..end
187    }
188
189    pub fn advance_width_max_byte_range(&self) -> Range<usize> {
190        let start = self.line_gap_byte_range().end;
191        let end = start + UfWord::RAW_BYTE_LEN;
192        start..end
193    }
194
195    pub fn min_left_side_bearing_byte_range(&self) -> Range<usize> {
196        let start = self.advance_width_max_byte_range().end;
197        let end = start + FWord::RAW_BYTE_LEN;
198        start..end
199    }
200
201    pub fn min_right_side_bearing_byte_range(&self) -> Range<usize> {
202        let start = self.min_left_side_bearing_byte_range().end;
203        let end = start + FWord::RAW_BYTE_LEN;
204        start..end
205    }
206
207    pub fn x_max_extent_byte_range(&self) -> Range<usize> {
208        let start = self.min_right_side_bearing_byte_range().end;
209        let end = start + FWord::RAW_BYTE_LEN;
210        start..end
211    }
212
213    pub fn caret_slope_rise_byte_range(&self) -> Range<usize> {
214        let start = self.x_max_extent_byte_range().end;
215        let end = start + i16::RAW_BYTE_LEN;
216        start..end
217    }
218
219    pub fn caret_slope_run_byte_range(&self) -> Range<usize> {
220        let start = self.caret_slope_rise_byte_range().end;
221        let end = start + i16::RAW_BYTE_LEN;
222        start..end
223    }
224
225    pub fn caret_offset_byte_range(&self) -> Range<usize> {
226        let start = self.caret_slope_run_byte_range().end;
227        let end = start + i16::RAW_BYTE_LEN;
228        start..end
229    }
230
231    pub fn reserved1_byte_range(&self) -> Range<usize> {
232        let start = self.caret_offset_byte_range().end;
233        let end = start + i16::RAW_BYTE_LEN;
234        start..end
235    }
236
237    pub fn reserved2_byte_range(&self) -> Range<usize> {
238        let start = self.reserved1_byte_range().end;
239        let end = start + i16::RAW_BYTE_LEN;
240        start..end
241    }
242
243    pub fn reserved3_byte_range(&self) -> Range<usize> {
244        let start = self.reserved2_byte_range().end;
245        let end = start + i16::RAW_BYTE_LEN;
246        start..end
247    }
248
249    pub fn reserved4_byte_range(&self) -> Range<usize> {
250        let start = self.reserved3_byte_range().end;
251        let end = start + i16::RAW_BYTE_LEN;
252        start..end
253    }
254
255    pub fn metric_data_format_byte_range(&self) -> Range<usize> {
256        let start = self.reserved4_byte_range().end;
257        let end = start + i16::RAW_BYTE_LEN;
258        start..end
259    }
260
261    pub fn number_of_h_metrics_byte_range(&self) -> Range<usize> {
262        let start = self.metric_data_format_byte_range().end;
263        let end = start + u16::RAW_BYTE_LEN;
264        start..end
265    }
266}
267
268const _: () = assert!(FontData::default_data_long_enough(Hhea::MIN_SIZE));
269
270impl Default for Hhea<'_> {
271    fn default() -> Self {
272        Self {
273            data: TableDataRef::new(FontData::default_table_data().as_bytes())
274                .unwrap_or_else(|| unreachable!("the default data covers MIN_SIZE")),
275        }
276    }
277}
278
279impl<'a> MinByteRange<'a> for HheaExtended<'a> {
280    fn min_byte_range(&self) -> Range<usize> {
281        0..self.number_of_h_metrics_byte_range().end
282    }
283    fn min_table_bytes(&self) -> &'a [u8] {
284        let range = self.min_byte_range();
285        self.offset_data().as_bytes().get(range).unwrap_or_default()
286    }
287}
288
289impl TopLevelTable for HheaExtended<'_> {
290    /// `HHEA`
291    const TAG: Tag = Tag::new(b"HHEA");
292}
293
294impl ReadArgs for HheaExtended<'_> {
295    type Args = ();
296}
297
298impl<'a> FontRead<'a> for HheaExtended<'a> {
299    fn read_with_args(data: FontData<'a>, _: ()) -> Result<Self, ReadError> {
300        #[allow(clippy::absurd_extreme_comparisons)]
301        if data.len() < Self::MIN_SIZE {
302            return Err(ReadError::OutOfBounds);
303        }
304        let Some(data) = TableDataRef::new(data.as_bytes()) else {
305            return Err(ReadError::OutOfBounds);
306        };
307        Ok(Self { data })
308    }
309}
310
311/// The fields at the start of the table, which are read directly.
312#[derive(Clone, Copy, bytemuck :: AnyBitPattern)]
313#[repr(C, packed)]
314#[doc(hidden)]
315pub struct HheaExtendedFixedHeader {
316    pub version: BigEndian<MajorMinor>,
317    pub ascender: BigEndian<FWord>,
318    pub descender: BigEndian<FWord>,
319    pub line_gap: BigEndian<FWord>,
320    pub advance_width_max: BigEndian<UfWord>,
321    pub min_left_side_bearing: BigEndian<FWord>,
322    pub min_right_side_bearing: BigEndian<FWord>,
323    pub x_max_extent: BigEndian<FWord>,
324    pub caret_slope_rise: BigEndian<i16>,
325    pub caret_slope_run: BigEndian<i16>,
326    pub caret_offset: BigEndian<i16>,
327    pub reserved1: BigEndian<i16>,
328    pub reserved2: BigEndian<i16>,
329    pub reserved3: BigEndian<i16>,
330    pub reserved4: BigEndian<i16>,
331    pub metric_data_format: BigEndian<i16>,
332    pub number_of_h_metrics: BigEndian<u32>,
333}
334
335#[allow(clippy::absurd_extreme_comparisons)]
336const _: () = assert!(std::mem::size_of::<HheaExtendedFixedHeader>() <= HheaExtended::MIN_SIZE);
337
338/// HHEA header table (ISO/IEC 14496-22:2026, 5.1.10).
339#[derive(Clone)]
340pub struct HheaExtended<'a> {
341    data: TableDataRef<'a, HheaExtendedFixedHeader>,
342}
343
344#[allow(clippy::needless_lifetimes)]
345impl<'a> HheaExtended<'a> {
346    pub const MIN_SIZE: usize = (MajorMinor::RAW_BYTE_LEN
347        + FWord::RAW_BYTE_LEN
348        + FWord::RAW_BYTE_LEN
349        + FWord::RAW_BYTE_LEN
350        + UfWord::RAW_BYTE_LEN
351        + FWord::RAW_BYTE_LEN
352        + FWord::RAW_BYTE_LEN
353        + FWord::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        + i16::RAW_BYTE_LEN
362        + u32::RAW_BYTE_LEN);
363    basic_table_impls!(impl_the_methods);
364
365    pub fn version(&self) -> MajorMinor {
366        self.data.header().version.get()
367    }
368
369    pub fn ascender(&self) -> FWord {
370        self.data.header().ascender.get()
371    }
372
373    pub fn descender(&self) -> FWord {
374        self.data.header().descender.get()
375    }
376
377    pub fn line_gap(&self) -> FWord {
378        self.data.header().line_gap.get()
379    }
380
381    pub fn advance_width_max(&self) -> UfWord {
382        self.data.header().advance_width_max.get()
383    }
384
385    pub fn min_left_side_bearing(&self) -> FWord {
386        self.data.header().min_left_side_bearing.get()
387    }
388
389    pub fn min_right_side_bearing(&self) -> FWord {
390        self.data.header().min_right_side_bearing.get()
391    }
392
393    pub fn x_max_extent(&self) -> FWord {
394        self.data.header().x_max_extent.get()
395    }
396
397    pub fn caret_slope_rise(&self) -> i16 {
398        self.data.header().caret_slope_rise.get()
399    }
400
401    pub fn caret_slope_run(&self) -> i16 {
402        self.data.header().caret_slope_run.get()
403    }
404
405    pub fn caret_offset(&self) -> i16 {
406        self.data.header().caret_offset.get()
407    }
408
409    pub fn metric_data_format(&self) -> i16 {
410        self.data.header().metric_data_format.get()
411    }
412
413    /// Number of long metric records in HMTX.
414    pub fn number_of_h_metrics(&self) -> u32 {
415        self.data.header().number_of_h_metrics.get()
416    }
417
418    pub fn version_byte_range(&self) -> Range<usize> {
419        let start = 0;
420        let end = start + MajorMinor::RAW_BYTE_LEN;
421        start..end
422    }
423
424    pub fn ascender_byte_range(&self) -> Range<usize> {
425        let start = self.version_byte_range().end;
426        let end = start + FWord::RAW_BYTE_LEN;
427        start..end
428    }
429
430    pub fn descender_byte_range(&self) -> Range<usize> {
431        let start = self.ascender_byte_range().end;
432        let end = start + FWord::RAW_BYTE_LEN;
433        start..end
434    }
435
436    pub fn line_gap_byte_range(&self) -> Range<usize> {
437        let start = self.descender_byte_range().end;
438        let end = start + FWord::RAW_BYTE_LEN;
439        start..end
440    }
441
442    pub fn advance_width_max_byte_range(&self) -> Range<usize> {
443        let start = self.line_gap_byte_range().end;
444        let end = start + UfWord::RAW_BYTE_LEN;
445        start..end
446    }
447
448    pub fn min_left_side_bearing_byte_range(&self) -> Range<usize> {
449        let start = self.advance_width_max_byte_range().end;
450        let end = start + FWord::RAW_BYTE_LEN;
451        start..end
452    }
453
454    pub fn min_right_side_bearing_byte_range(&self) -> Range<usize> {
455        let start = self.min_left_side_bearing_byte_range().end;
456        let end = start + FWord::RAW_BYTE_LEN;
457        start..end
458    }
459
460    pub fn x_max_extent_byte_range(&self) -> Range<usize> {
461        let start = self.min_right_side_bearing_byte_range().end;
462        let end = start + FWord::RAW_BYTE_LEN;
463        start..end
464    }
465
466    pub fn caret_slope_rise_byte_range(&self) -> Range<usize> {
467        let start = self.x_max_extent_byte_range().end;
468        let end = start + i16::RAW_BYTE_LEN;
469        start..end
470    }
471
472    pub fn caret_slope_run_byte_range(&self) -> Range<usize> {
473        let start = self.caret_slope_rise_byte_range().end;
474        let end = start + i16::RAW_BYTE_LEN;
475        start..end
476    }
477
478    pub fn caret_offset_byte_range(&self) -> Range<usize> {
479        let start = self.caret_slope_run_byte_range().end;
480        let end = start + i16::RAW_BYTE_LEN;
481        start..end
482    }
483
484    pub fn reserved1_byte_range(&self) -> Range<usize> {
485        let start = self.caret_offset_byte_range().end;
486        let end = start + i16::RAW_BYTE_LEN;
487        start..end
488    }
489
490    pub fn reserved2_byte_range(&self) -> Range<usize> {
491        let start = self.reserved1_byte_range().end;
492        let end = start + i16::RAW_BYTE_LEN;
493        start..end
494    }
495
496    pub fn reserved3_byte_range(&self) -> Range<usize> {
497        let start = self.reserved2_byte_range().end;
498        let end = start + i16::RAW_BYTE_LEN;
499        start..end
500    }
501
502    pub fn reserved4_byte_range(&self) -> Range<usize> {
503        let start = self.reserved3_byte_range().end;
504        let end = start + i16::RAW_BYTE_LEN;
505        start..end
506    }
507
508    pub fn metric_data_format_byte_range(&self) -> Range<usize> {
509        let start = self.reserved4_byte_range().end;
510        let end = start + i16::RAW_BYTE_LEN;
511        start..end
512    }
513
514    pub fn number_of_h_metrics_byte_range(&self) -> Range<usize> {
515        let start = self.metric_data_format_byte_range().end;
516        let end = start + u32::RAW_BYTE_LEN;
517        start..end
518    }
519}
520
521const _: () = assert!(FontData::default_data_long_enough(HheaExtended::MIN_SIZE));
522
523impl Default for HheaExtended<'_> {
524    fn default() -> Self {
525        Self {
526            data: TableDataRef::new(FontData::default_table_data().as_bytes())
527                .unwrap_or_else(|| unreachable!("the default data covers MIN_SIZE")),
528        }
529    }
530}