cairo/
enums.rs

1// Take a look at the license at the top of the repository in the LICENSE file.
2
3use std::fmt::Debug;
4
5#[cfg(feature = "use_glib")]
6use glib::translate::*;
7
8use crate::{ffi, Error};
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::prelude::StaticType for $name {
15            #[inline]
16            fn static_type() -> glib::Type {
17                unsafe { from_glib($get_type()) }
18            }
19        }
20
21        impl glib::value::ValueType for $name {
22            type Type = Self;
23        }
24
25        unsafe impl<'a> glib::value::FromValue<'a> for $name {
26            type Checker = glib::value::GenericValueTypeChecker<Self>;
27
28            unsafe fn from_value(value: &'a glib::Value) -> Self {
29                Self::from(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
30            }
31        }
32
33        impl glib::value::ToValue for $name {
34            fn to_value(&self) -> glib::Value {
35                let mut value = glib::Value::for_value_type::<Self>();
36                unsafe {
37                    glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, (*self).into());
38                }
39                value
40            }
41
42            fn value_type(&self) -> glib::Type {
43                <Self as glib::prelude::StaticType>::static_type()
44            }
45        }
46
47        impl From<$name> for glib::Value {
48            #[inline]
49            fn from(v: $name) -> Self {
50                glib::value::ToValue::to_value(&v)
51            }
52        }
53    };
54}
55
56#[derive(Clone, PartialEq, Eq, PartialOrd, Debug, Copy)]
57#[non_exhaustive]
58#[doc(alias = "cairo_antialias_t")]
59pub enum Antialias {
60    #[doc(alias = "ANTIALIAS_DEFAULT")]
61    Default,
62
63    /* method */
64    #[doc(alias = "ANTIALIAS_NONE")]
65    None,
66    #[doc(alias = "ANTIALIAS_GRAY")]
67    Gray,
68    #[doc(alias = "ANTIALIAS_SUBPIXEL")]
69    Subpixel,
70
71    /* hints */
72    #[doc(alias = "ANTIALIAS_FAST")]
73    Fast,
74    #[doc(alias = "ANTIALIAS_GOOD")]
75    Good,
76    #[doc(alias = "ANTIALIAS_BEST")]
77    Best,
78    #[doc(hidden)]
79    __Unknown(i32),
80}
81
82#[doc(hidden)]
83impl From<Antialias> for ffi::cairo_antialias_t {
84    fn from(val: Antialias) -> ffi::cairo_antialias_t {
85        match val {
86            Antialias::Default => ffi::ANTIALIAS_DEFAULT,
87            Antialias::None => ffi::ANTIALIAS_NONE,
88            Antialias::Gray => ffi::ANTIALIAS_GRAY,
89            Antialias::Subpixel => ffi::ANTIALIAS_SUBPIXEL,
90            Antialias::Fast => ffi::ANTIALIAS_FAST,
91            Antialias::Good => ffi::ANTIALIAS_GOOD,
92            Antialias::Best => ffi::ANTIALIAS_BEST,
93            Antialias::__Unknown(value) => value,
94        }
95    }
96}
97
98#[doc(hidden)]
99impl From<ffi::cairo_antialias_t> for Antialias {
100    fn from(value: ffi::cairo_antialias_t) -> Self {
101        match value {
102            ffi::ANTIALIAS_DEFAULT => Self::Default,
103            ffi::ANTIALIAS_NONE => Self::None,
104            ffi::ANTIALIAS_GRAY => Self::Gray,
105            ffi::ANTIALIAS_SUBPIXEL => Self::Subpixel,
106            ffi::ANTIALIAS_FAST => Self::Fast,
107            ffi::ANTIALIAS_GOOD => Self::Good,
108            ffi::ANTIALIAS_BEST => Self::Best,
109            value => Self::__Unknown(value),
110        }
111    }
112}
113
114#[cfg(feature = "use_glib")]
115gvalue_impl!(Antialias, ffi::gobject::cairo_gobject_antialias_get_type);
116
117#[derive(Clone, PartialEq, Eq, PartialOrd, Debug, Copy)]
118#[non_exhaustive]
119#[doc(alias = "cairo_fill_rule_t")]
120pub enum FillRule {
121    #[doc(alias = "FILL_RULE_WINDING")]
122    Winding,
123    #[doc(alias = "FILL_RULE_EVEN_ODD")]
124    EvenOdd,
125    #[doc(hidden)]
126    __Unknown(i32),
127}
128
129#[doc(hidden)]
130impl From<FillRule> for ffi::cairo_fill_rule_t {
131    fn from(val: FillRule) -> ffi::cairo_fill_rule_t {
132        match val {
133            FillRule::Winding => ffi::FILL_RULE_WINDING,
134            FillRule::EvenOdd => ffi::FILL_RULE_EVEN_ODD,
135            FillRule::__Unknown(value) => value,
136        }
137    }
138}
139
140#[doc(hidden)]
141impl From<ffi::cairo_fill_rule_t> for FillRule {
142    fn from(value: ffi::cairo_fill_rule_t) -> Self {
143        match value {
144            ffi::FILL_RULE_WINDING => Self::Winding,
145            ffi::FILL_RULE_EVEN_ODD => Self::EvenOdd,
146            value => Self::__Unknown(value),
147        }
148    }
149}
150
151#[cfg(feature = "use_glib")]
152gvalue_impl!(FillRule, ffi::gobject::cairo_gobject_fill_rule_get_type);
153
154#[derive(Clone, PartialEq, Eq, PartialOrd, Debug, Copy)]
155#[non_exhaustive]
156#[doc(alias = "cairo_line_cap_t")]
157pub enum LineCap {
158    #[doc(alias = "LINE_CAP_BUTT")]
159    Butt,
160    #[doc(alias = "LINE_CAP_ROUND")]
161    Round,
162    #[doc(alias = "LINE_CAP_SQUARE")]
163    Square,
164    #[doc(hidden)]
165    __Unknown(i32),
166}
167
168#[doc(hidden)]
169impl From<LineCap> for ffi::cairo_line_cap_t {
170    fn from(val: LineCap) -> ffi::cairo_line_cap_t {
171        match val {
172            LineCap::Butt => ffi::LINE_CAP_BUTT,
173            LineCap::Round => ffi::LINE_CAP_ROUND,
174            LineCap::Square => ffi::LINE_CAP_SQUARE,
175            LineCap::__Unknown(value) => value,
176        }
177    }
178}
179
180#[doc(hidden)]
181impl From<ffi::cairo_line_cap_t> for LineCap {
182    fn from(value: ffi::cairo_line_cap_t) -> Self {
183        match value {
184            ffi::LINE_CAP_BUTT => Self::Butt,
185            ffi::LINE_CAP_ROUND => Self::Round,
186            ffi::LINE_CAP_SQUARE => Self::Square,
187            value => Self::__Unknown(value),
188        }
189    }
190}
191
192#[cfg(feature = "use_glib")]
193gvalue_impl!(LineCap, ffi::gobject::cairo_gobject_line_cap_get_type);
194
195#[derive(Clone, PartialEq, Eq, PartialOrd, Debug, Copy)]
196#[non_exhaustive]
197#[doc(alias = "cairo_line_join_t")]
198pub enum LineJoin {
199    #[doc(alias = "LINE_JOIN_MITER")]
200    Miter,
201    #[doc(alias = "LINE_JOIN_ROUND")]
202    Round,
203    #[doc(alias = "LINE_JOIN_BEVEL")]
204    Bevel,
205    #[doc(hidden)]
206    __Unknown(i32),
207}
208
209#[doc(hidden)]
210impl From<LineJoin> for ffi::cairo_line_join_t {
211    fn from(val: LineJoin) -> ffi::cairo_line_join_t {
212        match val {
213            LineJoin::Miter => ffi::LINE_JOIN_MITER,
214            LineJoin::Round => ffi::LINE_JOIN_ROUND,
215            LineJoin::Bevel => ffi::LINE_JOIN_BEVEL,
216            LineJoin::__Unknown(value) => value,
217        }
218    }
219}
220
221#[doc(hidden)]
222impl From<ffi::cairo_line_join_t> for LineJoin {
223    fn from(value: ffi::cairo_line_join_t) -> Self {
224        match value {
225            ffi::LINE_JOIN_MITER => Self::Miter,
226            ffi::LINE_JOIN_ROUND => Self::Round,
227            ffi::LINE_JOIN_BEVEL => Self::Bevel,
228            value => Self::__Unknown(value),
229        }
230    }
231}
232
233#[cfg(feature = "use_glib")]
234gvalue_impl!(LineJoin, ffi::gobject::cairo_gobject_line_join_get_type);
235
236#[derive(Clone, PartialEq, Eq, PartialOrd, Debug, Copy)]
237#[non_exhaustive]
238#[doc(alias = "cairo_operator_t")]
239pub enum Operator {
240    #[doc(alias = "OPERATOR_CLEAR")]
241    Clear,
242
243    #[doc(alias = "OPERATOR_SOURCE")]
244    Source,
245    #[doc(alias = "OPERATOR_OVER")]
246    Over,
247    #[doc(alias = "OPERATOR_IN")]
248    In,
249    #[doc(alias = "OPERATOR_OUT")]
250    Out,
251    #[doc(alias = "OPERATOR_ATOP")]
252    Atop,
253
254    #[doc(alias = "OPERATOR_DEST")]
255    Dest,
256    #[doc(alias = "OPERATOR_DEST_OVER")]
257    DestOver,
258    #[doc(alias = "OPERATOR_DEST_IN")]
259    DestIn,
260    #[doc(alias = "OPERATOR_DEST_OUT")]
261    DestOut,
262    #[doc(alias = "OPERATOR_DEST_ATOP")]
263    DestAtop,
264
265    #[doc(alias = "OPERATOR_XOR")]
266    Xor,
267    #[doc(alias = "OPERATOR_ADD")]
268    Add,
269    #[doc(alias = "OPERATOR_SATURATE")]
270    Saturate,
271
272    #[doc(alias = "OPERATOR_MULTIPLY")]
273    Multiply,
274    #[doc(alias = "OPERATOR_SCREEN")]
275    Screen,
276    #[doc(alias = "OPERATOR_OVERLAY")]
277    Overlay,
278    #[doc(alias = "OPERATOR_DARKEN")]
279    Darken,
280    #[doc(alias = "OPERATOR_LIGHTEN")]
281    Lighten,
282    #[doc(alias = "OPERATOR_COLOR_DODGE")]
283    ColorDodge,
284    #[doc(alias = "OPERATOR_COLOR_BURN")]
285    ColorBurn,
286    #[doc(alias = "OPERATOR_HARD_LIGHT")]
287    HardLight,
288    #[doc(alias = "OPERATOR_SOFT_LIGHT")]
289    SoftLight,
290    #[doc(alias = "OPERATOR_DIFFERENCE")]
291    Difference,
292    #[doc(alias = "OPERATOR_EXCLUSION")]
293    Exclusion,
294    #[doc(alias = "OPERATOR_HSL_HUE")]
295    HslHue,
296    #[doc(alias = "OPERATOR_HSL_SATURATION")]
297    HslSaturation,
298    #[doc(alias = "OPERATOR_HSL_COLOR")]
299    HslColor,
300    #[doc(alias = "OPERATOR_HSL_LUMINOSITY")]
301    HslLuminosity,
302    #[doc(hidden)]
303    __Unknown(i32),
304}
305
306#[doc(hidden)]
307impl From<Operator> for ffi::cairo_operator_t {
308    fn from(val: Operator) -> ffi::cairo_operator_t {
309        match val {
310            Operator::Clear => ffi::OPERATOR_CLEAR,
311            Operator::Source => ffi::OPERATOR_SOURCE,
312            Operator::Over => ffi::OPERATOR_OVER,
313            Operator::In => ffi::OPERATOR_IN,
314            Operator::Out => ffi::OPERATOR_OUT,
315            Operator::Atop => ffi::OPERATOR_ATOP,
316            Operator::Dest => ffi::OPERATOR_DEST,
317            Operator::DestOver => ffi::OPERATOR_DEST_OVER,
318            Operator::DestIn => ffi::OPERATOR_DEST_IN,
319            Operator::DestOut => ffi::OPERATOR_DEST_OUT,
320            Operator::DestAtop => ffi::OPERATOR_DEST_ATOP,
321            Operator::Xor => ffi::OPERATOR_XOR,
322            Operator::Add => ffi::OPERATOR_ADD,
323            Operator::Saturate => ffi::OPERATOR_SATURATE,
324            Operator::Multiply => ffi::OPERATOR_MULTIPLY,
325            Operator::Screen => ffi::OPERATOR_SCREEN,
326            Operator::Overlay => ffi::OPERATOR_OVERLAY,
327            Operator::Darken => ffi::OPERATOR_DARKEN,
328            Operator::Lighten => ffi::OPERATOR_LIGHTEN,
329            Operator::ColorDodge => ffi::OPERATOR_COLOR_DODGE,
330            Operator::ColorBurn => ffi::OPERATOR_COLOR_BURN,
331            Operator::HardLight => ffi::OPERATOR_HARD_LIGHT,
332            Operator::SoftLight => ffi::OPERATOR_SOFT_LIGHT,
333            Operator::Difference => ffi::OPERATOR_DIFFERENCE,
334            Operator::Exclusion => ffi::OPERATOR_EXCLUSION,
335            Operator::HslHue => ffi::OPERATOR_HSL_HUE,
336            Operator::HslSaturation => ffi::OPERATOR_HSL_SATURATION,
337            Operator::HslColor => ffi::OPERATOR_HSL_COLOR,
338            Operator::HslLuminosity => ffi::OPERATOR_HSL_LUMINOSITY,
339            Operator::__Unknown(value) => value,
340        }
341    }
342}
343
344#[doc(hidden)]
345impl From<ffi::cairo_operator_t> for Operator {
346    fn from(value: ffi::cairo_operator_t) -> Self {
347        match value {
348            ffi::OPERATOR_CLEAR => Self::Clear,
349            ffi::OPERATOR_SOURCE => Self::Source,
350            ffi::OPERATOR_OVER => Self::Over,
351            ffi::OPERATOR_IN => Self::In,
352            ffi::OPERATOR_OUT => Self::Out,
353            ffi::OPERATOR_ATOP => Self::Atop,
354            ffi::OPERATOR_DEST => Self::Dest,
355            ffi::OPERATOR_DEST_OVER => Self::DestOver,
356            ffi::OPERATOR_DEST_IN => Self::DestIn,
357            ffi::OPERATOR_DEST_OUT => Self::DestOut,
358            ffi::OPERATOR_DEST_ATOP => Self::DestAtop,
359            ffi::OPERATOR_XOR => Self::Xor,
360            ffi::OPERATOR_ADD => Self::Add,
361            ffi::OPERATOR_SATURATE => Self::Saturate,
362            ffi::OPERATOR_MULTIPLY => Self::Multiply,
363            ffi::OPERATOR_SCREEN => Self::Screen,
364            ffi::OPERATOR_OVERLAY => Self::Overlay,
365            ffi::OPERATOR_DARKEN => Self::Darken,
366            ffi::OPERATOR_LIGHTEN => Self::Lighten,
367            ffi::OPERATOR_COLOR_DODGE => Self::ColorDodge,
368            ffi::OPERATOR_COLOR_BURN => Self::ColorBurn,
369            ffi::OPERATOR_HARD_LIGHT => Self::HardLight,
370            ffi::OPERATOR_SOFT_LIGHT => Self::SoftLight,
371            ffi::OPERATOR_DIFFERENCE => Self::Difference,
372            ffi::OPERATOR_EXCLUSION => Self::Exclusion,
373            ffi::OPERATOR_HSL_HUE => Self::HslHue,
374            ffi::OPERATOR_HSL_SATURATION => Self::HslSaturation,
375            ffi::OPERATOR_HSL_COLOR => Self::HslColor,
376            ffi::OPERATOR_HSL_LUMINOSITY => Self::HslLuminosity,
377            value => Self::__Unknown(value),
378        }
379    }
380}
381
382#[cfg(feature = "use_glib")]
383gvalue_impl!(Operator, ffi::gobject::cairo_gobject_operator_get_type);
384
385#[derive(Clone, PartialEq, Eq, PartialOrd, Debug, Copy)]
386#[non_exhaustive]
387#[doc(alias = "cairo_path_data_type_t")]
388pub enum PathDataType {
389    #[doc(alias = "PATH_DATA_TYPE_MOVE_TO")]
390    MoveTo,
391    #[doc(alias = "PATH_DATA_TYPE_LINE_TO")]
392    LineTo,
393    #[doc(alias = "PATH_DATA_TYPE_CURVE_TO")]
394    CurveTo,
395    #[doc(alias = "PATH_DATA_TYPE_CLOSE_PATH")]
396    ClosePath,
397    #[doc(hidden)]
398    __Unknown(i32),
399}
400
401#[doc(hidden)]
402impl From<PathDataType> for ffi::cairo_path_data_type_t {
403    fn from(val: PathDataType) -> ffi::cairo_path_data_type_t {
404        match val {
405            PathDataType::MoveTo => ffi::PATH_DATA_TYPE_MOVE_TO,
406            PathDataType::LineTo => ffi::PATH_DATA_TYPE_LINE_TO,
407            PathDataType::CurveTo => ffi::PATH_DATA_TYPE_CURVE_TO,
408            PathDataType::ClosePath => ffi::PATH_DATA_TYPE_CLOSE_PATH,
409            PathDataType::__Unknown(value) => value,
410        }
411    }
412}
413
414#[doc(hidden)]
415impl From<ffi::cairo_path_data_type_t> for PathDataType {
416    fn from(value: ffi::cairo_path_data_type_t) -> Self {
417        match value {
418            ffi::PATH_DATA_TYPE_MOVE_TO => Self::MoveTo,
419            ffi::PATH_DATA_TYPE_LINE_TO => Self::LineTo,
420            ffi::PATH_DATA_TYPE_CURVE_TO => Self::CurveTo,
421            ffi::PATH_DATA_TYPE_CLOSE_PATH => Self::ClosePath,
422            value => Self::__Unknown(value),
423        }
424    }
425}
426
427#[cfg(feature = "use_glib")]
428gvalue_impl!(
429    PathDataType,
430    ffi::gobject::cairo_gobject_path_data_type_get_type
431);
432
433#[derive(Clone, PartialEq, Eq, PartialOrd, Debug, Copy)]
434#[non_exhaustive]
435#[doc(alias = "cairo_content_t")]
436pub enum Content {
437    #[doc(alias = "CONTENT_COLOR")]
438    Color,
439    #[doc(alias = "CONTENT_ALPHA")]
440    Alpha,
441    #[doc(alias = "CONTENT_COLOR_ALPHA")]
442    ColorAlpha,
443    #[doc(hidden)]
444    __Unknown(i32),
445}
446
447#[doc(hidden)]
448impl From<Content> for ffi::cairo_content_t {
449    fn from(val: Content) -> ffi::cairo_content_t {
450        match val {
451            Content::Color => ffi::CONTENT_COLOR,
452            Content::Alpha => ffi::CONTENT_ALPHA,
453            Content::ColorAlpha => ffi::CONTENT_COLOR_ALPHA,
454            Content::__Unknown(value) => value,
455        }
456    }
457}
458
459#[doc(hidden)]
460impl From<ffi::cairo_content_t> for Content {
461    fn from(value: ffi::cairo_content_t) -> Self {
462        match value {
463            ffi::CONTENT_COLOR => Self::Color,
464            ffi::CONTENT_ALPHA => Self::Alpha,
465            ffi::CONTENT_COLOR_ALPHA => Self::ColorAlpha,
466            value => Self::__Unknown(value),
467        }
468    }
469}
470
471#[cfg(feature = "use_glib")]
472gvalue_impl!(Content, ffi::gobject::cairo_gobject_content_get_type);
473
474#[derive(Clone, PartialEq, Eq, PartialOrd, Debug, Copy)]
475#[non_exhaustive]
476#[doc(alias = "cairo_extend_t")]
477pub enum Extend {
478    #[doc(alias = "EXTEND_NONE")]
479    None,
480    #[doc(alias = "EXTEND_REPEAT")]
481    Repeat,
482    #[doc(alias = "EXTEND_REFLECT")]
483    Reflect,
484    #[doc(alias = "EXTEND_PAD")]
485    Pad,
486    #[doc(hidden)]
487    __Unknown(i32),
488}
489
490#[doc(hidden)]
491impl From<Extend> for ffi::cairo_extend_t {
492    fn from(val: Extend) -> ffi::cairo_extend_t {
493        match val {
494            Extend::None => ffi::EXTEND_NONE,
495            Extend::Repeat => ffi::EXTEND_REPEAT,
496            Extend::Reflect => ffi::EXTEND_REFLECT,
497            Extend::Pad => ffi::EXTEND_PAD,
498            Extend::__Unknown(value) => value,
499        }
500    }
501}
502
503#[doc(hidden)]
504impl From<ffi::cairo_extend_t> for Extend {
505    fn from(value: ffi::cairo_extend_t) -> Self {
506        match value {
507            ffi::EXTEND_NONE => Self::None,
508            ffi::EXTEND_REPEAT => Self::Repeat,
509            ffi::EXTEND_REFLECT => Self::Reflect,
510            ffi::EXTEND_PAD => Self::Pad,
511            value => Self::__Unknown(value),
512        }
513    }
514}
515
516#[cfg(feature = "use_glib")]
517gvalue_impl!(Extend, ffi::gobject::cairo_gobject_extend_get_type);
518
519#[derive(Clone, PartialEq, Eq, PartialOrd, Debug, Copy)]
520#[non_exhaustive]
521#[doc(alias = "cairo_filter_t")]
522pub enum Filter {
523    #[doc(alias = "FILTER_FAST")]
524    Fast,
525    #[doc(alias = "FILTER_GOOD")]
526    Good,
527    #[doc(alias = "FILTER_BEST")]
528    Best,
529    #[doc(alias = "FILTER_NEAREST")]
530    Nearest,
531    #[doc(alias = "FILTER_BILINEAR")]
532    Bilinear,
533    #[doc(alias = "FILTER_GAUSSIAN")]
534    Gaussian,
535    #[doc(hidden)]
536    __Unknown(i32),
537}
538
539#[doc(hidden)]
540impl From<Filter> for ffi::cairo_filter_t {
541    fn from(val: Filter) -> ffi::cairo_filter_t {
542        match val {
543            Filter::Fast => ffi::FILTER_FAST,
544            Filter::Good => ffi::FILTER_GOOD,
545            Filter::Best => ffi::FILTER_BEST,
546            Filter::Nearest => ffi::FILTER_NEAREST,
547            Filter::Bilinear => ffi::FILTER_BILINEAR,
548            Filter::Gaussian => ffi::FILTER_GAUSSIAN,
549            Filter::__Unknown(value) => value,
550        }
551    }
552}
553
554#[doc(hidden)]
555impl From<ffi::cairo_filter_t> for Filter {
556    fn from(value: ffi::cairo_filter_t) -> Self {
557        match value {
558            ffi::FILTER_FAST => Self::Fast,
559            ffi::FILTER_GOOD => Self::Good,
560            ffi::FILTER_BEST => Self::Best,
561            ffi::FILTER_NEAREST => Self::Nearest,
562            ffi::FILTER_BILINEAR => Self::Bilinear,
563            ffi::FILTER_GAUSSIAN => Self::Gaussian,
564            value => Self::__Unknown(value),
565        }
566    }
567}
568
569#[cfg(feature = "use_glib")]
570gvalue_impl!(Filter, ffi::gobject::cairo_gobject_filter_get_type);
571
572#[derive(Clone, PartialEq, Eq, PartialOrd, Debug, Copy)]
573#[non_exhaustive]
574#[doc(alias = "cairo_pattern_type_t")]
575pub enum PatternType {
576    #[doc(alias = "PATTERN_TYPE_SOLID")]
577    Solid,
578    #[doc(alias = "PATTERN_TYPE_SURFACE")]
579    Surface,
580    #[doc(alias = "PATTERN_TYPE_LINEAR_GRADIENT")]
581    LinearGradient,
582    #[doc(alias = "PATTERN_TYPE_RADIAL_GRADIENT")]
583    RadialGradient,
584    #[doc(alias = "PATTERN_TYPE_MESH")]
585    Mesh,
586    #[doc(alias = "PATTERN_TYPE_RASTER_SOURCE")]
587    RasterSource,
588    #[doc(hidden)]
589    __Unknown(i32),
590}
591
592#[doc(hidden)]
593impl From<PatternType> for ffi::cairo_pattern_type_t {
594    fn from(val: PatternType) -> ffi::cairo_pattern_type_t {
595        match val {
596            PatternType::Solid => ffi::PATTERN_TYPE_SOLID,
597            PatternType::Surface => ffi::PATTERN_TYPE_SURFACE,
598            PatternType::LinearGradient => ffi::PATTERN_TYPE_LINEAR_GRADIENT,
599            PatternType::RadialGradient => ffi::PATTERN_TYPE_RADIAL_GRADIENT,
600            PatternType::Mesh => ffi::PATTERN_TYPE_MESH,
601            PatternType::RasterSource => ffi::PATTERN_TYPE_RASTER_SOURCE,
602            PatternType::__Unknown(value) => value,
603        }
604    }
605}
606
607#[doc(hidden)]
608impl From<ffi::cairo_pattern_type_t> for PatternType {
609    fn from(value: ffi::cairo_pattern_type_t) -> Self {
610        match value {
611            ffi::PATTERN_TYPE_SOLID => Self::Solid,
612            ffi::PATTERN_TYPE_SURFACE => Self::Surface,
613            ffi::PATTERN_TYPE_LINEAR_GRADIENT => Self::LinearGradient,
614            ffi::PATTERN_TYPE_RADIAL_GRADIENT => Self::RadialGradient,
615            ffi::PATTERN_TYPE_MESH => Self::Mesh,
616            ffi::PATTERN_TYPE_RASTER_SOURCE => Self::RasterSource,
617            value => Self::__Unknown(value),
618        }
619    }
620}
621
622#[cfg(feature = "use_glib")]
623gvalue_impl!(
624    PatternType,
625    ffi::gobject::cairo_gobject_pattern_type_get_type
626);
627
628#[derive(Clone, PartialEq, Eq, PartialOrd, Debug, Copy)]
629#[non_exhaustive]
630#[doc(alias = "cairo_font_slant_t")]
631pub enum FontSlant {
632    #[doc(alias = "FONT_SLANT_NORMAL")]
633    Normal,
634    #[doc(alias = "FONT_SLANT_ITALIC")]
635    Italic,
636    #[doc(alias = "FONT_SLANT_OBLIQUE")]
637    Oblique,
638    #[doc(hidden)]
639    __Unknown(i32),
640}
641
642#[doc(hidden)]
643impl From<FontSlant> for ffi::cairo_font_slant_t {
644    fn from(val: FontSlant) -> ffi::cairo_font_slant_t {
645        match val {
646            FontSlant::Normal => ffi::FONT_SLANT_NORMAL,
647            FontSlant::Italic => ffi::FONT_SLANT_ITALIC,
648            FontSlant::Oblique => ffi::FONT_SLANT_OBLIQUE,
649            FontSlant::__Unknown(value) => value,
650        }
651    }
652}
653
654#[doc(hidden)]
655impl From<ffi::cairo_font_slant_t> for FontSlant {
656    fn from(value: ffi::cairo_font_slant_t) -> Self {
657        match value {
658            ffi::FONT_SLANT_NORMAL => Self::Normal,
659            ffi::FONT_SLANT_ITALIC => Self::Italic,
660            ffi::FONT_SLANT_OBLIQUE => Self::Oblique,
661            value => Self::__Unknown(value),
662        }
663    }
664}
665
666#[cfg(feature = "use_glib")]
667gvalue_impl!(FontSlant, ffi::gobject::cairo_gobject_font_slant_get_type);
668
669#[derive(Clone, PartialEq, Eq, PartialOrd, Debug, Copy)]
670#[non_exhaustive]
671#[doc(alias = "cairo_font_weight_t")]
672pub enum FontWeight {
673    #[doc(alias = "FONT_WEIGHT_NORMAL")]
674    Normal,
675    #[doc(alias = "FONT_WEIGHT_BOLD")]
676    Bold,
677    #[doc(hidden)]
678    __Unknown(i32),
679}
680
681#[doc(hidden)]
682impl From<FontWeight> for ffi::cairo_font_weight_t {
683    fn from(val: FontWeight) -> ffi::cairo_font_weight_t {
684        match val {
685            FontWeight::Normal => ffi::FONT_WEIGHT_NORMAL,
686            FontWeight::Bold => ffi::FONT_WEIGHT_BOLD,
687            FontWeight::__Unknown(value) => value,
688        }
689    }
690}
691
692#[doc(hidden)]
693impl From<ffi::cairo_font_weight_t> for FontWeight {
694    fn from(value: ffi::cairo_font_weight_t) -> Self {
695        match value {
696            ffi::FONT_WEIGHT_NORMAL => Self::Normal,
697            ffi::FONT_WEIGHT_BOLD => Self::Bold,
698            value => Self::__Unknown(value),
699        }
700    }
701}
702
703#[cfg(feature = "use_glib")]
704gvalue_impl!(FontWeight, ffi::gobject::cairo_gobject_font_weight_get_type);
705
706#[derive(Clone, PartialEq, Eq, PartialOrd, Debug, Copy)]
707#[non_exhaustive]
708#[doc(alias = "cairo_text_cluster_flags_t")]
709pub enum TextClusterFlags {
710    #[doc(alias = "TEXT_CLUSTER_FLAGS_NONE")]
711    None,
712    #[doc(alias = "TEXT_CLUSTER_FLAGS_BACKWARD")]
713    Backward,
714    #[doc(hidden)]
715    __Unknown(i32),
716}
717
718#[doc(hidden)]
719impl From<TextClusterFlags> for ffi::cairo_text_cluster_flags_t {
720    fn from(val: TextClusterFlags) -> ffi::cairo_text_cluster_flags_t {
721        match val {
722            TextClusterFlags::None => ffi::TEXT_CLUSTER_FLAGS_NONE,
723            TextClusterFlags::Backward => ffi::TEXT_CLUSTER_FLAGS_BACKWARD,
724            TextClusterFlags::__Unknown(value) => value,
725        }
726    }
727}
728
729#[doc(hidden)]
730impl From<ffi::cairo_text_cluster_flags_t> for TextClusterFlags {
731    fn from(value: ffi::cairo_text_cluster_flags_t) -> Self {
732        match value {
733            ffi::TEXT_CLUSTER_FLAGS_NONE => Self::None,
734            ffi::TEXT_CLUSTER_FLAGS_BACKWARD => Self::Backward,
735            value => Self::__Unknown(value),
736        }
737    }
738}
739
740#[cfg(feature = "use_glib")]
741gvalue_impl!(
742    TextClusterFlags,
743    ffi::gobject::cairo_gobject_text_cluster_flags_get_type
744);
745
746#[derive(Clone, PartialEq, Eq, PartialOrd, Debug, Copy)]
747#[non_exhaustive]
748#[doc(alias = "cairo_font_type_t")]
749pub enum FontType {
750    #[doc(alias = "FONT_TYPE_FONT_TYPE_TOY")]
751    FontTypeToy,
752    #[doc(alias = "FONT_TYPE_FONT_TYPE_FT")]
753    FontTypeFt,
754    #[doc(alias = "FONT_TYPE_FONT_TYPE_WIN32")]
755    FontTypeWin32,
756    #[doc(alias = "FONT_TYPE_FONT_TYPE_QUARTZ")]
757    FontTypeQuartz,
758    #[doc(alias = "FONT_TYPE_FONT_TYPE_USER")]
759    FontTypeUser,
760    #[cfg(feature = "v1_18")]
761    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
762    #[doc(alias = "FONT_TYPE_FONT_TYPE_DWRITE")]
763    FontTypeDwrite,
764    #[doc(hidden)]
765    __Unknown(i32),
766}
767
768#[doc(hidden)]
769impl From<FontType> for ffi::cairo_font_type_t {
770    fn from(val: FontType) -> ffi::cairo_font_type_t {
771        match val {
772            FontType::FontTypeToy => ffi::FONT_TYPE_FONT_TYPE_TOY,
773            FontType::FontTypeFt => ffi::FONT_TYPE_FONT_TYPE_FT,
774            FontType::FontTypeWin32 => ffi::FONT_TYPE_FONT_TYPE_WIN32,
775            FontType::FontTypeQuartz => ffi::FONT_TYPE_FONT_TYPE_QUARTZ,
776            FontType::FontTypeUser => ffi::FONT_TYPE_FONT_TYPE_USER,
777            #[cfg(feature = "v1_18")]
778            FontType::FontTypeDwrite => ffi::FONT_TYPE_FONT_TYPE_DWRITE,
779            FontType::__Unknown(value) => value,
780        }
781    }
782}
783
784#[doc(hidden)]
785impl From<ffi::cairo_font_type_t> for FontType {
786    fn from(value: ffi::cairo_font_type_t) -> Self {
787        match value {
788            ffi::FONT_TYPE_FONT_TYPE_TOY => Self::FontTypeToy,
789            ffi::FONT_TYPE_FONT_TYPE_FT => Self::FontTypeFt,
790            ffi::FONT_TYPE_FONT_TYPE_WIN32 => Self::FontTypeWin32,
791            ffi::FONT_TYPE_FONT_TYPE_QUARTZ => Self::FontTypeQuartz,
792            ffi::FONT_TYPE_FONT_TYPE_USER => Self::FontTypeUser,
793            #[cfg(feature = "v1_18")]
794            ffi::FONT_TYPE_FONT_TYPE_DWRITE => Self::FontTypeDwrite,
795            value => Self::__Unknown(value),
796        }
797    }
798}
799
800#[cfg(feature = "use_glib")]
801gvalue_impl!(FontType, ffi::gobject::cairo_gobject_font_type_get_type);
802
803#[derive(Clone, PartialEq, Eq, PartialOrd, Debug, Copy)]
804#[non_exhaustive]
805#[doc(alias = "cairo_subpixel_order_t")]
806pub enum SubpixelOrder {
807    #[doc(alias = "SUBPIXEL_ORDER_DEFAULT")]
808    Default,
809    #[doc(alias = "SUBPIXEL_ORDER_RGB")]
810    Rgb,
811    #[doc(alias = "SUBPIXEL_ORDER_BGR")]
812    Bgr,
813    #[doc(alias = "SUBPIXEL_ORDER_VRGB")]
814    Vrgb,
815    #[doc(alias = "SUBPIXEL_ORDER_VBGR")]
816    Vbgr,
817    #[doc(hidden)]
818    __Unknown(i32),
819}
820
821#[doc(hidden)]
822impl From<SubpixelOrder> for ffi::cairo_subpixel_order_t {
823    fn from(val: SubpixelOrder) -> ffi::cairo_subpixel_order_t {
824        match val {
825            SubpixelOrder::Default => ffi::SUBPIXEL_ORDER_DEFAULT,
826            SubpixelOrder::Rgb => ffi::SUBPIXEL_ORDER_RGB,
827            SubpixelOrder::Bgr => ffi::SUBPIXEL_ORDER_BGR,
828            SubpixelOrder::Vrgb => ffi::SUBPIXEL_ORDER_VRGB,
829            SubpixelOrder::Vbgr => ffi::SUBPIXEL_ORDER_VBGR,
830            SubpixelOrder::__Unknown(value) => value,
831        }
832    }
833}
834
835#[doc(hidden)]
836impl From<ffi::cairo_subpixel_order_t> for SubpixelOrder {
837    fn from(value: ffi::cairo_subpixel_order_t) -> Self {
838        match value {
839            ffi::SUBPIXEL_ORDER_DEFAULT => Self::Default,
840            ffi::SUBPIXEL_ORDER_RGB => Self::Rgb,
841            ffi::SUBPIXEL_ORDER_BGR => Self::Bgr,
842            ffi::SUBPIXEL_ORDER_VRGB => Self::Vrgb,
843            ffi::SUBPIXEL_ORDER_VBGR => Self::Vbgr,
844            value => Self::__Unknown(value),
845        }
846    }
847}
848
849#[cfg(feature = "use_glib")]
850gvalue_impl!(
851    SubpixelOrder,
852    ffi::gobject::cairo_gobject_subpixel_order_get_type
853);
854
855#[derive(Clone, PartialEq, Eq, PartialOrd, Debug, Copy)]
856#[non_exhaustive]
857#[doc(alias = "cairo_hint_style_t")]
858pub enum HintStyle {
859    #[doc(alias = "HINT_STYLE_DEFAULT")]
860    Default,
861    #[doc(alias = "HINT_STYLE_NONE")]
862    None,
863    #[doc(alias = "HINT_STYLE_SLIGHT")]
864    Slight,
865    #[doc(alias = "HINT_STYLE_MEDIUM")]
866    Medium,
867    #[doc(alias = "HINT_STYLE_FULL")]
868    Full,
869    #[doc(hidden)]
870    __Unknown(i32),
871}
872
873#[doc(hidden)]
874impl From<HintStyle> for ffi::cairo_hint_style_t {
875    fn from(val: HintStyle) -> ffi::cairo_hint_style_t {
876        match val {
877            HintStyle::Default => ffi::HINT_STYLE_DEFAULT,
878            HintStyle::None => ffi::HINT_STYLE_NONE,
879            HintStyle::Slight => ffi::HINT_STYLE_SLIGHT,
880            HintStyle::Medium => ffi::HINT_STYLE_MEDIUM,
881            HintStyle::Full => ffi::HINT_STYLE_FULL,
882            HintStyle::__Unknown(value) => value,
883        }
884    }
885}
886
887#[doc(hidden)]
888impl From<ffi::cairo_hint_style_t> for HintStyle {
889    fn from(value: ffi::cairo_hint_style_t) -> Self {
890        match value {
891            ffi::HINT_STYLE_DEFAULT => Self::Default,
892            ffi::HINT_STYLE_NONE => Self::None,
893            ffi::HINT_STYLE_SLIGHT => Self::Slight,
894            ffi::HINT_STYLE_MEDIUM => Self::Medium,
895            ffi::HINT_STYLE_FULL => Self::Full,
896            value => Self::__Unknown(value),
897        }
898    }
899}
900
901#[cfg(feature = "use_glib")]
902gvalue_impl!(HintStyle, ffi::gobject::cairo_gobject_hint_style_get_type);
903
904#[derive(Clone, PartialEq, Eq, PartialOrd, Debug, Copy)]
905#[non_exhaustive]
906#[doc(alias = "cairo_hint_metrics_t")]
907pub enum HintMetrics {
908    #[doc(alias = "HINT_METRICS_DEFAULT")]
909    Default,
910    #[doc(alias = "HINT_METRICS_OFF")]
911    Off,
912    #[doc(alias = "HINT_METRICS_ON")]
913    On,
914    #[doc(hidden)]
915    __Unknown(i32),
916}
917
918#[doc(hidden)]
919impl From<HintMetrics> for ffi::cairo_hint_metrics_t {
920    fn from(val: HintMetrics) -> ffi::cairo_hint_metrics_t {
921        match val {
922            HintMetrics::Default => ffi::HINT_METRICS_DEFAULT,
923            HintMetrics::Off => ffi::HINT_METRICS_OFF,
924            HintMetrics::On => ffi::HINT_METRICS_ON,
925            HintMetrics::__Unknown(value) => value,
926        }
927    }
928}
929
930#[doc(hidden)]
931impl From<ffi::cairo_hint_metrics_t> for HintMetrics {
932    fn from(value: ffi::cairo_hint_metrics_t) -> Self {
933        match value {
934            ffi::HINT_METRICS_DEFAULT => Self::Default,
935            ffi::HINT_METRICS_OFF => Self::Off,
936            ffi::HINT_METRICS_ON => Self::On,
937            value => Self::__Unknown(value),
938        }
939    }
940}
941
942#[cfg(feature = "use_glib")]
943gvalue_impl!(
944    HintMetrics,
945    ffi::gobject::cairo_gobject_hint_metrics_get_type
946);
947
948#[derive(Clone, Copy, Debug, PartialEq, Eq)]
949#[non_exhaustive]
950#[doc(alias = "cairo_surface_type_t")]
951pub enum SurfaceType {
952    #[doc(alias = "SURFACE_TYPE_IMAGE")]
953    Image,
954    #[doc(alias = "SURFACE_TYPE_PDF")]
955    Pdf,
956    #[doc(alias = "SURFACE_TYPE_PS")]
957    Ps,
958    #[doc(alias = "SURFACE_TYPE_XLIB")]
959    Xlib,
960    #[doc(alias = "SURFACE_TYPE_XCB")]
961    Xcb,
962    #[doc(alias = "SURFACE_TYPE_GLITZ")]
963    Glitz,
964    #[doc(alias = "SURFACE_TYPE_QUARTZ")]
965    Quartz,
966    #[doc(alias = "SURFACE_TYPE_WIN32")]
967    Win32,
968    #[doc(alias = "SURFACE_TYPE_BE_OS")]
969    BeOs,
970    #[doc(alias = "SURFACE_TYPE_DIRECT_FB")]
971    DirectFb,
972    #[doc(alias = "SURFACE_TYPE_SVG")]
973    Svg,
974    #[doc(alias = "SURFACE_TYPE_OS2")]
975    Os2,
976    #[doc(alias = "SURFACE_TYPE_WIN32_PRINTING")]
977    Win32Printing,
978    #[doc(alias = "SURFACE_TYPE_QUARTZ_IMAGE")]
979    QuartzImage,
980    #[doc(alias = "SURFACE_TYPE_SCRIPT")]
981    Script,
982    #[doc(alias = "SURFACE_TYPE_QT")]
983    Qt,
984    #[doc(alias = "SURFACE_TYPE_RECORDING")]
985    Recording,
986    #[doc(alias = "SURFACE_TYPE_VG")]
987    Vg,
988    #[doc(alias = "SURFACE_TYPE_GL")]
989    Gl,
990    #[doc(alias = "SURFACE_TYPE_DRM")]
991    Drm,
992    #[doc(alias = "SURFACE_TYPE_TEE")]
993    Tee,
994    #[doc(alias = "SURFACE_TYPE_XML")]
995    Xml,
996    #[doc(alias = "SURFACE_TYPE_SKIA")]
997    Skia,
998    #[doc(alias = "SURFACE_TYPE_SUBSURFACE")]
999    Subsurface,
1000    #[doc(alias = "SURFACE_TYPE_COGL")]
1001    Cogl,
1002    #[doc(hidden)]
1003    __Unknown(i32),
1004}
1005
1006#[doc(hidden)]
1007impl From<SurfaceType> for ffi::cairo_surface_type_t {
1008    fn from(val: SurfaceType) -> ffi::cairo_surface_type_t {
1009        match val {
1010            SurfaceType::Image => ffi::SURFACE_TYPE_IMAGE,
1011            SurfaceType::Pdf => ffi::SURFACE_TYPE_PDF,
1012            SurfaceType::Ps => ffi::SURFACE_TYPE_PS,
1013            SurfaceType::Xlib => ffi::SURFACE_TYPE_XLIB,
1014            SurfaceType::Xcb => ffi::SURFACE_TYPE_XCB,
1015            SurfaceType::Glitz => ffi::SURFACE_TYPE_GLITZ,
1016            SurfaceType::Quartz => ffi::SURFACE_TYPE_QUARTZ,
1017            SurfaceType::Win32 => ffi::SURFACE_TYPE_WIN32,
1018            SurfaceType::BeOs => ffi::SURFACE_TYPE_BE_OS,
1019            SurfaceType::DirectFb => ffi::SURFACE_TYPE_DIRECT_FB,
1020            SurfaceType::Svg => ffi::SURFACE_TYPE_SVG,
1021            SurfaceType::Os2 => ffi::SURFACE_TYPE_OS2,
1022            SurfaceType::Win32Printing => ffi::SURFACE_TYPE_WIN32_PRINTING,
1023            SurfaceType::QuartzImage => ffi::SURFACE_TYPE_QUARTZ_IMAGE,
1024            SurfaceType::Script => ffi::SURFACE_TYPE_SCRIPT,
1025            SurfaceType::Qt => ffi::SURFACE_TYPE_QT,
1026            SurfaceType::Recording => ffi::SURFACE_TYPE_RECORDING,
1027            SurfaceType::Vg => ffi::SURFACE_TYPE_VG,
1028            SurfaceType::Gl => ffi::SURFACE_TYPE_GL,
1029            SurfaceType::Drm => ffi::SURFACE_TYPE_DRM,
1030            SurfaceType::Tee => ffi::SURFACE_TYPE_TEE,
1031            SurfaceType::Xml => ffi::SURFACE_TYPE_XML,
1032            SurfaceType::Skia => ffi::SURFACE_TYPE_SKIA,
1033            SurfaceType::Subsurface => ffi::SURFACE_TYPE_SUBSURFACE,
1034            SurfaceType::Cogl => ffi::SURFACE_TYPE_COGL,
1035            SurfaceType::__Unknown(value) => value,
1036        }
1037    }
1038}
1039
1040#[doc(hidden)]
1041impl From<ffi::cairo_surface_type_t> for SurfaceType {
1042    fn from(value: ffi::cairo_surface_type_t) -> Self {
1043        match value {
1044            ffi::SURFACE_TYPE_IMAGE => Self::Image,
1045            ffi::SURFACE_TYPE_PDF => Self::Pdf,
1046            ffi::SURFACE_TYPE_PS => Self::Ps,
1047            ffi::SURFACE_TYPE_XLIB => Self::Xlib,
1048            ffi::SURFACE_TYPE_XCB => Self::Xcb,
1049            ffi::SURFACE_TYPE_GLITZ => Self::Glitz,
1050            ffi::SURFACE_TYPE_QUARTZ => Self::Quartz,
1051            ffi::SURFACE_TYPE_WIN32 => Self::Win32,
1052            ffi::SURFACE_TYPE_BE_OS => Self::BeOs,
1053            ffi::SURFACE_TYPE_DIRECT_FB => Self::DirectFb,
1054            ffi::SURFACE_TYPE_SVG => Self::Svg,
1055            ffi::SURFACE_TYPE_OS2 => Self::Os2,
1056            ffi::SURFACE_TYPE_WIN32_PRINTING => Self::Win32Printing,
1057            ffi::SURFACE_TYPE_QUARTZ_IMAGE => Self::QuartzImage,
1058            ffi::SURFACE_TYPE_SCRIPT => Self::Script,
1059            ffi::SURFACE_TYPE_QT => Self::Qt,
1060            ffi::SURFACE_TYPE_RECORDING => Self::Recording,
1061            ffi::SURFACE_TYPE_VG => Self::Vg,
1062            ffi::SURFACE_TYPE_GL => Self::Gl,
1063            ffi::SURFACE_TYPE_DRM => Self::Drm,
1064            ffi::SURFACE_TYPE_TEE => Self::Tee,
1065            ffi::SURFACE_TYPE_XML => Self::Xml,
1066            ffi::SURFACE_TYPE_SKIA => Self::Skia,
1067            ffi::SURFACE_TYPE_SUBSURFACE => Self::Subsurface,
1068            ffi::SURFACE_TYPE_COGL => Self::Cogl,
1069            value => Self::__Unknown(value),
1070        }
1071    }
1072}
1073
1074#[cfg(feature = "use_glib")]
1075gvalue_impl!(
1076    SurfaceType,
1077    ffi::gobject::cairo_gobject_surface_type_get_type
1078);
1079
1080#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1081#[cfg(all(feature = "svg", feature = "v1_16"))]
1082#[cfg_attr(docsrs, doc(cfg(all(feature = "svg", feature = "v1_16"))))]
1083#[non_exhaustive]
1084#[doc(alias = "cairo_svg_unit_t")]
1085pub enum SvgUnit {
1086    #[doc(alias = "SVG_UNIT_USER")]
1087    User,
1088    #[doc(alias = "SVG_UNIT_EM")]
1089    Em,
1090    #[doc(alias = "SVG_UNIT_EX")]
1091    Ex,
1092    #[doc(alias = "SVG_UNIT_PX")]
1093    Px,
1094    #[doc(alias = "SVG_UNIT_IN")]
1095    In,
1096    #[doc(alias = "SVG_UNIT_CM")]
1097    Cm,
1098    #[doc(alias = "SVG_UNIT_MM")]
1099    Mm,
1100    #[doc(alias = "SVG_UNIT_PT")]
1101    Pt,
1102    #[doc(alias = "SVG_UNIT_PC")]
1103    Pc,
1104    #[doc(alias = "SVG_UNIT_PERCENT")]
1105    Percent,
1106    #[doc(hidden)]
1107    __Unknown(i32),
1108}
1109
1110#[doc(hidden)]
1111#[cfg(all(feature = "svg", feature = "v1_16"))]
1112#[cfg_attr(docsrs, doc(cfg(all(feature = "svg", feature = "v1_16"))))]
1113impl From<SvgUnit> for ffi::cairo_svg_unit_t {
1114    fn from(val: SvgUnit) -> ffi::cairo_svg_unit_t {
1115        match val {
1116            SvgUnit::User => ffi::SVG_UNIT_USER,
1117            SvgUnit::Em => ffi::SVG_UNIT_EM,
1118            SvgUnit::Ex => ffi::SVG_UNIT_EX,
1119            SvgUnit::Px => ffi::SVG_UNIT_PX,
1120            SvgUnit::In => ffi::SVG_UNIT_IN,
1121            SvgUnit::Cm => ffi::SVG_UNIT_CM,
1122            SvgUnit::Mm => ffi::SVG_UNIT_MM,
1123            SvgUnit::Pt => ffi::SVG_UNIT_PT,
1124            SvgUnit::Pc => ffi::SVG_UNIT_PC,
1125            SvgUnit::Percent => ffi::SVG_UNIT_PERCENT,
1126            SvgUnit::__Unknown(value) => value,
1127        }
1128    }
1129}
1130
1131#[doc(hidden)]
1132#[cfg(all(feature = "svg", feature = "v1_16"))]
1133#[cfg_attr(docsrs, doc(cfg(all(feature = "svg", feature = "v1_16"))))]
1134impl From<ffi::cairo_svg_unit_t> for SvgUnit {
1135    fn from(value: ffi::cairo_svg_unit_t) -> Self {
1136        match value {
1137            ffi::SVG_UNIT_USER => Self::User,
1138            ffi::SVG_UNIT_EM => Self::Em,
1139            ffi::SVG_UNIT_EX => Self::Ex,
1140            ffi::SVG_UNIT_PX => Self::Px,
1141            ffi::SVG_UNIT_IN => Self::In,
1142            ffi::SVG_UNIT_CM => Self::Cm,
1143            ffi::SVG_UNIT_MM => Self::Mm,
1144            ffi::SVG_UNIT_PT => Self::Pt,
1145            ffi::SVG_UNIT_PC => Self::Pc,
1146            ffi::SVG_UNIT_PERCENT => Self::Percent,
1147            value => Self::__Unknown(value),
1148        }
1149    }
1150}
1151
1152#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1153#[non_exhaustive]
1154#[doc(alias = "cairo_format_t")]
1155pub enum Format {
1156    #[doc(alias = "FORMAT_INVALID")]
1157    Invalid,
1158    #[doc(alias = "FORMAT_A_RGB32")]
1159    ARgb32,
1160    #[doc(alias = "FORMAT_RGB24")]
1161    Rgb24,
1162    #[doc(alias = "FORMAT_A8")]
1163    A8,
1164    #[doc(alias = "FORMAT_A1")]
1165    A1,
1166    #[doc(alias = "FORMAT_RGB16_565")]
1167    Rgb16_565,
1168    #[doc(alias = "FORMAT_RGB30")]
1169    Rgb30,
1170    #[doc(hidden)]
1171    __Unknown(i32),
1172}
1173
1174#[doc(hidden)]
1175impl From<Format> for ffi::cairo_format_t {
1176    fn from(val: Format) -> ffi::cairo_format_t {
1177        match val {
1178            Format::Invalid => ffi::FORMAT_INVALID,
1179            Format::ARgb32 => ffi::FORMAT_A_RGB32,
1180            Format::Rgb24 => ffi::FORMAT_RGB24,
1181            Format::A8 => ffi::FORMAT_A8,
1182            Format::A1 => ffi::FORMAT_A1,
1183            Format::Rgb16_565 => ffi::FORMAT_RGB16_565,
1184            Format::Rgb30 => ffi::FORMAT_RGB30,
1185            Format::__Unknown(value) => value,
1186        }
1187    }
1188}
1189
1190#[doc(hidden)]
1191impl From<ffi::cairo_format_t> for Format {
1192    fn from(value: ffi::cairo_format_t) -> Self {
1193        match value {
1194            ffi::FORMAT_INVALID => Self::Invalid,
1195            ffi::FORMAT_A_RGB32 => Self::ARgb32,
1196            ffi::FORMAT_RGB24 => Self::Rgb24,
1197            ffi::FORMAT_A8 => Self::A8,
1198            ffi::FORMAT_A1 => Self::A1,
1199            ffi::FORMAT_RGB16_565 => Self::Rgb16_565,
1200            ffi::FORMAT_RGB30 => Self::Rgb30,
1201            value => Self::__Unknown(value),
1202        }
1203    }
1204}
1205
1206#[cfg(feature = "use_glib")]
1207gvalue_impl!(Format, ffi::gobject::cairo_gobject_format_get_type);
1208
1209impl Format {
1210    #[doc(alias = "cairo_format_stride_for_width")]
1211    pub fn stride_for_width(self, width: u32) -> Result<i32, Error> {
1212        assert!(width <= i32::MAX as u32);
1213        let width = width as i32;
1214
1215        let stride = unsafe { ffi::cairo_format_stride_for_width(self.into(), width) };
1216        if stride == -1 {
1217            Err(Error::InvalidFormat)
1218        } else {
1219            Ok(stride)
1220        }
1221    }
1222}
1223
1224#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1225#[non_exhaustive]
1226#[doc(alias = "cairo_region_overlap_t")]
1227pub enum RegionOverlap {
1228    #[doc(alias = "REGION_OVERLAP_IN")]
1229    In,
1230    #[doc(alias = "REGION_OVERLAP_OUT")]
1231    Out,
1232    #[doc(alias = "REGION_OVERLAP_PART")]
1233    Part,
1234    #[doc(hidden)]
1235    __Unknown(i32),
1236}
1237
1238#[doc(hidden)]
1239impl From<RegionOverlap> for ffi::cairo_region_overlap_t {
1240    fn from(val: RegionOverlap) -> ffi::cairo_region_overlap_t {
1241        match val {
1242            RegionOverlap::In => ffi::REGION_OVERLAP_IN,
1243            RegionOverlap::Out => ffi::REGION_OVERLAP_OUT,
1244            RegionOverlap::Part => ffi::REGION_OVERLAP_PART,
1245            RegionOverlap::__Unknown(value) => value,
1246        }
1247    }
1248}
1249
1250#[doc(hidden)]
1251impl From<ffi::cairo_region_overlap_t> for RegionOverlap {
1252    fn from(value: ffi::cairo_region_overlap_t) -> Self {
1253        match value {
1254            ffi::REGION_OVERLAP_IN => Self::In,
1255            ffi::REGION_OVERLAP_OUT => Self::Out,
1256            ffi::REGION_OVERLAP_PART => Self::Part,
1257            value => Self::__Unknown(value),
1258        }
1259    }
1260}
1261
1262#[cfg(feature = "use_glib")]
1263gvalue_impl!(
1264    RegionOverlap,
1265    ffi::gobject::cairo_gobject_region_overlap_get_type
1266);
1267
1268bitflags::bitflags! {
1269    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1270    pub struct PdfOutline: i32 {
1271        #[doc(alias = "PDF_OUTLINE_FLAG_OPEN")]
1272        const OPEN = ffi::PDF_OUTLINE_FLAG_OPEN;
1273        #[doc(alias = "PDF_OUTLINE_FLAG_BOLD")]
1274        const BOLD = ffi::PDF_OUTLINE_FLAG_BOLD;
1275        #[doc(alias = "PDF_OUTLINE_FLAG_ITALIC")]
1276        const ITALIC = ffi::PDF_OUTLINE_FLAG_ITALIC;
1277    }
1278}
1279
1280#[cfg(feature = "pdf")]
1281#[cfg_attr(docsrs, doc(cfg(feature = "pdf")))]
1282#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1283#[non_exhaustive]
1284#[doc(alias = "cairo_pdf_metadata_t")]
1285pub enum PdfMetadata {
1286    #[doc(alias = "PDF_METADATA_TITLE")]
1287    Title,
1288    #[doc(alias = "PDF_METADATA_AUTHOR")]
1289    Author,
1290    #[doc(alias = "PDF_METADATA_SUBJECT")]
1291    Subject,
1292    #[doc(alias = "PDF_METADATA_KEYWORDS")]
1293    Keywords,
1294    #[doc(alias = "PDF_METADATA_CREATOR")]
1295    Creator,
1296    #[doc(alias = "PDF_METADATA_CREATE_DATE")]
1297    CreateDate,
1298    #[doc(alias = "PDF_METADATA_MOD_DATE")]
1299    ModDate,
1300    #[doc(hidden)]
1301    __Unknown(i32),
1302}
1303
1304#[cfg(all(feature = "pdf", feature = "v1_16"))]
1305#[cfg_attr(docsrs, doc(cfg(all(feature = "pdf", feature = "v1_16"))))]
1306#[doc(hidden)]
1307impl From<PdfMetadata> for ffi::cairo_pdf_metadata_t {
1308    fn from(val: PdfMetadata) -> ffi::cairo_pdf_metadata_t {
1309        match val {
1310            PdfMetadata::Title => ffi::PDF_METADATA_TITLE,
1311            PdfMetadata::Author => ffi::PDF_METADATA_AUTHOR,
1312            PdfMetadata::Subject => ffi::PDF_METADATA_SUBJECT,
1313            PdfMetadata::Keywords => ffi::PDF_METADATA_KEYWORDS,
1314            PdfMetadata::Creator => ffi::PDF_METADATA_CREATOR,
1315            PdfMetadata::CreateDate => ffi::PDF_METADATA_CREATE_DATE,
1316            PdfMetadata::ModDate => ffi::PDF_METADATA_MOD_DATE,
1317            PdfMetadata::__Unknown(value) => value,
1318        }
1319    }
1320}
1321
1322#[cfg(all(feature = "pdf", feature = "v1_16"))]
1323#[cfg_attr(docsrs, doc(cfg(all(feature = "pdf", feature = "v1_16"))))]
1324#[doc(hidden)]
1325impl From<ffi::cairo_pdf_metadata_t> for PdfMetadata {
1326    fn from(value: ffi::cairo_pdf_metadata_t) -> Self {
1327        match value {
1328            ffi::PDF_METADATA_TITLE => Self::Title,
1329            ffi::PDF_METADATA_AUTHOR => Self::Author,
1330            ffi::PDF_METADATA_SUBJECT => Self::Subject,
1331            ffi::PDF_METADATA_KEYWORDS => Self::Keywords,
1332            ffi::PDF_METADATA_CREATOR => Self::Creator,
1333            ffi::PDF_METADATA_CREATE_DATE => Self::CreateDate,
1334            ffi::PDF_METADATA_MOD_DATE => Self::ModDate,
1335            value => Self::__Unknown(value),
1336        }
1337    }
1338}
1339
1340#[cfg(feature = "pdf")]
1341#[cfg_attr(docsrs, doc(cfg(feature = "pdf")))]
1342#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1343#[non_exhaustive]
1344#[doc(alias = "cairo_pdf_version_t")]
1345pub enum PdfVersion {
1346    #[doc(alias = "PDF_VERSION__1_4")]
1347    _1_4,
1348    #[doc(alias = "PDF_VERSION__1_5")]
1349    _1_5,
1350    #[cfg(feature = "v1_18")]
1351    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
1352    #[doc(alias = "PDF_VERSION__1_6")]
1353    _1_6,
1354    #[cfg(feature = "v1_18")]
1355    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
1356    #[doc(alias = "PDF_VERSION__1_7")]
1357    _1_7,
1358    #[doc(hidden)]
1359    __Unknown(i32),
1360}
1361
1362#[cfg(feature = "pdf")]
1363#[cfg_attr(docsrs, doc(cfg(feature = "pdf")))]
1364#[doc(hidden)]
1365impl From<PdfVersion> for ffi::cairo_pdf_version_t {
1366    fn from(val: PdfVersion) -> ffi::cairo_pdf_version_t {
1367        match val {
1368            PdfVersion::_1_4 => ffi::PDF_VERSION__1_4,
1369            PdfVersion::_1_5 => ffi::PDF_VERSION__1_5,
1370            #[cfg(feature = "v1_18")]
1371            PdfVersion::_1_6 => ffi::PDF_VERSION__1_6,
1372            #[cfg(feature = "v1_18")]
1373            PdfVersion::_1_7 => ffi::PDF_VERSION__1_7,
1374            PdfVersion::__Unknown(value) => value,
1375        }
1376    }
1377}
1378
1379#[cfg(feature = "pdf")]
1380#[cfg_attr(docsrs, doc(cfg(feature = "pdf")))]
1381#[doc(hidden)]
1382impl From<ffi::cairo_pdf_version_t> for PdfVersion {
1383    fn from(value: ffi::cairo_pdf_version_t) -> Self {
1384        match value {
1385            ffi::PDF_VERSION__1_4 => Self::_1_4,
1386            ffi::PDF_VERSION__1_5 => Self::_1_5,
1387            #[cfg(feature = "v1_18")]
1388            ffi::PDF_VERSION__1_6 => Self::_1_6,
1389            #[cfg(feature = "v1_18")]
1390            ffi::PDF_VERSION__1_7 => Self::_1_7,
1391            value => Self::__Unknown(value),
1392        }
1393    }
1394}
1395
1396#[cfg(feature = "svg")]
1397#[cfg_attr(docsrs, doc(cfg(feature = "svg")))]
1398#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1399#[non_exhaustive]
1400#[doc(alias = "cairo_svg_version_t")]
1401pub enum SvgVersion {
1402    #[doc(alias = "SVG_VERSION__1_1")]
1403    _1_1,
1404    #[doc(alias = "SVG_VERSION__1_2")]
1405    _1_2,
1406    #[doc(hidden)]
1407    __Unknown(i32),
1408}
1409
1410#[cfg(feature = "svg")]
1411#[cfg_attr(docsrs, doc(cfg(feature = "svg")))]
1412#[doc(hidden)]
1413impl From<SvgVersion> for ffi::cairo_svg_version_t {
1414    fn from(val: SvgVersion) -> ffi::cairo_svg_version_t {
1415        match val {
1416            SvgVersion::_1_1 => ffi::SVG_VERSION__1_1,
1417            SvgVersion::_1_2 => ffi::SVG_VERSION__1_2,
1418            SvgVersion::__Unknown(value) => value,
1419        }
1420    }
1421}
1422
1423#[cfg(feature = "svg")]
1424#[cfg_attr(docsrs, doc(cfg(feature = "svg")))]
1425#[doc(hidden)]
1426impl From<ffi::cairo_svg_version_t> for SvgVersion {
1427    fn from(value: ffi::cairo_svg_version_t) -> Self {
1428        match value {
1429            ffi::SVG_VERSION__1_1 => Self::_1_1,
1430            ffi::SVG_VERSION__1_2 => Self::_1_2,
1431            value => Self::__Unknown(value),
1432        }
1433    }
1434}
1435
1436#[cfg(feature = "ps")]
1437#[cfg_attr(docsrs, doc(cfg(feature = "ps")))]
1438#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1439#[non_exhaustive]
1440#[doc(alias = "cairo_ps_level_t")]
1441pub enum PsLevel {
1442    #[doc(alias = "PS_LEVEL__2")]
1443    _2,
1444    #[doc(alias = "PS_LEVEL__3")]
1445    _3,
1446    #[doc(hidden)]
1447    __Unknown(i32),
1448}
1449
1450#[cfg(feature = "ps")]
1451#[cfg_attr(docsrs, doc(cfg(feature = "ps")))]
1452#[doc(hidden)]
1453impl From<PsLevel> for ffi::cairo_ps_level_t {
1454    fn from(val: PsLevel) -> ffi::cairo_ps_level_t {
1455        match val {
1456            PsLevel::_2 => ffi::PS_LEVEL__2,
1457            PsLevel::_3 => ffi::PS_LEVEL__3,
1458            PsLevel::__Unknown(value) => value,
1459        }
1460    }
1461}
1462
1463#[cfg(feature = "ps")]
1464#[cfg_attr(docsrs, doc(cfg(feature = "ps")))]
1465#[doc(hidden)]
1466impl From<ffi::cairo_ps_level_t> for PsLevel {
1467    fn from(value: ffi::cairo_ps_level_t) -> Self {
1468        match value {
1469            ffi::PS_LEVEL__2 => Self::_2,
1470            ffi::PS_LEVEL__3 => Self::_3,
1471            value => Self::__Unknown(value),
1472        }
1473    }
1474}
1475
1476#[derive(Clone, PartialEq, Eq, PartialOrd, Copy, Debug)]
1477#[non_exhaustive]
1478#[doc(alias = "cairo_mesh_corner_t")]
1479pub enum MeshCorner {
1480    #[doc(alias = "MESH_CORNER_MESH_CORNER0")]
1481    MeshCorner0,
1482    #[doc(alias = "MESH_CORNER_MESH_CORNER1")]
1483    MeshCorner1,
1484    #[doc(alias = "MESH_CORNER_MESH_CORNER2")]
1485    MeshCorner2,
1486    #[doc(alias = "MESH_CORNER_MESH_CORNER3")]
1487    MeshCorner3,
1488    #[doc(hidden)]
1489    __Unknown(u32),
1490}
1491
1492#[doc(hidden)]
1493impl From<MeshCorner> for ffi::cairo_mesh_corner_t {
1494    fn from(val: MeshCorner) -> ffi::cairo_mesh_corner_t {
1495        match val {
1496            MeshCorner::MeshCorner0 => ffi::MESH_CORNER_MESH_CORNER0,
1497            MeshCorner::MeshCorner1 => ffi::MESH_CORNER_MESH_CORNER1,
1498            MeshCorner::MeshCorner2 => ffi::MESH_CORNER_MESH_CORNER2,
1499            MeshCorner::MeshCorner3 => ffi::MESH_CORNER_MESH_CORNER3,
1500            MeshCorner::__Unknown(value) => value,
1501        }
1502    }
1503}
1504
1505#[doc(hidden)]
1506impl From<ffi::cairo_mesh_corner_t> for MeshCorner {
1507    fn from(value: ffi::cairo_mesh_corner_t) -> Self {
1508        match value {
1509            ffi::MESH_CORNER_MESH_CORNER0 => Self::MeshCorner0,
1510            ffi::MESH_CORNER_MESH_CORNER1 => Self::MeshCorner1,
1511            ffi::MESH_CORNER_MESH_CORNER2 => Self::MeshCorner2,
1512            ffi::MESH_CORNER_MESH_CORNER3 => Self::MeshCorner3,
1513            value => Self::__Unknown(value),
1514        }
1515    }
1516}
1517
1518#[cfg(feature = "freetype")]
1519#[cfg_attr(docsrs, doc(cfg(feature = "freetype")))]
1520#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Copy)]
1521#[non_exhaustive]
1522#[doc(alias = "cairo_ft_synthesize_t")]
1523pub enum FtSynthesize {
1524    #[doc(alias = "CAIRO_FT_SYNTHESIZE_BOLD")]
1525    Bold,
1526    #[doc(alias = "CAIRO_FT_SYNTHESIZE_OBLIQUE")]
1527    Oblique,
1528    #[doc(hidden)]
1529    __Unknown(u32),
1530}
1531
1532#[cfg(feature = "freetype")]
1533#[cfg_attr(docsrs, doc(cfg(feature = "freetype")))]
1534#[doc(hidden)]
1535impl From<FtSynthesize> for ffi::cairo_ft_synthesize_t {
1536    fn from(val: FtSynthesize) -> ffi::cairo_ft_synthesize_t {
1537        match val {
1538            FtSynthesize::Bold => ffi::CAIRO_FT_SYNTHESIZE_BOLD,
1539            FtSynthesize::Oblique => ffi::CAIRO_FT_SYNTHESIZE_OBLIQUE,
1540            FtSynthesize::__Unknown(value) => value,
1541        }
1542    }
1543}
1544
1545#[cfg(feature = "freetype")]
1546#[cfg_attr(docsrs, doc(cfg(feature = "freetype")))]
1547#[doc(hidden)]
1548impl From<ffi::cairo_ft_synthesize_t> for FtSynthesize {
1549    fn from(value: ffi::cairo_ft_synthesize_t) -> Self {
1550        match value {
1551            ffi::CAIRO_FT_SYNTHESIZE_BOLD => Self::Bold,
1552            ffi::CAIRO_FT_SYNTHESIZE_OBLIQUE => Self::Oblique,
1553            value => Self::__Unknown(value),
1554        }
1555    }
1556}
1557
1558#[cfg(feature = "script")]
1559#[cfg_attr(docsrs, doc(cfg(feature = "script")))]
1560#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Copy)]
1561#[non_exhaustive]
1562#[doc(alias = "cairo_script_mode_t")]
1563pub enum ScriptMode {
1564    #[doc(alias = "CAIRO_SCRIPT_MODE_ASCII")]
1565    Ascii,
1566    #[doc(alias = "CAIRO_SCRIPT_MODE_BINARY")]
1567    Binary,
1568    #[doc(hidden)]
1569    __Unknown(i32),
1570}
1571
1572#[cfg(feature = "script")]
1573#[cfg_attr(docsrs, doc(cfg(feature = "script")))]
1574#[doc(hidden)]
1575impl From<ScriptMode> for ffi::cairo_script_mode_t {
1576    fn from(val: ScriptMode) -> ffi::cairo_script_mode_t {
1577        match val {
1578            ScriptMode::Ascii => ffi::CAIRO_SCRIPT_MODE_ASCII,
1579            ScriptMode::Binary => ffi::CAIRO_SCRIPT_MODE_BINARY,
1580            ScriptMode::__Unknown(value) => value,
1581        }
1582    }
1583}
1584
1585#[cfg(feature = "script")]
1586#[cfg_attr(docsrs, doc(cfg(feature = "script")))]
1587#[doc(hidden)]
1588impl From<ffi::cairo_script_mode_t> for ScriptMode {
1589    fn from(value: ffi::cairo_script_mode_t) -> Self {
1590        match value {
1591            ffi::CAIRO_SCRIPT_MODE_ASCII => Self::Ascii,
1592            ffi::CAIRO_SCRIPT_MODE_BINARY => Self::Binary,
1593            value => Self::__Unknown(value),
1594        }
1595    }
1596}
1597
1598#[derive(Clone, PartialEq, Eq, PartialOrd, Debug, Copy)]
1599#[non_exhaustive]
1600#[doc(alias = "cairo_device_type_t")]
1601pub enum DeviceType {
1602    #[doc(alias = "CAIRO_DEVICE_TYPE_DRM")]
1603    Ascii,
1604    #[doc(alias = "CAIRO_DEVICE_TYPE_GL")]
1605    Binary,
1606    #[doc(alias = "CAIRO_DEVICE_TYPE_SCRIPT")]
1607    Script,
1608    #[doc(alias = "CAIRO_DEVICE_TYPE_XCB")]
1609    Xcb,
1610    #[doc(alias = "CAIRO_DEVICE_TYPE_XLIB")]
1611    Xlib,
1612    #[doc(alias = "CAIRO_DEVICE_TYPE_XML")]
1613    Xml,
1614    #[doc(alias = "CAIRO_DEVICE_TYPE_COGL")]
1615    Cogl,
1616    #[doc(alias = "CAIRO_DEVICE_TYPE_WIN32")]
1617    Win32,
1618    #[doc(alias = "CAIRO_DEVICE_TYPE_INVALID")]
1619    Invalid,
1620    #[doc(hidden)]
1621    __Unknown(i32),
1622}
1623
1624#[doc(hidden)]
1625impl From<DeviceType> for ffi::cairo_device_type_t {
1626    fn from(val: DeviceType) -> ffi::cairo_device_type_t {
1627        match val {
1628            DeviceType::Ascii => ffi::CAIRO_DEVICE_TYPE_DRM,
1629            DeviceType::Binary => ffi::CAIRO_DEVICE_TYPE_GL,
1630            DeviceType::Script => ffi::CAIRO_DEVICE_TYPE_SCRIPT,
1631            DeviceType::Xcb => ffi::CAIRO_DEVICE_TYPE_XCB,
1632            DeviceType::Xlib => ffi::CAIRO_DEVICE_TYPE_XLIB,
1633            DeviceType::Xml => ffi::CAIRO_DEVICE_TYPE_XML,
1634            DeviceType::Cogl => ffi::CAIRO_DEVICE_TYPE_COGL,
1635            DeviceType::Win32 => ffi::CAIRO_DEVICE_TYPE_WIN32,
1636            DeviceType::Invalid => ffi::CAIRO_DEVICE_TYPE_INVALID,
1637            DeviceType::__Unknown(value) => value,
1638        }
1639    }
1640}
1641
1642#[doc(hidden)]
1643impl From<ffi::cairo_device_type_t> for DeviceType {
1644    fn from(value: ffi::cairo_device_type_t) -> Self {
1645        match value {
1646            ffi::CAIRO_DEVICE_TYPE_DRM => Self::Ascii,
1647            ffi::CAIRO_DEVICE_TYPE_GL => Self::Binary,
1648            ffi::CAIRO_DEVICE_TYPE_SCRIPT => Self::Script,
1649            ffi::CAIRO_DEVICE_TYPE_XCB => Self::Xcb,
1650            ffi::CAIRO_DEVICE_TYPE_XLIB => Self::Xlib,
1651            ffi::CAIRO_DEVICE_TYPE_XML => Self::Xml,
1652            ffi::CAIRO_DEVICE_TYPE_COGL => Self::Cogl,
1653            ffi::CAIRO_DEVICE_TYPE_WIN32 => Self::Win32,
1654            ffi::CAIRO_DEVICE_TYPE_INVALID => Self::Invalid,
1655            value => Self::__Unknown(value),
1656        }
1657    }
1658}
1659
1660#[cfg(feature = "use_glib")]
1661gvalue_impl!(DeviceType, ffi::gobject::cairo_gobject_device_type_get_type);
1662
1663#[cfg(test)]
1664mod tests {
1665    use super::*;
1666
1667    #[test]
1668    #[should_panic]
1669    fn stride_panics_on_bad_value() {
1670        let _ = Format::Rgb24.stride_for_width(u32::MAX);
1671    }
1672
1673    #[test]
1674    fn stride_errors_on_large_width() {
1675        assert!(Format::Rgb24.stride_for_width(i32::MAX as u32).is_err());
1676    }
1677
1678    #[test]
1679    fn stride_works() {
1680        assert_eq!(Format::Rgb24.stride_for_width(1).unwrap(), 4);
1681    }
1682}