cairo/
enums.rs

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