read_fonts/generated/
generated_head.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
8/// The `macStyle` field for the head table.
9#[derive(Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Hash, bytemuck :: AnyBitPattern)]
10#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
11#[repr(transparent)]
12pub struct MacStyle {
13    bits: u16,
14}
15
16impl MacStyle {
17    /// Bit 0: Bold (if set to 1)
18    pub const BOLD: Self = Self { bits: 0x0001 };
19
20    /// Bit 1: Italic (if set to 1)
21    pub const ITALIC: Self = Self { bits: 0x0002 };
22
23    /// Bit 2: Underline (if set to 1)
24    pub const UNDERLINE: Self = Self { bits: 0x0004 };
25
26    /// Bit 3: Outline (if set to 1)
27    pub const OUTLINE: Self = Self { bits: 0x0008 };
28
29    /// Bit 4: Shadow (if set to 1)
30    pub const SHADOW: Self = Self { bits: 0x0010 };
31
32    /// Bit 5: Condensed (if set to 1)
33    pub const CONDENSED: Self = Self { bits: 0x0020 };
34
35    /// Bit 6: Extended (if set to 1)
36    pub const EXTENDED: Self = Self { bits: 0x0040 };
37}
38
39impl MacStyle {
40    ///  Returns an empty set of flags.
41    #[inline]
42    pub const fn empty() -> Self {
43        Self { bits: 0 }
44    }
45
46    /// Returns the set containing all flags.
47    #[inline]
48    pub const fn all() -> Self {
49        Self {
50            bits: Self::BOLD.bits
51                | Self::ITALIC.bits
52                | Self::UNDERLINE.bits
53                | Self::OUTLINE.bits
54                | Self::SHADOW.bits
55                | Self::CONDENSED.bits
56                | Self::EXTENDED.bits,
57        }
58    }
59
60    /// Returns the raw value of the flags currently stored.
61    #[inline]
62    pub const fn bits(&self) -> u16 {
63        self.bits
64    }
65
66    /// Convert from underlying bit representation, unless that
67    /// representation contains bits that do not correspond to a flag.
68    #[inline]
69    pub const fn from_bits(bits: u16) -> Option<Self> {
70        if (bits & !Self::all().bits()) == 0 {
71            Some(Self { bits })
72        } else {
73            None
74        }
75    }
76
77    /// Convert from underlying bit representation, dropping any bits
78    /// that do not correspond to flags.
79    #[inline]
80    pub const fn from_bits_truncate(bits: u16) -> Self {
81        Self {
82            bits: bits & Self::all().bits,
83        }
84    }
85
86    /// Returns `true` if no flags are currently stored.
87    #[inline]
88    pub const fn is_empty(&self) -> bool {
89        self.bits() == Self::empty().bits()
90    }
91
92    /// Returns `true` if there are flags common to both `self` and `other`.
93    #[inline]
94    pub const fn intersects(&self, other: Self) -> bool {
95        !(Self {
96            bits: self.bits & other.bits,
97        })
98        .is_empty()
99    }
100
101    /// Returns `true` if all of the flags in `other` are contained within `self`.
102    #[inline]
103    pub const fn contains(&self, other: Self) -> bool {
104        (self.bits & other.bits) == other.bits
105    }
106
107    /// Inserts the specified flags in-place.
108    #[inline]
109    pub fn insert(&mut self, other: Self) {
110        self.bits |= other.bits;
111    }
112
113    /// Removes the specified flags in-place.
114    #[inline]
115    pub fn remove(&mut self, other: Self) {
116        self.bits &= !other.bits;
117    }
118
119    /// Toggles the specified flags in-place.
120    #[inline]
121    pub fn toggle(&mut self, other: Self) {
122        self.bits ^= other.bits;
123    }
124
125    /// Returns the intersection between the flags in `self` and
126    /// `other`.
127    ///
128    /// Specifically, the returned set contains only the flags which are
129    /// present in *both* `self` *and* `other`.
130    ///
131    /// This is equivalent to using the `&` operator (e.g.
132    /// [`ops::BitAnd`]), as in `flags & other`.
133    ///
134    /// [`ops::BitAnd`]: https://doc.rust-lang.org/std/ops/trait.BitAnd.html
135    #[inline]
136    #[must_use]
137    pub const fn intersection(self, other: Self) -> Self {
138        Self {
139            bits: self.bits & other.bits,
140        }
141    }
142
143    /// Returns the union of between the flags in `self` and `other`.
144    ///
145    /// Specifically, the returned set contains all flags which are
146    /// present in *either* `self` *or* `other`, including any which are
147    /// present in both.
148    ///
149    /// This is equivalent to using the `|` operator (e.g.
150    /// [`ops::BitOr`]), as in `flags | other`.
151    ///
152    /// [`ops::BitOr`]: https://doc.rust-lang.org/std/ops/trait.BitOr.html
153    #[inline]
154    #[must_use]
155    pub const fn union(self, other: Self) -> Self {
156        Self {
157            bits: self.bits | other.bits,
158        }
159    }
160
161    /// Returns the difference between the flags in `self` and `other`.
162    ///
163    /// Specifically, the returned set contains all flags present in
164    /// `self`, except for the ones present in `other`.
165    ///
166    /// It is also conceptually equivalent to the "bit-clear" operation:
167    /// `flags & !other` (and this syntax is also supported).
168    ///
169    /// This is equivalent to using the `-` operator (e.g.
170    /// [`ops::Sub`]), as in `flags - other`.
171    ///
172    /// [`ops::Sub`]: https://doc.rust-lang.org/std/ops/trait.Sub.html
173    #[inline]
174    #[must_use]
175    pub const fn difference(self, other: Self) -> Self {
176        Self {
177            bits: self.bits & !other.bits,
178        }
179    }
180}
181
182impl std::ops::BitOr for MacStyle {
183    type Output = Self;
184
185    /// Returns the union of the two sets of flags.
186    #[inline]
187    fn bitor(self, other: MacStyle) -> Self {
188        Self {
189            bits: self.bits | other.bits,
190        }
191    }
192}
193
194impl std::ops::BitOrAssign for MacStyle {
195    /// Adds the set of flags.
196    #[inline]
197    fn bitor_assign(&mut self, other: Self) {
198        self.bits |= other.bits;
199    }
200}
201
202impl std::ops::BitXor for MacStyle {
203    type Output = Self;
204
205    /// Returns the left flags, but with all the right flags toggled.
206    #[inline]
207    fn bitxor(self, other: Self) -> Self {
208        Self {
209            bits: self.bits ^ other.bits,
210        }
211    }
212}
213
214impl std::ops::BitXorAssign for MacStyle {
215    /// Toggles the set of flags.
216    #[inline]
217    fn bitxor_assign(&mut self, other: Self) {
218        self.bits ^= other.bits;
219    }
220}
221
222impl std::ops::BitAnd for MacStyle {
223    type Output = Self;
224
225    /// Returns the intersection between the two sets of flags.
226    #[inline]
227    fn bitand(self, other: Self) -> Self {
228        Self {
229            bits: self.bits & other.bits,
230        }
231    }
232}
233
234impl std::ops::BitAndAssign for MacStyle {
235    /// Disables all flags disabled in the set.
236    #[inline]
237    fn bitand_assign(&mut self, other: Self) {
238        self.bits &= other.bits;
239    }
240}
241
242impl std::ops::Sub for MacStyle {
243    type Output = Self;
244
245    /// Returns the set difference of the two sets of flags.
246    #[inline]
247    fn sub(self, other: Self) -> Self {
248        Self {
249            bits: self.bits & !other.bits,
250        }
251    }
252}
253
254impl std::ops::SubAssign for MacStyle {
255    /// Disables all flags enabled in the set.
256    #[inline]
257    fn sub_assign(&mut self, other: Self) {
258        self.bits &= !other.bits;
259    }
260}
261
262impl std::ops::Not for MacStyle {
263    type Output = Self;
264
265    /// Returns the complement of this set of flags.
266    #[inline]
267    fn not(self) -> Self {
268        Self { bits: !self.bits } & Self::all()
269    }
270}
271
272impl std::fmt::Debug for MacStyle {
273    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
274        let members: &[(&str, Self)] = &[
275            ("BOLD", Self::BOLD),
276            ("ITALIC", Self::ITALIC),
277            ("UNDERLINE", Self::UNDERLINE),
278            ("OUTLINE", Self::OUTLINE),
279            ("SHADOW", Self::SHADOW),
280            ("CONDENSED", Self::CONDENSED),
281            ("EXTENDED", Self::EXTENDED),
282        ];
283        let mut first = true;
284        for (name, value) in members {
285            if self.contains(*value) {
286                if !first {
287                    f.write_str(" | ")?;
288                }
289                first = false;
290                f.write_str(name)?;
291            }
292        }
293        if first {
294            f.write_str("(empty)")?;
295        }
296        Ok(())
297    }
298}
299
300impl std::fmt::Binary for MacStyle {
301    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
302        std::fmt::Binary::fmt(&self.bits, f)
303    }
304}
305
306impl std::fmt::Octal for MacStyle {
307    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
308        std::fmt::Octal::fmt(&self.bits, f)
309    }
310}
311
312impl std::fmt::LowerHex for MacStyle {
313    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
314        std::fmt::LowerHex::fmt(&self.bits, f)
315    }
316}
317
318impl std::fmt::UpperHex for MacStyle {
319    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
320        std::fmt::UpperHex::fmt(&self.bits, f)
321    }
322}
323
324impl font_types::Scalar for MacStyle {
325    type Raw = <u16 as font_types::Scalar>::Raw;
326    fn to_raw(self) -> Self::Raw {
327        self.bits().to_raw()
328    }
329    fn from_raw(raw: Self::Raw) -> Self {
330        let t = <u16>::from_raw(raw);
331        Self::from_bits_truncate(t)
332    }
333}
334
335#[cfg(feature = "experimental_traverse")]
336impl<'a> From<MacStyle> for FieldType<'a> {
337    fn from(src: MacStyle) -> FieldType<'a> {
338        src.bits().into()
339    }
340}
341
342/// The `flags` field for the head table.
343#[derive(Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Hash, bytemuck :: AnyBitPattern)]
344#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
345#[repr(transparent)]
346pub struct Flags {
347    bits: u16,
348}
349
350impl Flags {
351    /// Bit 0: Baseline for font at y=0.
352    pub const BASELINE_AT_Y_0: Self = Self { bits: 0x0001 };
353
354    /// Bit 1: Left sidebearing point at x=0 (relevant only for TrueType rasterizers).
355    pub const LSB_AT_X_0: Self = Self { bits: 0x0002 };
356
357    /// Bit 2: Instructions may depend on point size.
358    pub const INSTRUCTIONS_MAY_DEPEND_ON_POINT_SIZE: Self = Self { bits: 0x0004 };
359
360    /// Bit 3: Force ppem to integer values for all internal scaler math; may use fractional ppem sizes if this bit is clear. It is strongly recommended that this be set in hinted fonts.
361    pub const FORCE_INTEGER_PPEM: Self = Self { bits: 0x0008 };
362
363    /// Bit 4: Instructions may alter advance width (the advance widths might not scale linearly).
364    pub const INSTRUCTIONS_MAY_ALTER_ADVANCE_WIDTH: Self = Self { bits: 0x0010 };
365
366    /// Bit 11: Font data is “lossless” as a result of having been subjected to optimizing transformation and/or compression (such as compression mechanisms defined by ISO/IEC 14496-18, MicroType® Express, WOFF 2.0, or similar) where the original font functionality and features are retained but the binary compatibility between input and output font files is not guaranteed. As a result of the applied transform, the DSIG table may also be invalidated.
367    pub const LOSSLESS_TRANSFORMED_FONT_DATA: Self = Self { bits: 0x0800 };
368
369    /// Bit 12: Font converted (produce compatible metrics).
370    pub const CONVERTED_FONT: Self = Self { bits: 0x1000 };
371
372    /// Bit 13: Font optimized for ClearType. Note, fonts that rely on embedded bitmaps (EBDT) for rendering should not be considered optimized for ClearType, and therefore should keep this bit cleared.
373    pub const OPTIMIZED_FOR_CLEARTYPE: Self = Self { bits: 0x2000 };
374
375    /// Bit 14: Last Resort font. If set, indicates that the glyphs encoded in the 'cmap' subtables are simply generic symbolic representations of code point ranges and do not truly represent support for those code points. If unset, indicates that the glyphs encoded in the 'cmap' subtables represent proper support for those code points.
376    pub const LAST_RESORT_FONT: Self = Self { bits: 0x4000 };
377}
378
379impl Flags {
380    ///  Returns an empty set of flags.
381    #[inline]
382    pub const fn empty() -> Self {
383        Self { bits: 0 }
384    }
385
386    /// Returns the set containing all flags.
387    #[inline]
388    pub const fn all() -> Self {
389        Self {
390            bits: Self::BASELINE_AT_Y_0.bits
391                | Self::LSB_AT_X_0.bits
392                | Self::INSTRUCTIONS_MAY_DEPEND_ON_POINT_SIZE.bits
393                | Self::FORCE_INTEGER_PPEM.bits
394                | Self::INSTRUCTIONS_MAY_ALTER_ADVANCE_WIDTH.bits
395                | Self::LOSSLESS_TRANSFORMED_FONT_DATA.bits
396                | Self::CONVERTED_FONT.bits
397                | Self::OPTIMIZED_FOR_CLEARTYPE.bits
398                | Self::LAST_RESORT_FONT.bits,
399        }
400    }
401
402    /// Returns the raw value of the flags currently stored.
403    #[inline]
404    pub const fn bits(&self) -> u16 {
405        self.bits
406    }
407
408    /// Convert from underlying bit representation, unless that
409    /// representation contains bits that do not correspond to a flag.
410    #[inline]
411    pub const fn from_bits(bits: u16) -> Option<Self> {
412        if (bits & !Self::all().bits()) == 0 {
413            Some(Self { bits })
414        } else {
415            None
416        }
417    }
418
419    /// Convert from underlying bit representation, dropping any bits
420    /// that do not correspond to flags.
421    #[inline]
422    pub const fn from_bits_truncate(bits: u16) -> Self {
423        Self {
424            bits: bits & Self::all().bits,
425        }
426    }
427
428    /// Returns `true` if no flags are currently stored.
429    #[inline]
430    pub const fn is_empty(&self) -> bool {
431        self.bits() == Self::empty().bits()
432    }
433
434    /// Returns `true` if there are flags common to both `self` and `other`.
435    #[inline]
436    pub const fn intersects(&self, other: Self) -> bool {
437        !(Self {
438            bits: self.bits & other.bits,
439        })
440        .is_empty()
441    }
442
443    /// Returns `true` if all of the flags in `other` are contained within `self`.
444    #[inline]
445    pub const fn contains(&self, other: Self) -> bool {
446        (self.bits & other.bits) == other.bits
447    }
448
449    /// Inserts the specified flags in-place.
450    #[inline]
451    pub fn insert(&mut self, other: Self) {
452        self.bits |= other.bits;
453    }
454
455    /// Removes the specified flags in-place.
456    #[inline]
457    pub fn remove(&mut self, other: Self) {
458        self.bits &= !other.bits;
459    }
460
461    /// Toggles the specified flags in-place.
462    #[inline]
463    pub fn toggle(&mut self, other: Self) {
464        self.bits ^= other.bits;
465    }
466
467    /// Returns the intersection between the flags in `self` and
468    /// `other`.
469    ///
470    /// Specifically, the returned set contains only the flags which are
471    /// present in *both* `self` *and* `other`.
472    ///
473    /// This is equivalent to using the `&` operator (e.g.
474    /// [`ops::BitAnd`]), as in `flags & other`.
475    ///
476    /// [`ops::BitAnd`]: https://doc.rust-lang.org/std/ops/trait.BitAnd.html
477    #[inline]
478    #[must_use]
479    pub const fn intersection(self, other: Self) -> Self {
480        Self {
481            bits: self.bits & other.bits,
482        }
483    }
484
485    /// Returns the union of between the flags in `self` and `other`.
486    ///
487    /// Specifically, the returned set contains all flags which are
488    /// present in *either* `self` *or* `other`, including any which are
489    /// present in both.
490    ///
491    /// This is equivalent to using the `|` operator (e.g.
492    /// [`ops::BitOr`]), as in `flags | other`.
493    ///
494    /// [`ops::BitOr`]: https://doc.rust-lang.org/std/ops/trait.BitOr.html
495    #[inline]
496    #[must_use]
497    pub const fn union(self, other: Self) -> Self {
498        Self {
499            bits: self.bits | other.bits,
500        }
501    }
502
503    /// Returns the difference between the flags in `self` and `other`.
504    ///
505    /// Specifically, the returned set contains all flags present in
506    /// `self`, except for the ones present in `other`.
507    ///
508    /// It is also conceptually equivalent to the "bit-clear" operation:
509    /// `flags & !other` (and this syntax is also supported).
510    ///
511    /// This is equivalent to using the `-` operator (e.g.
512    /// [`ops::Sub`]), as in `flags - other`.
513    ///
514    /// [`ops::Sub`]: https://doc.rust-lang.org/std/ops/trait.Sub.html
515    #[inline]
516    #[must_use]
517    pub const fn difference(self, other: Self) -> Self {
518        Self {
519            bits: self.bits & !other.bits,
520        }
521    }
522}
523
524impl std::ops::BitOr for Flags {
525    type Output = Self;
526
527    /// Returns the union of the two sets of flags.
528    #[inline]
529    fn bitor(self, other: Flags) -> Self {
530        Self {
531            bits: self.bits | other.bits,
532        }
533    }
534}
535
536impl std::ops::BitOrAssign for Flags {
537    /// Adds the set of flags.
538    #[inline]
539    fn bitor_assign(&mut self, other: Self) {
540        self.bits |= other.bits;
541    }
542}
543
544impl std::ops::BitXor for Flags {
545    type Output = Self;
546
547    /// Returns the left flags, but with all the right flags toggled.
548    #[inline]
549    fn bitxor(self, other: Self) -> Self {
550        Self {
551            bits: self.bits ^ other.bits,
552        }
553    }
554}
555
556impl std::ops::BitXorAssign for Flags {
557    /// Toggles the set of flags.
558    #[inline]
559    fn bitxor_assign(&mut self, other: Self) {
560        self.bits ^= other.bits;
561    }
562}
563
564impl std::ops::BitAnd for Flags {
565    type Output = Self;
566
567    /// Returns the intersection between the two sets of flags.
568    #[inline]
569    fn bitand(self, other: Self) -> Self {
570        Self {
571            bits: self.bits & other.bits,
572        }
573    }
574}
575
576impl std::ops::BitAndAssign for Flags {
577    /// Disables all flags disabled in the set.
578    #[inline]
579    fn bitand_assign(&mut self, other: Self) {
580        self.bits &= other.bits;
581    }
582}
583
584impl std::ops::Sub for Flags {
585    type Output = Self;
586
587    /// Returns the set difference of the two sets of flags.
588    #[inline]
589    fn sub(self, other: Self) -> Self {
590        Self {
591            bits: self.bits & !other.bits,
592        }
593    }
594}
595
596impl std::ops::SubAssign for Flags {
597    /// Disables all flags enabled in the set.
598    #[inline]
599    fn sub_assign(&mut self, other: Self) {
600        self.bits &= !other.bits;
601    }
602}
603
604impl std::ops::Not for Flags {
605    type Output = Self;
606
607    /// Returns the complement of this set of flags.
608    #[inline]
609    fn not(self) -> Self {
610        Self { bits: !self.bits } & Self::all()
611    }
612}
613
614impl std::fmt::Debug for Flags {
615    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
616        let members: &[(&str, Self)] = &[
617            ("BASELINE_AT_Y_0", Self::BASELINE_AT_Y_0),
618            ("LSB_AT_X_0", Self::LSB_AT_X_0),
619            (
620                "INSTRUCTIONS_MAY_DEPEND_ON_POINT_SIZE",
621                Self::INSTRUCTIONS_MAY_DEPEND_ON_POINT_SIZE,
622            ),
623            ("FORCE_INTEGER_PPEM", Self::FORCE_INTEGER_PPEM),
624            (
625                "INSTRUCTIONS_MAY_ALTER_ADVANCE_WIDTH",
626                Self::INSTRUCTIONS_MAY_ALTER_ADVANCE_WIDTH,
627            ),
628            (
629                "LOSSLESS_TRANSFORMED_FONT_DATA",
630                Self::LOSSLESS_TRANSFORMED_FONT_DATA,
631            ),
632            ("CONVERTED_FONT", Self::CONVERTED_FONT),
633            ("OPTIMIZED_FOR_CLEARTYPE", Self::OPTIMIZED_FOR_CLEARTYPE),
634            ("LAST_RESORT_FONT", Self::LAST_RESORT_FONT),
635        ];
636        let mut first = true;
637        for (name, value) in members {
638            if self.contains(*value) {
639                if !first {
640                    f.write_str(" | ")?;
641                }
642                first = false;
643                f.write_str(name)?;
644            }
645        }
646        if first {
647            f.write_str("(empty)")?;
648        }
649        Ok(())
650    }
651}
652
653impl std::fmt::Binary for Flags {
654    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
655        std::fmt::Binary::fmt(&self.bits, f)
656    }
657}
658
659impl std::fmt::Octal for Flags {
660    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
661        std::fmt::Octal::fmt(&self.bits, f)
662    }
663}
664
665impl std::fmt::LowerHex for Flags {
666    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
667        std::fmt::LowerHex::fmt(&self.bits, f)
668    }
669}
670
671impl std::fmt::UpperHex for Flags {
672    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
673        std::fmt::UpperHex::fmt(&self.bits, f)
674    }
675}
676
677impl font_types::Scalar for Flags {
678    type Raw = <u16 as font_types::Scalar>::Raw;
679    fn to_raw(self) -> Self::Raw {
680        self.bits().to_raw()
681    }
682    fn from_raw(raw: Self::Raw) -> Self {
683        let t = <u16>::from_raw(raw);
684        Self::from_bits_truncate(t)
685    }
686}
687
688#[cfg(feature = "experimental_traverse")]
689impl<'a> From<Flags> for FieldType<'a> {
690    fn from(src: Flags) -> FieldType<'a> {
691        src.bits().into()
692    }
693}
694
695impl<'a> MinByteRange<'a> for Head<'a> {
696    fn min_byte_range(&self) -> Range<usize> {
697        0..self.glyph_data_format_byte_range().end
698    }
699    fn min_table_bytes(&self) -> &'a [u8] {
700        let range = self.min_byte_range();
701        self.data.as_bytes().get(range).unwrap_or_default()
702    }
703}
704
705impl TopLevelTable for Head<'_> {
706    /// `head`
707    const TAG: Tag = Tag::new(b"head");
708}
709
710impl<'a> FontRead<'a> for Head<'a> {
711    fn read(data: FontData<'a>) -> Result<Self, ReadError> {
712        #[allow(clippy::absurd_extreme_comparisons)]
713        if data.len() < Self::MIN_SIZE {
714            return Err(ReadError::OutOfBounds);
715        }
716        Ok(Self { data })
717    }
718}
719
720/// The [head](https://docs.microsoft.com/en-us/typography/opentype/spec/head)
721/// (font header) table.
722#[derive(Clone)]
723pub struct Head<'a> {
724    data: FontData<'a>,
725}
726
727#[allow(clippy::needless_lifetimes)]
728impl<'a> Head<'a> {
729    pub const MIN_SIZE: usize = (MajorMinor::RAW_BYTE_LEN
730        + Fixed::RAW_BYTE_LEN
731        + u32::RAW_BYTE_LEN
732        + u32::RAW_BYTE_LEN
733        + Flags::RAW_BYTE_LEN
734        + u16::RAW_BYTE_LEN
735        + LongDateTime::RAW_BYTE_LEN
736        + LongDateTime::RAW_BYTE_LEN
737        + i16::RAW_BYTE_LEN
738        + i16::RAW_BYTE_LEN
739        + i16::RAW_BYTE_LEN
740        + i16::RAW_BYTE_LEN
741        + MacStyle::RAW_BYTE_LEN
742        + u16::RAW_BYTE_LEN
743        + i16::RAW_BYTE_LEN
744        + i16::RAW_BYTE_LEN
745        + i16::RAW_BYTE_LEN);
746    basic_table_impls!(impl_the_methods);
747
748    /// Version number of the font header table, set to (1, 0)
749    pub fn version(&self) -> MajorMinor {
750        let range = self.version_byte_range();
751        self.data.read_at(range.start).ok().unwrap()
752    }
753
754    /// Set by font manufacturer.
755    pub fn font_revision(&self) -> Fixed {
756        let range = self.font_revision_byte_range();
757        self.data.read_at(range.start).ok().unwrap()
758    }
759
760    /// To compute: set it to 0, sum the entire font as uint32, then
761    /// store 0xB1B0AFBA - sum. If the font is used as a component in a
762    /// font collection file, the value of this field will be
763    /// invalidated by changes to the file structure and font table
764    /// directory, and must be ignored.
765    pub fn checksum_adjustment(&self) -> u32 {
766        let range = self.checksum_adjustment_byte_range();
767        self.data.read_at(range.start).ok().unwrap()
768    }
769
770    /// Set to 0x5F0F3CF5.
771    pub fn magic_number(&self) -> u32 {
772        let range = self.magic_number_byte_range();
773        self.data.read_at(range.start).ok().unwrap()
774    }
775
776    /// See the flags enum.
777    pub fn flags(&self) -> Flags {
778        let range = self.flags_byte_range();
779        self.data.read_at(range.start).ok().unwrap()
780    }
781
782    /// Set to a value from 16 to 16384. Any value in this range is
783    /// valid. In fonts that have TrueType outlines, a power of 2 is
784    /// recommended as this allows performance optimizations in some
785    /// rasterizers.
786    pub fn units_per_em(&self) -> u16 {
787        let range = self.units_per_em_byte_range();
788        self.data.read_at(range.start).ok().unwrap()
789    }
790
791    /// Number of seconds since 12:00 midnight that started January 1st
792    /// 1904 in GMT/UTC time zone.
793    pub fn created(&self) -> LongDateTime {
794        let range = self.created_byte_range();
795        self.data.read_at(range.start).ok().unwrap()
796    }
797
798    /// Number of seconds since 12:00 midnight that started January 1st
799    /// 1904 in GMT/UTC time zone.
800    pub fn modified(&self) -> LongDateTime {
801        let range = self.modified_byte_range();
802        self.data.read_at(range.start).ok().unwrap()
803    }
804
805    /// Minimum x coordinate across all glyph bounding boxes.
806    pub fn x_min(&self) -> i16 {
807        let range = self.x_min_byte_range();
808        self.data.read_at(range.start).ok().unwrap()
809    }
810
811    /// Minimum y coordinate across all glyph bounding boxes.
812    pub fn y_min(&self) -> i16 {
813        let range = self.y_min_byte_range();
814        self.data.read_at(range.start).ok().unwrap()
815    }
816
817    /// Maximum x coordinate across all glyph bounding boxes.
818    pub fn x_max(&self) -> i16 {
819        let range = self.x_max_byte_range();
820        self.data.read_at(range.start).ok().unwrap()
821    }
822
823    /// Maximum y coordinate across all glyph bounding boxes.
824    pub fn y_max(&self) -> i16 {
825        let range = self.y_max_byte_range();
826        self.data.read_at(range.start).ok().unwrap()
827    }
828
829    /// Bits identifying the font's style; see [MacStyle]
830    pub fn mac_style(&self) -> MacStyle {
831        let range = self.mac_style_byte_range();
832        self.data.read_at(range.start).ok().unwrap()
833    }
834
835    /// Smallest readable size in pixels.
836    pub fn lowest_rec_ppem(&self) -> u16 {
837        let range = self.lowest_rec_ppem_byte_range();
838        self.data.read_at(range.start).ok().unwrap()
839    }
840
841    /// Deprecated (Set to 2).
842    pub fn font_direction_hint(&self) -> i16 {
843        let range = self.font_direction_hint_byte_range();
844        self.data.read_at(range.start).ok().unwrap()
845    }
846
847    /// 0 for short offsets (Offset16), 1 for long (Offset32).
848    pub fn index_to_loc_format(&self) -> i16 {
849        let range = self.index_to_loc_format_byte_range();
850        self.data.read_at(range.start).ok().unwrap()
851    }
852
853    /// 0 for current format.
854    pub fn glyph_data_format(&self) -> i16 {
855        let range = self.glyph_data_format_byte_range();
856        self.data.read_at(range.start).ok().unwrap()
857    }
858
859    pub fn version_byte_range(&self) -> Range<usize> {
860        let start = 0;
861        start..start + MajorMinor::RAW_BYTE_LEN
862    }
863
864    pub fn font_revision_byte_range(&self) -> Range<usize> {
865        let start = self.version_byte_range().end;
866        start..start + Fixed::RAW_BYTE_LEN
867    }
868
869    pub fn checksum_adjustment_byte_range(&self) -> Range<usize> {
870        let start = self.font_revision_byte_range().end;
871        start..start + u32::RAW_BYTE_LEN
872    }
873
874    pub fn magic_number_byte_range(&self) -> Range<usize> {
875        let start = self.checksum_adjustment_byte_range().end;
876        start..start + u32::RAW_BYTE_LEN
877    }
878
879    pub fn flags_byte_range(&self) -> Range<usize> {
880        let start = self.magic_number_byte_range().end;
881        start..start + Flags::RAW_BYTE_LEN
882    }
883
884    pub fn units_per_em_byte_range(&self) -> Range<usize> {
885        let start = self.flags_byte_range().end;
886        start..start + u16::RAW_BYTE_LEN
887    }
888
889    pub fn created_byte_range(&self) -> Range<usize> {
890        let start = self.units_per_em_byte_range().end;
891        start..start + LongDateTime::RAW_BYTE_LEN
892    }
893
894    pub fn modified_byte_range(&self) -> Range<usize> {
895        let start = self.created_byte_range().end;
896        start..start + LongDateTime::RAW_BYTE_LEN
897    }
898
899    pub fn x_min_byte_range(&self) -> Range<usize> {
900        let start = self.modified_byte_range().end;
901        start..start + i16::RAW_BYTE_LEN
902    }
903
904    pub fn y_min_byte_range(&self) -> Range<usize> {
905        let start = self.x_min_byte_range().end;
906        start..start + i16::RAW_BYTE_LEN
907    }
908
909    pub fn x_max_byte_range(&self) -> Range<usize> {
910        let start = self.y_min_byte_range().end;
911        start..start + i16::RAW_BYTE_LEN
912    }
913
914    pub fn y_max_byte_range(&self) -> Range<usize> {
915        let start = self.x_max_byte_range().end;
916        start..start + i16::RAW_BYTE_LEN
917    }
918
919    pub fn mac_style_byte_range(&self) -> Range<usize> {
920        let start = self.y_max_byte_range().end;
921        start..start + MacStyle::RAW_BYTE_LEN
922    }
923
924    pub fn lowest_rec_ppem_byte_range(&self) -> Range<usize> {
925        let start = self.mac_style_byte_range().end;
926        start..start + u16::RAW_BYTE_LEN
927    }
928
929    pub fn font_direction_hint_byte_range(&self) -> Range<usize> {
930        let start = self.lowest_rec_ppem_byte_range().end;
931        start..start + i16::RAW_BYTE_LEN
932    }
933
934    pub fn index_to_loc_format_byte_range(&self) -> Range<usize> {
935        let start = self.font_direction_hint_byte_range().end;
936        start..start + i16::RAW_BYTE_LEN
937    }
938
939    pub fn glyph_data_format_byte_range(&self) -> Range<usize> {
940        let start = self.index_to_loc_format_byte_range().end;
941        start..start + i16::RAW_BYTE_LEN
942    }
943}
944
945#[cfg(feature = "experimental_traverse")]
946impl<'a> SomeTable<'a> for Head<'a> {
947    fn type_name(&self) -> &str {
948        "Head"
949    }
950    fn get_field(&self, idx: usize) -> Option<Field<'a>> {
951        match idx {
952            0usize => Some(Field::new("version", self.version())),
953            1usize => Some(Field::new("font_revision", self.font_revision())),
954            2usize => Some(Field::new(
955                "checksum_adjustment",
956                self.checksum_adjustment(),
957            )),
958            3usize => Some(Field::new("magic_number", self.magic_number())),
959            4usize => Some(Field::new("flags", self.flags())),
960            5usize => Some(Field::new("units_per_em", self.units_per_em())),
961            6usize => Some(Field::new("created", self.created())),
962            7usize => Some(Field::new("modified", self.modified())),
963            8usize => Some(Field::new("x_min", self.x_min())),
964            9usize => Some(Field::new("y_min", self.y_min())),
965            10usize => Some(Field::new("x_max", self.x_max())),
966            11usize => Some(Field::new("y_max", self.y_max())),
967            12usize => Some(Field::new("mac_style", self.mac_style())),
968            13usize => Some(Field::new("lowest_rec_ppem", self.lowest_rec_ppem())),
969            14usize => Some(Field::new(
970                "font_direction_hint",
971                self.font_direction_hint(),
972            )),
973            15usize => Some(Field::new(
974                "index_to_loc_format",
975                self.index_to_loc_format(),
976            )),
977            16usize => Some(Field::new("glyph_data_format", self.glyph_data_format())),
978            _ => None,
979        }
980    }
981}
982
983#[cfg(feature = "experimental_traverse")]
984#[allow(clippy::needless_lifetimes)]
985impl<'a> std::fmt::Debug for Head<'a> {
986    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
987        (self as &dyn SomeTable<'a>).fmt(f)
988    }
989}
read_fonts/generated/generated_head.rs

read_fonts/generated/
generated_head.rs
