1use 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#[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 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 None,
288 Gray,
289 Subpixel,
290
291 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}