glib/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 error::ErrorDomain;
6use glib_sys;
7use std::fmt;
8use translate::*;
9use Quark;
10
11#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
12pub enum ChecksumType {
13    Md5,
14    Sha1,
15    Sha256,
16    Sha512,
17    #[cfg(any(feature = "v2_52", feature = "dox"))]
18    Sha384,
19    #[doc(hidden)]
20    __Unknown(i32),
21}
22
23impl fmt::Display for ChecksumType {
24    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
25        write!(
26            f,
27            "ChecksumType::{}",
28            match *self {
29                ChecksumType::Md5 => "Md5",
30                ChecksumType::Sha1 => "Sha1",
31                ChecksumType::Sha256 => "Sha256",
32                ChecksumType::Sha512 => "Sha512",
33                #[cfg(any(feature = "v2_52", feature = "dox"))]
34                ChecksumType::Sha384 => "Sha384",
35                _ => "Unknown",
36            }
37        )
38    }
39}
40
41#[doc(hidden)]
42impl ToGlib for ChecksumType {
43    type GlibType = glib_sys::GChecksumType;
44
45    fn to_glib(&self) -> glib_sys::GChecksumType {
46        match *self {
47            ChecksumType::Md5 => glib_sys::G_CHECKSUM_MD5,
48            ChecksumType::Sha1 => glib_sys::G_CHECKSUM_SHA1,
49            ChecksumType::Sha256 => glib_sys::G_CHECKSUM_SHA256,
50            ChecksumType::Sha512 => glib_sys::G_CHECKSUM_SHA512,
51            #[cfg(any(feature = "v2_52", feature = "dox"))]
52            ChecksumType::Sha384 => glib_sys::G_CHECKSUM_SHA384,
53            ChecksumType::__Unknown(value) => value,
54        }
55    }
56}
57
58#[doc(hidden)]
59impl FromGlib<glib_sys::GChecksumType> for ChecksumType {
60    fn from_glib(value: glib_sys::GChecksumType) -> Self {
61        match value {
62            0 => ChecksumType::Md5,
63            1 => ChecksumType::Sha1,
64            2 => ChecksumType::Sha256,
65            3 => ChecksumType::Sha512,
66            #[cfg(any(feature = "v2_52", feature = "dox"))]
67            4 => ChecksumType::Sha384,
68            value => ChecksumType::__Unknown(value),
69        }
70    }
71}
72
73#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
74pub enum DateMonth {
75    BadMonth,
76    January,
77    February,
78    March,
79    April,
80    May,
81    June,
82    July,
83    August,
84    September,
85    October,
86    November,
87    December,
88    #[doc(hidden)]
89    __Unknown(i32),
90}
91
92impl fmt::Display for DateMonth {
93    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
94        write!(
95            f,
96            "DateMonth::{}",
97            match *self {
98                DateMonth::BadMonth => "BadMonth",
99                DateMonth::January => "January",
100                DateMonth::February => "February",
101                DateMonth::March => "March",
102                DateMonth::April => "April",
103                DateMonth::May => "May",
104                DateMonth::June => "June",
105                DateMonth::July => "July",
106                DateMonth::August => "August",
107                DateMonth::September => "September",
108                DateMonth::October => "October",
109                DateMonth::November => "November",
110                DateMonth::December => "December",
111                _ => "Unknown",
112            }
113        )
114    }
115}
116
117#[doc(hidden)]
118impl ToGlib for DateMonth {
119    type GlibType = glib_sys::GDateMonth;
120
121    fn to_glib(&self) -> glib_sys::GDateMonth {
122        match *self {
123            DateMonth::BadMonth => glib_sys::G_DATE_BAD_MONTH,
124            DateMonth::January => glib_sys::G_DATE_JANUARY,
125            DateMonth::February => glib_sys::G_DATE_FEBRUARY,
126            DateMonth::March => glib_sys::G_DATE_MARCH,
127            DateMonth::April => glib_sys::G_DATE_APRIL,
128            DateMonth::May => glib_sys::G_DATE_MAY,
129            DateMonth::June => glib_sys::G_DATE_JUNE,
130            DateMonth::July => glib_sys::G_DATE_JULY,
131            DateMonth::August => glib_sys::G_DATE_AUGUST,
132            DateMonth::September => glib_sys::G_DATE_SEPTEMBER,
133            DateMonth::October => glib_sys::G_DATE_OCTOBER,
134            DateMonth::November => glib_sys::G_DATE_NOVEMBER,
135            DateMonth::December => glib_sys::G_DATE_DECEMBER,
136            DateMonth::__Unknown(value) => value,
137        }
138    }
139}
140
141#[doc(hidden)]
142impl FromGlib<glib_sys::GDateMonth> for DateMonth {
143    fn from_glib(value: glib_sys::GDateMonth) -> Self {
144        match value {
145            0 => DateMonth::BadMonth,
146            1 => DateMonth::January,
147            2 => DateMonth::February,
148            3 => DateMonth::March,
149            4 => DateMonth::April,
150            5 => DateMonth::May,
151            6 => DateMonth::June,
152            7 => DateMonth::July,
153            8 => DateMonth::August,
154            9 => DateMonth::September,
155            10 => DateMonth::October,
156            11 => DateMonth::November,
157            12 => DateMonth::December,
158            value => DateMonth::__Unknown(value),
159        }
160    }
161}
162
163#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
164pub enum DateWeekday {
165    BadWeekday,
166    Monday,
167    Tuesday,
168    Wednesday,
169    Thursday,
170    Friday,
171    Saturday,
172    Sunday,
173    #[doc(hidden)]
174    __Unknown(i32),
175}
176
177impl fmt::Display for DateWeekday {
178    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
179        write!(
180            f,
181            "DateWeekday::{}",
182            match *self {
183                DateWeekday::BadWeekday => "BadWeekday",
184                DateWeekday::Monday => "Monday",
185                DateWeekday::Tuesday => "Tuesday",
186                DateWeekday::Wednesday => "Wednesday",
187                DateWeekday::Thursday => "Thursday",
188                DateWeekday::Friday => "Friday",
189                DateWeekday::Saturday => "Saturday",
190                DateWeekday::Sunday => "Sunday",
191                _ => "Unknown",
192            }
193        )
194    }
195}
196
197#[doc(hidden)]
198impl ToGlib for DateWeekday {
199    type GlibType = glib_sys::GDateWeekday;
200
201    fn to_glib(&self) -> glib_sys::GDateWeekday {
202        match *self {
203            DateWeekday::BadWeekday => glib_sys::G_DATE_BAD_WEEKDAY,
204            DateWeekday::Monday => glib_sys::G_DATE_MONDAY,
205            DateWeekday::Tuesday => glib_sys::G_DATE_TUESDAY,
206            DateWeekday::Wednesday => glib_sys::G_DATE_WEDNESDAY,
207            DateWeekday::Thursday => glib_sys::G_DATE_THURSDAY,
208            DateWeekday::Friday => glib_sys::G_DATE_FRIDAY,
209            DateWeekday::Saturday => glib_sys::G_DATE_SATURDAY,
210            DateWeekday::Sunday => glib_sys::G_DATE_SUNDAY,
211            DateWeekday::__Unknown(value) => value,
212        }
213    }
214}
215
216#[doc(hidden)]
217impl FromGlib<glib_sys::GDateWeekday> for DateWeekday {
218    fn from_glib(value: glib_sys::GDateWeekday) -> Self {
219        match value {
220            0 => DateWeekday::BadWeekday,
221            1 => DateWeekday::Monday,
222            2 => DateWeekday::Tuesday,
223            3 => DateWeekday::Wednesday,
224            4 => DateWeekday::Thursday,
225            5 => DateWeekday::Friday,
226            6 => DateWeekday::Saturday,
227            7 => DateWeekday::Sunday,
228            value => DateWeekday::__Unknown(value),
229        }
230    }
231}
232
233#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
234pub enum KeyFileError {
235    UnknownEncoding,
236    Parse,
237    NotFound,
238    KeyNotFound,
239    GroupNotFound,
240    InvalidValue,
241    #[doc(hidden)]
242    __Unknown(i32),
243}
244
245impl fmt::Display for KeyFileError {
246    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
247        write!(
248            f,
249            "KeyFileError::{}",
250            match *self {
251                KeyFileError::UnknownEncoding => "UnknownEncoding",
252                KeyFileError::Parse => "Parse",
253                KeyFileError::NotFound => "NotFound",
254                KeyFileError::KeyNotFound => "KeyNotFound",
255                KeyFileError::GroupNotFound => "GroupNotFound",
256                KeyFileError::InvalidValue => "InvalidValue",
257                _ => "Unknown",
258            }
259        )
260    }
261}
262
263#[doc(hidden)]
264impl ToGlib for KeyFileError {
265    type GlibType = glib_sys::GKeyFileError;
266
267    fn to_glib(&self) -> glib_sys::GKeyFileError {
268        match *self {
269            KeyFileError::UnknownEncoding => glib_sys::G_KEY_FILE_ERROR_UNKNOWN_ENCODING,
270            KeyFileError::Parse => glib_sys::G_KEY_FILE_ERROR_PARSE,
271            KeyFileError::NotFound => glib_sys::G_KEY_FILE_ERROR_NOT_FOUND,
272            KeyFileError::KeyNotFound => glib_sys::G_KEY_FILE_ERROR_KEY_NOT_FOUND,
273            KeyFileError::GroupNotFound => glib_sys::G_KEY_FILE_ERROR_GROUP_NOT_FOUND,
274            KeyFileError::InvalidValue => glib_sys::G_KEY_FILE_ERROR_INVALID_VALUE,
275            KeyFileError::__Unknown(value) => value,
276        }
277    }
278}
279
280#[doc(hidden)]
281impl FromGlib<glib_sys::GKeyFileError> for KeyFileError {
282    fn from_glib(value: glib_sys::GKeyFileError) -> Self {
283        match value {
284            0 => KeyFileError::UnknownEncoding,
285            1 => KeyFileError::Parse,
286            2 => KeyFileError::NotFound,
287            3 => KeyFileError::KeyNotFound,
288            4 => KeyFileError::GroupNotFound,
289            5 => KeyFileError::InvalidValue,
290            value => KeyFileError::__Unknown(value),
291        }
292    }
293}
294
295impl ErrorDomain for KeyFileError {
296    fn domain() -> Quark {
297        unsafe { from_glib(glib_sys::g_key_file_error_quark()) }
298    }
299
300    fn code(self) -> i32 {
301        self.to_glib()
302    }
303
304    fn from(code: i32) -> Option<Self> {
305        match code {
306            0 => Some(KeyFileError::UnknownEncoding),
307            1 => Some(KeyFileError::Parse),
308            2 => Some(KeyFileError::NotFound),
309            3 => Some(KeyFileError::KeyNotFound),
310            4 => Some(KeyFileError::GroupNotFound),
311            5 => Some(KeyFileError::InvalidValue),
312            value => Some(KeyFileError::__Unknown(value)),
313        }
314    }
315}
316
317#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
318pub enum OptionArg {
319    None,
320    String,
321    Int,
322    Callback,
323    Filename,
324    StringArray,
325    FilenameArray,
326    Double,
327    Int64,
328    #[doc(hidden)]
329    __Unknown(i32),
330}
331
332impl fmt::Display for OptionArg {
333    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
334        write!(
335            f,
336            "OptionArg::{}",
337            match *self {
338                OptionArg::None => "None",
339                OptionArg::String => "String",
340                OptionArg::Int => "Int",
341                OptionArg::Callback => "Callback",
342                OptionArg::Filename => "Filename",
343                OptionArg::StringArray => "StringArray",
344                OptionArg::FilenameArray => "FilenameArray",
345                OptionArg::Double => "Double",
346                OptionArg::Int64 => "Int64",
347                _ => "Unknown",
348            }
349        )
350    }
351}
352
353#[doc(hidden)]
354impl ToGlib for OptionArg {
355    type GlibType = glib_sys::GOptionArg;
356
357    fn to_glib(&self) -> glib_sys::GOptionArg {
358        match *self {
359            OptionArg::None => glib_sys::G_OPTION_ARG_NONE,
360            OptionArg::String => glib_sys::G_OPTION_ARG_STRING,
361            OptionArg::Int => glib_sys::G_OPTION_ARG_INT,
362            OptionArg::Callback => glib_sys::G_OPTION_ARG_CALLBACK,
363            OptionArg::Filename => glib_sys::G_OPTION_ARG_FILENAME,
364            OptionArg::StringArray => glib_sys::G_OPTION_ARG_STRING_ARRAY,
365            OptionArg::FilenameArray => glib_sys::G_OPTION_ARG_FILENAME_ARRAY,
366            OptionArg::Double => glib_sys::G_OPTION_ARG_DOUBLE,
367            OptionArg::Int64 => glib_sys::G_OPTION_ARG_INT64,
368            OptionArg::__Unknown(value) => value,
369        }
370    }
371}
372
373#[doc(hidden)]
374impl FromGlib<glib_sys::GOptionArg> for OptionArg {
375    fn from_glib(value: glib_sys::GOptionArg) -> Self {
376        match value {
377            0 => OptionArg::None,
378            1 => OptionArg::String,
379            2 => OptionArg::Int,
380            3 => OptionArg::Callback,
381            4 => OptionArg::Filename,
382            5 => OptionArg::StringArray,
383            6 => OptionArg::FilenameArray,
384            7 => OptionArg::Double,
385            8 => OptionArg::Int64,
386            value => OptionArg::__Unknown(value),
387        }
388    }
389}
390
391#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
392pub enum SeekType {
393    Cur,
394    Set,
395    End,
396    #[doc(hidden)]
397    __Unknown(i32),
398}
399
400impl fmt::Display for SeekType {
401    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
402        write!(
403            f,
404            "SeekType::{}",
405            match *self {
406                SeekType::Cur => "Cur",
407                SeekType::Set => "Set",
408                SeekType::End => "End",
409                _ => "Unknown",
410            }
411        )
412    }
413}
414
415#[doc(hidden)]
416impl ToGlib for SeekType {
417    type GlibType = glib_sys::GSeekType;
418
419    fn to_glib(&self) -> glib_sys::GSeekType {
420        match *self {
421            SeekType::Cur => glib_sys::G_SEEK_CUR,
422            SeekType::Set => glib_sys::G_SEEK_SET,
423            SeekType::End => glib_sys::G_SEEK_END,
424            SeekType::__Unknown(value) => value,
425        }
426    }
427}
428
429#[doc(hidden)]
430impl FromGlib<glib_sys::GSeekType> for SeekType {
431    fn from_glib(value: glib_sys::GSeekType) -> Self {
432        match value {
433            0 => SeekType::Cur,
434            1 => SeekType::Set,
435            2 => SeekType::End,
436            value => SeekType::__Unknown(value),
437        }
438    }
439}
440
441#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
442pub enum TimeType {
443    Standard,
444    Daylight,
445    Universal,
446    #[doc(hidden)]
447    __Unknown(i32),
448}
449
450impl fmt::Display for TimeType {
451    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
452        write!(
453            f,
454            "TimeType::{}",
455            match *self {
456                TimeType::Standard => "Standard",
457                TimeType::Daylight => "Daylight",
458                TimeType::Universal => "Universal",
459                _ => "Unknown",
460            }
461        )
462    }
463}
464
465#[doc(hidden)]
466impl ToGlib for TimeType {
467    type GlibType = glib_sys::GTimeType;
468
469    fn to_glib(&self) -> glib_sys::GTimeType {
470        match *self {
471            TimeType::Standard => glib_sys::G_TIME_TYPE_STANDARD,
472            TimeType::Daylight => glib_sys::G_TIME_TYPE_DAYLIGHT,
473            TimeType::Universal => glib_sys::G_TIME_TYPE_UNIVERSAL,
474            TimeType::__Unknown(value) => value,
475        }
476    }
477}
478
479#[doc(hidden)]
480impl FromGlib<glib_sys::GTimeType> for TimeType {
481    fn from_glib(value: glib_sys::GTimeType) -> Self {
482        match value {
483            0 => TimeType::Standard,
484            1 => TimeType::Daylight,
485            2 => TimeType::Universal,
486            value => TimeType::__Unknown(value),
487        }
488    }
489}