1use 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}