cairo/
enums.rs

1// Take a look at the license at the top of the repository in the LICENSE file.
2
3use std::fmt::{self, Debug};
4
5use crate::error::Error;
6
7#[cfg(feature = "use_glib")]
8use glib::translate::*;
9
10// Helper macro for our GValue related trait impls
11#[cfg(feature = "use_glib")]
12macro_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")]
51pub 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)]
75impl From<Antialias> for ffi::cairo_antialias_t {
76    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)]
91impl From<ffi::cairo_antialias_t> for Antialias {
92    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
106impl fmt::Display for Antialias {
107    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")]
126gvalue_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")]
131pub 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)]
141impl From<FillRule> for ffi::cairo_fill_rule_t {
142    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)]
152impl From<ffi::cairo_fill_rule_t> for FillRule {
153    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
162impl fmt::Display for FillRule {
163    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")]
177gvalue_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")]
182pub 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)]
194impl From<LineCap> for ffi::cairo_line_cap_t {
195    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)]
206impl From<ffi::cairo_line_cap_t> for LineCap {
207    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
217impl fmt::Display for LineCap {
218    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")]
233gvalue_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")]
238pub 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)]
250impl From<LineJoin> for ffi::cairo_line_join_t {
251    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)]
262impl From<ffi::cairo_line_join_t> for LineJoin {
263    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
273impl fmt::Display for LineJoin {
274    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")]
289gvalue_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")]
294pub 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)]
362impl From<Operator> for ffi::cairo_operator_t {
363    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)]
400impl From<ffi::cairo_operator_t> for Operator {
401    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
437impl fmt::Display for Operator {
438    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")]
479gvalue_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")]
484pub 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)]
498impl From<PathDataType> for ffi::cairo_path_data_type_t {
499    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)]
511impl From<ffi::cairo_path_data_type_t> for PathDataType {
512    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
523impl fmt::Display for PathDataType {
524    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")]
540gvalue_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")]
548pub 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)]
560impl From<Content> for ffi::cairo_content_t {
561    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)]
572impl From<ffi::cairo_content_t> for Content {
573    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
583impl fmt::Display for Content {
584    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")]
599gvalue_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")]
604pub 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)]
618impl From<Extend> for ffi::cairo_extend_t {
619    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)]
631impl From<ffi::cairo_extend_t> for Extend {
632    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
643impl fmt::Display for Extend {
644    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")]
660gvalue_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")]
665pub 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)]
683impl From<Filter> for ffi::cairo_filter_t {
684    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)]
698impl From<ffi::cairo_filter_t> for Filter {
699    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
712impl fmt::Display for Filter {
713    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")]
731gvalue_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")]
736pub 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)]
754impl From<PatternType> for ffi::cairo_pattern_type_t {
755    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)]
769impl From<ffi::cairo_pattern_type_t> for PatternType {
770    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
783impl fmt::Display for PatternType {
784    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")]
802gvalue_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")]
810pub 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)]
822impl From<FontSlant> for ffi::cairo_font_slant_t {
823    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)]
834impl From<ffi::cairo_font_slant_t> for FontSlant {
835    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
845impl fmt::Display for FontSlant {
846    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")]
861gvalue_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")]
866pub 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)]
876impl From<FontWeight> for ffi::cairo_font_weight_t {
877    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)]
887impl From<ffi::cairo_font_weight_t> for FontWeight {
888    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
897impl fmt::Display for FontWeight {
898    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")]
912gvalue_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")]
917pub 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)]
927impl From<TextClusterFlags> for ffi::cairo_text_cluster_flags_t {
928    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)]
938impl From<ffi::cairo_text_cluster_flags_t> for TextClusterFlags {
939    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
948impl fmt::Display for TextClusterFlags {
949    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")]
963gvalue_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")]
971pub 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)]
987impl From<FontType> for ffi::cairo_font_type_t {
988    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)]
1001impl From<ffi::cairo_font_type_t> for FontType {
1002    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
1014impl fmt::Display for FontType {
1015    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")]
1032gvalue_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")]
1037pub 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)]
1053impl From<SubpixelOrder> for ffi::cairo_subpixel_order_t {
1054    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)]
1067impl From<ffi::cairo_subpixel_order_t> for SubpixelOrder {
1068    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
1080impl fmt::Display for SubpixelOrder {
1081    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")]
1098gvalue_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")]
1106pub 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)]
1122impl From<HintStyle> for ffi::cairo_hint_style_t {
1123    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)]
1136impl From<ffi::cairo_hint_style_t> for HintStyle {
1137    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
1149impl fmt::Display for HintStyle {
1150    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")]
1167gvalue_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")]
1172pub 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)]
1184impl From<HintMetrics> for ffi::cairo_hint_metrics_t {
1185    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)]
1196impl From<ffi::cairo_hint_metrics_t> for HintMetrics {
1197    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
1207impl fmt::Display for HintMetrics {
1208    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")]
1223gvalue_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")]
1231pub 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)]
1287impl From<SurfaceType> for ffi::cairo_surface_type_t {
1288    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)]
1321impl From<ffi::cairo_surface_type_t> for SurfaceType {
1322    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
1354impl fmt::Display for SurfaceType {
1355    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")]
1392gvalue_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")]
1401pub 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"))]
1428impl From<SvgUnit> for ffi::cairo_svg_unit_t {
1429    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"))]
1448impl From<ffi::cairo_svg_unit_t> for SvgUnit {
1449    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"))]
1467impl fmt::Display for SvgUnit {
1468    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")]
1492pub 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)]
1512impl From<Format> for ffi::cairo_format_t {
1513    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)]
1528impl From<ffi::cairo_format_t> for Format {
1529    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
1543impl fmt::Display for Format {
1544    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")]
1563gvalue_impl!(Format, ffi::gobject::cairo_gobject_format_get_type);
1564
1565impl Format {
1566    #[doc(alias = "cairo_format_stride_for_width")]
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")]
1583pub 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)]
1595impl From<RegionOverlap> for ffi::cairo_region_overlap_t {
1596    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)]
1607impl From<ffi::cairo_region_overlap_t> for RegionOverlap {
1608    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
1618impl fmt::Display for RegionOverlap {
1619    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")]
1634gvalue_impl!(
1635    RegionOverlap,
1636    ffi::gobject::cairo_gobject_region_overlap_get_type
1637);
1638
1639bitflags::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")]
1654pub 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)]
1675impl From<PdfMetadata> for ffi::cairo_pdf_metadata_t {
1676    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)]
1692impl From<ffi::cairo_pdf_metadata_t> for PdfMetadata {
1693    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"))]
1708impl fmt::Display for PdfMetadata {
1709    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")]
1731pub 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)]
1742impl From<PdfVersion> for ffi::cairo_pdf_version_t {
1743    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)]
1754impl From<ffi::cairo_pdf_version_t> for PdfVersion {
1755    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"))]
1765impl fmt::Display for PdfVersion {
1766    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")]
1783pub 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)]
1794impl From<SvgVersion> for ffi::cairo_svg_version_t {
1795    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)]
1806impl From<ffi::cairo_svg_version_t> for SvgVersion {
1807    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"))]
1817impl fmt::Display for SvgVersion {
1818    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")]
1835pub 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)]
1846impl From<PsLevel> for ffi::cairo_ps_level_t {
1847    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)]
1858impl From<ffi::cairo_ps_level_t> for PsLevel {
1859    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"))]
1869impl fmt::Display for PsLevel {
1870    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")]
1886pub 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)]
1900impl From<MeshCorner> for ffi::cairo_mesh_corner_t {
1901    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)]
1913impl From<ffi::cairo_mesh_corner_t> for MeshCorner {
1914    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
1925impl fmt::Display for MeshCorner {
1926    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")]
1945pub 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)]
1956impl From<FtSynthesize> for ffi::cairo_ft_synthesize_t {
1957    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)]
1968impl From<ffi::cairo_ft_synthesize_t> for FtSynthesize {
1969    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"))]
1979impl fmt::Display for FtSynthesize {
1980    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")]
1997pub 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)]
2008impl From<ScriptMode> for ffi::cairo_script_mode_t {
2009    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)]
2020impl From<ffi::cairo_script_mode_t> for ScriptMode {
2021    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"))]
2031impl fmt::Display for ScriptMode {
2032    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")]
2048pub 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)]
2072impl From<DeviceType> for ffi::cairo_device_type_t {
2073    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)]
2090impl From<ffi::cairo_device_type_t> for DeviceType {
2091    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
2107impl fmt::Display for DeviceType {
2108    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")]
2129gvalue_impl!(DeviceType, ffi::gobject::cairo_gobject_device_type_get_type);
2130
2131#[cfg(test)]
2132mod tests {
2133    use super::*;
2134
2135    #[test]
2136    #[should_panic]
2137    fn stride_panics_on_bad_value() {
2138        let _ = Format::Rgb24.stride_for_width(u32::MAX);
2139    }
2140
2141    #[test]
2142    fn stride_errors_on_large_width() {
2143        assert!(Format::Rgb24.stride_for_width(i32::MAX as u32).is_err());
2144    }
2145
2146    #[test]
2147    fn stride_works() {
2148        assert_eq!(Format::Rgb24.stride_for_width(1).unwrap(), 4);
2149    }
2150}
cairo/enums.rs

cairo/
enums.rs
