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