1#[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 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#[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#[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 pub fn version(&self) -> u16 {
72 self.data.header().version.get()
73 }
74
75 pub fn num_palette_entries(&self) -> u16 {
77 self.data.header().num_palette_entries.get()
78 }
79
80 pub fn num_palettes(&self) -> u16 {
82 self.data.header().num_palettes.get()
83 }
84
85 pub fn num_color_records(&self) -> u16 {
87 self.data.header().num_color_records.get()
88 }
89
90 pub fn color_records_array_offset(&self) -> Nullable<Offset32> {
93 self.data.header().color_records_array_offset.get()
94 }
95
96 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 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 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 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 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 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 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 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#[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 pub const USABLE_WITH_LIGHT_BACKGROUND: Self = Self { bits: 0x0001 };
270
271 pub const USABLE_WITH_DARK_BACKGROUND: Self = Self { bits: 0x0002 };
273}
274
275impl PaletteType {
276 #[inline]
278 pub const fn empty() -> Self {
279 Self { bits: 0 }
280 }
281
282 #[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 #[inline]
292 pub const fn bits(&self) -> u32 {
293 self.bits
294 }
295
296 #[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 #[inline]
310 pub const fn from_bits_truncate(bits: u32) -> Self {
311 Self {
312 bits: bits & Self::all().bits,
313 }
314 }
315
316 #[inline]
318 pub const fn is_empty(&self) -> bool {
319 self.bits() == Self::empty().bits()
320 }
321
322 #[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 #[inline]
333 pub const fn contains(&self, other: Self) -> bool {
334 (self.bits & other.bits) == other.bits
335 }
336
337 #[inline]
339 pub fn insert(&mut self, other: Self) {
340 self.bits |= other.bits;
341 }
342
343 #[inline]
345 pub fn remove(&mut self, other: Self) {
346 self.bits &= !other.bits;
347 }
348
349 #[inline]
351 pub fn toggle(&mut self, other: Self) {
352 self.bits ^= other.bits;
353 }
354
355 #[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 #[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 #[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 #[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 #[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 #[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 #[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 #[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 #[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 #[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 #[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 #[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#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Copy, bytemuck :: AnyBitPattern)]
570#[repr(C)]
571#[repr(packed)]
572pub struct ColorRecord {
573 pub blue: u8,
575 pub green: u8,
577 pub red: u8,
579 pub alpha: u8,
581}
582
583impl ColorRecord {
584 pub fn blue(&self) -> u8 {
586 self.blue
587 }
588
589 pub fn green(&self) -> u8 {
591 self.green
592 }
593
594 pub fn red(&self) -> u8 {
596 self.red
597 }
598
599 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}