1 // Take a look at the license at the top of the repository in the LICENSE file.
2 
3 use std::fmt::{self, Debug};
4 
5 use crate::error::Error;
6 
7 #[cfg(feature = "use_glib")]
8 use glib::translate::*;
9 
10 // Helper macro for our GValue related trait impls
11 #[cfg(feature = "use_glib")]
12 macro_rules! gvalue_impl {
13     ($name:ty, $get_type:expr) => {
14         impl glib::types::StaticType for $name {
15             fn static_type() -> glib::Type {
16                 unsafe { from_glib($get_type()) }
17             }
18         }
19 
20         impl glib::value::ValueType for $name {
21             type Type = Self;
22         }
23 
24         unsafe impl<'a> glib::value::FromValue<'a> for $name {
25             type Checker = glib::value::GenericValueTypeChecker<Self>;
26 
27             unsafe fn from_value(value: &'a glib::Value) -> Self {
28                 Self::from(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
29             }
30         }
31 
32         impl glib::value::ToValue for $name {
33             fn to_value(&self) -> glib::Value {
34                 let mut value = glib::Value::for_value_type::<Self>();
35                 unsafe {
36                     glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, (*self).into());
37                 }
38                 value
39             }
40 
41             fn value_type(&self) -> glib::Type {
42                 <Self as glib::StaticType>::static_type()
43             }
44         }
45     };
46 }
47 
48 #[derive(Clone, PartialEq, PartialOrd, Debug, Copy)]
49 #[non_exhaustive]
50 #[doc(alias = "cairo_antialias_t")]
51 pub enum Antialias {
52     #[doc(alias = "ANTIALIAS_DEFAULT")]
53     Default,
54 
55     /* method */
56     #[doc(alias = "ANTIALIAS_NONE")]
57     None,
58     #[doc(alias = "ANTIALIAS_GRAY")]
59     Gray,
60     #[doc(alias = "ANTIALIAS_SUBPIXEL")]
61     Subpixel,
62 
63     /* hints */
64     #[doc(alias = "ANTIALIAS_FAST")]
65     Fast,
66     #[doc(alias = "ANTIALIAS_GOOD")]
67     Good,
68     #[doc(alias = "ANTIALIAS_BEST")]
69     Best,
70     #[doc(hidden)]
71     __Unknown(i32),
72 }
73 
74 #[doc(hidden)]
75 impl From<Antialias> for ffi::cairo_antialias_t {
from(val: Antialias) -> ffi::cairo_antialias_t76     fn from(val: Antialias) -> ffi::cairo_antialias_t {
77         match val {
78             Antialias::Default => ffi::ANTIALIAS_DEFAULT,
79             Antialias::None => ffi::ANTIALIAS_NONE,
80             Antialias::Gray => ffi::ANTIALIAS_GRAY,
81             Antialias::Subpixel => ffi::ANTIALIAS_SUBPIXEL,
82             Antialias::Fast => ffi::ANTIALIAS_FAST,
83             Antialias::Good => ffi::ANTIALIAS_GOOD,
84             Antialias::Best => ffi::ANTIALIAS_BEST,
85             Antialias::__Unknown(value) => value,
86         }
87     }
88 }
89 
90 #[doc(hidden)]
91 impl From<ffi::cairo_antialias_t> for Antialias {
from(value: ffi::cairo_antialias_t) -> Self92     fn from(value: ffi::cairo_antialias_t) -> Self {
93         match value {
94             ffi::ANTIALIAS_DEFAULT => Self::Default,
95             ffi::ANTIALIAS_NONE => Self::None,
96             ffi::ANTIALIAS_GRAY => Self::Gray,
97             ffi::ANTIALIAS_SUBPIXEL => Self::Subpixel,
98             ffi::ANTIALIAS_FAST => Self::Fast,
99             ffi::ANTIALIAS_GOOD => Self::Good,
100             ffi::ANTIALIAS_BEST => Self::Best,
101             value => Self::__Unknown(value),
102         }
103     }
104 }
105 
106 impl fmt::Display for Antialias {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result107     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
108         write!(
109             f,
110             "Self::{}",
111             match *self {
112                 Self::Default => "Default",
113                 Self::None => "None",
114                 Self::Gray => "Gray",
115                 Self::Subpixel => "Subpixel",
116                 Self::Fast => "Fast",
117                 Self::Good => "Good",
118                 Self::Best => "Best",
119                 _ => "Unknown",
120             }
121         )
122     }
123 }
124 
125 #[cfg(feature = "use_glib")]
126 gvalue_impl!(Antialias, ffi::gobject::cairo_gobject_antialias_get_type);
127 
128 #[derive(Clone, PartialEq, PartialOrd, Debug, Copy)]
129 #[non_exhaustive]
130 #[doc(alias = "cairo_fill_rule_t")]
131 pub enum FillRule {
132     #[doc(alias = "FILL_RULE_WINDING")]
133     Winding,
134     #[doc(alias = "FILL_RULE_EVEN_ODD")]
135     EvenOdd,
136     #[doc(hidden)]
137     __Unknown(i32),
138 }
139 
140 #[doc(hidden)]
141 impl From<FillRule> for ffi::cairo_fill_rule_t {
from(val: FillRule) -> ffi::cairo_fill_rule_t142     fn from(val: FillRule) -> ffi::cairo_fill_rule_t {
143         match val {
144             FillRule::Winding => ffi::FILL_RULE_WINDING,
145             FillRule::EvenOdd => ffi::FILL_RULE_EVEN_ODD,
146             FillRule::__Unknown(value) => value,
147         }
148     }
149 }
150 
151 #[doc(hidden)]
152 impl From<ffi::cairo_fill_rule_t> for FillRule {
from(value: ffi::cairo_fill_rule_t) -> Self153     fn from(value: ffi::cairo_fill_rule_t) -> Self {
154         match value {
155             ffi::FILL_RULE_WINDING => Self::Winding,
156             ffi::FILL_RULE_EVEN_ODD => Self::EvenOdd,
157             value => Self::__Unknown(value),
158         }
159     }
160 }
161 
162 impl fmt::Display for FillRule {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result163     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
164         write!(
165             f,
166             "Self::{}",
167             match *self {
168                 Self::Winding => "Winding",
169                 Self::EvenOdd => "EvenOdd",
170                 _ => "Unknown",
171             }
172         )
173     }
174 }
175 
176 #[cfg(feature = "use_glib")]
177 gvalue_impl!(FillRule, ffi::gobject::cairo_gobject_fill_rule_get_type);
178 
179 #[derive(Clone, PartialEq, PartialOrd, Debug, Copy)]
180 #[non_exhaustive]
181 #[doc(alias = "cairo_line_cap_t")]
182 pub enum LineCap {
183     #[doc(alias = "LINE_CAP_BUTT")]
184     Butt,
185     #[doc(alias = "LINE_CAP_ROUND")]
186     Round,
187     #[doc(alias = "LINE_CAP_SQUARE")]
188     Square,
189     #[doc(hidden)]
190     __Unknown(i32),
191 }
192 
193 #[doc(hidden)]
194 impl From<LineCap> for ffi::cairo_line_cap_t {
from(val: LineCap) -> ffi::cairo_line_cap_t195     fn from(val: LineCap) -> ffi::cairo_line_cap_t {
196         match val {
197             LineCap::Butt => ffi::LINE_CAP_BUTT,
198             LineCap::Round => ffi::LINE_CAP_ROUND,
199             LineCap::Square => ffi::LINE_CAP_SQUARE,
200             LineCap::__Unknown(value) => value,
201         }
202     }
203 }
204 
205 #[doc(hidden)]
206 impl From<ffi::cairo_line_cap_t> for LineCap {
from(value: ffi::cairo_line_cap_t) -> Self207     fn from(value: ffi::cairo_line_cap_t) -> Self {
208         match value {
209             ffi::LINE_CAP_BUTT => Self::Butt,
210             ffi::LINE_CAP_ROUND => Self::Round,
211             ffi::LINE_CAP_SQUARE => Self::Square,
212             value => Self::__Unknown(value),
213         }
214     }
215 }
216 
217 impl fmt::Display for LineCap {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result218     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
219         write!(
220             f,
221             "Self::{}",
222             match *self {
223                 Self::Butt => "Butt",
224                 Self::Round => "Round",
225                 Self::Square => "Square",
226                 _ => "Unknown",
227             }
228         )
229     }
230 }
231 
232 #[cfg(feature = "use_glib")]
233 gvalue_impl!(LineCap, ffi::gobject::cairo_gobject_line_cap_get_type);
234 
235 #[derive(Clone, PartialEq, PartialOrd, Debug, Copy)]
236 #[non_exhaustive]
237 #[doc(alias = "cairo_line_join_t")]
238 pub enum LineJoin {
239     #[doc(alias = "LINE_JOIN_MITER")]
240     Miter,
241     #[doc(alias = "LINE_JOIN_ROUND")]
242     Round,
243     #[doc(alias = "LINE_JOIN_BEVEL")]
244     Bevel,
245     #[doc(hidden)]
246     __Unknown(i32),
247 }
248 
249 #[doc(hidden)]
250 impl From<LineJoin> for ffi::cairo_line_join_t {
from(val: LineJoin) -> ffi::cairo_line_join_t251     fn from(val: LineJoin) -> ffi::cairo_line_join_t {
252         match val {
253             LineJoin::Miter => ffi::LINE_JOIN_MITER,
254             LineJoin::Round => ffi::LINE_JOIN_ROUND,
255             LineJoin::Bevel => ffi::LINE_JOIN_BEVEL,
256             LineJoin::__Unknown(value) => value,
257         }
258     }
259 }
260 
261 #[doc(hidden)]
262 impl From<ffi::cairo_line_join_t> for LineJoin {
from(value: ffi::cairo_line_join_t) -> Self263     fn from(value: ffi::cairo_line_join_t) -> Self {
264         match value {
265             ffi::LINE_JOIN_MITER => Self::Miter,
266             ffi::LINE_JOIN_ROUND => Self::Round,
267             ffi::LINE_JOIN_BEVEL => Self::Bevel,
268             value => Self::__Unknown(value),
269         }
270     }
271 }
272 
273 impl fmt::Display for LineJoin {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result274     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
275         write!(
276             f,
277             "Self::{}",
278             match *self {
279                 Self::Miter => "Miter",
280                 Self::Round => "Round",
281                 Self::Bevel => "Bevel",
282                 _ => "Unknown",
283             }
284         )
285     }
286 }
287 
288 #[cfg(feature = "use_glib")]
289 gvalue_impl!(LineJoin, ffi::gobject::cairo_gobject_line_join_get_type);
290 
291 #[derive(Clone, PartialEq, PartialOrd, Debug, Copy)]
292 #[non_exhaustive]
293 #[doc(alias = "cairo_operator_t")]
294 pub enum Operator {
295     #[doc(alias = "OPERATOR_CLEAR")]
296     Clear,
297 
298     #[doc(alias = "OPERATOR_SOURCE")]
299     Source,
300     #[doc(alias = "OPERATOR_OVER")]
301     Over,
302     #[doc(alias = "OPERATOR_IN")]
303     In,
304     #[doc(alias = "OPERATOR_OUT")]
305     Out,
306     #[doc(alias = "OPERATOR_ATOP")]
307     Atop,
308 
309     #[doc(alias = "OPERATOR_DEST")]
310     Dest,
311     #[doc(alias = "OPERATOR_DEST_OVER")]
312     DestOver,
313     #[doc(alias = "OPERATOR_DEST_IN")]
314     DestIn,
315     #[doc(alias = "OPERATOR_DEST_OUT")]
316     DestOut,
317     #[doc(alias = "OPERATOR_DEST_ATOP")]
318     DestAtop,
319 
320     #[doc(alias = "OPERATOR_XOR")]
321     Xor,
322     #[doc(alias = "OPERATOR_ADD")]
323     Add,
324     #[doc(alias = "OPERATOR_SATURATE")]
325     Saturate,
326 
327     #[doc(alias = "OPERATOR_MULTIPLY")]
328     Multiply,
329     #[doc(alias = "OPERATOR_SCREEN")]
330     Screen,
331     #[doc(alias = "OPERATOR_OVERLAY")]
332     Overlay,
333     #[doc(alias = "OPERATOR_DARKEN")]
334     Darken,
335     #[doc(alias = "OPERATOR_LIGHTEN")]
336     Lighten,
337     #[doc(alias = "OPERATOR_COLOR_DODGE")]
338     ColorDodge,
339     #[doc(alias = "OPERATOR_COLOR_BURN")]
340     ColorBurn,
341     #[doc(alias = "OPERATOR_HARD_LIGHT")]
342     HardLight,
343     #[doc(alias = "OPERATOR_SOFT_LIGHT")]
344     SoftLight,
345     #[doc(alias = "OPERATOR_DIFFERENCE")]
346     Difference,
347     #[doc(alias = "OPERATOR_EXCLUSION")]
348     Exclusion,
349     #[doc(alias = "OPERATOR_HSL_HUE")]
350     HslHue,
351     #[doc(alias = "OPERATOR_HSL_SATURATION")]
352     HslSaturation,
353     #[doc(alias = "OPERATOR_HSL_COLOR")]
354     HslColor,
355     #[doc(alias = "OPERATOR_HSL_LUMINOSITY")]
356     HslLuminosity,
357     #[doc(hidden)]
358     __Unknown(i32),
359 }
360 
361 #[doc(hidden)]
362 impl From<Operator> for ffi::cairo_operator_t {
from(val: Operator) -> ffi::cairo_operator_t363     fn from(val: Operator) -> ffi::cairo_operator_t {
364         match val {
365             Operator::Clear => ffi::OPERATOR_CLEAR,
366             Operator::Source => ffi::OPERATOR_SOURCE,
367             Operator::Over => ffi::OPERATOR_OVER,
368             Operator::In => ffi::OPERATOR_IN,
369             Operator::Out => ffi::OPERATOR_OUT,
370             Operator::Atop => ffi::OPERATOR_ATOP,
371             Operator::Dest => ffi::OPERATOR_DEST,
372             Operator::DestOver => ffi::OPERATOR_DEST_OVER,
373             Operator::DestIn => ffi::OPERATOR_DEST_IN,
374             Operator::DestOut => ffi::OPERATOR_DEST_OUT,
375             Operator::DestAtop => ffi::OPERATOR_DEST_ATOP,
376             Operator::Xor => ffi::OPERATOR_XOR,
377             Operator::Add => ffi::OPERATOR_ADD,
378             Operator::Saturate => ffi::OPERATOR_SATURATE,
379             Operator::Multiply => ffi::OPERATOR_MULTIPLY,
380             Operator::Screen => ffi::OPERATOR_SCREEN,
381             Operator::Overlay => ffi::OPERATOR_OVERLAY,
382             Operator::Darken => ffi::OPERATOR_DARKEN,
383             Operator::Lighten => ffi::OPERATOR_LIGHTEN,
384             Operator::ColorDodge => ffi::OPERATOR_COLOR_DODGE,
385             Operator::ColorBurn => ffi::OPERATOR_COLOR_BURN,
386             Operator::HardLight => ffi::OPERATOR_HARD_LIGHT,
387             Operator::SoftLight => ffi::OPERATOR_SOFT_LIGHT,
388             Operator::Difference => ffi::OPERATOR_DIFFERENCE,
389             Operator::Exclusion => ffi::OPERATOR_EXCLUSION,
390             Operator::HslHue => ffi::OPERATOR_HSL_HUE,
391             Operator::HslSaturation => ffi::OPERATOR_HSL_SATURATION,
392             Operator::HslColor => ffi::OPERATOR_HSL_COLOR,
393             Operator::HslLuminosity => ffi::OPERATOR_HSL_LUMINOSITY,
394             Operator::__Unknown(value) => value,
395         }
396     }
397 }
398 
399 #[doc(hidden)]
400 impl From<ffi::cairo_operator_t> for Operator {
from(value: ffi::cairo_operator_t) -> Self401     fn from(value: ffi::cairo_operator_t) -> Self {
402         match value {
403             ffi::OPERATOR_CLEAR => Self::Clear,
404             ffi::OPERATOR_SOURCE => Self::Source,
405             ffi::OPERATOR_OVER => Self::Over,
406             ffi::OPERATOR_IN => Self::In,
407             ffi::OPERATOR_OUT => Self::Out,
408             ffi::OPERATOR_ATOP => Self::Atop,
409             ffi::OPERATOR_DEST => Self::Dest,
410             ffi::OPERATOR_DEST_OVER => Self::DestOver,
411             ffi::OPERATOR_DEST_IN => Self::DestIn,
412             ffi::OPERATOR_DEST_OUT => Self::DestOut,
413             ffi::OPERATOR_DEST_ATOP => Self::DestAtop,
414             ffi::OPERATOR_XOR => Self::Xor,
415             ffi::OPERATOR_ADD => Self::Add,
416             ffi::OPERATOR_SATURATE => Self::Saturate,
417             ffi::OPERATOR_MULTIPLY => Self::Multiply,
418             ffi::OPERATOR_SCREEN => Self::Screen,
419             ffi::OPERATOR_OVERLAY => Self::Overlay,
420             ffi::OPERATOR_DARKEN => Self::Darken,
421             ffi::OPERATOR_LIGHTEN => Self::Lighten,
422             ffi::OPERATOR_COLOR_DODGE => Self::ColorDodge,
423             ffi::OPERATOR_COLOR_BURN => Self::ColorBurn,
424             ffi::OPERATOR_HARD_LIGHT => Self::HardLight,
425             ffi::OPERATOR_SOFT_LIGHT => Self::SoftLight,
426             ffi::OPERATOR_DIFFERENCE => Self::Difference,
427             ffi::OPERATOR_EXCLUSION => Self::Exclusion,
428             ffi::OPERATOR_HSL_HUE => Self::HslHue,
429             ffi::OPERATOR_HSL_SATURATION => Self::HslSaturation,
430             ffi::OPERATOR_HSL_COLOR => Self::HslColor,
431             ffi::OPERATOR_HSL_LUMINOSITY => Self::HslLuminosity,
432             value => Self::__Unknown(value),
433         }
434     }
435 }
436 
437 impl fmt::Display for Operator {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result438     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
439         write!(
440             f,
441             "Self::{}",
442             match *self {
443                 Self::Clear => "Clear",
444                 Self::Source => "Source",
445                 Self::Over => "Over",
446                 Self::In => "In",
447                 Self::Out => "Out",
448                 Self::Atop => "Atop",
449                 Self::Dest => "Dest",
450                 Self::DestOver => "DestOver",
451                 Self::DestIn => "DestIn",
452                 Self::DestOut => "DestOut",
453                 Self::DestAtop => "DestAtop",
454                 Self::Xor => "Xor",
455                 Self::Add => "Add",
456                 Self::Saturate => "Saturate",
457                 Self::Multiply => "Multiply",
458                 Self::Screen => "Screen",
459                 Self::Overlay => "Overlay",
460                 Self::Darken => "Darken",
461                 Self::Lighten => "Lighten",
462                 Self::ColorDodge => "ColorDodge",
463                 Self::ColorBurn => "ColorBurn",
464                 Self::HardLight => "HardLight",
465                 Self::SoftLight => "SoftLight",
466                 Self::Difference => "Difference",
467                 Self::Exclusion => "Exclusion",
468                 Self::HslHue => "HslHue",
469                 Self::HslSaturation => "HslSaturation",
470                 Self::HslColor => "HslColor",
471                 Self::HslLuminosity => "HslLuminosity",
472                 _ => "Unknown",
473             }
474         )
475     }
476 }
477 
478 #[cfg(feature = "use_glib")]
479 gvalue_impl!(Operator, ffi::gobject::cairo_gobject_operator_get_type);
480 
481 #[derive(Clone, PartialEq, PartialOrd, Debug, Copy)]
482 #[non_exhaustive]
483 #[doc(alias = "cairo_path_data_type_t")]
484 pub enum PathDataType {
485     #[doc(alias = "PATH_DATA_TYPE_MOVE_TO")]
486     MoveTo,
487     #[doc(alias = "PATH_DATA_TYPE_LINE_TO")]
488     LineTo,
489     #[doc(alias = "PATH_DATA_TYPE_CURVE_TO")]
490     CurveTo,
491     #[doc(alias = "PATH_DATA_TYPE_CLOSE_PATH")]
492     ClosePath,
493     #[doc(hidden)]
494     __Unknown(i32),
495 }
496 
497 #[doc(hidden)]
498 impl From<PathDataType> for ffi::cairo_path_data_type_t {
from(val: PathDataType) -> ffi::cairo_path_data_type_t499     fn from(val: PathDataType) -> ffi::cairo_path_data_type_t {
500         match val {
501             PathDataType::MoveTo => ffi::PATH_DATA_TYPE_MOVE_TO,
502             PathDataType::LineTo => ffi::PATH_DATA_TYPE_LINE_TO,
503             PathDataType::CurveTo => ffi::PATH_DATA_TYPE_CURVE_TO,
504             PathDataType::ClosePath => ffi::PATH_DATA_TYPE_CLOSE_PATH,
505             PathDataType::__Unknown(value) => value,
506         }
507     }
508 }
509 
510 #[doc(hidden)]
511 impl From<ffi::cairo_path_data_type_t> for PathDataType {
from(value: ffi::cairo_path_data_type_t) -> Self512     fn from(value: ffi::cairo_path_data_type_t) -> Self {
513         match value {
514             ffi::PATH_DATA_TYPE_MOVE_TO => Self::MoveTo,
515             ffi::PATH_DATA_TYPE_LINE_TO => Self::LineTo,
516             ffi::PATH_DATA_TYPE_CURVE_TO => Self::CurveTo,
517             ffi::PATH_DATA_TYPE_CLOSE_PATH => Self::ClosePath,
518             value => Self::__Unknown(value),
519         }
520     }
521 }
522 
523 impl fmt::Display for PathDataType {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result524     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
525         write!(
526             f,
527             "Self::{}",
528             match *self {
529                 Self::MoveTo => "MoveTo",
530                 Self::LineTo => "LineTo",
531                 Self::CurveTo => "CurveTo",
532                 Self::ClosePath => "ClosePath",
533                 _ => "Unknown",
534             }
535         )
536     }
537 }
538 
539 #[cfg(feature = "use_glib")]
540 gvalue_impl!(
541     PathDataType,
542     ffi::gobject::cairo_gobject_path_data_type_get_type
543 );
544 
545 #[derive(Clone, PartialEq, PartialOrd, Debug, Copy)]
546 #[non_exhaustive]
547 #[doc(alias = "cairo_content_t")]
548 pub enum Content {
549     #[doc(alias = "CONTENT_COLOR")]
550     Color,
551     #[doc(alias = "CONTENT_ALPHA")]
552     Alpha,
553     #[doc(alias = "CONTENT_COLOR_ALPHA")]
554     ColorAlpha,
555     #[doc(hidden)]
556     __Unknown(i32),
557 }
558 
559 #[doc(hidden)]
560 impl From<Content> for ffi::cairo_content_t {
from(val: Content) -> ffi::cairo_content_t561     fn from(val: Content) -> ffi::cairo_content_t {
562         match val {
563             Content::Color => ffi::CONTENT_COLOR,
564             Content::Alpha => ffi::CONTENT_ALPHA,
565             Content::ColorAlpha => ffi::CONTENT_COLOR_ALPHA,
566             Content::__Unknown(value) => value,
567         }
568     }
569 }
570 
571 #[doc(hidden)]
572 impl From<ffi::cairo_content_t> for Content {
from(value: ffi::cairo_content_t) -> Self573     fn from(value: ffi::cairo_content_t) -> Self {
574         match value {
575             ffi::CONTENT_COLOR => Self::Color,
576             ffi::CONTENT_ALPHA => Self::Alpha,
577             ffi::CONTENT_COLOR_ALPHA => Self::ColorAlpha,
578             value => Self::__Unknown(value),
579         }
580     }
581 }
582 
583 impl fmt::Display for Content {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result584     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
585         write!(
586             f,
587             "Self::{}",
588             match *self {
589                 Self::Color => "Color",
590                 Self::Alpha => "Alpha",
591                 Self::ColorAlpha => "ColorAlpha",
592                 _ => "Unknown",
593             }
594         )
595     }
596 }
597 
598 #[cfg(feature = "use_glib")]
599 gvalue_impl!(Content, ffi::gobject::cairo_gobject_content_get_type);
600 
601 #[derive(Clone, PartialEq, PartialOrd, Debug, Copy)]
602 #[non_exhaustive]
603 #[doc(alias = "cairo_extend_t")]
604 pub enum Extend {
605     #[doc(alias = "EXTEND_NONE")]
606     None,
607     #[doc(alias = "EXTEND_REPEAT")]
608     Repeat,
609     #[doc(alias = "EXTEND_REFLECT")]
610     Reflect,
611     #[doc(alias = "EXTEND_PAD")]
612     Pad,
613     #[doc(hidden)]
614     __Unknown(i32),
615 }
616 
617 #[doc(hidden)]
618 impl From<Extend> for ffi::cairo_extend_t {
from(val: Extend) -> ffi::cairo_extend_t619     fn from(val: Extend) -> ffi::cairo_extend_t {
620         match val {
621             Extend::None => ffi::EXTEND_NONE,
622             Extend::Repeat => ffi::EXTEND_REPEAT,
623             Extend::Reflect => ffi::EXTEND_REFLECT,
624             Extend::Pad => ffi::EXTEND_PAD,
625             Extend::__Unknown(value) => value,
626         }
627     }
628 }
629 
630 #[doc(hidden)]
631 impl From<ffi::cairo_extend_t> for Extend {
from(value: ffi::cairo_extend_t) -> Self632     fn from(value: ffi::cairo_extend_t) -> Self {
633         match value {
634             ffi::EXTEND_NONE => Self::None,
635             ffi::EXTEND_REPEAT => Self::Repeat,
636             ffi::EXTEND_REFLECT => Self::Reflect,
637             ffi::EXTEND_PAD => Self::Pad,
638             value => Self::__Unknown(value),
639         }
640     }
641 }
642 
643 impl fmt::Display for Extend {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result644     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
645         write!(
646             f,
647             "Self::{}",
648             match *self {
649                 Self::None => "None",
650                 Self::Repeat => "Repeat",
651                 Self::Reflect => "Reflect",
652                 Self::Pad => "Pad",
653                 _ => "Unknown",
654             }
655         )
656     }
657 }
658 
659 #[cfg(feature = "use_glib")]
660 gvalue_impl!(Extend, ffi::gobject::cairo_gobject_extend_get_type);
661 
662 #[derive(Clone, PartialEq, PartialOrd, Debug, Copy)]
663 #[non_exhaustive]
664 #[doc(alias = "cairo_filter_t")]
665 pub enum Filter {
666     #[doc(alias = "FILTER_FAST")]
667     Fast,
668     #[doc(alias = "FILTER_GOOD")]
669     Good,
670     #[doc(alias = "FILTER_BEST")]
671     Best,
672     #[doc(alias = "FILTER_NEAREST")]
673     Nearest,
674     #[doc(alias = "FILTER_BILINEAR")]
675     Bilinear,
676     #[doc(alias = "FILTER_GAUSSIAN")]
677     Gaussian,
678     #[doc(hidden)]
679     __Unknown(i32),
680 }
681 
682 #[doc(hidden)]
683 impl From<Filter> for ffi::cairo_filter_t {
from(val: Filter) -> ffi::cairo_filter_t684     fn from(val: Filter) -> ffi::cairo_filter_t {
685         match val {
686             Filter::Fast => ffi::FILTER_FAST,
687             Filter::Good => ffi::FILTER_GOOD,
688             Filter::Best => ffi::FILTER_BEST,
689             Filter::Nearest => ffi::FILTER_NEAREST,
690             Filter::Bilinear => ffi::FILTER_BILINEAR,
691             Filter::Gaussian => ffi::FILTER_GAUSSIAN,
692             Filter::__Unknown(value) => value,
693         }
694     }
695 }
696 
697 #[doc(hidden)]
698 impl From<ffi::cairo_filter_t> for Filter {
from(value: ffi::cairo_filter_t) -> Self699     fn from(value: ffi::cairo_filter_t) -> Self {
700         match value {
701             ffi::FILTER_FAST => Self::Fast,
702             ffi::FILTER_GOOD => Self::Good,
703             ffi::FILTER_BEST => Self::Best,
704             ffi::FILTER_NEAREST => Self::Nearest,
705             ffi::FILTER_BILINEAR => Self::Bilinear,
706             ffi::FILTER_GAUSSIAN => Self::Gaussian,
707             value => Self::__Unknown(value),
708         }
709     }
710 }
711 
712 impl fmt::Display for Filter {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result713     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
714         write!(
715             f,
716             "Self::{}",
717             match *self {
718                 Self::Fast => "Fast",
719                 Self::Good => "Good",
720                 Self::Best => "Best",
721                 Self::Nearest => "Nearest",
722                 Self::Bilinear => "Bilinear",
723                 Self::Gaussian => "Gaussian",
724                 _ => "Unknown",
725             }
726         )
727     }
728 }
729 
730 #[cfg(feature = "use_glib")]
731 gvalue_impl!(Filter, ffi::gobject::cairo_gobject_filter_get_type);
732 
733 #[derive(Clone, PartialEq, PartialOrd, Debug, Copy)]
734 #[non_exhaustive]
735 #[doc(alias = "cairo_pattern_type_t")]
736 pub enum PatternType {
737     #[doc(alias = "PATTERN_TYPE_SOLID")]
738     Solid,
739     #[doc(alias = "PATTERN_TYPE_SURFACE")]
740     Surface,
741     #[doc(alias = "PATTERN_TYPE_LINEAR_GRADIENT")]
742     LinearGradient,
743     #[doc(alias = "PATTERN_TYPE_RADIAL_GRADIENT")]
744     RadialGradient,
745     #[doc(alias = "PATTERN_TYPE_MESH")]
746     Mesh,
747     #[doc(alias = "PATTERN_TYPE_RASTER_SOURCE")]
748     RasterSource,
749     #[doc(hidden)]
750     __Unknown(i32),
751 }
752 
753 #[doc(hidden)]
754 impl From<PatternType> for ffi::cairo_pattern_type_t {
from(val: PatternType) -> ffi::cairo_pattern_type_t755     fn from(val: PatternType) -> ffi::cairo_pattern_type_t {
756         match val {
757             PatternType::Solid => ffi::PATTERN_TYPE_SOLID,
758             PatternType::Surface => ffi::PATTERN_TYPE_SURFACE,
759             PatternType::LinearGradient => ffi::PATTERN_TYPE_LINEAR_GRADIENT,
760             PatternType::RadialGradient => ffi::PATTERN_TYPE_RADIAL_GRADIENT,
761             PatternType::Mesh => ffi::PATTERN_TYPE_MESH,
762             PatternType::RasterSource => ffi::PATTERN_TYPE_RASTER_SOURCE,
763             PatternType::__Unknown(value) => value,
764         }
765     }
766 }
767 
768 #[doc(hidden)]
769 impl From<ffi::cairo_pattern_type_t> for PatternType {
from(value: ffi::cairo_pattern_type_t) -> Self770     fn from(value: ffi::cairo_pattern_type_t) -> Self {
771         match value {
772             ffi::PATTERN_TYPE_SOLID => Self::Solid,
773             ffi::PATTERN_TYPE_SURFACE => Self::Surface,
774             ffi::PATTERN_TYPE_LINEAR_GRADIENT => Self::LinearGradient,
775             ffi::PATTERN_TYPE_RADIAL_GRADIENT => Self::RadialGradient,
776             ffi::PATTERN_TYPE_MESH => Self::Mesh,
777             ffi::PATTERN_TYPE_RASTER_SOURCE => Self::RasterSource,
778             value => Self::__Unknown(value),
779         }
780     }
781 }
782 
783 impl fmt::Display for PatternType {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result784     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
785         write!(
786             f,
787             "Self::{}",
788             match *self {
789                 Self::Solid => "Solid",
790                 Self::Surface => "Surface",
791                 Self::LinearGradient => "LinearGradient",
792                 Self::RadialGradient => "RadialGradient",
793                 Self::Mesh => "Mesh",
794                 Self::RasterSource => "RasterSource",
795                 _ => "Unknown",
796             }
797         )
798     }
799 }
800 
801 #[cfg(feature = "use_glib")]
802 gvalue_impl!(
803     PatternType,
804     ffi::gobject::cairo_gobject_pattern_type_get_type
805 );
806 
807 #[derive(Clone, PartialEq, PartialOrd, Debug, Copy)]
808 #[non_exhaustive]
809 #[doc(alias = "cairo_font_slant_t")]
810 pub enum FontSlant {
811     #[doc(alias = "FONT_SLANT_NORMAL")]
812     Normal,
813     #[doc(alias = "FONT_SLANT_ITALIC")]
814     Italic,
815     #[doc(alias = "FONT_SLANT_OBLIQUE")]
816     Oblique,
817     #[doc(hidden)]
818     __Unknown(i32),
819 }
820 
821 #[doc(hidden)]
822 impl From<FontSlant> for ffi::cairo_font_slant_t {
from(val: FontSlant) -> ffi::cairo_font_slant_t823     fn from(val: FontSlant) -> ffi::cairo_font_slant_t {
824         match val {
825             FontSlant::Normal => ffi::FONT_SLANT_NORMAL,
826             FontSlant::Italic => ffi::FONT_SLANT_ITALIC,
827             FontSlant::Oblique => ffi::FONT_SLANT_OBLIQUE,
828             FontSlant::__Unknown(value) => value,
829         }
830     }
831 }
832 
833 #[doc(hidden)]
834 impl From<ffi::cairo_font_slant_t> for FontSlant {
from(value: ffi::cairo_font_slant_t) -> Self835     fn from(value: ffi::cairo_font_slant_t) -> Self {
836         match value {
837             ffi::FONT_SLANT_NORMAL => Self::Normal,
838             ffi::FONT_SLANT_ITALIC => Self::Italic,
839             ffi::FONT_SLANT_OBLIQUE => Self::Oblique,
840             value => Self::__Unknown(value),
841         }
842     }
843 }
844 
845 impl fmt::Display for FontSlant {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result846     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
847         write!(
848             f,
849             "Self::{}",
850             match *self {
851                 Self::Normal => "Normal",
852                 Self::Italic => "Italic",
853                 Self::Oblique => "Oblique",
854                 _ => "Unknown",
855             }
856         )
857     }
858 }
859 
860 #[cfg(feature = "use_glib")]
861 gvalue_impl!(FontSlant, ffi::gobject::cairo_gobject_font_slant_get_type);
862 
863 #[derive(Clone, PartialEq, PartialOrd, Debug, Copy)]
864 #[non_exhaustive]
865 #[doc(alias = "cairo_font_weight_t")]
866 pub enum FontWeight {
867     #[doc(alias = "FONT_WEIGHT_NORMAL")]
868     Normal,
869     #[doc(alias = "FONT_WEIGHT_BOLD")]
870     Bold,
871     #[doc(hidden)]
872     __Unknown(i32),
873 }
874 
875 #[doc(hidden)]
876 impl From<FontWeight> for ffi::cairo_font_weight_t {
from(val: FontWeight) -> ffi::cairo_font_weight_t877     fn from(val: FontWeight) -> ffi::cairo_font_weight_t {
878         match val {
879             FontWeight::Normal => ffi::FONT_WEIGHT_NORMAL,
880             FontWeight::Bold => ffi::FONT_WEIGHT_BOLD,
881             FontWeight::__Unknown(value) => value,
882         }
883     }
884 }
885 
886 #[doc(hidden)]
887 impl From<ffi::cairo_font_weight_t> for FontWeight {
from(value: ffi::cairo_font_weight_t) -> Self888     fn from(value: ffi::cairo_font_weight_t) -> Self {
889         match value {
890             ffi::FONT_WEIGHT_NORMAL => Self::Normal,
891             ffi::FONT_WEIGHT_BOLD => Self::Bold,
892             value => Self::__Unknown(value),
893         }
894     }
895 }
896 
897 impl fmt::Display for FontWeight {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result898     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
899         write!(
900             f,
901             "Self::{}",
902             match *self {
903                 Self::Normal => "Normal",
904                 Self::Bold => "Bold",
905                 _ => "Unknown",
906             }
907         )
908     }
909 }
910 
911 #[cfg(feature = "use_glib")]
912 gvalue_impl!(FontWeight, ffi::gobject::cairo_gobject_font_weight_get_type);
913 
914 #[derive(Clone, PartialEq, PartialOrd, Debug, Copy)]
915 #[non_exhaustive]
916 #[doc(alias = "cairo_text_cluster_flags_t")]
917 pub enum TextClusterFlags {
918     #[doc(alias = "TEXT_CLUSTER_FLAGS_NONE")]
919     None,
920     #[doc(alias = "TEXT_CLUSTER_FLAGS_BACKWARD")]
921     Backward,
922     #[doc(hidden)]
923     __Unknown(i32),
924 }
925 
926 #[doc(hidden)]
927 impl From<TextClusterFlags> for ffi::cairo_text_cluster_flags_t {
from(val: TextClusterFlags) -> ffi::cairo_text_cluster_flags_t928     fn from(val: TextClusterFlags) -> ffi::cairo_text_cluster_flags_t {
929         match val {
930             TextClusterFlags::None => ffi::TEXT_CLUSTER_FLAGS_NONE,
931             TextClusterFlags::Backward => ffi::TEXT_CLUSTER_FLAGS_BACKWARD,
932             TextClusterFlags::__Unknown(value) => value,
933         }
934     }
935 }
936 
937 #[doc(hidden)]
938 impl From<ffi::cairo_text_cluster_flags_t> for TextClusterFlags {
from(value: ffi::cairo_text_cluster_flags_t) -> Self939     fn from(value: ffi::cairo_text_cluster_flags_t) -> Self {
940         match value {
941             ffi::TEXT_CLUSTER_FLAGS_NONE => Self::None,
942             ffi::TEXT_CLUSTER_FLAGS_BACKWARD => Self::Backward,
943             value => Self::__Unknown(value),
944         }
945     }
946 }
947 
948 impl fmt::Display for TextClusterFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result949     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
950         write!(
951             f,
952             "Self::{}",
953             match *self {
954                 Self::None => "None",
955                 Self::Backward => "Backward",
956                 _ => "Unknown",
957             }
958         )
959     }
960 }
961 
962 #[cfg(feature = "use_glib")]
963 gvalue_impl!(
964     TextClusterFlags,
965     ffi::gobject::cairo_gobject_text_cluster_flags_get_type
966 );
967 
968 #[derive(Clone, PartialEq, PartialOrd, Debug, Copy)]
969 #[non_exhaustive]
970 #[doc(alias = "cairo_font_type_t")]
971 pub enum FontType {
972     #[doc(alias = "FONT_TYPE_FONT_TYPE_TOY")]
973     FontTypeToy,
974     #[doc(alias = "FONT_TYPE_FONT_TYPE_FT")]
975     FontTypeFt,
976     #[doc(alias = "FONT_TYPE_FONT_TYPE_WIN32")]
977     FontTypeWin32,
978     #[doc(alias = "FONT_TYPE_FONT_TYPE_QUARTZ")]
979     FontTypeQuartz,
980     #[doc(alias = "FONT_TYPE_FONT_TYPE_USER")]
981     FontTypeUser,
982     #[doc(hidden)]
983     __Unknown(i32),
984 }
985 
986 #[doc(hidden)]
987 impl From<FontType> for ffi::cairo_font_type_t {
from(val: FontType) -> ffi::cairo_font_type_t988     fn from(val: FontType) -> ffi::cairo_font_type_t {
989         match val {
990             FontType::FontTypeToy => ffi::FONT_TYPE_FONT_TYPE_TOY,
991             FontType::FontTypeFt => ffi::FONT_TYPE_FONT_TYPE_FT,
992             FontType::FontTypeWin32 => ffi::FONT_TYPE_FONT_TYPE_WIN32,
993             FontType::FontTypeQuartz => ffi::FONT_TYPE_FONT_TYPE_QUARTZ,
994             FontType::FontTypeUser => ffi::FONT_TYPE_FONT_TYPE_USER,
995             FontType::__Unknown(value) => value,
996         }
997     }
998 }
999 
1000 #[doc(hidden)]
1001 impl From<ffi::cairo_font_type_t> for FontType {
from(value: ffi::cairo_font_type_t) -> Self1002     fn from(value: ffi::cairo_font_type_t) -> Self {
1003         match value {
1004             ffi::FONT_TYPE_FONT_TYPE_TOY => Self::FontTypeToy,
1005             ffi::FONT_TYPE_FONT_TYPE_FT => Self::FontTypeFt,
1006             ffi::FONT_TYPE_FONT_TYPE_WIN32 => Self::FontTypeWin32,
1007             ffi::FONT_TYPE_FONT_TYPE_QUARTZ => Self::FontTypeQuartz,
1008             ffi::FONT_TYPE_FONT_TYPE_USER => Self::FontTypeUser,
1009             value => Self::__Unknown(value),
1010         }
1011     }
1012 }
1013 
1014 impl fmt::Display for FontType {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1015     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1016         write!(
1017             f,
1018             "Self::{}",
1019             match *self {
1020                 Self::FontTypeToy => "FontTypeToy",
1021                 Self::FontTypeFt => "FontTypeFt",
1022                 Self::FontTypeWin32 => "FontTypeWin32",
1023                 Self::FontTypeQuartz => "FontTypeQuartz",
1024                 Self::FontTypeUser => "FontTypeUser",
1025                 _ => "Unknown",
1026             }
1027         )
1028     }
1029 }
1030 
1031 #[cfg(feature = "use_glib")]
1032 gvalue_impl!(FontType, ffi::gobject::cairo_gobject_font_type_get_type);
1033 
1034 #[derive(Clone, PartialEq, PartialOrd, Debug, Copy)]
1035 #[non_exhaustive]
1036 #[doc(alias = "cairo_subpixel_order_t")]
1037 pub enum SubpixelOrder {
1038     #[doc(alias = "SUBPIXEL_ORDER_DEFAULT")]
1039     Default,
1040     #[doc(alias = "SUBPIXEL_ORDER_RGB")]
1041     Rgb,
1042     #[doc(alias = "SUBPIXEL_ORDER_BGR")]
1043     Bgr,
1044     #[doc(alias = "SUBPIXEL_ORDER_VRGB")]
1045     Vrgb,
1046     #[doc(alias = "SUBPIXEL_ORDER_VBGR")]
1047     Vbgr,
1048     #[doc(hidden)]
1049     __Unknown(i32),
1050 }
1051 
1052 #[doc(hidden)]
1053 impl From<SubpixelOrder> for ffi::cairo_subpixel_order_t {
from(val: SubpixelOrder) -> ffi::cairo_subpixel_order_t1054     fn from(val: SubpixelOrder) -> ffi::cairo_subpixel_order_t {
1055         match val {
1056             SubpixelOrder::Default => ffi::SUBPIXEL_ORDER_DEFAULT,
1057             SubpixelOrder::Rgb => ffi::SUBPIXEL_ORDER_RGB,
1058             SubpixelOrder::Bgr => ffi::SUBPIXEL_ORDER_BGR,
1059             SubpixelOrder::Vrgb => ffi::SUBPIXEL_ORDER_VRGB,
1060             SubpixelOrder::Vbgr => ffi::SUBPIXEL_ORDER_VBGR,
1061             SubpixelOrder::__Unknown(value) => value,
1062         }
1063     }
1064 }
1065 
1066 #[doc(hidden)]
1067 impl From<ffi::cairo_subpixel_order_t> for SubpixelOrder {
from(value: ffi::cairo_subpixel_order_t) -> Self1068     fn from(value: ffi::cairo_subpixel_order_t) -> Self {
1069         match value {
1070             ffi::SUBPIXEL_ORDER_DEFAULT => Self::Default,
1071             ffi::SUBPIXEL_ORDER_RGB => Self::Rgb,
1072             ffi::SUBPIXEL_ORDER_BGR => Self::Bgr,
1073             ffi::SUBPIXEL_ORDER_VRGB => Self::Vrgb,
1074             ffi::SUBPIXEL_ORDER_VBGR => Self::Vbgr,
1075             value => Self::__Unknown(value),
1076         }
1077     }
1078 }
1079 
1080 impl fmt::Display for SubpixelOrder {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1081     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1082         write!(
1083             f,
1084             "Self::{}",
1085             match *self {
1086                 Self::Default => "Default",
1087                 Self::Rgb => "Rgb",
1088                 Self::Bgr => "Bgr",
1089                 Self::Vrgb => "Vrgb",
1090                 Self::Vbgr => "Vbgr",
1091                 _ => "Unknown",
1092             }
1093         )
1094     }
1095 }
1096 
1097 #[cfg(feature = "use_glib")]
1098 gvalue_impl!(
1099     SubpixelOrder,
1100     ffi::gobject::cairo_gobject_subpixel_order_get_type
1101 );
1102 
1103 #[derive(Clone, PartialEq, PartialOrd, Debug, Copy)]
1104 #[non_exhaustive]
1105 #[doc(alias = "cairo_hint_style_t")]
1106 pub enum HintStyle {
1107     #[doc(alias = "HINT_STYLE_DEFAULT")]
1108     Default,
1109     #[doc(alias = "HINT_STYLE_NONE")]
1110     None,
1111     #[doc(alias = "HINT_STYLE_SLIGHT")]
1112     Slight,
1113     #[doc(alias = "HINT_STYLE_MEDIUM")]
1114     Medium,
1115     #[doc(alias = "HINT_STYLE_FULL")]
1116     Full,
1117     #[doc(hidden)]
1118     __Unknown(i32),
1119 }
1120 
1121 #[doc(hidden)]
1122 impl From<HintStyle> for ffi::cairo_hint_style_t {
from(val: HintStyle) -> ffi::cairo_hint_style_t1123     fn from(val: HintStyle) -> ffi::cairo_hint_style_t {
1124         match val {
1125             HintStyle::Default => ffi::HINT_STYLE_DEFAULT,
1126             HintStyle::None => ffi::HINT_STYLE_NONE,
1127             HintStyle::Slight => ffi::HINT_STYLE_SLIGHT,
1128             HintStyle::Medium => ffi::HINT_STYLE_MEDIUM,
1129             HintStyle::Full => ffi::HINT_STYLE_FULL,
1130             HintStyle::__Unknown(value) => value,
1131         }
1132     }
1133 }
1134 
1135 #[doc(hidden)]
1136 impl From<ffi::cairo_hint_style_t> for HintStyle {
from(value: ffi::cairo_hint_style_t) -> Self1137     fn from(value: ffi::cairo_hint_style_t) -> Self {
1138         match value {
1139             ffi::HINT_STYLE_DEFAULT => Self::Default,
1140             ffi::HINT_STYLE_NONE => Self::None,
1141             ffi::HINT_STYLE_SLIGHT => Self::Slight,
1142             ffi::HINT_STYLE_MEDIUM => Self::Medium,
1143             ffi::HINT_STYLE_FULL => Self::Full,
1144             value => Self::__Unknown(value),
1145         }
1146     }
1147 }
1148 
1149 impl fmt::Display for HintStyle {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1150     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1151         write!(
1152             f,
1153             "Self::{}",
1154             match *self {
1155                 Self::Default => "Default",
1156                 Self::None => "None",
1157                 Self::Slight => "Slight",
1158                 Self::Medium => "Medium",
1159                 Self::Full => "Full",
1160                 _ => "Unknown",
1161             }
1162         )
1163     }
1164 }
1165 
1166 #[cfg(feature = "use_glib")]
1167 gvalue_impl!(HintStyle, ffi::gobject::cairo_gobject_hint_style_get_type);
1168 
1169 #[derive(Clone, PartialEq, PartialOrd, Debug, Copy)]
1170 #[non_exhaustive]
1171 #[doc(alias = "cairo_hint_metrics_t")]
1172 pub enum HintMetrics {
1173     #[doc(alias = "HINT_METRICS_DEFAULT")]
1174     Default,
1175     #[doc(alias = "HINT_METRICS_OFF")]
1176     Off,
1177     #[doc(alias = "HINT_METRICS_ON")]
1178     On,
1179     #[doc(hidden)]
1180     __Unknown(i32),
1181 }
1182 
1183 #[doc(hidden)]
1184 impl From<HintMetrics> for ffi::cairo_hint_metrics_t {
from(val: HintMetrics) -> ffi::cairo_hint_metrics_t1185     fn from(val: HintMetrics) -> ffi::cairo_hint_metrics_t {
1186         match val {
1187             HintMetrics::Default => ffi::HINT_METRICS_DEFAULT,
1188             HintMetrics::Off => ffi::HINT_METRICS_OFF,
1189             HintMetrics::On => ffi::HINT_METRICS_ON,
1190             HintMetrics::__Unknown(value) => value,
1191         }
1192     }
1193 }
1194 
1195 #[doc(hidden)]
1196 impl From<ffi::cairo_hint_metrics_t> for HintMetrics {
from(value: ffi::cairo_hint_metrics_t) -> Self1197     fn from(value: ffi::cairo_hint_metrics_t) -> Self {
1198         match value {
1199             ffi::HINT_METRICS_DEFAULT => Self::Default,
1200             ffi::HINT_METRICS_OFF => Self::Off,
1201             ffi::HINT_METRICS_ON => Self::On,
1202             value => Self::__Unknown(value),
1203         }
1204     }
1205 }
1206 
1207 impl fmt::Display for HintMetrics {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1208     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1209         write!(
1210             f,
1211             "Self::{}",
1212             match *self {
1213                 Self::Default => "Default",
1214                 Self::Off => "Off",
1215                 Self::On => "On",
1216                 _ => "Unknown",
1217             }
1218         )
1219     }
1220 }
1221 
1222 #[cfg(feature = "use_glib")]
1223 gvalue_impl!(
1224     HintMetrics,
1225     ffi::gobject::cairo_gobject_hint_metrics_get_type
1226 );
1227 
1228 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
1229 #[non_exhaustive]
1230 #[doc(alias = "cairo_surface_type_t")]
1231 pub enum SurfaceType {
1232     #[doc(alias = "SURFACE_TYPE_IMAGE")]
1233     Image,
1234     #[doc(alias = "SURFACE_TYPE_PDF")]
1235     Pdf,
1236     #[doc(alias = "SURFACE_TYPE_PS")]
1237     Ps,
1238     #[doc(alias = "SURFACE_TYPE_XLIB")]
1239     Xlib,
1240     #[doc(alias = "SURFACE_TYPE_XCB")]
1241     Xcb,
1242     #[doc(alias = "SURFACE_TYPE_GLITZ")]
1243     Glitz,
1244     #[doc(alias = "SURFACE_TYPE_QUARTZ")]
1245     Quartz,
1246     #[doc(alias = "SURFACE_TYPE_WIN32")]
1247     Win32,
1248     #[doc(alias = "SURFACE_TYPE_BE_OS")]
1249     BeOs,
1250     #[doc(alias = "SURFACE_TYPE_DIRECT_FB")]
1251     DirectFb,
1252     #[doc(alias = "SURFACE_TYPE_SVG")]
1253     Svg,
1254     #[doc(alias = "SURFACE_TYPE_OS2")]
1255     Os2,
1256     #[doc(alias = "SURFACE_TYPE_WIN32_PRINTING")]
1257     Win32Printing,
1258     #[doc(alias = "SURFACE_TYPE_QUARTZ_IMAGE")]
1259     QuartzImage,
1260     #[doc(alias = "SURFACE_TYPE_SCRIPT")]
1261     Script,
1262     #[doc(alias = "SURFACE_TYPE_QT")]
1263     Qt,
1264     #[doc(alias = "SURFACE_TYPE_RECORDING")]
1265     Recording,
1266     #[doc(alias = "SURFACE_TYPE_VG")]
1267     Vg,
1268     #[doc(alias = "SURFACE_TYPE_GL")]
1269     Gl,
1270     #[doc(alias = "SURFACE_TYPE_DRM")]
1271     Drm,
1272     #[doc(alias = "SURFACE_TYPE_TEE")]
1273     Tee,
1274     #[doc(alias = "SURFACE_TYPE_XML")]
1275     Xml,
1276     #[doc(alias = "SURFACE_TYPE_SKIA")]
1277     Skia,
1278     #[doc(alias = "SURFACE_TYPE_SUBSURFACE")]
1279     Subsurface,
1280     #[doc(alias = "SURFACE_TYPE_COGL")]
1281     Cogl,
1282     #[doc(hidden)]
1283     __Unknown(i32),
1284 }
1285 
1286 #[doc(hidden)]
1287 impl From<SurfaceType> for ffi::cairo_surface_type_t {
from(val: SurfaceType) -> ffi::cairo_surface_type_t1288     fn from(val: SurfaceType) -> ffi::cairo_surface_type_t {
1289         match val {
1290             SurfaceType::Image => ffi::SURFACE_TYPE_IMAGE,
1291             SurfaceType::Pdf => ffi::SURFACE_TYPE_PDF,
1292             SurfaceType::Ps => ffi::SURFACE_TYPE_PS,
1293             SurfaceType::Xlib => ffi::SURFACE_TYPE_XLIB,
1294             SurfaceType::Xcb => ffi::SURFACE_TYPE_XCB,
1295             SurfaceType::Glitz => ffi::SURFACE_TYPE_GLITZ,
1296             SurfaceType::Quartz => ffi::SURFACE_TYPE_QUARTZ,
1297             SurfaceType::Win32 => ffi::SURFACE_TYPE_WIN32,
1298             SurfaceType::BeOs => ffi::SURFACE_TYPE_BE_OS,
1299             SurfaceType::DirectFb => ffi::SURFACE_TYPE_DIRECT_FB,
1300             SurfaceType::Svg => ffi::SURFACE_TYPE_SVG,
1301             SurfaceType::Os2 => ffi::SURFACE_TYPE_OS2,
1302             SurfaceType::Win32Printing => ffi::SURFACE_TYPE_WIN32_PRINTING,
1303             SurfaceType::QuartzImage => ffi::SURFACE_TYPE_QUARTZ_IMAGE,
1304             SurfaceType::Script => ffi::SURFACE_TYPE_SCRIPT,
1305             SurfaceType::Qt => ffi::SURFACE_TYPE_QT,
1306             SurfaceType::Recording => ffi::SURFACE_TYPE_RECORDING,
1307             SurfaceType::Vg => ffi::SURFACE_TYPE_VG,
1308             SurfaceType::Gl => ffi::SURFACE_TYPE_GL,
1309             SurfaceType::Drm => ffi::SURFACE_TYPE_DRM,
1310             SurfaceType::Tee => ffi::SURFACE_TYPE_TEE,
1311             SurfaceType::Xml => ffi::SURFACE_TYPE_XML,
1312             SurfaceType::Skia => ffi::SURFACE_TYPE_SKIA,
1313             SurfaceType::Subsurface => ffi::SURFACE_TYPE_SUBSURFACE,
1314             SurfaceType::Cogl => ffi::SURFACE_TYPE_COGL,
1315             SurfaceType::__Unknown(value) => value,
1316         }
1317     }
1318 }
1319 
1320 #[doc(hidden)]
1321 impl From<ffi::cairo_surface_type_t> for SurfaceType {
from(value: ffi::cairo_surface_type_t) -> Self1322     fn from(value: ffi::cairo_surface_type_t) -> Self {
1323         match value {
1324             ffi::SURFACE_TYPE_IMAGE => Self::Image,
1325             ffi::SURFACE_TYPE_PDF => Self::Pdf,
1326             ffi::SURFACE_TYPE_PS => Self::Ps,
1327             ffi::SURFACE_TYPE_XLIB => Self::Xlib,
1328             ffi::SURFACE_TYPE_XCB => Self::Xcb,
1329             ffi::SURFACE_TYPE_GLITZ => Self::Glitz,
1330             ffi::SURFACE_TYPE_QUARTZ => Self::Quartz,
1331             ffi::SURFACE_TYPE_WIN32 => Self::Win32,
1332             ffi::SURFACE_TYPE_BE_OS => Self::BeOs,
1333             ffi::SURFACE_TYPE_DIRECT_FB => Self::DirectFb,
1334             ffi::SURFACE_TYPE_SVG => Self::Svg,
1335             ffi::SURFACE_TYPE_OS2 => Self::Os2,
1336             ffi::SURFACE_TYPE_WIN32_PRINTING => Self::Win32Printing,
1337             ffi::SURFACE_TYPE_QUARTZ_IMAGE => Self::QuartzImage,
1338             ffi::SURFACE_TYPE_SCRIPT => Self::Script,
1339             ffi::SURFACE_TYPE_QT => Self::Qt,
1340             ffi::SURFACE_TYPE_RECORDING => Self::Recording,
1341             ffi::SURFACE_TYPE_VG => Self::Vg,
1342             ffi::SURFACE_TYPE_GL => Self::Gl,
1343             ffi::SURFACE_TYPE_DRM => Self::Drm,
1344             ffi::SURFACE_TYPE_TEE => Self::Tee,
1345             ffi::SURFACE_TYPE_XML => Self::Xml,
1346             ffi::SURFACE_TYPE_SKIA => Self::Skia,
1347             ffi::SURFACE_TYPE_SUBSURFACE => Self::Subsurface,
1348             ffi::SURFACE_TYPE_COGL => Self::Cogl,
1349             value => Self::__Unknown(value),
1350         }
1351     }
1352 }
1353 
1354 impl fmt::Display for SurfaceType {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1355     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1356         write!(
1357             f,
1358             "Self::{}",
1359             match *self {
1360                 Self::Image => "Image",
1361                 Self::Pdf => "Pdf",
1362                 Self::Ps => "Ps",
1363                 Self::Xlib => "Xlib",
1364                 Self::Xcb => "Xcb",
1365                 Self::Glitz => "Glitz",
1366                 Self::Quartz => "Quartz",
1367                 Self::Win32 => "Win32",
1368                 Self::BeOs => "BeOs",
1369                 Self::DirectFb => "DirectFb",
1370                 Self::Svg => "Svg",
1371                 Self::Os2 => "Os2",
1372                 Self::Win32Printing => "Win32Printing",
1373                 Self::QuartzImage => "QuartzImage",
1374                 Self::Script => "Script",
1375                 Self::Qt => "Qt",
1376                 Self::Recording => "Recording",
1377                 Self::Vg => "Vg",
1378                 Self::Gl => "Gl",
1379                 Self::Drm => "Drm",
1380                 Self::Tee => "Tee",
1381                 Self::Xml => "Xml",
1382                 Self::Skia => "Skia",
1383                 Self::Subsurface => "Subsurface",
1384                 Self::Cogl => "Cogl",
1385                 _ => "Unknown",
1386             }
1387         )
1388     }
1389 }
1390 
1391 #[cfg(feature = "use_glib")]
1392 gvalue_impl!(
1393     SurfaceType,
1394     ffi::gobject::cairo_gobject_surface_type_get_type
1395 );
1396 
1397 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
1398 #[cfg(any(all(feature = "svg", feature = "v1_16"), feature = "dox"))]
1399 #[non_exhaustive]
1400 #[doc(alias = "cairo_svg_unit_t")]
1401 pub enum SvgUnit {
1402     #[doc(alias = "SVG_UNIT_USER")]
1403     User,
1404     #[doc(alias = "SVG_UNIT_EM")]
1405     Em,
1406     #[doc(alias = "SVG_UNIT_EX")]
1407     Ex,
1408     #[doc(alias = "SVG_UNIT_PX")]
1409     Px,
1410     #[doc(alias = "SVG_UNIT_IN")]
1411     In,
1412     #[doc(alias = "SVG_UNIT_CM")]
1413     Cm,
1414     #[doc(alias = "SVG_UNIT_MM")]
1415     Mm,
1416     #[doc(alias = "SVG_UNIT_PT")]
1417     Pt,
1418     #[doc(alias = "SVG_UNIT_PC")]
1419     Pc,
1420     #[doc(alias = "SVG_UNIT_PERCENT")]
1421     Percent,
1422     #[doc(hidden)]
1423     __Unknown(i32),
1424 }
1425 
1426 #[doc(hidden)]
1427 #[cfg(any(all(feature = "svg", feature = "v1_16"), feature = "dox"))]
1428 impl From<SvgUnit> for ffi::cairo_svg_unit_t {
from(val: SvgUnit) -> ffi::cairo_svg_unit_t1429     fn from(val: SvgUnit) -> ffi::cairo_svg_unit_t {
1430         match val {
1431             SvgUnit::User => ffi::SVG_UNIT_USER,
1432             SvgUnit::Em => ffi::SVG_UNIT_EM,
1433             SvgUnit::Ex => ffi::SVG_UNIT_EX,
1434             SvgUnit::Px => ffi::SVG_UNIT_PX,
1435             SvgUnit::In => ffi::SVG_UNIT_IN,
1436             SvgUnit::Cm => ffi::SVG_UNIT_CM,
1437             SvgUnit::Mm => ffi::SVG_UNIT_MM,
1438             SvgUnit::Pt => ffi::SVG_UNIT_PT,
1439             SvgUnit::Pc => ffi::SVG_UNIT_PC,
1440             SvgUnit::Percent => ffi::SVG_UNIT_PERCENT,
1441             SvgUnit::__Unknown(value) => value,
1442         }
1443     }
1444 }
1445 
1446 #[doc(hidden)]
1447 #[cfg(any(all(feature = "svg", feature = "v1_16"), feature = "dox"))]
1448 impl From<ffi::cairo_svg_unit_t> for SvgUnit {
from(value: ffi::cairo_svg_unit_t) -> Self1449     fn from(value: ffi::cairo_svg_unit_t) -> Self {
1450         match value {
1451             ffi::SVG_UNIT_USER => Self::User,
1452             ffi::SVG_UNIT_EM => Self::Em,
1453             ffi::SVG_UNIT_EX => Self::Ex,
1454             ffi::SVG_UNIT_PX => Self::Px,
1455             ffi::SVG_UNIT_IN => Self::In,
1456             ffi::SVG_UNIT_CM => Self::Cm,
1457             ffi::SVG_UNIT_MM => Self::Mm,
1458             ffi::SVG_UNIT_PT => Self::Pt,
1459             ffi::SVG_UNIT_PC => Self::Pc,
1460             ffi::SVG_UNIT_PERCENT => Self::Percent,
1461             value => Self::__Unknown(value),
1462         }
1463     }
1464 }
1465 
1466 #[cfg(any(all(feature = "svg", feature = "v1_16"), feature = "dox"))]
1467 impl fmt::Display for SvgUnit {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1468     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1469         write!(
1470             f,
1471             "Self::{}",
1472             match *self {
1473                 Self::User => "User",
1474                 Self::Em => "Em",
1475                 Self::Ex => "Ex",
1476                 Self::Px => "Px",
1477                 Self::In => "In",
1478                 Self::Cm => "Cm",
1479                 Self::Mm => "Mm",
1480                 Self::Pt => "Pt",
1481                 Self::Pc => "Pc",
1482                 Self::Percent => "Percent",
1483                 _ => "Unknown",
1484             }
1485         )
1486     }
1487 }
1488 
1489 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
1490 #[non_exhaustive]
1491 #[doc(alias = "cairo_format_t")]
1492 pub enum Format {
1493     #[doc(alias = "FORMAT_INVALID")]
1494     Invalid,
1495     #[doc(alias = "FORMAT_A_RGB32")]
1496     ARgb32,
1497     #[doc(alias = "FORMAT_RGB24")]
1498     Rgb24,
1499     #[doc(alias = "FORMAT_A8")]
1500     A8,
1501     #[doc(alias = "FORMAT_A1")]
1502     A1,
1503     #[doc(alias = "FORMAT_RGB16_565")]
1504     Rgb16_565,
1505     #[doc(alias = "FORMAT_RGB30")]
1506     Rgb30,
1507     #[doc(hidden)]
1508     __Unknown(i32),
1509 }
1510 
1511 #[doc(hidden)]
1512 impl From<Format> for ffi::cairo_format_t {
from(val: Format) -> ffi::cairo_format_t1513     fn from(val: Format) -> ffi::cairo_format_t {
1514         match val {
1515             Format::Invalid => ffi::FORMAT_INVALID,
1516             Format::ARgb32 => ffi::FORMAT_A_RGB32,
1517             Format::Rgb24 => ffi::FORMAT_RGB24,
1518             Format::A8 => ffi::FORMAT_A8,
1519             Format::A1 => ffi::FORMAT_A1,
1520             Format::Rgb16_565 => ffi::FORMAT_RGB16_565,
1521             Format::Rgb30 => ffi::FORMAT_RGB30,
1522             Format::__Unknown(value) => value,
1523         }
1524     }
1525 }
1526 
1527 #[doc(hidden)]
1528 impl From<ffi::cairo_format_t> for Format {
from(value: ffi::cairo_format_t) -> Self1529     fn from(value: ffi::cairo_format_t) -> Self {
1530         match value {
1531             ffi::FORMAT_INVALID => Self::Invalid,
1532             ffi::FORMAT_A_RGB32 => Self::ARgb32,
1533             ffi::FORMAT_RGB24 => Self::Rgb24,
1534             ffi::FORMAT_A8 => Self::A8,
1535             ffi::FORMAT_A1 => Self::A1,
1536             ffi::FORMAT_RGB16_565 => Self::Rgb16_565,
1537             ffi::FORMAT_RGB30 => Self::Rgb30,
1538             value => Self::__Unknown(value),
1539         }
1540     }
1541 }
1542 
1543 impl fmt::Display for Format {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1544     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1545         write!(
1546             f,
1547             "Self::{}",
1548             match *self {
1549                 Self::Invalid => "Invalid",
1550                 Self::ARgb32 => "ARgb32",
1551                 Self::Rgb24 => "Rgb24",
1552                 Self::A8 => "A8",
1553                 Self::A1 => "A1",
1554                 Self::Rgb16_565 => "Rgb16_565",
1555                 Self::Rgb30 => "Rgb30",
1556                 _ => "Unknown",
1557             }
1558         )
1559     }
1560 }
1561 
1562 #[cfg(feature = "use_glib")]
1563 gvalue_impl!(Format, ffi::gobject::cairo_gobject_format_get_type);
1564 
1565 impl Format {
1566     #[doc(alias = "cairo_format_stride_for_width")]
stride_for_width(self, width: u32) -> Result<i32, Error>1567     pub fn stride_for_width(self, width: u32) -> Result<i32, Error> {
1568         assert!(width <= i32::MAX as u32);
1569         let width = width as i32;
1570 
1571         let stride = unsafe { ffi::cairo_format_stride_for_width(self.into(), width) };
1572         if stride == -1 {
1573             Err(Error::InvalidFormat)
1574         } else {
1575             Ok(stride)
1576         }
1577     }
1578 }
1579 
1580 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
1581 #[non_exhaustive]
1582 #[doc(alias = "cairo_region_overlap_t")]
1583 pub enum RegionOverlap {
1584     #[doc(alias = "REGION_OVERLAP_IN")]
1585     In,
1586     #[doc(alias = "REGION_OVERLAP_OUT")]
1587     Out,
1588     #[doc(alias = "REGION_OVERLAP_PART")]
1589     Part,
1590     #[doc(hidden)]
1591     __Unknown(i32),
1592 }
1593 
1594 #[doc(hidden)]
1595 impl From<RegionOverlap> for ffi::cairo_region_overlap_t {
from(val: RegionOverlap) -> ffi::cairo_region_overlap_t1596     fn from(val: RegionOverlap) -> ffi::cairo_region_overlap_t {
1597         match val {
1598             RegionOverlap::In => ffi::REGION_OVERLAP_IN,
1599             RegionOverlap::Out => ffi::REGION_OVERLAP_OUT,
1600             RegionOverlap::Part => ffi::REGION_OVERLAP_PART,
1601             RegionOverlap::__Unknown(value) => value,
1602         }
1603     }
1604 }
1605 
1606 #[doc(hidden)]
1607 impl From<ffi::cairo_region_overlap_t> for RegionOverlap {
from(value: ffi::cairo_region_overlap_t) -> Self1608     fn from(value: ffi::cairo_region_overlap_t) -> Self {
1609         match value {
1610             ffi::REGION_OVERLAP_IN => Self::In,
1611             ffi::REGION_OVERLAP_OUT => Self::Out,
1612             ffi::REGION_OVERLAP_PART => Self::Part,
1613             value => Self::__Unknown(value),
1614         }
1615     }
1616 }
1617 
1618 impl fmt::Display for RegionOverlap {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1619     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1620         write!(
1621             f,
1622             "Self::{}",
1623             match *self {
1624                 Self::In => "In",
1625                 Self::Out => "Out",
1626                 Self::Part => "Part",
1627                 _ => "Unknown",
1628             }
1629         )
1630     }
1631 }
1632 
1633 #[cfg(feature = "use_glib")]
1634 gvalue_impl!(
1635     RegionOverlap,
1636     ffi::gobject::cairo_gobject_region_overlap_get_type
1637 );
1638 
1639 bitflags::bitflags! {
1640     pub struct PdfOutline: i32 {
1641         #[doc(alias = "PDF_OUTLINE_FLAG_OPEN")]
1642         const OPEN = ffi::PDF_OUTLINE_FLAG_OPEN;
1643         #[doc(alias = "PDF_OUTLINE_FLAG_BOLD")]
1644         const BOLD = ffi::PDF_OUTLINE_FLAG_BOLD;
1645         #[doc(alias = "PDF_OUTLINE_FLAG_ITALIC")]
1646         const ITALIC = ffi::PDF_OUTLINE_FLAG_ITALIC;
1647     }
1648 }
1649 
1650 #[cfg(any(feature = "pdf", feature = "dox"))]
1651 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
1652 #[non_exhaustive]
1653 #[doc(alias = "cairo_pdf_metadata_t")]
1654 pub enum PdfMetadata {
1655     #[doc(alias = "PDF_METADATA_TITLE")]
1656     Title,
1657     #[doc(alias = "PDF_METADATA_AUTHOR")]
1658     Author,
1659     #[doc(alias = "PDF_METADATA_SUBJECT")]
1660     Subject,
1661     #[doc(alias = "PDF_METADATA_KEYWORDS")]
1662     Keywords,
1663     #[doc(alias = "PDF_METADATA_CREATOR")]
1664     Creator,
1665     #[doc(alias = "PDF_METADATA_CREATE_DATE")]
1666     CreateDate,
1667     #[doc(alias = "PDF_METADATA_MOD_DATE")]
1668     ModDate,
1669     #[doc(hidden)]
1670     __Unknown(i32),
1671 }
1672 
1673 #[cfg(any(all(feature = "pdf", feature = "v1_16"), feature = "dox"))]
1674 #[doc(hidden)]
1675 impl From<PdfMetadata> for ffi::cairo_pdf_metadata_t {
from(val: PdfMetadata) -> ffi::cairo_pdf_metadata_t1676     fn from(val: PdfMetadata) -> ffi::cairo_pdf_metadata_t {
1677         match val {
1678             PdfMetadata::Title => ffi::PDF_METADATA_TITLE,
1679             PdfMetadata::Author => ffi::PDF_METADATA_AUTHOR,
1680             PdfMetadata::Subject => ffi::PDF_METADATA_SUBJECT,
1681             PdfMetadata::Keywords => ffi::PDF_METADATA_KEYWORDS,
1682             PdfMetadata::Creator => ffi::PDF_METADATA_CREATOR,
1683             PdfMetadata::CreateDate => ffi::PDF_METADATA_CREATE_DATE,
1684             PdfMetadata::ModDate => ffi::PDF_METADATA_MOD_DATE,
1685             PdfMetadata::__Unknown(value) => value,
1686         }
1687     }
1688 }
1689 
1690 #[cfg(any(all(feature = "pdf", feature = "v1_16"), feature = "dox"))]
1691 #[doc(hidden)]
1692 impl From<ffi::cairo_pdf_metadata_t> for PdfMetadata {
from(value: ffi::cairo_pdf_metadata_t) -> Self1693     fn from(value: ffi::cairo_pdf_metadata_t) -> Self {
1694         match value {
1695             ffi::PDF_METADATA_TITLE => Self::Title,
1696             ffi::PDF_METADATA_AUTHOR => Self::Author,
1697             ffi::PDF_METADATA_SUBJECT => Self::Subject,
1698             ffi::PDF_METADATA_KEYWORDS => Self::Keywords,
1699             ffi::PDF_METADATA_CREATOR => Self::Creator,
1700             ffi::PDF_METADATA_CREATE_DATE => Self::CreateDate,
1701             ffi::PDF_METADATA_MOD_DATE => Self::ModDate,
1702             value => Self::__Unknown(value),
1703         }
1704     }
1705 }
1706 
1707 #[cfg(any(all(feature = "pdf", feature = "v1_16"), feature = "dox"))]
1708 impl fmt::Display for PdfMetadata {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1709     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1710         write!(
1711             f,
1712             "Self::{}",
1713             match *self {
1714                 Self::Title => "Title",
1715                 Self::Author => "Author",
1716                 Self::Subject => "Subject",
1717                 Self::Keywords => "Keywords",
1718                 Self::Creator => "Creator",
1719                 Self::CreateDate => "CreateDate",
1720                 Self::ModDate => "ModDate",
1721                 _ => "Unknown",
1722             }
1723         )
1724     }
1725 }
1726 
1727 #[cfg(any(feature = "pdf", feature = "dox"))]
1728 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
1729 #[non_exhaustive]
1730 #[doc(alias = "cairo_pdf_version_t")]
1731 pub enum PdfVersion {
1732     #[doc(alias = "PDF_VERSION__1_4")]
1733     _1_4,
1734     #[doc(alias = "PDF_VERSION__1_5")]
1735     _1_5,
1736     #[doc(hidden)]
1737     __Unknown(i32),
1738 }
1739 
1740 #[cfg(any(feature = "pdf", feature = "dox"))]
1741 #[doc(hidden)]
1742 impl From<PdfVersion> for ffi::cairo_pdf_version_t {
from(val: PdfVersion) -> ffi::cairo_pdf_version_t1743     fn from(val: PdfVersion) -> ffi::cairo_pdf_version_t {
1744         match val {
1745             PdfVersion::_1_4 => ffi::PDF_VERSION__1_4,
1746             PdfVersion::_1_5 => ffi::PDF_VERSION__1_5,
1747             PdfVersion::__Unknown(value) => value,
1748         }
1749     }
1750 }
1751 
1752 #[cfg(any(feature = "pdf", feature = "dox"))]
1753 #[doc(hidden)]
1754 impl From<ffi::cairo_pdf_version_t> for PdfVersion {
from(value: ffi::cairo_pdf_version_t) -> Self1755     fn from(value: ffi::cairo_pdf_version_t) -> Self {
1756         match value {
1757             ffi::PDF_VERSION__1_4 => Self::_1_4,
1758             ffi::PDF_VERSION__1_5 => Self::_1_5,
1759             value => Self::__Unknown(value),
1760         }
1761     }
1762 }
1763 
1764 #[cfg(any(feature = "pdf", feature = "dox"))]
1765 impl fmt::Display for PdfVersion {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1766     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1767         write!(
1768             f,
1769             "Self::{}",
1770             match *self {
1771                 Self::_1_4 => "1_4",
1772                 Self::_1_5 => "1_5",
1773                 _ => "Unknown",
1774             }
1775         )
1776     }
1777 }
1778 
1779 #[cfg(any(feature = "svg", feature = "dox"))]
1780 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
1781 #[non_exhaustive]
1782 #[doc(alias = "cairo_svg_version_t")]
1783 pub enum SvgVersion {
1784     #[doc(alias = "SVG_VERSION__1_1")]
1785     _1_1,
1786     #[doc(alias = "SVG_VERSION__1_2")]
1787     _1_2,
1788     #[doc(hidden)]
1789     __Unknown(i32),
1790 }
1791 
1792 #[cfg(any(feature = "svg", feature = "dox"))]
1793 #[doc(hidden)]
1794 impl From<SvgVersion> for ffi::cairo_svg_version_t {
from(val: SvgVersion) -> ffi::cairo_svg_version_t1795     fn from(val: SvgVersion) -> ffi::cairo_svg_version_t {
1796         match val {
1797             SvgVersion::_1_1 => ffi::SVG_VERSION__1_1,
1798             SvgVersion::_1_2 => ffi::SVG_VERSION__1_2,
1799             SvgVersion::__Unknown(value) => value,
1800         }
1801     }
1802 }
1803 
1804 #[cfg(any(feature = "svg", feature = "dox"))]
1805 #[doc(hidden)]
1806 impl From<ffi::cairo_svg_version_t> for SvgVersion {
from(value: ffi::cairo_svg_version_t) -> Self1807     fn from(value: ffi::cairo_svg_version_t) -> Self {
1808         match value {
1809             ffi::SVG_VERSION__1_1 => Self::_1_1,
1810             ffi::SVG_VERSION__1_2 => Self::_1_2,
1811             value => Self::__Unknown(value),
1812         }
1813     }
1814 }
1815 
1816 #[cfg(any(feature = "svg", feature = "dox"))]
1817 impl fmt::Display for SvgVersion {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1818     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1819         write!(
1820             f,
1821             "Self::{}",
1822             match *self {
1823                 Self::_1_1 => "1_1",
1824                 Self::_1_2 => "1_2",
1825                 _ => "Unknown",
1826             }
1827         )
1828     }
1829 }
1830 
1831 #[cfg(any(feature = "ps", feature = "dox"))]
1832 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
1833 #[non_exhaustive]
1834 #[doc(alias = "cairo_ps_level_t")]
1835 pub enum PsLevel {
1836     #[doc(alias = "PS_LEVEL__2")]
1837     _2,
1838     #[doc(alias = "PS_LEVEL__3")]
1839     _3,
1840     #[doc(hidden)]
1841     __Unknown(i32),
1842 }
1843 
1844 #[cfg(any(feature = "ps", feature = "dox"))]
1845 #[doc(hidden)]
1846 impl From<PsLevel> for ffi::cairo_ps_level_t {
from(val: PsLevel) -> ffi::cairo_ps_level_t1847     fn from(val: PsLevel) -> ffi::cairo_ps_level_t {
1848         match val {
1849             PsLevel::_2 => ffi::PS_LEVEL__2,
1850             PsLevel::_3 => ffi::PS_LEVEL__3,
1851             PsLevel::__Unknown(value) => value,
1852         }
1853     }
1854 }
1855 
1856 #[cfg(any(feature = "ps", feature = "dox"))]
1857 #[doc(hidden)]
1858 impl From<ffi::cairo_ps_level_t> for PsLevel {
from(value: ffi::cairo_ps_level_t) -> Self1859     fn from(value: ffi::cairo_ps_level_t) -> Self {
1860         match value {
1861             ffi::PS_LEVEL__2 => Self::_2,
1862             ffi::PS_LEVEL__3 => Self::_3,
1863             value => Self::__Unknown(value),
1864         }
1865     }
1866 }
1867 
1868 #[cfg(any(feature = "ps", feature = "dox"))]
1869 impl fmt::Display for PsLevel {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1870     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1871         write!(
1872             f,
1873             "Self::{}",
1874             match *self {
1875                 Self::_2 => "_2",
1876                 Self::_3 => "_3",
1877                 _ => "Unknown",
1878             }
1879         )
1880     }
1881 }
1882 
1883 #[derive(Clone, PartialEq, PartialOrd, Copy, Debug)]
1884 #[non_exhaustive]
1885 #[doc(alias = "cairo_mesh_corner_t")]
1886 pub enum MeshCorner {
1887     #[doc(alias = "MESH_CORNER_MESH_CORNER0")]
1888     MeshCorner0,
1889     #[doc(alias = "MESH_CORNER_MESH_CORNER1")]
1890     MeshCorner1,
1891     #[doc(alias = "MESH_CORNER_MESH_CORNER2")]
1892     MeshCorner2,
1893     #[doc(alias = "MESH_CORNER_MESH_CORNER3")]
1894     MeshCorner3,
1895     #[doc(hidden)]
1896     __Unknown(u32),
1897 }
1898 
1899 #[doc(hidden)]
1900 impl From<MeshCorner> for ffi::cairo_mesh_corner_t {
from(val: MeshCorner) -> ffi::cairo_mesh_corner_t1901     fn from(val: MeshCorner) -> ffi::cairo_mesh_corner_t {
1902         match val {
1903             MeshCorner::MeshCorner0 => ffi::MESH_CORNER_MESH_CORNER0,
1904             MeshCorner::MeshCorner1 => ffi::MESH_CORNER_MESH_CORNER1,
1905             MeshCorner::MeshCorner2 => ffi::MESH_CORNER_MESH_CORNER2,
1906             MeshCorner::MeshCorner3 => ffi::MESH_CORNER_MESH_CORNER3,
1907             MeshCorner::__Unknown(value) => value,
1908         }
1909     }
1910 }
1911 
1912 #[doc(hidden)]
1913 impl From<ffi::cairo_mesh_corner_t> for MeshCorner {
from(value: ffi::cairo_mesh_corner_t) -> Self1914     fn from(value: ffi::cairo_mesh_corner_t) -> Self {
1915         match value {
1916             ffi::MESH_CORNER_MESH_CORNER0 => Self::MeshCorner0,
1917             ffi::MESH_CORNER_MESH_CORNER1 => Self::MeshCorner1,
1918             ffi::MESH_CORNER_MESH_CORNER2 => Self::MeshCorner2,
1919             ffi::MESH_CORNER_MESH_CORNER3 => Self::MeshCorner3,
1920             value => Self::__Unknown(value),
1921         }
1922     }
1923 }
1924 
1925 impl fmt::Display for MeshCorner {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1926     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1927         write!(
1928             f,
1929             "Self::{}",
1930             match *self {
1931                 Self::MeshCorner0 => "MeshCorner0",
1932                 Self::MeshCorner1 => "MeshCorner1",
1933                 Self::MeshCorner2 => "MeshCorner2",
1934                 Self::MeshCorner3 => "MeshCorner3",
1935                 _ => "Unknown",
1936             }
1937         )
1938     }
1939 }
1940 
1941 #[cfg(any(feature = "freetype", feature = "dox"))]
1942 #[derive(Clone, PartialEq, PartialOrd, Debug, Copy)]
1943 #[non_exhaustive]
1944 #[doc(alias = "cairo_ft_synthesize_t")]
1945 pub enum FtSynthesize {
1946     #[doc(alias = "CAIRO_FT_SYNTHESIZE_BOLD")]
1947     Bold,
1948     #[doc(alias = "CAIRO_FT_SYNTHESIZE_OBLIQUE")]
1949     Oblique,
1950     #[doc(hidden)]
1951     __Unknown(u32),
1952 }
1953 
1954 #[cfg(any(feature = "freetype", feature = "dox"))]
1955 #[doc(hidden)]
1956 impl From<FtSynthesize> for ffi::cairo_ft_synthesize_t {
from(val: FtSynthesize) -> ffi::cairo_ft_synthesize_t1957     fn from(val: FtSynthesize) -> ffi::cairo_ft_synthesize_t {
1958         match val {
1959             FtSynthesize::Bold => ffi::CAIRO_FT_SYNTHESIZE_BOLD,
1960             FtSynthesize::Oblique => ffi::CAIRO_FT_SYNTHESIZE_OBLIQUE,
1961             FtSynthesize::__Unknown(value) => value,
1962         }
1963     }
1964 }
1965 
1966 #[cfg(any(feature = "freetype", feature = "dox"))]
1967 #[doc(hidden)]
1968 impl From<ffi::cairo_ft_synthesize_t> for FtSynthesize {
from(value: ffi::cairo_ft_synthesize_t) -> Self1969     fn from(value: ffi::cairo_ft_synthesize_t) -> Self {
1970         match value {
1971             ffi::CAIRO_FT_SYNTHESIZE_BOLD => Self::Bold,
1972             ffi::CAIRO_FT_SYNTHESIZE_OBLIQUE => Self::Oblique,
1973             value => Self::__Unknown(value),
1974         }
1975     }
1976 }
1977 
1978 #[cfg(any(feature = "freetype", feature = "dox"))]
1979 impl fmt::Display for FtSynthesize {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1980     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1981         write!(
1982             f,
1983             "Self::{}",
1984             match *self {
1985                 Self::Bold => "Bold",
1986                 Self::Oblique => "Oblique",
1987                 Self::__Unknown(_) => "Unknown",
1988             }
1989         )
1990     }
1991 }
1992 
1993 #[cfg(any(feature = "script", feature = "dox"))]
1994 #[derive(Clone, PartialEq, PartialOrd, Debug, Copy)]
1995 #[non_exhaustive]
1996 #[doc(alias = "cairo_script_mode_t")]
1997 pub enum ScriptMode {
1998     #[doc(alias = "CAIRO_SCRIPT_MODE_ASCII")]
1999     Ascii,
2000     #[doc(alias = "CAIRO_SCRIPT_MODE_BINARY")]
2001     Binary,
2002     #[doc(hidden)]
2003     __Unknown(i32),
2004 }
2005 
2006 #[cfg(any(feature = "script", feature = "dox"))]
2007 #[doc(hidden)]
2008 impl From<ScriptMode> for ffi::cairo_script_mode_t {
from(val: ScriptMode) -> ffi::cairo_script_mode_t2009     fn from(val: ScriptMode) -> ffi::cairo_script_mode_t {
2010         match val {
2011             ScriptMode::Ascii => ffi::CAIRO_SCRIPT_MODE_ASCII,
2012             ScriptMode::Binary => ffi::CAIRO_SCRIPT_MODE_BINARY,
2013             ScriptMode::__Unknown(value) => value,
2014         }
2015     }
2016 }
2017 
2018 #[cfg(any(feature = "script", feature = "dox"))]
2019 #[doc(hidden)]
2020 impl From<ffi::cairo_script_mode_t> for ScriptMode {
from(value: ffi::cairo_script_mode_t) -> Self2021     fn from(value: ffi::cairo_script_mode_t) -> Self {
2022         match value {
2023             ffi::CAIRO_SCRIPT_MODE_ASCII => Self::Ascii,
2024             ffi::CAIRO_SCRIPT_MODE_BINARY => Self::Binary,
2025             value => Self::__Unknown(value),
2026         }
2027     }
2028 }
2029 
2030 #[cfg(any(feature = "script", feature = "dox"))]
2031 impl fmt::Display for ScriptMode {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2032     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2033         write!(
2034             f,
2035             "Self::{}",
2036             match *self {
2037                 Self::Ascii => "Ascii",
2038                 Self::Binary => "Binary",
2039                 Self::__Unknown(_) => "Unknown",
2040             }
2041         )
2042     }
2043 }
2044 
2045 #[derive(Clone, PartialEq, PartialOrd, Debug, Copy)]
2046 #[non_exhaustive]
2047 #[doc(alias = "cairo_device_type_t")]
2048 pub enum DeviceType {
2049     #[doc(alias = "CAIRO_DEVICE_TYPE_DRM")]
2050     Ascii,
2051     #[doc(alias = "CAIRO_DEVICE_TYPE_GL")]
2052     Binary,
2053     #[doc(alias = "CAIRO_DEVICE_TYPE_SCRIPT")]
2054     Script,
2055     #[doc(alias = "CAIRO_DEVICE_TYPE_XCB")]
2056     Xcb,
2057     #[doc(alias = "CAIRO_DEVICE_TYPE_XLIB")]
2058     Xlib,
2059     #[doc(alias = "CAIRO_DEVICE_TYPE_XML")]
2060     Xml,
2061     #[doc(alias = "CAIRO_DEVICE_TYPE_COGL")]
2062     Cogl,
2063     #[doc(alias = "CAIRO_DEVICE_TYPE_WIN32")]
2064     Win32,
2065     #[doc(alias = "CAIRO_DEVICE_TYPE_INVALID")]
2066     Invalid,
2067     #[doc(hidden)]
2068     __Unknown(i32),
2069 }
2070 
2071 #[doc(hidden)]
2072 impl From<DeviceType> for ffi::cairo_device_type_t {
from(val: DeviceType) -> ffi::cairo_device_type_t2073     fn from(val: DeviceType) -> ffi::cairo_device_type_t {
2074         match val {
2075             DeviceType::Ascii => ffi::CAIRO_DEVICE_TYPE_DRM,
2076             DeviceType::Binary => ffi::CAIRO_DEVICE_TYPE_GL,
2077             DeviceType::Script => ffi::CAIRO_DEVICE_TYPE_SCRIPT,
2078             DeviceType::Xcb => ffi::CAIRO_DEVICE_TYPE_XCB,
2079             DeviceType::Xlib => ffi::CAIRO_DEVICE_TYPE_XLIB,
2080             DeviceType::Xml => ffi::CAIRO_DEVICE_TYPE_XML,
2081             DeviceType::Cogl => ffi::CAIRO_DEVICE_TYPE_COGL,
2082             DeviceType::Win32 => ffi::CAIRO_DEVICE_TYPE_WIN32,
2083             DeviceType::Invalid => ffi::CAIRO_DEVICE_TYPE_INVALID,
2084             DeviceType::__Unknown(value) => value,
2085         }
2086     }
2087 }
2088 
2089 #[doc(hidden)]
2090 impl From<ffi::cairo_device_type_t> for DeviceType {
from(value: ffi::cairo_device_type_t) -> Self2091     fn from(value: ffi::cairo_device_type_t) -> Self {
2092         match value {
2093             ffi::CAIRO_DEVICE_TYPE_DRM => Self::Ascii,
2094             ffi::CAIRO_DEVICE_TYPE_GL => Self::Binary,
2095             ffi::CAIRO_DEVICE_TYPE_SCRIPT => Self::Script,
2096             ffi::CAIRO_DEVICE_TYPE_XCB => Self::Xcb,
2097             ffi::CAIRO_DEVICE_TYPE_XLIB => Self::Xlib,
2098             ffi::CAIRO_DEVICE_TYPE_XML => Self::Xml,
2099             ffi::CAIRO_DEVICE_TYPE_COGL => Self::Cogl,
2100             ffi::CAIRO_DEVICE_TYPE_WIN32 => Self::Win32,
2101             ffi::CAIRO_DEVICE_TYPE_INVALID => Self::Invalid,
2102             value => Self::__Unknown(value),
2103         }
2104     }
2105 }
2106 
2107 impl fmt::Display for DeviceType {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result2108     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2109         write!(
2110             f,
2111             "Self::{}",
2112             match *self {
2113                 Self::Ascii => "Ascii",
2114                 Self::Binary => "Binary",
2115                 Self::Script => "Script",
2116                 Self::Xcb => "Xcb",
2117                 Self::Xlib => "Xlib",
2118                 Self::Xml => "Xml",
2119                 Self::Cogl => "Cogl",
2120                 Self::Win32 => "Win32",
2121                 Self::Invalid => "Invalid",
2122                 Self::__Unknown(_) => "Unknown",
2123             }
2124         )
2125     }
2126 }
2127 
2128 #[cfg(feature = "use_glib")]
2129 gvalue_impl!(DeviceType, ffi::gobject::cairo_gobject_device_type_get_type);
2130 
2131 #[cfg(test)]
2132 mod tests {
2133     use super::*;
2134 
2135     #[test]
2136     #[should_panic]
stride_panics_on_bad_value()2137     fn stride_panics_on_bad_value() {
2138         let _ = Format::Rgb24.stride_for_width(u32::MAX);
2139     }
2140 
2141     #[test]
stride_errors_on_large_width()2142     fn stride_errors_on_large_width() {
2143         assert!(Format::Rgb24.stride_for_width(i32::MAX as u32).is_err());
2144     }
2145 
2146     #[test]
stride_works()2147     fn stride_works() {
2148         assert_eq!(Format::Rgb24.stride_for_width(1).unwrap(), 4);
2149     }
2150 }
2151