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
695/// The [head](https://docs.microsoft.com/en-us/typography/opentype/spec/head)
696/// (font header) table.
697#[derive(Debug, Clone, Copy)]
698#[doc(hidden)]
699pub struct HeadMarker {}
700
701impl HeadMarker {
702    pub fn version_byte_range(&self) -> Range<usize> {
703        let start = 0;
704        start..start + MajorMinor::RAW_BYTE_LEN
705    }
706
707    pub fn font_revision_byte_range(&self) -> Range<usize> {
708        let start = self.version_byte_range().end;
709        start..start + Fixed::RAW_BYTE_LEN
710    }
711
712    pub fn checksum_adjustment_byte_range(&self) -> Range<usize> {
713        let start = self.font_revision_byte_range().end;
714        start..start + u32::RAW_BYTE_LEN
715    }
716
717    pub fn magic_number_byte_range(&self) -> Range<usize> {
718        let start = self.checksum_adjustment_byte_range().end;
719        start..start + u32::RAW_BYTE_LEN
720    }
721
722    pub fn flags_byte_range(&self) -> Range<usize> {
723        let start = self.magic_number_byte_range().end;
724        start..start + Flags::RAW_BYTE_LEN
725    }
726
727    pub fn units_per_em_byte_range(&self) -> Range<usize> {
728        let start = self.flags_byte_range().end;
729        start..start + u16::RAW_BYTE_LEN
730    }
731
732    pub fn created_byte_range(&self) -> Range<usize> {
733        let start = self.units_per_em_byte_range().end;
734        start..start + LongDateTime::RAW_BYTE_LEN
735    }
736
737    pub fn modified_byte_range(&self) -> Range<usize> {
738        let start = self.created_byte_range().end;
739        start..start + LongDateTime::RAW_BYTE_LEN
740    }
741
742    pub fn x_min_byte_range(&self) -> Range<usize> {
743        let start = self.modified_byte_range().end;
744        start..start + i16::RAW_BYTE_LEN
745    }
746
747    pub fn y_min_byte_range(&self) -> Range<usize> {
748        let start = self.x_min_byte_range().end;
749        start..start + i16::RAW_BYTE_LEN
750    }
751
752    pub fn x_max_byte_range(&self) -> Range<usize> {
753        let start = self.y_min_byte_range().end;
754        start..start + i16::RAW_BYTE_LEN
755    }
756
757    pub fn y_max_byte_range(&self) -> Range<usize> {
758        let start = self.x_max_byte_range().end;
759        start..start + i16::RAW_BYTE_LEN
760    }
761
762    pub fn mac_style_byte_range(&self) -> Range<usize> {
763        let start = self.y_max_byte_range().end;
764        start..start + MacStyle::RAW_BYTE_LEN
765    }
766
767    pub fn lowest_rec_ppem_byte_range(&self) -> Range<usize> {
768        let start = self.mac_style_byte_range().end;
769        start..start + u16::RAW_BYTE_LEN
770    }
771
772    pub fn font_direction_hint_byte_range(&self) -> Range<usize> {
773        let start = self.lowest_rec_ppem_byte_range().end;
774        start..start + i16::RAW_BYTE_LEN
775    }
776
777    pub fn index_to_loc_format_byte_range(&self) -> Range<usize> {
778        let start = self.font_direction_hint_byte_range().end;
779        start..start + i16::RAW_BYTE_LEN
780    }
781
782    pub fn glyph_data_format_byte_range(&self) -> Range<usize> {
783        let start = self.index_to_loc_format_byte_range().end;
784        start..start + i16::RAW_BYTE_LEN
785    }
786}
787
788impl MinByteRange for HeadMarker {
789    fn min_byte_range(&self) -> Range<usize> {
790        0..self.glyph_data_format_byte_range().end
791    }
792}
793
794impl TopLevelTable for Head<'_> {
795    /// `head`
796    const TAG: Tag = Tag::new(b"head");
797}
798
799impl<'a> FontRead<'a> for Head<'a> {
800    fn read(data: FontData<'a>) -> Result<Self, ReadError> {
801        let mut cursor = data.cursor();
802        cursor.advance::<MajorMinor>();
803        cursor.advance::<Fixed>();
804        cursor.advance::<u32>();
805        cursor.advance::<u32>();
806        cursor.advance::<Flags>();
807        cursor.advance::<u16>();
808        cursor.advance::<LongDateTime>();
809        cursor.advance::<LongDateTime>();
810        cursor.advance::<i16>();
811        cursor.advance::<i16>();
812        cursor.advance::<i16>();
813        cursor.advance::<i16>();
814        cursor.advance::<MacStyle>();
815        cursor.advance::<u16>();
816        cursor.advance::<i16>();
817        cursor.advance::<i16>();
818        cursor.advance::<i16>();
819        cursor.finish(HeadMarker {})
820    }
821}
822
823/// The [head](https://docs.microsoft.com/en-us/typography/opentype/spec/head)
824/// (font header) table.
825pub type Head<'a> = TableRef<'a, HeadMarker>;
826
827#[allow(clippy::needless_lifetimes)]
828impl<'a> Head<'a> {
829    /// Version number of the font header table, set to (1, 0)
830    pub fn version(&self) -> MajorMinor {
831        let range = self.shape.version_byte_range();
832        self.data.read_at(range.start).unwrap()
833    }
834
835    /// Set by font manufacturer.
836    pub fn font_revision(&self) -> Fixed {
837        let range = self.shape.font_revision_byte_range();
838        self.data.read_at(range.start).unwrap()
839    }
840
841    /// To compute: set it to 0, sum the entire font as uint32, then
842    /// store 0xB1B0AFBA - sum. If the font is used as a component in a
843    /// font collection file, the value of this field will be
844    /// invalidated by changes to the file structure and font table
845    /// directory, and must be ignored.
846    pub fn checksum_adjustment(&self) -> u32 {
847        let range = self.shape.checksum_adjustment_byte_range();
848        self.data.read_at(range.start).unwrap()
849    }
850
851    /// Set to 0x5F0F3CF5.
852    pub fn magic_number(&self) -> u32 {
853        let range = self.shape.magic_number_byte_range();
854        self.data.read_at(range.start).unwrap()
855    }
856
857    /// See the flags enum.
858    pub fn flags(&self) -> Flags {
859        let range = self.shape.flags_byte_range();
860        self.data.read_at(range.start).unwrap()
861    }
862
863    /// Set to a value from 16 to 16384. Any value in this range is
864    /// valid. In fonts that have TrueType outlines, a power of 2 is
865    /// recommended as this allows performance optimizations in some
866    /// rasterizers.
867    pub fn units_per_em(&self) -> u16 {
868        let range = self.shape.units_per_em_byte_range();
869        self.data.read_at(range.start).unwrap()
870    }
871
872    /// Number of seconds since 12:00 midnight that started January 1st
873    /// 1904 in GMT/UTC time zone.
874    pub fn created(&self) -> LongDateTime {
875        let range = self.shape.created_byte_range();
876        self.data.read_at(range.start).unwrap()
877    }
878
879    /// Number of seconds since 12:00 midnight that started January 1st
880    /// 1904 in GMT/UTC time zone.
881    pub fn modified(&self) -> LongDateTime {
882        let range = self.shape.modified_byte_range();
883        self.data.read_at(range.start).unwrap()
884    }
885
886    /// Minimum x coordinate across all glyph bounding boxes.
887    pub fn x_min(&self) -> i16 {
888        let range = self.shape.x_min_byte_range();
889        self.data.read_at(range.start).unwrap()
890    }
891
892    /// Minimum y coordinate across all glyph bounding boxes.
893    pub fn y_min(&self) -> i16 {
894        let range = self.shape.y_min_byte_range();
895        self.data.read_at(range.start).unwrap()
896    }
897
898    /// Maximum x coordinate across all glyph bounding boxes.
899    pub fn x_max(&self) -> i16 {
900        let range = self.shape.x_max_byte_range();
901        self.data.read_at(range.start).unwrap()
902    }
903
904    /// Maximum y coordinate across all glyph bounding boxes.
905    pub fn y_max(&self) -> i16 {
906        let range = self.shape.y_max_byte_range();
907        self.data.read_at(range.start).unwrap()
908    }
909
910    /// Bits identifying the font's style; see [MacStyle]
911    pub fn mac_style(&self) -> MacStyle {
912        let range = self.shape.mac_style_byte_range();
913        self.data.read_at(range.start).unwrap()
914    }
915
916    /// Smallest readable size in pixels.
917    pub fn lowest_rec_ppem(&self) -> u16 {
918        let range = self.shape.lowest_rec_ppem_byte_range();
919        self.data.read_at(range.start).unwrap()
920    }
921
922    /// Deprecated (Set to 2).
923    pub fn font_direction_hint(&self) -> i16 {
924        let range = self.shape.font_direction_hint_byte_range();
925        self.data.read_at(range.start).unwrap()
926    }
927
928    /// 0 for short offsets (Offset16), 1 for long (Offset32).
929    pub fn index_to_loc_format(&self) -> i16 {
930        let range = self.shape.index_to_loc_format_byte_range();
931        self.data.read_at(range.start).unwrap()
932    }
933
934    /// 0 for current format.
935    pub fn glyph_data_format(&self) -> i16 {
936        let range = self.shape.glyph_data_format_byte_range();
937        self.data.read_at(range.start).unwrap()
938    }
939}
940
941#[cfg(feature = "experimental_traverse")]
942impl<'a> SomeTable<'a> for Head<'a> {
943    fn type_name(&self) -> &str {
944        "Head"
945    }
946    fn get_field(&self, idx: usize) -> Option<Field<'a>> {
947        match idx {
948            0usize => Some(Field::new("version", self.version())),
949            1usize => Some(Field::new("font_revision", self.font_revision())),
950            2usize => Some(Field::new(
951                "checksum_adjustment",
952                self.checksum_adjustment(),
953            )),
954            3usize => Some(Field::new("magic_number", self.magic_number())),
955            4usize => Some(Field::new("flags", self.flags())),
956            5usize => Some(Field::new("units_per_em", self.units_per_em())),
957            6usize => Some(Field::new("created", self.created())),
958            7usize => Some(Field::new("modified", self.modified())),
959            8usize => Some(Field::new("x_min", self.x_min())),
960            9usize => Some(Field::new("y_min", self.y_min())),
961            10usize => Some(Field::new("x_max", self.x_max())),
962            11usize => Some(Field::new("y_max", self.y_max())),
963            12usize => Some(Field::new("mac_style", self.mac_style())),
964            13usize => Some(Field::new("lowest_rec_ppem", self.lowest_rec_ppem())),
965            14usize => Some(Field::new(
966                "font_direction_hint",
967                self.font_direction_hint(),
968            )),
969            15usize => Some(Field::new(
970                "index_to_loc_format",
971                self.index_to_loc_format(),
972            )),
973            16usize => Some(Field::new("glyph_data_format", self.glyph_data_format())),
974            _ => None,
975        }
976    }
977}
978
979#[cfg(feature = "experimental_traverse")]
980#[allow(clippy::needless_lifetimes)]
981impl<'a> std::fmt::Debug for Head<'a> {
982    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
983        (self as &dyn SomeTable<'a>).fmt(f)
984    }
985}
read_fonts/generated/generated_head.rs

read_fonts/generated/
generated_head.rs
