gtk/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 glib::error::ErrorDomain;
6use glib::translate::*;
7use glib::value::FromValue;
8use glib::value::FromValueOptional;
9use glib::value::SetValue;
10use glib::value::Value;
11use glib::Quark;
12use glib::StaticType;
13use glib::Type;
14use gobject_sys;
15use gtk_sys;
16use std::fmt;
17
18#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
19pub enum Align {
20    Fill,
21    Start,
22    End,
23    Center,
24    Baseline,
25    #[doc(hidden)]
26    __Unknown(i32),
27}
28
29impl fmt::Display for Align {
30    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
31        write!(
32            f,
33            "Align::{}",
34            match *self {
35                Align::Fill => "Fill",
36                Align::Start => "Start",
37                Align::End => "End",
38                Align::Center => "Center",
39                Align::Baseline => "Baseline",
40                _ => "Unknown",
41            }
42        )
43    }
44}
45
46#[doc(hidden)]
47impl ToGlib for Align {
48    type GlibType = gtk_sys::GtkAlign;
49
50    fn to_glib(&self) -> gtk_sys::GtkAlign {
51        match *self {
52            Align::Fill => gtk_sys::GTK_ALIGN_FILL,
53            Align::Start => gtk_sys::GTK_ALIGN_START,
54            Align::End => gtk_sys::GTK_ALIGN_END,
55            Align::Center => gtk_sys::GTK_ALIGN_CENTER,
56            Align::Baseline => gtk_sys::GTK_ALIGN_BASELINE,
57            Align::__Unknown(value) => value,
58        }
59    }
60}
61
62#[doc(hidden)]
63impl FromGlib<gtk_sys::GtkAlign> for Align {
64    fn from_glib(value: gtk_sys::GtkAlign) -> Self {
65        skip_assert_initialized!();
66        match value {
67            0 => Align::Fill,
68            1 => Align::Start,
69            2 => Align::End,
70            3 => Align::Center,
71            4 => Align::Baseline,
72            value => Align::__Unknown(value),
73        }
74    }
75}
76
77impl StaticType for Align {
78    fn static_type() -> Type {
79        unsafe { from_glib(gtk_sys::gtk_align_get_type()) }
80    }
81}
82
83impl<'a> FromValueOptional<'a> for Align {
84    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
85        Some(FromValue::from_value(value))
86    }
87}
88
89impl<'a> FromValue<'a> for Align {
90    unsafe fn from_value(value: &Value) -> Self {
91        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
92    }
93}
94
95impl SetValue for Align {
96    unsafe fn set_value(value: &mut Value, this: &Self) {
97        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
98    }
99}
100
101#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
102pub enum ArrowType {
103    Up,
104    Down,
105    Left,
106    Right,
107    None,
108    #[doc(hidden)]
109    __Unknown(i32),
110}
111
112impl fmt::Display for ArrowType {
113    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
114        write!(
115            f,
116            "ArrowType::{}",
117            match *self {
118                ArrowType::Up => "Up",
119                ArrowType::Down => "Down",
120                ArrowType::Left => "Left",
121                ArrowType::Right => "Right",
122                ArrowType::None => "None",
123                _ => "Unknown",
124            }
125        )
126    }
127}
128
129#[doc(hidden)]
130impl ToGlib for ArrowType {
131    type GlibType = gtk_sys::GtkArrowType;
132
133    fn to_glib(&self) -> gtk_sys::GtkArrowType {
134        match *self {
135            ArrowType::Up => gtk_sys::GTK_ARROW_UP,
136            ArrowType::Down => gtk_sys::GTK_ARROW_DOWN,
137            ArrowType::Left => gtk_sys::GTK_ARROW_LEFT,
138            ArrowType::Right => gtk_sys::GTK_ARROW_RIGHT,
139            ArrowType::None => gtk_sys::GTK_ARROW_NONE,
140            ArrowType::__Unknown(value) => value,
141        }
142    }
143}
144
145#[doc(hidden)]
146impl FromGlib<gtk_sys::GtkArrowType> for ArrowType {
147    fn from_glib(value: gtk_sys::GtkArrowType) -> Self {
148        skip_assert_initialized!();
149        match value {
150            0 => ArrowType::Up,
151            1 => ArrowType::Down,
152            2 => ArrowType::Left,
153            3 => ArrowType::Right,
154            4 => ArrowType::None,
155            value => ArrowType::__Unknown(value),
156        }
157    }
158}
159
160impl StaticType for ArrowType {
161    fn static_type() -> Type {
162        unsafe { from_glib(gtk_sys::gtk_arrow_type_get_type()) }
163    }
164}
165
166impl<'a> FromValueOptional<'a> for ArrowType {
167    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
168        Some(FromValue::from_value(value))
169    }
170}
171
172impl<'a> FromValue<'a> for ArrowType {
173    unsafe fn from_value(value: &Value) -> Self {
174        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
175    }
176}
177
178impl SetValue for ArrowType {
179    unsafe fn set_value(value: &mut Value, this: &Self) {
180        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
181    }
182}
183
184#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
185pub enum AssistantPageType {
186    Content,
187    Intro,
188    Confirm,
189    Summary,
190    Progress,
191    Custom,
192    #[doc(hidden)]
193    __Unknown(i32),
194}
195
196impl fmt::Display for AssistantPageType {
197    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
198        write!(
199            f,
200            "AssistantPageType::{}",
201            match *self {
202                AssistantPageType::Content => "Content",
203                AssistantPageType::Intro => "Intro",
204                AssistantPageType::Confirm => "Confirm",
205                AssistantPageType::Summary => "Summary",
206                AssistantPageType::Progress => "Progress",
207                AssistantPageType::Custom => "Custom",
208                _ => "Unknown",
209            }
210        )
211    }
212}
213
214#[doc(hidden)]
215impl ToGlib for AssistantPageType {
216    type GlibType = gtk_sys::GtkAssistantPageType;
217
218    fn to_glib(&self) -> gtk_sys::GtkAssistantPageType {
219        match *self {
220            AssistantPageType::Content => gtk_sys::GTK_ASSISTANT_PAGE_CONTENT,
221            AssistantPageType::Intro => gtk_sys::GTK_ASSISTANT_PAGE_INTRO,
222            AssistantPageType::Confirm => gtk_sys::GTK_ASSISTANT_PAGE_CONFIRM,
223            AssistantPageType::Summary => gtk_sys::GTK_ASSISTANT_PAGE_SUMMARY,
224            AssistantPageType::Progress => gtk_sys::GTK_ASSISTANT_PAGE_PROGRESS,
225            AssistantPageType::Custom => gtk_sys::GTK_ASSISTANT_PAGE_CUSTOM,
226            AssistantPageType::__Unknown(value) => value,
227        }
228    }
229}
230
231#[doc(hidden)]
232impl FromGlib<gtk_sys::GtkAssistantPageType> for AssistantPageType {
233    fn from_glib(value: gtk_sys::GtkAssistantPageType) -> Self {
234        skip_assert_initialized!();
235        match value {
236            0 => AssistantPageType::Content,
237            1 => AssistantPageType::Intro,
238            2 => AssistantPageType::Confirm,
239            3 => AssistantPageType::Summary,
240            4 => AssistantPageType::Progress,
241            5 => AssistantPageType::Custom,
242            value => AssistantPageType::__Unknown(value),
243        }
244    }
245}
246
247impl StaticType for AssistantPageType {
248    fn static_type() -> Type {
249        unsafe { from_glib(gtk_sys::gtk_assistant_page_type_get_type()) }
250    }
251}
252
253impl<'a> FromValueOptional<'a> for AssistantPageType {
254    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
255        Some(FromValue::from_value(value))
256    }
257}
258
259impl<'a> FromValue<'a> for AssistantPageType {
260    unsafe fn from_value(value: &Value) -> Self {
261        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
262    }
263}
264
265impl SetValue for AssistantPageType {
266    unsafe fn set_value(value: &mut Value, this: &Self) {
267        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
268    }
269}
270
271#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
272pub enum BaselinePosition {
273    Top,
274    Center,
275    Bottom,
276    #[doc(hidden)]
277    __Unknown(i32),
278}
279
280impl fmt::Display for BaselinePosition {
281    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
282        write!(
283            f,
284            "BaselinePosition::{}",
285            match *self {
286                BaselinePosition::Top => "Top",
287                BaselinePosition::Center => "Center",
288                BaselinePosition::Bottom => "Bottom",
289                _ => "Unknown",
290            }
291        )
292    }
293}
294
295#[doc(hidden)]
296impl ToGlib for BaselinePosition {
297    type GlibType = gtk_sys::GtkBaselinePosition;
298
299    fn to_glib(&self) -> gtk_sys::GtkBaselinePosition {
300        match *self {
301            BaselinePosition::Top => gtk_sys::GTK_BASELINE_POSITION_TOP,
302            BaselinePosition::Center => gtk_sys::GTK_BASELINE_POSITION_CENTER,
303            BaselinePosition::Bottom => gtk_sys::GTK_BASELINE_POSITION_BOTTOM,
304            BaselinePosition::__Unknown(value) => value,
305        }
306    }
307}
308
309#[doc(hidden)]
310impl FromGlib<gtk_sys::GtkBaselinePosition> for BaselinePosition {
311    fn from_glib(value: gtk_sys::GtkBaselinePosition) -> Self {
312        skip_assert_initialized!();
313        match value {
314            0 => BaselinePosition::Top,
315            1 => BaselinePosition::Center,
316            2 => BaselinePosition::Bottom,
317            value => BaselinePosition::__Unknown(value),
318        }
319    }
320}
321
322impl StaticType for BaselinePosition {
323    fn static_type() -> Type {
324        unsafe { from_glib(gtk_sys::gtk_baseline_position_get_type()) }
325    }
326}
327
328impl<'a> FromValueOptional<'a> for BaselinePosition {
329    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
330        Some(FromValue::from_value(value))
331    }
332}
333
334impl<'a> FromValue<'a> for BaselinePosition {
335    unsafe fn from_value(value: &Value) -> Self {
336        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
337    }
338}
339
340impl SetValue for BaselinePosition {
341    unsafe fn set_value(value: &mut Value, this: &Self) {
342        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
343    }
344}
345
346#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
347pub enum BorderStyle {
348    None,
349    Solid,
350    Inset,
351    Outset,
352    Hidden,
353    Dotted,
354    Dashed,
355    Double,
356    Groove,
357    Ridge,
358    #[doc(hidden)]
359    __Unknown(i32),
360}
361
362impl fmt::Display for BorderStyle {
363    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
364        write!(
365            f,
366            "BorderStyle::{}",
367            match *self {
368                BorderStyle::None => "None",
369                BorderStyle::Solid => "Solid",
370                BorderStyle::Inset => "Inset",
371                BorderStyle::Outset => "Outset",
372                BorderStyle::Hidden => "Hidden",
373                BorderStyle::Dotted => "Dotted",
374                BorderStyle::Dashed => "Dashed",
375                BorderStyle::Double => "Double",
376                BorderStyle::Groove => "Groove",
377                BorderStyle::Ridge => "Ridge",
378                _ => "Unknown",
379            }
380        )
381    }
382}
383
384#[doc(hidden)]
385impl ToGlib for BorderStyle {
386    type GlibType = gtk_sys::GtkBorderStyle;
387
388    fn to_glib(&self) -> gtk_sys::GtkBorderStyle {
389        match *self {
390            BorderStyle::None => gtk_sys::GTK_BORDER_STYLE_NONE,
391            BorderStyle::Solid => gtk_sys::GTK_BORDER_STYLE_SOLID,
392            BorderStyle::Inset => gtk_sys::GTK_BORDER_STYLE_INSET,
393            BorderStyle::Outset => gtk_sys::GTK_BORDER_STYLE_OUTSET,
394            BorderStyle::Hidden => gtk_sys::GTK_BORDER_STYLE_HIDDEN,
395            BorderStyle::Dotted => gtk_sys::GTK_BORDER_STYLE_DOTTED,
396            BorderStyle::Dashed => gtk_sys::GTK_BORDER_STYLE_DASHED,
397            BorderStyle::Double => gtk_sys::GTK_BORDER_STYLE_DOUBLE,
398            BorderStyle::Groove => gtk_sys::GTK_BORDER_STYLE_GROOVE,
399            BorderStyle::Ridge => gtk_sys::GTK_BORDER_STYLE_RIDGE,
400            BorderStyle::__Unknown(value) => value,
401        }
402    }
403}
404
405#[doc(hidden)]
406impl FromGlib<gtk_sys::GtkBorderStyle> for BorderStyle {
407    fn from_glib(value: gtk_sys::GtkBorderStyle) -> Self {
408        skip_assert_initialized!();
409        match value {
410            0 => BorderStyle::None,
411            1 => BorderStyle::Solid,
412            2 => BorderStyle::Inset,
413            3 => BorderStyle::Outset,
414            4 => BorderStyle::Hidden,
415            5 => BorderStyle::Dotted,
416            6 => BorderStyle::Dashed,
417            7 => BorderStyle::Double,
418            8 => BorderStyle::Groove,
419            9 => BorderStyle::Ridge,
420            value => BorderStyle::__Unknown(value),
421        }
422    }
423}
424
425impl StaticType for BorderStyle {
426    fn static_type() -> Type {
427        unsafe { from_glib(gtk_sys::gtk_border_style_get_type()) }
428    }
429}
430
431impl<'a> FromValueOptional<'a> for BorderStyle {
432    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
433        Some(FromValue::from_value(value))
434    }
435}
436
437impl<'a> FromValue<'a> for BorderStyle {
438    unsafe fn from_value(value: &Value) -> Self {
439        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
440    }
441}
442
443impl SetValue for BorderStyle {
444    unsafe fn set_value(value: &mut Value, this: &Self) {
445        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
446    }
447}
448
449#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
450pub enum BuilderError {
451    InvalidTypeFunction,
452    UnhandledTag,
453    MissingAttribute,
454    InvalidAttribute,
455    InvalidTag,
456    MissingPropertyValue,
457    InvalidValue,
458    VersionMismatch,
459    DuplicateId,
460    ObjectTypeRefused,
461    TemplateMismatch,
462    InvalidProperty,
463    InvalidSignal,
464    InvalidId,
465    #[doc(hidden)]
466    __Unknown(i32),
467}
468
469impl fmt::Display for BuilderError {
470    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
471        write!(
472            f,
473            "BuilderError::{}",
474            match *self {
475                BuilderError::InvalidTypeFunction => "InvalidTypeFunction",
476                BuilderError::UnhandledTag => "UnhandledTag",
477                BuilderError::MissingAttribute => "MissingAttribute",
478                BuilderError::InvalidAttribute => "InvalidAttribute",
479                BuilderError::InvalidTag => "InvalidTag",
480                BuilderError::MissingPropertyValue => "MissingPropertyValue",
481                BuilderError::InvalidValue => "InvalidValue",
482                BuilderError::VersionMismatch => "VersionMismatch",
483                BuilderError::DuplicateId => "DuplicateId",
484                BuilderError::ObjectTypeRefused => "ObjectTypeRefused",
485                BuilderError::TemplateMismatch => "TemplateMismatch",
486                BuilderError::InvalidProperty => "InvalidProperty",
487                BuilderError::InvalidSignal => "InvalidSignal",
488                BuilderError::InvalidId => "InvalidId",
489                _ => "Unknown",
490            }
491        )
492    }
493}
494
495#[doc(hidden)]
496impl ToGlib for BuilderError {
497    type GlibType = gtk_sys::GtkBuilderError;
498
499    fn to_glib(&self) -> gtk_sys::GtkBuilderError {
500        match *self {
501            BuilderError::InvalidTypeFunction => gtk_sys::GTK_BUILDER_ERROR_INVALID_TYPE_FUNCTION,
502            BuilderError::UnhandledTag => gtk_sys::GTK_BUILDER_ERROR_UNHANDLED_TAG,
503            BuilderError::MissingAttribute => gtk_sys::GTK_BUILDER_ERROR_MISSING_ATTRIBUTE,
504            BuilderError::InvalidAttribute => gtk_sys::GTK_BUILDER_ERROR_INVALID_ATTRIBUTE,
505            BuilderError::InvalidTag => gtk_sys::GTK_BUILDER_ERROR_INVALID_TAG,
506            BuilderError::MissingPropertyValue => gtk_sys::GTK_BUILDER_ERROR_MISSING_PROPERTY_VALUE,
507            BuilderError::InvalidValue => gtk_sys::GTK_BUILDER_ERROR_INVALID_VALUE,
508            BuilderError::VersionMismatch => gtk_sys::GTK_BUILDER_ERROR_VERSION_MISMATCH,
509            BuilderError::DuplicateId => gtk_sys::GTK_BUILDER_ERROR_DUPLICATE_ID,
510            BuilderError::ObjectTypeRefused => gtk_sys::GTK_BUILDER_ERROR_OBJECT_TYPE_REFUSED,
511            BuilderError::TemplateMismatch => gtk_sys::GTK_BUILDER_ERROR_TEMPLATE_MISMATCH,
512            BuilderError::InvalidProperty => gtk_sys::GTK_BUILDER_ERROR_INVALID_PROPERTY,
513            BuilderError::InvalidSignal => gtk_sys::GTK_BUILDER_ERROR_INVALID_SIGNAL,
514            BuilderError::InvalidId => gtk_sys::GTK_BUILDER_ERROR_INVALID_ID,
515            BuilderError::__Unknown(value) => value,
516        }
517    }
518}
519
520#[doc(hidden)]
521impl FromGlib<gtk_sys::GtkBuilderError> for BuilderError {
522    fn from_glib(value: gtk_sys::GtkBuilderError) -> Self {
523        skip_assert_initialized!();
524        match value {
525            0 => BuilderError::InvalidTypeFunction,
526            1 => BuilderError::UnhandledTag,
527            2 => BuilderError::MissingAttribute,
528            3 => BuilderError::InvalidAttribute,
529            4 => BuilderError::InvalidTag,
530            5 => BuilderError::MissingPropertyValue,
531            6 => BuilderError::InvalidValue,
532            7 => BuilderError::VersionMismatch,
533            8 => BuilderError::DuplicateId,
534            9 => BuilderError::ObjectTypeRefused,
535            10 => BuilderError::TemplateMismatch,
536            11 => BuilderError::InvalidProperty,
537            12 => BuilderError::InvalidSignal,
538            13 => BuilderError::InvalidId,
539            value => BuilderError::__Unknown(value),
540        }
541    }
542}
543
544impl ErrorDomain for BuilderError {
545    fn domain() -> Quark {
546        skip_assert_initialized!();
547        unsafe { from_glib(gtk_sys::gtk_builder_error_quark()) }
548    }
549
550    fn code(self) -> i32 {
551        self.to_glib()
552    }
553
554    fn from(code: i32) -> Option<Self> {
555        skip_assert_initialized!();
556        match code {
557            0 => Some(BuilderError::InvalidTypeFunction),
558            1 => Some(BuilderError::UnhandledTag),
559            2 => Some(BuilderError::MissingAttribute),
560            3 => Some(BuilderError::InvalidAttribute),
561            4 => Some(BuilderError::InvalidTag),
562            5 => Some(BuilderError::MissingPropertyValue),
563            6 => Some(BuilderError::InvalidValue),
564            7 => Some(BuilderError::VersionMismatch),
565            8 => Some(BuilderError::DuplicateId),
566            9 => Some(BuilderError::ObjectTypeRefused),
567            10 => Some(BuilderError::TemplateMismatch),
568            11 => Some(BuilderError::InvalidProperty),
569            12 => Some(BuilderError::InvalidSignal),
570            13 => Some(BuilderError::InvalidId),
571            value => Some(BuilderError::__Unknown(value)),
572        }
573    }
574}
575
576impl StaticType for BuilderError {
577    fn static_type() -> Type {
578        unsafe { from_glib(gtk_sys::gtk_builder_error_get_type()) }
579    }
580}
581
582impl<'a> FromValueOptional<'a> for BuilderError {
583    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
584        Some(FromValue::from_value(value))
585    }
586}
587
588impl<'a> FromValue<'a> for BuilderError {
589    unsafe fn from_value(value: &Value) -> Self {
590        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
591    }
592}
593
594impl SetValue for BuilderError {
595    unsafe fn set_value(value: &mut Value, this: &Self) {
596        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
597    }
598}
599
600#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
601pub enum ButtonBoxStyle {
602    Spread,
603    Edge,
604    Start,
605    End,
606    Center,
607    Expand,
608    #[doc(hidden)]
609    __Unknown(i32),
610}
611
612impl fmt::Display for ButtonBoxStyle {
613    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
614        write!(
615            f,
616            "ButtonBoxStyle::{}",
617            match *self {
618                ButtonBoxStyle::Spread => "Spread",
619                ButtonBoxStyle::Edge => "Edge",
620                ButtonBoxStyle::Start => "Start",
621                ButtonBoxStyle::End => "End",
622                ButtonBoxStyle::Center => "Center",
623                ButtonBoxStyle::Expand => "Expand",
624                _ => "Unknown",
625            }
626        )
627    }
628}
629
630#[doc(hidden)]
631impl ToGlib for ButtonBoxStyle {
632    type GlibType = gtk_sys::GtkButtonBoxStyle;
633
634    fn to_glib(&self) -> gtk_sys::GtkButtonBoxStyle {
635        match *self {
636            ButtonBoxStyle::Spread => gtk_sys::GTK_BUTTONBOX_SPREAD,
637            ButtonBoxStyle::Edge => gtk_sys::GTK_BUTTONBOX_EDGE,
638            ButtonBoxStyle::Start => gtk_sys::GTK_BUTTONBOX_START,
639            ButtonBoxStyle::End => gtk_sys::GTK_BUTTONBOX_END,
640            ButtonBoxStyle::Center => gtk_sys::GTK_BUTTONBOX_CENTER,
641            ButtonBoxStyle::Expand => gtk_sys::GTK_BUTTONBOX_EXPAND,
642            ButtonBoxStyle::__Unknown(value) => value,
643        }
644    }
645}
646
647#[doc(hidden)]
648impl FromGlib<gtk_sys::GtkButtonBoxStyle> for ButtonBoxStyle {
649    fn from_glib(value: gtk_sys::GtkButtonBoxStyle) -> Self {
650        skip_assert_initialized!();
651        match value {
652            1 => ButtonBoxStyle::Spread,
653            2 => ButtonBoxStyle::Edge,
654            3 => ButtonBoxStyle::Start,
655            4 => ButtonBoxStyle::End,
656            5 => ButtonBoxStyle::Center,
657            6 => ButtonBoxStyle::Expand,
658            value => ButtonBoxStyle::__Unknown(value),
659        }
660    }
661}
662
663impl StaticType for ButtonBoxStyle {
664    fn static_type() -> Type {
665        unsafe { from_glib(gtk_sys::gtk_button_box_style_get_type()) }
666    }
667}
668
669impl<'a> FromValueOptional<'a> for ButtonBoxStyle {
670    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
671        Some(FromValue::from_value(value))
672    }
673}
674
675impl<'a> FromValue<'a> for ButtonBoxStyle {
676    unsafe fn from_value(value: &Value) -> Self {
677        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
678    }
679}
680
681impl SetValue for ButtonBoxStyle {
682    unsafe fn set_value(value: &mut Value, this: &Self) {
683        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
684    }
685}
686
687#[cfg(any(feature = "v3_16", feature = "dox"))]
688#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
689pub enum ButtonRole {
690    Normal,
691    Check,
692    Radio,
693    #[doc(hidden)]
694    __Unknown(i32),
695}
696
697#[cfg(any(feature = "v3_16", feature = "dox"))]
698impl fmt::Display for ButtonRole {
699    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
700        write!(
701            f,
702            "ButtonRole::{}",
703            match *self {
704                ButtonRole::Normal => "Normal",
705                ButtonRole::Check => "Check",
706                ButtonRole::Radio => "Radio",
707                _ => "Unknown",
708            }
709        )
710    }
711}
712
713#[cfg(any(feature = "v3_16", feature = "dox"))]
714#[doc(hidden)]
715impl ToGlib for ButtonRole {
716    type GlibType = gtk_sys::GtkButtonRole;
717
718    fn to_glib(&self) -> gtk_sys::GtkButtonRole {
719        match *self {
720            ButtonRole::Normal => gtk_sys::GTK_BUTTON_ROLE_NORMAL,
721            ButtonRole::Check => gtk_sys::GTK_BUTTON_ROLE_CHECK,
722            ButtonRole::Radio => gtk_sys::GTK_BUTTON_ROLE_RADIO,
723            ButtonRole::__Unknown(value) => value,
724        }
725    }
726}
727
728#[cfg(any(feature = "v3_16", feature = "dox"))]
729#[doc(hidden)]
730impl FromGlib<gtk_sys::GtkButtonRole> for ButtonRole {
731    fn from_glib(value: gtk_sys::GtkButtonRole) -> Self {
732        skip_assert_initialized!();
733        match value {
734            0 => ButtonRole::Normal,
735            1 => ButtonRole::Check,
736            2 => ButtonRole::Radio,
737            value => ButtonRole::__Unknown(value),
738        }
739    }
740}
741
742#[cfg(any(feature = "v3_16", feature = "dox"))]
743impl StaticType for ButtonRole {
744    fn static_type() -> Type {
745        unsafe { from_glib(gtk_sys::gtk_button_role_get_type()) }
746    }
747}
748
749#[cfg(any(feature = "v3_16", feature = "dox"))]
750impl<'a> FromValueOptional<'a> for ButtonRole {
751    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
752        Some(FromValue::from_value(value))
753    }
754}
755
756#[cfg(any(feature = "v3_16", feature = "dox"))]
757impl<'a> FromValue<'a> for ButtonRole {
758    unsafe fn from_value(value: &Value) -> Self {
759        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
760    }
761}
762
763#[cfg(any(feature = "v3_16", feature = "dox"))]
764impl SetValue for ButtonRole {
765    unsafe fn set_value(value: &mut Value, this: &Self) {
766        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
767    }
768}
769
770#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
771pub enum ButtonsType {
772    None,
773    Ok,
774    Close,
775    Cancel,
776    YesNo,
777    OkCancel,
778    #[doc(hidden)]
779    __Unknown(i32),
780}
781
782impl fmt::Display for ButtonsType {
783    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
784        write!(
785            f,
786            "ButtonsType::{}",
787            match *self {
788                ButtonsType::None => "None",
789                ButtonsType::Ok => "Ok",
790                ButtonsType::Close => "Close",
791                ButtonsType::Cancel => "Cancel",
792                ButtonsType::YesNo => "YesNo",
793                ButtonsType::OkCancel => "OkCancel",
794                _ => "Unknown",
795            }
796        )
797    }
798}
799
800#[doc(hidden)]
801impl ToGlib for ButtonsType {
802    type GlibType = gtk_sys::GtkButtonsType;
803
804    fn to_glib(&self) -> gtk_sys::GtkButtonsType {
805        match *self {
806            ButtonsType::None => gtk_sys::GTK_BUTTONS_NONE,
807            ButtonsType::Ok => gtk_sys::GTK_BUTTONS_OK,
808            ButtonsType::Close => gtk_sys::GTK_BUTTONS_CLOSE,
809            ButtonsType::Cancel => gtk_sys::GTK_BUTTONS_CANCEL,
810            ButtonsType::YesNo => gtk_sys::GTK_BUTTONS_YES_NO,
811            ButtonsType::OkCancel => gtk_sys::GTK_BUTTONS_OK_CANCEL,
812            ButtonsType::__Unknown(value) => value,
813        }
814    }
815}
816
817#[doc(hidden)]
818impl FromGlib<gtk_sys::GtkButtonsType> for ButtonsType {
819    fn from_glib(value: gtk_sys::GtkButtonsType) -> Self {
820        skip_assert_initialized!();
821        match value {
822            0 => ButtonsType::None,
823            1 => ButtonsType::Ok,
824            2 => ButtonsType::Close,
825            3 => ButtonsType::Cancel,
826            4 => ButtonsType::YesNo,
827            5 => ButtonsType::OkCancel,
828            value => ButtonsType::__Unknown(value),
829        }
830    }
831}
832
833impl StaticType for ButtonsType {
834    fn static_type() -> Type {
835        unsafe { from_glib(gtk_sys::gtk_buttons_type_get_type()) }
836    }
837}
838
839impl<'a> FromValueOptional<'a> for ButtonsType {
840    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
841        Some(FromValue::from_value(value))
842    }
843}
844
845impl<'a> FromValue<'a> for ButtonsType {
846    unsafe fn from_value(value: &Value) -> Self {
847        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
848    }
849}
850
851impl SetValue for ButtonsType {
852    unsafe fn set_value(value: &mut Value, this: &Self) {
853        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
854    }
855}
856
857#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
858pub enum CellRendererAccelMode {
859    Gtk,
860    Other,
861    ModifierTap,
862    #[doc(hidden)]
863    __Unknown(i32),
864}
865
866impl fmt::Display for CellRendererAccelMode {
867    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
868        write!(
869            f,
870            "CellRendererAccelMode::{}",
871            match *self {
872                CellRendererAccelMode::Gtk => "Gtk",
873                CellRendererAccelMode::Other => "Other",
874                CellRendererAccelMode::ModifierTap => "ModifierTap",
875                _ => "Unknown",
876            }
877        )
878    }
879}
880
881#[doc(hidden)]
882impl ToGlib for CellRendererAccelMode {
883    type GlibType = gtk_sys::GtkCellRendererAccelMode;
884
885    fn to_glib(&self) -> gtk_sys::GtkCellRendererAccelMode {
886        match *self {
887            CellRendererAccelMode::Gtk => gtk_sys::GTK_CELL_RENDERER_ACCEL_MODE_GTK,
888            CellRendererAccelMode::Other => gtk_sys::GTK_CELL_RENDERER_ACCEL_MODE_OTHER,
889            CellRendererAccelMode::ModifierTap => {
890                gtk_sys::GTK_CELL_RENDERER_ACCEL_MODE_MODIFIER_TAP
891            }
892            CellRendererAccelMode::__Unknown(value) => value,
893        }
894    }
895}
896
897#[doc(hidden)]
898impl FromGlib<gtk_sys::GtkCellRendererAccelMode> for CellRendererAccelMode {
899    fn from_glib(value: gtk_sys::GtkCellRendererAccelMode) -> Self {
900        skip_assert_initialized!();
901        match value {
902            0 => CellRendererAccelMode::Gtk,
903            1 => CellRendererAccelMode::Other,
904            2 => CellRendererAccelMode::ModifierTap,
905            value => CellRendererAccelMode::__Unknown(value),
906        }
907    }
908}
909
910impl StaticType for CellRendererAccelMode {
911    fn static_type() -> Type {
912        unsafe { from_glib(gtk_sys::gtk_cell_renderer_accel_mode_get_type()) }
913    }
914}
915
916impl<'a> FromValueOptional<'a> for CellRendererAccelMode {
917    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
918        Some(FromValue::from_value(value))
919    }
920}
921
922impl<'a> FromValue<'a> for CellRendererAccelMode {
923    unsafe fn from_value(value: &Value) -> Self {
924        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
925    }
926}
927
928impl SetValue for CellRendererAccelMode {
929    unsafe fn set_value(value: &mut Value, this: &Self) {
930        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
931    }
932}
933
934#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
935pub enum CellRendererMode {
936    Inert,
937    Activatable,
938    Editable,
939    #[doc(hidden)]
940    __Unknown(i32),
941}
942
943impl fmt::Display for CellRendererMode {
944    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
945        write!(
946            f,
947            "CellRendererMode::{}",
948            match *self {
949                CellRendererMode::Inert => "Inert",
950                CellRendererMode::Activatable => "Activatable",
951                CellRendererMode::Editable => "Editable",
952                _ => "Unknown",
953            }
954        )
955    }
956}
957
958#[doc(hidden)]
959impl ToGlib for CellRendererMode {
960    type GlibType = gtk_sys::GtkCellRendererMode;
961
962    fn to_glib(&self) -> gtk_sys::GtkCellRendererMode {
963        match *self {
964            CellRendererMode::Inert => gtk_sys::GTK_CELL_RENDERER_MODE_INERT,
965            CellRendererMode::Activatable => gtk_sys::GTK_CELL_RENDERER_MODE_ACTIVATABLE,
966            CellRendererMode::Editable => gtk_sys::GTK_CELL_RENDERER_MODE_EDITABLE,
967            CellRendererMode::__Unknown(value) => value,
968        }
969    }
970}
971
972#[doc(hidden)]
973impl FromGlib<gtk_sys::GtkCellRendererMode> for CellRendererMode {
974    fn from_glib(value: gtk_sys::GtkCellRendererMode) -> Self {
975        skip_assert_initialized!();
976        match value {
977            0 => CellRendererMode::Inert,
978            1 => CellRendererMode::Activatable,
979            2 => CellRendererMode::Editable,
980            value => CellRendererMode::__Unknown(value),
981        }
982    }
983}
984
985impl StaticType for CellRendererMode {
986    fn static_type() -> Type {
987        unsafe { from_glib(gtk_sys::gtk_cell_renderer_mode_get_type()) }
988    }
989}
990
991impl<'a> FromValueOptional<'a> for CellRendererMode {
992    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
993        Some(FromValue::from_value(value))
994    }
995}
996
997impl<'a> FromValue<'a> for CellRendererMode {
998    unsafe fn from_value(value: &Value) -> Self {
999        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
1000    }
1001}
1002
1003impl SetValue for CellRendererMode {
1004    unsafe fn set_value(value: &mut Value, this: &Self) {
1005        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
1006    }
1007}
1008
1009#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1010pub enum CornerType {
1011    TopLeft,
1012    BottomLeft,
1013    TopRight,
1014    BottomRight,
1015    #[doc(hidden)]
1016    __Unknown(i32),
1017}
1018
1019impl fmt::Display for CornerType {
1020    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1021        write!(
1022            f,
1023            "CornerType::{}",
1024            match *self {
1025                CornerType::TopLeft => "TopLeft",
1026                CornerType::BottomLeft => "BottomLeft",
1027                CornerType::TopRight => "TopRight",
1028                CornerType::BottomRight => "BottomRight",
1029                _ => "Unknown",
1030            }
1031        )
1032    }
1033}
1034
1035#[doc(hidden)]
1036impl ToGlib for CornerType {
1037    type GlibType = gtk_sys::GtkCornerType;
1038
1039    fn to_glib(&self) -> gtk_sys::GtkCornerType {
1040        match *self {
1041            CornerType::TopLeft => gtk_sys::GTK_CORNER_TOP_LEFT,
1042            CornerType::BottomLeft => gtk_sys::GTK_CORNER_BOTTOM_LEFT,
1043            CornerType::TopRight => gtk_sys::GTK_CORNER_TOP_RIGHT,
1044            CornerType::BottomRight => gtk_sys::GTK_CORNER_BOTTOM_RIGHT,
1045            CornerType::__Unknown(value) => value,
1046        }
1047    }
1048}
1049
1050#[doc(hidden)]
1051impl FromGlib<gtk_sys::GtkCornerType> for CornerType {
1052    fn from_glib(value: gtk_sys::GtkCornerType) -> Self {
1053        skip_assert_initialized!();
1054        match value {
1055            0 => CornerType::TopLeft,
1056            1 => CornerType::BottomLeft,
1057            2 => CornerType::TopRight,
1058            3 => CornerType::BottomRight,
1059            value => CornerType::__Unknown(value),
1060        }
1061    }
1062}
1063
1064impl StaticType for CornerType {
1065    fn static_type() -> Type {
1066        unsafe { from_glib(gtk_sys::gtk_corner_type_get_type()) }
1067    }
1068}
1069
1070impl<'a> FromValueOptional<'a> for CornerType {
1071    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
1072        Some(FromValue::from_value(value))
1073    }
1074}
1075
1076impl<'a> FromValue<'a> for CornerType {
1077    unsafe fn from_value(value: &Value) -> Self {
1078        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
1079    }
1080}
1081
1082impl SetValue for CornerType {
1083    unsafe fn set_value(value: &mut Value, this: &Self) {
1084        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
1085    }
1086}
1087
1088#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1089pub enum CssProviderError {
1090    Failed,
1091    Syntax,
1092    Import,
1093    Name,
1094    Deprecated,
1095    UnknownValue,
1096    #[doc(hidden)]
1097    __Unknown(i32),
1098}
1099
1100impl fmt::Display for CssProviderError {
1101    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1102        write!(
1103            f,
1104            "CssProviderError::{}",
1105            match *self {
1106                CssProviderError::Failed => "Failed",
1107                CssProviderError::Syntax => "Syntax",
1108                CssProviderError::Import => "Import",
1109                CssProviderError::Name => "Name",
1110                CssProviderError::Deprecated => "Deprecated",
1111                CssProviderError::UnknownValue => "UnknownValue",
1112                _ => "Unknown",
1113            }
1114        )
1115    }
1116}
1117
1118#[doc(hidden)]
1119impl ToGlib for CssProviderError {
1120    type GlibType = gtk_sys::GtkCssProviderError;
1121
1122    fn to_glib(&self) -> gtk_sys::GtkCssProviderError {
1123        match *self {
1124            CssProviderError::Failed => gtk_sys::GTK_CSS_PROVIDER_ERROR_FAILED,
1125            CssProviderError::Syntax => gtk_sys::GTK_CSS_PROVIDER_ERROR_SYNTAX,
1126            CssProviderError::Import => gtk_sys::GTK_CSS_PROVIDER_ERROR_IMPORT,
1127            CssProviderError::Name => gtk_sys::GTK_CSS_PROVIDER_ERROR_NAME,
1128            CssProviderError::Deprecated => gtk_sys::GTK_CSS_PROVIDER_ERROR_DEPRECATED,
1129            CssProviderError::UnknownValue => gtk_sys::GTK_CSS_PROVIDER_ERROR_UNKNOWN_VALUE,
1130            CssProviderError::__Unknown(value) => value,
1131        }
1132    }
1133}
1134
1135#[doc(hidden)]
1136impl FromGlib<gtk_sys::GtkCssProviderError> for CssProviderError {
1137    fn from_glib(value: gtk_sys::GtkCssProviderError) -> Self {
1138        skip_assert_initialized!();
1139        match value {
1140            0 => CssProviderError::Failed,
1141            1 => CssProviderError::Syntax,
1142            2 => CssProviderError::Import,
1143            3 => CssProviderError::Name,
1144            4 => CssProviderError::Deprecated,
1145            5 => CssProviderError::UnknownValue,
1146            value => CssProviderError::__Unknown(value),
1147        }
1148    }
1149}
1150
1151impl ErrorDomain for CssProviderError {
1152    fn domain() -> Quark {
1153        skip_assert_initialized!();
1154        unsafe { from_glib(gtk_sys::gtk_css_provider_error_quark()) }
1155    }
1156
1157    fn code(self) -> i32 {
1158        self.to_glib()
1159    }
1160
1161    fn from(code: i32) -> Option<Self> {
1162        skip_assert_initialized!();
1163        match code {
1164            0 => Some(CssProviderError::Failed),
1165            1 => Some(CssProviderError::Syntax),
1166            2 => Some(CssProviderError::Import),
1167            3 => Some(CssProviderError::Name),
1168            4 => Some(CssProviderError::Deprecated),
1169            5 => Some(CssProviderError::UnknownValue),
1170            _ => Some(CssProviderError::Failed),
1171        }
1172    }
1173}
1174
1175impl StaticType for CssProviderError {
1176    fn static_type() -> Type {
1177        unsafe { from_glib(gtk_sys::gtk_css_provider_error_get_type()) }
1178    }
1179}
1180
1181impl<'a> FromValueOptional<'a> for CssProviderError {
1182    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
1183        Some(FromValue::from_value(value))
1184    }
1185}
1186
1187impl<'a> FromValue<'a> for CssProviderError {
1188    unsafe fn from_value(value: &Value) -> Self {
1189        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
1190    }
1191}
1192
1193impl SetValue for CssProviderError {
1194    unsafe fn set_value(value: &mut Value, this: &Self) {
1195        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
1196    }
1197}
1198
1199#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1200pub enum CssSectionType {
1201    Document,
1202    Import,
1203    ColorDefinition,
1204    BindingSet,
1205    Ruleset,
1206    Selector,
1207    Declaration,
1208    Value,
1209    Keyframes,
1210    #[doc(hidden)]
1211    __Unknown(i32),
1212}
1213
1214impl fmt::Display for CssSectionType {
1215    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1216        write!(
1217            f,
1218            "CssSectionType::{}",
1219            match *self {
1220                CssSectionType::Document => "Document",
1221                CssSectionType::Import => "Import",
1222                CssSectionType::ColorDefinition => "ColorDefinition",
1223                CssSectionType::BindingSet => "BindingSet",
1224                CssSectionType::Ruleset => "Ruleset",
1225                CssSectionType::Selector => "Selector",
1226                CssSectionType::Declaration => "Declaration",
1227                CssSectionType::Value => "Value",
1228                CssSectionType::Keyframes => "Keyframes",
1229                _ => "Unknown",
1230            }
1231        )
1232    }
1233}
1234
1235#[doc(hidden)]
1236impl ToGlib for CssSectionType {
1237    type GlibType = gtk_sys::GtkCssSectionType;
1238
1239    fn to_glib(&self) -> gtk_sys::GtkCssSectionType {
1240        match *self {
1241            CssSectionType::Document => gtk_sys::GTK_CSS_SECTION_DOCUMENT,
1242            CssSectionType::Import => gtk_sys::GTK_CSS_SECTION_IMPORT,
1243            CssSectionType::ColorDefinition => gtk_sys::GTK_CSS_SECTION_COLOR_DEFINITION,
1244            CssSectionType::BindingSet => gtk_sys::GTK_CSS_SECTION_BINDING_SET,
1245            CssSectionType::Ruleset => gtk_sys::GTK_CSS_SECTION_RULESET,
1246            CssSectionType::Selector => gtk_sys::GTK_CSS_SECTION_SELECTOR,
1247            CssSectionType::Declaration => gtk_sys::GTK_CSS_SECTION_DECLARATION,
1248            CssSectionType::Value => gtk_sys::GTK_CSS_SECTION_VALUE,
1249            CssSectionType::Keyframes => gtk_sys::GTK_CSS_SECTION_KEYFRAMES,
1250            CssSectionType::__Unknown(value) => value,
1251        }
1252    }
1253}
1254
1255#[doc(hidden)]
1256impl FromGlib<gtk_sys::GtkCssSectionType> for CssSectionType {
1257    fn from_glib(value: gtk_sys::GtkCssSectionType) -> Self {
1258        skip_assert_initialized!();
1259        match value {
1260            0 => CssSectionType::Document,
1261            1 => CssSectionType::Import,
1262            2 => CssSectionType::ColorDefinition,
1263            3 => CssSectionType::BindingSet,
1264            4 => CssSectionType::Ruleset,
1265            5 => CssSectionType::Selector,
1266            6 => CssSectionType::Declaration,
1267            7 => CssSectionType::Value,
1268            8 => CssSectionType::Keyframes,
1269            value => CssSectionType::__Unknown(value),
1270        }
1271    }
1272}
1273
1274impl StaticType for CssSectionType {
1275    fn static_type() -> Type {
1276        unsafe { from_glib(gtk_sys::gtk_css_section_type_get_type()) }
1277    }
1278}
1279
1280impl<'a> FromValueOptional<'a> for CssSectionType {
1281    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
1282        Some(FromValue::from_value(value))
1283    }
1284}
1285
1286impl<'a> FromValue<'a> for CssSectionType {
1287    unsafe fn from_value(value: &Value) -> Self {
1288        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
1289    }
1290}
1291
1292impl SetValue for CssSectionType {
1293    unsafe fn set_value(value: &mut Value, this: &Self) {
1294        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
1295    }
1296}
1297
1298#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1299pub enum DeleteType {
1300    Chars,
1301    WordEnds,
1302    Words,
1303    DisplayLines,
1304    DisplayLineEnds,
1305    ParagraphEnds,
1306    Paragraphs,
1307    Whitespace,
1308    #[doc(hidden)]
1309    __Unknown(i32),
1310}
1311
1312impl fmt::Display for DeleteType {
1313    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1314        write!(
1315            f,
1316            "DeleteType::{}",
1317            match *self {
1318                DeleteType::Chars => "Chars",
1319                DeleteType::WordEnds => "WordEnds",
1320                DeleteType::Words => "Words",
1321                DeleteType::DisplayLines => "DisplayLines",
1322                DeleteType::DisplayLineEnds => "DisplayLineEnds",
1323                DeleteType::ParagraphEnds => "ParagraphEnds",
1324                DeleteType::Paragraphs => "Paragraphs",
1325                DeleteType::Whitespace => "Whitespace",
1326                _ => "Unknown",
1327            }
1328        )
1329    }
1330}
1331
1332#[doc(hidden)]
1333impl ToGlib for DeleteType {
1334    type GlibType = gtk_sys::GtkDeleteType;
1335
1336    fn to_glib(&self) -> gtk_sys::GtkDeleteType {
1337        match *self {
1338            DeleteType::Chars => gtk_sys::GTK_DELETE_CHARS,
1339            DeleteType::WordEnds => gtk_sys::GTK_DELETE_WORD_ENDS,
1340            DeleteType::Words => gtk_sys::GTK_DELETE_WORDS,
1341            DeleteType::DisplayLines => gtk_sys::GTK_DELETE_DISPLAY_LINES,
1342            DeleteType::DisplayLineEnds => gtk_sys::GTK_DELETE_DISPLAY_LINE_ENDS,
1343            DeleteType::ParagraphEnds => gtk_sys::GTK_DELETE_PARAGRAPH_ENDS,
1344            DeleteType::Paragraphs => gtk_sys::GTK_DELETE_PARAGRAPHS,
1345            DeleteType::Whitespace => gtk_sys::GTK_DELETE_WHITESPACE,
1346            DeleteType::__Unknown(value) => value,
1347        }
1348    }
1349}
1350
1351#[doc(hidden)]
1352impl FromGlib<gtk_sys::GtkDeleteType> for DeleteType {
1353    fn from_glib(value: gtk_sys::GtkDeleteType) -> Self {
1354        skip_assert_initialized!();
1355        match value {
1356            0 => DeleteType::Chars,
1357            1 => DeleteType::WordEnds,
1358            2 => DeleteType::Words,
1359            3 => DeleteType::DisplayLines,
1360            4 => DeleteType::DisplayLineEnds,
1361            5 => DeleteType::ParagraphEnds,
1362            6 => DeleteType::Paragraphs,
1363            7 => DeleteType::Whitespace,
1364            value => DeleteType::__Unknown(value),
1365        }
1366    }
1367}
1368
1369impl StaticType for DeleteType {
1370    fn static_type() -> Type {
1371        unsafe { from_glib(gtk_sys::gtk_delete_type_get_type()) }
1372    }
1373}
1374
1375impl<'a> FromValueOptional<'a> for DeleteType {
1376    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
1377        Some(FromValue::from_value(value))
1378    }
1379}
1380
1381impl<'a> FromValue<'a> for DeleteType {
1382    unsafe fn from_value(value: &Value) -> Self {
1383        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
1384    }
1385}
1386
1387impl SetValue for DeleteType {
1388    unsafe fn set_value(value: &mut Value, this: &Self) {
1389        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
1390    }
1391}
1392
1393#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1394pub enum DirectionType {
1395    TabForward,
1396    TabBackward,
1397    Up,
1398    Down,
1399    Left,
1400    Right,
1401    #[doc(hidden)]
1402    __Unknown(i32),
1403}
1404
1405impl fmt::Display for DirectionType {
1406    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1407        write!(
1408            f,
1409            "DirectionType::{}",
1410            match *self {
1411                DirectionType::TabForward => "TabForward",
1412                DirectionType::TabBackward => "TabBackward",
1413                DirectionType::Up => "Up",
1414                DirectionType::Down => "Down",
1415                DirectionType::Left => "Left",
1416                DirectionType::Right => "Right",
1417                _ => "Unknown",
1418            }
1419        )
1420    }
1421}
1422
1423#[doc(hidden)]
1424impl ToGlib for DirectionType {
1425    type GlibType = gtk_sys::GtkDirectionType;
1426
1427    fn to_glib(&self) -> gtk_sys::GtkDirectionType {
1428        match *self {
1429            DirectionType::TabForward => gtk_sys::GTK_DIR_TAB_FORWARD,
1430            DirectionType::TabBackward => gtk_sys::GTK_DIR_TAB_BACKWARD,
1431            DirectionType::Up => gtk_sys::GTK_DIR_UP,
1432            DirectionType::Down => gtk_sys::GTK_DIR_DOWN,
1433            DirectionType::Left => gtk_sys::GTK_DIR_LEFT,
1434            DirectionType::Right => gtk_sys::GTK_DIR_RIGHT,
1435            DirectionType::__Unknown(value) => value,
1436        }
1437    }
1438}
1439
1440#[doc(hidden)]
1441impl FromGlib<gtk_sys::GtkDirectionType> for DirectionType {
1442    fn from_glib(value: gtk_sys::GtkDirectionType) -> Self {
1443        skip_assert_initialized!();
1444        match value {
1445            0 => DirectionType::TabForward,
1446            1 => DirectionType::TabBackward,
1447            2 => DirectionType::Up,
1448            3 => DirectionType::Down,
1449            4 => DirectionType::Left,
1450            5 => DirectionType::Right,
1451            value => DirectionType::__Unknown(value),
1452        }
1453    }
1454}
1455
1456impl StaticType for DirectionType {
1457    fn static_type() -> Type {
1458        unsafe { from_glib(gtk_sys::gtk_direction_type_get_type()) }
1459    }
1460}
1461
1462impl<'a> FromValueOptional<'a> for DirectionType {
1463    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
1464        Some(FromValue::from_value(value))
1465    }
1466}
1467
1468impl<'a> FromValue<'a> for DirectionType {
1469    unsafe fn from_value(value: &Value) -> Self {
1470        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
1471    }
1472}
1473
1474impl SetValue for DirectionType {
1475    unsafe fn set_value(value: &mut Value, this: &Self) {
1476        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
1477    }
1478}
1479
1480#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1481pub enum DragResult {
1482    Success,
1483    NoTarget,
1484    UserCancelled,
1485    TimeoutExpired,
1486    GrabBroken,
1487    Error,
1488    #[doc(hidden)]
1489    __Unknown(i32),
1490}
1491
1492impl fmt::Display for DragResult {
1493    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1494        write!(
1495            f,
1496            "DragResult::{}",
1497            match *self {
1498                DragResult::Success => "Success",
1499                DragResult::NoTarget => "NoTarget",
1500                DragResult::UserCancelled => "UserCancelled",
1501                DragResult::TimeoutExpired => "TimeoutExpired",
1502                DragResult::GrabBroken => "GrabBroken",
1503                DragResult::Error => "Error",
1504                _ => "Unknown",
1505            }
1506        )
1507    }
1508}
1509
1510#[doc(hidden)]
1511impl ToGlib for DragResult {
1512    type GlibType = gtk_sys::GtkDragResult;
1513
1514    fn to_glib(&self) -> gtk_sys::GtkDragResult {
1515        match *self {
1516            DragResult::Success => gtk_sys::GTK_DRAG_RESULT_SUCCESS,
1517            DragResult::NoTarget => gtk_sys::GTK_DRAG_RESULT_NO_TARGET,
1518            DragResult::UserCancelled => gtk_sys::GTK_DRAG_RESULT_USER_CANCELLED,
1519            DragResult::TimeoutExpired => gtk_sys::GTK_DRAG_RESULT_TIMEOUT_EXPIRED,
1520            DragResult::GrabBroken => gtk_sys::GTK_DRAG_RESULT_GRAB_BROKEN,
1521            DragResult::Error => gtk_sys::GTK_DRAG_RESULT_ERROR,
1522            DragResult::__Unknown(value) => value,
1523        }
1524    }
1525}
1526
1527#[doc(hidden)]
1528impl FromGlib<gtk_sys::GtkDragResult> for DragResult {
1529    fn from_glib(value: gtk_sys::GtkDragResult) -> Self {
1530        skip_assert_initialized!();
1531        match value {
1532            0 => DragResult::Success,
1533            1 => DragResult::NoTarget,
1534            2 => DragResult::UserCancelled,
1535            3 => DragResult::TimeoutExpired,
1536            4 => DragResult::GrabBroken,
1537            5 => DragResult::Error,
1538            value => DragResult::__Unknown(value),
1539        }
1540    }
1541}
1542
1543impl StaticType for DragResult {
1544    fn static_type() -> Type {
1545        unsafe { from_glib(gtk_sys::gtk_drag_result_get_type()) }
1546    }
1547}
1548
1549impl<'a> FromValueOptional<'a> for DragResult {
1550    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
1551        Some(FromValue::from_value(value))
1552    }
1553}
1554
1555impl<'a> FromValue<'a> for DragResult {
1556    unsafe fn from_value(value: &Value) -> Self {
1557        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
1558    }
1559}
1560
1561impl SetValue for DragResult {
1562    unsafe fn set_value(value: &mut Value, this: &Self) {
1563        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
1564    }
1565}
1566
1567#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1568pub enum EntryIconPosition {
1569    Primary,
1570    Secondary,
1571    #[doc(hidden)]
1572    __Unknown(i32),
1573}
1574
1575impl fmt::Display for EntryIconPosition {
1576    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1577        write!(
1578            f,
1579            "EntryIconPosition::{}",
1580            match *self {
1581                EntryIconPosition::Primary => "Primary",
1582                EntryIconPosition::Secondary => "Secondary",
1583                _ => "Unknown",
1584            }
1585        )
1586    }
1587}
1588
1589#[doc(hidden)]
1590impl ToGlib for EntryIconPosition {
1591    type GlibType = gtk_sys::GtkEntryIconPosition;
1592
1593    fn to_glib(&self) -> gtk_sys::GtkEntryIconPosition {
1594        match *self {
1595            EntryIconPosition::Primary => gtk_sys::GTK_ENTRY_ICON_PRIMARY,
1596            EntryIconPosition::Secondary => gtk_sys::GTK_ENTRY_ICON_SECONDARY,
1597            EntryIconPosition::__Unknown(value) => value,
1598        }
1599    }
1600}
1601
1602#[doc(hidden)]
1603impl FromGlib<gtk_sys::GtkEntryIconPosition> for EntryIconPosition {
1604    fn from_glib(value: gtk_sys::GtkEntryIconPosition) -> Self {
1605        skip_assert_initialized!();
1606        match value {
1607            0 => EntryIconPosition::Primary,
1608            1 => EntryIconPosition::Secondary,
1609            value => EntryIconPosition::__Unknown(value),
1610        }
1611    }
1612}
1613
1614impl StaticType for EntryIconPosition {
1615    fn static_type() -> Type {
1616        unsafe { from_glib(gtk_sys::gtk_entry_icon_position_get_type()) }
1617    }
1618}
1619
1620impl<'a> FromValueOptional<'a> for EntryIconPosition {
1621    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
1622        Some(FromValue::from_value(value))
1623    }
1624}
1625
1626impl<'a> FromValue<'a> for EntryIconPosition {
1627    unsafe fn from_value(value: &Value) -> Self {
1628        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
1629    }
1630}
1631
1632impl SetValue for EntryIconPosition {
1633    unsafe fn set_value(value: &mut Value, this: &Self) {
1634        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
1635    }
1636}
1637
1638#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1639pub enum EventSequenceState {
1640    None,
1641    Claimed,
1642    Denied,
1643    #[doc(hidden)]
1644    __Unknown(i32),
1645}
1646
1647impl fmt::Display for EventSequenceState {
1648    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1649        write!(
1650            f,
1651            "EventSequenceState::{}",
1652            match *self {
1653                EventSequenceState::None => "None",
1654                EventSequenceState::Claimed => "Claimed",
1655                EventSequenceState::Denied => "Denied",
1656                _ => "Unknown",
1657            }
1658        )
1659    }
1660}
1661
1662#[doc(hidden)]
1663impl ToGlib for EventSequenceState {
1664    type GlibType = gtk_sys::GtkEventSequenceState;
1665
1666    fn to_glib(&self) -> gtk_sys::GtkEventSequenceState {
1667        match *self {
1668            EventSequenceState::None => gtk_sys::GTK_EVENT_SEQUENCE_NONE,
1669            EventSequenceState::Claimed => gtk_sys::GTK_EVENT_SEQUENCE_CLAIMED,
1670            EventSequenceState::Denied => gtk_sys::GTK_EVENT_SEQUENCE_DENIED,
1671            EventSequenceState::__Unknown(value) => value,
1672        }
1673    }
1674}
1675
1676#[doc(hidden)]
1677impl FromGlib<gtk_sys::GtkEventSequenceState> for EventSequenceState {
1678    fn from_glib(value: gtk_sys::GtkEventSequenceState) -> Self {
1679        skip_assert_initialized!();
1680        match value {
1681            0 => EventSequenceState::None,
1682            1 => EventSequenceState::Claimed,
1683            2 => EventSequenceState::Denied,
1684            value => EventSequenceState::__Unknown(value),
1685        }
1686    }
1687}
1688
1689impl StaticType for EventSequenceState {
1690    fn static_type() -> Type {
1691        unsafe { from_glib(gtk_sys::gtk_event_sequence_state_get_type()) }
1692    }
1693}
1694
1695impl<'a> FromValueOptional<'a> for EventSequenceState {
1696    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
1697        Some(FromValue::from_value(value))
1698    }
1699}
1700
1701impl<'a> FromValue<'a> for EventSequenceState {
1702    unsafe fn from_value(value: &Value) -> Self {
1703        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
1704    }
1705}
1706
1707impl SetValue for EventSequenceState {
1708    unsafe fn set_value(value: &mut Value, this: &Self) {
1709        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
1710    }
1711}
1712
1713#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1714pub enum FileChooserAction {
1715    Open,
1716    Save,
1717    SelectFolder,
1718    CreateFolder,
1719    #[doc(hidden)]
1720    __Unknown(i32),
1721}
1722
1723impl fmt::Display for FileChooserAction {
1724    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1725        write!(
1726            f,
1727            "FileChooserAction::{}",
1728            match *self {
1729                FileChooserAction::Open => "Open",
1730                FileChooserAction::Save => "Save",
1731                FileChooserAction::SelectFolder => "SelectFolder",
1732                FileChooserAction::CreateFolder => "CreateFolder",
1733                _ => "Unknown",
1734            }
1735        )
1736    }
1737}
1738
1739#[doc(hidden)]
1740impl ToGlib for FileChooserAction {
1741    type GlibType = gtk_sys::GtkFileChooserAction;
1742
1743    fn to_glib(&self) -> gtk_sys::GtkFileChooserAction {
1744        match *self {
1745            FileChooserAction::Open => gtk_sys::GTK_FILE_CHOOSER_ACTION_OPEN,
1746            FileChooserAction::Save => gtk_sys::GTK_FILE_CHOOSER_ACTION_SAVE,
1747            FileChooserAction::SelectFolder => gtk_sys::GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
1748            FileChooserAction::CreateFolder => gtk_sys::GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER,
1749            FileChooserAction::__Unknown(value) => value,
1750        }
1751    }
1752}
1753
1754#[doc(hidden)]
1755impl FromGlib<gtk_sys::GtkFileChooserAction> for FileChooserAction {
1756    fn from_glib(value: gtk_sys::GtkFileChooserAction) -> Self {
1757        skip_assert_initialized!();
1758        match value {
1759            0 => FileChooserAction::Open,
1760            1 => FileChooserAction::Save,
1761            2 => FileChooserAction::SelectFolder,
1762            3 => FileChooserAction::CreateFolder,
1763            value => FileChooserAction::__Unknown(value),
1764        }
1765    }
1766}
1767
1768impl StaticType for FileChooserAction {
1769    fn static_type() -> Type {
1770        unsafe { from_glib(gtk_sys::gtk_file_chooser_action_get_type()) }
1771    }
1772}
1773
1774impl<'a> FromValueOptional<'a> for FileChooserAction {
1775    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
1776        Some(FromValue::from_value(value))
1777    }
1778}
1779
1780impl<'a> FromValue<'a> for FileChooserAction {
1781    unsafe fn from_value(value: &Value) -> Self {
1782        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
1783    }
1784}
1785
1786impl SetValue for FileChooserAction {
1787    unsafe fn set_value(value: &mut Value, this: &Self) {
1788        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
1789    }
1790}
1791
1792#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1793pub enum FileChooserConfirmation {
1794    Confirm,
1795    AcceptFilename,
1796    SelectAgain,
1797    #[doc(hidden)]
1798    __Unknown(i32),
1799}
1800
1801impl fmt::Display for FileChooserConfirmation {
1802    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1803        write!(
1804            f,
1805            "FileChooserConfirmation::{}",
1806            match *self {
1807                FileChooserConfirmation::Confirm => "Confirm",
1808                FileChooserConfirmation::AcceptFilename => "AcceptFilename",
1809                FileChooserConfirmation::SelectAgain => "SelectAgain",
1810                _ => "Unknown",
1811            }
1812        )
1813    }
1814}
1815
1816#[doc(hidden)]
1817impl ToGlib for FileChooserConfirmation {
1818    type GlibType = gtk_sys::GtkFileChooserConfirmation;
1819
1820    fn to_glib(&self) -> gtk_sys::GtkFileChooserConfirmation {
1821        match *self {
1822            FileChooserConfirmation::Confirm => gtk_sys::GTK_FILE_CHOOSER_CONFIRMATION_CONFIRM,
1823            FileChooserConfirmation::AcceptFilename => {
1824                gtk_sys::GTK_FILE_CHOOSER_CONFIRMATION_ACCEPT_FILENAME
1825            }
1826            FileChooserConfirmation::SelectAgain => {
1827                gtk_sys::GTK_FILE_CHOOSER_CONFIRMATION_SELECT_AGAIN
1828            }
1829            FileChooserConfirmation::__Unknown(value) => value,
1830        }
1831    }
1832}
1833
1834#[doc(hidden)]
1835impl FromGlib<gtk_sys::GtkFileChooserConfirmation> for FileChooserConfirmation {
1836    fn from_glib(value: gtk_sys::GtkFileChooserConfirmation) -> Self {
1837        skip_assert_initialized!();
1838        match value {
1839            0 => FileChooserConfirmation::Confirm,
1840            1 => FileChooserConfirmation::AcceptFilename,
1841            2 => FileChooserConfirmation::SelectAgain,
1842            value => FileChooserConfirmation::__Unknown(value),
1843        }
1844    }
1845}
1846
1847impl StaticType for FileChooserConfirmation {
1848    fn static_type() -> Type {
1849        unsafe { from_glib(gtk_sys::gtk_file_chooser_confirmation_get_type()) }
1850    }
1851}
1852
1853impl<'a> FromValueOptional<'a> for FileChooserConfirmation {
1854    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
1855        Some(FromValue::from_value(value))
1856    }
1857}
1858
1859impl<'a> FromValue<'a> for FileChooserConfirmation {
1860    unsafe fn from_value(value: &Value) -> Self {
1861        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
1862    }
1863}
1864
1865impl SetValue for FileChooserConfirmation {
1866    unsafe fn set_value(value: &mut Value, this: &Self) {
1867        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
1868    }
1869}
1870
1871#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1872pub enum FileChooserError {
1873    Nonexistent,
1874    BadFilename,
1875    AlreadyExists,
1876    IncompleteHostname,
1877    #[doc(hidden)]
1878    __Unknown(i32),
1879}
1880
1881impl fmt::Display for FileChooserError {
1882    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1883        write!(
1884            f,
1885            "FileChooserError::{}",
1886            match *self {
1887                FileChooserError::Nonexistent => "Nonexistent",
1888                FileChooserError::BadFilename => "BadFilename",
1889                FileChooserError::AlreadyExists => "AlreadyExists",
1890                FileChooserError::IncompleteHostname => "IncompleteHostname",
1891                _ => "Unknown",
1892            }
1893        )
1894    }
1895}
1896
1897#[doc(hidden)]
1898impl ToGlib for FileChooserError {
1899    type GlibType = gtk_sys::GtkFileChooserError;
1900
1901    fn to_glib(&self) -> gtk_sys::GtkFileChooserError {
1902        match *self {
1903            FileChooserError::Nonexistent => gtk_sys::GTK_FILE_CHOOSER_ERROR_NONEXISTENT,
1904            FileChooserError::BadFilename => gtk_sys::GTK_FILE_CHOOSER_ERROR_BAD_FILENAME,
1905            FileChooserError::AlreadyExists => gtk_sys::GTK_FILE_CHOOSER_ERROR_ALREADY_EXISTS,
1906            FileChooserError::IncompleteHostname => {
1907                gtk_sys::GTK_FILE_CHOOSER_ERROR_INCOMPLETE_HOSTNAME
1908            }
1909            FileChooserError::__Unknown(value) => value,
1910        }
1911    }
1912}
1913
1914#[doc(hidden)]
1915impl FromGlib<gtk_sys::GtkFileChooserError> for FileChooserError {
1916    fn from_glib(value: gtk_sys::GtkFileChooserError) -> Self {
1917        skip_assert_initialized!();
1918        match value {
1919            0 => FileChooserError::Nonexistent,
1920            1 => FileChooserError::BadFilename,
1921            2 => FileChooserError::AlreadyExists,
1922            3 => FileChooserError::IncompleteHostname,
1923            value => FileChooserError::__Unknown(value),
1924        }
1925    }
1926}
1927
1928impl ErrorDomain for FileChooserError {
1929    fn domain() -> Quark {
1930        skip_assert_initialized!();
1931        unsafe { from_glib(gtk_sys::gtk_file_chooser_error_quark()) }
1932    }
1933
1934    fn code(self) -> i32 {
1935        self.to_glib()
1936    }
1937
1938    fn from(code: i32) -> Option<Self> {
1939        skip_assert_initialized!();
1940        match code {
1941            0 => Some(FileChooserError::Nonexistent),
1942            1 => Some(FileChooserError::BadFilename),
1943            2 => Some(FileChooserError::AlreadyExists),
1944            3 => Some(FileChooserError::IncompleteHostname),
1945            value => Some(FileChooserError::__Unknown(value)),
1946        }
1947    }
1948}
1949
1950impl StaticType for FileChooserError {
1951    fn static_type() -> Type {
1952        unsafe { from_glib(gtk_sys::gtk_file_chooser_error_get_type()) }
1953    }
1954}
1955
1956impl<'a> FromValueOptional<'a> for FileChooserError {
1957    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
1958        Some(FromValue::from_value(value))
1959    }
1960}
1961
1962impl<'a> FromValue<'a> for FileChooserError {
1963    unsafe fn from_value(value: &Value) -> Self {
1964        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
1965    }
1966}
1967
1968impl SetValue for FileChooserError {
1969    unsafe fn set_value(value: &mut Value, this: &Self) {
1970        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
1971    }
1972}
1973
1974#[deprecated]
1975#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1976pub enum IMPreeditStyle {
1977    Nothing,
1978    Callback,
1979    None,
1980    #[doc(hidden)]
1981    __Unknown(i32),
1982}
1983
1984#[deprecated]
1985impl fmt::Display for IMPreeditStyle {
1986    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1987        write!(
1988            f,
1989            "IMPreeditStyle::{}",
1990            match *self {
1991                IMPreeditStyle::Nothing => "Nothing",
1992                IMPreeditStyle::Callback => "Callback",
1993                IMPreeditStyle::None => "None",
1994                _ => "Unknown",
1995            }
1996        )
1997    }
1998}
1999
2000#[deprecated]
2001#[doc(hidden)]
2002impl ToGlib for IMPreeditStyle {
2003    type GlibType = gtk_sys::GtkIMPreeditStyle;
2004
2005    fn to_glib(&self) -> gtk_sys::GtkIMPreeditStyle {
2006        match *self {
2007            IMPreeditStyle::Nothing => gtk_sys::GTK_IM_PREEDIT_NOTHING,
2008            IMPreeditStyle::Callback => gtk_sys::GTK_IM_PREEDIT_CALLBACK,
2009            IMPreeditStyle::None => gtk_sys::GTK_IM_PREEDIT_NONE,
2010            IMPreeditStyle::__Unknown(value) => value,
2011        }
2012    }
2013}
2014
2015#[deprecated]
2016#[doc(hidden)]
2017impl FromGlib<gtk_sys::GtkIMPreeditStyle> for IMPreeditStyle {
2018    fn from_glib(value: gtk_sys::GtkIMPreeditStyle) -> Self {
2019        skip_assert_initialized!();
2020        match value {
2021            0 => IMPreeditStyle::Nothing,
2022            1 => IMPreeditStyle::Callback,
2023            2 => IMPreeditStyle::None,
2024            value => IMPreeditStyle::__Unknown(value),
2025        }
2026    }
2027}
2028
2029#[deprecated]
2030impl StaticType for IMPreeditStyle {
2031    fn static_type() -> Type {
2032        unsafe { from_glib(gtk_sys::gtk_im_preedit_style_get_type()) }
2033    }
2034}
2035
2036#[deprecated]
2037impl<'a> FromValueOptional<'a> for IMPreeditStyle {
2038    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
2039        Some(FromValue::from_value(value))
2040    }
2041}
2042
2043#[deprecated]
2044impl<'a> FromValue<'a> for IMPreeditStyle {
2045    unsafe fn from_value(value: &Value) -> Self {
2046        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
2047    }
2048}
2049
2050#[deprecated]
2051impl SetValue for IMPreeditStyle {
2052    unsafe fn set_value(value: &mut Value, this: &Self) {
2053        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
2054    }
2055}
2056
2057#[deprecated]
2058#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2059pub enum IMStatusStyle {
2060    Nothing,
2061    Callback,
2062    None,
2063    #[doc(hidden)]
2064    __Unknown(i32),
2065}
2066
2067#[deprecated]
2068impl fmt::Display for IMStatusStyle {
2069    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2070        write!(
2071            f,
2072            "IMStatusStyle::{}",
2073            match *self {
2074                IMStatusStyle::Nothing => "Nothing",
2075                IMStatusStyle::Callback => "Callback",
2076                IMStatusStyle::None => "None",
2077                _ => "Unknown",
2078            }
2079        )
2080    }
2081}
2082
2083#[deprecated]
2084#[doc(hidden)]
2085impl ToGlib for IMStatusStyle {
2086    type GlibType = gtk_sys::GtkIMStatusStyle;
2087
2088    fn to_glib(&self) -> gtk_sys::GtkIMStatusStyle {
2089        match *self {
2090            IMStatusStyle::Nothing => gtk_sys::GTK_IM_STATUS_NOTHING,
2091            IMStatusStyle::Callback => gtk_sys::GTK_IM_STATUS_CALLBACK,
2092            IMStatusStyle::None => gtk_sys::GTK_IM_STATUS_NONE,
2093            IMStatusStyle::__Unknown(value) => value,
2094        }
2095    }
2096}
2097
2098#[deprecated]
2099#[doc(hidden)]
2100impl FromGlib<gtk_sys::GtkIMStatusStyle> for IMStatusStyle {
2101    fn from_glib(value: gtk_sys::GtkIMStatusStyle) -> Self {
2102        skip_assert_initialized!();
2103        match value {
2104            0 => IMStatusStyle::Nothing,
2105            1 => IMStatusStyle::Callback,
2106            2 => IMStatusStyle::None,
2107            value => IMStatusStyle::__Unknown(value),
2108        }
2109    }
2110}
2111
2112#[deprecated]
2113impl StaticType for IMStatusStyle {
2114    fn static_type() -> Type {
2115        unsafe { from_glib(gtk_sys::gtk_im_status_style_get_type()) }
2116    }
2117}
2118
2119#[deprecated]
2120impl<'a> FromValueOptional<'a> for IMStatusStyle {
2121    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
2122        Some(FromValue::from_value(value))
2123    }
2124}
2125
2126#[deprecated]
2127impl<'a> FromValue<'a> for IMStatusStyle {
2128    unsafe fn from_value(value: &Value) -> Self {
2129        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
2130    }
2131}
2132
2133#[deprecated]
2134impl SetValue for IMStatusStyle {
2135    unsafe fn set_value(value: &mut Value, this: &Self) {
2136        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
2137    }
2138}
2139
2140#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2141pub enum IconSize {
2142    Invalid,
2143    Menu,
2144    SmallToolbar,
2145    LargeToolbar,
2146    Button,
2147    Dnd,
2148    Dialog,
2149    #[doc(hidden)]
2150    __Unknown(i32),
2151}
2152
2153impl fmt::Display for IconSize {
2154    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2155        write!(
2156            f,
2157            "IconSize::{}",
2158            match *self {
2159                IconSize::Invalid => "Invalid",
2160                IconSize::Menu => "Menu",
2161                IconSize::SmallToolbar => "SmallToolbar",
2162                IconSize::LargeToolbar => "LargeToolbar",
2163                IconSize::Button => "Button",
2164                IconSize::Dnd => "Dnd",
2165                IconSize::Dialog => "Dialog",
2166                _ => "Unknown",
2167            }
2168        )
2169    }
2170}
2171
2172#[doc(hidden)]
2173impl ToGlib for IconSize {
2174    type GlibType = gtk_sys::GtkIconSize;
2175
2176    fn to_glib(&self) -> gtk_sys::GtkIconSize {
2177        match *self {
2178            IconSize::Invalid => gtk_sys::GTK_ICON_SIZE_INVALID,
2179            IconSize::Menu => gtk_sys::GTK_ICON_SIZE_MENU,
2180            IconSize::SmallToolbar => gtk_sys::GTK_ICON_SIZE_SMALL_TOOLBAR,
2181            IconSize::LargeToolbar => gtk_sys::GTK_ICON_SIZE_LARGE_TOOLBAR,
2182            IconSize::Button => gtk_sys::GTK_ICON_SIZE_BUTTON,
2183            IconSize::Dnd => gtk_sys::GTK_ICON_SIZE_DND,
2184            IconSize::Dialog => gtk_sys::GTK_ICON_SIZE_DIALOG,
2185            IconSize::__Unknown(value) => value,
2186        }
2187    }
2188}
2189
2190#[doc(hidden)]
2191impl FromGlib<gtk_sys::GtkIconSize> for IconSize {
2192    fn from_glib(value: gtk_sys::GtkIconSize) -> Self {
2193        skip_assert_initialized!();
2194        match value {
2195            0 => IconSize::Invalid,
2196            1 => IconSize::Menu,
2197            2 => IconSize::SmallToolbar,
2198            3 => IconSize::LargeToolbar,
2199            4 => IconSize::Button,
2200            5 => IconSize::Dnd,
2201            6 => IconSize::Dialog,
2202            value => IconSize::__Unknown(value),
2203        }
2204    }
2205}
2206
2207impl StaticType for IconSize {
2208    fn static_type() -> Type {
2209        unsafe { from_glib(gtk_sys::gtk_icon_size_get_type()) }
2210    }
2211}
2212
2213impl<'a> FromValueOptional<'a> for IconSize {
2214    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
2215        Some(FromValue::from_value(value))
2216    }
2217}
2218
2219impl<'a> FromValue<'a> for IconSize {
2220    unsafe fn from_value(value: &Value) -> Self {
2221        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
2222    }
2223}
2224
2225impl SetValue for IconSize {
2226    unsafe fn set_value(value: &mut Value, this: &Self) {
2227        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
2228    }
2229}
2230
2231#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2232pub enum IconThemeError {
2233    NotFound,
2234    Failed,
2235    #[doc(hidden)]
2236    __Unknown(i32),
2237}
2238
2239impl fmt::Display for IconThemeError {
2240    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2241        write!(
2242            f,
2243            "IconThemeError::{}",
2244            match *self {
2245                IconThemeError::NotFound => "NotFound",
2246                IconThemeError::Failed => "Failed",
2247                _ => "Unknown",
2248            }
2249        )
2250    }
2251}
2252
2253#[doc(hidden)]
2254impl ToGlib for IconThemeError {
2255    type GlibType = gtk_sys::GtkIconThemeError;
2256
2257    fn to_glib(&self) -> gtk_sys::GtkIconThemeError {
2258        match *self {
2259            IconThemeError::NotFound => gtk_sys::GTK_ICON_THEME_NOT_FOUND,
2260            IconThemeError::Failed => gtk_sys::GTK_ICON_THEME_FAILED,
2261            IconThemeError::__Unknown(value) => value,
2262        }
2263    }
2264}
2265
2266#[doc(hidden)]
2267impl FromGlib<gtk_sys::GtkIconThemeError> for IconThemeError {
2268    fn from_glib(value: gtk_sys::GtkIconThemeError) -> Self {
2269        skip_assert_initialized!();
2270        match value {
2271            0 => IconThemeError::NotFound,
2272            1 => IconThemeError::Failed,
2273            value => IconThemeError::__Unknown(value),
2274        }
2275    }
2276}
2277
2278impl ErrorDomain for IconThemeError {
2279    fn domain() -> Quark {
2280        skip_assert_initialized!();
2281        unsafe { from_glib(gtk_sys::gtk_icon_theme_error_quark()) }
2282    }
2283
2284    fn code(self) -> i32 {
2285        self.to_glib()
2286    }
2287
2288    fn from(code: i32) -> Option<Self> {
2289        skip_assert_initialized!();
2290        match code {
2291            0 => Some(IconThemeError::NotFound),
2292            1 => Some(IconThemeError::Failed),
2293            _ => Some(IconThemeError::Failed),
2294        }
2295    }
2296}
2297
2298impl StaticType for IconThemeError {
2299    fn static_type() -> Type {
2300        unsafe { from_glib(gtk_sys::gtk_icon_theme_error_get_type()) }
2301    }
2302}
2303
2304impl<'a> FromValueOptional<'a> for IconThemeError {
2305    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
2306        Some(FromValue::from_value(value))
2307    }
2308}
2309
2310impl<'a> FromValue<'a> for IconThemeError {
2311    unsafe fn from_value(value: &Value) -> Self {
2312        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
2313    }
2314}
2315
2316impl SetValue for IconThemeError {
2317    unsafe fn set_value(value: &mut Value, this: &Self) {
2318        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
2319    }
2320}
2321
2322#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2323pub enum IconViewDropPosition {
2324    NoDrop,
2325    DropInto,
2326    DropLeft,
2327    DropRight,
2328    DropAbove,
2329    DropBelow,
2330    #[doc(hidden)]
2331    __Unknown(i32),
2332}
2333
2334impl fmt::Display for IconViewDropPosition {
2335    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2336        write!(
2337            f,
2338            "IconViewDropPosition::{}",
2339            match *self {
2340                IconViewDropPosition::NoDrop => "NoDrop",
2341                IconViewDropPosition::DropInto => "DropInto",
2342                IconViewDropPosition::DropLeft => "DropLeft",
2343                IconViewDropPosition::DropRight => "DropRight",
2344                IconViewDropPosition::DropAbove => "DropAbove",
2345                IconViewDropPosition::DropBelow => "DropBelow",
2346                _ => "Unknown",
2347            }
2348        )
2349    }
2350}
2351
2352#[doc(hidden)]
2353impl ToGlib for IconViewDropPosition {
2354    type GlibType = gtk_sys::GtkIconViewDropPosition;
2355
2356    fn to_glib(&self) -> gtk_sys::GtkIconViewDropPosition {
2357        match *self {
2358            IconViewDropPosition::NoDrop => gtk_sys::GTK_ICON_VIEW_NO_DROP,
2359            IconViewDropPosition::DropInto => gtk_sys::GTK_ICON_VIEW_DROP_INTO,
2360            IconViewDropPosition::DropLeft => gtk_sys::GTK_ICON_VIEW_DROP_LEFT,
2361            IconViewDropPosition::DropRight => gtk_sys::GTK_ICON_VIEW_DROP_RIGHT,
2362            IconViewDropPosition::DropAbove => gtk_sys::GTK_ICON_VIEW_DROP_ABOVE,
2363            IconViewDropPosition::DropBelow => gtk_sys::GTK_ICON_VIEW_DROP_BELOW,
2364            IconViewDropPosition::__Unknown(value) => value,
2365        }
2366    }
2367}
2368
2369#[doc(hidden)]
2370impl FromGlib<gtk_sys::GtkIconViewDropPosition> for IconViewDropPosition {
2371    fn from_glib(value: gtk_sys::GtkIconViewDropPosition) -> Self {
2372        skip_assert_initialized!();
2373        match value {
2374            0 => IconViewDropPosition::NoDrop,
2375            1 => IconViewDropPosition::DropInto,
2376            2 => IconViewDropPosition::DropLeft,
2377            3 => IconViewDropPosition::DropRight,
2378            4 => IconViewDropPosition::DropAbove,
2379            5 => IconViewDropPosition::DropBelow,
2380            value => IconViewDropPosition::__Unknown(value),
2381        }
2382    }
2383}
2384
2385impl StaticType for IconViewDropPosition {
2386    fn static_type() -> Type {
2387        unsafe { from_glib(gtk_sys::gtk_icon_view_drop_position_get_type()) }
2388    }
2389}
2390
2391impl<'a> FromValueOptional<'a> for IconViewDropPosition {
2392    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
2393        Some(FromValue::from_value(value))
2394    }
2395}
2396
2397impl<'a> FromValue<'a> for IconViewDropPosition {
2398    unsafe fn from_value(value: &Value) -> Self {
2399        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
2400    }
2401}
2402
2403impl SetValue for IconViewDropPosition {
2404    unsafe fn set_value(value: &mut Value, this: &Self) {
2405        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
2406    }
2407}
2408
2409#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2410pub enum ImageType {
2411    Empty,
2412    Pixbuf,
2413    Stock,
2414    IconSet,
2415    Animation,
2416    IconName,
2417    Gicon,
2418    Surface,
2419    #[doc(hidden)]
2420    __Unknown(i32),
2421}
2422
2423impl fmt::Display for ImageType {
2424    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2425        write!(
2426            f,
2427            "ImageType::{}",
2428            match *self {
2429                ImageType::Empty => "Empty",
2430                ImageType::Pixbuf => "Pixbuf",
2431                ImageType::Stock => "Stock",
2432                ImageType::IconSet => "IconSet",
2433                ImageType::Animation => "Animation",
2434                ImageType::IconName => "IconName",
2435                ImageType::Gicon => "Gicon",
2436                ImageType::Surface => "Surface",
2437                _ => "Unknown",
2438            }
2439        )
2440    }
2441}
2442
2443#[doc(hidden)]
2444impl ToGlib for ImageType {
2445    type GlibType = gtk_sys::GtkImageType;
2446
2447    fn to_glib(&self) -> gtk_sys::GtkImageType {
2448        match *self {
2449            ImageType::Empty => gtk_sys::GTK_IMAGE_EMPTY,
2450            ImageType::Pixbuf => gtk_sys::GTK_IMAGE_PIXBUF,
2451            ImageType::Stock => gtk_sys::GTK_IMAGE_STOCK,
2452            ImageType::IconSet => gtk_sys::GTK_IMAGE_ICON_SET,
2453            ImageType::Animation => gtk_sys::GTK_IMAGE_ANIMATION,
2454            ImageType::IconName => gtk_sys::GTK_IMAGE_ICON_NAME,
2455            ImageType::Gicon => gtk_sys::GTK_IMAGE_GICON,
2456            ImageType::Surface => gtk_sys::GTK_IMAGE_SURFACE,
2457            ImageType::__Unknown(value) => value,
2458        }
2459    }
2460}
2461
2462#[doc(hidden)]
2463impl FromGlib<gtk_sys::GtkImageType> for ImageType {
2464    fn from_glib(value: gtk_sys::GtkImageType) -> Self {
2465        skip_assert_initialized!();
2466        match value {
2467            0 => ImageType::Empty,
2468            1 => ImageType::Pixbuf,
2469            2 => ImageType::Stock,
2470            3 => ImageType::IconSet,
2471            4 => ImageType::Animation,
2472            5 => ImageType::IconName,
2473            6 => ImageType::Gicon,
2474            7 => ImageType::Surface,
2475            value => ImageType::__Unknown(value),
2476        }
2477    }
2478}
2479
2480impl StaticType for ImageType {
2481    fn static_type() -> Type {
2482        unsafe { from_glib(gtk_sys::gtk_image_type_get_type()) }
2483    }
2484}
2485
2486impl<'a> FromValueOptional<'a> for ImageType {
2487    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
2488        Some(FromValue::from_value(value))
2489    }
2490}
2491
2492impl<'a> FromValue<'a> for ImageType {
2493    unsafe fn from_value(value: &Value) -> Self {
2494        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
2495    }
2496}
2497
2498impl SetValue for ImageType {
2499    unsafe fn set_value(value: &mut Value, this: &Self) {
2500        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
2501    }
2502}
2503
2504#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2505pub enum InputPurpose {
2506    FreeForm,
2507    Alpha,
2508    Digits,
2509    Number,
2510    Phone,
2511    Url,
2512    Email,
2513    Name,
2514    Password,
2515    Pin,
2516    #[doc(hidden)]
2517    __Unknown(i32),
2518}
2519
2520impl fmt::Display for InputPurpose {
2521    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2522        write!(
2523            f,
2524            "InputPurpose::{}",
2525            match *self {
2526                InputPurpose::FreeForm => "FreeForm",
2527                InputPurpose::Alpha => "Alpha",
2528                InputPurpose::Digits => "Digits",
2529                InputPurpose::Number => "Number",
2530                InputPurpose::Phone => "Phone",
2531                InputPurpose::Url => "Url",
2532                InputPurpose::Email => "Email",
2533                InputPurpose::Name => "Name",
2534                InputPurpose::Password => "Password",
2535                InputPurpose::Pin => "Pin",
2536                _ => "Unknown",
2537            }
2538        )
2539    }
2540}
2541
2542#[doc(hidden)]
2543impl ToGlib for InputPurpose {
2544    type GlibType = gtk_sys::GtkInputPurpose;
2545
2546    fn to_glib(&self) -> gtk_sys::GtkInputPurpose {
2547        match *self {
2548            InputPurpose::FreeForm => gtk_sys::GTK_INPUT_PURPOSE_FREE_FORM,
2549            InputPurpose::Alpha => gtk_sys::GTK_INPUT_PURPOSE_ALPHA,
2550            InputPurpose::Digits => gtk_sys::GTK_INPUT_PURPOSE_DIGITS,
2551            InputPurpose::Number => gtk_sys::GTK_INPUT_PURPOSE_NUMBER,
2552            InputPurpose::Phone => gtk_sys::GTK_INPUT_PURPOSE_PHONE,
2553            InputPurpose::Url => gtk_sys::GTK_INPUT_PURPOSE_URL,
2554            InputPurpose::Email => gtk_sys::GTK_INPUT_PURPOSE_EMAIL,
2555            InputPurpose::Name => gtk_sys::GTK_INPUT_PURPOSE_NAME,
2556            InputPurpose::Password => gtk_sys::GTK_INPUT_PURPOSE_PASSWORD,
2557            InputPurpose::Pin => gtk_sys::GTK_INPUT_PURPOSE_PIN,
2558            InputPurpose::__Unknown(value) => value,
2559        }
2560    }
2561}
2562
2563#[doc(hidden)]
2564impl FromGlib<gtk_sys::GtkInputPurpose> for InputPurpose {
2565    fn from_glib(value: gtk_sys::GtkInputPurpose) -> Self {
2566        skip_assert_initialized!();
2567        match value {
2568            0 => InputPurpose::FreeForm,
2569            1 => InputPurpose::Alpha,
2570            2 => InputPurpose::Digits,
2571            3 => InputPurpose::Number,
2572            4 => InputPurpose::Phone,
2573            5 => InputPurpose::Url,
2574            6 => InputPurpose::Email,
2575            7 => InputPurpose::Name,
2576            8 => InputPurpose::Password,
2577            9 => InputPurpose::Pin,
2578            value => InputPurpose::__Unknown(value),
2579        }
2580    }
2581}
2582
2583impl StaticType for InputPurpose {
2584    fn static_type() -> Type {
2585        unsafe { from_glib(gtk_sys::gtk_input_purpose_get_type()) }
2586    }
2587}
2588
2589impl<'a> FromValueOptional<'a> for InputPurpose {
2590    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
2591        Some(FromValue::from_value(value))
2592    }
2593}
2594
2595impl<'a> FromValue<'a> for InputPurpose {
2596    unsafe fn from_value(value: &Value) -> Self {
2597        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
2598    }
2599}
2600
2601impl SetValue for InputPurpose {
2602    unsafe fn set_value(value: &mut Value, this: &Self) {
2603        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
2604    }
2605}
2606
2607#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2608pub enum Justification {
2609    Left,
2610    Right,
2611    Center,
2612    Fill,
2613    #[doc(hidden)]
2614    __Unknown(i32),
2615}
2616
2617impl fmt::Display for Justification {
2618    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2619        write!(
2620            f,
2621            "Justification::{}",
2622            match *self {
2623                Justification::Left => "Left",
2624                Justification::Right => "Right",
2625                Justification::Center => "Center",
2626                Justification::Fill => "Fill",
2627                _ => "Unknown",
2628            }
2629        )
2630    }
2631}
2632
2633#[doc(hidden)]
2634impl ToGlib for Justification {
2635    type GlibType = gtk_sys::GtkJustification;
2636
2637    fn to_glib(&self) -> gtk_sys::GtkJustification {
2638        match *self {
2639            Justification::Left => gtk_sys::GTK_JUSTIFY_LEFT,
2640            Justification::Right => gtk_sys::GTK_JUSTIFY_RIGHT,
2641            Justification::Center => gtk_sys::GTK_JUSTIFY_CENTER,
2642            Justification::Fill => gtk_sys::GTK_JUSTIFY_FILL,
2643            Justification::__Unknown(value) => value,
2644        }
2645    }
2646}
2647
2648#[doc(hidden)]
2649impl FromGlib<gtk_sys::GtkJustification> for Justification {
2650    fn from_glib(value: gtk_sys::GtkJustification) -> Self {
2651        skip_assert_initialized!();
2652        match value {
2653            0 => Justification::Left,
2654            1 => Justification::Right,
2655            2 => Justification::Center,
2656            3 => Justification::Fill,
2657            value => Justification::__Unknown(value),
2658        }
2659    }
2660}
2661
2662impl StaticType for Justification {
2663    fn static_type() -> Type {
2664        unsafe { from_glib(gtk_sys::gtk_justification_get_type()) }
2665    }
2666}
2667
2668impl<'a> FromValueOptional<'a> for Justification {
2669    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
2670        Some(FromValue::from_value(value))
2671    }
2672}
2673
2674impl<'a> FromValue<'a> for Justification {
2675    unsafe fn from_value(value: &Value) -> Self {
2676        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
2677    }
2678}
2679
2680impl SetValue for Justification {
2681    unsafe fn set_value(value: &mut Value, this: &Self) {
2682        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
2683    }
2684}
2685
2686#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2687pub enum LevelBarMode {
2688    Continuous,
2689    Discrete,
2690    #[doc(hidden)]
2691    __Unknown(i32),
2692}
2693
2694impl fmt::Display for LevelBarMode {
2695    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2696        write!(
2697            f,
2698            "LevelBarMode::{}",
2699            match *self {
2700                LevelBarMode::Continuous => "Continuous",
2701                LevelBarMode::Discrete => "Discrete",
2702                _ => "Unknown",
2703            }
2704        )
2705    }
2706}
2707
2708#[doc(hidden)]
2709impl ToGlib for LevelBarMode {
2710    type GlibType = gtk_sys::GtkLevelBarMode;
2711
2712    fn to_glib(&self) -> gtk_sys::GtkLevelBarMode {
2713        match *self {
2714            LevelBarMode::Continuous => gtk_sys::GTK_LEVEL_BAR_MODE_CONTINUOUS,
2715            LevelBarMode::Discrete => gtk_sys::GTK_LEVEL_BAR_MODE_DISCRETE,
2716            LevelBarMode::__Unknown(value) => value,
2717        }
2718    }
2719}
2720
2721#[doc(hidden)]
2722impl FromGlib<gtk_sys::GtkLevelBarMode> for LevelBarMode {
2723    fn from_glib(value: gtk_sys::GtkLevelBarMode) -> Self {
2724        skip_assert_initialized!();
2725        match value {
2726            0 => LevelBarMode::Continuous,
2727            1 => LevelBarMode::Discrete,
2728            value => LevelBarMode::__Unknown(value),
2729        }
2730    }
2731}
2732
2733impl StaticType for LevelBarMode {
2734    fn static_type() -> Type {
2735        unsafe { from_glib(gtk_sys::gtk_level_bar_mode_get_type()) }
2736    }
2737}
2738
2739impl<'a> FromValueOptional<'a> for LevelBarMode {
2740    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
2741        Some(FromValue::from_value(value))
2742    }
2743}
2744
2745impl<'a> FromValue<'a> for LevelBarMode {
2746    unsafe fn from_value(value: &Value) -> Self {
2747        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
2748    }
2749}
2750
2751impl SetValue for LevelBarMode {
2752    unsafe fn set_value(value: &mut Value, this: &Self) {
2753        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
2754    }
2755}
2756
2757#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2758pub enum License {
2759    Unknown,
2760    Custom,
2761    Gpl20,
2762    Gpl30,
2763    Lgpl21,
2764    Lgpl30,
2765    Bsd,
2766    MitX11,
2767    Artistic,
2768    Gpl20Only,
2769    Gpl30Only,
2770    Lgpl21Only,
2771    Lgpl30Only,
2772    Agpl30,
2773    Agpl30Only,
2774    #[doc(hidden)]
2775    __Unknown(i32),
2776}
2777
2778impl fmt::Display for License {
2779    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2780        write!(
2781            f,
2782            "License::{}",
2783            match *self {
2784                License::Unknown => "Unknown",
2785                License::Custom => "Custom",
2786                License::Gpl20 => "Gpl20",
2787                License::Gpl30 => "Gpl30",
2788                License::Lgpl21 => "Lgpl21",
2789                License::Lgpl30 => "Lgpl30",
2790                License::Bsd => "Bsd",
2791                License::MitX11 => "MitX11",
2792                License::Artistic => "Artistic",
2793                License::Gpl20Only => "Gpl20Only",
2794                License::Gpl30Only => "Gpl30Only",
2795                License::Lgpl21Only => "Lgpl21Only",
2796                License::Lgpl30Only => "Lgpl30Only",
2797                License::Agpl30 => "Agpl30",
2798                License::Agpl30Only => "Agpl30Only",
2799                _ => "Unknown",
2800            }
2801        )
2802    }
2803}
2804
2805#[doc(hidden)]
2806impl ToGlib for License {
2807    type GlibType = gtk_sys::GtkLicense;
2808
2809    fn to_glib(&self) -> gtk_sys::GtkLicense {
2810        match *self {
2811            License::Unknown => gtk_sys::GTK_LICENSE_UNKNOWN,
2812            License::Custom => gtk_sys::GTK_LICENSE_CUSTOM,
2813            License::Gpl20 => gtk_sys::GTK_LICENSE_GPL_2_0,
2814            License::Gpl30 => gtk_sys::GTK_LICENSE_GPL_3_0,
2815            License::Lgpl21 => gtk_sys::GTK_LICENSE_LGPL_2_1,
2816            License::Lgpl30 => gtk_sys::GTK_LICENSE_LGPL_3_0,
2817            License::Bsd => gtk_sys::GTK_LICENSE_BSD,
2818            License::MitX11 => gtk_sys::GTK_LICENSE_MIT_X11,
2819            License::Artistic => gtk_sys::GTK_LICENSE_ARTISTIC,
2820            License::Gpl20Only => gtk_sys::GTK_LICENSE_GPL_2_0_ONLY,
2821            License::Gpl30Only => gtk_sys::GTK_LICENSE_GPL_3_0_ONLY,
2822            License::Lgpl21Only => gtk_sys::GTK_LICENSE_LGPL_2_1_ONLY,
2823            License::Lgpl30Only => gtk_sys::GTK_LICENSE_LGPL_3_0_ONLY,
2824            License::Agpl30 => gtk_sys::GTK_LICENSE_AGPL_3_0,
2825            License::Agpl30Only => gtk_sys::GTK_LICENSE_AGPL_3_0_ONLY,
2826            License::__Unknown(value) => value,
2827        }
2828    }
2829}
2830
2831#[doc(hidden)]
2832impl FromGlib<gtk_sys::GtkLicense> for License {
2833    fn from_glib(value: gtk_sys::GtkLicense) -> Self {
2834        skip_assert_initialized!();
2835        match value {
2836            0 => License::Unknown,
2837            1 => License::Custom,
2838            2 => License::Gpl20,
2839            3 => License::Gpl30,
2840            4 => License::Lgpl21,
2841            5 => License::Lgpl30,
2842            6 => License::Bsd,
2843            7 => License::MitX11,
2844            8 => License::Artistic,
2845            9 => License::Gpl20Only,
2846            10 => License::Gpl30Only,
2847            11 => License::Lgpl21Only,
2848            12 => License::Lgpl30Only,
2849            13 => License::Agpl30,
2850            14 => License::Agpl30Only,
2851            value => License::__Unknown(value),
2852        }
2853    }
2854}
2855
2856impl StaticType for License {
2857    fn static_type() -> Type {
2858        unsafe { from_glib(gtk_sys::gtk_license_get_type()) }
2859    }
2860}
2861
2862impl<'a> FromValueOptional<'a> for License {
2863    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
2864        Some(FromValue::from_value(value))
2865    }
2866}
2867
2868impl<'a> FromValue<'a> for License {
2869    unsafe fn from_value(value: &Value) -> Self {
2870        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
2871    }
2872}
2873
2874impl SetValue for License {
2875    unsafe fn set_value(value: &mut Value, this: &Self) {
2876        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
2877    }
2878}
2879
2880#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2881pub enum MenuDirectionType {
2882    Parent,
2883    Child,
2884    Next,
2885    Prev,
2886    #[doc(hidden)]
2887    __Unknown(i32),
2888}
2889
2890impl fmt::Display for MenuDirectionType {
2891    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2892        write!(
2893            f,
2894            "MenuDirectionType::{}",
2895            match *self {
2896                MenuDirectionType::Parent => "Parent",
2897                MenuDirectionType::Child => "Child",
2898                MenuDirectionType::Next => "Next",
2899                MenuDirectionType::Prev => "Prev",
2900                _ => "Unknown",
2901            }
2902        )
2903    }
2904}
2905
2906#[doc(hidden)]
2907impl ToGlib for MenuDirectionType {
2908    type GlibType = gtk_sys::GtkMenuDirectionType;
2909
2910    fn to_glib(&self) -> gtk_sys::GtkMenuDirectionType {
2911        match *self {
2912            MenuDirectionType::Parent => gtk_sys::GTK_MENU_DIR_PARENT,
2913            MenuDirectionType::Child => gtk_sys::GTK_MENU_DIR_CHILD,
2914            MenuDirectionType::Next => gtk_sys::GTK_MENU_DIR_NEXT,
2915            MenuDirectionType::Prev => gtk_sys::GTK_MENU_DIR_PREV,
2916            MenuDirectionType::__Unknown(value) => value,
2917        }
2918    }
2919}
2920
2921#[doc(hidden)]
2922impl FromGlib<gtk_sys::GtkMenuDirectionType> for MenuDirectionType {
2923    fn from_glib(value: gtk_sys::GtkMenuDirectionType) -> Self {
2924        skip_assert_initialized!();
2925        match value {
2926            0 => MenuDirectionType::Parent,
2927            1 => MenuDirectionType::Child,
2928            2 => MenuDirectionType::Next,
2929            3 => MenuDirectionType::Prev,
2930            value => MenuDirectionType::__Unknown(value),
2931        }
2932    }
2933}
2934
2935impl StaticType for MenuDirectionType {
2936    fn static_type() -> Type {
2937        unsafe { from_glib(gtk_sys::gtk_menu_direction_type_get_type()) }
2938    }
2939}
2940
2941impl<'a> FromValueOptional<'a> for MenuDirectionType {
2942    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
2943        Some(FromValue::from_value(value))
2944    }
2945}
2946
2947impl<'a> FromValue<'a> for MenuDirectionType {
2948    unsafe fn from_value(value: &Value) -> Self {
2949        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
2950    }
2951}
2952
2953impl SetValue for MenuDirectionType {
2954    unsafe fn set_value(value: &mut Value, this: &Self) {
2955        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
2956    }
2957}
2958
2959#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2960pub enum MessageType {
2961    Info,
2962    Warning,
2963    Question,
2964    Error,
2965    Other,
2966    #[doc(hidden)]
2967    __Unknown(i32),
2968}
2969
2970impl fmt::Display for MessageType {
2971    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2972        write!(
2973            f,
2974            "MessageType::{}",
2975            match *self {
2976                MessageType::Info => "Info",
2977                MessageType::Warning => "Warning",
2978                MessageType::Question => "Question",
2979                MessageType::Error => "Error",
2980                MessageType::Other => "Other",
2981                _ => "Unknown",
2982            }
2983        )
2984    }
2985}
2986
2987#[doc(hidden)]
2988impl ToGlib for MessageType {
2989    type GlibType = gtk_sys::GtkMessageType;
2990
2991    fn to_glib(&self) -> gtk_sys::GtkMessageType {
2992        match *self {
2993            MessageType::Info => gtk_sys::GTK_MESSAGE_INFO,
2994            MessageType::Warning => gtk_sys::GTK_MESSAGE_WARNING,
2995            MessageType::Question => gtk_sys::GTK_MESSAGE_QUESTION,
2996            MessageType::Error => gtk_sys::GTK_MESSAGE_ERROR,
2997            MessageType::Other => gtk_sys::GTK_MESSAGE_OTHER,
2998            MessageType::__Unknown(value) => value,
2999        }
3000    }
3001}
3002
3003#[doc(hidden)]
3004impl FromGlib<gtk_sys::GtkMessageType> for MessageType {
3005    fn from_glib(value: gtk_sys::GtkMessageType) -> Self {
3006        skip_assert_initialized!();
3007        match value {
3008            0 => MessageType::Info,
3009            1 => MessageType::Warning,
3010            2 => MessageType::Question,
3011            3 => MessageType::Error,
3012            4 => MessageType::Other,
3013            value => MessageType::__Unknown(value),
3014        }
3015    }
3016}
3017
3018impl StaticType for MessageType {
3019    fn static_type() -> Type {
3020        unsafe { from_glib(gtk_sys::gtk_message_type_get_type()) }
3021    }
3022}
3023
3024impl<'a> FromValueOptional<'a> for MessageType {
3025    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
3026        Some(FromValue::from_value(value))
3027    }
3028}
3029
3030impl<'a> FromValue<'a> for MessageType {
3031    unsafe fn from_value(value: &Value) -> Self {
3032        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
3033    }
3034}
3035
3036impl SetValue for MessageType {
3037    unsafe fn set_value(value: &mut Value, this: &Self) {
3038        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
3039    }
3040}
3041
3042#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3043pub enum MovementStep {
3044    LogicalPositions,
3045    VisualPositions,
3046    Words,
3047    DisplayLines,
3048    DisplayLineEnds,
3049    Paragraphs,
3050    ParagraphEnds,
3051    Pages,
3052    BufferEnds,
3053    HorizontalPages,
3054    #[doc(hidden)]
3055    __Unknown(i32),
3056}
3057
3058impl fmt::Display for MovementStep {
3059    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3060        write!(
3061            f,
3062            "MovementStep::{}",
3063            match *self {
3064                MovementStep::LogicalPositions => "LogicalPositions",
3065                MovementStep::VisualPositions => "VisualPositions",
3066                MovementStep::Words => "Words",
3067                MovementStep::DisplayLines => "DisplayLines",
3068                MovementStep::DisplayLineEnds => "DisplayLineEnds",
3069                MovementStep::Paragraphs => "Paragraphs",
3070                MovementStep::ParagraphEnds => "ParagraphEnds",
3071                MovementStep::Pages => "Pages",
3072                MovementStep::BufferEnds => "BufferEnds",
3073                MovementStep::HorizontalPages => "HorizontalPages",
3074                _ => "Unknown",
3075            }
3076        )
3077    }
3078}
3079
3080#[doc(hidden)]
3081impl ToGlib for MovementStep {
3082    type GlibType = gtk_sys::GtkMovementStep;
3083
3084    fn to_glib(&self) -> gtk_sys::GtkMovementStep {
3085        match *self {
3086            MovementStep::LogicalPositions => gtk_sys::GTK_MOVEMENT_LOGICAL_POSITIONS,
3087            MovementStep::VisualPositions => gtk_sys::GTK_MOVEMENT_VISUAL_POSITIONS,
3088            MovementStep::Words => gtk_sys::GTK_MOVEMENT_WORDS,
3089            MovementStep::DisplayLines => gtk_sys::GTK_MOVEMENT_DISPLAY_LINES,
3090            MovementStep::DisplayLineEnds => gtk_sys::GTK_MOVEMENT_DISPLAY_LINE_ENDS,
3091            MovementStep::Paragraphs => gtk_sys::GTK_MOVEMENT_PARAGRAPHS,
3092            MovementStep::ParagraphEnds => gtk_sys::GTK_MOVEMENT_PARAGRAPH_ENDS,
3093            MovementStep::Pages => gtk_sys::GTK_MOVEMENT_PAGES,
3094            MovementStep::BufferEnds => gtk_sys::GTK_MOVEMENT_BUFFER_ENDS,
3095            MovementStep::HorizontalPages => gtk_sys::GTK_MOVEMENT_HORIZONTAL_PAGES,
3096            MovementStep::__Unknown(value) => value,
3097        }
3098    }
3099}
3100
3101#[doc(hidden)]
3102impl FromGlib<gtk_sys::GtkMovementStep> for MovementStep {
3103    fn from_glib(value: gtk_sys::GtkMovementStep) -> Self {
3104        skip_assert_initialized!();
3105        match value {
3106            0 => MovementStep::LogicalPositions,
3107            1 => MovementStep::VisualPositions,
3108            2 => MovementStep::Words,
3109            3 => MovementStep::DisplayLines,
3110            4 => MovementStep::DisplayLineEnds,
3111            5 => MovementStep::Paragraphs,
3112            6 => MovementStep::ParagraphEnds,
3113            7 => MovementStep::Pages,
3114            8 => MovementStep::BufferEnds,
3115            9 => MovementStep::HorizontalPages,
3116            value => MovementStep::__Unknown(value),
3117        }
3118    }
3119}
3120
3121impl StaticType for MovementStep {
3122    fn static_type() -> Type {
3123        unsafe { from_glib(gtk_sys::gtk_movement_step_get_type()) }
3124    }
3125}
3126
3127impl<'a> FromValueOptional<'a> for MovementStep {
3128    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
3129        Some(FromValue::from_value(value))
3130    }
3131}
3132
3133impl<'a> FromValue<'a> for MovementStep {
3134    unsafe fn from_value(value: &Value) -> Self {
3135        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
3136    }
3137}
3138
3139impl SetValue for MovementStep {
3140    unsafe fn set_value(value: &mut Value, this: &Self) {
3141        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
3142    }
3143}
3144
3145#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3146pub enum NotebookTab {
3147    First,
3148    Last,
3149    #[doc(hidden)]
3150    __Unknown(i32),
3151}
3152
3153impl fmt::Display for NotebookTab {
3154    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3155        write!(
3156            f,
3157            "NotebookTab::{}",
3158            match *self {
3159                NotebookTab::First => "First",
3160                NotebookTab::Last => "Last",
3161                _ => "Unknown",
3162            }
3163        )
3164    }
3165}
3166
3167#[doc(hidden)]
3168impl ToGlib for NotebookTab {
3169    type GlibType = gtk_sys::GtkNotebookTab;
3170
3171    fn to_glib(&self) -> gtk_sys::GtkNotebookTab {
3172        match *self {
3173            NotebookTab::First => gtk_sys::GTK_NOTEBOOK_TAB_FIRST,
3174            NotebookTab::Last => gtk_sys::GTK_NOTEBOOK_TAB_LAST,
3175            NotebookTab::__Unknown(value) => value,
3176        }
3177    }
3178}
3179
3180#[doc(hidden)]
3181impl FromGlib<gtk_sys::GtkNotebookTab> for NotebookTab {
3182    fn from_glib(value: gtk_sys::GtkNotebookTab) -> Self {
3183        skip_assert_initialized!();
3184        match value {
3185            0 => NotebookTab::First,
3186            1 => NotebookTab::Last,
3187            value => NotebookTab::__Unknown(value),
3188        }
3189    }
3190}
3191
3192impl StaticType for NotebookTab {
3193    fn static_type() -> Type {
3194        unsafe { from_glib(gtk_sys::gtk_notebook_tab_get_type()) }
3195    }
3196}
3197
3198impl<'a> FromValueOptional<'a> for NotebookTab {
3199    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
3200        Some(FromValue::from_value(value))
3201    }
3202}
3203
3204impl<'a> FromValue<'a> for NotebookTab {
3205    unsafe fn from_value(value: &Value) -> Self {
3206        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
3207    }
3208}
3209
3210impl SetValue for NotebookTab {
3211    unsafe fn set_value(value: &mut Value, this: &Self) {
3212        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
3213    }
3214}
3215
3216#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3217pub enum NumberUpLayout {
3218    Lrtb,
3219    Lrbt,
3220    Rltb,
3221    Rlbt,
3222    Tblr,
3223    Tbrl,
3224    Btlr,
3225    Btrl,
3226    #[doc(hidden)]
3227    __Unknown(i32),
3228}
3229
3230impl fmt::Display for NumberUpLayout {
3231    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3232        write!(
3233            f,
3234            "NumberUpLayout::{}",
3235            match *self {
3236                NumberUpLayout::Lrtb => "Lrtb",
3237                NumberUpLayout::Lrbt => "Lrbt",
3238                NumberUpLayout::Rltb => "Rltb",
3239                NumberUpLayout::Rlbt => "Rlbt",
3240                NumberUpLayout::Tblr => "Tblr",
3241                NumberUpLayout::Tbrl => "Tbrl",
3242                NumberUpLayout::Btlr => "Btlr",
3243                NumberUpLayout::Btrl => "Btrl",
3244                _ => "Unknown",
3245            }
3246        )
3247    }
3248}
3249
3250#[doc(hidden)]
3251impl ToGlib for NumberUpLayout {
3252    type GlibType = gtk_sys::GtkNumberUpLayout;
3253
3254    fn to_glib(&self) -> gtk_sys::GtkNumberUpLayout {
3255        match *self {
3256            NumberUpLayout::Lrtb => gtk_sys::GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM,
3257            NumberUpLayout::Lrbt => gtk_sys::GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_BOTTOM_TO_TOP,
3258            NumberUpLayout::Rltb => gtk_sys::GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM,
3259            NumberUpLayout::Rlbt => gtk_sys::GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_BOTTOM_TO_TOP,
3260            NumberUpLayout::Tblr => gtk_sys::GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_LEFT_TO_RIGHT,
3261            NumberUpLayout::Tbrl => gtk_sys::GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_RIGHT_TO_LEFT,
3262            NumberUpLayout::Btlr => gtk_sys::GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_LEFT_TO_RIGHT,
3263            NumberUpLayout::Btrl => gtk_sys::GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_RIGHT_TO_LEFT,
3264            NumberUpLayout::__Unknown(value) => value,
3265        }
3266    }
3267}
3268
3269#[doc(hidden)]
3270impl FromGlib<gtk_sys::GtkNumberUpLayout> for NumberUpLayout {
3271    fn from_glib(value: gtk_sys::GtkNumberUpLayout) -> Self {
3272        skip_assert_initialized!();
3273        match value {
3274            0 => NumberUpLayout::Lrtb,
3275            1 => NumberUpLayout::Lrbt,
3276            2 => NumberUpLayout::Rltb,
3277            3 => NumberUpLayout::Rlbt,
3278            4 => NumberUpLayout::Tblr,
3279            5 => NumberUpLayout::Tbrl,
3280            6 => NumberUpLayout::Btlr,
3281            7 => NumberUpLayout::Btrl,
3282            value => NumberUpLayout::__Unknown(value),
3283        }
3284    }
3285}
3286
3287impl StaticType for NumberUpLayout {
3288    fn static_type() -> Type {
3289        unsafe { from_glib(gtk_sys::gtk_number_up_layout_get_type()) }
3290    }
3291}
3292
3293impl<'a> FromValueOptional<'a> for NumberUpLayout {
3294    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
3295        Some(FromValue::from_value(value))
3296    }
3297}
3298
3299impl<'a> FromValue<'a> for NumberUpLayout {
3300    unsafe fn from_value(value: &Value) -> Self {
3301        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
3302    }
3303}
3304
3305impl SetValue for NumberUpLayout {
3306    unsafe fn set_value(value: &mut Value, this: &Self) {
3307        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
3308    }
3309}
3310
3311#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3312pub enum Orientation {
3313    Horizontal,
3314    Vertical,
3315    #[doc(hidden)]
3316    __Unknown(i32),
3317}
3318
3319impl fmt::Display for Orientation {
3320    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3321        write!(
3322            f,
3323            "Orientation::{}",
3324            match *self {
3325                Orientation::Horizontal => "Horizontal",
3326                Orientation::Vertical => "Vertical",
3327                _ => "Unknown",
3328            }
3329        )
3330    }
3331}
3332
3333#[doc(hidden)]
3334impl ToGlib for Orientation {
3335    type GlibType = gtk_sys::GtkOrientation;
3336
3337    fn to_glib(&self) -> gtk_sys::GtkOrientation {
3338        match *self {
3339            Orientation::Horizontal => gtk_sys::GTK_ORIENTATION_HORIZONTAL,
3340            Orientation::Vertical => gtk_sys::GTK_ORIENTATION_VERTICAL,
3341            Orientation::__Unknown(value) => value,
3342        }
3343    }
3344}
3345
3346#[doc(hidden)]
3347impl FromGlib<gtk_sys::GtkOrientation> for Orientation {
3348    fn from_glib(value: gtk_sys::GtkOrientation) -> Self {
3349        skip_assert_initialized!();
3350        match value {
3351            0 => Orientation::Horizontal,
3352            1 => Orientation::Vertical,
3353            value => Orientation::__Unknown(value),
3354        }
3355    }
3356}
3357
3358impl StaticType for Orientation {
3359    fn static_type() -> Type {
3360        unsafe { from_glib(gtk_sys::gtk_orientation_get_type()) }
3361    }
3362}
3363
3364impl<'a> FromValueOptional<'a> for Orientation {
3365    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
3366        Some(FromValue::from_value(value))
3367    }
3368}
3369
3370impl<'a> FromValue<'a> for Orientation {
3371    unsafe fn from_value(value: &Value) -> Self {
3372        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
3373    }
3374}
3375
3376impl SetValue for Orientation {
3377    unsafe fn set_value(value: &mut Value, this: &Self) {
3378        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
3379    }
3380}
3381
3382#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3383pub enum PackDirection {
3384    Ltr,
3385    Rtl,
3386    Ttb,
3387    Btt,
3388    #[doc(hidden)]
3389    __Unknown(i32),
3390}
3391
3392impl fmt::Display for PackDirection {
3393    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3394        write!(
3395            f,
3396            "PackDirection::{}",
3397            match *self {
3398                PackDirection::Ltr => "Ltr",
3399                PackDirection::Rtl => "Rtl",
3400                PackDirection::Ttb => "Ttb",
3401                PackDirection::Btt => "Btt",
3402                _ => "Unknown",
3403            }
3404        )
3405    }
3406}
3407
3408#[doc(hidden)]
3409impl ToGlib for PackDirection {
3410    type GlibType = gtk_sys::GtkPackDirection;
3411
3412    fn to_glib(&self) -> gtk_sys::GtkPackDirection {
3413        match *self {
3414            PackDirection::Ltr => gtk_sys::GTK_PACK_DIRECTION_LTR,
3415            PackDirection::Rtl => gtk_sys::GTK_PACK_DIRECTION_RTL,
3416            PackDirection::Ttb => gtk_sys::GTK_PACK_DIRECTION_TTB,
3417            PackDirection::Btt => gtk_sys::GTK_PACK_DIRECTION_BTT,
3418            PackDirection::__Unknown(value) => value,
3419        }
3420    }
3421}
3422
3423#[doc(hidden)]
3424impl FromGlib<gtk_sys::GtkPackDirection> for PackDirection {
3425    fn from_glib(value: gtk_sys::GtkPackDirection) -> Self {
3426        skip_assert_initialized!();
3427        match value {
3428            0 => PackDirection::Ltr,
3429            1 => PackDirection::Rtl,
3430            2 => PackDirection::Ttb,
3431            3 => PackDirection::Btt,
3432            value => PackDirection::__Unknown(value),
3433        }
3434    }
3435}
3436
3437impl StaticType for PackDirection {
3438    fn static_type() -> Type {
3439        unsafe { from_glib(gtk_sys::gtk_pack_direction_get_type()) }
3440    }
3441}
3442
3443impl<'a> FromValueOptional<'a> for PackDirection {
3444    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
3445        Some(FromValue::from_value(value))
3446    }
3447}
3448
3449impl<'a> FromValue<'a> for PackDirection {
3450    unsafe fn from_value(value: &Value) -> Self {
3451        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
3452    }
3453}
3454
3455impl SetValue for PackDirection {
3456    unsafe fn set_value(value: &mut Value, this: &Self) {
3457        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
3458    }
3459}
3460
3461#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3462pub enum PackType {
3463    Start,
3464    End,
3465    #[doc(hidden)]
3466    __Unknown(i32),
3467}
3468
3469impl fmt::Display for PackType {
3470    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3471        write!(
3472            f,
3473            "PackType::{}",
3474            match *self {
3475                PackType::Start => "Start",
3476                PackType::End => "End",
3477                _ => "Unknown",
3478            }
3479        )
3480    }
3481}
3482
3483#[doc(hidden)]
3484impl ToGlib for PackType {
3485    type GlibType = gtk_sys::GtkPackType;
3486
3487    fn to_glib(&self) -> gtk_sys::GtkPackType {
3488        match *self {
3489            PackType::Start => gtk_sys::GTK_PACK_START,
3490            PackType::End => gtk_sys::GTK_PACK_END,
3491            PackType::__Unknown(value) => value,
3492        }
3493    }
3494}
3495
3496#[doc(hidden)]
3497impl FromGlib<gtk_sys::GtkPackType> for PackType {
3498    fn from_glib(value: gtk_sys::GtkPackType) -> Self {
3499        skip_assert_initialized!();
3500        match value {
3501            0 => PackType::Start,
3502            1 => PackType::End,
3503            value => PackType::__Unknown(value),
3504        }
3505    }
3506}
3507
3508impl StaticType for PackType {
3509    fn static_type() -> Type {
3510        unsafe { from_glib(gtk_sys::gtk_pack_type_get_type()) }
3511    }
3512}
3513
3514impl<'a> FromValueOptional<'a> for PackType {
3515    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
3516        Some(FromValue::from_value(value))
3517    }
3518}
3519
3520impl<'a> FromValue<'a> for PackType {
3521    unsafe fn from_value(value: &Value) -> Self {
3522        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
3523    }
3524}
3525
3526impl SetValue for PackType {
3527    unsafe fn set_value(value: &mut Value, this: &Self) {
3528        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
3529    }
3530}
3531
3532#[cfg(any(feature = "v3_22", feature = "dox"))]
3533#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3534pub enum PadActionType {
3535    Button,
3536    Ring,
3537    Strip,
3538    #[doc(hidden)]
3539    __Unknown(i32),
3540}
3541
3542#[cfg(any(feature = "v3_22", feature = "dox"))]
3543impl fmt::Display for PadActionType {
3544    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3545        write!(
3546            f,
3547            "PadActionType::{}",
3548            match *self {
3549                PadActionType::Button => "Button",
3550                PadActionType::Ring => "Ring",
3551                PadActionType::Strip => "Strip",
3552                _ => "Unknown",
3553            }
3554        )
3555    }
3556}
3557
3558#[cfg(any(feature = "v3_22", feature = "dox"))]
3559#[doc(hidden)]
3560impl ToGlib for PadActionType {
3561    type GlibType = gtk_sys::GtkPadActionType;
3562
3563    fn to_glib(&self) -> gtk_sys::GtkPadActionType {
3564        match *self {
3565            PadActionType::Button => gtk_sys::GTK_PAD_ACTION_BUTTON,
3566            PadActionType::Ring => gtk_sys::GTK_PAD_ACTION_RING,
3567            PadActionType::Strip => gtk_sys::GTK_PAD_ACTION_STRIP,
3568            PadActionType::__Unknown(value) => value,
3569        }
3570    }
3571}
3572
3573#[cfg(any(feature = "v3_22", feature = "dox"))]
3574#[doc(hidden)]
3575impl FromGlib<gtk_sys::GtkPadActionType> for PadActionType {
3576    fn from_glib(value: gtk_sys::GtkPadActionType) -> Self {
3577        skip_assert_initialized!();
3578        match value {
3579            0 => PadActionType::Button,
3580            1 => PadActionType::Ring,
3581            2 => PadActionType::Strip,
3582            value => PadActionType::__Unknown(value),
3583        }
3584    }
3585}
3586
3587#[cfg(any(feature = "v3_22", feature = "dox"))]
3588impl StaticType for PadActionType {
3589    fn static_type() -> Type {
3590        unsafe { from_glib(gtk_sys::gtk_pad_action_type_get_type()) }
3591    }
3592}
3593
3594#[cfg(any(feature = "v3_22", feature = "dox"))]
3595impl<'a> FromValueOptional<'a> for PadActionType {
3596    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
3597        Some(FromValue::from_value(value))
3598    }
3599}
3600
3601#[cfg(any(feature = "v3_22", feature = "dox"))]
3602impl<'a> FromValue<'a> for PadActionType {
3603    unsafe fn from_value(value: &Value) -> Self {
3604        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
3605    }
3606}
3607
3608#[cfg(any(feature = "v3_22", feature = "dox"))]
3609impl SetValue for PadActionType {
3610    unsafe fn set_value(value: &mut Value, this: &Self) {
3611        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
3612    }
3613}
3614
3615#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3616pub enum PageOrientation {
3617    Portrait,
3618    Landscape,
3619    ReversePortrait,
3620    ReverseLandscape,
3621    #[doc(hidden)]
3622    __Unknown(i32),
3623}
3624
3625impl fmt::Display for PageOrientation {
3626    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3627        write!(
3628            f,
3629            "PageOrientation::{}",
3630            match *self {
3631                PageOrientation::Portrait => "Portrait",
3632                PageOrientation::Landscape => "Landscape",
3633                PageOrientation::ReversePortrait => "ReversePortrait",
3634                PageOrientation::ReverseLandscape => "ReverseLandscape",
3635                _ => "Unknown",
3636            }
3637        )
3638    }
3639}
3640
3641#[doc(hidden)]
3642impl ToGlib for PageOrientation {
3643    type GlibType = gtk_sys::GtkPageOrientation;
3644
3645    fn to_glib(&self) -> gtk_sys::GtkPageOrientation {
3646        match *self {
3647            PageOrientation::Portrait => gtk_sys::GTK_PAGE_ORIENTATION_PORTRAIT,
3648            PageOrientation::Landscape => gtk_sys::GTK_PAGE_ORIENTATION_LANDSCAPE,
3649            PageOrientation::ReversePortrait => gtk_sys::GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT,
3650            PageOrientation::ReverseLandscape => gtk_sys::GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE,
3651            PageOrientation::__Unknown(value) => value,
3652        }
3653    }
3654}
3655
3656#[doc(hidden)]
3657impl FromGlib<gtk_sys::GtkPageOrientation> for PageOrientation {
3658    fn from_glib(value: gtk_sys::GtkPageOrientation) -> Self {
3659        skip_assert_initialized!();
3660        match value {
3661            0 => PageOrientation::Portrait,
3662            1 => PageOrientation::Landscape,
3663            2 => PageOrientation::ReversePortrait,
3664            3 => PageOrientation::ReverseLandscape,
3665            value => PageOrientation::__Unknown(value),
3666        }
3667    }
3668}
3669
3670impl StaticType for PageOrientation {
3671    fn static_type() -> Type {
3672        unsafe { from_glib(gtk_sys::gtk_page_orientation_get_type()) }
3673    }
3674}
3675
3676impl<'a> FromValueOptional<'a> for PageOrientation {
3677    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
3678        Some(FromValue::from_value(value))
3679    }
3680}
3681
3682impl<'a> FromValue<'a> for PageOrientation {
3683    unsafe fn from_value(value: &Value) -> Self {
3684        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
3685    }
3686}
3687
3688impl SetValue for PageOrientation {
3689    unsafe fn set_value(value: &mut Value, this: &Self) {
3690        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
3691    }
3692}
3693
3694#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3695pub enum PageSet {
3696    All,
3697    Even,
3698    Odd,
3699    #[doc(hidden)]
3700    __Unknown(i32),
3701}
3702
3703impl fmt::Display for PageSet {
3704    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3705        write!(
3706            f,
3707            "PageSet::{}",
3708            match *self {
3709                PageSet::All => "All",
3710                PageSet::Even => "Even",
3711                PageSet::Odd => "Odd",
3712                _ => "Unknown",
3713            }
3714        )
3715    }
3716}
3717
3718#[doc(hidden)]
3719impl ToGlib for PageSet {
3720    type GlibType = gtk_sys::GtkPageSet;
3721
3722    fn to_glib(&self) -> gtk_sys::GtkPageSet {
3723        match *self {
3724            PageSet::All => gtk_sys::GTK_PAGE_SET_ALL,
3725            PageSet::Even => gtk_sys::GTK_PAGE_SET_EVEN,
3726            PageSet::Odd => gtk_sys::GTK_PAGE_SET_ODD,
3727            PageSet::__Unknown(value) => value,
3728        }
3729    }
3730}
3731
3732#[doc(hidden)]
3733impl FromGlib<gtk_sys::GtkPageSet> for PageSet {
3734    fn from_glib(value: gtk_sys::GtkPageSet) -> Self {
3735        skip_assert_initialized!();
3736        match value {
3737            0 => PageSet::All,
3738            1 => PageSet::Even,
3739            2 => PageSet::Odd,
3740            value => PageSet::__Unknown(value),
3741        }
3742    }
3743}
3744
3745impl StaticType for PageSet {
3746    fn static_type() -> Type {
3747        unsafe { from_glib(gtk_sys::gtk_page_set_get_type()) }
3748    }
3749}
3750
3751impl<'a> FromValueOptional<'a> for PageSet {
3752    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
3753        Some(FromValue::from_value(value))
3754    }
3755}
3756
3757impl<'a> FromValue<'a> for PageSet {
3758    unsafe fn from_value(value: &Value) -> Self {
3759        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
3760    }
3761}
3762
3763impl SetValue for PageSet {
3764    unsafe fn set_value(value: &mut Value, this: &Self) {
3765        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
3766    }
3767}
3768
3769#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3770pub enum PanDirection {
3771    Left,
3772    Right,
3773    Up,
3774    Down,
3775    #[doc(hidden)]
3776    __Unknown(i32),
3777}
3778
3779impl fmt::Display for PanDirection {
3780    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3781        write!(
3782            f,
3783            "PanDirection::{}",
3784            match *self {
3785                PanDirection::Left => "Left",
3786                PanDirection::Right => "Right",
3787                PanDirection::Up => "Up",
3788                PanDirection::Down => "Down",
3789                _ => "Unknown",
3790            }
3791        )
3792    }
3793}
3794
3795#[doc(hidden)]
3796impl ToGlib for PanDirection {
3797    type GlibType = gtk_sys::GtkPanDirection;
3798
3799    fn to_glib(&self) -> gtk_sys::GtkPanDirection {
3800        match *self {
3801            PanDirection::Left => gtk_sys::GTK_PAN_DIRECTION_LEFT,
3802            PanDirection::Right => gtk_sys::GTK_PAN_DIRECTION_RIGHT,
3803            PanDirection::Up => gtk_sys::GTK_PAN_DIRECTION_UP,
3804            PanDirection::Down => gtk_sys::GTK_PAN_DIRECTION_DOWN,
3805            PanDirection::__Unknown(value) => value,
3806        }
3807    }
3808}
3809
3810#[doc(hidden)]
3811impl FromGlib<gtk_sys::GtkPanDirection> for PanDirection {
3812    fn from_glib(value: gtk_sys::GtkPanDirection) -> Self {
3813        skip_assert_initialized!();
3814        match value {
3815            0 => PanDirection::Left,
3816            1 => PanDirection::Right,
3817            2 => PanDirection::Up,
3818            3 => PanDirection::Down,
3819            value => PanDirection::__Unknown(value),
3820        }
3821    }
3822}
3823
3824impl StaticType for PanDirection {
3825    fn static_type() -> Type {
3826        unsafe { from_glib(gtk_sys::gtk_pan_direction_get_type()) }
3827    }
3828}
3829
3830impl<'a> FromValueOptional<'a> for PanDirection {
3831    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
3832        Some(FromValue::from_value(value))
3833    }
3834}
3835
3836impl<'a> FromValue<'a> for PanDirection {
3837    unsafe fn from_value(value: &Value) -> Self {
3838        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
3839    }
3840}
3841
3842impl SetValue for PanDirection {
3843    unsafe fn set_value(value: &mut Value, this: &Self) {
3844        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
3845    }
3846}
3847
3848#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3849pub enum PolicyType {
3850    Always,
3851    Automatic,
3852    Never,
3853    External,
3854    #[doc(hidden)]
3855    __Unknown(i32),
3856}
3857
3858impl fmt::Display for PolicyType {
3859    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3860        write!(
3861            f,
3862            "PolicyType::{}",
3863            match *self {
3864                PolicyType::Always => "Always",
3865                PolicyType::Automatic => "Automatic",
3866                PolicyType::Never => "Never",
3867                PolicyType::External => "External",
3868                _ => "Unknown",
3869            }
3870        )
3871    }
3872}
3873
3874#[doc(hidden)]
3875impl ToGlib for PolicyType {
3876    type GlibType = gtk_sys::GtkPolicyType;
3877
3878    fn to_glib(&self) -> gtk_sys::GtkPolicyType {
3879        match *self {
3880            PolicyType::Always => gtk_sys::GTK_POLICY_ALWAYS,
3881            PolicyType::Automatic => gtk_sys::GTK_POLICY_AUTOMATIC,
3882            PolicyType::Never => gtk_sys::GTK_POLICY_NEVER,
3883            PolicyType::External => gtk_sys::GTK_POLICY_EXTERNAL,
3884            PolicyType::__Unknown(value) => value,
3885        }
3886    }
3887}
3888
3889#[doc(hidden)]
3890impl FromGlib<gtk_sys::GtkPolicyType> for PolicyType {
3891    fn from_glib(value: gtk_sys::GtkPolicyType) -> Self {
3892        skip_assert_initialized!();
3893        match value {
3894            0 => PolicyType::Always,
3895            1 => PolicyType::Automatic,
3896            2 => PolicyType::Never,
3897            3 => PolicyType::External,
3898            value => PolicyType::__Unknown(value),
3899        }
3900    }
3901}
3902
3903impl StaticType for PolicyType {
3904    fn static_type() -> Type {
3905        unsafe { from_glib(gtk_sys::gtk_policy_type_get_type()) }
3906    }
3907}
3908
3909impl<'a> FromValueOptional<'a> for PolicyType {
3910    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
3911        Some(FromValue::from_value(value))
3912    }
3913}
3914
3915impl<'a> FromValue<'a> for PolicyType {
3916    unsafe fn from_value(value: &Value) -> Self {
3917        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
3918    }
3919}
3920
3921impl SetValue for PolicyType {
3922    unsafe fn set_value(value: &mut Value, this: &Self) {
3923        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
3924    }
3925}
3926
3927#[cfg(any(feature = "v3_20", feature = "dox"))]
3928#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3929pub enum PopoverConstraint {
3930    None,
3931    Window,
3932    #[doc(hidden)]
3933    __Unknown(i32),
3934}
3935
3936#[cfg(any(feature = "v3_20", feature = "dox"))]
3937impl fmt::Display for PopoverConstraint {
3938    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3939        write!(
3940            f,
3941            "PopoverConstraint::{}",
3942            match *self {
3943                PopoverConstraint::None => "None",
3944                PopoverConstraint::Window => "Window",
3945                _ => "Unknown",
3946            }
3947        )
3948    }
3949}
3950
3951#[cfg(any(feature = "v3_20", feature = "dox"))]
3952#[doc(hidden)]
3953impl ToGlib for PopoverConstraint {
3954    type GlibType = gtk_sys::GtkPopoverConstraint;
3955
3956    fn to_glib(&self) -> gtk_sys::GtkPopoverConstraint {
3957        match *self {
3958            PopoverConstraint::None => gtk_sys::GTK_POPOVER_CONSTRAINT_NONE,
3959            PopoverConstraint::Window => gtk_sys::GTK_POPOVER_CONSTRAINT_WINDOW,
3960            PopoverConstraint::__Unknown(value) => value,
3961        }
3962    }
3963}
3964
3965#[cfg(any(feature = "v3_20", feature = "dox"))]
3966#[doc(hidden)]
3967impl FromGlib<gtk_sys::GtkPopoverConstraint> for PopoverConstraint {
3968    fn from_glib(value: gtk_sys::GtkPopoverConstraint) -> Self {
3969        skip_assert_initialized!();
3970        match value {
3971            0 => PopoverConstraint::None,
3972            1 => PopoverConstraint::Window,
3973            value => PopoverConstraint::__Unknown(value),
3974        }
3975    }
3976}
3977
3978#[cfg(any(feature = "v3_20", feature = "dox"))]
3979impl StaticType for PopoverConstraint {
3980    fn static_type() -> Type {
3981        unsafe { from_glib(gtk_sys::gtk_popover_constraint_get_type()) }
3982    }
3983}
3984
3985#[cfg(any(feature = "v3_20", feature = "dox"))]
3986impl<'a> FromValueOptional<'a> for PopoverConstraint {
3987    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
3988        Some(FromValue::from_value(value))
3989    }
3990}
3991
3992#[cfg(any(feature = "v3_20", feature = "dox"))]
3993impl<'a> FromValue<'a> for PopoverConstraint {
3994    unsafe fn from_value(value: &Value) -> Self {
3995        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
3996    }
3997}
3998
3999#[cfg(any(feature = "v3_20", feature = "dox"))]
4000impl SetValue for PopoverConstraint {
4001    unsafe fn set_value(value: &mut Value, this: &Self) {
4002        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
4003    }
4004}
4005
4006#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4007pub enum PositionType {
4008    Left,
4009    Right,
4010    Top,
4011    Bottom,
4012    #[doc(hidden)]
4013    __Unknown(i32),
4014}
4015
4016impl fmt::Display for PositionType {
4017    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4018        write!(
4019            f,
4020            "PositionType::{}",
4021            match *self {
4022                PositionType::Left => "Left",
4023                PositionType::Right => "Right",
4024                PositionType::Top => "Top",
4025                PositionType::Bottom => "Bottom",
4026                _ => "Unknown",
4027            }
4028        )
4029    }
4030}
4031
4032#[doc(hidden)]
4033impl ToGlib for PositionType {
4034    type GlibType = gtk_sys::GtkPositionType;
4035
4036    fn to_glib(&self) -> gtk_sys::GtkPositionType {
4037        match *self {
4038            PositionType::Left => gtk_sys::GTK_POS_LEFT,
4039            PositionType::Right => gtk_sys::GTK_POS_RIGHT,
4040            PositionType::Top => gtk_sys::GTK_POS_TOP,
4041            PositionType::Bottom => gtk_sys::GTK_POS_BOTTOM,
4042            PositionType::__Unknown(value) => value,
4043        }
4044    }
4045}
4046
4047#[doc(hidden)]
4048impl FromGlib<gtk_sys::GtkPositionType> for PositionType {
4049    fn from_glib(value: gtk_sys::GtkPositionType) -> Self {
4050        skip_assert_initialized!();
4051        match value {
4052            0 => PositionType::Left,
4053            1 => PositionType::Right,
4054            2 => PositionType::Top,
4055            3 => PositionType::Bottom,
4056            value => PositionType::__Unknown(value),
4057        }
4058    }
4059}
4060
4061impl StaticType for PositionType {
4062    fn static_type() -> Type {
4063        unsafe { from_glib(gtk_sys::gtk_position_type_get_type()) }
4064    }
4065}
4066
4067impl<'a> FromValueOptional<'a> for PositionType {
4068    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
4069        Some(FromValue::from_value(value))
4070    }
4071}
4072
4073impl<'a> FromValue<'a> for PositionType {
4074    unsafe fn from_value(value: &Value) -> Self {
4075        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
4076    }
4077}
4078
4079impl SetValue for PositionType {
4080    unsafe fn set_value(value: &mut Value, this: &Self) {
4081        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
4082    }
4083}
4084
4085#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4086pub enum PrintDuplex {
4087    Simplex,
4088    Horizontal,
4089    Vertical,
4090    #[doc(hidden)]
4091    __Unknown(i32),
4092}
4093
4094impl fmt::Display for PrintDuplex {
4095    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4096        write!(
4097            f,
4098            "PrintDuplex::{}",
4099            match *self {
4100                PrintDuplex::Simplex => "Simplex",
4101                PrintDuplex::Horizontal => "Horizontal",
4102                PrintDuplex::Vertical => "Vertical",
4103                _ => "Unknown",
4104            }
4105        )
4106    }
4107}
4108
4109#[doc(hidden)]
4110impl ToGlib for PrintDuplex {
4111    type GlibType = gtk_sys::GtkPrintDuplex;
4112
4113    fn to_glib(&self) -> gtk_sys::GtkPrintDuplex {
4114        match *self {
4115            PrintDuplex::Simplex => gtk_sys::GTK_PRINT_DUPLEX_SIMPLEX,
4116            PrintDuplex::Horizontal => gtk_sys::GTK_PRINT_DUPLEX_HORIZONTAL,
4117            PrintDuplex::Vertical => gtk_sys::GTK_PRINT_DUPLEX_VERTICAL,
4118            PrintDuplex::__Unknown(value) => value,
4119        }
4120    }
4121}
4122
4123#[doc(hidden)]
4124impl FromGlib<gtk_sys::GtkPrintDuplex> for PrintDuplex {
4125    fn from_glib(value: gtk_sys::GtkPrintDuplex) -> Self {
4126        skip_assert_initialized!();
4127        match value {
4128            0 => PrintDuplex::Simplex,
4129            1 => PrintDuplex::Horizontal,
4130            2 => PrintDuplex::Vertical,
4131            value => PrintDuplex::__Unknown(value),
4132        }
4133    }
4134}
4135
4136impl StaticType for PrintDuplex {
4137    fn static_type() -> Type {
4138        unsafe { from_glib(gtk_sys::gtk_print_duplex_get_type()) }
4139    }
4140}
4141
4142impl<'a> FromValueOptional<'a> for PrintDuplex {
4143    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
4144        Some(FromValue::from_value(value))
4145    }
4146}
4147
4148impl<'a> FromValue<'a> for PrintDuplex {
4149    unsafe fn from_value(value: &Value) -> Self {
4150        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
4151    }
4152}
4153
4154impl SetValue for PrintDuplex {
4155    unsafe fn set_value(value: &mut Value, this: &Self) {
4156        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
4157    }
4158}
4159
4160#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4161pub enum PrintError {
4162    General,
4163    InternalError,
4164    Nomem,
4165    InvalidFile,
4166    #[doc(hidden)]
4167    __Unknown(i32),
4168}
4169
4170impl fmt::Display for PrintError {
4171    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4172        write!(
4173            f,
4174            "PrintError::{}",
4175            match *self {
4176                PrintError::General => "General",
4177                PrintError::InternalError => "InternalError",
4178                PrintError::Nomem => "Nomem",
4179                PrintError::InvalidFile => "InvalidFile",
4180                _ => "Unknown",
4181            }
4182        )
4183    }
4184}
4185
4186#[doc(hidden)]
4187impl ToGlib for PrintError {
4188    type GlibType = gtk_sys::GtkPrintError;
4189
4190    fn to_glib(&self) -> gtk_sys::GtkPrintError {
4191        match *self {
4192            PrintError::General => gtk_sys::GTK_PRINT_ERROR_GENERAL,
4193            PrintError::InternalError => gtk_sys::GTK_PRINT_ERROR_INTERNAL_ERROR,
4194            PrintError::Nomem => gtk_sys::GTK_PRINT_ERROR_NOMEM,
4195            PrintError::InvalidFile => gtk_sys::GTK_PRINT_ERROR_INVALID_FILE,
4196            PrintError::__Unknown(value) => value,
4197        }
4198    }
4199}
4200
4201#[doc(hidden)]
4202impl FromGlib<gtk_sys::GtkPrintError> for PrintError {
4203    fn from_glib(value: gtk_sys::GtkPrintError) -> Self {
4204        skip_assert_initialized!();
4205        match value {
4206            0 => PrintError::General,
4207            1 => PrintError::InternalError,
4208            2 => PrintError::Nomem,
4209            3 => PrintError::InvalidFile,
4210            value => PrintError::__Unknown(value),
4211        }
4212    }
4213}
4214
4215impl ErrorDomain for PrintError {
4216    fn domain() -> Quark {
4217        skip_assert_initialized!();
4218        unsafe { from_glib(gtk_sys::gtk_print_error_quark()) }
4219    }
4220
4221    fn code(self) -> i32 {
4222        self.to_glib()
4223    }
4224
4225    fn from(code: i32) -> Option<Self> {
4226        skip_assert_initialized!();
4227        match code {
4228            0 => Some(PrintError::General),
4229            1 => Some(PrintError::InternalError),
4230            2 => Some(PrintError::Nomem),
4231            3 => Some(PrintError::InvalidFile),
4232            value => Some(PrintError::__Unknown(value)),
4233        }
4234    }
4235}
4236
4237impl StaticType for PrintError {
4238    fn static_type() -> Type {
4239        unsafe { from_glib(gtk_sys::gtk_print_error_get_type()) }
4240    }
4241}
4242
4243impl<'a> FromValueOptional<'a> for PrintError {
4244    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
4245        Some(FromValue::from_value(value))
4246    }
4247}
4248
4249impl<'a> FromValue<'a> for PrintError {
4250    unsafe fn from_value(value: &Value) -> Self {
4251        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
4252    }
4253}
4254
4255impl SetValue for PrintError {
4256    unsafe fn set_value(value: &mut Value, this: &Self) {
4257        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
4258    }
4259}
4260
4261#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4262pub enum PrintOperationAction {
4263    PrintDialog,
4264    Print,
4265    Preview,
4266    Export,
4267    #[doc(hidden)]
4268    __Unknown(i32),
4269}
4270
4271impl fmt::Display for PrintOperationAction {
4272    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4273        write!(
4274            f,
4275            "PrintOperationAction::{}",
4276            match *self {
4277                PrintOperationAction::PrintDialog => "PrintDialog",
4278                PrintOperationAction::Print => "Print",
4279                PrintOperationAction::Preview => "Preview",
4280                PrintOperationAction::Export => "Export",
4281                _ => "Unknown",
4282            }
4283        )
4284    }
4285}
4286
4287#[doc(hidden)]
4288impl ToGlib for PrintOperationAction {
4289    type GlibType = gtk_sys::GtkPrintOperationAction;
4290
4291    fn to_glib(&self) -> gtk_sys::GtkPrintOperationAction {
4292        match *self {
4293            PrintOperationAction::PrintDialog => gtk_sys::GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG,
4294            PrintOperationAction::Print => gtk_sys::GTK_PRINT_OPERATION_ACTION_PRINT,
4295            PrintOperationAction::Preview => gtk_sys::GTK_PRINT_OPERATION_ACTION_PREVIEW,
4296            PrintOperationAction::Export => gtk_sys::GTK_PRINT_OPERATION_ACTION_EXPORT,
4297            PrintOperationAction::__Unknown(value) => value,
4298        }
4299    }
4300}
4301
4302#[doc(hidden)]
4303impl FromGlib<gtk_sys::GtkPrintOperationAction> for PrintOperationAction {
4304    fn from_glib(value: gtk_sys::GtkPrintOperationAction) -> Self {
4305        skip_assert_initialized!();
4306        match value {
4307            0 => PrintOperationAction::PrintDialog,
4308            1 => PrintOperationAction::Print,
4309            2 => PrintOperationAction::Preview,
4310            3 => PrintOperationAction::Export,
4311            value => PrintOperationAction::__Unknown(value),
4312        }
4313    }
4314}
4315
4316impl StaticType for PrintOperationAction {
4317    fn static_type() -> Type {
4318        unsafe { from_glib(gtk_sys::gtk_print_operation_action_get_type()) }
4319    }
4320}
4321
4322impl<'a> FromValueOptional<'a> for PrintOperationAction {
4323    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
4324        Some(FromValue::from_value(value))
4325    }
4326}
4327
4328impl<'a> FromValue<'a> for PrintOperationAction {
4329    unsafe fn from_value(value: &Value) -> Self {
4330        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
4331    }
4332}
4333
4334impl SetValue for PrintOperationAction {
4335    unsafe fn set_value(value: &mut Value, this: &Self) {
4336        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
4337    }
4338}
4339
4340#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4341pub enum PrintOperationResult {
4342    Error,
4343    Apply,
4344    Cancel,
4345    InProgress,
4346    #[doc(hidden)]
4347    __Unknown(i32),
4348}
4349
4350impl fmt::Display for PrintOperationResult {
4351    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4352        write!(
4353            f,
4354            "PrintOperationResult::{}",
4355            match *self {
4356                PrintOperationResult::Error => "Error",
4357                PrintOperationResult::Apply => "Apply",
4358                PrintOperationResult::Cancel => "Cancel",
4359                PrintOperationResult::InProgress => "InProgress",
4360                _ => "Unknown",
4361            }
4362        )
4363    }
4364}
4365
4366#[doc(hidden)]
4367impl ToGlib for PrintOperationResult {
4368    type GlibType = gtk_sys::GtkPrintOperationResult;
4369
4370    fn to_glib(&self) -> gtk_sys::GtkPrintOperationResult {
4371        match *self {
4372            PrintOperationResult::Error => gtk_sys::GTK_PRINT_OPERATION_RESULT_ERROR,
4373            PrintOperationResult::Apply => gtk_sys::GTK_PRINT_OPERATION_RESULT_APPLY,
4374            PrintOperationResult::Cancel => gtk_sys::GTK_PRINT_OPERATION_RESULT_CANCEL,
4375            PrintOperationResult::InProgress => gtk_sys::GTK_PRINT_OPERATION_RESULT_IN_PROGRESS,
4376            PrintOperationResult::__Unknown(value) => value,
4377        }
4378    }
4379}
4380
4381#[doc(hidden)]
4382impl FromGlib<gtk_sys::GtkPrintOperationResult> for PrintOperationResult {
4383    fn from_glib(value: gtk_sys::GtkPrintOperationResult) -> Self {
4384        skip_assert_initialized!();
4385        match value {
4386            0 => PrintOperationResult::Error,
4387            1 => PrintOperationResult::Apply,
4388            2 => PrintOperationResult::Cancel,
4389            3 => PrintOperationResult::InProgress,
4390            value => PrintOperationResult::__Unknown(value),
4391        }
4392    }
4393}
4394
4395impl StaticType for PrintOperationResult {
4396    fn static_type() -> Type {
4397        unsafe { from_glib(gtk_sys::gtk_print_operation_result_get_type()) }
4398    }
4399}
4400
4401impl<'a> FromValueOptional<'a> for PrintOperationResult {
4402    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
4403        Some(FromValue::from_value(value))
4404    }
4405}
4406
4407impl<'a> FromValue<'a> for PrintOperationResult {
4408    unsafe fn from_value(value: &Value) -> Self {
4409        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
4410    }
4411}
4412
4413impl SetValue for PrintOperationResult {
4414    unsafe fn set_value(value: &mut Value, this: &Self) {
4415        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
4416    }
4417}
4418
4419#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4420pub enum PrintPages {
4421    All,
4422    Current,
4423    Ranges,
4424    Selection,
4425    #[doc(hidden)]
4426    __Unknown(i32),
4427}
4428
4429impl fmt::Display for PrintPages {
4430    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4431        write!(
4432            f,
4433            "PrintPages::{}",
4434            match *self {
4435                PrintPages::All => "All",
4436                PrintPages::Current => "Current",
4437                PrintPages::Ranges => "Ranges",
4438                PrintPages::Selection => "Selection",
4439                _ => "Unknown",
4440            }
4441        )
4442    }
4443}
4444
4445#[doc(hidden)]
4446impl ToGlib for PrintPages {
4447    type GlibType = gtk_sys::GtkPrintPages;
4448
4449    fn to_glib(&self) -> gtk_sys::GtkPrintPages {
4450        match *self {
4451            PrintPages::All => gtk_sys::GTK_PRINT_PAGES_ALL,
4452            PrintPages::Current => gtk_sys::GTK_PRINT_PAGES_CURRENT,
4453            PrintPages::Ranges => gtk_sys::GTK_PRINT_PAGES_RANGES,
4454            PrintPages::Selection => gtk_sys::GTK_PRINT_PAGES_SELECTION,
4455            PrintPages::__Unknown(value) => value,
4456        }
4457    }
4458}
4459
4460#[doc(hidden)]
4461impl FromGlib<gtk_sys::GtkPrintPages> for PrintPages {
4462    fn from_glib(value: gtk_sys::GtkPrintPages) -> Self {
4463        skip_assert_initialized!();
4464        match value {
4465            0 => PrintPages::All,
4466            1 => PrintPages::Current,
4467            2 => PrintPages::Ranges,
4468            3 => PrintPages::Selection,
4469            value => PrintPages::__Unknown(value),
4470        }
4471    }
4472}
4473
4474impl StaticType for PrintPages {
4475    fn static_type() -> Type {
4476        unsafe { from_glib(gtk_sys::gtk_print_pages_get_type()) }
4477    }
4478}
4479
4480impl<'a> FromValueOptional<'a> for PrintPages {
4481    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
4482        Some(FromValue::from_value(value))
4483    }
4484}
4485
4486impl<'a> FromValue<'a> for PrintPages {
4487    unsafe fn from_value(value: &Value) -> Self {
4488        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
4489    }
4490}
4491
4492impl SetValue for PrintPages {
4493    unsafe fn set_value(value: &mut Value, this: &Self) {
4494        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
4495    }
4496}
4497
4498#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4499pub enum PrintQuality {
4500    Low,
4501    Normal,
4502    High,
4503    Draft,
4504    #[doc(hidden)]
4505    __Unknown(i32),
4506}
4507
4508impl fmt::Display for PrintQuality {
4509    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4510        write!(
4511            f,
4512            "PrintQuality::{}",
4513            match *self {
4514                PrintQuality::Low => "Low",
4515                PrintQuality::Normal => "Normal",
4516                PrintQuality::High => "High",
4517                PrintQuality::Draft => "Draft",
4518                _ => "Unknown",
4519            }
4520        )
4521    }
4522}
4523
4524#[doc(hidden)]
4525impl ToGlib for PrintQuality {
4526    type GlibType = gtk_sys::GtkPrintQuality;
4527
4528    fn to_glib(&self) -> gtk_sys::GtkPrintQuality {
4529        match *self {
4530            PrintQuality::Low => gtk_sys::GTK_PRINT_QUALITY_LOW,
4531            PrintQuality::Normal => gtk_sys::GTK_PRINT_QUALITY_NORMAL,
4532            PrintQuality::High => gtk_sys::GTK_PRINT_QUALITY_HIGH,
4533            PrintQuality::Draft => gtk_sys::GTK_PRINT_QUALITY_DRAFT,
4534            PrintQuality::__Unknown(value) => value,
4535        }
4536    }
4537}
4538
4539#[doc(hidden)]
4540impl FromGlib<gtk_sys::GtkPrintQuality> for PrintQuality {
4541    fn from_glib(value: gtk_sys::GtkPrintQuality) -> Self {
4542        skip_assert_initialized!();
4543        match value {
4544            0 => PrintQuality::Low,
4545            1 => PrintQuality::Normal,
4546            2 => PrintQuality::High,
4547            3 => PrintQuality::Draft,
4548            value => PrintQuality::__Unknown(value),
4549        }
4550    }
4551}
4552
4553impl StaticType for PrintQuality {
4554    fn static_type() -> Type {
4555        unsafe { from_glib(gtk_sys::gtk_print_quality_get_type()) }
4556    }
4557}
4558
4559impl<'a> FromValueOptional<'a> for PrintQuality {
4560    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
4561        Some(FromValue::from_value(value))
4562    }
4563}
4564
4565impl<'a> FromValue<'a> for PrintQuality {
4566    unsafe fn from_value(value: &Value) -> Self {
4567        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
4568    }
4569}
4570
4571impl SetValue for PrintQuality {
4572    unsafe fn set_value(value: &mut Value, this: &Self) {
4573        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
4574    }
4575}
4576
4577#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4578pub enum PrintStatus {
4579    Initial,
4580    Preparing,
4581    GeneratingData,
4582    SendingData,
4583    Pending,
4584    PendingIssue,
4585    Printing,
4586    Finished,
4587    FinishedAborted,
4588    #[doc(hidden)]
4589    __Unknown(i32),
4590}
4591
4592impl fmt::Display for PrintStatus {
4593    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4594        write!(
4595            f,
4596            "PrintStatus::{}",
4597            match *self {
4598                PrintStatus::Initial => "Initial",
4599                PrintStatus::Preparing => "Preparing",
4600                PrintStatus::GeneratingData => "GeneratingData",
4601                PrintStatus::SendingData => "SendingData",
4602                PrintStatus::Pending => "Pending",
4603                PrintStatus::PendingIssue => "PendingIssue",
4604                PrintStatus::Printing => "Printing",
4605                PrintStatus::Finished => "Finished",
4606                PrintStatus::FinishedAborted => "FinishedAborted",
4607                _ => "Unknown",
4608            }
4609        )
4610    }
4611}
4612
4613#[doc(hidden)]
4614impl ToGlib for PrintStatus {
4615    type GlibType = gtk_sys::GtkPrintStatus;
4616
4617    fn to_glib(&self) -> gtk_sys::GtkPrintStatus {
4618        match *self {
4619            PrintStatus::Initial => gtk_sys::GTK_PRINT_STATUS_INITIAL,
4620            PrintStatus::Preparing => gtk_sys::GTK_PRINT_STATUS_PREPARING,
4621            PrintStatus::GeneratingData => gtk_sys::GTK_PRINT_STATUS_GENERATING_DATA,
4622            PrintStatus::SendingData => gtk_sys::GTK_PRINT_STATUS_SENDING_DATA,
4623            PrintStatus::Pending => gtk_sys::GTK_PRINT_STATUS_PENDING,
4624            PrintStatus::PendingIssue => gtk_sys::GTK_PRINT_STATUS_PENDING_ISSUE,
4625            PrintStatus::Printing => gtk_sys::GTK_PRINT_STATUS_PRINTING,
4626            PrintStatus::Finished => gtk_sys::GTK_PRINT_STATUS_FINISHED,
4627            PrintStatus::FinishedAborted => gtk_sys::GTK_PRINT_STATUS_FINISHED_ABORTED,
4628            PrintStatus::__Unknown(value) => value,
4629        }
4630    }
4631}
4632
4633#[doc(hidden)]
4634impl FromGlib<gtk_sys::GtkPrintStatus> for PrintStatus {
4635    fn from_glib(value: gtk_sys::GtkPrintStatus) -> Self {
4636        skip_assert_initialized!();
4637        match value {
4638            0 => PrintStatus::Initial,
4639            1 => PrintStatus::Preparing,
4640            2 => PrintStatus::GeneratingData,
4641            3 => PrintStatus::SendingData,
4642            4 => PrintStatus::Pending,
4643            5 => PrintStatus::PendingIssue,
4644            6 => PrintStatus::Printing,
4645            7 => PrintStatus::Finished,
4646            8 => PrintStatus::FinishedAborted,
4647            value => PrintStatus::__Unknown(value),
4648        }
4649    }
4650}
4651
4652impl StaticType for PrintStatus {
4653    fn static_type() -> Type {
4654        unsafe { from_glib(gtk_sys::gtk_print_status_get_type()) }
4655    }
4656}
4657
4658impl<'a> FromValueOptional<'a> for PrintStatus {
4659    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
4660        Some(FromValue::from_value(value))
4661    }
4662}
4663
4664impl<'a> FromValue<'a> for PrintStatus {
4665    unsafe fn from_value(value: &Value) -> Self {
4666        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
4667    }
4668}
4669
4670impl SetValue for PrintStatus {
4671    unsafe fn set_value(value: &mut Value, this: &Self) {
4672        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
4673    }
4674}
4675
4676#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4677pub enum PropagationPhase {
4678    None,
4679    Capture,
4680    Bubble,
4681    Target,
4682    #[doc(hidden)]
4683    __Unknown(i32),
4684}
4685
4686impl fmt::Display for PropagationPhase {
4687    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4688        write!(
4689            f,
4690            "PropagationPhase::{}",
4691            match *self {
4692                PropagationPhase::None => "None",
4693                PropagationPhase::Capture => "Capture",
4694                PropagationPhase::Bubble => "Bubble",
4695                PropagationPhase::Target => "Target",
4696                _ => "Unknown",
4697            }
4698        )
4699    }
4700}
4701
4702#[doc(hidden)]
4703impl ToGlib for PropagationPhase {
4704    type GlibType = gtk_sys::GtkPropagationPhase;
4705
4706    fn to_glib(&self) -> gtk_sys::GtkPropagationPhase {
4707        match *self {
4708            PropagationPhase::None => gtk_sys::GTK_PHASE_NONE,
4709            PropagationPhase::Capture => gtk_sys::GTK_PHASE_CAPTURE,
4710            PropagationPhase::Bubble => gtk_sys::GTK_PHASE_BUBBLE,
4711            PropagationPhase::Target => gtk_sys::GTK_PHASE_TARGET,
4712            PropagationPhase::__Unknown(value) => value,
4713        }
4714    }
4715}
4716
4717#[doc(hidden)]
4718impl FromGlib<gtk_sys::GtkPropagationPhase> for PropagationPhase {
4719    fn from_glib(value: gtk_sys::GtkPropagationPhase) -> Self {
4720        skip_assert_initialized!();
4721        match value {
4722            0 => PropagationPhase::None,
4723            1 => PropagationPhase::Capture,
4724            2 => PropagationPhase::Bubble,
4725            3 => PropagationPhase::Target,
4726            value => PropagationPhase::__Unknown(value),
4727        }
4728    }
4729}
4730
4731impl StaticType for PropagationPhase {
4732    fn static_type() -> Type {
4733        unsafe { from_glib(gtk_sys::gtk_propagation_phase_get_type()) }
4734    }
4735}
4736
4737impl<'a> FromValueOptional<'a> for PropagationPhase {
4738    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
4739        Some(FromValue::from_value(value))
4740    }
4741}
4742
4743impl<'a> FromValue<'a> for PropagationPhase {
4744    unsafe fn from_value(value: &Value) -> Self {
4745        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
4746    }
4747}
4748
4749impl SetValue for PropagationPhase {
4750    unsafe fn set_value(value: &mut Value, this: &Self) {
4751        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
4752    }
4753}
4754
4755#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4756pub enum RecentChooserError {
4757    NotFound,
4758    InvalidUri,
4759    #[doc(hidden)]
4760    __Unknown(i32),
4761}
4762
4763impl fmt::Display for RecentChooserError {
4764    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4765        write!(
4766            f,
4767            "RecentChooserError::{}",
4768            match *self {
4769                RecentChooserError::NotFound => "NotFound",
4770                RecentChooserError::InvalidUri => "InvalidUri",
4771                _ => "Unknown",
4772            }
4773        )
4774    }
4775}
4776
4777#[doc(hidden)]
4778impl ToGlib for RecentChooserError {
4779    type GlibType = gtk_sys::GtkRecentChooserError;
4780
4781    fn to_glib(&self) -> gtk_sys::GtkRecentChooserError {
4782        match *self {
4783            RecentChooserError::NotFound => gtk_sys::GTK_RECENT_CHOOSER_ERROR_NOT_FOUND,
4784            RecentChooserError::InvalidUri => gtk_sys::GTK_RECENT_CHOOSER_ERROR_INVALID_URI,
4785            RecentChooserError::__Unknown(value) => value,
4786        }
4787    }
4788}
4789
4790#[doc(hidden)]
4791impl FromGlib<gtk_sys::GtkRecentChooserError> for RecentChooserError {
4792    fn from_glib(value: gtk_sys::GtkRecentChooserError) -> Self {
4793        skip_assert_initialized!();
4794        match value {
4795            0 => RecentChooserError::NotFound,
4796            1 => RecentChooserError::InvalidUri,
4797            value => RecentChooserError::__Unknown(value),
4798        }
4799    }
4800}
4801
4802impl ErrorDomain for RecentChooserError {
4803    fn domain() -> Quark {
4804        skip_assert_initialized!();
4805        unsafe { from_glib(gtk_sys::gtk_recent_chooser_error_quark()) }
4806    }
4807
4808    fn code(self) -> i32 {
4809        self.to_glib()
4810    }
4811
4812    fn from(code: i32) -> Option<Self> {
4813        skip_assert_initialized!();
4814        match code {
4815            0 => Some(RecentChooserError::NotFound),
4816            1 => Some(RecentChooserError::InvalidUri),
4817            value => Some(RecentChooserError::__Unknown(value)),
4818        }
4819    }
4820}
4821
4822impl StaticType for RecentChooserError {
4823    fn static_type() -> Type {
4824        unsafe { from_glib(gtk_sys::gtk_recent_chooser_error_get_type()) }
4825    }
4826}
4827
4828impl<'a> FromValueOptional<'a> for RecentChooserError {
4829    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
4830        Some(FromValue::from_value(value))
4831    }
4832}
4833
4834impl<'a> FromValue<'a> for RecentChooserError {
4835    unsafe fn from_value(value: &Value) -> Self {
4836        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
4837    }
4838}
4839
4840impl SetValue for RecentChooserError {
4841    unsafe fn set_value(value: &mut Value, this: &Self) {
4842        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
4843    }
4844}
4845
4846#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4847pub enum RecentManagerError {
4848    NotFound,
4849    InvalidUri,
4850    InvalidEncoding,
4851    NotRegistered,
4852    Read,
4853    Write,
4854    Unknown,
4855    #[doc(hidden)]
4856    __Unknown(i32),
4857}
4858
4859impl fmt::Display for RecentManagerError {
4860    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4861        write!(
4862            f,
4863            "RecentManagerError::{}",
4864            match *self {
4865                RecentManagerError::NotFound => "NotFound",
4866                RecentManagerError::InvalidUri => "InvalidUri",
4867                RecentManagerError::InvalidEncoding => "InvalidEncoding",
4868                RecentManagerError::NotRegistered => "NotRegistered",
4869                RecentManagerError::Read => "Read",
4870                RecentManagerError::Write => "Write",
4871                RecentManagerError::Unknown => "Unknown",
4872                _ => "Unknown",
4873            }
4874        )
4875    }
4876}
4877
4878#[doc(hidden)]
4879impl ToGlib for RecentManagerError {
4880    type GlibType = gtk_sys::GtkRecentManagerError;
4881
4882    fn to_glib(&self) -> gtk_sys::GtkRecentManagerError {
4883        match *self {
4884            RecentManagerError::NotFound => gtk_sys::GTK_RECENT_MANAGER_ERROR_NOT_FOUND,
4885            RecentManagerError::InvalidUri => gtk_sys::GTK_RECENT_MANAGER_ERROR_INVALID_URI,
4886            RecentManagerError::InvalidEncoding => {
4887                gtk_sys::GTK_RECENT_MANAGER_ERROR_INVALID_ENCODING
4888            }
4889            RecentManagerError::NotRegistered => gtk_sys::GTK_RECENT_MANAGER_ERROR_NOT_REGISTERED,
4890            RecentManagerError::Read => gtk_sys::GTK_RECENT_MANAGER_ERROR_READ,
4891            RecentManagerError::Write => gtk_sys::GTK_RECENT_MANAGER_ERROR_WRITE,
4892            RecentManagerError::Unknown => gtk_sys::GTK_RECENT_MANAGER_ERROR_UNKNOWN,
4893            RecentManagerError::__Unknown(value) => value,
4894        }
4895    }
4896}
4897
4898#[doc(hidden)]
4899impl FromGlib<gtk_sys::GtkRecentManagerError> for RecentManagerError {
4900    fn from_glib(value: gtk_sys::GtkRecentManagerError) -> Self {
4901        skip_assert_initialized!();
4902        match value {
4903            0 => RecentManagerError::NotFound,
4904            1 => RecentManagerError::InvalidUri,
4905            2 => RecentManagerError::InvalidEncoding,
4906            3 => RecentManagerError::NotRegistered,
4907            4 => RecentManagerError::Read,
4908            5 => RecentManagerError::Write,
4909            6 => RecentManagerError::Unknown,
4910            value => RecentManagerError::__Unknown(value),
4911        }
4912    }
4913}
4914
4915impl ErrorDomain for RecentManagerError {
4916    fn domain() -> Quark {
4917        skip_assert_initialized!();
4918        unsafe { from_glib(gtk_sys::gtk_recent_manager_error_quark()) }
4919    }
4920
4921    fn code(self) -> i32 {
4922        self.to_glib()
4923    }
4924
4925    fn from(code: i32) -> Option<Self> {
4926        skip_assert_initialized!();
4927        match code {
4928            0 => Some(RecentManagerError::NotFound),
4929            1 => Some(RecentManagerError::InvalidUri),
4930            2 => Some(RecentManagerError::InvalidEncoding),
4931            3 => Some(RecentManagerError::NotRegistered),
4932            4 => Some(RecentManagerError::Read),
4933            5 => Some(RecentManagerError::Write),
4934            6 => Some(RecentManagerError::Unknown),
4935            value => Some(RecentManagerError::__Unknown(value)),
4936        }
4937    }
4938}
4939
4940impl StaticType for RecentManagerError {
4941    fn static_type() -> Type {
4942        unsafe { from_glib(gtk_sys::gtk_recent_manager_error_get_type()) }
4943    }
4944}
4945
4946impl<'a> FromValueOptional<'a> for RecentManagerError {
4947    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
4948        Some(FromValue::from_value(value))
4949    }
4950}
4951
4952impl<'a> FromValue<'a> for RecentManagerError {
4953    unsafe fn from_value(value: &Value) -> Self {
4954        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
4955    }
4956}
4957
4958impl SetValue for RecentManagerError {
4959    unsafe fn set_value(value: &mut Value, this: &Self) {
4960        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
4961    }
4962}
4963
4964#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4965pub enum RecentSortType {
4966    None,
4967    Mru,
4968    Lru,
4969    Custom,
4970    #[doc(hidden)]
4971    __Unknown(i32),
4972}
4973
4974impl fmt::Display for RecentSortType {
4975    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
4976        write!(
4977            f,
4978            "RecentSortType::{}",
4979            match *self {
4980                RecentSortType::None => "None",
4981                RecentSortType::Mru => "Mru",
4982                RecentSortType::Lru => "Lru",
4983                RecentSortType::Custom => "Custom",
4984                _ => "Unknown",
4985            }
4986        )
4987    }
4988}
4989
4990#[doc(hidden)]
4991impl ToGlib for RecentSortType {
4992    type GlibType = gtk_sys::GtkRecentSortType;
4993
4994    fn to_glib(&self) -> gtk_sys::GtkRecentSortType {
4995        match *self {
4996            RecentSortType::None => gtk_sys::GTK_RECENT_SORT_NONE,
4997            RecentSortType::Mru => gtk_sys::GTK_RECENT_SORT_MRU,
4998            RecentSortType::Lru => gtk_sys::GTK_RECENT_SORT_LRU,
4999            RecentSortType::Custom => gtk_sys::GTK_RECENT_SORT_CUSTOM,
5000            RecentSortType::__Unknown(value) => value,
5001        }
5002    }
5003}
5004
5005#[doc(hidden)]
5006impl FromGlib<gtk_sys::GtkRecentSortType> for RecentSortType {
5007    fn from_glib(value: gtk_sys::GtkRecentSortType) -> Self {
5008        skip_assert_initialized!();
5009        match value {
5010            0 => RecentSortType::None,
5011            1 => RecentSortType::Mru,
5012            2 => RecentSortType::Lru,
5013            3 => RecentSortType::Custom,
5014            value => RecentSortType::__Unknown(value),
5015        }
5016    }
5017}
5018
5019impl StaticType for RecentSortType {
5020    fn static_type() -> Type {
5021        unsafe { from_glib(gtk_sys::gtk_recent_sort_type_get_type()) }
5022    }
5023}
5024
5025impl<'a> FromValueOptional<'a> for RecentSortType {
5026    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
5027        Some(FromValue::from_value(value))
5028    }
5029}
5030
5031impl<'a> FromValue<'a> for RecentSortType {
5032    unsafe fn from_value(value: &Value) -> Self {
5033        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
5034    }
5035}
5036
5037impl SetValue for RecentSortType {
5038    unsafe fn set_value(value: &mut Value, this: &Self) {
5039        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
5040    }
5041}
5042
5043#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5044pub enum ReliefStyle {
5045    Normal,
5046    Half,
5047    None,
5048    #[doc(hidden)]
5049    __Unknown(i32),
5050}
5051
5052impl fmt::Display for ReliefStyle {
5053    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
5054        write!(
5055            f,
5056            "ReliefStyle::{}",
5057            match *self {
5058                ReliefStyle::Normal => "Normal",
5059                ReliefStyle::Half => "Half",
5060                ReliefStyle::None => "None",
5061                _ => "Unknown",
5062            }
5063        )
5064    }
5065}
5066
5067#[doc(hidden)]
5068impl ToGlib for ReliefStyle {
5069    type GlibType = gtk_sys::GtkReliefStyle;
5070
5071    fn to_glib(&self) -> gtk_sys::GtkReliefStyle {
5072        match *self {
5073            ReliefStyle::Normal => gtk_sys::GTK_RELIEF_NORMAL,
5074            ReliefStyle::Half => gtk_sys::GTK_RELIEF_HALF,
5075            ReliefStyle::None => gtk_sys::GTK_RELIEF_NONE,
5076            ReliefStyle::__Unknown(value) => value,
5077        }
5078    }
5079}
5080
5081#[doc(hidden)]
5082impl FromGlib<gtk_sys::GtkReliefStyle> for ReliefStyle {
5083    fn from_glib(value: gtk_sys::GtkReliefStyle) -> Self {
5084        skip_assert_initialized!();
5085        match value {
5086            0 => ReliefStyle::Normal,
5087            1 => ReliefStyle::Half,
5088            2 => ReliefStyle::None,
5089            value => ReliefStyle::__Unknown(value),
5090        }
5091    }
5092}
5093
5094impl StaticType for ReliefStyle {
5095    fn static_type() -> Type {
5096        unsafe { from_glib(gtk_sys::gtk_relief_style_get_type()) }
5097    }
5098}
5099
5100impl<'a> FromValueOptional<'a> for ReliefStyle {
5101    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
5102        Some(FromValue::from_value(value))
5103    }
5104}
5105
5106impl<'a> FromValue<'a> for ReliefStyle {
5107    unsafe fn from_value(value: &Value) -> Self {
5108        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
5109    }
5110}
5111
5112impl SetValue for ReliefStyle {
5113    unsafe fn set_value(value: &mut Value, this: &Self) {
5114        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
5115    }
5116}
5117
5118#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5119pub enum ResizeMode {
5120    Parent,
5121    Queue,
5122    Immediate,
5123    #[doc(hidden)]
5124    __Unknown(i32),
5125}
5126
5127impl fmt::Display for ResizeMode {
5128    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
5129        write!(
5130            f,
5131            "ResizeMode::{}",
5132            match *self {
5133                ResizeMode::Parent => "Parent",
5134                ResizeMode::Queue => "Queue",
5135                ResizeMode::Immediate => "Immediate",
5136                _ => "Unknown",
5137            }
5138        )
5139    }
5140}
5141
5142#[doc(hidden)]
5143impl ToGlib for ResizeMode {
5144    type GlibType = gtk_sys::GtkResizeMode;
5145
5146    fn to_glib(&self) -> gtk_sys::GtkResizeMode {
5147        match *self {
5148            ResizeMode::Parent => gtk_sys::GTK_RESIZE_PARENT,
5149            ResizeMode::Queue => gtk_sys::GTK_RESIZE_QUEUE,
5150            ResizeMode::Immediate => gtk_sys::GTK_RESIZE_IMMEDIATE,
5151            ResizeMode::__Unknown(value) => value,
5152        }
5153    }
5154}
5155
5156#[doc(hidden)]
5157impl FromGlib<gtk_sys::GtkResizeMode> for ResizeMode {
5158    fn from_glib(value: gtk_sys::GtkResizeMode) -> Self {
5159        skip_assert_initialized!();
5160        match value {
5161            0 => ResizeMode::Parent,
5162            1 => ResizeMode::Queue,
5163            2 => ResizeMode::Immediate,
5164            value => ResizeMode::__Unknown(value),
5165        }
5166    }
5167}
5168
5169impl StaticType for ResizeMode {
5170    fn static_type() -> Type {
5171        unsafe { from_glib(gtk_sys::gtk_resize_mode_get_type()) }
5172    }
5173}
5174
5175impl<'a> FromValueOptional<'a> for ResizeMode {
5176    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
5177        Some(FromValue::from_value(value))
5178    }
5179}
5180
5181impl<'a> FromValue<'a> for ResizeMode {
5182    unsafe fn from_value(value: &Value) -> Self {
5183        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
5184    }
5185}
5186
5187impl SetValue for ResizeMode {
5188    unsafe fn set_value(value: &mut Value, this: &Self) {
5189        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
5190    }
5191}
5192
5193#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5194pub enum RevealerTransitionType {
5195    None,
5196    Crossfade,
5197    SlideRight,
5198    SlideLeft,
5199    SlideUp,
5200    SlideDown,
5201    #[doc(hidden)]
5202    __Unknown(i32),
5203}
5204
5205impl fmt::Display for RevealerTransitionType {
5206    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
5207        write!(
5208            f,
5209            "RevealerTransitionType::{}",
5210            match *self {
5211                RevealerTransitionType::None => "None",
5212                RevealerTransitionType::Crossfade => "Crossfade",
5213                RevealerTransitionType::SlideRight => "SlideRight",
5214                RevealerTransitionType::SlideLeft => "SlideLeft",
5215                RevealerTransitionType::SlideUp => "SlideUp",
5216                RevealerTransitionType::SlideDown => "SlideDown",
5217                _ => "Unknown",
5218            }
5219        )
5220    }
5221}
5222
5223#[doc(hidden)]
5224impl ToGlib for RevealerTransitionType {
5225    type GlibType = gtk_sys::GtkRevealerTransitionType;
5226
5227    fn to_glib(&self) -> gtk_sys::GtkRevealerTransitionType {
5228        match *self {
5229            RevealerTransitionType::None => gtk_sys::GTK_REVEALER_TRANSITION_TYPE_NONE,
5230            RevealerTransitionType::Crossfade => gtk_sys::GTK_REVEALER_TRANSITION_TYPE_CROSSFADE,
5231            RevealerTransitionType::SlideRight => gtk_sys::GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT,
5232            RevealerTransitionType::SlideLeft => gtk_sys::GTK_REVEALER_TRANSITION_TYPE_SLIDE_LEFT,
5233            RevealerTransitionType::SlideUp => gtk_sys::GTK_REVEALER_TRANSITION_TYPE_SLIDE_UP,
5234            RevealerTransitionType::SlideDown => gtk_sys::GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN,
5235            RevealerTransitionType::__Unknown(value) => value,
5236        }
5237    }
5238}
5239
5240#[doc(hidden)]
5241impl FromGlib<gtk_sys::GtkRevealerTransitionType> for RevealerTransitionType {
5242    fn from_glib(value: gtk_sys::GtkRevealerTransitionType) -> Self {
5243        skip_assert_initialized!();
5244        match value {
5245            0 => RevealerTransitionType::None,
5246            1 => RevealerTransitionType::Crossfade,
5247            2 => RevealerTransitionType::SlideRight,
5248            3 => RevealerTransitionType::SlideLeft,
5249            4 => RevealerTransitionType::SlideUp,
5250            5 => RevealerTransitionType::SlideDown,
5251            value => RevealerTransitionType::__Unknown(value),
5252        }
5253    }
5254}
5255
5256impl StaticType for RevealerTransitionType {
5257    fn static_type() -> Type {
5258        unsafe { from_glib(gtk_sys::gtk_revealer_transition_type_get_type()) }
5259    }
5260}
5261
5262impl<'a> FromValueOptional<'a> for RevealerTransitionType {
5263    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
5264        Some(FromValue::from_value(value))
5265    }
5266}
5267
5268impl<'a> FromValue<'a> for RevealerTransitionType {
5269    unsafe fn from_value(value: &Value) -> Self {
5270        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
5271    }
5272}
5273
5274impl SetValue for RevealerTransitionType {
5275    unsafe fn set_value(value: &mut Value, this: &Self) {
5276        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
5277    }
5278}
5279
5280#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5281pub enum ScrollStep {
5282    Steps,
5283    Pages,
5284    Ends,
5285    HorizontalSteps,
5286    HorizontalPages,
5287    HorizontalEnds,
5288    #[doc(hidden)]
5289    __Unknown(i32),
5290}
5291
5292impl fmt::Display for ScrollStep {
5293    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
5294        write!(
5295            f,
5296            "ScrollStep::{}",
5297            match *self {
5298                ScrollStep::Steps => "Steps",
5299                ScrollStep::Pages => "Pages",
5300                ScrollStep::Ends => "Ends",
5301                ScrollStep::HorizontalSteps => "HorizontalSteps",
5302                ScrollStep::HorizontalPages => "HorizontalPages",
5303                ScrollStep::HorizontalEnds => "HorizontalEnds",
5304                _ => "Unknown",
5305            }
5306        )
5307    }
5308}
5309
5310#[doc(hidden)]
5311impl ToGlib for ScrollStep {
5312    type GlibType = gtk_sys::GtkScrollStep;
5313
5314    fn to_glib(&self) -> gtk_sys::GtkScrollStep {
5315        match *self {
5316            ScrollStep::Steps => gtk_sys::GTK_SCROLL_STEPS,
5317            ScrollStep::Pages => gtk_sys::GTK_SCROLL_PAGES,
5318            ScrollStep::Ends => gtk_sys::GTK_SCROLL_ENDS,
5319            ScrollStep::HorizontalSteps => gtk_sys::GTK_SCROLL_HORIZONTAL_STEPS,
5320            ScrollStep::HorizontalPages => gtk_sys::GTK_SCROLL_HORIZONTAL_PAGES,
5321            ScrollStep::HorizontalEnds => gtk_sys::GTK_SCROLL_HORIZONTAL_ENDS,
5322            ScrollStep::__Unknown(value) => value,
5323        }
5324    }
5325}
5326
5327#[doc(hidden)]
5328impl FromGlib<gtk_sys::GtkScrollStep> for ScrollStep {
5329    fn from_glib(value: gtk_sys::GtkScrollStep) -> Self {
5330        skip_assert_initialized!();
5331        match value {
5332            0 => ScrollStep::Steps,
5333            1 => ScrollStep::Pages,
5334            2 => ScrollStep::Ends,
5335            3 => ScrollStep::HorizontalSteps,
5336            4 => ScrollStep::HorizontalPages,
5337            5 => ScrollStep::HorizontalEnds,
5338            value => ScrollStep::__Unknown(value),
5339        }
5340    }
5341}
5342
5343impl StaticType for ScrollStep {
5344    fn static_type() -> Type {
5345        unsafe { from_glib(gtk_sys::gtk_scroll_step_get_type()) }
5346    }
5347}
5348
5349impl<'a> FromValueOptional<'a> for ScrollStep {
5350    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
5351        Some(FromValue::from_value(value))
5352    }
5353}
5354
5355impl<'a> FromValue<'a> for ScrollStep {
5356    unsafe fn from_value(value: &Value) -> Self {
5357        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
5358    }
5359}
5360
5361impl SetValue for ScrollStep {
5362    unsafe fn set_value(value: &mut Value, this: &Self) {
5363        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
5364    }
5365}
5366
5367#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5368pub enum ScrollType {
5369    None,
5370    Jump,
5371    StepBackward,
5372    StepForward,
5373    PageBackward,
5374    PageForward,
5375    StepUp,
5376    StepDown,
5377    PageUp,
5378    PageDown,
5379    StepLeft,
5380    StepRight,
5381    PageLeft,
5382    PageRight,
5383    Start,
5384    End,
5385    #[doc(hidden)]
5386    __Unknown(i32),
5387}
5388
5389impl fmt::Display for ScrollType {
5390    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
5391        write!(
5392            f,
5393            "ScrollType::{}",
5394            match *self {
5395                ScrollType::None => "None",
5396                ScrollType::Jump => "Jump",
5397                ScrollType::StepBackward => "StepBackward",
5398                ScrollType::StepForward => "StepForward",
5399                ScrollType::PageBackward => "PageBackward",
5400                ScrollType::PageForward => "PageForward",
5401                ScrollType::StepUp => "StepUp",
5402                ScrollType::StepDown => "StepDown",
5403                ScrollType::PageUp => "PageUp",
5404                ScrollType::PageDown => "PageDown",
5405                ScrollType::StepLeft => "StepLeft",
5406                ScrollType::StepRight => "StepRight",
5407                ScrollType::PageLeft => "PageLeft",
5408                ScrollType::PageRight => "PageRight",
5409                ScrollType::Start => "Start",
5410                ScrollType::End => "End",
5411                _ => "Unknown",
5412            }
5413        )
5414    }
5415}
5416
5417#[doc(hidden)]
5418impl ToGlib for ScrollType {
5419    type GlibType = gtk_sys::GtkScrollType;
5420
5421    fn to_glib(&self) -> gtk_sys::GtkScrollType {
5422        match *self {
5423            ScrollType::None => gtk_sys::GTK_SCROLL_NONE,
5424            ScrollType::Jump => gtk_sys::GTK_SCROLL_JUMP,
5425            ScrollType::StepBackward => gtk_sys::GTK_SCROLL_STEP_BACKWARD,
5426            ScrollType::StepForward => gtk_sys::GTK_SCROLL_STEP_FORWARD,
5427            ScrollType::PageBackward => gtk_sys::GTK_SCROLL_PAGE_BACKWARD,
5428            ScrollType::PageForward => gtk_sys::GTK_SCROLL_PAGE_FORWARD,
5429            ScrollType::StepUp => gtk_sys::GTK_SCROLL_STEP_UP,
5430            ScrollType::StepDown => gtk_sys::GTK_SCROLL_STEP_DOWN,
5431            ScrollType::PageUp => gtk_sys::GTK_SCROLL_PAGE_UP,
5432            ScrollType::PageDown => gtk_sys::GTK_SCROLL_PAGE_DOWN,
5433            ScrollType::StepLeft => gtk_sys::GTK_SCROLL_STEP_LEFT,
5434            ScrollType::StepRight => gtk_sys::GTK_SCROLL_STEP_RIGHT,
5435            ScrollType::PageLeft => gtk_sys::GTK_SCROLL_PAGE_LEFT,
5436            ScrollType::PageRight => gtk_sys::GTK_SCROLL_PAGE_RIGHT,
5437            ScrollType::Start => gtk_sys::GTK_SCROLL_START,
5438            ScrollType::End => gtk_sys::GTK_SCROLL_END,
5439            ScrollType::__Unknown(value) => value,
5440        }
5441    }
5442}
5443
5444#[doc(hidden)]
5445impl FromGlib<gtk_sys::GtkScrollType> for ScrollType {
5446    fn from_glib(value: gtk_sys::GtkScrollType) -> Self {
5447        skip_assert_initialized!();
5448        match value {
5449            0 => ScrollType::None,
5450            1 => ScrollType::Jump,
5451            2 => ScrollType::StepBackward,
5452            3 => ScrollType::StepForward,
5453            4 => ScrollType::PageBackward,
5454            5 => ScrollType::PageForward,
5455            6 => ScrollType::StepUp,
5456            7 => ScrollType::StepDown,
5457            8 => ScrollType::PageUp,
5458            9 => ScrollType::PageDown,
5459            10 => ScrollType::StepLeft,
5460            11 => ScrollType::StepRight,
5461            12 => ScrollType::PageLeft,
5462            13 => ScrollType::PageRight,
5463            14 => ScrollType::Start,
5464            15 => ScrollType::End,
5465            value => ScrollType::__Unknown(value),
5466        }
5467    }
5468}
5469
5470impl StaticType for ScrollType {
5471    fn static_type() -> Type {
5472        unsafe { from_glib(gtk_sys::gtk_scroll_type_get_type()) }
5473    }
5474}
5475
5476impl<'a> FromValueOptional<'a> for ScrollType {
5477    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
5478        Some(FromValue::from_value(value))
5479    }
5480}
5481
5482impl<'a> FromValue<'a> for ScrollType {
5483    unsafe fn from_value(value: &Value) -> Self {
5484        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
5485    }
5486}
5487
5488impl SetValue for ScrollType {
5489    unsafe fn set_value(value: &mut Value, this: &Self) {
5490        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
5491    }
5492}
5493
5494#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5495pub enum ScrollablePolicy {
5496    Minimum,
5497    Natural,
5498    #[doc(hidden)]
5499    __Unknown(i32),
5500}
5501
5502impl fmt::Display for ScrollablePolicy {
5503    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
5504        write!(
5505            f,
5506            "ScrollablePolicy::{}",
5507            match *self {
5508                ScrollablePolicy::Minimum => "Minimum",
5509                ScrollablePolicy::Natural => "Natural",
5510                _ => "Unknown",
5511            }
5512        )
5513    }
5514}
5515
5516#[doc(hidden)]
5517impl ToGlib for ScrollablePolicy {
5518    type GlibType = gtk_sys::GtkScrollablePolicy;
5519
5520    fn to_glib(&self) -> gtk_sys::GtkScrollablePolicy {
5521        match *self {
5522            ScrollablePolicy::Minimum => gtk_sys::GTK_SCROLL_MINIMUM,
5523            ScrollablePolicy::Natural => gtk_sys::GTK_SCROLL_NATURAL,
5524            ScrollablePolicy::__Unknown(value) => value,
5525        }
5526    }
5527}
5528
5529#[doc(hidden)]
5530impl FromGlib<gtk_sys::GtkScrollablePolicy> for ScrollablePolicy {
5531    fn from_glib(value: gtk_sys::GtkScrollablePolicy) -> Self {
5532        skip_assert_initialized!();
5533        match value {
5534            0 => ScrollablePolicy::Minimum,
5535            1 => ScrollablePolicy::Natural,
5536            value => ScrollablePolicy::__Unknown(value),
5537        }
5538    }
5539}
5540
5541impl StaticType for ScrollablePolicy {
5542    fn static_type() -> Type {
5543        unsafe { from_glib(gtk_sys::gtk_scrollable_policy_get_type()) }
5544    }
5545}
5546
5547impl<'a> FromValueOptional<'a> for ScrollablePolicy {
5548    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
5549        Some(FromValue::from_value(value))
5550    }
5551}
5552
5553impl<'a> FromValue<'a> for ScrollablePolicy {
5554    unsafe fn from_value(value: &Value) -> Self {
5555        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
5556    }
5557}
5558
5559impl SetValue for ScrollablePolicy {
5560    unsafe fn set_value(value: &mut Value, this: &Self) {
5561        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
5562    }
5563}
5564
5565#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5566pub enum SelectionMode {
5567    None,
5568    Single,
5569    Browse,
5570    Multiple,
5571    #[doc(hidden)]
5572    __Unknown(i32),
5573}
5574
5575impl fmt::Display for SelectionMode {
5576    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
5577        write!(
5578            f,
5579            "SelectionMode::{}",
5580            match *self {
5581                SelectionMode::None => "None",
5582                SelectionMode::Single => "Single",
5583                SelectionMode::Browse => "Browse",
5584                SelectionMode::Multiple => "Multiple",
5585                _ => "Unknown",
5586            }
5587        )
5588    }
5589}
5590
5591#[doc(hidden)]
5592impl ToGlib for SelectionMode {
5593    type GlibType = gtk_sys::GtkSelectionMode;
5594
5595    fn to_glib(&self) -> gtk_sys::GtkSelectionMode {
5596        match *self {
5597            SelectionMode::None => gtk_sys::GTK_SELECTION_NONE,
5598            SelectionMode::Single => gtk_sys::GTK_SELECTION_SINGLE,
5599            SelectionMode::Browse => gtk_sys::GTK_SELECTION_BROWSE,
5600            SelectionMode::Multiple => gtk_sys::GTK_SELECTION_MULTIPLE,
5601            SelectionMode::__Unknown(value) => value,
5602        }
5603    }
5604}
5605
5606#[doc(hidden)]
5607impl FromGlib<gtk_sys::GtkSelectionMode> for SelectionMode {
5608    fn from_glib(value: gtk_sys::GtkSelectionMode) -> Self {
5609        skip_assert_initialized!();
5610        match value {
5611            0 => SelectionMode::None,
5612            1 => SelectionMode::Single,
5613            2 => SelectionMode::Browse,
5614            3 => SelectionMode::Multiple,
5615            value => SelectionMode::__Unknown(value),
5616        }
5617    }
5618}
5619
5620impl StaticType for SelectionMode {
5621    fn static_type() -> Type {
5622        unsafe { from_glib(gtk_sys::gtk_selection_mode_get_type()) }
5623    }
5624}
5625
5626impl<'a> FromValueOptional<'a> for SelectionMode {
5627    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
5628        Some(FromValue::from_value(value))
5629    }
5630}
5631
5632impl<'a> FromValue<'a> for SelectionMode {
5633    unsafe fn from_value(value: &Value) -> Self {
5634        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
5635    }
5636}
5637
5638impl SetValue for SelectionMode {
5639    unsafe fn set_value(value: &mut Value, this: &Self) {
5640        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
5641    }
5642}
5643
5644#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5645pub enum SensitivityType {
5646    Auto,
5647    On,
5648    Off,
5649    #[doc(hidden)]
5650    __Unknown(i32),
5651}
5652
5653impl fmt::Display for SensitivityType {
5654    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
5655        write!(
5656            f,
5657            "SensitivityType::{}",
5658            match *self {
5659                SensitivityType::Auto => "Auto",
5660                SensitivityType::On => "On",
5661                SensitivityType::Off => "Off",
5662                _ => "Unknown",
5663            }
5664        )
5665    }
5666}
5667
5668#[doc(hidden)]
5669impl ToGlib for SensitivityType {
5670    type GlibType = gtk_sys::GtkSensitivityType;
5671
5672    fn to_glib(&self) -> gtk_sys::GtkSensitivityType {
5673        match *self {
5674            SensitivityType::Auto => gtk_sys::GTK_SENSITIVITY_AUTO,
5675            SensitivityType::On => gtk_sys::GTK_SENSITIVITY_ON,
5676            SensitivityType::Off => gtk_sys::GTK_SENSITIVITY_OFF,
5677            SensitivityType::__Unknown(value) => value,
5678        }
5679    }
5680}
5681
5682#[doc(hidden)]
5683impl FromGlib<gtk_sys::GtkSensitivityType> for SensitivityType {
5684    fn from_glib(value: gtk_sys::GtkSensitivityType) -> Self {
5685        skip_assert_initialized!();
5686        match value {
5687            0 => SensitivityType::Auto,
5688            1 => SensitivityType::On,
5689            2 => SensitivityType::Off,
5690            value => SensitivityType::__Unknown(value),
5691        }
5692    }
5693}
5694
5695impl StaticType for SensitivityType {
5696    fn static_type() -> Type {
5697        unsafe { from_glib(gtk_sys::gtk_sensitivity_type_get_type()) }
5698    }
5699}
5700
5701impl<'a> FromValueOptional<'a> for SensitivityType {
5702    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
5703        Some(FromValue::from_value(value))
5704    }
5705}
5706
5707impl<'a> FromValue<'a> for SensitivityType {
5708    unsafe fn from_value(value: &Value) -> Self {
5709        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
5710    }
5711}
5712
5713impl SetValue for SensitivityType {
5714    unsafe fn set_value(value: &mut Value, this: &Self) {
5715        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
5716    }
5717}
5718
5719#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5720pub enum ShadowType {
5721    None,
5722    In,
5723    Out,
5724    EtchedIn,
5725    EtchedOut,
5726    #[doc(hidden)]
5727    __Unknown(i32),
5728}
5729
5730impl fmt::Display for ShadowType {
5731    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
5732        write!(
5733            f,
5734            "ShadowType::{}",
5735            match *self {
5736                ShadowType::None => "None",
5737                ShadowType::In => "In",
5738                ShadowType::Out => "Out",
5739                ShadowType::EtchedIn => "EtchedIn",
5740                ShadowType::EtchedOut => "EtchedOut",
5741                _ => "Unknown",
5742            }
5743        )
5744    }
5745}
5746
5747#[doc(hidden)]
5748impl ToGlib for ShadowType {
5749    type GlibType = gtk_sys::GtkShadowType;
5750
5751    fn to_glib(&self) -> gtk_sys::GtkShadowType {
5752        match *self {
5753            ShadowType::None => gtk_sys::GTK_SHADOW_NONE,
5754            ShadowType::In => gtk_sys::GTK_SHADOW_IN,
5755            ShadowType::Out => gtk_sys::GTK_SHADOW_OUT,
5756            ShadowType::EtchedIn => gtk_sys::GTK_SHADOW_ETCHED_IN,
5757            ShadowType::EtchedOut => gtk_sys::GTK_SHADOW_ETCHED_OUT,
5758            ShadowType::__Unknown(value) => value,
5759        }
5760    }
5761}
5762
5763#[doc(hidden)]
5764impl FromGlib<gtk_sys::GtkShadowType> for ShadowType {
5765    fn from_glib(value: gtk_sys::GtkShadowType) -> Self {
5766        skip_assert_initialized!();
5767        match value {
5768            0 => ShadowType::None,
5769            1 => ShadowType::In,
5770            2 => ShadowType::Out,
5771            3 => ShadowType::EtchedIn,
5772            4 => ShadowType::EtchedOut,
5773            value => ShadowType::__Unknown(value),
5774        }
5775    }
5776}
5777
5778impl StaticType for ShadowType {
5779    fn static_type() -> Type {
5780        unsafe { from_glib(gtk_sys::gtk_shadow_type_get_type()) }
5781    }
5782}
5783
5784impl<'a> FromValueOptional<'a> for ShadowType {
5785    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
5786        Some(FromValue::from_value(value))
5787    }
5788}
5789
5790impl<'a> FromValue<'a> for ShadowType {
5791    unsafe fn from_value(value: &Value) -> Self {
5792        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
5793    }
5794}
5795
5796impl SetValue for ShadowType {
5797    unsafe fn set_value(value: &mut Value, this: &Self) {
5798        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
5799    }
5800}
5801
5802#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5803pub enum SizeGroupMode {
5804    None,
5805    Horizontal,
5806    Vertical,
5807    Both,
5808    #[doc(hidden)]
5809    __Unknown(i32),
5810}
5811
5812impl fmt::Display for SizeGroupMode {
5813    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
5814        write!(
5815            f,
5816            "SizeGroupMode::{}",
5817            match *self {
5818                SizeGroupMode::None => "None",
5819                SizeGroupMode::Horizontal => "Horizontal",
5820                SizeGroupMode::Vertical => "Vertical",
5821                SizeGroupMode::Both => "Both",
5822                _ => "Unknown",
5823            }
5824        )
5825    }
5826}
5827
5828#[doc(hidden)]
5829impl ToGlib for SizeGroupMode {
5830    type GlibType = gtk_sys::GtkSizeGroupMode;
5831
5832    fn to_glib(&self) -> gtk_sys::GtkSizeGroupMode {
5833        match *self {
5834            SizeGroupMode::None => gtk_sys::GTK_SIZE_GROUP_NONE,
5835            SizeGroupMode::Horizontal => gtk_sys::GTK_SIZE_GROUP_HORIZONTAL,
5836            SizeGroupMode::Vertical => gtk_sys::GTK_SIZE_GROUP_VERTICAL,
5837            SizeGroupMode::Both => gtk_sys::GTK_SIZE_GROUP_BOTH,
5838            SizeGroupMode::__Unknown(value) => value,
5839        }
5840    }
5841}
5842
5843#[doc(hidden)]
5844impl FromGlib<gtk_sys::GtkSizeGroupMode> for SizeGroupMode {
5845    fn from_glib(value: gtk_sys::GtkSizeGroupMode) -> Self {
5846        skip_assert_initialized!();
5847        match value {
5848            0 => SizeGroupMode::None,
5849            1 => SizeGroupMode::Horizontal,
5850            2 => SizeGroupMode::Vertical,
5851            3 => SizeGroupMode::Both,
5852            value => SizeGroupMode::__Unknown(value),
5853        }
5854    }
5855}
5856
5857impl StaticType for SizeGroupMode {
5858    fn static_type() -> Type {
5859        unsafe { from_glib(gtk_sys::gtk_size_group_mode_get_type()) }
5860    }
5861}
5862
5863impl<'a> FromValueOptional<'a> for SizeGroupMode {
5864    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
5865        Some(FromValue::from_value(value))
5866    }
5867}
5868
5869impl<'a> FromValue<'a> for SizeGroupMode {
5870    unsafe fn from_value(value: &Value) -> Self {
5871        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
5872    }
5873}
5874
5875impl SetValue for SizeGroupMode {
5876    unsafe fn set_value(value: &mut Value, this: &Self) {
5877        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
5878    }
5879}
5880
5881#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5882pub enum SizeRequestMode {
5883    HeightForWidth,
5884    WidthForHeight,
5885    ConstantSize,
5886    #[doc(hidden)]
5887    __Unknown(i32),
5888}
5889
5890impl fmt::Display for SizeRequestMode {
5891    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
5892        write!(
5893            f,
5894            "SizeRequestMode::{}",
5895            match *self {
5896                SizeRequestMode::HeightForWidth => "HeightForWidth",
5897                SizeRequestMode::WidthForHeight => "WidthForHeight",
5898                SizeRequestMode::ConstantSize => "ConstantSize",
5899                _ => "Unknown",
5900            }
5901        )
5902    }
5903}
5904
5905#[doc(hidden)]
5906impl ToGlib for SizeRequestMode {
5907    type GlibType = gtk_sys::GtkSizeRequestMode;
5908
5909    fn to_glib(&self) -> gtk_sys::GtkSizeRequestMode {
5910        match *self {
5911            SizeRequestMode::HeightForWidth => gtk_sys::GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH,
5912            SizeRequestMode::WidthForHeight => gtk_sys::GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT,
5913            SizeRequestMode::ConstantSize => gtk_sys::GTK_SIZE_REQUEST_CONSTANT_SIZE,
5914            SizeRequestMode::__Unknown(value) => value,
5915        }
5916    }
5917}
5918
5919#[doc(hidden)]
5920impl FromGlib<gtk_sys::GtkSizeRequestMode> for SizeRequestMode {
5921    fn from_glib(value: gtk_sys::GtkSizeRequestMode) -> Self {
5922        skip_assert_initialized!();
5923        match value {
5924            0 => SizeRequestMode::HeightForWidth,
5925            1 => SizeRequestMode::WidthForHeight,
5926            2 => SizeRequestMode::ConstantSize,
5927            value => SizeRequestMode::__Unknown(value),
5928        }
5929    }
5930}
5931
5932impl StaticType for SizeRequestMode {
5933    fn static_type() -> Type {
5934        unsafe { from_glib(gtk_sys::gtk_size_request_mode_get_type()) }
5935    }
5936}
5937
5938impl<'a> FromValueOptional<'a> for SizeRequestMode {
5939    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
5940        Some(FromValue::from_value(value))
5941    }
5942}
5943
5944impl<'a> FromValue<'a> for SizeRequestMode {
5945    unsafe fn from_value(value: &Value) -> Self {
5946        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
5947    }
5948}
5949
5950impl SetValue for SizeRequestMode {
5951    unsafe fn set_value(value: &mut Value, this: &Self) {
5952        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
5953    }
5954}
5955
5956#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5957pub enum SortType {
5958    Ascending,
5959    Descending,
5960    #[doc(hidden)]
5961    __Unknown(i32),
5962}
5963
5964impl fmt::Display for SortType {
5965    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
5966        write!(
5967            f,
5968            "SortType::{}",
5969            match *self {
5970                SortType::Ascending => "Ascending",
5971                SortType::Descending => "Descending",
5972                _ => "Unknown",
5973            }
5974        )
5975    }
5976}
5977
5978#[doc(hidden)]
5979impl ToGlib for SortType {
5980    type GlibType = gtk_sys::GtkSortType;
5981
5982    fn to_glib(&self) -> gtk_sys::GtkSortType {
5983        match *self {
5984            SortType::Ascending => gtk_sys::GTK_SORT_ASCENDING,
5985            SortType::Descending => gtk_sys::GTK_SORT_DESCENDING,
5986            SortType::__Unknown(value) => value,
5987        }
5988    }
5989}
5990
5991#[doc(hidden)]
5992impl FromGlib<gtk_sys::GtkSortType> for SortType {
5993    fn from_glib(value: gtk_sys::GtkSortType) -> Self {
5994        skip_assert_initialized!();
5995        match value {
5996            0 => SortType::Ascending,
5997            1 => SortType::Descending,
5998            value => SortType::__Unknown(value),
5999        }
6000    }
6001}
6002
6003impl StaticType for SortType {
6004    fn static_type() -> Type {
6005        unsafe { from_glib(gtk_sys::gtk_sort_type_get_type()) }
6006    }
6007}
6008
6009impl<'a> FromValueOptional<'a> for SortType {
6010    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
6011        Some(FromValue::from_value(value))
6012    }
6013}
6014
6015impl<'a> FromValue<'a> for SortType {
6016    unsafe fn from_value(value: &Value) -> Self {
6017        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
6018    }
6019}
6020
6021impl SetValue for SortType {
6022    unsafe fn set_value(value: &mut Value, this: &Self) {
6023        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
6024    }
6025}
6026
6027#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6028pub enum SpinButtonUpdatePolicy {
6029    Always,
6030    IfValid,
6031    #[doc(hidden)]
6032    __Unknown(i32),
6033}
6034
6035impl fmt::Display for SpinButtonUpdatePolicy {
6036    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6037        write!(
6038            f,
6039            "SpinButtonUpdatePolicy::{}",
6040            match *self {
6041                SpinButtonUpdatePolicy::Always => "Always",
6042                SpinButtonUpdatePolicy::IfValid => "IfValid",
6043                _ => "Unknown",
6044            }
6045        )
6046    }
6047}
6048
6049#[doc(hidden)]
6050impl ToGlib for SpinButtonUpdatePolicy {
6051    type GlibType = gtk_sys::GtkSpinButtonUpdatePolicy;
6052
6053    fn to_glib(&self) -> gtk_sys::GtkSpinButtonUpdatePolicy {
6054        match *self {
6055            SpinButtonUpdatePolicy::Always => gtk_sys::GTK_UPDATE_ALWAYS,
6056            SpinButtonUpdatePolicy::IfValid => gtk_sys::GTK_UPDATE_IF_VALID,
6057            SpinButtonUpdatePolicy::__Unknown(value) => value,
6058        }
6059    }
6060}
6061
6062#[doc(hidden)]
6063impl FromGlib<gtk_sys::GtkSpinButtonUpdatePolicy> for SpinButtonUpdatePolicy {
6064    fn from_glib(value: gtk_sys::GtkSpinButtonUpdatePolicy) -> Self {
6065        skip_assert_initialized!();
6066        match value {
6067            0 => SpinButtonUpdatePolicy::Always,
6068            1 => SpinButtonUpdatePolicy::IfValid,
6069            value => SpinButtonUpdatePolicy::__Unknown(value),
6070        }
6071    }
6072}
6073
6074impl StaticType for SpinButtonUpdatePolicy {
6075    fn static_type() -> Type {
6076        unsafe { from_glib(gtk_sys::gtk_spin_button_update_policy_get_type()) }
6077    }
6078}
6079
6080impl<'a> FromValueOptional<'a> for SpinButtonUpdatePolicy {
6081    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
6082        Some(FromValue::from_value(value))
6083    }
6084}
6085
6086impl<'a> FromValue<'a> for SpinButtonUpdatePolicy {
6087    unsafe fn from_value(value: &Value) -> Self {
6088        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
6089    }
6090}
6091
6092impl SetValue for SpinButtonUpdatePolicy {
6093    unsafe fn set_value(value: &mut Value, this: &Self) {
6094        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
6095    }
6096}
6097
6098#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6099pub enum SpinType {
6100    StepForward,
6101    StepBackward,
6102    PageForward,
6103    PageBackward,
6104    Home,
6105    End,
6106    UserDefined,
6107    #[doc(hidden)]
6108    __Unknown(i32),
6109}
6110
6111impl fmt::Display for SpinType {
6112    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6113        write!(
6114            f,
6115            "SpinType::{}",
6116            match *self {
6117                SpinType::StepForward => "StepForward",
6118                SpinType::StepBackward => "StepBackward",
6119                SpinType::PageForward => "PageForward",
6120                SpinType::PageBackward => "PageBackward",
6121                SpinType::Home => "Home",
6122                SpinType::End => "End",
6123                SpinType::UserDefined => "UserDefined",
6124                _ => "Unknown",
6125            }
6126        )
6127    }
6128}
6129
6130#[doc(hidden)]
6131impl ToGlib for SpinType {
6132    type GlibType = gtk_sys::GtkSpinType;
6133
6134    fn to_glib(&self) -> gtk_sys::GtkSpinType {
6135        match *self {
6136            SpinType::StepForward => gtk_sys::GTK_SPIN_STEP_FORWARD,
6137            SpinType::StepBackward => gtk_sys::GTK_SPIN_STEP_BACKWARD,
6138            SpinType::PageForward => gtk_sys::GTK_SPIN_PAGE_FORWARD,
6139            SpinType::PageBackward => gtk_sys::GTK_SPIN_PAGE_BACKWARD,
6140            SpinType::Home => gtk_sys::GTK_SPIN_HOME,
6141            SpinType::End => gtk_sys::GTK_SPIN_END,
6142            SpinType::UserDefined => gtk_sys::GTK_SPIN_USER_DEFINED,
6143            SpinType::__Unknown(value) => value,
6144        }
6145    }
6146}
6147
6148#[doc(hidden)]
6149impl FromGlib<gtk_sys::GtkSpinType> for SpinType {
6150    fn from_glib(value: gtk_sys::GtkSpinType) -> Self {
6151        skip_assert_initialized!();
6152        match value {
6153            0 => SpinType::StepForward,
6154            1 => SpinType::StepBackward,
6155            2 => SpinType::PageForward,
6156            3 => SpinType::PageBackward,
6157            4 => SpinType::Home,
6158            5 => SpinType::End,
6159            6 => SpinType::UserDefined,
6160            value => SpinType::__Unknown(value),
6161        }
6162    }
6163}
6164
6165impl StaticType for SpinType {
6166    fn static_type() -> Type {
6167        unsafe { from_glib(gtk_sys::gtk_spin_type_get_type()) }
6168    }
6169}
6170
6171impl<'a> FromValueOptional<'a> for SpinType {
6172    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
6173        Some(FromValue::from_value(value))
6174    }
6175}
6176
6177impl<'a> FromValue<'a> for SpinType {
6178    unsafe fn from_value(value: &Value) -> Self {
6179        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
6180    }
6181}
6182
6183impl SetValue for SpinType {
6184    unsafe fn set_value(value: &mut Value, this: &Self) {
6185        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
6186    }
6187}
6188
6189#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6190pub enum StackTransitionType {
6191    None,
6192    Crossfade,
6193    SlideRight,
6194    SlideLeft,
6195    SlideUp,
6196    SlideDown,
6197    SlideLeftRight,
6198    SlideUpDown,
6199    OverUp,
6200    OverDown,
6201    OverLeft,
6202    OverRight,
6203    UnderUp,
6204    UnderDown,
6205    UnderLeft,
6206    UnderRight,
6207    OverUpDown,
6208    OverDownUp,
6209    OverLeftRight,
6210    OverRightLeft,
6211    #[doc(hidden)]
6212    __Unknown(i32),
6213}
6214
6215impl fmt::Display for StackTransitionType {
6216    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6217        write!(
6218            f,
6219            "StackTransitionType::{}",
6220            match *self {
6221                StackTransitionType::None => "None",
6222                StackTransitionType::Crossfade => "Crossfade",
6223                StackTransitionType::SlideRight => "SlideRight",
6224                StackTransitionType::SlideLeft => "SlideLeft",
6225                StackTransitionType::SlideUp => "SlideUp",
6226                StackTransitionType::SlideDown => "SlideDown",
6227                StackTransitionType::SlideLeftRight => "SlideLeftRight",
6228                StackTransitionType::SlideUpDown => "SlideUpDown",
6229                StackTransitionType::OverUp => "OverUp",
6230                StackTransitionType::OverDown => "OverDown",
6231                StackTransitionType::OverLeft => "OverLeft",
6232                StackTransitionType::OverRight => "OverRight",
6233                StackTransitionType::UnderUp => "UnderUp",
6234                StackTransitionType::UnderDown => "UnderDown",
6235                StackTransitionType::UnderLeft => "UnderLeft",
6236                StackTransitionType::UnderRight => "UnderRight",
6237                StackTransitionType::OverUpDown => "OverUpDown",
6238                StackTransitionType::OverDownUp => "OverDownUp",
6239                StackTransitionType::OverLeftRight => "OverLeftRight",
6240                StackTransitionType::OverRightLeft => "OverRightLeft",
6241                _ => "Unknown",
6242            }
6243        )
6244    }
6245}
6246
6247#[doc(hidden)]
6248impl ToGlib for StackTransitionType {
6249    type GlibType = gtk_sys::GtkStackTransitionType;
6250
6251    fn to_glib(&self) -> gtk_sys::GtkStackTransitionType {
6252        match *self {
6253            StackTransitionType::None => gtk_sys::GTK_STACK_TRANSITION_TYPE_NONE,
6254            StackTransitionType::Crossfade => gtk_sys::GTK_STACK_TRANSITION_TYPE_CROSSFADE,
6255            StackTransitionType::SlideRight => gtk_sys::GTK_STACK_TRANSITION_TYPE_SLIDE_RIGHT,
6256            StackTransitionType::SlideLeft => gtk_sys::GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT,
6257            StackTransitionType::SlideUp => gtk_sys::GTK_STACK_TRANSITION_TYPE_SLIDE_UP,
6258            StackTransitionType::SlideDown => gtk_sys::GTK_STACK_TRANSITION_TYPE_SLIDE_DOWN,
6259            StackTransitionType::SlideLeftRight => {
6260                gtk_sys::GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT
6261            }
6262            StackTransitionType::SlideUpDown => gtk_sys::GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN,
6263            StackTransitionType::OverUp => gtk_sys::GTK_STACK_TRANSITION_TYPE_OVER_UP,
6264            StackTransitionType::OverDown => gtk_sys::GTK_STACK_TRANSITION_TYPE_OVER_DOWN,
6265            StackTransitionType::OverLeft => gtk_sys::GTK_STACK_TRANSITION_TYPE_OVER_LEFT,
6266            StackTransitionType::OverRight => gtk_sys::GTK_STACK_TRANSITION_TYPE_OVER_RIGHT,
6267            StackTransitionType::UnderUp => gtk_sys::GTK_STACK_TRANSITION_TYPE_UNDER_UP,
6268            StackTransitionType::UnderDown => gtk_sys::GTK_STACK_TRANSITION_TYPE_UNDER_DOWN,
6269            StackTransitionType::UnderLeft => gtk_sys::GTK_STACK_TRANSITION_TYPE_UNDER_LEFT,
6270            StackTransitionType::UnderRight => gtk_sys::GTK_STACK_TRANSITION_TYPE_UNDER_RIGHT,
6271            StackTransitionType::OverUpDown => gtk_sys::GTK_STACK_TRANSITION_TYPE_OVER_UP_DOWN,
6272            StackTransitionType::OverDownUp => gtk_sys::GTK_STACK_TRANSITION_TYPE_OVER_DOWN_UP,
6273            StackTransitionType::OverLeftRight => {
6274                gtk_sys::GTK_STACK_TRANSITION_TYPE_OVER_LEFT_RIGHT
6275            }
6276            StackTransitionType::OverRightLeft => {
6277                gtk_sys::GTK_STACK_TRANSITION_TYPE_OVER_RIGHT_LEFT
6278            }
6279            StackTransitionType::__Unknown(value) => value,
6280        }
6281    }
6282}
6283
6284#[doc(hidden)]
6285impl FromGlib<gtk_sys::GtkStackTransitionType> for StackTransitionType {
6286    fn from_glib(value: gtk_sys::GtkStackTransitionType) -> Self {
6287        skip_assert_initialized!();
6288        match value {
6289            0 => StackTransitionType::None,
6290            1 => StackTransitionType::Crossfade,
6291            2 => StackTransitionType::SlideRight,
6292            3 => StackTransitionType::SlideLeft,
6293            4 => StackTransitionType::SlideUp,
6294            5 => StackTransitionType::SlideDown,
6295            6 => StackTransitionType::SlideLeftRight,
6296            7 => StackTransitionType::SlideUpDown,
6297            8 => StackTransitionType::OverUp,
6298            9 => StackTransitionType::OverDown,
6299            10 => StackTransitionType::OverLeft,
6300            11 => StackTransitionType::OverRight,
6301            12 => StackTransitionType::UnderUp,
6302            13 => StackTransitionType::UnderDown,
6303            14 => StackTransitionType::UnderLeft,
6304            15 => StackTransitionType::UnderRight,
6305            16 => StackTransitionType::OverUpDown,
6306            17 => StackTransitionType::OverDownUp,
6307            18 => StackTransitionType::OverLeftRight,
6308            19 => StackTransitionType::OverRightLeft,
6309            value => StackTransitionType::__Unknown(value),
6310        }
6311    }
6312}
6313
6314impl StaticType for StackTransitionType {
6315    fn static_type() -> Type {
6316        unsafe { from_glib(gtk_sys::gtk_stack_transition_type_get_type()) }
6317    }
6318}
6319
6320impl<'a> FromValueOptional<'a> for StackTransitionType {
6321    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
6322        Some(FromValue::from_value(value))
6323    }
6324}
6325
6326impl<'a> FromValue<'a> for StackTransitionType {
6327    unsafe fn from_value(value: &Value) -> Self {
6328        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
6329    }
6330}
6331
6332impl SetValue for StackTransitionType {
6333    unsafe fn set_value(value: &mut Value, this: &Self) {
6334        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
6335    }
6336}
6337
6338#[deprecated]
6339#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6340pub enum StateType {
6341    Normal,
6342    Active,
6343    Prelight,
6344    Selected,
6345    Insensitive,
6346    Inconsistent,
6347    Focused,
6348    #[doc(hidden)]
6349    __Unknown(i32),
6350}
6351
6352#[deprecated]
6353impl fmt::Display for StateType {
6354    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6355        write!(
6356            f,
6357            "StateType::{}",
6358            match *self {
6359                StateType::Normal => "Normal",
6360                StateType::Active => "Active",
6361                StateType::Prelight => "Prelight",
6362                StateType::Selected => "Selected",
6363                StateType::Insensitive => "Insensitive",
6364                StateType::Inconsistent => "Inconsistent",
6365                StateType::Focused => "Focused",
6366                _ => "Unknown",
6367            }
6368        )
6369    }
6370}
6371
6372#[deprecated]
6373#[doc(hidden)]
6374impl ToGlib for StateType {
6375    type GlibType = gtk_sys::GtkStateType;
6376
6377    fn to_glib(&self) -> gtk_sys::GtkStateType {
6378        match *self {
6379            StateType::Normal => gtk_sys::GTK_STATE_NORMAL,
6380            StateType::Active => gtk_sys::GTK_STATE_ACTIVE,
6381            StateType::Prelight => gtk_sys::GTK_STATE_PRELIGHT,
6382            StateType::Selected => gtk_sys::GTK_STATE_SELECTED,
6383            StateType::Insensitive => gtk_sys::GTK_STATE_INSENSITIVE,
6384            StateType::Inconsistent => gtk_sys::GTK_STATE_INCONSISTENT,
6385            StateType::Focused => gtk_sys::GTK_STATE_FOCUSED,
6386            StateType::__Unknown(value) => value,
6387        }
6388    }
6389}
6390
6391#[deprecated]
6392#[doc(hidden)]
6393impl FromGlib<gtk_sys::GtkStateType> for StateType {
6394    fn from_glib(value: gtk_sys::GtkStateType) -> Self {
6395        skip_assert_initialized!();
6396        match value {
6397            0 => StateType::Normal,
6398            1 => StateType::Active,
6399            2 => StateType::Prelight,
6400            3 => StateType::Selected,
6401            4 => StateType::Insensitive,
6402            5 => StateType::Inconsistent,
6403            6 => StateType::Focused,
6404            value => StateType::__Unknown(value),
6405        }
6406    }
6407}
6408
6409#[deprecated]
6410impl StaticType for StateType {
6411    fn static_type() -> Type {
6412        unsafe { from_glib(gtk_sys::gtk_state_type_get_type()) }
6413    }
6414}
6415
6416#[deprecated]
6417impl<'a> FromValueOptional<'a> for StateType {
6418    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
6419        Some(FromValue::from_value(value))
6420    }
6421}
6422
6423#[deprecated]
6424impl<'a> FromValue<'a> for StateType {
6425    unsafe fn from_value(value: &Value) -> Self {
6426        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
6427    }
6428}
6429
6430#[deprecated]
6431impl SetValue for StateType {
6432    unsafe fn set_value(value: &mut Value, this: &Self) {
6433        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
6434    }
6435}
6436
6437#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6438pub enum TextDirection {
6439    None,
6440    Ltr,
6441    Rtl,
6442    #[doc(hidden)]
6443    __Unknown(i32),
6444}
6445
6446impl fmt::Display for TextDirection {
6447    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6448        write!(
6449            f,
6450            "TextDirection::{}",
6451            match *self {
6452                TextDirection::None => "None",
6453                TextDirection::Ltr => "Ltr",
6454                TextDirection::Rtl => "Rtl",
6455                _ => "Unknown",
6456            }
6457        )
6458    }
6459}
6460
6461#[doc(hidden)]
6462impl ToGlib for TextDirection {
6463    type GlibType = gtk_sys::GtkTextDirection;
6464
6465    fn to_glib(&self) -> gtk_sys::GtkTextDirection {
6466        match *self {
6467            TextDirection::None => gtk_sys::GTK_TEXT_DIR_NONE,
6468            TextDirection::Ltr => gtk_sys::GTK_TEXT_DIR_LTR,
6469            TextDirection::Rtl => gtk_sys::GTK_TEXT_DIR_RTL,
6470            TextDirection::__Unknown(value) => value,
6471        }
6472    }
6473}
6474
6475#[doc(hidden)]
6476impl FromGlib<gtk_sys::GtkTextDirection> for TextDirection {
6477    fn from_glib(value: gtk_sys::GtkTextDirection) -> Self {
6478        skip_assert_initialized!();
6479        match value {
6480            0 => TextDirection::None,
6481            1 => TextDirection::Ltr,
6482            2 => TextDirection::Rtl,
6483            value => TextDirection::__Unknown(value),
6484        }
6485    }
6486}
6487
6488impl StaticType for TextDirection {
6489    fn static_type() -> Type {
6490        unsafe { from_glib(gtk_sys::gtk_text_direction_get_type()) }
6491    }
6492}
6493
6494impl<'a> FromValueOptional<'a> for TextDirection {
6495    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
6496        Some(FromValue::from_value(value))
6497    }
6498}
6499
6500impl<'a> FromValue<'a> for TextDirection {
6501    unsafe fn from_value(value: &Value) -> Self {
6502        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
6503    }
6504}
6505
6506impl SetValue for TextDirection {
6507    unsafe fn set_value(value: &mut Value, this: &Self) {
6508        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
6509    }
6510}
6511
6512#[cfg(any(feature = "v3_16", feature = "dox"))]
6513#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6514pub enum TextExtendSelection {
6515    Word,
6516    Line,
6517    #[doc(hidden)]
6518    __Unknown(i32),
6519}
6520
6521#[cfg(any(feature = "v3_16", feature = "dox"))]
6522impl fmt::Display for TextExtendSelection {
6523    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6524        write!(
6525            f,
6526            "TextExtendSelection::{}",
6527            match *self {
6528                TextExtendSelection::Word => "Word",
6529                TextExtendSelection::Line => "Line",
6530                _ => "Unknown",
6531            }
6532        )
6533    }
6534}
6535
6536#[cfg(any(feature = "v3_16", feature = "dox"))]
6537#[doc(hidden)]
6538impl ToGlib for TextExtendSelection {
6539    type GlibType = gtk_sys::GtkTextExtendSelection;
6540
6541    fn to_glib(&self) -> gtk_sys::GtkTextExtendSelection {
6542        match *self {
6543            TextExtendSelection::Word => gtk_sys::GTK_TEXT_EXTEND_SELECTION_WORD,
6544            TextExtendSelection::Line => gtk_sys::GTK_TEXT_EXTEND_SELECTION_LINE,
6545            TextExtendSelection::__Unknown(value) => value,
6546        }
6547    }
6548}
6549
6550#[cfg(any(feature = "v3_16", feature = "dox"))]
6551#[doc(hidden)]
6552impl FromGlib<gtk_sys::GtkTextExtendSelection> for TextExtendSelection {
6553    fn from_glib(value: gtk_sys::GtkTextExtendSelection) -> Self {
6554        skip_assert_initialized!();
6555        match value {
6556            0 => TextExtendSelection::Word,
6557            1 => TextExtendSelection::Line,
6558            value => TextExtendSelection::__Unknown(value),
6559        }
6560    }
6561}
6562
6563#[cfg(any(feature = "v3_16", feature = "dox"))]
6564impl StaticType for TextExtendSelection {
6565    fn static_type() -> Type {
6566        unsafe { from_glib(gtk_sys::gtk_text_extend_selection_get_type()) }
6567    }
6568}
6569
6570#[cfg(any(feature = "v3_16", feature = "dox"))]
6571impl<'a> FromValueOptional<'a> for TextExtendSelection {
6572    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
6573        Some(FromValue::from_value(value))
6574    }
6575}
6576
6577#[cfg(any(feature = "v3_16", feature = "dox"))]
6578impl<'a> FromValue<'a> for TextExtendSelection {
6579    unsafe fn from_value(value: &Value) -> Self {
6580        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
6581    }
6582}
6583
6584#[cfg(any(feature = "v3_16", feature = "dox"))]
6585impl SetValue for TextExtendSelection {
6586    unsafe fn set_value(value: &mut Value, this: &Self) {
6587        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
6588    }
6589}
6590
6591#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6592pub enum TextViewLayer {
6593    Below,
6594    Above,
6595    BelowText,
6596    AboveText,
6597    #[doc(hidden)]
6598    __Unknown(i32),
6599}
6600
6601impl fmt::Display for TextViewLayer {
6602    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6603        write!(
6604            f,
6605            "TextViewLayer::{}",
6606            match *self {
6607                TextViewLayer::Below => "Below",
6608                TextViewLayer::Above => "Above",
6609                TextViewLayer::BelowText => "BelowText",
6610                TextViewLayer::AboveText => "AboveText",
6611                _ => "Unknown",
6612            }
6613        )
6614    }
6615}
6616
6617#[doc(hidden)]
6618impl ToGlib for TextViewLayer {
6619    type GlibType = gtk_sys::GtkTextViewLayer;
6620
6621    fn to_glib(&self) -> gtk_sys::GtkTextViewLayer {
6622        match *self {
6623            TextViewLayer::Below => gtk_sys::GTK_TEXT_VIEW_LAYER_BELOW,
6624            TextViewLayer::Above => gtk_sys::GTK_TEXT_VIEW_LAYER_ABOVE,
6625            TextViewLayer::BelowText => gtk_sys::GTK_TEXT_VIEW_LAYER_BELOW_TEXT,
6626            TextViewLayer::AboveText => gtk_sys::GTK_TEXT_VIEW_LAYER_ABOVE_TEXT,
6627            TextViewLayer::__Unknown(value) => value,
6628        }
6629    }
6630}
6631
6632#[doc(hidden)]
6633impl FromGlib<gtk_sys::GtkTextViewLayer> for TextViewLayer {
6634    fn from_glib(value: gtk_sys::GtkTextViewLayer) -> Self {
6635        skip_assert_initialized!();
6636        match value {
6637            0 => TextViewLayer::Below,
6638            1 => TextViewLayer::Above,
6639            2 => TextViewLayer::BelowText,
6640            3 => TextViewLayer::AboveText,
6641            value => TextViewLayer::__Unknown(value),
6642        }
6643    }
6644}
6645
6646impl StaticType for TextViewLayer {
6647    fn static_type() -> Type {
6648        unsafe { from_glib(gtk_sys::gtk_text_view_layer_get_type()) }
6649    }
6650}
6651
6652impl<'a> FromValueOptional<'a> for TextViewLayer {
6653    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
6654        Some(FromValue::from_value(value))
6655    }
6656}
6657
6658impl<'a> FromValue<'a> for TextViewLayer {
6659    unsafe fn from_value(value: &Value) -> Self {
6660        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
6661    }
6662}
6663
6664impl SetValue for TextViewLayer {
6665    unsafe fn set_value(value: &mut Value, this: &Self) {
6666        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
6667    }
6668}
6669
6670#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6671pub enum TextWindowType {
6672    Private,
6673    Widget,
6674    Text,
6675    Left,
6676    Right,
6677    Top,
6678    Bottom,
6679    #[doc(hidden)]
6680    __Unknown(i32),
6681}
6682
6683impl fmt::Display for TextWindowType {
6684    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6685        write!(
6686            f,
6687            "TextWindowType::{}",
6688            match *self {
6689                TextWindowType::Private => "Private",
6690                TextWindowType::Widget => "Widget",
6691                TextWindowType::Text => "Text",
6692                TextWindowType::Left => "Left",
6693                TextWindowType::Right => "Right",
6694                TextWindowType::Top => "Top",
6695                TextWindowType::Bottom => "Bottom",
6696                _ => "Unknown",
6697            }
6698        )
6699    }
6700}
6701
6702#[doc(hidden)]
6703impl ToGlib for TextWindowType {
6704    type GlibType = gtk_sys::GtkTextWindowType;
6705
6706    fn to_glib(&self) -> gtk_sys::GtkTextWindowType {
6707        match *self {
6708            TextWindowType::Private => gtk_sys::GTK_TEXT_WINDOW_PRIVATE,
6709            TextWindowType::Widget => gtk_sys::GTK_TEXT_WINDOW_WIDGET,
6710            TextWindowType::Text => gtk_sys::GTK_TEXT_WINDOW_TEXT,
6711            TextWindowType::Left => gtk_sys::GTK_TEXT_WINDOW_LEFT,
6712            TextWindowType::Right => gtk_sys::GTK_TEXT_WINDOW_RIGHT,
6713            TextWindowType::Top => gtk_sys::GTK_TEXT_WINDOW_TOP,
6714            TextWindowType::Bottom => gtk_sys::GTK_TEXT_WINDOW_BOTTOM,
6715            TextWindowType::__Unknown(value) => value,
6716        }
6717    }
6718}
6719
6720#[doc(hidden)]
6721impl FromGlib<gtk_sys::GtkTextWindowType> for TextWindowType {
6722    fn from_glib(value: gtk_sys::GtkTextWindowType) -> Self {
6723        skip_assert_initialized!();
6724        match value {
6725            0 => TextWindowType::Private,
6726            1 => TextWindowType::Widget,
6727            2 => TextWindowType::Text,
6728            3 => TextWindowType::Left,
6729            4 => TextWindowType::Right,
6730            5 => TextWindowType::Top,
6731            6 => TextWindowType::Bottom,
6732            value => TextWindowType::__Unknown(value),
6733        }
6734    }
6735}
6736
6737impl StaticType for TextWindowType {
6738    fn static_type() -> Type {
6739        unsafe { from_glib(gtk_sys::gtk_text_window_type_get_type()) }
6740    }
6741}
6742
6743impl<'a> FromValueOptional<'a> for TextWindowType {
6744    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
6745        Some(FromValue::from_value(value))
6746    }
6747}
6748
6749impl<'a> FromValue<'a> for TextWindowType {
6750    unsafe fn from_value(value: &Value) -> Self {
6751        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
6752    }
6753}
6754
6755impl SetValue for TextWindowType {
6756    unsafe fn set_value(value: &mut Value, this: &Self) {
6757        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
6758    }
6759}
6760
6761#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6762pub enum ToolbarStyle {
6763    Icons,
6764    Text,
6765    Both,
6766    BothHoriz,
6767    #[doc(hidden)]
6768    __Unknown(i32),
6769}
6770
6771impl fmt::Display for ToolbarStyle {
6772    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6773        write!(
6774            f,
6775            "ToolbarStyle::{}",
6776            match *self {
6777                ToolbarStyle::Icons => "Icons",
6778                ToolbarStyle::Text => "Text",
6779                ToolbarStyle::Both => "Both",
6780                ToolbarStyle::BothHoriz => "BothHoriz",
6781                _ => "Unknown",
6782            }
6783        )
6784    }
6785}
6786
6787#[doc(hidden)]
6788impl ToGlib for ToolbarStyle {
6789    type GlibType = gtk_sys::GtkToolbarStyle;
6790
6791    fn to_glib(&self) -> gtk_sys::GtkToolbarStyle {
6792        match *self {
6793            ToolbarStyle::Icons => gtk_sys::GTK_TOOLBAR_ICONS,
6794            ToolbarStyle::Text => gtk_sys::GTK_TOOLBAR_TEXT,
6795            ToolbarStyle::Both => gtk_sys::GTK_TOOLBAR_BOTH,
6796            ToolbarStyle::BothHoriz => gtk_sys::GTK_TOOLBAR_BOTH_HORIZ,
6797            ToolbarStyle::__Unknown(value) => value,
6798        }
6799    }
6800}
6801
6802#[doc(hidden)]
6803impl FromGlib<gtk_sys::GtkToolbarStyle> for ToolbarStyle {
6804    fn from_glib(value: gtk_sys::GtkToolbarStyle) -> Self {
6805        skip_assert_initialized!();
6806        match value {
6807            0 => ToolbarStyle::Icons,
6808            1 => ToolbarStyle::Text,
6809            2 => ToolbarStyle::Both,
6810            3 => ToolbarStyle::BothHoriz,
6811            value => ToolbarStyle::__Unknown(value),
6812        }
6813    }
6814}
6815
6816impl StaticType for ToolbarStyle {
6817    fn static_type() -> Type {
6818        unsafe { from_glib(gtk_sys::gtk_toolbar_style_get_type()) }
6819    }
6820}
6821
6822impl<'a> FromValueOptional<'a> for ToolbarStyle {
6823    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
6824        Some(FromValue::from_value(value))
6825    }
6826}
6827
6828impl<'a> FromValue<'a> for ToolbarStyle {
6829    unsafe fn from_value(value: &Value) -> Self {
6830        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
6831    }
6832}
6833
6834impl SetValue for ToolbarStyle {
6835    unsafe fn set_value(value: &mut Value, this: &Self) {
6836        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
6837    }
6838}
6839
6840#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6841pub enum TreeViewColumnSizing {
6842    GrowOnly,
6843    Autosize,
6844    Fixed,
6845    #[doc(hidden)]
6846    __Unknown(i32),
6847}
6848
6849impl fmt::Display for TreeViewColumnSizing {
6850    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6851        write!(
6852            f,
6853            "TreeViewColumnSizing::{}",
6854            match *self {
6855                TreeViewColumnSizing::GrowOnly => "GrowOnly",
6856                TreeViewColumnSizing::Autosize => "Autosize",
6857                TreeViewColumnSizing::Fixed => "Fixed",
6858                _ => "Unknown",
6859            }
6860        )
6861    }
6862}
6863
6864#[doc(hidden)]
6865impl ToGlib for TreeViewColumnSizing {
6866    type GlibType = gtk_sys::GtkTreeViewColumnSizing;
6867
6868    fn to_glib(&self) -> gtk_sys::GtkTreeViewColumnSizing {
6869        match *self {
6870            TreeViewColumnSizing::GrowOnly => gtk_sys::GTK_TREE_VIEW_COLUMN_GROW_ONLY,
6871            TreeViewColumnSizing::Autosize => gtk_sys::GTK_TREE_VIEW_COLUMN_AUTOSIZE,
6872            TreeViewColumnSizing::Fixed => gtk_sys::GTK_TREE_VIEW_COLUMN_FIXED,
6873            TreeViewColumnSizing::__Unknown(value) => value,
6874        }
6875    }
6876}
6877
6878#[doc(hidden)]
6879impl FromGlib<gtk_sys::GtkTreeViewColumnSizing> for TreeViewColumnSizing {
6880    fn from_glib(value: gtk_sys::GtkTreeViewColumnSizing) -> Self {
6881        skip_assert_initialized!();
6882        match value {
6883            0 => TreeViewColumnSizing::GrowOnly,
6884            1 => TreeViewColumnSizing::Autosize,
6885            2 => TreeViewColumnSizing::Fixed,
6886            value => TreeViewColumnSizing::__Unknown(value),
6887        }
6888    }
6889}
6890
6891impl StaticType for TreeViewColumnSizing {
6892    fn static_type() -> Type {
6893        unsafe { from_glib(gtk_sys::gtk_tree_view_column_sizing_get_type()) }
6894    }
6895}
6896
6897impl<'a> FromValueOptional<'a> for TreeViewColumnSizing {
6898    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
6899        Some(FromValue::from_value(value))
6900    }
6901}
6902
6903impl<'a> FromValue<'a> for TreeViewColumnSizing {
6904    unsafe fn from_value(value: &Value) -> Self {
6905        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
6906    }
6907}
6908
6909impl SetValue for TreeViewColumnSizing {
6910    unsafe fn set_value(value: &mut Value, this: &Self) {
6911        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
6912    }
6913}
6914
6915#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6916pub enum TreeViewDropPosition {
6917    Before,
6918    After,
6919    IntoOrBefore,
6920    IntoOrAfter,
6921    #[doc(hidden)]
6922    __Unknown(i32),
6923}
6924
6925impl fmt::Display for TreeViewDropPosition {
6926    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
6927        write!(
6928            f,
6929            "TreeViewDropPosition::{}",
6930            match *self {
6931                TreeViewDropPosition::Before => "Before",
6932                TreeViewDropPosition::After => "After",
6933                TreeViewDropPosition::IntoOrBefore => "IntoOrBefore",
6934                TreeViewDropPosition::IntoOrAfter => "IntoOrAfter",
6935                _ => "Unknown",
6936            }
6937        )
6938    }
6939}
6940
6941#[doc(hidden)]
6942impl ToGlib for TreeViewDropPosition {
6943    type GlibType = gtk_sys::GtkTreeViewDropPosition;
6944
6945    fn to_glib(&self) -> gtk_sys::GtkTreeViewDropPosition {
6946        match *self {
6947            TreeViewDropPosition::Before => gtk_sys::GTK_TREE_VIEW_DROP_BEFORE,
6948            TreeViewDropPosition::After => gtk_sys::GTK_TREE_VIEW_DROP_AFTER,
6949            TreeViewDropPosition::IntoOrBefore => gtk_sys::GTK_TREE_VIEW_DROP_INTO_OR_BEFORE,
6950            TreeViewDropPosition::IntoOrAfter => gtk_sys::GTK_TREE_VIEW_DROP_INTO_OR_AFTER,
6951            TreeViewDropPosition::__Unknown(value) => value,
6952        }
6953    }
6954}
6955
6956#[doc(hidden)]
6957impl FromGlib<gtk_sys::GtkTreeViewDropPosition> for TreeViewDropPosition {
6958    fn from_glib(value: gtk_sys::GtkTreeViewDropPosition) -> Self {
6959        skip_assert_initialized!();
6960        match value {
6961            0 => TreeViewDropPosition::Before,
6962            1 => TreeViewDropPosition::After,
6963            2 => TreeViewDropPosition::IntoOrBefore,
6964            3 => TreeViewDropPosition::IntoOrAfter,
6965            value => TreeViewDropPosition::__Unknown(value),
6966        }
6967    }
6968}
6969
6970impl StaticType for TreeViewDropPosition {
6971    fn static_type() -> Type {
6972        unsafe { from_glib(gtk_sys::gtk_tree_view_drop_position_get_type()) }
6973    }
6974}
6975
6976impl<'a> FromValueOptional<'a> for TreeViewDropPosition {
6977    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
6978        Some(FromValue::from_value(value))
6979    }
6980}
6981
6982impl<'a> FromValue<'a> for TreeViewDropPosition {
6983    unsafe fn from_value(value: &Value) -> Self {
6984        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
6985    }
6986}
6987
6988impl SetValue for TreeViewDropPosition {
6989    unsafe fn set_value(value: &mut Value, this: &Self) {
6990        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
6991    }
6992}
6993
6994#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6995pub enum TreeViewGridLines {
6996    None,
6997    Horizontal,
6998    Vertical,
6999    Both,
7000    #[doc(hidden)]
7001    __Unknown(i32),
7002}
7003
7004impl fmt::Display for TreeViewGridLines {
7005    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
7006        write!(
7007            f,
7008            "TreeViewGridLines::{}",
7009            match *self {
7010                TreeViewGridLines::None => "None",
7011                TreeViewGridLines::Horizontal => "Horizontal",
7012                TreeViewGridLines::Vertical => "Vertical",
7013                TreeViewGridLines::Both => "Both",
7014                _ => "Unknown",
7015            }
7016        )
7017    }
7018}
7019
7020#[doc(hidden)]
7021impl ToGlib for TreeViewGridLines {
7022    type GlibType = gtk_sys::GtkTreeViewGridLines;
7023
7024    fn to_glib(&self) -> gtk_sys::GtkTreeViewGridLines {
7025        match *self {
7026            TreeViewGridLines::None => gtk_sys::GTK_TREE_VIEW_GRID_LINES_NONE,
7027            TreeViewGridLines::Horizontal => gtk_sys::GTK_TREE_VIEW_GRID_LINES_HORIZONTAL,
7028            TreeViewGridLines::Vertical => gtk_sys::GTK_TREE_VIEW_GRID_LINES_VERTICAL,
7029            TreeViewGridLines::Both => gtk_sys::GTK_TREE_VIEW_GRID_LINES_BOTH,
7030            TreeViewGridLines::__Unknown(value) => value,
7031        }
7032    }
7033}
7034
7035#[doc(hidden)]
7036impl FromGlib<gtk_sys::GtkTreeViewGridLines> for TreeViewGridLines {
7037    fn from_glib(value: gtk_sys::GtkTreeViewGridLines) -> Self {
7038        skip_assert_initialized!();
7039        match value {
7040            0 => TreeViewGridLines::None,
7041            1 => TreeViewGridLines::Horizontal,
7042            2 => TreeViewGridLines::Vertical,
7043            3 => TreeViewGridLines::Both,
7044            value => TreeViewGridLines::__Unknown(value),
7045        }
7046    }
7047}
7048
7049impl StaticType for TreeViewGridLines {
7050    fn static_type() -> Type {
7051        unsafe { from_glib(gtk_sys::gtk_tree_view_grid_lines_get_type()) }
7052    }
7053}
7054
7055impl<'a> FromValueOptional<'a> for TreeViewGridLines {
7056    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
7057        Some(FromValue::from_value(value))
7058    }
7059}
7060
7061impl<'a> FromValue<'a> for TreeViewGridLines {
7062    unsafe fn from_value(value: &Value) -> Self {
7063        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
7064    }
7065}
7066
7067impl SetValue for TreeViewGridLines {
7068    unsafe fn set_value(value: &mut Value, this: &Self) {
7069        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
7070    }
7071}
7072
7073#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7074pub enum Unit {
7075    None,
7076    Points,
7077    Inch,
7078    Mm,
7079    #[doc(hidden)]
7080    __Unknown(i32),
7081}
7082
7083impl fmt::Display for Unit {
7084    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
7085        write!(
7086            f,
7087            "Unit::{}",
7088            match *self {
7089                Unit::None => "None",
7090                Unit::Points => "Points",
7091                Unit::Inch => "Inch",
7092                Unit::Mm => "Mm",
7093                _ => "Unknown",
7094            }
7095        )
7096    }
7097}
7098
7099#[doc(hidden)]
7100impl ToGlib for Unit {
7101    type GlibType = gtk_sys::GtkUnit;
7102
7103    fn to_glib(&self) -> gtk_sys::GtkUnit {
7104        match *self {
7105            Unit::None => gtk_sys::GTK_UNIT_NONE,
7106            Unit::Points => gtk_sys::GTK_UNIT_POINTS,
7107            Unit::Inch => gtk_sys::GTK_UNIT_INCH,
7108            Unit::Mm => gtk_sys::GTK_UNIT_MM,
7109            Unit::__Unknown(value) => value,
7110        }
7111    }
7112}
7113
7114#[doc(hidden)]
7115impl FromGlib<gtk_sys::GtkUnit> for Unit {
7116    fn from_glib(value: gtk_sys::GtkUnit) -> Self {
7117        skip_assert_initialized!();
7118        match value {
7119            0 => Unit::None,
7120            1 => Unit::Points,
7121            2 => Unit::Inch,
7122            3 => Unit::Mm,
7123            value => Unit::__Unknown(value),
7124        }
7125    }
7126}
7127
7128impl StaticType for Unit {
7129    fn static_type() -> Type {
7130        unsafe { from_glib(gtk_sys::gtk_unit_get_type()) }
7131    }
7132}
7133
7134impl<'a> FromValueOptional<'a> for Unit {
7135    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
7136        Some(FromValue::from_value(value))
7137    }
7138}
7139
7140impl<'a> FromValue<'a> for Unit {
7141    unsafe fn from_value(value: &Value) -> Self {
7142        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
7143    }
7144}
7145
7146impl SetValue for Unit {
7147    unsafe fn set_value(value: &mut Value, this: &Self) {
7148        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
7149    }
7150}
7151
7152#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7153pub enum WidgetHelpType {
7154    Tooltip,
7155    WhatsThis,
7156    #[doc(hidden)]
7157    __Unknown(i32),
7158}
7159
7160impl fmt::Display for WidgetHelpType {
7161    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
7162        write!(
7163            f,
7164            "WidgetHelpType::{}",
7165            match *self {
7166                WidgetHelpType::Tooltip => "Tooltip",
7167                WidgetHelpType::WhatsThis => "WhatsThis",
7168                _ => "Unknown",
7169            }
7170        )
7171    }
7172}
7173
7174#[doc(hidden)]
7175impl ToGlib for WidgetHelpType {
7176    type GlibType = gtk_sys::GtkWidgetHelpType;
7177
7178    fn to_glib(&self) -> gtk_sys::GtkWidgetHelpType {
7179        match *self {
7180            WidgetHelpType::Tooltip => gtk_sys::GTK_WIDGET_HELP_TOOLTIP,
7181            WidgetHelpType::WhatsThis => gtk_sys::GTK_WIDGET_HELP_WHATS_THIS,
7182            WidgetHelpType::__Unknown(value) => value,
7183        }
7184    }
7185}
7186
7187#[doc(hidden)]
7188impl FromGlib<gtk_sys::GtkWidgetHelpType> for WidgetHelpType {
7189    fn from_glib(value: gtk_sys::GtkWidgetHelpType) -> Self {
7190        skip_assert_initialized!();
7191        match value {
7192            0 => WidgetHelpType::Tooltip,
7193            1 => WidgetHelpType::WhatsThis,
7194            value => WidgetHelpType::__Unknown(value),
7195        }
7196    }
7197}
7198
7199impl StaticType for WidgetHelpType {
7200    fn static_type() -> Type {
7201        unsafe { from_glib(gtk_sys::gtk_widget_help_type_get_type()) }
7202    }
7203}
7204
7205impl<'a> FromValueOptional<'a> for WidgetHelpType {
7206    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
7207        Some(FromValue::from_value(value))
7208    }
7209}
7210
7211impl<'a> FromValue<'a> for WidgetHelpType {
7212    unsafe fn from_value(value: &Value) -> Self {
7213        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
7214    }
7215}
7216
7217impl SetValue for WidgetHelpType {
7218    unsafe fn set_value(value: &mut Value, this: &Self) {
7219        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
7220    }
7221}
7222
7223#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7224pub enum WindowPosition {
7225    None,
7226    Center,
7227    Mouse,
7228    CenterAlways,
7229    CenterOnParent,
7230    #[doc(hidden)]
7231    __Unknown(i32),
7232}
7233
7234impl fmt::Display for WindowPosition {
7235    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
7236        write!(
7237            f,
7238            "WindowPosition::{}",
7239            match *self {
7240                WindowPosition::None => "None",
7241                WindowPosition::Center => "Center",
7242                WindowPosition::Mouse => "Mouse",
7243                WindowPosition::CenterAlways => "CenterAlways",
7244                WindowPosition::CenterOnParent => "CenterOnParent",
7245                _ => "Unknown",
7246            }
7247        )
7248    }
7249}
7250
7251#[doc(hidden)]
7252impl ToGlib for WindowPosition {
7253    type GlibType = gtk_sys::GtkWindowPosition;
7254
7255    fn to_glib(&self) -> gtk_sys::GtkWindowPosition {
7256        match *self {
7257            WindowPosition::None => gtk_sys::GTK_WIN_POS_NONE,
7258            WindowPosition::Center => gtk_sys::GTK_WIN_POS_CENTER,
7259            WindowPosition::Mouse => gtk_sys::GTK_WIN_POS_MOUSE,
7260            WindowPosition::CenterAlways => gtk_sys::GTK_WIN_POS_CENTER_ALWAYS,
7261            WindowPosition::CenterOnParent => gtk_sys::GTK_WIN_POS_CENTER_ON_PARENT,
7262            WindowPosition::__Unknown(value) => value,
7263        }
7264    }
7265}
7266
7267#[doc(hidden)]
7268impl FromGlib<gtk_sys::GtkWindowPosition> for WindowPosition {
7269    fn from_glib(value: gtk_sys::GtkWindowPosition) -> Self {
7270        skip_assert_initialized!();
7271        match value {
7272            0 => WindowPosition::None,
7273            1 => WindowPosition::Center,
7274            2 => WindowPosition::Mouse,
7275            3 => WindowPosition::CenterAlways,
7276            4 => WindowPosition::CenterOnParent,
7277            value => WindowPosition::__Unknown(value),
7278        }
7279    }
7280}
7281
7282impl StaticType for WindowPosition {
7283    fn static_type() -> Type {
7284        unsafe { from_glib(gtk_sys::gtk_window_position_get_type()) }
7285    }
7286}
7287
7288impl<'a> FromValueOptional<'a> for WindowPosition {
7289    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
7290        Some(FromValue::from_value(value))
7291    }
7292}
7293
7294impl<'a> FromValue<'a> for WindowPosition {
7295    unsafe fn from_value(value: &Value) -> Self {
7296        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
7297    }
7298}
7299
7300impl SetValue for WindowPosition {
7301    unsafe fn set_value(value: &mut Value, this: &Self) {
7302        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
7303    }
7304}
7305
7306#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7307pub enum WindowType {
7308    Toplevel,
7309    Popup,
7310    #[doc(hidden)]
7311    __Unknown(i32),
7312}
7313
7314impl fmt::Display for WindowType {
7315    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
7316        write!(
7317            f,
7318            "WindowType::{}",
7319            match *self {
7320                WindowType::Toplevel => "Toplevel",
7321                WindowType::Popup => "Popup",
7322                _ => "Unknown",
7323            }
7324        )
7325    }
7326}
7327
7328#[doc(hidden)]
7329impl ToGlib for WindowType {
7330    type GlibType = gtk_sys::GtkWindowType;
7331
7332    fn to_glib(&self) -> gtk_sys::GtkWindowType {
7333        match *self {
7334            WindowType::Toplevel => gtk_sys::GTK_WINDOW_TOPLEVEL,
7335            WindowType::Popup => gtk_sys::GTK_WINDOW_POPUP,
7336            WindowType::__Unknown(value) => value,
7337        }
7338    }
7339}
7340
7341#[doc(hidden)]
7342impl FromGlib<gtk_sys::GtkWindowType> for WindowType {
7343    fn from_glib(value: gtk_sys::GtkWindowType) -> Self {
7344        skip_assert_initialized!();
7345        match value {
7346            0 => WindowType::Toplevel,
7347            1 => WindowType::Popup,
7348            value => WindowType::__Unknown(value),
7349        }
7350    }
7351}
7352
7353impl StaticType for WindowType {
7354    fn static_type() -> Type {
7355        unsafe { from_glib(gtk_sys::gtk_window_type_get_type()) }
7356    }
7357}
7358
7359impl<'a> FromValueOptional<'a> for WindowType {
7360    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
7361        Some(FromValue::from_value(value))
7362    }
7363}
7364
7365impl<'a> FromValue<'a> for WindowType {
7366    unsafe fn from_value(value: &Value) -> Self {
7367        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
7368    }
7369}
7370
7371impl SetValue for WindowType {
7372    unsafe fn set_value(value: &mut Value, this: &Self) {
7373        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
7374    }
7375}
7376
7377#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7378pub enum WrapMode {
7379    None,
7380    Char,
7381    Word,
7382    WordChar,
7383    #[doc(hidden)]
7384    __Unknown(i32),
7385}
7386
7387impl fmt::Display for WrapMode {
7388    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
7389        write!(
7390            f,
7391            "WrapMode::{}",
7392            match *self {
7393                WrapMode::None => "None",
7394                WrapMode::Char => "Char",
7395                WrapMode::Word => "Word",
7396                WrapMode::WordChar => "WordChar",
7397                _ => "Unknown",
7398            }
7399        )
7400    }
7401}
7402
7403#[doc(hidden)]
7404impl ToGlib for WrapMode {
7405    type GlibType = gtk_sys::GtkWrapMode;
7406
7407    fn to_glib(&self) -> gtk_sys::GtkWrapMode {
7408        match *self {
7409            WrapMode::None => gtk_sys::GTK_WRAP_NONE,
7410            WrapMode::Char => gtk_sys::GTK_WRAP_CHAR,
7411            WrapMode::Word => gtk_sys::GTK_WRAP_WORD,
7412            WrapMode::WordChar => gtk_sys::GTK_WRAP_WORD_CHAR,
7413            WrapMode::__Unknown(value) => value,
7414        }
7415    }
7416}
7417
7418#[doc(hidden)]
7419impl FromGlib<gtk_sys::GtkWrapMode> for WrapMode {
7420    fn from_glib(value: gtk_sys::GtkWrapMode) -> Self {
7421        skip_assert_initialized!();
7422        match value {
7423            0 => WrapMode::None,
7424            1 => WrapMode::Char,
7425            2 => WrapMode::Word,
7426            3 => WrapMode::WordChar,
7427            value => WrapMode::__Unknown(value),
7428        }
7429    }
7430}
7431
7432impl StaticType for WrapMode {
7433    fn static_type() -> Type {
7434        unsafe { from_glib(gtk_sys::gtk_wrap_mode_get_type()) }
7435    }
7436}
7437
7438impl<'a> FromValueOptional<'a> for WrapMode {
7439    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
7440        Some(FromValue::from_value(value))
7441    }
7442}
7443
7444impl<'a> FromValue<'a> for WrapMode {
7445    unsafe fn from_value(value: &Value) -> Self {
7446        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
7447    }
7448}
7449
7450impl SetValue for WrapMode {
7451    unsafe fn set_value(value: &mut Value, this: &Self) {
7452        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
7453    }
7454}