gdk/auto/
enums.rs

1// This file was generated by gir (https://github.com/gtk-rs/gir)
2// from gir-files (https://github.com/gtk-rs/gir-files)
3// DO NOT EDIT
4
5use gdk_sys;
6use glib::error::ErrorDomain;
7use glib::translate::*;
8use glib::value::FromValue;
9use glib::value::FromValueOptional;
10use glib::value::SetValue;
11use glib::value::Value;
12use glib::Quark;
13use glib::StaticType;
14use glib::Type;
15use gobject_sys;
16use std::fmt;
17
18#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
19pub enum AxisUse {
20    Ignore,
21    X,
22    Y,
23    Pressure,
24    Xtilt,
25    Ytilt,
26    Wheel,
27    Distance,
28    Rotation,
29    Slider,
30    Last,
31    #[doc(hidden)]
32    __Unknown(i32),
33}
34
35impl fmt::Display for AxisUse {
36    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
37        write!(
38            f,
39            "AxisUse::{}",
40            match *self {
41                AxisUse::Ignore => "Ignore",
42                AxisUse::X => "X",
43                AxisUse::Y => "Y",
44                AxisUse::Pressure => "Pressure",
45                AxisUse::Xtilt => "Xtilt",
46                AxisUse::Ytilt => "Ytilt",
47                AxisUse::Wheel => "Wheel",
48                AxisUse::Distance => "Distance",
49                AxisUse::Rotation => "Rotation",
50                AxisUse::Slider => "Slider",
51                AxisUse::Last => "Last",
52                _ => "Unknown",
53            }
54        )
55    }
56}
57
58#[doc(hidden)]
59impl ToGlib for AxisUse {
60    type GlibType = gdk_sys::GdkAxisUse;
61
62    fn to_glib(&self) -> gdk_sys::GdkAxisUse {
63        match *self {
64            AxisUse::Ignore => gdk_sys::GDK_AXIS_IGNORE,
65            AxisUse::X => gdk_sys::GDK_AXIS_X,
66            AxisUse::Y => gdk_sys::GDK_AXIS_Y,
67            AxisUse::Pressure => gdk_sys::GDK_AXIS_PRESSURE,
68            AxisUse::Xtilt => gdk_sys::GDK_AXIS_XTILT,
69            AxisUse::Ytilt => gdk_sys::GDK_AXIS_YTILT,
70            AxisUse::Wheel => gdk_sys::GDK_AXIS_WHEEL,
71            AxisUse::Distance => gdk_sys::GDK_AXIS_DISTANCE,
72            AxisUse::Rotation => gdk_sys::GDK_AXIS_ROTATION,
73            AxisUse::Slider => gdk_sys::GDK_AXIS_SLIDER,
74            AxisUse::Last => gdk_sys::GDK_AXIS_LAST,
75            AxisUse::__Unknown(value) => value,
76        }
77    }
78}
79
80#[doc(hidden)]
81impl FromGlib<gdk_sys::GdkAxisUse> for AxisUse {
82    fn from_glib(value: gdk_sys::GdkAxisUse) -> Self {
83        skip_assert_initialized!();
84        match value {
85            0 => AxisUse::Ignore,
86            1 => AxisUse::X,
87            2 => AxisUse::Y,
88            3 => AxisUse::Pressure,
89            4 => AxisUse::Xtilt,
90            5 => AxisUse::Ytilt,
91            6 => AxisUse::Wheel,
92            7 => AxisUse::Distance,
93            8 => AxisUse::Rotation,
94            9 => AxisUse::Slider,
95            10 => AxisUse::Last,
96            value => AxisUse::__Unknown(value),
97        }
98    }
99}
100
101impl StaticType for AxisUse {
102    fn static_type() -> Type {
103        unsafe { from_glib(gdk_sys::gdk_axis_use_get_type()) }
104    }
105}
106
107impl<'a> FromValueOptional<'a> for AxisUse {
108    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
109        Some(FromValue::from_value(value))
110    }
111}
112
113impl<'a> FromValue<'a> for AxisUse {
114    unsafe fn from_value(value: &Value) -> Self {
115        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
116    }
117}
118
119impl SetValue for AxisUse {
120    unsafe fn set_value(value: &mut Value, this: &Self) {
121        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
122    }
123}
124
125#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
126pub enum ByteOrder {
127    LsbFirst,
128    MsbFirst,
129    #[doc(hidden)]
130    __Unknown(i32),
131}
132
133impl fmt::Display for ByteOrder {
134    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
135        write!(
136            f,
137            "ByteOrder::{}",
138            match *self {
139                ByteOrder::LsbFirst => "LsbFirst",
140                ByteOrder::MsbFirst => "MsbFirst",
141                _ => "Unknown",
142            }
143        )
144    }
145}
146
147#[doc(hidden)]
148impl ToGlib for ByteOrder {
149    type GlibType = gdk_sys::GdkByteOrder;
150
151    fn to_glib(&self) -> gdk_sys::GdkByteOrder {
152        match *self {
153            ByteOrder::LsbFirst => gdk_sys::GDK_LSB_FIRST,
154            ByteOrder::MsbFirst => gdk_sys::GDK_MSB_FIRST,
155            ByteOrder::__Unknown(value) => value,
156        }
157    }
158}
159
160#[doc(hidden)]
161impl FromGlib<gdk_sys::GdkByteOrder> for ByteOrder {
162    fn from_glib(value: gdk_sys::GdkByteOrder) -> Self {
163        skip_assert_initialized!();
164        match value {
165            0 => ByteOrder::LsbFirst,
166            1 => ByteOrder::MsbFirst,
167            value => ByteOrder::__Unknown(value),
168        }
169    }
170}
171
172impl StaticType for ByteOrder {
173    fn static_type() -> Type {
174        unsafe { from_glib(gdk_sys::gdk_byte_order_get_type()) }
175    }
176}
177
178impl<'a> FromValueOptional<'a> for ByteOrder {
179    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
180        Some(FromValue::from_value(value))
181    }
182}
183
184impl<'a> FromValue<'a> for ByteOrder {
185    unsafe fn from_value(value: &Value) -> Self {
186        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
187    }
188}
189
190impl SetValue for ByteOrder {
191    unsafe fn set_value(value: &mut Value, this: &Self) {
192        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
193    }
194}
195
196#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
197pub enum CrossingMode {
198    Normal,
199    Grab,
200    Ungrab,
201    GtkGrab,
202    GtkUngrab,
203    StateChanged,
204    TouchBegin,
205    TouchEnd,
206    DeviceSwitch,
207    #[doc(hidden)]
208    __Unknown(i32),
209}
210
211impl fmt::Display for CrossingMode {
212    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
213        write!(
214            f,
215            "CrossingMode::{}",
216            match *self {
217                CrossingMode::Normal => "Normal",
218                CrossingMode::Grab => "Grab",
219                CrossingMode::Ungrab => "Ungrab",
220                CrossingMode::GtkGrab => "GtkGrab",
221                CrossingMode::GtkUngrab => "GtkUngrab",
222                CrossingMode::StateChanged => "StateChanged",
223                CrossingMode::TouchBegin => "TouchBegin",
224                CrossingMode::TouchEnd => "TouchEnd",
225                CrossingMode::DeviceSwitch => "DeviceSwitch",
226                _ => "Unknown",
227            }
228        )
229    }
230}
231
232#[doc(hidden)]
233impl ToGlib for CrossingMode {
234    type GlibType = gdk_sys::GdkCrossingMode;
235
236    fn to_glib(&self) -> gdk_sys::GdkCrossingMode {
237        match *self {
238            CrossingMode::Normal => gdk_sys::GDK_CROSSING_NORMAL,
239            CrossingMode::Grab => gdk_sys::GDK_CROSSING_GRAB,
240            CrossingMode::Ungrab => gdk_sys::GDK_CROSSING_UNGRAB,
241            CrossingMode::GtkGrab => gdk_sys::GDK_CROSSING_GTK_GRAB,
242            CrossingMode::GtkUngrab => gdk_sys::GDK_CROSSING_GTK_UNGRAB,
243            CrossingMode::StateChanged => gdk_sys::GDK_CROSSING_STATE_CHANGED,
244            CrossingMode::TouchBegin => gdk_sys::GDK_CROSSING_TOUCH_BEGIN,
245            CrossingMode::TouchEnd => gdk_sys::GDK_CROSSING_TOUCH_END,
246            CrossingMode::DeviceSwitch => gdk_sys::GDK_CROSSING_DEVICE_SWITCH,
247            CrossingMode::__Unknown(value) => value,
248        }
249    }
250}
251
252#[doc(hidden)]
253impl FromGlib<gdk_sys::GdkCrossingMode> for CrossingMode {
254    fn from_glib(value: gdk_sys::GdkCrossingMode) -> Self {
255        skip_assert_initialized!();
256        match value {
257            0 => CrossingMode::Normal,
258            1 => CrossingMode::Grab,
259            2 => CrossingMode::Ungrab,
260            3 => CrossingMode::GtkGrab,
261            4 => CrossingMode::GtkUngrab,
262            5 => CrossingMode::StateChanged,
263            6 => CrossingMode::TouchBegin,
264            7 => CrossingMode::TouchEnd,
265            8 => CrossingMode::DeviceSwitch,
266            value => CrossingMode::__Unknown(value),
267        }
268    }
269}
270
271impl StaticType for CrossingMode {
272    fn static_type() -> Type {
273        unsafe { from_glib(gdk_sys::gdk_crossing_mode_get_type()) }
274    }
275}
276
277impl<'a> FromValueOptional<'a> for CrossingMode {
278    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
279        Some(FromValue::from_value(value))
280    }
281}
282
283impl<'a> FromValue<'a> for CrossingMode {
284    unsafe fn from_value(value: &Value) -> Self {
285        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
286    }
287}
288
289impl SetValue for CrossingMode {
290    unsafe fn set_value(value: &mut Value, this: &Self) {
291        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
292    }
293}
294
295#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
296pub enum CursorType {
297    XCursor,
298    Arrow,
299    BasedArrowDown,
300    BasedArrowUp,
301    Boat,
302    Bogosity,
303    BottomLeftCorner,
304    BottomRightCorner,
305    BottomSide,
306    BottomTee,
307    BoxSpiral,
308    CenterPtr,
309    Circle,
310    Clock,
311    CoffeeMug,
312    Cross,
313    CrossReverse,
314    Crosshair,
315    DiamondCross,
316    Dot,
317    Dotbox,
318    DoubleArrow,
319    DraftLarge,
320    DraftSmall,
321    DrapedBox,
322    Exchange,
323    Fleur,
324    Gobbler,
325    Gumby,
326    Hand1,
327    Hand2,
328    Heart,
329    Icon,
330    IronCross,
331    LeftPtr,
332    LeftSide,
333    LeftTee,
334    Leftbutton,
335    LlAngle,
336    LrAngle,
337    Man,
338    Middlebutton,
339    Mouse,
340    Pencil,
341    Pirate,
342    Plus,
343    QuestionArrow,
344    RightPtr,
345    RightSide,
346    RightTee,
347    Rightbutton,
348    RtlLogo,
349    Sailboat,
350    SbDownArrow,
351    SbHDoubleArrow,
352    SbLeftArrow,
353    SbRightArrow,
354    SbUpArrow,
355    SbVDoubleArrow,
356    Shuttle,
357    Sizing,
358    Spider,
359    Spraycan,
360    Star,
361    Target,
362    Tcross,
363    TopLeftArrow,
364    TopLeftCorner,
365    TopRightCorner,
366    TopSide,
367    TopTee,
368    Trek,
369    UlAngle,
370    Umbrella,
371    UrAngle,
372    Watch,
373    Xterm,
374    LastCursor,
375    BlankCursor,
376    CursorIsPixmap,
377    #[doc(hidden)]
378    __Unknown(i32),
379}
380
381impl fmt::Display for CursorType {
382    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
383        write!(
384            f,
385            "CursorType::{}",
386            match *self {
387                CursorType::XCursor => "XCursor",
388                CursorType::Arrow => "Arrow",
389                CursorType::BasedArrowDown => "BasedArrowDown",
390                CursorType::BasedArrowUp => "BasedArrowUp",
391                CursorType::Boat => "Boat",
392                CursorType::Bogosity => "Bogosity",
393                CursorType::BottomLeftCorner => "BottomLeftCorner",
394                CursorType::BottomRightCorner => "BottomRightCorner",
395                CursorType::BottomSide => "BottomSide",
396                CursorType::BottomTee => "BottomTee",
397                CursorType::BoxSpiral => "BoxSpiral",
398                CursorType::CenterPtr => "CenterPtr",
399                CursorType::Circle => "Circle",
400                CursorType::Clock => "Clock",
401                CursorType::CoffeeMug => "CoffeeMug",
402                CursorType::Cross => "Cross",
403                CursorType::CrossReverse => "CrossReverse",
404                CursorType::Crosshair => "Crosshair",
405                CursorType::DiamondCross => "DiamondCross",
406                CursorType::Dot => "Dot",
407                CursorType::Dotbox => "Dotbox",
408                CursorType::DoubleArrow => "DoubleArrow",
409                CursorType::DraftLarge => "DraftLarge",
410                CursorType::DraftSmall => "DraftSmall",
411                CursorType::DrapedBox => "DrapedBox",
412                CursorType::Exchange => "Exchange",
413                CursorType::Fleur => "Fleur",
414                CursorType::Gobbler => "Gobbler",
415                CursorType::Gumby => "Gumby",
416                CursorType::Hand1 => "Hand1",
417                CursorType::Hand2 => "Hand2",
418                CursorType::Heart => "Heart",
419                CursorType::Icon => "Icon",
420                CursorType::IronCross => "IronCross",
421                CursorType::LeftPtr => "LeftPtr",
422                CursorType::LeftSide => "LeftSide",
423                CursorType::LeftTee => "LeftTee",
424                CursorType::Leftbutton => "Leftbutton",
425                CursorType::LlAngle => "LlAngle",
426                CursorType::LrAngle => "LrAngle",
427                CursorType::Man => "Man",
428                CursorType::Middlebutton => "Middlebutton",
429                CursorType::Mouse => "Mouse",
430                CursorType::Pencil => "Pencil",
431                CursorType::Pirate => "Pirate",
432                CursorType::Plus => "Plus",
433                CursorType::QuestionArrow => "QuestionArrow",
434                CursorType::RightPtr => "RightPtr",
435                CursorType::RightSide => "RightSide",
436                CursorType::RightTee => "RightTee",
437                CursorType::Rightbutton => "Rightbutton",
438                CursorType::RtlLogo => "RtlLogo",
439                CursorType::Sailboat => "Sailboat",
440                CursorType::SbDownArrow => "SbDownArrow",
441                CursorType::SbHDoubleArrow => "SbHDoubleArrow",
442                CursorType::SbLeftArrow => "SbLeftArrow",
443                CursorType::SbRightArrow => "SbRightArrow",
444                CursorType::SbUpArrow => "SbUpArrow",
445                CursorType::SbVDoubleArrow => "SbVDoubleArrow",
446                CursorType::Shuttle => "Shuttle",
447                CursorType::Sizing => "Sizing",
448                CursorType::Spider => "Spider",
449                CursorType::Spraycan => "Spraycan",
450                CursorType::Star => "Star",
451                CursorType::Target => "Target",
452                CursorType::Tcross => "Tcross",
453                CursorType::TopLeftArrow => "TopLeftArrow",
454                CursorType::TopLeftCorner => "TopLeftCorner",
455                CursorType::TopRightCorner => "TopRightCorner",
456                CursorType::TopSide => "TopSide",
457                CursorType::TopTee => "TopTee",
458                CursorType::Trek => "Trek",
459                CursorType::UlAngle => "UlAngle",
460                CursorType::Umbrella => "Umbrella",
461                CursorType::UrAngle => "UrAngle",
462                CursorType::Watch => "Watch",
463                CursorType::Xterm => "Xterm",
464                CursorType::LastCursor => "LastCursor",
465                CursorType::BlankCursor => "BlankCursor",
466                CursorType::CursorIsPixmap => "CursorIsPixmap",
467                _ => "Unknown",
468            }
469        )
470    }
471}
472
473#[doc(hidden)]
474impl ToGlib for CursorType {
475    type GlibType = gdk_sys::GdkCursorType;
476
477    fn to_glib(&self) -> gdk_sys::GdkCursorType {
478        match *self {
479            CursorType::XCursor => gdk_sys::GDK_X_CURSOR,
480            CursorType::Arrow => gdk_sys::GDK_ARROW,
481            CursorType::BasedArrowDown => gdk_sys::GDK_BASED_ARROW_DOWN,
482            CursorType::BasedArrowUp => gdk_sys::GDK_BASED_ARROW_UP,
483            CursorType::Boat => gdk_sys::GDK_BOAT,
484            CursorType::Bogosity => gdk_sys::GDK_BOGOSITY,
485            CursorType::BottomLeftCorner => gdk_sys::GDK_BOTTOM_LEFT_CORNER,
486            CursorType::BottomRightCorner => gdk_sys::GDK_BOTTOM_RIGHT_CORNER,
487            CursorType::BottomSide => gdk_sys::GDK_BOTTOM_SIDE,
488            CursorType::BottomTee => gdk_sys::GDK_BOTTOM_TEE,
489            CursorType::BoxSpiral => gdk_sys::GDK_BOX_SPIRAL,
490            CursorType::CenterPtr => gdk_sys::GDK_CENTER_PTR,
491            CursorType::Circle => gdk_sys::GDK_CIRCLE,
492            CursorType::Clock => gdk_sys::GDK_CLOCK,
493            CursorType::CoffeeMug => gdk_sys::GDK_COFFEE_MUG,
494            CursorType::Cross => gdk_sys::GDK_CROSS,
495            CursorType::CrossReverse => gdk_sys::GDK_CROSS_REVERSE,
496            CursorType::Crosshair => gdk_sys::GDK_CROSSHAIR,
497            CursorType::DiamondCross => gdk_sys::GDK_DIAMOND_CROSS,
498            CursorType::Dot => gdk_sys::GDK_DOT,
499            CursorType::Dotbox => gdk_sys::GDK_DOTBOX,
500            CursorType::DoubleArrow => gdk_sys::GDK_DOUBLE_ARROW,
501            CursorType::DraftLarge => gdk_sys::GDK_DRAFT_LARGE,
502            CursorType::DraftSmall => gdk_sys::GDK_DRAFT_SMALL,
503            CursorType::DrapedBox => gdk_sys::GDK_DRAPED_BOX,
504            CursorType::Exchange => gdk_sys::GDK_EXCHANGE,
505            CursorType::Fleur => gdk_sys::GDK_FLEUR,
506            CursorType::Gobbler => gdk_sys::GDK_GOBBLER,
507            CursorType::Gumby => gdk_sys::GDK_GUMBY,
508            CursorType::Hand1 => gdk_sys::GDK_HAND1,
509            CursorType::Hand2 => gdk_sys::GDK_HAND2,
510            CursorType::Heart => gdk_sys::GDK_HEART,
511            CursorType::Icon => gdk_sys::GDK_ICON,
512            CursorType::IronCross => gdk_sys::GDK_IRON_CROSS,
513            CursorType::LeftPtr => gdk_sys::GDK_LEFT_PTR,
514            CursorType::LeftSide => gdk_sys::GDK_LEFT_SIDE,
515            CursorType::LeftTee => gdk_sys::GDK_LEFT_TEE,
516            CursorType::Leftbutton => gdk_sys::GDK_LEFTBUTTON,
517            CursorType::LlAngle => gdk_sys::GDK_LL_ANGLE,
518            CursorType::LrAngle => gdk_sys::GDK_LR_ANGLE,
519            CursorType::Man => gdk_sys::GDK_MAN,
520            CursorType::Middlebutton => gdk_sys::GDK_MIDDLEBUTTON,
521            CursorType::Mouse => gdk_sys::GDK_MOUSE,
522            CursorType::Pencil => gdk_sys::GDK_PENCIL,
523            CursorType::Pirate => gdk_sys::GDK_PIRATE,
524            CursorType::Plus => gdk_sys::GDK_PLUS,
525            CursorType::QuestionArrow => gdk_sys::GDK_QUESTION_ARROW,
526            CursorType::RightPtr => gdk_sys::GDK_RIGHT_PTR,
527            CursorType::RightSide => gdk_sys::GDK_RIGHT_SIDE,
528            CursorType::RightTee => gdk_sys::GDK_RIGHT_TEE,
529            CursorType::Rightbutton => gdk_sys::GDK_RIGHTBUTTON,
530            CursorType::RtlLogo => gdk_sys::GDK_RTL_LOGO,
531            CursorType::Sailboat => gdk_sys::GDK_SAILBOAT,
532            CursorType::SbDownArrow => gdk_sys::GDK_SB_DOWN_ARROW,
533            CursorType::SbHDoubleArrow => gdk_sys::GDK_SB_H_DOUBLE_ARROW,
534            CursorType::SbLeftArrow => gdk_sys::GDK_SB_LEFT_ARROW,
535            CursorType::SbRightArrow => gdk_sys::GDK_SB_RIGHT_ARROW,
536            CursorType::SbUpArrow => gdk_sys::GDK_SB_UP_ARROW,
537            CursorType::SbVDoubleArrow => gdk_sys::GDK_SB_V_DOUBLE_ARROW,
538            CursorType::Shuttle => gdk_sys::GDK_SHUTTLE,
539            CursorType::Sizing => gdk_sys::GDK_SIZING,
540            CursorType::Spider => gdk_sys::GDK_SPIDER,
541            CursorType::Spraycan => gdk_sys::GDK_SPRAYCAN,
542            CursorType::Star => gdk_sys::GDK_STAR,
543            CursorType::Target => gdk_sys::GDK_TARGET,
544            CursorType::Tcross => gdk_sys::GDK_TCROSS,
545            CursorType::TopLeftArrow => gdk_sys::GDK_TOP_LEFT_ARROW,
546            CursorType::TopLeftCorner => gdk_sys::GDK_TOP_LEFT_CORNER,
547            CursorType::TopRightCorner => gdk_sys::GDK_TOP_RIGHT_CORNER,
548            CursorType::TopSide => gdk_sys::GDK_TOP_SIDE,
549            CursorType::TopTee => gdk_sys::GDK_TOP_TEE,
550            CursorType::Trek => gdk_sys::GDK_TREK,
551            CursorType::UlAngle => gdk_sys::GDK_UL_ANGLE,
552            CursorType::Umbrella => gdk_sys::GDK_UMBRELLA,
553            CursorType::UrAngle => gdk_sys::GDK_UR_ANGLE,
554            CursorType::Watch => gdk_sys::GDK_WATCH,
555            CursorType::Xterm => gdk_sys::GDK_XTERM,
556            CursorType::LastCursor => gdk_sys::GDK_LAST_CURSOR,
557            CursorType::BlankCursor => gdk_sys::GDK_BLANK_CURSOR,
558            CursorType::CursorIsPixmap => gdk_sys::GDK_CURSOR_IS_PIXMAP,
559            CursorType::__Unknown(value) => value,
560        }
561    }
562}
563
564#[doc(hidden)]
565impl FromGlib<gdk_sys::GdkCursorType> for CursorType {
566    fn from_glib(value: gdk_sys::GdkCursorType) -> Self {
567        skip_assert_initialized!();
568        match value {
569            0 => CursorType::XCursor,
570            2 => CursorType::Arrow,
571            4 => CursorType::BasedArrowDown,
572            6 => CursorType::BasedArrowUp,
573            8 => CursorType::Boat,
574            10 => CursorType::Bogosity,
575            12 => CursorType::BottomLeftCorner,
576            14 => CursorType::BottomRightCorner,
577            16 => CursorType::BottomSide,
578            18 => CursorType::BottomTee,
579            20 => CursorType::BoxSpiral,
580            22 => CursorType::CenterPtr,
581            24 => CursorType::Circle,
582            26 => CursorType::Clock,
583            28 => CursorType::CoffeeMug,
584            30 => CursorType::Cross,
585            32 => CursorType::CrossReverse,
586            34 => CursorType::Crosshair,
587            36 => CursorType::DiamondCross,
588            38 => CursorType::Dot,
589            40 => CursorType::Dotbox,
590            42 => CursorType::DoubleArrow,
591            44 => CursorType::DraftLarge,
592            46 => CursorType::DraftSmall,
593            48 => CursorType::DrapedBox,
594            50 => CursorType::Exchange,
595            52 => CursorType::Fleur,
596            54 => CursorType::Gobbler,
597            56 => CursorType::Gumby,
598            58 => CursorType::Hand1,
599            60 => CursorType::Hand2,
600            62 => CursorType::Heart,
601            64 => CursorType::Icon,
602            66 => CursorType::IronCross,
603            68 => CursorType::LeftPtr,
604            70 => CursorType::LeftSide,
605            72 => CursorType::LeftTee,
606            74 => CursorType::Leftbutton,
607            76 => CursorType::LlAngle,
608            78 => CursorType::LrAngle,
609            80 => CursorType::Man,
610            82 => CursorType::Middlebutton,
611            84 => CursorType::Mouse,
612            86 => CursorType::Pencil,
613            88 => CursorType::Pirate,
614            90 => CursorType::Plus,
615            92 => CursorType::QuestionArrow,
616            94 => CursorType::RightPtr,
617            96 => CursorType::RightSide,
618            98 => CursorType::RightTee,
619            100 => CursorType::Rightbutton,
620            102 => CursorType::RtlLogo,
621            104 => CursorType::Sailboat,
622            106 => CursorType::SbDownArrow,
623            108 => CursorType::SbHDoubleArrow,
624            110 => CursorType::SbLeftArrow,
625            112 => CursorType::SbRightArrow,
626            114 => CursorType::SbUpArrow,
627            116 => CursorType::SbVDoubleArrow,
628            118 => CursorType::Shuttle,
629            120 => CursorType::Sizing,
630            122 => CursorType::Spider,
631            124 => CursorType::Spraycan,
632            126 => CursorType::Star,
633            128 => CursorType::Target,
634            130 => CursorType::Tcross,
635            132 => CursorType::TopLeftArrow,
636            134 => CursorType::TopLeftCorner,
637            136 => CursorType::TopRightCorner,
638            138 => CursorType::TopSide,
639            140 => CursorType::TopTee,
640            142 => CursorType::Trek,
641            144 => CursorType::UlAngle,
642            146 => CursorType::Umbrella,
643            148 => CursorType::UrAngle,
644            150 => CursorType::Watch,
645            152 => CursorType::Xterm,
646            153 => CursorType::LastCursor,
647            -2 => CursorType::BlankCursor,
648            -1 => CursorType::CursorIsPixmap,
649            value => CursorType::__Unknown(value),
650        }
651    }
652}
653
654impl StaticType for CursorType {
655    fn static_type() -> Type {
656        unsafe { from_glib(gdk_sys::gdk_cursor_type_get_type()) }
657    }
658}
659
660impl<'a> FromValueOptional<'a> for CursorType {
661    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
662        Some(FromValue::from_value(value))
663    }
664}
665
666impl<'a> FromValue<'a> for CursorType {
667    unsafe fn from_value(value: &Value) -> Self {
668        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
669    }
670}
671
672impl SetValue for CursorType {
673    unsafe fn set_value(value: &mut Value, this: &Self) {
674        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
675    }
676}
677
678#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
679pub enum DevicePadFeature {
680    Button,
681    Ring,
682    Strip,
683    #[doc(hidden)]
684    __Unknown(i32),
685}
686
687impl fmt::Display for DevicePadFeature {
688    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
689        write!(
690            f,
691            "DevicePadFeature::{}",
692            match *self {
693                DevicePadFeature::Button => "Button",
694                DevicePadFeature::Ring => "Ring",
695                DevicePadFeature::Strip => "Strip",
696                _ => "Unknown",
697            }
698        )
699    }
700}
701
702#[doc(hidden)]
703impl ToGlib for DevicePadFeature {
704    type GlibType = gdk_sys::GdkDevicePadFeature;
705
706    fn to_glib(&self) -> gdk_sys::GdkDevicePadFeature {
707        match *self {
708            DevicePadFeature::Button => gdk_sys::GDK_DEVICE_PAD_FEATURE_BUTTON,
709            DevicePadFeature::Ring => gdk_sys::GDK_DEVICE_PAD_FEATURE_RING,
710            DevicePadFeature::Strip => gdk_sys::GDK_DEVICE_PAD_FEATURE_STRIP,
711            DevicePadFeature::__Unknown(value) => value,
712        }
713    }
714}
715
716#[doc(hidden)]
717impl FromGlib<gdk_sys::GdkDevicePadFeature> for DevicePadFeature {
718    fn from_glib(value: gdk_sys::GdkDevicePadFeature) -> Self {
719        skip_assert_initialized!();
720        match value {
721            0 => DevicePadFeature::Button,
722            1 => DevicePadFeature::Ring,
723            2 => DevicePadFeature::Strip,
724            value => DevicePadFeature::__Unknown(value),
725        }
726    }
727}
728
729impl StaticType for DevicePadFeature {
730    fn static_type() -> Type {
731        unsafe { from_glib(gdk_sys::gdk_device_pad_feature_get_type()) }
732    }
733}
734
735impl<'a> FromValueOptional<'a> for DevicePadFeature {
736    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
737        Some(FromValue::from_value(value))
738    }
739}
740
741impl<'a> FromValue<'a> for DevicePadFeature {
742    unsafe fn from_value(value: &Value) -> Self {
743        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
744    }
745}
746
747impl SetValue for DevicePadFeature {
748    unsafe fn set_value(value: &mut Value, this: &Self) {
749        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
750    }
751}
752
753#[cfg(any(feature = "v3_22", feature = "dox"))]
754#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
755pub enum DeviceToolType {
756    Unknown,
757    Pen,
758    Eraser,
759    Brush,
760    Pencil,
761    Airbrush,
762    Mouse,
763    Lens,
764    #[doc(hidden)]
765    __Unknown(i32),
766}
767
768#[cfg(any(feature = "v3_22", feature = "dox"))]
769impl fmt::Display for DeviceToolType {
770    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
771        write!(
772            f,
773            "DeviceToolType::{}",
774            match *self {
775                DeviceToolType::Unknown => "Unknown",
776                DeviceToolType::Pen => "Pen",
777                DeviceToolType::Eraser => "Eraser",
778                DeviceToolType::Brush => "Brush",
779                DeviceToolType::Pencil => "Pencil",
780                DeviceToolType::Airbrush => "Airbrush",
781                DeviceToolType::Mouse => "Mouse",
782                DeviceToolType::Lens => "Lens",
783                _ => "Unknown",
784            }
785        )
786    }
787}
788
789#[cfg(any(feature = "v3_22", feature = "dox"))]
790#[doc(hidden)]
791impl ToGlib for DeviceToolType {
792    type GlibType = gdk_sys::GdkDeviceToolType;
793
794    fn to_glib(&self) -> gdk_sys::GdkDeviceToolType {
795        match *self {
796            DeviceToolType::Unknown => gdk_sys::GDK_DEVICE_TOOL_TYPE_UNKNOWN,
797            DeviceToolType::Pen => gdk_sys::GDK_DEVICE_TOOL_TYPE_PEN,
798            DeviceToolType::Eraser => gdk_sys::GDK_DEVICE_TOOL_TYPE_ERASER,
799            DeviceToolType::Brush => gdk_sys::GDK_DEVICE_TOOL_TYPE_BRUSH,
800            DeviceToolType::Pencil => gdk_sys::GDK_DEVICE_TOOL_TYPE_PENCIL,
801            DeviceToolType::Airbrush => gdk_sys::GDK_DEVICE_TOOL_TYPE_AIRBRUSH,
802            DeviceToolType::Mouse => gdk_sys::GDK_DEVICE_TOOL_TYPE_MOUSE,
803            DeviceToolType::Lens => gdk_sys::GDK_DEVICE_TOOL_TYPE_LENS,
804            DeviceToolType::__Unknown(value) => value,
805        }
806    }
807}
808
809#[cfg(any(feature = "v3_22", feature = "dox"))]
810#[doc(hidden)]
811impl FromGlib<gdk_sys::GdkDeviceToolType> for DeviceToolType {
812    fn from_glib(value: gdk_sys::GdkDeviceToolType) -> Self {
813        skip_assert_initialized!();
814        match value {
815            0 => DeviceToolType::Unknown,
816            1 => DeviceToolType::Pen,
817            2 => DeviceToolType::Eraser,
818            3 => DeviceToolType::Brush,
819            4 => DeviceToolType::Pencil,
820            5 => DeviceToolType::Airbrush,
821            6 => DeviceToolType::Mouse,
822            7 => DeviceToolType::Lens,
823            value => DeviceToolType::__Unknown(value),
824        }
825    }
826}
827
828#[cfg(any(feature = "v3_22", feature = "dox"))]
829impl StaticType for DeviceToolType {
830    fn static_type() -> Type {
831        unsafe { from_glib(gdk_sys::gdk_device_tool_type_get_type()) }
832    }
833}
834
835#[cfg(any(feature = "v3_22", feature = "dox"))]
836impl<'a> FromValueOptional<'a> for DeviceToolType {
837    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
838        Some(FromValue::from_value(value))
839    }
840}
841
842#[cfg(any(feature = "v3_22", feature = "dox"))]
843impl<'a> FromValue<'a> for DeviceToolType {
844    unsafe fn from_value(value: &Value) -> Self {
845        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
846    }
847}
848
849#[cfg(any(feature = "v3_22", feature = "dox"))]
850impl SetValue for DeviceToolType {
851    unsafe fn set_value(value: &mut Value, this: &Self) {
852        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
853    }
854}
855
856#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
857pub enum DeviceType {
858    Master,
859    Slave,
860    Floating,
861    #[doc(hidden)]
862    __Unknown(i32),
863}
864
865impl fmt::Display for DeviceType {
866    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
867        write!(
868            f,
869            "DeviceType::{}",
870            match *self {
871                DeviceType::Master => "Master",
872                DeviceType::Slave => "Slave",
873                DeviceType::Floating => "Floating",
874                _ => "Unknown",
875            }
876        )
877    }
878}
879
880#[doc(hidden)]
881impl ToGlib for DeviceType {
882    type GlibType = gdk_sys::GdkDeviceType;
883
884    fn to_glib(&self) -> gdk_sys::GdkDeviceType {
885        match *self {
886            DeviceType::Master => gdk_sys::GDK_DEVICE_TYPE_MASTER,
887            DeviceType::Slave => gdk_sys::GDK_DEVICE_TYPE_SLAVE,
888            DeviceType::Floating => gdk_sys::GDK_DEVICE_TYPE_FLOATING,
889            DeviceType::__Unknown(value) => value,
890        }
891    }
892}
893
894#[doc(hidden)]
895impl FromGlib<gdk_sys::GdkDeviceType> for DeviceType {
896    fn from_glib(value: gdk_sys::GdkDeviceType) -> Self {
897        skip_assert_initialized!();
898        match value {
899            0 => DeviceType::Master,
900            1 => DeviceType::Slave,
901            2 => DeviceType::Floating,
902            value => DeviceType::__Unknown(value),
903        }
904    }
905}
906
907impl StaticType for DeviceType {
908    fn static_type() -> Type {
909        unsafe { from_glib(gdk_sys::gdk_device_type_get_type()) }
910    }
911}
912
913impl<'a> FromValueOptional<'a> for DeviceType {
914    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
915        Some(FromValue::from_value(value))
916    }
917}
918
919impl<'a> FromValue<'a> for DeviceType {
920    unsafe fn from_value(value: &Value) -> Self {
921        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
922    }
923}
924
925impl SetValue for DeviceType {
926    unsafe fn set_value(value: &mut Value, this: &Self) {
927        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
928    }
929}
930
931#[cfg(any(feature = "v3_20", feature = "dox"))]
932#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
933pub enum DragCancelReason {
934    NoTarget,
935    UserCancelled,
936    Error,
937    #[doc(hidden)]
938    __Unknown(i32),
939}
940
941#[cfg(any(feature = "v3_20", feature = "dox"))]
942impl fmt::Display for DragCancelReason {
943    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
944        write!(
945            f,
946            "DragCancelReason::{}",
947            match *self {
948                DragCancelReason::NoTarget => "NoTarget",
949                DragCancelReason::UserCancelled => "UserCancelled",
950                DragCancelReason::Error => "Error",
951                _ => "Unknown",
952            }
953        )
954    }
955}
956
957#[cfg(any(feature = "v3_20", feature = "dox"))]
958#[doc(hidden)]
959impl ToGlib for DragCancelReason {
960    type GlibType = gdk_sys::GdkDragCancelReason;
961
962    fn to_glib(&self) -> gdk_sys::GdkDragCancelReason {
963        match *self {
964            DragCancelReason::NoTarget => gdk_sys::GDK_DRAG_CANCEL_NO_TARGET,
965            DragCancelReason::UserCancelled => gdk_sys::GDK_DRAG_CANCEL_USER_CANCELLED,
966            DragCancelReason::Error => gdk_sys::GDK_DRAG_CANCEL_ERROR,
967            DragCancelReason::__Unknown(value) => value,
968        }
969    }
970}
971
972#[cfg(any(feature = "v3_20", feature = "dox"))]
973#[doc(hidden)]
974impl FromGlib<gdk_sys::GdkDragCancelReason> for DragCancelReason {
975    fn from_glib(value: gdk_sys::GdkDragCancelReason) -> Self {
976        skip_assert_initialized!();
977        match value {
978            0 => DragCancelReason::NoTarget,
979            1 => DragCancelReason::UserCancelled,
980            2 => DragCancelReason::Error,
981            value => DragCancelReason::__Unknown(value),
982        }
983    }
984}
985
986#[cfg(any(feature = "v3_20", feature = "dox"))]
987impl StaticType for DragCancelReason {
988    fn static_type() -> Type {
989        unsafe { from_glib(gdk_sys::gdk_drag_cancel_reason_get_type()) }
990    }
991}
992
993#[cfg(any(feature = "v3_20", feature = "dox"))]
994impl<'a> FromValueOptional<'a> for DragCancelReason {
995    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
996        Some(FromValue::from_value(value))
997    }
998}
999
1000#[cfg(any(feature = "v3_20", feature = "dox"))]
1001impl<'a> FromValue<'a> for DragCancelReason {
1002    unsafe fn from_value(value: &Value) -> Self {
1003        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
1004    }
1005}
1006
1007#[cfg(any(feature = "v3_20", feature = "dox"))]
1008impl SetValue for DragCancelReason {
1009    unsafe fn set_value(value: &mut Value, this: &Self) {
1010        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
1011    }
1012}
1013
1014#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1015pub enum DragProtocol {
1016    None,
1017    Motif,
1018    Xdnd,
1019    Rootwin,
1020    Win32Dropfiles,
1021    Ole2,
1022    Local,
1023    Wayland,
1024    #[doc(hidden)]
1025    __Unknown(i32),
1026}
1027
1028impl fmt::Display for DragProtocol {
1029    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1030        write!(
1031            f,
1032            "DragProtocol::{}",
1033            match *self {
1034                DragProtocol::None => "None",
1035                DragProtocol::Motif => "Motif",
1036                DragProtocol::Xdnd => "Xdnd",
1037                DragProtocol::Rootwin => "Rootwin",
1038                DragProtocol::Win32Dropfiles => "Win32Dropfiles",
1039                DragProtocol::Ole2 => "Ole2",
1040                DragProtocol::Local => "Local",
1041                DragProtocol::Wayland => "Wayland",
1042                _ => "Unknown",
1043            }
1044        )
1045    }
1046}
1047
1048#[doc(hidden)]
1049impl ToGlib for DragProtocol {
1050    type GlibType = gdk_sys::GdkDragProtocol;
1051
1052    fn to_glib(&self) -> gdk_sys::GdkDragProtocol {
1053        match *self {
1054            DragProtocol::None => gdk_sys::GDK_DRAG_PROTO_NONE,
1055            DragProtocol::Motif => gdk_sys::GDK_DRAG_PROTO_MOTIF,
1056            DragProtocol::Xdnd => gdk_sys::GDK_DRAG_PROTO_XDND,
1057            DragProtocol::Rootwin => gdk_sys::GDK_DRAG_PROTO_ROOTWIN,
1058            DragProtocol::Win32Dropfiles => gdk_sys::GDK_DRAG_PROTO_WIN32_DROPFILES,
1059            DragProtocol::Ole2 => gdk_sys::GDK_DRAG_PROTO_OLE2,
1060            DragProtocol::Local => gdk_sys::GDK_DRAG_PROTO_LOCAL,
1061            DragProtocol::Wayland => gdk_sys::GDK_DRAG_PROTO_WAYLAND,
1062            DragProtocol::__Unknown(value) => value,
1063        }
1064    }
1065}
1066
1067#[doc(hidden)]
1068impl FromGlib<gdk_sys::GdkDragProtocol> for DragProtocol {
1069    fn from_glib(value: gdk_sys::GdkDragProtocol) -> Self {
1070        skip_assert_initialized!();
1071        match value {
1072            0 => DragProtocol::None,
1073            1 => DragProtocol::Motif,
1074            2 => DragProtocol::Xdnd,
1075            3 => DragProtocol::Rootwin,
1076            4 => DragProtocol::Win32Dropfiles,
1077            5 => DragProtocol::Ole2,
1078            6 => DragProtocol::Local,
1079            7 => DragProtocol::Wayland,
1080            value => DragProtocol::__Unknown(value),
1081        }
1082    }
1083}
1084
1085impl StaticType for DragProtocol {
1086    fn static_type() -> Type {
1087        unsafe { from_glib(gdk_sys::gdk_drag_protocol_get_type()) }
1088    }
1089}
1090
1091impl<'a> FromValueOptional<'a> for DragProtocol {
1092    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
1093        Some(FromValue::from_value(value))
1094    }
1095}
1096
1097impl<'a> FromValue<'a> for DragProtocol {
1098    unsafe fn from_value(value: &Value) -> Self {
1099        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
1100    }
1101}
1102
1103impl SetValue for DragProtocol {
1104    unsafe fn set_value(value: &mut Value, this: &Self) {
1105        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
1106    }
1107}
1108
1109#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1110pub enum EventType {
1111    Nothing,
1112    Delete,
1113    Destroy,
1114    Expose,
1115    MotionNotify,
1116    ButtonPress,
1117    DoubleButtonPress,
1118    TripleButtonPress,
1119    ButtonRelease,
1120    KeyPress,
1121    KeyRelease,
1122    EnterNotify,
1123    LeaveNotify,
1124    FocusChange,
1125    Configure,
1126    Map,
1127    Unmap,
1128    PropertyNotify,
1129    SelectionClear,
1130    SelectionRequest,
1131    SelectionNotify,
1132    ProximityIn,
1133    ProximityOut,
1134    DragEnter,
1135    DragLeave,
1136    DragMotion,
1137    DragStatus,
1138    DropStart,
1139    DropFinished,
1140    ClientEvent,
1141    VisibilityNotify,
1142    Scroll,
1143    WindowState,
1144    Setting,
1145    OwnerChange,
1146    GrabBroken,
1147    Damage,
1148    TouchBegin,
1149    TouchUpdate,
1150    TouchEnd,
1151    TouchCancel,
1152    #[cfg(any(feature = "v3_18", feature = "dox"))]
1153    TouchpadSwipe,
1154    #[cfg(any(feature = "v3_18", feature = "dox"))]
1155    TouchpadPinch,
1156    PadButtonPress,
1157    PadButtonRelease,
1158    PadRing,
1159    PadStrip,
1160    PadGroupMode,
1161    #[doc(hidden)]
1162    __Unknown(i32),
1163}
1164
1165impl fmt::Display for EventType {
1166    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1167        write!(
1168            f,
1169            "EventType::{}",
1170            match *self {
1171                EventType::Nothing => "Nothing",
1172                EventType::Delete => "Delete",
1173                EventType::Destroy => "Destroy",
1174                EventType::Expose => "Expose",
1175                EventType::MotionNotify => "MotionNotify",
1176                EventType::ButtonPress => "ButtonPress",
1177                EventType::DoubleButtonPress => "DoubleButtonPress",
1178                EventType::TripleButtonPress => "TripleButtonPress",
1179                EventType::ButtonRelease => "ButtonRelease",
1180                EventType::KeyPress => "KeyPress",
1181                EventType::KeyRelease => "KeyRelease",
1182                EventType::EnterNotify => "EnterNotify",
1183                EventType::LeaveNotify => "LeaveNotify",
1184                EventType::FocusChange => "FocusChange",
1185                EventType::Configure => "Configure",
1186                EventType::Map => "Map",
1187                EventType::Unmap => "Unmap",
1188                EventType::PropertyNotify => "PropertyNotify",
1189                EventType::SelectionClear => "SelectionClear",
1190                EventType::SelectionRequest => "SelectionRequest",
1191                EventType::SelectionNotify => "SelectionNotify",
1192                EventType::ProximityIn => "ProximityIn",
1193                EventType::ProximityOut => "ProximityOut",
1194                EventType::DragEnter => "DragEnter",
1195                EventType::DragLeave => "DragLeave",
1196                EventType::DragMotion => "DragMotion",
1197                EventType::DragStatus => "DragStatus",
1198                EventType::DropStart => "DropStart",
1199                EventType::DropFinished => "DropFinished",
1200                EventType::ClientEvent => "ClientEvent",
1201                EventType::VisibilityNotify => "VisibilityNotify",
1202                EventType::Scroll => "Scroll",
1203                EventType::WindowState => "WindowState",
1204                EventType::Setting => "Setting",
1205                EventType::OwnerChange => "OwnerChange",
1206                EventType::GrabBroken => "GrabBroken",
1207                EventType::Damage => "Damage",
1208                EventType::TouchBegin => "TouchBegin",
1209                EventType::TouchUpdate => "TouchUpdate",
1210                EventType::TouchEnd => "TouchEnd",
1211                EventType::TouchCancel => "TouchCancel",
1212                #[cfg(any(feature = "v3_18", feature = "dox"))]
1213                EventType::TouchpadSwipe => "TouchpadSwipe",
1214                #[cfg(any(feature = "v3_18", feature = "dox"))]
1215                EventType::TouchpadPinch => "TouchpadPinch",
1216                EventType::PadButtonPress => "PadButtonPress",
1217                EventType::PadButtonRelease => "PadButtonRelease",
1218                EventType::PadRing => "PadRing",
1219                EventType::PadStrip => "PadStrip",
1220                EventType::PadGroupMode => "PadGroupMode",
1221                _ => "Unknown",
1222            }
1223        )
1224    }
1225}
1226
1227#[doc(hidden)]
1228impl ToGlib for EventType {
1229    type GlibType = gdk_sys::GdkEventType;
1230
1231    fn to_glib(&self) -> gdk_sys::GdkEventType {
1232        match *self {
1233            EventType::Nothing => gdk_sys::GDK_NOTHING,
1234            EventType::Delete => gdk_sys::GDK_DELETE,
1235            EventType::Destroy => gdk_sys::GDK_DESTROY,
1236            EventType::Expose => gdk_sys::GDK_EXPOSE,
1237            EventType::MotionNotify => gdk_sys::GDK_MOTION_NOTIFY,
1238            EventType::ButtonPress => gdk_sys::GDK_BUTTON_PRESS,
1239            EventType::DoubleButtonPress => gdk_sys::GDK_DOUBLE_BUTTON_PRESS,
1240            EventType::TripleButtonPress => gdk_sys::GDK_TRIPLE_BUTTON_PRESS,
1241            EventType::ButtonRelease => gdk_sys::GDK_BUTTON_RELEASE,
1242            EventType::KeyPress => gdk_sys::GDK_KEY_PRESS,
1243            EventType::KeyRelease => gdk_sys::GDK_KEY_RELEASE,
1244            EventType::EnterNotify => gdk_sys::GDK_ENTER_NOTIFY,
1245            EventType::LeaveNotify => gdk_sys::GDK_LEAVE_NOTIFY,
1246            EventType::FocusChange => gdk_sys::GDK_FOCUS_CHANGE,
1247            EventType::Configure => gdk_sys::GDK_CONFIGURE,
1248            EventType::Map => gdk_sys::GDK_MAP,
1249            EventType::Unmap => gdk_sys::GDK_UNMAP,
1250            EventType::PropertyNotify => gdk_sys::GDK_PROPERTY_NOTIFY,
1251            EventType::SelectionClear => gdk_sys::GDK_SELECTION_CLEAR,
1252            EventType::SelectionRequest => gdk_sys::GDK_SELECTION_REQUEST,
1253            EventType::SelectionNotify => gdk_sys::GDK_SELECTION_NOTIFY,
1254            EventType::ProximityIn => gdk_sys::GDK_PROXIMITY_IN,
1255            EventType::ProximityOut => gdk_sys::GDK_PROXIMITY_OUT,
1256            EventType::DragEnter => gdk_sys::GDK_DRAG_ENTER,
1257            EventType::DragLeave => gdk_sys::GDK_DRAG_LEAVE,
1258            EventType::DragMotion => gdk_sys::GDK_DRAG_MOTION,
1259            EventType::DragStatus => gdk_sys::GDK_DRAG_STATUS,
1260            EventType::DropStart => gdk_sys::GDK_DROP_START,
1261            EventType::DropFinished => gdk_sys::GDK_DROP_FINISHED,
1262            EventType::ClientEvent => gdk_sys::GDK_CLIENT_EVENT,
1263            EventType::VisibilityNotify => gdk_sys::GDK_VISIBILITY_NOTIFY,
1264            EventType::Scroll => gdk_sys::GDK_SCROLL,
1265            EventType::WindowState => gdk_sys::GDK_WINDOW_STATE,
1266            EventType::Setting => gdk_sys::GDK_SETTING,
1267            EventType::OwnerChange => gdk_sys::GDK_OWNER_CHANGE,
1268            EventType::GrabBroken => gdk_sys::GDK_GRAB_BROKEN,
1269            EventType::Damage => gdk_sys::GDK_DAMAGE,
1270            EventType::TouchBegin => gdk_sys::GDK_TOUCH_BEGIN,
1271            EventType::TouchUpdate => gdk_sys::GDK_TOUCH_UPDATE,
1272            EventType::TouchEnd => gdk_sys::GDK_TOUCH_END,
1273            EventType::TouchCancel => gdk_sys::GDK_TOUCH_CANCEL,
1274            #[cfg(any(feature = "v3_18", feature = "dox"))]
1275            EventType::TouchpadSwipe => gdk_sys::GDK_TOUCHPAD_SWIPE,
1276            #[cfg(any(feature = "v3_18", feature = "dox"))]
1277            EventType::TouchpadPinch => gdk_sys::GDK_TOUCHPAD_PINCH,
1278            EventType::PadButtonPress => gdk_sys::GDK_PAD_BUTTON_PRESS,
1279            EventType::PadButtonRelease => gdk_sys::GDK_PAD_BUTTON_RELEASE,
1280            EventType::PadRing => gdk_sys::GDK_PAD_RING,
1281            EventType::PadStrip => gdk_sys::GDK_PAD_STRIP,
1282            EventType::PadGroupMode => gdk_sys::GDK_PAD_GROUP_MODE,
1283            EventType::__Unknown(value) => value,
1284        }
1285    }
1286}
1287
1288#[doc(hidden)]
1289impl FromGlib<gdk_sys::GdkEventType> for EventType {
1290    fn from_glib(value: gdk_sys::GdkEventType) -> Self {
1291        skip_assert_initialized!();
1292        match value {
1293            -1 => EventType::Nothing,
1294            0 => EventType::Delete,
1295            1 => EventType::Destroy,
1296            2 => EventType::Expose,
1297            3 => EventType::MotionNotify,
1298            4 => EventType::ButtonPress,
1299            5 => EventType::DoubleButtonPress,
1300            6 => EventType::TripleButtonPress,
1301            7 => EventType::ButtonRelease,
1302            8 => EventType::KeyPress,
1303            9 => EventType::KeyRelease,
1304            10 => EventType::EnterNotify,
1305            11 => EventType::LeaveNotify,
1306            12 => EventType::FocusChange,
1307            13 => EventType::Configure,
1308            14 => EventType::Map,
1309            15 => EventType::Unmap,
1310            16 => EventType::PropertyNotify,
1311            17 => EventType::SelectionClear,
1312            18 => EventType::SelectionRequest,
1313            19 => EventType::SelectionNotify,
1314            20 => EventType::ProximityIn,
1315            21 => EventType::ProximityOut,
1316            22 => EventType::DragEnter,
1317            23 => EventType::DragLeave,
1318            24 => EventType::DragMotion,
1319            25 => EventType::DragStatus,
1320            26 => EventType::DropStart,
1321            27 => EventType::DropFinished,
1322            28 => EventType::ClientEvent,
1323            29 => EventType::VisibilityNotify,
1324            31 => EventType::Scroll,
1325            32 => EventType::WindowState,
1326            33 => EventType::Setting,
1327            34 => EventType::OwnerChange,
1328            35 => EventType::GrabBroken,
1329            36 => EventType::Damage,
1330            37 => EventType::TouchBegin,
1331            38 => EventType::TouchUpdate,
1332            39 => EventType::TouchEnd,
1333            40 => EventType::TouchCancel,
1334            #[cfg(any(feature = "v3_18", feature = "dox"))]
1335            41 => EventType::TouchpadSwipe,
1336            #[cfg(any(feature = "v3_18", feature = "dox"))]
1337            42 => EventType::TouchpadPinch,
1338            43 => EventType::PadButtonPress,
1339            44 => EventType::PadButtonRelease,
1340            45 => EventType::PadRing,
1341            46 => EventType::PadStrip,
1342            47 => EventType::PadGroupMode,
1343            value => EventType::__Unknown(value),
1344        }
1345    }
1346}
1347
1348impl StaticType for EventType {
1349    fn static_type() -> Type {
1350        unsafe { from_glib(gdk_sys::gdk_event_type_get_type()) }
1351    }
1352}
1353
1354impl<'a> FromValueOptional<'a> for EventType {
1355    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
1356        Some(FromValue::from_value(value))
1357    }
1358}
1359
1360impl<'a> FromValue<'a> for EventType {
1361    unsafe fn from_value(value: &Value) -> Self {
1362        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
1363    }
1364}
1365
1366impl SetValue for EventType {
1367    unsafe fn set_value(value: &mut Value, this: &Self) {
1368        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
1369    }
1370}
1371
1372#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1373pub enum FullscreenMode {
1374    CurrentMonitor,
1375    AllMonitors,
1376    #[doc(hidden)]
1377    __Unknown(i32),
1378}
1379
1380impl fmt::Display for FullscreenMode {
1381    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1382        write!(
1383            f,
1384            "FullscreenMode::{}",
1385            match *self {
1386                FullscreenMode::CurrentMonitor => "CurrentMonitor",
1387                FullscreenMode::AllMonitors => "AllMonitors",
1388                _ => "Unknown",
1389            }
1390        )
1391    }
1392}
1393
1394#[doc(hidden)]
1395impl ToGlib for FullscreenMode {
1396    type GlibType = gdk_sys::GdkFullscreenMode;
1397
1398    fn to_glib(&self) -> gdk_sys::GdkFullscreenMode {
1399        match *self {
1400            FullscreenMode::CurrentMonitor => gdk_sys::GDK_FULLSCREEN_ON_CURRENT_MONITOR,
1401            FullscreenMode::AllMonitors => gdk_sys::GDK_FULLSCREEN_ON_ALL_MONITORS,
1402            FullscreenMode::__Unknown(value) => value,
1403        }
1404    }
1405}
1406
1407#[doc(hidden)]
1408impl FromGlib<gdk_sys::GdkFullscreenMode> for FullscreenMode {
1409    fn from_glib(value: gdk_sys::GdkFullscreenMode) -> Self {
1410        skip_assert_initialized!();
1411        match value {
1412            0 => FullscreenMode::CurrentMonitor,
1413            1 => FullscreenMode::AllMonitors,
1414            value => FullscreenMode::__Unknown(value),
1415        }
1416    }
1417}
1418
1419impl StaticType for FullscreenMode {
1420    fn static_type() -> Type {
1421        unsafe { from_glib(gdk_sys::gdk_fullscreen_mode_get_type()) }
1422    }
1423}
1424
1425impl<'a> FromValueOptional<'a> for FullscreenMode {
1426    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
1427        Some(FromValue::from_value(value))
1428    }
1429}
1430
1431impl<'a> FromValue<'a> for FullscreenMode {
1432    unsafe fn from_value(value: &Value) -> Self {
1433        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
1434    }
1435}
1436
1437impl SetValue for FullscreenMode {
1438    unsafe fn set_value(value: &mut Value, this: &Self) {
1439        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
1440    }
1441}
1442
1443#[cfg(any(feature = "v3_16", feature = "dox"))]
1444#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1445pub enum GLError {
1446    NotAvailable,
1447    UnsupportedFormat,
1448    UnsupportedProfile,
1449    #[doc(hidden)]
1450    __Unknown(i32),
1451}
1452
1453#[cfg(any(feature = "v3_16", feature = "dox"))]
1454impl fmt::Display for GLError {
1455    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1456        write!(
1457            f,
1458            "GLError::{}",
1459            match *self {
1460                GLError::NotAvailable => "NotAvailable",
1461                GLError::UnsupportedFormat => "UnsupportedFormat",
1462                GLError::UnsupportedProfile => "UnsupportedProfile",
1463                _ => "Unknown",
1464            }
1465        )
1466    }
1467}
1468
1469#[cfg(any(feature = "v3_16", feature = "dox"))]
1470#[doc(hidden)]
1471impl ToGlib for GLError {
1472    type GlibType = gdk_sys::GdkGLError;
1473
1474    fn to_glib(&self) -> gdk_sys::GdkGLError {
1475        match *self {
1476            GLError::NotAvailable => gdk_sys::GDK_GL_ERROR_NOT_AVAILABLE,
1477            GLError::UnsupportedFormat => gdk_sys::GDK_GL_ERROR_UNSUPPORTED_FORMAT,
1478            GLError::UnsupportedProfile => gdk_sys::GDK_GL_ERROR_UNSUPPORTED_PROFILE,
1479            GLError::__Unknown(value) => value,
1480        }
1481    }
1482}
1483
1484#[cfg(any(feature = "v3_16", feature = "dox"))]
1485#[doc(hidden)]
1486impl FromGlib<gdk_sys::GdkGLError> for GLError {
1487    fn from_glib(value: gdk_sys::GdkGLError) -> Self {
1488        skip_assert_initialized!();
1489        match value {
1490            0 => GLError::NotAvailable,
1491            1 => GLError::UnsupportedFormat,
1492            2 => GLError::UnsupportedProfile,
1493            value => GLError::__Unknown(value),
1494        }
1495    }
1496}
1497
1498#[cfg(any(feature = "v3_16", feature = "dox"))]
1499impl ErrorDomain for GLError {
1500    fn domain() -> Quark {
1501        skip_assert_initialized!();
1502        unsafe { from_glib(gdk_sys::gdk_gl_error_quark()) }
1503    }
1504
1505    fn code(self) -> i32 {
1506        self.to_glib()
1507    }
1508
1509    fn from(code: i32) -> Option<Self> {
1510        skip_assert_initialized!();
1511        match code {
1512            0 => Some(GLError::NotAvailable),
1513            1 => Some(GLError::UnsupportedFormat),
1514            2 => Some(GLError::UnsupportedProfile),
1515            value => Some(GLError::__Unknown(value)),
1516        }
1517    }
1518}
1519
1520#[cfg(any(feature = "v3_16", feature = "dox"))]
1521impl StaticType for GLError {
1522    fn static_type() -> Type {
1523        unsafe { from_glib(gdk_sys::gdk_gl_error_get_type()) }
1524    }
1525}
1526
1527#[cfg(any(feature = "v3_16", feature = "dox"))]
1528impl<'a> FromValueOptional<'a> for GLError {
1529    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
1530        Some(FromValue::from_value(value))
1531    }
1532}
1533
1534#[cfg(any(feature = "v3_16", feature = "dox"))]
1535impl<'a> FromValue<'a> for GLError {
1536    unsafe fn from_value(value: &Value) -> Self {
1537        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
1538    }
1539}
1540
1541#[cfg(any(feature = "v3_16", feature = "dox"))]
1542impl SetValue for GLError {
1543    unsafe fn set_value(value: &mut Value, this: &Self) {
1544        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
1545    }
1546}
1547
1548#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1549pub enum GrabOwnership {
1550    None,
1551    Window,
1552    Application,
1553    #[doc(hidden)]
1554    __Unknown(i32),
1555}
1556
1557impl fmt::Display for GrabOwnership {
1558    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1559        write!(
1560            f,
1561            "GrabOwnership::{}",
1562            match *self {
1563                GrabOwnership::None => "None",
1564                GrabOwnership::Window => "Window",
1565                GrabOwnership::Application => "Application",
1566                _ => "Unknown",
1567            }
1568        )
1569    }
1570}
1571
1572#[doc(hidden)]
1573impl ToGlib for GrabOwnership {
1574    type GlibType = gdk_sys::GdkGrabOwnership;
1575
1576    fn to_glib(&self) -> gdk_sys::GdkGrabOwnership {
1577        match *self {
1578            GrabOwnership::None => gdk_sys::GDK_OWNERSHIP_NONE,
1579            GrabOwnership::Window => gdk_sys::GDK_OWNERSHIP_WINDOW,
1580            GrabOwnership::Application => gdk_sys::GDK_OWNERSHIP_APPLICATION,
1581            GrabOwnership::__Unknown(value) => value,
1582        }
1583    }
1584}
1585
1586#[doc(hidden)]
1587impl FromGlib<gdk_sys::GdkGrabOwnership> for GrabOwnership {
1588    fn from_glib(value: gdk_sys::GdkGrabOwnership) -> Self {
1589        skip_assert_initialized!();
1590        match value {
1591            0 => GrabOwnership::None,
1592            1 => GrabOwnership::Window,
1593            2 => GrabOwnership::Application,
1594            value => GrabOwnership::__Unknown(value),
1595        }
1596    }
1597}
1598
1599impl StaticType for GrabOwnership {
1600    fn static_type() -> Type {
1601        unsafe { from_glib(gdk_sys::gdk_grab_ownership_get_type()) }
1602    }
1603}
1604
1605impl<'a> FromValueOptional<'a> for GrabOwnership {
1606    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
1607        Some(FromValue::from_value(value))
1608    }
1609}
1610
1611impl<'a> FromValue<'a> for GrabOwnership {
1612    unsafe fn from_value(value: &Value) -> Self {
1613        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
1614    }
1615}
1616
1617impl SetValue for GrabOwnership {
1618    unsafe fn set_value(value: &mut Value, this: &Self) {
1619        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
1620    }
1621}
1622
1623#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1624pub enum GrabStatus {
1625    Success,
1626    AlreadyGrabbed,
1627    InvalidTime,
1628    NotViewable,
1629    Frozen,
1630    Failed,
1631    #[doc(hidden)]
1632    __Unknown(i32),
1633}
1634
1635impl fmt::Display for GrabStatus {
1636    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1637        write!(
1638            f,
1639            "GrabStatus::{}",
1640            match *self {
1641                GrabStatus::Success => "Success",
1642                GrabStatus::AlreadyGrabbed => "AlreadyGrabbed",
1643                GrabStatus::InvalidTime => "InvalidTime",
1644                GrabStatus::NotViewable => "NotViewable",
1645                GrabStatus::Frozen => "Frozen",
1646                GrabStatus::Failed => "Failed",
1647                _ => "Unknown",
1648            }
1649        )
1650    }
1651}
1652
1653#[doc(hidden)]
1654impl ToGlib for GrabStatus {
1655    type GlibType = gdk_sys::GdkGrabStatus;
1656
1657    fn to_glib(&self) -> gdk_sys::GdkGrabStatus {
1658        match *self {
1659            GrabStatus::Success => gdk_sys::GDK_GRAB_SUCCESS,
1660            GrabStatus::AlreadyGrabbed => gdk_sys::GDK_GRAB_ALREADY_GRABBED,
1661            GrabStatus::InvalidTime => gdk_sys::GDK_GRAB_INVALID_TIME,
1662            GrabStatus::NotViewable => gdk_sys::GDK_GRAB_NOT_VIEWABLE,
1663            GrabStatus::Frozen => gdk_sys::GDK_GRAB_FROZEN,
1664            GrabStatus::Failed => gdk_sys::GDK_GRAB_FAILED,
1665            GrabStatus::__Unknown(value) => value,
1666        }
1667    }
1668}
1669
1670#[doc(hidden)]
1671impl FromGlib<gdk_sys::GdkGrabStatus> for GrabStatus {
1672    fn from_glib(value: gdk_sys::GdkGrabStatus) -> Self {
1673        skip_assert_initialized!();
1674        match value {
1675            0 => GrabStatus::Success,
1676            1 => GrabStatus::AlreadyGrabbed,
1677            2 => GrabStatus::InvalidTime,
1678            3 => GrabStatus::NotViewable,
1679            4 => GrabStatus::Frozen,
1680            5 => GrabStatus::Failed,
1681            value => GrabStatus::__Unknown(value),
1682        }
1683    }
1684}
1685
1686impl StaticType for GrabStatus {
1687    fn static_type() -> Type {
1688        unsafe { from_glib(gdk_sys::gdk_grab_status_get_type()) }
1689    }
1690}
1691
1692impl<'a> FromValueOptional<'a> for GrabStatus {
1693    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
1694        Some(FromValue::from_value(value))
1695    }
1696}
1697
1698impl<'a> FromValue<'a> for GrabStatus {
1699    unsafe fn from_value(value: &Value) -> Self {
1700        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
1701    }
1702}
1703
1704impl SetValue for GrabStatus {
1705    unsafe fn set_value(value: &mut Value, this: &Self) {
1706        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
1707    }
1708}
1709
1710#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1711pub enum Gravity {
1712    NorthWest,
1713    North,
1714    NorthEast,
1715    West,
1716    Center,
1717    East,
1718    SouthWest,
1719    South,
1720    SouthEast,
1721    Static,
1722    #[doc(hidden)]
1723    __Unknown(i32),
1724}
1725
1726impl fmt::Display for Gravity {
1727    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1728        write!(
1729            f,
1730            "Gravity::{}",
1731            match *self {
1732                Gravity::NorthWest => "NorthWest",
1733                Gravity::North => "North",
1734                Gravity::NorthEast => "NorthEast",
1735                Gravity::West => "West",
1736                Gravity::Center => "Center",
1737                Gravity::East => "East",
1738                Gravity::SouthWest => "SouthWest",
1739                Gravity::South => "South",
1740                Gravity::SouthEast => "SouthEast",
1741                Gravity::Static => "Static",
1742                _ => "Unknown",
1743            }
1744        )
1745    }
1746}
1747
1748#[doc(hidden)]
1749impl ToGlib for Gravity {
1750    type GlibType = gdk_sys::GdkGravity;
1751
1752    fn to_glib(&self) -> gdk_sys::GdkGravity {
1753        match *self {
1754            Gravity::NorthWest => gdk_sys::GDK_GRAVITY_NORTH_WEST,
1755            Gravity::North => gdk_sys::GDK_GRAVITY_NORTH,
1756            Gravity::NorthEast => gdk_sys::GDK_GRAVITY_NORTH_EAST,
1757            Gravity::West => gdk_sys::GDK_GRAVITY_WEST,
1758            Gravity::Center => gdk_sys::GDK_GRAVITY_CENTER,
1759            Gravity::East => gdk_sys::GDK_GRAVITY_EAST,
1760            Gravity::SouthWest => gdk_sys::GDK_GRAVITY_SOUTH_WEST,
1761            Gravity::South => gdk_sys::GDK_GRAVITY_SOUTH,
1762            Gravity::SouthEast => gdk_sys::GDK_GRAVITY_SOUTH_EAST,
1763            Gravity::Static => gdk_sys::GDK_GRAVITY_STATIC,
1764            Gravity::__Unknown(value) => value,
1765        }
1766    }
1767}
1768
1769#[doc(hidden)]
1770impl FromGlib<gdk_sys::GdkGravity> for Gravity {
1771    fn from_glib(value: gdk_sys::GdkGravity) -> Self {
1772        skip_assert_initialized!();
1773        match value {
1774            1 => Gravity::NorthWest,
1775            2 => Gravity::North,
1776            3 => Gravity::NorthEast,
1777            4 => Gravity::West,
1778            5 => Gravity::Center,
1779            6 => Gravity::East,
1780            7 => Gravity::SouthWest,
1781            8 => Gravity::South,
1782            9 => Gravity::SouthEast,
1783            10 => Gravity::Static,
1784            value => Gravity::__Unknown(value),
1785        }
1786    }
1787}
1788
1789impl StaticType for Gravity {
1790    fn static_type() -> Type {
1791        unsafe { from_glib(gdk_sys::gdk_gravity_get_type()) }
1792    }
1793}
1794
1795impl<'a> FromValueOptional<'a> for Gravity {
1796    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
1797        Some(FromValue::from_value(value))
1798    }
1799}
1800
1801impl<'a> FromValue<'a> for Gravity {
1802    unsafe fn from_value(value: &Value) -> Self {
1803        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
1804    }
1805}
1806
1807impl SetValue for Gravity {
1808    unsafe fn set_value(value: &mut Value, this: &Self) {
1809        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
1810    }
1811}
1812
1813#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1814pub enum InputMode {
1815    Disabled,
1816    Screen,
1817    Window,
1818    #[doc(hidden)]
1819    __Unknown(i32),
1820}
1821
1822impl fmt::Display for InputMode {
1823    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1824        write!(
1825            f,
1826            "InputMode::{}",
1827            match *self {
1828                InputMode::Disabled => "Disabled",
1829                InputMode::Screen => "Screen",
1830                InputMode::Window => "Window",
1831                _ => "Unknown",
1832            }
1833        )
1834    }
1835}
1836
1837#[doc(hidden)]
1838impl ToGlib for InputMode {
1839    type GlibType = gdk_sys::GdkInputMode;
1840
1841    fn to_glib(&self) -> gdk_sys::GdkInputMode {
1842        match *self {
1843            InputMode::Disabled => gdk_sys::GDK_MODE_DISABLED,
1844            InputMode::Screen => gdk_sys::GDK_MODE_SCREEN,
1845            InputMode::Window => gdk_sys::GDK_MODE_WINDOW,
1846            InputMode::__Unknown(value) => value,
1847        }
1848    }
1849}
1850
1851#[doc(hidden)]
1852impl FromGlib<gdk_sys::GdkInputMode> for InputMode {
1853    fn from_glib(value: gdk_sys::GdkInputMode) -> Self {
1854        skip_assert_initialized!();
1855        match value {
1856            0 => InputMode::Disabled,
1857            1 => InputMode::Screen,
1858            2 => InputMode::Window,
1859            value => InputMode::__Unknown(value),
1860        }
1861    }
1862}
1863
1864impl StaticType for InputMode {
1865    fn static_type() -> Type {
1866        unsafe { from_glib(gdk_sys::gdk_input_mode_get_type()) }
1867    }
1868}
1869
1870impl<'a> FromValueOptional<'a> for InputMode {
1871    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
1872        Some(FromValue::from_value(value))
1873    }
1874}
1875
1876impl<'a> FromValue<'a> for InputMode {
1877    unsafe fn from_value(value: &Value) -> Self {
1878        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
1879    }
1880}
1881
1882impl SetValue for InputMode {
1883    unsafe fn set_value(value: &mut Value, this: &Self) {
1884        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
1885    }
1886}
1887
1888#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1889pub enum InputSource {
1890    Mouse,
1891    Pen,
1892    Eraser,
1893    Cursor,
1894    Keyboard,
1895    Touchscreen,
1896    Touchpad,
1897    Trackpoint,
1898    TabletPad,
1899    #[doc(hidden)]
1900    __Unknown(i32),
1901}
1902
1903impl fmt::Display for InputSource {
1904    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1905        write!(
1906            f,
1907            "InputSource::{}",
1908            match *self {
1909                InputSource::Mouse => "Mouse",
1910                InputSource::Pen => "Pen",
1911                InputSource::Eraser => "Eraser",
1912                InputSource::Cursor => "Cursor",
1913                InputSource::Keyboard => "Keyboard",
1914                InputSource::Touchscreen => "Touchscreen",
1915                InputSource::Touchpad => "Touchpad",
1916                InputSource::Trackpoint => "Trackpoint",
1917                InputSource::TabletPad => "TabletPad",
1918                _ => "Unknown",
1919            }
1920        )
1921    }
1922}
1923
1924#[doc(hidden)]
1925impl ToGlib for InputSource {
1926    type GlibType = gdk_sys::GdkInputSource;
1927
1928    fn to_glib(&self) -> gdk_sys::GdkInputSource {
1929        match *self {
1930            InputSource::Mouse => gdk_sys::GDK_SOURCE_MOUSE,
1931            InputSource::Pen => gdk_sys::GDK_SOURCE_PEN,
1932            InputSource::Eraser => gdk_sys::GDK_SOURCE_ERASER,
1933            InputSource::Cursor => gdk_sys::GDK_SOURCE_CURSOR,
1934            InputSource::Keyboard => gdk_sys::GDK_SOURCE_KEYBOARD,
1935            InputSource::Touchscreen => gdk_sys::GDK_SOURCE_TOUCHSCREEN,
1936            InputSource::Touchpad => gdk_sys::GDK_SOURCE_TOUCHPAD,
1937            InputSource::Trackpoint => gdk_sys::GDK_SOURCE_TRACKPOINT,
1938            InputSource::TabletPad => gdk_sys::GDK_SOURCE_TABLET_PAD,
1939            InputSource::__Unknown(value) => value,
1940        }
1941    }
1942}
1943
1944#[doc(hidden)]
1945impl FromGlib<gdk_sys::GdkInputSource> for InputSource {
1946    fn from_glib(value: gdk_sys::GdkInputSource) -> Self {
1947        skip_assert_initialized!();
1948        match value {
1949            0 => InputSource::Mouse,
1950            1 => InputSource::Pen,
1951            2 => InputSource::Eraser,
1952            3 => InputSource::Cursor,
1953            4 => InputSource::Keyboard,
1954            5 => InputSource::Touchscreen,
1955            6 => InputSource::Touchpad,
1956            7 => InputSource::Trackpoint,
1957            8 => InputSource::TabletPad,
1958            value => InputSource::__Unknown(value),
1959        }
1960    }
1961}
1962
1963impl StaticType for InputSource {
1964    fn static_type() -> Type {
1965        unsafe { from_glib(gdk_sys::gdk_input_source_get_type()) }
1966    }
1967}
1968
1969impl<'a> FromValueOptional<'a> for InputSource {
1970    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
1971        Some(FromValue::from_value(value))
1972    }
1973}
1974
1975impl<'a> FromValue<'a> for InputSource {
1976    unsafe fn from_value(value: &Value) -> Self {
1977        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
1978    }
1979}
1980
1981impl SetValue for InputSource {
1982    unsafe fn set_value(value: &mut Value, this: &Self) {
1983        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
1984    }
1985}
1986
1987#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1988pub enum ModifierIntent {
1989    PrimaryAccelerator,
1990    ContextMenu,
1991    ExtendSelection,
1992    ModifySelection,
1993    NoTextInput,
1994    ShiftGroup,
1995    DefaultModMask,
1996    #[doc(hidden)]
1997    __Unknown(i32),
1998}
1999
2000impl fmt::Display for ModifierIntent {
2001    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2002        write!(
2003            f,
2004            "ModifierIntent::{}",
2005            match *self {
2006                ModifierIntent::PrimaryAccelerator => "PrimaryAccelerator",
2007                ModifierIntent::ContextMenu => "ContextMenu",
2008                ModifierIntent::ExtendSelection => "ExtendSelection",
2009                ModifierIntent::ModifySelection => "ModifySelection",
2010                ModifierIntent::NoTextInput => "NoTextInput",
2011                ModifierIntent::ShiftGroup => "ShiftGroup",
2012                ModifierIntent::DefaultModMask => "DefaultModMask",
2013                _ => "Unknown",
2014            }
2015        )
2016    }
2017}
2018
2019#[doc(hidden)]
2020impl ToGlib for ModifierIntent {
2021    type GlibType = gdk_sys::GdkModifierIntent;
2022
2023    fn to_glib(&self) -> gdk_sys::GdkModifierIntent {
2024        match *self {
2025            ModifierIntent::PrimaryAccelerator => gdk_sys::GDK_MODIFIER_INTENT_PRIMARY_ACCELERATOR,
2026            ModifierIntent::ContextMenu => gdk_sys::GDK_MODIFIER_INTENT_CONTEXT_MENU,
2027            ModifierIntent::ExtendSelection => gdk_sys::GDK_MODIFIER_INTENT_EXTEND_SELECTION,
2028            ModifierIntent::ModifySelection => gdk_sys::GDK_MODIFIER_INTENT_MODIFY_SELECTION,
2029            ModifierIntent::NoTextInput => gdk_sys::GDK_MODIFIER_INTENT_NO_TEXT_INPUT,
2030            ModifierIntent::ShiftGroup => gdk_sys::GDK_MODIFIER_INTENT_SHIFT_GROUP,
2031            ModifierIntent::DefaultModMask => gdk_sys::GDK_MODIFIER_INTENT_DEFAULT_MOD_MASK,
2032            ModifierIntent::__Unknown(value) => value,
2033        }
2034    }
2035}
2036
2037#[doc(hidden)]
2038impl FromGlib<gdk_sys::GdkModifierIntent> for ModifierIntent {
2039    fn from_glib(value: gdk_sys::GdkModifierIntent) -> Self {
2040        skip_assert_initialized!();
2041        match value {
2042            0 => ModifierIntent::PrimaryAccelerator,
2043            1 => ModifierIntent::ContextMenu,
2044            2 => ModifierIntent::ExtendSelection,
2045            3 => ModifierIntent::ModifySelection,
2046            4 => ModifierIntent::NoTextInput,
2047            5 => ModifierIntent::ShiftGroup,
2048            6 => ModifierIntent::DefaultModMask,
2049            value => ModifierIntent::__Unknown(value),
2050        }
2051    }
2052}
2053
2054impl StaticType for ModifierIntent {
2055    fn static_type() -> Type {
2056        unsafe { from_glib(gdk_sys::gdk_modifier_intent_get_type()) }
2057    }
2058}
2059
2060impl<'a> FromValueOptional<'a> for ModifierIntent {
2061    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
2062        Some(FromValue::from_value(value))
2063    }
2064}
2065
2066impl<'a> FromValue<'a> for ModifierIntent {
2067    unsafe fn from_value(value: &Value) -> Self {
2068        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
2069    }
2070}
2071
2072impl SetValue for ModifierIntent {
2073    unsafe fn set_value(value: &mut Value, this: &Self) {
2074        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
2075    }
2076}
2077
2078#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2079pub enum NotifyType {
2080    Ancestor,
2081    Virtual,
2082    Inferior,
2083    Nonlinear,
2084    NonlinearVirtual,
2085    Unknown,
2086    #[doc(hidden)]
2087    __Unknown(i32),
2088}
2089
2090impl fmt::Display for NotifyType {
2091    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2092        write!(
2093            f,
2094            "NotifyType::{}",
2095            match *self {
2096                NotifyType::Ancestor => "Ancestor",
2097                NotifyType::Virtual => "Virtual",
2098                NotifyType::Inferior => "Inferior",
2099                NotifyType::Nonlinear => "Nonlinear",
2100                NotifyType::NonlinearVirtual => "NonlinearVirtual",
2101                NotifyType::Unknown => "Unknown",
2102                _ => "Unknown",
2103            }
2104        )
2105    }
2106}
2107
2108#[doc(hidden)]
2109impl ToGlib for NotifyType {
2110    type GlibType = gdk_sys::GdkNotifyType;
2111
2112    fn to_glib(&self) -> gdk_sys::GdkNotifyType {
2113        match *self {
2114            NotifyType::Ancestor => gdk_sys::GDK_NOTIFY_ANCESTOR,
2115            NotifyType::Virtual => gdk_sys::GDK_NOTIFY_VIRTUAL,
2116            NotifyType::Inferior => gdk_sys::GDK_NOTIFY_INFERIOR,
2117            NotifyType::Nonlinear => gdk_sys::GDK_NOTIFY_NONLINEAR,
2118            NotifyType::NonlinearVirtual => gdk_sys::GDK_NOTIFY_NONLINEAR_VIRTUAL,
2119            NotifyType::Unknown => gdk_sys::GDK_NOTIFY_UNKNOWN,
2120            NotifyType::__Unknown(value) => value,
2121        }
2122    }
2123}
2124
2125#[doc(hidden)]
2126impl FromGlib<gdk_sys::GdkNotifyType> for NotifyType {
2127    fn from_glib(value: gdk_sys::GdkNotifyType) -> Self {
2128        skip_assert_initialized!();
2129        match value {
2130            0 => NotifyType::Ancestor,
2131            1 => NotifyType::Virtual,
2132            2 => NotifyType::Inferior,
2133            3 => NotifyType::Nonlinear,
2134            4 => NotifyType::NonlinearVirtual,
2135            5 => NotifyType::Unknown,
2136            value => NotifyType::__Unknown(value),
2137        }
2138    }
2139}
2140
2141impl StaticType for NotifyType {
2142    fn static_type() -> Type {
2143        unsafe { from_glib(gdk_sys::gdk_notify_type_get_type()) }
2144    }
2145}
2146
2147impl<'a> FromValueOptional<'a> for NotifyType {
2148    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
2149        Some(FromValue::from_value(value))
2150    }
2151}
2152
2153impl<'a> FromValue<'a> for NotifyType {
2154    unsafe fn from_value(value: &Value) -> Self {
2155        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
2156    }
2157}
2158
2159impl SetValue for NotifyType {
2160    unsafe fn set_value(value: &mut Value, this: &Self) {
2161        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
2162    }
2163}
2164
2165#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2166pub enum OwnerChange {
2167    NewOwner,
2168    Destroy,
2169    Close,
2170    #[doc(hidden)]
2171    __Unknown(i32),
2172}
2173
2174impl fmt::Display for OwnerChange {
2175    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2176        write!(
2177            f,
2178            "OwnerChange::{}",
2179            match *self {
2180                OwnerChange::NewOwner => "NewOwner",
2181                OwnerChange::Destroy => "Destroy",
2182                OwnerChange::Close => "Close",
2183                _ => "Unknown",
2184            }
2185        )
2186    }
2187}
2188
2189#[doc(hidden)]
2190impl ToGlib for OwnerChange {
2191    type GlibType = gdk_sys::GdkOwnerChange;
2192
2193    fn to_glib(&self) -> gdk_sys::GdkOwnerChange {
2194        match *self {
2195            OwnerChange::NewOwner => gdk_sys::GDK_OWNER_CHANGE_NEW_OWNER,
2196            OwnerChange::Destroy => gdk_sys::GDK_OWNER_CHANGE_DESTROY,
2197            OwnerChange::Close => gdk_sys::GDK_OWNER_CHANGE_CLOSE,
2198            OwnerChange::__Unknown(value) => value,
2199        }
2200    }
2201}
2202
2203#[doc(hidden)]
2204impl FromGlib<gdk_sys::GdkOwnerChange> for OwnerChange {
2205    fn from_glib(value: gdk_sys::GdkOwnerChange) -> Self {
2206        skip_assert_initialized!();
2207        match value {
2208            0 => OwnerChange::NewOwner,
2209            1 => OwnerChange::Destroy,
2210            2 => OwnerChange::Close,
2211            value => OwnerChange::__Unknown(value),
2212        }
2213    }
2214}
2215
2216impl StaticType for OwnerChange {
2217    fn static_type() -> Type {
2218        unsafe { from_glib(gdk_sys::gdk_owner_change_get_type()) }
2219    }
2220}
2221
2222impl<'a> FromValueOptional<'a> for OwnerChange {
2223    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
2224        Some(FromValue::from_value(value))
2225    }
2226}
2227
2228impl<'a> FromValue<'a> for OwnerChange {
2229    unsafe fn from_value(value: &Value) -> Self {
2230        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
2231    }
2232}
2233
2234impl SetValue for OwnerChange {
2235    unsafe fn set_value(value: &mut Value, this: &Self) {
2236        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
2237    }
2238}
2239
2240#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2241pub enum PropMode {
2242    Replace,
2243    Prepend,
2244    Append,
2245    #[doc(hidden)]
2246    __Unknown(i32),
2247}
2248
2249impl fmt::Display for PropMode {
2250    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2251        write!(
2252            f,
2253            "PropMode::{}",
2254            match *self {
2255                PropMode::Replace => "Replace",
2256                PropMode::Prepend => "Prepend",
2257                PropMode::Append => "Append",
2258                _ => "Unknown",
2259            }
2260        )
2261    }
2262}
2263
2264#[doc(hidden)]
2265impl ToGlib for PropMode {
2266    type GlibType = gdk_sys::GdkPropMode;
2267
2268    fn to_glib(&self) -> gdk_sys::GdkPropMode {
2269        match *self {
2270            PropMode::Replace => gdk_sys::GDK_PROP_MODE_REPLACE,
2271            PropMode::Prepend => gdk_sys::GDK_PROP_MODE_PREPEND,
2272            PropMode::Append => gdk_sys::GDK_PROP_MODE_APPEND,
2273            PropMode::__Unknown(value) => value,
2274        }
2275    }
2276}
2277
2278#[doc(hidden)]
2279impl FromGlib<gdk_sys::GdkPropMode> for PropMode {
2280    fn from_glib(value: gdk_sys::GdkPropMode) -> Self {
2281        skip_assert_initialized!();
2282        match value {
2283            0 => PropMode::Replace,
2284            1 => PropMode::Prepend,
2285            2 => PropMode::Append,
2286            value => PropMode::__Unknown(value),
2287        }
2288    }
2289}
2290
2291impl StaticType for PropMode {
2292    fn static_type() -> Type {
2293        unsafe { from_glib(gdk_sys::gdk_prop_mode_get_type()) }
2294    }
2295}
2296
2297impl<'a> FromValueOptional<'a> for PropMode {
2298    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
2299        Some(FromValue::from_value(value))
2300    }
2301}
2302
2303impl<'a> FromValue<'a> for PropMode {
2304    unsafe fn from_value(value: &Value) -> Self {
2305        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
2306    }
2307}
2308
2309impl SetValue for PropMode {
2310    unsafe fn set_value(value: &mut Value, this: &Self) {
2311        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
2312    }
2313}
2314
2315#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2316pub enum PropertyState {
2317    NewValue,
2318    Delete,
2319    #[doc(hidden)]
2320    __Unknown(i32),
2321}
2322
2323impl fmt::Display for PropertyState {
2324    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2325        write!(
2326            f,
2327            "PropertyState::{}",
2328            match *self {
2329                PropertyState::NewValue => "NewValue",
2330                PropertyState::Delete => "Delete",
2331                _ => "Unknown",
2332            }
2333        )
2334    }
2335}
2336
2337#[doc(hidden)]
2338impl ToGlib for PropertyState {
2339    type GlibType = gdk_sys::GdkPropertyState;
2340
2341    fn to_glib(&self) -> gdk_sys::GdkPropertyState {
2342        match *self {
2343            PropertyState::NewValue => gdk_sys::GDK_PROPERTY_NEW_VALUE,
2344            PropertyState::Delete => gdk_sys::GDK_PROPERTY_DELETE,
2345            PropertyState::__Unknown(value) => value,
2346        }
2347    }
2348}
2349
2350#[doc(hidden)]
2351impl FromGlib<gdk_sys::GdkPropertyState> for PropertyState {
2352    fn from_glib(value: gdk_sys::GdkPropertyState) -> Self {
2353        skip_assert_initialized!();
2354        match value {
2355            0 => PropertyState::NewValue,
2356            1 => PropertyState::Delete,
2357            value => PropertyState::__Unknown(value),
2358        }
2359    }
2360}
2361
2362impl StaticType for PropertyState {
2363    fn static_type() -> Type {
2364        unsafe { from_glib(gdk_sys::gdk_property_state_get_type()) }
2365    }
2366}
2367
2368impl<'a> FromValueOptional<'a> for PropertyState {
2369    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
2370        Some(FromValue::from_value(value))
2371    }
2372}
2373
2374impl<'a> FromValue<'a> for PropertyState {
2375    unsafe fn from_value(value: &Value) -> Self {
2376        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
2377    }
2378}
2379
2380impl SetValue for PropertyState {
2381    unsafe fn set_value(value: &mut Value, this: &Self) {
2382        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
2383    }
2384}
2385
2386#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2387pub enum ScrollDirection {
2388    Up,
2389    Down,
2390    Left,
2391    Right,
2392    Smooth,
2393    #[doc(hidden)]
2394    __Unknown(i32),
2395}
2396
2397impl fmt::Display for ScrollDirection {
2398    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2399        write!(
2400            f,
2401            "ScrollDirection::{}",
2402            match *self {
2403                ScrollDirection::Up => "Up",
2404                ScrollDirection::Down => "Down",
2405                ScrollDirection::Left => "Left",
2406                ScrollDirection::Right => "Right",
2407                ScrollDirection::Smooth => "Smooth",
2408                _ => "Unknown",
2409            }
2410        )
2411    }
2412}
2413
2414#[doc(hidden)]
2415impl ToGlib for ScrollDirection {
2416    type GlibType = gdk_sys::GdkScrollDirection;
2417
2418    fn to_glib(&self) -> gdk_sys::GdkScrollDirection {
2419        match *self {
2420            ScrollDirection::Up => gdk_sys::GDK_SCROLL_UP,
2421            ScrollDirection::Down => gdk_sys::GDK_SCROLL_DOWN,
2422            ScrollDirection::Left => gdk_sys::GDK_SCROLL_LEFT,
2423            ScrollDirection::Right => gdk_sys::GDK_SCROLL_RIGHT,
2424            ScrollDirection::Smooth => gdk_sys::GDK_SCROLL_SMOOTH,
2425            ScrollDirection::__Unknown(value) => value,
2426        }
2427    }
2428}
2429
2430#[doc(hidden)]
2431impl FromGlib<gdk_sys::GdkScrollDirection> for ScrollDirection {
2432    fn from_glib(value: gdk_sys::GdkScrollDirection) -> Self {
2433        skip_assert_initialized!();
2434        match value {
2435            0 => ScrollDirection::Up,
2436            1 => ScrollDirection::Down,
2437            2 => ScrollDirection::Left,
2438            3 => ScrollDirection::Right,
2439            4 => ScrollDirection::Smooth,
2440            value => ScrollDirection::__Unknown(value),
2441        }
2442    }
2443}
2444
2445impl StaticType for ScrollDirection {
2446    fn static_type() -> Type {
2447        unsafe { from_glib(gdk_sys::gdk_scroll_direction_get_type()) }
2448    }
2449}
2450
2451impl<'a> FromValueOptional<'a> for ScrollDirection {
2452    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
2453        Some(FromValue::from_value(value))
2454    }
2455}
2456
2457impl<'a> FromValue<'a> for ScrollDirection {
2458    unsafe fn from_value(value: &Value) -> Self {
2459        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
2460    }
2461}
2462
2463impl SetValue for ScrollDirection {
2464    unsafe fn set_value(value: &mut Value, this: &Self) {
2465        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
2466    }
2467}
2468
2469#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2470pub enum SettingAction {
2471    New,
2472    Changed,
2473    Deleted,
2474    #[doc(hidden)]
2475    __Unknown(i32),
2476}
2477
2478impl fmt::Display for SettingAction {
2479    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2480        write!(
2481            f,
2482            "SettingAction::{}",
2483            match *self {
2484                SettingAction::New => "New",
2485                SettingAction::Changed => "Changed",
2486                SettingAction::Deleted => "Deleted",
2487                _ => "Unknown",
2488            }
2489        )
2490    }
2491}
2492
2493#[doc(hidden)]
2494impl ToGlib for SettingAction {
2495    type GlibType = gdk_sys::GdkSettingAction;
2496
2497    fn to_glib(&self) -> gdk_sys::GdkSettingAction {
2498        match *self {
2499            SettingAction::New => gdk_sys::GDK_SETTING_ACTION_NEW,
2500            SettingAction::Changed => gdk_sys::GDK_SETTING_ACTION_CHANGED,
2501            SettingAction::Deleted => gdk_sys::GDK_SETTING_ACTION_DELETED,
2502            SettingAction::__Unknown(value) => value,
2503        }
2504    }
2505}
2506
2507#[doc(hidden)]
2508impl FromGlib<gdk_sys::GdkSettingAction> for SettingAction {
2509    fn from_glib(value: gdk_sys::GdkSettingAction) -> Self {
2510        skip_assert_initialized!();
2511        match value {
2512            0 => SettingAction::New,
2513            1 => SettingAction::Changed,
2514            2 => SettingAction::Deleted,
2515            value => SettingAction::__Unknown(value),
2516        }
2517    }
2518}
2519
2520impl StaticType for SettingAction {
2521    fn static_type() -> Type {
2522        unsafe { from_glib(gdk_sys::gdk_setting_action_get_type()) }
2523    }
2524}
2525
2526impl<'a> FromValueOptional<'a> for SettingAction {
2527    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
2528        Some(FromValue::from_value(value))
2529    }
2530}
2531
2532impl<'a> FromValue<'a> for SettingAction {
2533    unsafe fn from_value(value: &Value) -> Self {
2534        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
2535    }
2536}
2537
2538impl SetValue for SettingAction {
2539    unsafe fn set_value(value: &mut Value, this: &Self) {
2540        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
2541    }
2542}
2543
2544#[cfg(any(feature = "v3_22", feature = "dox"))]
2545#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2546pub enum SubpixelLayout {
2547    Unknown,
2548    None,
2549    HorizontalRgb,
2550    HorizontalBgr,
2551    VerticalRgb,
2552    VerticalBgr,
2553    #[doc(hidden)]
2554    __Unknown(i32),
2555}
2556
2557#[cfg(any(feature = "v3_22", feature = "dox"))]
2558impl fmt::Display for SubpixelLayout {
2559    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2560        write!(
2561            f,
2562            "SubpixelLayout::{}",
2563            match *self {
2564                SubpixelLayout::Unknown => "Unknown",
2565                SubpixelLayout::None => "None",
2566                SubpixelLayout::HorizontalRgb => "HorizontalRgb",
2567                SubpixelLayout::HorizontalBgr => "HorizontalBgr",
2568                SubpixelLayout::VerticalRgb => "VerticalRgb",
2569                SubpixelLayout::VerticalBgr => "VerticalBgr",
2570                _ => "Unknown",
2571            }
2572        )
2573    }
2574}
2575
2576#[cfg(any(feature = "v3_22", feature = "dox"))]
2577#[doc(hidden)]
2578impl ToGlib for SubpixelLayout {
2579    type GlibType = gdk_sys::GdkSubpixelLayout;
2580
2581    fn to_glib(&self) -> gdk_sys::GdkSubpixelLayout {
2582        match *self {
2583            SubpixelLayout::Unknown => gdk_sys::GDK_SUBPIXEL_LAYOUT_UNKNOWN,
2584            SubpixelLayout::None => gdk_sys::GDK_SUBPIXEL_LAYOUT_NONE,
2585            SubpixelLayout::HorizontalRgb => gdk_sys::GDK_SUBPIXEL_LAYOUT_HORIZONTAL_RGB,
2586            SubpixelLayout::HorizontalBgr => gdk_sys::GDK_SUBPIXEL_LAYOUT_HORIZONTAL_BGR,
2587            SubpixelLayout::VerticalRgb => gdk_sys::GDK_SUBPIXEL_LAYOUT_VERTICAL_RGB,
2588            SubpixelLayout::VerticalBgr => gdk_sys::GDK_SUBPIXEL_LAYOUT_VERTICAL_BGR,
2589            SubpixelLayout::__Unknown(value) => value,
2590        }
2591    }
2592}
2593
2594#[cfg(any(feature = "v3_22", feature = "dox"))]
2595#[doc(hidden)]
2596impl FromGlib<gdk_sys::GdkSubpixelLayout> for SubpixelLayout {
2597    fn from_glib(value: gdk_sys::GdkSubpixelLayout) -> Self {
2598        skip_assert_initialized!();
2599        match value {
2600            0 => SubpixelLayout::Unknown,
2601            1 => SubpixelLayout::None,
2602            2 => SubpixelLayout::HorizontalRgb,
2603            3 => SubpixelLayout::HorizontalBgr,
2604            4 => SubpixelLayout::VerticalRgb,
2605            5 => SubpixelLayout::VerticalBgr,
2606            value => SubpixelLayout::__Unknown(value),
2607        }
2608    }
2609}
2610
2611#[cfg(any(feature = "v3_22", feature = "dox"))]
2612impl StaticType for SubpixelLayout {
2613    fn static_type() -> Type {
2614        unsafe { from_glib(gdk_sys::gdk_subpixel_layout_get_type()) }
2615    }
2616}
2617
2618#[cfg(any(feature = "v3_22", feature = "dox"))]
2619impl<'a> FromValueOptional<'a> for SubpixelLayout {
2620    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
2621        Some(FromValue::from_value(value))
2622    }
2623}
2624
2625#[cfg(any(feature = "v3_22", feature = "dox"))]
2626impl<'a> FromValue<'a> for SubpixelLayout {
2627    unsafe fn from_value(value: &Value) -> Self {
2628        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
2629    }
2630}
2631
2632#[cfg(any(feature = "v3_22", feature = "dox"))]
2633impl SetValue for SubpixelLayout {
2634    unsafe fn set_value(value: &mut Value, this: &Self) {
2635        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
2636    }
2637}
2638
2639#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2640pub enum VisibilityState {
2641    Unobscured,
2642    Partial,
2643    FullyObscured,
2644    #[doc(hidden)]
2645    __Unknown(i32),
2646}
2647
2648impl fmt::Display for VisibilityState {
2649    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2650        write!(
2651            f,
2652            "VisibilityState::{}",
2653            match *self {
2654                VisibilityState::Unobscured => "Unobscured",
2655                VisibilityState::Partial => "Partial",
2656                VisibilityState::FullyObscured => "FullyObscured",
2657                _ => "Unknown",
2658            }
2659        )
2660    }
2661}
2662
2663#[doc(hidden)]
2664impl ToGlib for VisibilityState {
2665    type GlibType = gdk_sys::GdkVisibilityState;
2666
2667    fn to_glib(&self) -> gdk_sys::GdkVisibilityState {
2668        match *self {
2669            VisibilityState::Unobscured => gdk_sys::GDK_VISIBILITY_UNOBSCURED,
2670            VisibilityState::Partial => gdk_sys::GDK_VISIBILITY_PARTIAL,
2671            VisibilityState::FullyObscured => gdk_sys::GDK_VISIBILITY_FULLY_OBSCURED,
2672            VisibilityState::__Unknown(value) => value,
2673        }
2674    }
2675}
2676
2677#[doc(hidden)]
2678impl FromGlib<gdk_sys::GdkVisibilityState> for VisibilityState {
2679    fn from_glib(value: gdk_sys::GdkVisibilityState) -> Self {
2680        skip_assert_initialized!();
2681        match value {
2682            0 => VisibilityState::Unobscured,
2683            1 => VisibilityState::Partial,
2684            2 => VisibilityState::FullyObscured,
2685            value => VisibilityState::__Unknown(value),
2686        }
2687    }
2688}
2689
2690impl StaticType for VisibilityState {
2691    fn static_type() -> Type {
2692        unsafe { from_glib(gdk_sys::gdk_visibility_state_get_type()) }
2693    }
2694}
2695
2696impl<'a> FromValueOptional<'a> for VisibilityState {
2697    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
2698        Some(FromValue::from_value(value))
2699    }
2700}
2701
2702impl<'a> FromValue<'a> for VisibilityState {
2703    unsafe fn from_value(value: &Value) -> Self {
2704        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
2705    }
2706}
2707
2708impl SetValue for VisibilityState {
2709    unsafe fn set_value(value: &mut Value, this: &Self) {
2710        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
2711    }
2712}
2713
2714#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2715pub enum VisualType {
2716    StaticGray,
2717    Grayscale,
2718    StaticColor,
2719    PseudoColor,
2720    TrueColor,
2721    DirectColor,
2722    #[doc(hidden)]
2723    __Unknown(i32),
2724}
2725
2726impl fmt::Display for VisualType {
2727    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2728        write!(
2729            f,
2730            "VisualType::{}",
2731            match *self {
2732                VisualType::StaticGray => "StaticGray",
2733                VisualType::Grayscale => "Grayscale",
2734                VisualType::StaticColor => "StaticColor",
2735                VisualType::PseudoColor => "PseudoColor",
2736                VisualType::TrueColor => "TrueColor",
2737                VisualType::DirectColor => "DirectColor",
2738                _ => "Unknown",
2739            }
2740        )
2741    }
2742}
2743
2744#[doc(hidden)]
2745impl ToGlib for VisualType {
2746    type GlibType = gdk_sys::GdkVisualType;
2747
2748    fn to_glib(&self) -> gdk_sys::GdkVisualType {
2749        match *self {
2750            VisualType::StaticGray => gdk_sys::GDK_VISUAL_STATIC_GRAY,
2751            VisualType::Grayscale => gdk_sys::GDK_VISUAL_GRAYSCALE,
2752            VisualType::StaticColor => gdk_sys::GDK_VISUAL_STATIC_COLOR,
2753            VisualType::PseudoColor => gdk_sys::GDK_VISUAL_PSEUDO_COLOR,
2754            VisualType::TrueColor => gdk_sys::GDK_VISUAL_TRUE_COLOR,
2755            VisualType::DirectColor => gdk_sys::GDK_VISUAL_DIRECT_COLOR,
2756            VisualType::__Unknown(value) => value,
2757        }
2758    }
2759}
2760
2761#[doc(hidden)]
2762impl FromGlib<gdk_sys::GdkVisualType> for VisualType {
2763    fn from_glib(value: gdk_sys::GdkVisualType) -> Self {
2764        skip_assert_initialized!();
2765        match value {
2766            0 => VisualType::StaticGray,
2767            1 => VisualType::Grayscale,
2768            2 => VisualType::StaticColor,
2769            3 => VisualType::PseudoColor,
2770            4 => VisualType::TrueColor,
2771            5 => VisualType::DirectColor,
2772            value => VisualType::__Unknown(value),
2773        }
2774    }
2775}
2776
2777impl StaticType for VisualType {
2778    fn static_type() -> Type {
2779        unsafe { from_glib(gdk_sys::gdk_visual_type_get_type()) }
2780    }
2781}
2782
2783impl<'a> FromValueOptional<'a> for VisualType {
2784    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
2785        Some(FromValue::from_value(value))
2786    }
2787}
2788
2789impl<'a> FromValue<'a> for VisualType {
2790    unsafe fn from_value(value: &Value) -> Self {
2791        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
2792    }
2793}
2794
2795impl SetValue for VisualType {
2796    unsafe fn set_value(value: &mut Value, this: &Self) {
2797        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
2798    }
2799}
2800
2801#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2802pub enum WindowEdge {
2803    NorthWest,
2804    North,
2805    NorthEast,
2806    West,
2807    East,
2808    SouthWest,
2809    South,
2810    SouthEast,
2811    #[doc(hidden)]
2812    __Unknown(i32),
2813}
2814
2815impl fmt::Display for WindowEdge {
2816    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2817        write!(
2818            f,
2819            "WindowEdge::{}",
2820            match *self {
2821                WindowEdge::NorthWest => "NorthWest",
2822                WindowEdge::North => "North",
2823                WindowEdge::NorthEast => "NorthEast",
2824                WindowEdge::West => "West",
2825                WindowEdge::East => "East",
2826                WindowEdge::SouthWest => "SouthWest",
2827                WindowEdge::South => "South",
2828                WindowEdge::SouthEast => "SouthEast",
2829                _ => "Unknown",
2830            }
2831        )
2832    }
2833}
2834
2835#[doc(hidden)]
2836impl ToGlib for WindowEdge {
2837    type GlibType = gdk_sys::GdkWindowEdge;
2838
2839    fn to_glib(&self) -> gdk_sys::GdkWindowEdge {
2840        match *self {
2841            WindowEdge::NorthWest => gdk_sys::GDK_WINDOW_EDGE_NORTH_WEST,
2842            WindowEdge::North => gdk_sys::GDK_WINDOW_EDGE_NORTH,
2843            WindowEdge::NorthEast => gdk_sys::GDK_WINDOW_EDGE_NORTH_EAST,
2844            WindowEdge::West => gdk_sys::GDK_WINDOW_EDGE_WEST,
2845            WindowEdge::East => gdk_sys::GDK_WINDOW_EDGE_EAST,
2846            WindowEdge::SouthWest => gdk_sys::GDK_WINDOW_EDGE_SOUTH_WEST,
2847            WindowEdge::South => gdk_sys::GDK_WINDOW_EDGE_SOUTH,
2848            WindowEdge::SouthEast => gdk_sys::GDK_WINDOW_EDGE_SOUTH_EAST,
2849            WindowEdge::__Unknown(value) => value,
2850        }
2851    }
2852}
2853
2854#[doc(hidden)]
2855impl FromGlib<gdk_sys::GdkWindowEdge> for WindowEdge {
2856    fn from_glib(value: gdk_sys::GdkWindowEdge) -> Self {
2857        skip_assert_initialized!();
2858        match value {
2859            0 => WindowEdge::NorthWest,
2860            1 => WindowEdge::North,
2861            2 => WindowEdge::NorthEast,
2862            3 => WindowEdge::West,
2863            4 => WindowEdge::East,
2864            5 => WindowEdge::SouthWest,
2865            6 => WindowEdge::South,
2866            7 => WindowEdge::SouthEast,
2867            value => WindowEdge::__Unknown(value),
2868        }
2869    }
2870}
2871
2872impl StaticType for WindowEdge {
2873    fn static_type() -> Type {
2874        unsafe { from_glib(gdk_sys::gdk_window_edge_get_type()) }
2875    }
2876}
2877
2878impl<'a> FromValueOptional<'a> for WindowEdge {
2879    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
2880        Some(FromValue::from_value(value))
2881    }
2882}
2883
2884impl<'a> FromValue<'a> for WindowEdge {
2885    unsafe fn from_value(value: &Value) -> Self {
2886        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
2887    }
2888}
2889
2890impl SetValue for WindowEdge {
2891    unsafe fn set_value(value: &mut Value, this: &Self) {
2892        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
2893    }
2894}
2895
2896#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2897pub enum WindowType {
2898    Root,
2899    Toplevel,
2900    Child,
2901    Temp,
2902    Foreign,
2903    Offscreen,
2904    Subsurface,
2905    #[doc(hidden)]
2906    __Unknown(i32),
2907}
2908
2909impl fmt::Display for WindowType {
2910    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2911        write!(
2912            f,
2913            "WindowType::{}",
2914            match *self {
2915                WindowType::Root => "Root",
2916                WindowType::Toplevel => "Toplevel",
2917                WindowType::Child => "Child",
2918                WindowType::Temp => "Temp",
2919                WindowType::Foreign => "Foreign",
2920                WindowType::Offscreen => "Offscreen",
2921                WindowType::Subsurface => "Subsurface",
2922                _ => "Unknown",
2923            }
2924        )
2925    }
2926}
2927
2928#[doc(hidden)]
2929impl ToGlib for WindowType {
2930    type GlibType = gdk_sys::GdkWindowType;
2931
2932    fn to_glib(&self) -> gdk_sys::GdkWindowType {
2933        match *self {
2934            WindowType::Root => gdk_sys::GDK_WINDOW_ROOT,
2935            WindowType::Toplevel => gdk_sys::GDK_WINDOW_TOPLEVEL,
2936            WindowType::Child => gdk_sys::GDK_WINDOW_CHILD,
2937            WindowType::Temp => gdk_sys::GDK_WINDOW_TEMP,
2938            WindowType::Foreign => gdk_sys::GDK_WINDOW_FOREIGN,
2939            WindowType::Offscreen => gdk_sys::GDK_WINDOW_OFFSCREEN,
2940            WindowType::Subsurface => gdk_sys::GDK_WINDOW_SUBSURFACE,
2941            WindowType::__Unknown(value) => value,
2942        }
2943    }
2944}
2945
2946#[doc(hidden)]
2947impl FromGlib<gdk_sys::GdkWindowType> for WindowType {
2948    fn from_glib(value: gdk_sys::GdkWindowType) -> Self {
2949        skip_assert_initialized!();
2950        match value {
2951            0 => WindowType::Root,
2952            1 => WindowType::Toplevel,
2953            2 => WindowType::Child,
2954            3 => WindowType::Temp,
2955            4 => WindowType::Foreign,
2956            5 => WindowType::Offscreen,
2957            6 => WindowType::Subsurface,
2958            value => WindowType::__Unknown(value),
2959        }
2960    }
2961}
2962
2963impl StaticType for WindowType {
2964    fn static_type() -> Type {
2965        unsafe { from_glib(gdk_sys::gdk_window_type_get_type()) }
2966    }
2967}
2968
2969impl<'a> FromValueOptional<'a> for WindowType {
2970    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
2971        Some(FromValue::from_value(value))
2972    }
2973}
2974
2975impl<'a> FromValue<'a> for WindowType {
2976    unsafe fn from_value(value: &Value) -> Self {
2977        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
2978    }
2979}
2980
2981impl SetValue for WindowType {
2982    unsafe fn set_value(value: &mut Value, this: &Self) {
2983        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
2984    }
2985}
2986
2987#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2988pub enum WindowTypeHint {
2989    Normal,
2990    Dialog,
2991    Menu,
2992    Toolbar,
2993    Splashscreen,
2994    Utility,
2995    Dock,
2996    Desktop,
2997    DropdownMenu,
2998    PopupMenu,
2999    Tooltip,
3000    Notification,
3001    Combo,
3002    Dnd,
3003    #[doc(hidden)]
3004    __Unknown(i32),
3005}
3006
3007impl fmt::Display for WindowTypeHint {
3008    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3009        write!(
3010            f,
3011            "WindowTypeHint::{}",
3012            match *self {
3013                WindowTypeHint::Normal => "Normal",
3014                WindowTypeHint::Dialog => "Dialog",
3015                WindowTypeHint::Menu => "Menu",
3016                WindowTypeHint::Toolbar => "Toolbar",
3017                WindowTypeHint::Splashscreen => "Splashscreen",
3018                WindowTypeHint::Utility => "Utility",
3019                WindowTypeHint::Dock => "Dock",
3020                WindowTypeHint::Desktop => "Desktop",
3021                WindowTypeHint::DropdownMenu => "DropdownMenu",
3022                WindowTypeHint::PopupMenu => "PopupMenu",
3023                WindowTypeHint::Tooltip => "Tooltip",
3024                WindowTypeHint::Notification => "Notification",
3025                WindowTypeHint::Combo => "Combo",
3026                WindowTypeHint::Dnd => "Dnd",
3027                _ => "Unknown",
3028            }
3029        )
3030    }
3031}
3032
3033#[doc(hidden)]
3034impl ToGlib for WindowTypeHint {
3035    type GlibType = gdk_sys::GdkWindowTypeHint;
3036
3037    fn to_glib(&self) -> gdk_sys::GdkWindowTypeHint {
3038        match *self {
3039            WindowTypeHint::Normal => gdk_sys::GDK_WINDOW_TYPE_HINT_NORMAL,
3040            WindowTypeHint::Dialog => gdk_sys::GDK_WINDOW_TYPE_HINT_DIALOG,
3041            WindowTypeHint::Menu => gdk_sys::GDK_WINDOW_TYPE_HINT_MENU,
3042            WindowTypeHint::Toolbar => gdk_sys::GDK_WINDOW_TYPE_HINT_TOOLBAR,
3043            WindowTypeHint::Splashscreen => gdk_sys::GDK_WINDOW_TYPE_HINT_SPLASHSCREEN,
3044            WindowTypeHint::Utility => gdk_sys::GDK_WINDOW_TYPE_HINT_UTILITY,
3045            WindowTypeHint::Dock => gdk_sys::GDK_WINDOW_TYPE_HINT_DOCK,
3046            WindowTypeHint::Desktop => gdk_sys::GDK_WINDOW_TYPE_HINT_DESKTOP,
3047            WindowTypeHint::DropdownMenu => gdk_sys::GDK_WINDOW_TYPE_HINT_DROPDOWN_MENU,
3048            WindowTypeHint::PopupMenu => gdk_sys::GDK_WINDOW_TYPE_HINT_POPUP_MENU,
3049            WindowTypeHint::Tooltip => gdk_sys::GDK_WINDOW_TYPE_HINT_TOOLTIP,
3050            WindowTypeHint::Notification => gdk_sys::GDK_WINDOW_TYPE_HINT_NOTIFICATION,
3051            WindowTypeHint::Combo => gdk_sys::GDK_WINDOW_TYPE_HINT_COMBO,
3052            WindowTypeHint::Dnd => gdk_sys::GDK_WINDOW_TYPE_HINT_DND,
3053            WindowTypeHint::__Unknown(value) => value,
3054        }
3055    }
3056}
3057
3058#[doc(hidden)]
3059impl FromGlib<gdk_sys::GdkWindowTypeHint> for WindowTypeHint {
3060    fn from_glib(value: gdk_sys::GdkWindowTypeHint) -> Self {
3061        skip_assert_initialized!();
3062        match value {
3063            0 => WindowTypeHint::Normal,
3064            1 => WindowTypeHint::Dialog,
3065            2 => WindowTypeHint::Menu,
3066            3 => WindowTypeHint::Toolbar,
3067            4 => WindowTypeHint::Splashscreen,
3068            5 => WindowTypeHint::Utility,
3069            6 => WindowTypeHint::Dock,
3070            7 => WindowTypeHint::Desktop,
3071            8 => WindowTypeHint::DropdownMenu,
3072            9 => WindowTypeHint::PopupMenu,
3073            10 => WindowTypeHint::Tooltip,
3074            11 => WindowTypeHint::Notification,
3075            12 => WindowTypeHint::Combo,
3076            13 => WindowTypeHint::Dnd,
3077            value => WindowTypeHint::__Unknown(value),
3078        }
3079    }
3080}
3081
3082impl StaticType for WindowTypeHint {
3083    fn static_type() -> Type {
3084        unsafe { from_glib(gdk_sys::gdk_window_type_hint_get_type()) }
3085    }
3086}
3087
3088impl<'a> FromValueOptional<'a> for WindowTypeHint {
3089    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
3090        Some(FromValue::from_value(value))
3091    }
3092}
3093
3094impl<'a> FromValue<'a> for WindowTypeHint {
3095    unsafe fn from_value(value: &Value) -> Self {
3096        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
3097    }
3098}
3099
3100impl SetValue for WindowTypeHint {
3101    unsafe fn set_value(value: &mut Value, this: &Self) {
3102        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
3103    }
3104}
3105
3106#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3107pub enum WindowWindowClass {
3108    InputOutput,
3109    InputOnly,
3110    #[doc(hidden)]
3111    __Unknown(i32),
3112}
3113
3114impl fmt::Display for WindowWindowClass {
3115    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
3116        write!(
3117            f,
3118            "WindowWindowClass::{}",
3119            match *self {
3120                WindowWindowClass::InputOutput => "InputOutput",
3121                WindowWindowClass::InputOnly => "InputOnly",
3122                _ => "Unknown",
3123            }
3124        )
3125    }
3126}
3127
3128#[doc(hidden)]
3129impl ToGlib for WindowWindowClass {
3130    type GlibType = gdk_sys::GdkWindowWindowClass;
3131
3132    fn to_glib(&self) -> gdk_sys::GdkWindowWindowClass {
3133        match *self {
3134            WindowWindowClass::InputOutput => gdk_sys::GDK_INPUT_OUTPUT,
3135            WindowWindowClass::InputOnly => gdk_sys::GDK_INPUT_ONLY,
3136            WindowWindowClass::__Unknown(value) => value,
3137        }
3138    }
3139}
3140
3141#[doc(hidden)]
3142impl FromGlib<gdk_sys::GdkWindowWindowClass> for WindowWindowClass {
3143    fn from_glib(value: gdk_sys::GdkWindowWindowClass) -> Self {
3144        skip_assert_initialized!();
3145        match value {
3146            0 => WindowWindowClass::InputOutput,
3147            1 => WindowWindowClass::InputOnly,
3148            value => WindowWindowClass::__Unknown(value),
3149        }
3150    }
3151}
3152
3153impl StaticType for WindowWindowClass {
3154    fn static_type() -> Type {
3155        unsafe { from_glib(gdk_sys::gdk_window_window_class_get_type()) }
3156    }
3157}
3158
3159impl<'a> FromValueOptional<'a> for WindowWindowClass {
3160    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
3161        Some(FromValue::from_value(value))
3162    }
3163}
3164
3165impl<'a> FromValue<'a> for WindowWindowClass {
3166    unsafe fn from_value(value: &Value) -> Self {
3167        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
3168    }
3169}
3170
3171impl SetValue for WindowWindowClass {
3172    unsafe fn set_value(value: &mut Value, this: &Self) {
3173        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
3174    }
3175}