gdk_pixbuf/auto/
enums.rs

1// This file was generated by gir (https://github.com/gtk-rs/gir)
2// from gir-files (https://github.com/gtk-rs/gir-files)
3// DO NOT EDIT
4
5use gdk_pixbuf_sys;
6use glib::error::ErrorDomain;
7use glib::translate::*;
8use glib::value::FromValue;
9use glib::value::FromValueOptional;
10use glib::value::SetValue;
11use glib::value::Value;
12use glib::Quark;
13use glib::StaticType;
14use glib::Type;
15use gobject_sys;
16use std::fmt;
17
18#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
19pub enum Colorspace {
20    Rgb,
21    #[doc(hidden)]
22    __Unknown(i32),
23}
24
25impl fmt::Display for Colorspace {
26    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
27        write!(
28            f,
29            "Colorspace::{}",
30            match *self {
31                Colorspace::Rgb => "Rgb",
32                _ => "Unknown",
33            }
34        )
35    }
36}
37
38#[doc(hidden)]
39impl ToGlib for Colorspace {
40    type GlibType = gdk_pixbuf_sys::GdkColorspace;
41
42    fn to_glib(&self) -> gdk_pixbuf_sys::GdkColorspace {
43        match *self {
44            Colorspace::Rgb => gdk_pixbuf_sys::GDK_COLORSPACE_RGB,
45            Colorspace::__Unknown(value) => value,
46        }
47    }
48}
49
50#[doc(hidden)]
51impl FromGlib<gdk_pixbuf_sys::GdkColorspace> for Colorspace {
52    fn from_glib(value: gdk_pixbuf_sys::GdkColorspace) -> Self {
53        match value {
54            0 => Colorspace::Rgb,
55            value => Colorspace::__Unknown(value),
56        }
57    }
58}
59
60impl StaticType for Colorspace {
61    fn static_type() -> Type {
62        unsafe { from_glib(gdk_pixbuf_sys::gdk_colorspace_get_type()) }
63    }
64}
65
66impl<'a> FromValueOptional<'a> for Colorspace {
67    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
68        Some(FromValue::from_value(value))
69    }
70}
71
72impl<'a> FromValue<'a> for Colorspace {
73    unsafe fn from_value(value: &Value) -> Self {
74        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
75    }
76}
77
78impl SetValue for Colorspace {
79    unsafe fn set_value(value: &mut Value, this: &Self) {
80        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
81    }
82}
83
84#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
85pub enum InterpType {
86    Nearest,
87    Tiles,
88    Bilinear,
89    Hyper,
90    #[doc(hidden)]
91    __Unknown(i32),
92}
93
94impl fmt::Display for InterpType {
95    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
96        write!(
97            f,
98            "InterpType::{}",
99            match *self {
100                InterpType::Nearest => "Nearest",
101                InterpType::Tiles => "Tiles",
102                InterpType::Bilinear => "Bilinear",
103                InterpType::Hyper => "Hyper",
104                _ => "Unknown",
105            }
106        )
107    }
108}
109
110#[doc(hidden)]
111impl ToGlib for InterpType {
112    type GlibType = gdk_pixbuf_sys::GdkInterpType;
113
114    fn to_glib(&self) -> gdk_pixbuf_sys::GdkInterpType {
115        match *self {
116            InterpType::Nearest => gdk_pixbuf_sys::GDK_INTERP_NEAREST,
117            InterpType::Tiles => gdk_pixbuf_sys::GDK_INTERP_TILES,
118            InterpType::Bilinear => gdk_pixbuf_sys::GDK_INTERP_BILINEAR,
119            InterpType::Hyper => gdk_pixbuf_sys::GDK_INTERP_HYPER,
120            InterpType::__Unknown(value) => value,
121        }
122    }
123}
124
125#[doc(hidden)]
126impl FromGlib<gdk_pixbuf_sys::GdkInterpType> for InterpType {
127    fn from_glib(value: gdk_pixbuf_sys::GdkInterpType) -> Self {
128        match value {
129            0 => InterpType::Nearest,
130            1 => InterpType::Tiles,
131            2 => InterpType::Bilinear,
132            3 => InterpType::Hyper,
133            value => InterpType::__Unknown(value),
134        }
135    }
136}
137
138impl StaticType for InterpType {
139    fn static_type() -> Type {
140        unsafe { from_glib(gdk_pixbuf_sys::gdk_interp_type_get_type()) }
141    }
142}
143
144impl<'a> FromValueOptional<'a> for InterpType {
145    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
146        Some(FromValue::from_value(value))
147    }
148}
149
150impl<'a> FromValue<'a> for InterpType {
151    unsafe fn from_value(value: &Value) -> Self {
152        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
153    }
154}
155
156impl SetValue for InterpType {
157    unsafe fn set_value(value: &mut Value, this: &Self) {
158        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
159    }
160}
161
162#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
163pub enum PixbufAlphaMode {
164    Bilevel,
165    Full,
166    #[doc(hidden)]
167    __Unknown(i32),
168}
169
170impl fmt::Display for PixbufAlphaMode {
171    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
172        write!(
173            f,
174            "PixbufAlphaMode::{}",
175            match *self {
176                PixbufAlphaMode::Bilevel => "Bilevel",
177                PixbufAlphaMode::Full => "Full",
178                _ => "Unknown",
179            }
180        )
181    }
182}
183
184#[doc(hidden)]
185impl ToGlib for PixbufAlphaMode {
186    type GlibType = gdk_pixbuf_sys::GdkPixbufAlphaMode;
187
188    fn to_glib(&self) -> gdk_pixbuf_sys::GdkPixbufAlphaMode {
189        match *self {
190            PixbufAlphaMode::Bilevel => gdk_pixbuf_sys::GDK_PIXBUF_ALPHA_BILEVEL,
191            PixbufAlphaMode::Full => gdk_pixbuf_sys::GDK_PIXBUF_ALPHA_FULL,
192            PixbufAlphaMode::__Unknown(value) => value,
193        }
194    }
195}
196
197#[doc(hidden)]
198impl FromGlib<gdk_pixbuf_sys::GdkPixbufAlphaMode> for PixbufAlphaMode {
199    fn from_glib(value: gdk_pixbuf_sys::GdkPixbufAlphaMode) -> Self {
200        match value {
201            0 => PixbufAlphaMode::Bilevel,
202            1 => PixbufAlphaMode::Full,
203            value => PixbufAlphaMode::__Unknown(value),
204        }
205    }
206}
207
208impl StaticType for PixbufAlphaMode {
209    fn static_type() -> Type {
210        unsafe { from_glib(gdk_pixbuf_sys::gdk_pixbuf_alpha_mode_get_type()) }
211    }
212}
213
214impl<'a> FromValueOptional<'a> for PixbufAlphaMode {
215    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
216        Some(FromValue::from_value(value))
217    }
218}
219
220impl<'a> FromValue<'a> for PixbufAlphaMode {
221    unsafe fn from_value(value: &Value) -> Self {
222        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
223    }
224}
225
226impl SetValue for PixbufAlphaMode {
227    unsafe fn set_value(value: &mut Value, this: &Self) {
228        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
229    }
230}
231
232#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
233pub enum PixbufError {
234    CorruptImage,
235    InsufficientMemory,
236    BadOption,
237    UnknownType,
238    UnsupportedOperation,
239    Failed,
240    IncompleteAnimation,
241    #[doc(hidden)]
242    __Unknown(i32),
243}
244
245impl fmt::Display for PixbufError {
246    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
247        write!(
248            f,
249            "PixbufError::{}",
250            match *self {
251                PixbufError::CorruptImage => "CorruptImage",
252                PixbufError::InsufficientMemory => "InsufficientMemory",
253                PixbufError::BadOption => "BadOption",
254                PixbufError::UnknownType => "UnknownType",
255                PixbufError::UnsupportedOperation => "UnsupportedOperation",
256                PixbufError::Failed => "Failed",
257                PixbufError::IncompleteAnimation => "IncompleteAnimation",
258                _ => "Unknown",
259            }
260        )
261    }
262}
263
264#[doc(hidden)]
265impl ToGlib for PixbufError {
266    type GlibType = gdk_pixbuf_sys::GdkPixbufError;
267
268    fn to_glib(&self) -> gdk_pixbuf_sys::GdkPixbufError {
269        match *self {
270            PixbufError::CorruptImage => gdk_pixbuf_sys::GDK_PIXBUF_ERROR_CORRUPT_IMAGE,
271            PixbufError::InsufficientMemory => gdk_pixbuf_sys::GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,
272            PixbufError::BadOption => gdk_pixbuf_sys::GDK_PIXBUF_ERROR_BAD_OPTION,
273            PixbufError::UnknownType => gdk_pixbuf_sys::GDK_PIXBUF_ERROR_UNKNOWN_TYPE,
274            PixbufError::UnsupportedOperation => {
275                gdk_pixbuf_sys::GDK_PIXBUF_ERROR_UNSUPPORTED_OPERATION
276            }
277            PixbufError::Failed => gdk_pixbuf_sys::GDK_PIXBUF_ERROR_FAILED,
278            PixbufError::IncompleteAnimation => {
279                gdk_pixbuf_sys::GDK_PIXBUF_ERROR_INCOMPLETE_ANIMATION
280            }
281            PixbufError::__Unknown(value) => value,
282        }
283    }
284}
285
286#[doc(hidden)]
287impl FromGlib<gdk_pixbuf_sys::GdkPixbufError> for PixbufError {
288    fn from_glib(value: gdk_pixbuf_sys::GdkPixbufError) -> Self {
289        match value {
290            0 => PixbufError::CorruptImage,
291            1 => PixbufError::InsufficientMemory,
292            2 => PixbufError::BadOption,
293            3 => PixbufError::UnknownType,
294            4 => PixbufError::UnsupportedOperation,
295            5 => PixbufError::Failed,
296            6 => PixbufError::IncompleteAnimation,
297            value => PixbufError::__Unknown(value),
298        }
299    }
300}
301
302impl ErrorDomain for PixbufError {
303    fn domain() -> Quark {
304        unsafe { from_glib(gdk_pixbuf_sys::gdk_pixbuf_error_quark()) }
305    }
306
307    fn code(self) -> i32 {
308        self.to_glib()
309    }
310
311    fn from(code: i32) -> Option<Self> {
312        match code {
313            0 => Some(PixbufError::CorruptImage),
314            1 => Some(PixbufError::InsufficientMemory),
315            2 => Some(PixbufError::BadOption),
316            3 => Some(PixbufError::UnknownType),
317            4 => Some(PixbufError::UnsupportedOperation),
318            5 => Some(PixbufError::Failed),
319            6 => Some(PixbufError::IncompleteAnimation),
320            _ => Some(PixbufError::Failed),
321        }
322    }
323}
324
325impl StaticType for PixbufError {
326    fn static_type() -> Type {
327        unsafe { from_glib(gdk_pixbuf_sys::gdk_pixbuf_error_get_type()) }
328    }
329}
330
331impl<'a> FromValueOptional<'a> for PixbufError {
332    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
333        Some(FromValue::from_value(value))
334    }
335}
336
337impl<'a> FromValue<'a> for PixbufError {
338    unsafe fn from_value(value: &Value) -> Self {
339        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
340    }
341}
342
343impl SetValue for PixbufError {
344    unsafe fn set_value(value: &mut Value, this: &Self) {
345        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
346    }
347}
348
349#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
350pub enum PixbufRotation {
351    None,
352    Counterclockwise,
353    Upsidedown,
354    Clockwise,
355    #[doc(hidden)]
356    __Unknown(i32),
357}
358
359impl fmt::Display for PixbufRotation {
360    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
361        write!(
362            f,
363            "PixbufRotation::{}",
364            match *self {
365                PixbufRotation::None => "None",
366                PixbufRotation::Counterclockwise => "Counterclockwise",
367                PixbufRotation::Upsidedown => "Upsidedown",
368                PixbufRotation::Clockwise => "Clockwise",
369                _ => "Unknown",
370            }
371        )
372    }
373}
374
375#[doc(hidden)]
376impl ToGlib for PixbufRotation {
377    type GlibType = gdk_pixbuf_sys::GdkPixbufRotation;
378
379    fn to_glib(&self) -> gdk_pixbuf_sys::GdkPixbufRotation {
380        match *self {
381            PixbufRotation::None => gdk_pixbuf_sys::GDK_PIXBUF_ROTATE_NONE,
382            PixbufRotation::Counterclockwise => gdk_pixbuf_sys::GDK_PIXBUF_ROTATE_COUNTERCLOCKWISE,
383            PixbufRotation::Upsidedown => gdk_pixbuf_sys::GDK_PIXBUF_ROTATE_UPSIDEDOWN,
384            PixbufRotation::Clockwise => gdk_pixbuf_sys::GDK_PIXBUF_ROTATE_CLOCKWISE,
385            PixbufRotation::__Unknown(value) => value,
386        }
387    }
388}
389
390#[doc(hidden)]
391impl FromGlib<gdk_pixbuf_sys::GdkPixbufRotation> for PixbufRotation {
392    fn from_glib(value: gdk_pixbuf_sys::GdkPixbufRotation) -> Self {
393        match value {
394            0 => PixbufRotation::None,
395            90 => PixbufRotation::Counterclockwise,
396            180 => PixbufRotation::Upsidedown,
397            270 => PixbufRotation::Clockwise,
398            value => PixbufRotation::__Unknown(value),
399        }
400    }
401}
402
403impl StaticType for PixbufRotation {
404    fn static_type() -> Type {
405        unsafe { from_glib(gdk_pixbuf_sys::gdk_pixbuf_rotation_get_type()) }
406    }
407}
408
409impl<'a> FromValueOptional<'a> for PixbufRotation {
410    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
411        Some(FromValue::from_value(value))
412    }
413}
414
415impl<'a> FromValue<'a> for PixbufRotation {
416    unsafe fn from_value(value: &Value) -> Self {
417        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
418    }
419}
420
421impl SetValue for PixbufRotation {
422    unsafe fn set_value(value: &mut Value, this: &Self) {
423        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
424    }
425}