Skip to main content

read_fonts/generated/
generated_cpal.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 Cpal<'a> {
9    fn min_byte_range(&self) -> Range<usize> {
10        0..self.color_record_indices_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 Cpal<'_> {
19    /// `CPAL`
20    const TAG: Tag = Tag::new(b"CPAL");
21}
22
23impl ReadArgs for Cpal<'_> {
24    type Args = ();
25}
26
27impl<'a> FontRead<'a> for Cpal<'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 CpalFixedHeader {
45    pub version: BigEndian<u16>,
46    pub num_palette_entries: BigEndian<u16>,
47    pub num_palettes: BigEndian<u16>,
48    pub num_color_records: BigEndian<u16>,
49    pub color_records_array_offset: BigEndian<Nullable<Offset32>>,
50}
51
52#[allow(clippy::absurd_extreme_comparisons)]
53const _: () = assert!(std::mem::size_of::<CpalFixedHeader>() <= Cpal::MIN_SIZE);
54
55/// [CPAL (Color Palette Table)](https://learn.microsoft.com/en-us/typography/opentype/spec/cpal#palette-table-header) table
56#[derive(Clone)]
57pub struct Cpal<'a> {
58    data: TableDataRef<'a, CpalFixedHeader>,
59}
60
61#[allow(clippy::needless_lifetimes)]
62impl<'a> Cpal<'a> {
63    pub const MIN_SIZE: usize = (u16::RAW_BYTE_LEN
64        + u16::RAW_BYTE_LEN
65        + u16::RAW_BYTE_LEN
66        + u16::RAW_BYTE_LEN
67        + Offset32::RAW_BYTE_LEN);
68    basic_table_impls!(impl_the_methods);
69
70    /// Table version number (=0).
71    pub fn version(&self) -> u16 {
72        self.data.header().version.get()
73    }
74
75    /// Number of palette entries in each palette.
76    pub fn num_palette_entries(&self) -> u16 {
77        self.data.header().num_palette_entries.get()
78    }
79
80    /// Number of palettes in the table.
81    pub fn num_palettes(&self) -> u16 {
82        self.data.header().num_palettes.get()
83    }
84
85    /// Total number of color records, combined for all palettes.
86    pub fn num_color_records(&self) -> u16 {
87        self.data.header().num_color_records.get()
88    }
89
90    /// Offset from the beginning of CPAL table to the first
91    /// ColorRecord.
92    pub fn color_records_array_offset(&self) -> Nullable<Offset32> {
93        self.data.header().color_records_array_offset.get()
94    }
95
96    /// Attempt to resolve [`color_records_array_offset`][Self::color_records_array_offset].
97    pub fn color_records_array(&self) -> Option<Result<&'a [ColorRecord], ReadError>> {
98        let data = self.offset_data();
99        let args = self.num_color_records();
100        self.color_records_array_offset()
101            .resolve_with_args(data, args)
102    }
103
104    /// Index of each palette’s first color record in the combined
105    /// color record array.
106    pub fn color_record_indices(&self) -> &'a [BigEndian<u16>] {
107        let range = self.color_record_indices_byte_range();
108        self.offset_data()
109            .read_array(range)
110            .ok()
111            .unwrap_or_default()
112    }
113
114    /// Offset from the beginning of CPAL table to the [Palette Types Array][].
115    ///
116    /// This is an array of 32-bit flag fields that describe properties of each palette.
117    ///
118    /// [Palette Types Array]: https://learn.microsoft.com/en-us/typography/opentype/spec/cpal#palette-type-array
119    pub fn palette_types_array_offset(&self) -> Option<Nullable<Offset32>> {
120        let range = self.palette_types_array_offset_byte_range();
121        (!range.is_empty())
122            .then(|| self.offset_data().read_at(range.start).ok())
123            .flatten()
124    }
125
126    /// Attempt to resolve [`palette_types_array_offset`][Self::palette_types_array_offset].
127    pub fn palette_types_array(&self) -> Option<Result<&'a [BigEndian<PaletteType>], ReadError>> {
128        let data = self.offset_data();
129        let args = self.num_palettes();
130        self.palette_types_array_offset()
131            .map(|x| x.resolve_with_args(data, args))?
132    }
133
134    /// Offset from the beginning of CPAL table to the [Palette Labels Array][].
135    ///
136    /// This is an array of 'name' table IDs (typically in the font-specific name
137    /// ID range) that specify user interface strings associated with  each palette.
138    /// Use 0xFFFF if no name ID is provided for a palette.
139    ///
140    /// [Palette Labels Array]: https://learn.microsoft.com/en-us/typography/opentype/spec/cpal#palette-labels-array
141    pub fn palette_labels_array_offset(&self) -> Option<Nullable<Offset32>> {
142        let range = self.palette_labels_array_offset_byte_range();
143        (!range.is_empty())
144            .then(|| self.offset_data().read_at(range.start).ok())
145            .flatten()
146    }
147
148    /// Attempt to resolve [`palette_labels_array_offset`][Self::palette_labels_array_offset].
149    pub fn palette_labels_array(&self) -> Option<Result<&'a [BigEndian<NameId>], ReadError>> {
150        let data = self.offset_data();
151        let args = self.num_palettes();
152        self.palette_labels_array_offset()
153            .map(|x| x.resolve_with_args(data, args))?
154    }
155
156    /// Offset from the beginning of CPAL table to the [Palette Entry Labels Array][].
157    ///
158    /// This is an array of 'name' table IDs (typically in the font-specific name
159    /// ID range) that specify user interface strings associated with  each palette
160    /// entry, e.g. “Outline”, “Fill”. This set of palette entry labels applies
161    /// to all palettes in the font. Use  0xFFFF if no name ID is provided for a
162    /// palette entry.
163    ///
164    /// [Palette Entry Labels Array]: https://learn.microsoft.com/en-us/typography/opentype/spec/cpal#palette-entry-label-array
165    pub fn palette_entry_labels_array_offset(&self) -> Option<Nullable<Offset32>> {
166        let range = self.palette_entry_labels_array_offset_byte_range();
167        (!range.is_empty())
168            .then(|| self.offset_data().read_at(range.start).ok())
169            .flatten()
170    }
171
172    /// Attempt to resolve [`palette_entry_labels_array_offset`][Self::palette_entry_labels_array_offset].
173    pub fn palette_entry_labels_array(&self) -> Option<Result<&'a [BigEndian<NameId>], ReadError>> {
174        let data = self.offset_data();
175        let args = self.num_palette_entries();
176        self.palette_entry_labels_array_offset()
177            .map(|x| x.resolve_with_args(data, args))?
178    }
179
180    pub fn version_byte_range(&self) -> Range<usize> {
181        let start = 0;
182        let end = start + u16::RAW_BYTE_LEN;
183        start..end
184    }
185
186    pub fn num_palette_entries_byte_range(&self) -> Range<usize> {
187        let start = self.version_byte_range().end;
188        let end = start + u16::RAW_BYTE_LEN;
189        start..end
190    }
191
192    pub fn num_palettes_byte_range(&self) -> Range<usize> {
193        let start = self.num_palette_entries_byte_range().end;
194        let end = start + u16::RAW_BYTE_LEN;
195        start..end
196    }
197
198    pub fn num_color_records_byte_range(&self) -> Range<usize> {
199        let start = self.num_palettes_byte_range().end;
200        let end = start + u16::RAW_BYTE_LEN;
201        start..end
202    }
203
204    pub fn color_records_array_offset_byte_range(&self) -> Range<usize> {
205        let start = self.num_color_records_byte_range().end;
206        let end = start + Offset32::RAW_BYTE_LEN;
207        start..end
208    }
209
210    pub fn color_record_indices_byte_range(&self) -> Range<usize> {
211        let num_palettes = self.num_palettes();
212        let start = self.color_records_array_offset_byte_range().end;
213        let end = start + (transforms::to_usize(num_palettes)).saturating_mul(u16::RAW_BYTE_LEN);
214        start..end
215    }
216
217    pub fn palette_types_array_offset_byte_range(&self) -> Range<usize> {
218        let start = self.color_record_indices_byte_range().end;
219        let end = if self.version().compatible(1u16) {
220            start + Offset32::RAW_BYTE_LEN
221        } else {
222            start
223        };
224        start..end
225    }
226
227    pub fn palette_labels_array_offset_byte_range(&self) -> Range<usize> {
228        let start = self.palette_types_array_offset_byte_range().end;
229        let end = if self.version().compatible(1u16) {
230            start + Offset32::RAW_BYTE_LEN
231        } else {
232            start
233        };
234        start..end
235    }
236
237    pub fn palette_entry_labels_array_offset_byte_range(&self) -> Range<usize> {
238        let start = self.palette_labels_array_offset_byte_range().end;
239        let end = if self.version().compatible(1u16) {
240            start + Offset32::RAW_BYTE_LEN
241        } else {
242            start
243        };
244        start..end
245    }
246}
247
248const _: () = assert!(FontData::default_data_long_enough(Cpal::MIN_SIZE));
249
250impl Default for Cpal<'_> {
251    fn default() -> Self {
252        Self {
253            data: TableDataRef::new(FontData::default_table_data().as_bytes())
254                .unwrap_or_else(|| unreachable!("the default data covers MIN_SIZE")),
255        }
256    }
257}
258
259/// The [PaletteType](https://learn.microsoft.com/en-us/typography/opentype/spec/cpal#palette-type-array) flags.
260#[derive(Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Hash, bytemuck :: AnyBitPattern)]
261#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
262#[repr(transparent)]
263pub struct PaletteType {
264    bits: u32,
265}
266
267impl PaletteType {
268    /// Bit 0: palette is appropriate to use when displaying the font on a light background such as white.
269    pub const USABLE_WITH_LIGHT_BACKGROUND: Self = Self { bits: 0x0001 };
270
271    /// Bit 1: palette is appropriate to use when displaying the font on a dark background such as black.
272    pub const USABLE_WITH_DARK_BACKGROUND: Self = Self { bits: 0x0002 };
273}
274
275impl PaletteType {
276    ///  Returns an empty set of flags.
277    #[inline]
278    pub const fn empty() -> Self {
279        Self { bits: 0 }
280    }
281
282    /// Returns the set containing all flags.
283    #[inline]
284    pub const fn all() -> Self {
285        Self {
286            bits: Self::USABLE_WITH_LIGHT_BACKGROUND.bits | Self::USABLE_WITH_DARK_BACKGROUND.bits,
287        }
288    }
289
290    /// Returns the raw value of the flags currently stored.
291    #[inline]
292    pub const fn bits(&self) -> u32 {
293        self.bits
294    }
295
296    /// Convert from underlying bit representation, unless that
297    /// representation contains bits that do not correspond to a flag.
298    #[inline]
299    pub const fn from_bits(bits: u32) -> Option<Self> {
300        if (bits & !Self::all().bits()) == 0 {
301            Some(Self { bits })
302        } else {
303            None
304        }
305    }
306
307    /// Convert from underlying bit representation, dropping any bits
308    /// that do not correspond to flags.
309    #[inline]
310    pub const fn from_bits_truncate(bits: u32) -> Self {
311        Self {
312            bits: bits & Self::all().bits,
313        }
314    }
315
316    /// Returns `true` if no flags are currently stored.
317    #[inline]
318    pub const fn is_empty(&self) -> bool {
319        self.bits() == Self::empty().bits()
320    }
321
322    /// Returns `true` if there are flags common to both `self` and `other`.
323    #[inline]
324    pub const fn intersects(&self, other: Self) -> bool {
325        !(Self {
326            bits: self.bits & other.bits,
327        })
328        .is_empty()
329    }
330
331    /// Returns `true` if all of the flags in `other` are contained within `self`.
332    #[inline]
333    pub const fn contains(&self, other: Self) -> bool {
334        (self.bits & other.bits) == other.bits
335    }
336
337    /// Inserts the specified flags in-place.
338    #[inline]
339    pub fn insert(&mut self, other: Self) {
340        self.bits |= other.bits;
341    }
342
343    /// Removes the specified flags in-place.
344    #[inline]
345    pub fn remove(&mut self, other: Self) {
346        self.bits &= !other.bits;
347    }
348
349    /// Toggles the specified flags in-place.
350    #[inline]
351    pub fn toggle(&mut self, other: Self) {
352        self.bits ^= other.bits;
353    }
354
355    /// Returns the intersection between the flags in `self` and
356    /// `other`.
357    ///
358    /// Specifically, the returned set contains only the flags which are
359    /// present in *both* `self` *and* `other`.
360    ///
361    /// This is equivalent to using the `&` operator (e.g.
362    /// [`ops::BitAnd`]), as in `flags & other`.
363    ///
364    /// [`ops::BitAnd`]: https://doc.rust-lang.org/std/ops/trait.BitAnd.html
365    #[inline]
366    #[must_use]
367    pub const fn intersection(self, other: Self) -> Self {
368        Self {
369            bits: self.bits & other.bits,
370        }
371    }
372
373    /// Returns the union of between the flags in `self` and `other`.
374    ///
375    /// Specifically, the returned set contains all flags which are
376    /// present in *either* `self` *or* `other`, including any which are
377    /// present in both.
378    ///
379    /// This is equivalent to using the `|` operator (e.g.
380    /// [`ops::BitOr`]), as in `flags | other`.
381    ///
382    /// [`ops::BitOr`]: https://doc.rust-lang.org/std/ops/trait.BitOr.html
383    #[inline]
384    #[must_use]
385    pub const fn union(self, other: Self) -> Self {
386        Self {
387            bits: self.bits | other.bits,
388        }
389    }
390
391    /// Returns the difference between the flags in `self` and `other`.
392    ///
393    /// Specifically, the returned set contains all flags present in
394    /// `self`, except for the ones present in `other`.
395    ///
396    /// It is also conceptually equivalent to the "bit-clear" operation:
397    /// `flags & !other` (and this syntax is also supported).
398    ///
399    /// This is equivalent to using the `-` operator (e.g.
400    /// [`ops::Sub`]), as in `flags - other`.
401    ///
402    /// [`ops::Sub`]: https://doc.rust-lang.org/std/ops/trait.Sub.html
403    #[inline]
404    #[must_use]
405    pub const fn difference(self, other: Self) -> Self {
406        Self {
407            bits: self.bits & !other.bits,
408        }
409    }
410}
411
412impl std::ops::BitOr for PaletteType {
413    type Output = Self;
414
415    /// Returns the union of the two sets of flags.
416    #[inline]
417    fn bitor(self, other: PaletteType) -> Self {
418        Self {
419            bits: self.bits | other.bits,
420        }
421    }
422}
423
424impl std::ops::BitOrAssign for PaletteType {
425    /// Adds the set of flags.
426    #[inline]
427    fn bitor_assign(&mut self, other: Self) {
428        self.bits |= other.bits;
429    }
430}
431
432impl std::ops::BitXor for PaletteType {
433    type Output = Self;
434
435    /// Returns the left flags, but with all the right flags toggled.
436    #[inline]
437    fn bitxor(self, other: Self) -> Self {
438        Self {
439            bits: self.bits ^ other.bits,
440        }
441    }
442}
443
444impl std::ops::BitXorAssign for PaletteType {
445    /// Toggles the set of flags.
446    #[inline]
447    fn bitxor_assign(&mut self, other: Self) {
448        self.bits ^= other.bits;
449    }
450}
451
452impl std::ops::BitAnd for PaletteType {
453    type Output = Self;
454
455    /// Returns the intersection between the two sets of flags.
456    #[inline]
457    fn bitand(self, other: Self) -> Self {
458        Self {
459            bits: self.bits & other.bits,
460        }
461    }
462}
463
464impl std::ops::BitAndAssign for PaletteType {
465    /// Disables all flags disabled in the set.
466    #[inline]
467    fn bitand_assign(&mut self, other: Self) {
468        self.bits &= other.bits;
469    }
470}
471
472impl std::ops::Sub for PaletteType {
473    type Output = Self;
474
475    /// Returns the set difference of the two sets of flags.
476    #[inline]
477    fn sub(self, other: Self) -> Self {
478        Self {
479            bits: self.bits & !other.bits,
480        }
481    }
482}
483
484impl std::ops::SubAssign for PaletteType {
485    /// Disables all flags enabled in the set.
486    #[inline]
487    fn sub_assign(&mut self, other: Self) {
488        self.bits &= !other.bits;
489    }
490}
491
492impl std::ops::Not for PaletteType {
493    type Output = Self;
494
495    /// Returns the complement of this set of flags.
496    #[inline]
497    fn not(self) -> Self {
498        Self { bits: !self.bits } & Self::all()
499    }
500}
501
502impl std::fmt::Debug for PaletteType {
503    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
504        let members: &[(&str, Self)] = &[
505            (
506                "USABLE_WITH_LIGHT_BACKGROUND",
507                Self::USABLE_WITH_LIGHT_BACKGROUND,
508            ),
509            (
510                "USABLE_WITH_DARK_BACKGROUND",
511                Self::USABLE_WITH_DARK_BACKGROUND,
512            ),
513        ];
514        let mut first = true;
515        for (name, value) in members {
516            if self.contains(*value) {
517                if !first {
518                    f.write_str(" | ")?;
519                }
520                first = false;
521                f.write_str(name)?;
522            }
523        }
524        if first {
525            f.write_str("(empty)")?;
526        }
527        Ok(())
528    }
529}
530
531impl std::fmt::Binary for PaletteType {
532    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
533        std::fmt::Binary::fmt(&self.bits, f)
534    }
535}
536
537impl std::fmt::Octal for PaletteType {
538    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
539        std::fmt::Octal::fmt(&self.bits, f)
540    }
541}
542
543impl std::fmt::LowerHex for PaletteType {
544    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
545        std::fmt::LowerHex::fmt(&self.bits, f)
546    }
547}
548
549impl std::fmt::UpperHex for PaletteType {
550    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
551        std::fmt::UpperHex::fmt(&self.bits, f)
552    }
553}
554
555impl font_types::Scalar for PaletteType {
556    type Raw = <u32 as font_types::Scalar>::Raw;
557    fn to_raw(self) -> Self::Raw {
558        self.bits().to_raw()
559    }
560    fn from_raw(raw: Self::Raw) -> Self {
561        let t = <u32>::from_raw(raw);
562        Self::from_bits_truncate(t)
563    }
564}
565
566/// [CPAL (Color Record)](https://learn.microsoft.com/en-us/typography/opentype/spec/cpal#palette-entries-and-color-records) record
567///
568/// Contains a color in non-premultiplied BGRA form, in the sRGB color space.
569#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Copy, bytemuck :: AnyBitPattern)]
570#[repr(C)]
571#[repr(packed)]
572pub struct ColorRecord {
573    /// Blue value (B0).
574    pub blue: u8,
575    /// Green value (B1).
576    pub green: u8,
577    /// Red value (B2).
578    pub red: u8,
579    /// Alpha value (B3).
580    pub alpha: u8,
581}
582
583impl ColorRecord {
584    /// Blue value (B0).
585    pub fn blue(&self) -> u8 {
586        self.blue
587    }
588
589    /// Green value (B1).
590    pub fn green(&self) -> u8 {
591        self.green
592    }
593
594    /// Red value (B2).
595    pub fn red(&self) -> u8 {
596        self.red
597    }
598
599    /// Alpha value (B3).
600    pub fn alpha(&self) -> u8 {
601        self.alpha
602    }
603}
604
605impl FixedSize for ColorRecord {
606    const RAW_BYTE_LEN: usize =
607        u8::RAW_BYTE_LEN + u8::RAW_BYTE_LEN + u8::RAW_BYTE_LEN + u8::RAW_BYTE_LEN;
608}