Skip to main content

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 crate::ffi;
6use glib::{prelude::*, translate::*};
7
8/// An enumeration describing the way in which a device
9/// axis (valuator) maps onto the predefined valuator
10/// types that GTK+ understands.
11///
12/// Note that the X and Y axes are not really needed; pointer devices
13/// report their location via the x/y members of events regardless. Whether
14/// X and Y are present as axes depends on the GDK backend.
15#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
16#[non_exhaustive]
17#[doc(alias = "GdkAxisUse")]
18pub enum AxisUse {
19    /// the axis is ignored.
20    #[doc(alias = "GDK_AXIS_IGNORE")]
21    Ignore,
22    /// the axis is used as the x axis.
23    #[doc(alias = "GDK_AXIS_X")]
24    X,
25    /// the axis is used as the y axis.
26    #[doc(alias = "GDK_AXIS_Y")]
27    Y,
28    /// the axis is used for pressure information.
29    #[doc(alias = "GDK_AXIS_PRESSURE")]
30    Pressure,
31    /// the axis is used for x tilt information.
32    #[doc(alias = "GDK_AXIS_XTILT")]
33    Xtilt,
34    /// the axis is used for y tilt information.
35    #[doc(alias = "GDK_AXIS_YTILT")]
36    Ytilt,
37    /// the axis is used for wheel information.
38    #[doc(alias = "GDK_AXIS_WHEEL")]
39    Wheel,
40    /// the axis is used for pen/tablet distance information. (Since: 3.22)
41    #[doc(alias = "GDK_AXIS_DISTANCE")]
42    Distance,
43    /// the axis is used for pen rotation information. (Since: 3.22)
44    #[doc(alias = "GDK_AXIS_ROTATION")]
45    Rotation,
46    /// the axis is used for pen slider information. (Since: 3.22)
47    #[doc(alias = "GDK_AXIS_SLIDER")]
48    Slider,
49    /// a constant equal to the numerically highest axis value.
50    #[doc(alias = "GDK_AXIS_LAST")]
51    Last,
52    #[doc(hidden)]
53    __Unknown(i32),
54}
55
56#[doc(hidden)]
57impl IntoGlib for AxisUse {
58    type GlibType = ffi::GdkAxisUse;
59
60    #[inline]
61    fn into_glib(self) -> ffi::GdkAxisUse {
62        match self {
63            Self::Ignore => ffi::GDK_AXIS_IGNORE,
64            Self::X => ffi::GDK_AXIS_X,
65            Self::Y => ffi::GDK_AXIS_Y,
66            Self::Pressure => ffi::GDK_AXIS_PRESSURE,
67            Self::Xtilt => ffi::GDK_AXIS_XTILT,
68            Self::Ytilt => ffi::GDK_AXIS_YTILT,
69            Self::Wheel => ffi::GDK_AXIS_WHEEL,
70            Self::Distance => ffi::GDK_AXIS_DISTANCE,
71            Self::Rotation => ffi::GDK_AXIS_ROTATION,
72            Self::Slider => ffi::GDK_AXIS_SLIDER,
73            Self::Last => ffi::GDK_AXIS_LAST,
74            Self::__Unknown(value) => value,
75        }
76    }
77}
78
79#[doc(hidden)]
80impl FromGlib<ffi::GdkAxisUse> for AxisUse {
81    #[inline]
82    unsafe fn from_glib(value: ffi::GdkAxisUse) -> Self {
83        skip_assert_initialized!();
84
85        match value {
86            ffi::GDK_AXIS_IGNORE => Self::Ignore,
87            ffi::GDK_AXIS_X => Self::X,
88            ffi::GDK_AXIS_Y => Self::Y,
89            ffi::GDK_AXIS_PRESSURE => Self::Pressure,
90            ffi::GDK_AXIS_XTILT => Self::Xtilt,
91            ffi::GDK_AXIS_YTILT => Self::Ytilt,
92            ffi::GDK_AXIS_WHEEL => Self::Wheel,
93            ffi::GDK_AXIS_DISTANCE => Self::Distance,
94            ffi::GDK_AXIS_ROTATION => Self::Rotation,
95            ffi::GDK_AXIS_SLIDER => Self::Slider,
96            ffi::GDK_AXIS_LAST => Self::Last,
97            value => Self::__Unknown(value),
98        }
99    }
100}
101
102impl StaticType for AxisUse {
103    #[inline]
104    #[doc(alias = "gdk_axis_use_get_type")]
105    fn static_type() -> glib::Type {
106        unsafe { from_glib(ffi::gdk_axis_use_get_type()) }
107    }
108}
109
110impl glib::HasParamSpec for AxisUse {
111    type ParamSpec = glib::ParamSpecEnum;
112    type SetValue = Self;
113    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
114
115    fn param_spec_builder() -> Self::BuilderFn {
116        Self::ParamSpec::builder_with_default
117    }
118}
119
120impl glib::value::ValueType for AxisUse {
121    type Type = Self;
122}
123
124unsafe impl<'a> glib::value::FromValue<'a> for AxisUse {
125    type Checker = glib::value::GenericValueTypeChecker<Self>;
126
127    #[inline]
128    unsafe fn from_value(value: &'a glib::Value) -> Self {
129        skip_assert_initialized!();
130        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
131    }
132}
133
134impl ToValue for AxisUse {
135    #[inline]
136    fn to_value(&self) -> glib::Value {
137        let mut value = glib::Value::for_value_type::<Self>();
138        unsafe {
139            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
140        }
141        value
142    }
143
144    #[inline]
145    fn value_type(&self) -> glib::Type {
146        Self::static_type()
147    }
148}
149
150impl From<AxisUse> for glib::Value {
151    #[inline]
152    fn from(v: AxisUse) -> Self {
153        skip_assert_initialized!();
154        ToValue::to_value(&v)
155    }
156}
157
158/// A set of values describing the possible byte-orders
159/// for storing pixel values in memory.
160#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
161#[non_exhaustive]
162#[doc(alias = "GdkByteOrder")]
163pub enum ByteOrder {
164    /// The values are stored with the least-significant byte
165    ///  first. For instance, the 32-bit value 0xffeecc would be stored
166    ///  in memory as 0xcc, 0xee, 0xff, 0x00.
167    #[doc(alias = "GDK_LSB_FIRST")]
168    LsbFirst,
169    /// The values are stored with the most-significant byte
170    ///  first. For instance, the 32-bit value 0xffeecc would be stored
171    ///  in memory as 0x00, 0xff, 0xee, 0xcc.
172    #[doc(alias = "GDK_MSB_FIRST")]
173    MsbFirst,
174    #[doc(hidden)]
175    __Unknown(i32),
176}
177
178#[doc(hidden)]
179impl IntoGlib for ByteOrder {
180    type GlibType = ffi::GdkByteOrder;
181
182    #[inline]
183    fn into_glib(self) -> ffi::GdkByteOrder {
184        match self {
185            Self::LsbFirst => ffi::GDK_LSB_FIRST,
186            Self::MsbFirst => ffi::GDK_MSB_FIRST,
187            Self::__Unknown(value) => value,
188        }
189    }
190}
191
192#[doc(hidden)]
193impl FromGlib<ffi::GdkByteOrder> for ByteOrder {
194    #[inline]
195    unsafe fn from_glib(value: ffi::GdkByteOrder) -> Self {
196        skip_assert_initialized!();
197
198        match value {
199            ffi::GDK_LSB_FIRST => Self::LsbFirst,
200            ffi::GDK_MSB_FIRST => Self::MsbFirst,
201            value => Self::__Unknown(value),
202        }
203    }
204}
205
206impl StaticType for ByteOrder {
207    #[inline]
208    #[doc(alias = "gdk_byte_order_get_type")]
209    fn static_type() -> glib::Type {
210        unsafe { from_glib(ffi::gdk_byte_order_get_type()) }
211    }
212}
213
214impl glib::HasParamSpec for ByteOrder {
215    type ParamSpec = glib::ParamSpecEnum;
216    type SetValue = Self;
217    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
218
219    fn param_spec_builder() -> Self::BuilderFn {
220        Self::ParamSpec::builder_with_default
221    }
222}
223
224impl glib::value::ValueType for ByteOrder {
225    type Type = Self;
226}
227
228unsafe impl<'a> glib::value::FromValue<'a> for ByteOrder {
229    type Checker = glib::value::GenericValueTypeChecker<Self>;
230
231    #[inline]
232    unsafe fn from_value(value: &'a glib::Value) -> Self {
233        skip_assert_initialized!();
234        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
235    }
236}
237
238impl ToValue for ByteOrder {
239    #[inline]
240    fn to_value(&self) -> glib::Value {
241        let mut value = glib::Value::for_value_type::<Self>();
242        unsafe {
243            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
244        }
245        value
246    }
247
248    #[inline]
249    fn value_type(&self) -> glib::Type {
250        Self::static_type()
251    }
252}
253
254impl From<ByteOrder> for glib::Value {
255    #[inline]
256    fn from(v: ByteOrder) -> Self {
257        skip_assert_initialized!();
258        ToValue::to_value(&v)
259    }
260}
261
262/// Specifies the crossing mode for [`EventCrossing`][crate::EventCrossing].
263#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
264#[non_exhaustive]
265#[doc(alias = "GdkCrossingMode")]
266pub enum CrossingMode {
267    /// crossing because of pointer motion.
268    #[doc(alias = "GDK_CROSSING_NORMAL")]
269    Normal,
270    /// crossing because a grab is activated.
271    #[doc(alias = "GDK_CROSSING_GRAB")]
272    Grab,
273    /// crossing because a grab is deactivated.
274    #[doc(alias = "GDK_CROSSING_UNGRAB")]
275    Ungrab,
276    /// crossing because a GTK+ grab is activated.
277    #[doc(alias = "GDK_CROSSING_GTK_GRAB")]
278    GtkGrab,
279    /// crossing because a GTK+ grab is deactivated.
280    #[doc(alias = "GDK_CROSSING_GTK_UNGRAB")]
281    GtkUngrab,
282    /// crossing because a GTK+ widget changed
283    ///  state (e.g. sensitivity).
284    #[doc(alias = "GDK_CROSSING_STATE_CHANGED")]
285    StateChanged,
286    /// crossing because a touch sequence has begun,
287    ///  this event is synthetic as the pointer might have not left the window.
288    #[doc(alias = "GDK_CROSSING_TOUCH_BEGIN")]
289    TouchBegin,
290    /// crossing because a touch sequence has ended,
291    ///  this event is synthetic as the pointer might have not left the window.
292    #[doc(alias = "GDK_CROSSING_TOUCH_END")]
293    TouchEnd,
294    /// crossing because of a device switch (i.e.
295    ///  a mouse taking control of the pointer after a touch device), this event
296    ///  is synthetic as the pointer didn’t leave the window.
297    #[doc(alias = "GDK_CROSSING_DEVICE_SWITCH")]
298    DeviceSwitch,
299    #[doc(hidden)]
300    __Unknown(i32),
301}
302
303#[doc(hidden)]
304impl IntoGlib for CrossingMode {
305    type GlibType = ffi::GdkCrossingMode;
306
307    #[inline]
308    fn into_glib(self) -> ffi::GdkCrossingMode {
309        match self {
310            Self::Normal => ffi::GDK_CROSSING_NORMAL,
311            Self::Grab => ffi::GDK_CROSSING_GRAB,
312            Self::Ungrab => ffi::GDK_CROSSING_UNGRAB,
313            Self::GtkGrab => ffi::GDK_CROSSING_GTK_GRAB,
314            Self::GtkUngrab => ffi::GDK_CROSSING_GTK_UNGRAB,
315            Self::StateChanged => ffi::GDK_CROSSING_STATE_CHANGED,
316            Self::TouchBegin => ffi::GDK_CROSSING_TOUCH_BEGIN,
317            Self::TouchEnd => ffi::GDK_CROSSING_TOUCH_END,
318            Self::DeviceSwitch => ffi::GDK_CROSSING_DEVICE_SWITCH,
319            Self::__Unknown(value) => value,
320        }
321    }
322}
323
324#[doc(hidden)]
325impl FromGlib<ffi::GdkCrossingMode> for CrossingMode {
326    #[inline]
327    unsafe fn from_glib(value: ffi::GdkCrossingMode) -> Self {
328        skip_assert_initialized!();
329
330        match value {
331            ffi::GDK_CROSSING_NORMAL => Self::Normal,
332            ffi::GDK_CROSSING_GRAB => Self::Grab,
333            ffi::GDK_CROSSING_UNGRAB => Self::Ungrab,
334            ffi::GDK_CROSSING_GTK_GRAB => Self::GtkGrab,
335            ffi::GDK_CROSSING_GTK_UNGRAB => Self::GtkUngrab,
336            ffi::GDK_CROSSING_STATE_CHANGED => Self::StateChanged,
337            ffi::GDK_CROSSING_TOUCH_BEGIN => Self::TouchBegin,
338            ffi::GDK_CROSSING_TOUCH_END => Self::TouchEnd,
339            ffi::GDK_CROSSING_DEVICE_SWITCH => Self::DeviceSwitch,
340            value => Self::__Unknown(value),
341        }
342    }
343}
344
345impl StaticType for CrossingMode {
346    #[inline]
347    #[doc(alias = "gdk_crossing_mode_get_type")]
348    fn static_type() -> glib::Type {
349        unsafe { from_glib(ffi::gdk_crossing_mode_get_type()) }
350    }
351}
352
353impl glib::HasParamSpec for CrossingMode {
354    type ParamSpec = glib::ParamSpecEnum;
355    type SetValue = Self;
356    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
357
358    fn param_spec_builder() -> Self::BuilderFn {
359        Self::ParamSpec::builder_with_default
360    }
361}
362
363impl glib::value::ValueType for CrossingMode {
364    type Type = Self;
365}
366
367unsafe impl<'a> glib::value::FromValue<'a> for CrossingMode {
368    type Checker = glib::value::GenericValueTypeChecker<Self>;
369
370    #[inline]
371    unsafe fn from_value(value: &'a glib::Value) -> Self {
372        skip_assert_initialized!();
373        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
374    }
375}
376
377impl ToValue for CrossingMode {
378    #[inline]
379    fn to_value(&self) -> glib::Value {
380        let mut value = glib::Value::for_value_type::<Self>();
381        unsafe {
382            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
383        }
384        value
385    }
386
387    #[inline]
388    fn value_type(&self) -> glib::Type {
389        Self::static_type()
390    }
391}
392
393impl From<CrossingMode> for glib::Value {
394    #[inline]
395    fn from(v: CrossingMode) -> Self {
396        skip_assert_initialized!();
397        ToValue::to_value(&v)
398    }
399}
400
401/// Predefined cursors.
402///
403/// Note that these IDs are directly taken from the X cursor font, and many
404/// of these cursors are either not useful, or are not available on other platforms.
405///
406/// The recommended way to create cursors is to use [`Cursor::from_name()`][crate::Cursor::from_name()].
407#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
408#[non_exhaustive]
409#[doc(alias = "GdkCursorType")]
410pub enum CursorType {
411    /// ![](X_cursor.png)
412    #[doc(alias = "GDK_X_CURSOR")]
413    XCursor,
414    /// ![](arrow.png)
415    #[doc(alias = "GDK_ARROW")]
416    Arrow,
417    /// ![](based_arrow_down.png)
418    #[doc(alias = "GDK_BASED_ARROW_DOWN")]
419    BasedArrowDown,
420    /// ![](based_arrow_up.png)
421    #[doc(alias = "GDK_BASED_ARROW_UP")]
422    BasedArrowUp,
423    /// ![](boat.png)
424    #[doc(alias = "GDK_BOAT")]
425    Boat,
426    /// ![](bogosity.png)
427    #[doc(alias = "GDK_BOGOSITY")]
428    Bogosity,
429    /// ![](bottom_left_corner.png)
430    #[doc(alias = "GDK_BOTTOM_LEFT_CORNER")]
431    BottomLeftCorner,
432    /// ![](bottom_right_corner.png)
433    #[doc(alias = "GDK_BOTTOM_RIGHT_CORNER")]
434    BottomRightCorner,
435    /// ![](bottom_side.png)
436    #[doc(alias = "GDK_BOTTOM_SIDE")]
437    BottomSide,
438    /// ![](bottom_tee.png)
439    #[doc(alias = "GDK_BOTTOM_TEE")]
440    BottomTee,
441    /// ![](box_spiral.png)
442    #[doc(alias = "GDK_BOX_SPIRAL")]
443    BoxSpiral,
444    /// ![](center_ptr.png)
445    #[doc(alias = "GDK_CENTER_PTR")]
446    CenterPtr,
447    /// ![](circle.png)
448    #[doc(alias = "GDK_CIRCLE")]
449    Circle,
450    /// ![](clock.png)
451    #[doc(alias = "GDK_CLOCK")]
452    Clock,
453    /// ![](coffee_mug.png)
454    #[doc(alias = "GDK_COFFEE_MUG")]
455    CoffeeMug,
456    /// ![](cross.png)
457    #[doc(alias = "GDK_CROSS")]
458    Cross,
459    /// ![](cross_reverse.png)
460    #[doc(alias = "GDK_CROSS_REVERSE")]
461    CrossReverse,
462    /// ![](crosshair.png)
463    #[doc(alias = "GDK_CROSSHAIR")]
464    Crosshair,
465    /// ![](diamond_cross.png)
466    #[doc(alias = "GDK_DIAMOND_CROSS")]
467    DiamondCross,
468    /// ![](dot.png)
469    #[doc(alias = "GDK_DOT")]
470    Dot,
471    /// ![](dotbox.png)
472    #[doc(alias = "GDK_DOTBOX")]
473    Dotbox,
474    /// ![](double_arrow.png)
475    #[doc(alias = "GDK_DOUBLE_ARROW")]
476    DoubleArrow,
477    /// ![](draft_large.png)
478    #[doc(alias = "GDK_DRAFT_LARGE")]
479    DraftLarge,
480    /// ![](draft_small.png)
481    #[doc(alias = "GDK_DRAFT_SMALL")]
482    DraftSmall,
483    /// ![](draped_box.png)
484    #[doc(alias = "GDK_DRAPED_BOX")]
485    DrapedBox,
486    /// ![](exchange.png)
487    #[doc(alias = "GDK_EXCHANGE")]
488    Exchange,
489    /// ![](fleur.png)
490    #[doc(alias = "GDK_FLEUR")]
491    Fleur,
492    /// ![](gobbler.png)
493    #[doc(alias = "GDK_GOBBLER")]
494    Gobbler,
495    /// ![](gumby.png)
496    #[doc(alias = "GDK_GUMBY")]
497    Gumby,
498    /// ![](hand1.png)
499    #[doc(alias = "GDK_HAND1")]
500    Hand1,
501    /// ![](hand2.png)
502    #[doc(alias = "GDK_HAND2")]
503    Hand2,
504    /// ![](heart.png)
505    #[doc(alias = "GDK_HEART")]
506    Heart,
507    /// ![](icon.png)
508    #[doc(alias = "GDK_ICON")]
509    Icon,
510    /// ![](iron_cross.png)
511    #[doc(alias = "GDK_IRON_CROSS")]
512    IronCross,
513    /// ![](left_ptr.png)
514    #[doc(alias = "GDK_LEFT_PTR")]
515    LeftPtr,
516    /// ![](left_side.png)
517    #[doc(alias = "GDK_LEFT_SIDE")]
518    LeftSide,
519    /// ![](left_tee.png)
520    #[doc(alias = "GDK_LEFT_TEE")]
521    LeftTee,
522    /// ![](leftbutton.png)
523    #[doc(alias = "GDK_LEFTBUTTON")]
524    Leftbutton,
525    /// ![](ll_angle.png)
526    #[doc(alias = "GDK_LL_ANGLE")]
527    LlAngle,
528    /// ![](lr_angle.png)
529    #[doc(alias = "GDK_LR_ANGLE")]
530    LrAngle,
531    /// ![](man.png)
532    #[doc(alias = "GDK_MAN")]
533    Man,
534    /// ![](middlebutton.png)
535    #[doc(alias = "GDK_MIDDLEBUTTON")]
536    Middlebutton,
537    /// ![](mouse.png)
538    #[doc(alias = "GDK_MOUSE")]
539    Mouse,
540    /// ![](pencil.png)
541    #[doc(alias = "GDK_PENCIL")]
542    Pencil,
543    /// ![](pirate.png)
544    #[doc(alias = "GDK_PIRATE")]
545    Pirate,
546    /// ![](plus.png)
547    #[doc(alias = "GDK_PLUS")]
548    Plus,
549    /// ![](question_arrow.png)
550    #[doc(alias = "GDK_QUESTION_ARROW")]
551    QuestionArrow,
552    /// ![](right_ptr.png)
553    #[doc(alias = "GDK_RIGHT_PTR")]
554    RightPtr,
555    /// ![](right_side.png)
556    #[doc(alias = "GDK_RIGHT_SIDE")]
557    RightSide,
558    /// ![](right_tee.png)
559    #[doc(alias = "GDK_RIGHT_TEE")]
560    RightTee,
561    /// ![](rightbutton.png)
562    #[doc(alias = "GDK_RIGHTBUTTON")]
563    Rightbutton,
564    /// ![](rtl_logo.png)
565    #[doc(alias = "GDK_RTL_LOGO")]
566    RtlLogo,
567    /// ![](sailboat.png)
568    #[doc(alias = "GDK_SAILBOAT")]
569    Sailboat,
570    /// ![](sb_down_arrow.png)
571    #[doc(alias = "GDK_SB_DOWN_ARROW")]
572    SbDownArrow,
573    /// ![](sb_h_double_arrow.png)
574    #[doc(alias = "GDK_SB_H_DOUBLE_ARROW")]
575    SbHDoubleArrow,
576    /// ![](sb_left_arrow.png)
577    #[doc(alias = "GDK_SB_LEFT_ARROW")]
578    SbLeftArrow,
579    /// ![](sb_right_arrow.png)
580    #[doc(alias = "GDK_SB_RIGHT_ARROW")]
581    SbRightArrow,
582    /// ![](sb_up_arrow.png)
583    #[doc(alias = "GDK_SB_UP_ARROW")]
584    SbUpArrow,
585    /// ![](sb_v_double_arrow.png)
586    #[doc(alias = "GDK_SB_V_DOUBLE_ARROW")]
587    SbVDoubleArrow,
588    /// ![](shuttle.png)
589    #[doc(alias = "GDK_SHUTTLE")]
590    Shuttle,
591    /// ![](sizing.png)
592    #[doc(alias = "GDK_SIZING")]
593    Sizing,
594    /// ![](spider.png)
595    #[doc(alias = "GDK_SPIDER")]
596    Spider,
597    /// ![](spraycan.png)
598    #[doc(alias = "GDK_SPRAYCAN")]
599    Spraycan,
600    /// ![](star.png)
601    #[doc(alias = "GDK_STAR")]
602    Star,
603    /// ![](target.png)
604    #[doc(alias = "GDK_TARGET")]
605    Target,
606    /// ![](tcross.png)
607    #[doc(alias = "GDK_TCROSS")]
608    Tcross,
609    /// ![](top_left_arrow.png)
610    #[doc(alias = "GDK_TOP_LEFT_ARROW")]
611    TopLeftArrow,
612    /// ![](top_left_corner.png)
613    #[doc(alias = "GDK_TOP_LEFT_CORNER")]
614    TopLeftCorner,
615    /// ![](top_right_corner.png)
616    #[doc(alias = "GDK_TOP_RIGHT_CORNER")]
617    TopRightCorner,
618    /// ![](top_side.png)
619    #[doc(alias = "GDK_TOP_SIDE")]
620    TopSide,
621    /// ![](top_tee.png)
622    #[doc(alias = "GDK_TOP_TEE")]
623    TopTee,
624    /// ![](trek.png)
625    #[doc(alias = "GDK_TREK")]
626    Trek,
627    /// ![](ul_angle.png)
628    #[doc(alias = "GDK_UL_ANGLE")]
629    UlAngle,
630    /// ![](umbrella.png)
631    #[doc(alias = "GDK_UMBRELLA")]
632    Umbrella,
633    /// ![](ur_angle.png)
634    #[doc(alias = "GDK_UR_ANGLE")]
635    UrAngle,
636    /// ![](watch.png)
637    #[doc(alias = "GDK_WATCH")]
638    Watch,
639    /// ![](xterm.png)
640    #[doc(alias = "GDK_XTERM")]
641    Xterm,
642    /// last cursor type
643    #[doc(alias = "GDK_LAST_CURSOR")]
644    LastCursor,
645    /// Blank cursor. Since 2.16
646    #[doc(alias = "GDK_BLANK_CURSOR")]
647    BlankCursor,
648    /// type of cursors constructed with
649    ///  [`Cursor::from_pixbuf()`][crate::Cursor::from_pixbuf()]
650    #[doc(alias = "GDK_CURSOR_IS_PIXMAP")]
651    CursorIsPixmap,
652    #[doc(hidden)]
653    __Unknown(i32),
654}
655
656#[doc(hidden)]
657impl IntoGlib for CursorType {
658    type GlibType = ffi::GdkCursorType;
659
660    fn into_glib(self) -> ffi::GdkCursorType {
661        match self {
662            Self::XCursor => ffi::GDK_X_CURSOR,
663            Self::Arrow => ffi::GDK_ARROW,
664            Self::BasedArrowDown => ffi::GDK_BASED_ARROW_DOWN,
665            Self::BasedArrowUp => ffi::GDK_BASED_ARROW_UP,
666            Self::Boat => ffi::GDK_BOAT,
667            Self::Bogosity => ffi::GDK_BOGOSITY,
668            Self::BottomLeftCorner => ffi::GDK_BOTTOM_LEFT_CORNER,
669            Self::BottomRightCorner => ffi::GDK_BOTTOM_RIGHT_CORNER,
670            Self::BottomSide => ffi::GDK_BOTTOM_SIDE,
671            Self::BottomTee => ffi::GDK_BOTTOM_TEE,
672            Self::BoxSpiral => ffi::GDK_BOX_SPIRAL,
673            Self::CenterPtr => ffi::GDK_CENTER_PTR,
674            Self::Circle => ffi::GDK_CIRCLE,
675            Self::Clock => ffi::GDK_CLOCK,
676            Self::CoffeeMug => ffi::GDK_COFFEE_MUG,
677            Self::Cross => ffi::GDK_CROSS,
678            Self::CrossReverse => ffi::GDK_CROSS_REVERSE,
679            Self::Crosshair => ffi::GDK_CROSSHAIR,
680            Self::DiamondCross => ffi::GDK_DIAMOND_CROSS,
681            Self::Dot => ffi::GDK_DOT,
682            Self::Dotbox => ffi::GDK_DOTBOX,
683            Self::DoubleArrow => ffi::GDK_DOUBLE_ARROW,
684            Self::DraftLarge => ffi::GDK_DRAFT_LARGE,
685            Self::DraftSmall => ffi::GDK_DRAFT_SMALL,
686            Self::DrapedBox => ffi::GDK_DRAPED_BOX,
687            Self::Exchange => ffi::GDK_EXCHANGE,
688            Self::Fleur => ffi::GDK_FLEUR,
689            Self::Gobbler => ffi::GDK_GOBBLER,
690            Self::Gumby => ffi::GDK_GUMBY,
691            Self::Hand1 => ffi::GDK_HAND1,
692            Self::Hand2 => ffi::GDK_HAND2,
693            Self::Heart => ffi::GDK_HEART,
694            Self::Icon => ffi::GDK_ICON,
695            Self::IronCross => ffi::GDK_IRON_CROSS,
696            Self::LeftPtr => ffi::GDK_LEFT_PTR,
697            Self::LeftSide => ffi::GDK_LEFT_SIDE,
698            Self::LeftTee => ffi::GDK_LEFT_TEE,
699            Self::Leftbutton => ffi::GDK_LEFTBUTTON,
700            Self::LlAngle => ffi::GDK_LL_ANGLE,
701            Self::LrAngle => ffi::GDK_LR_ANGLE,
702            Self::Man => ffi::GDK_MAN,
703            Self::Middlebutton => ffi::GDK_MIDDLEBUTTON,
704            Self::Mouse => ffi::GDK_MOUSE,
705            Self::Pencil => ffi::GDK_PENCIL,
706            Self::Pirate => ffi::GDK_PIRATE,
707            Self::Plus => ffi::GDK_PLUS,
708            Self::QuestionArrow => ffi::GDK_QUESTION_ARROW,
709            Self::RightPtr => ffi::GDK_RIGHT_PTR,
710            Self::RightSide => ffi::GDK_RIGHT_SIDE,
711            Self::RightTee => ffi::GDK_RIGHT_TEE,
712            Self::Rightbutton => ffi::GDK_RIGHTBUTTON,
713            Self::RtlLogo => ffi::GDK_RTL_LOGO,
714            Self::Sailboat => ffi::GDK_SAILBOAT,
715            Self::SbDownArrow => ffi::GDK_SB_DOWN_ARROW,
716            Self::SbHDoubleArrow => ffi::GDK_SB_H_DOUBLE_ARROW,
717            Self::SbLeftArrow => ffi::GDK_SB_LEFT_ARROW,
718            Self::SbRightArrow => ffi::GDK_SB_RIGHT_ARROW,
719            Self::SbUpArrow => ffi::GDK_SB_UP_ARROW,
720            Self::SbVDoubleArrow => ffi::GDK_SB_V_DOUBLE_ARROW,
721            Self::Shuttle => ffi::GDK_SHUTTLE,
722            Self::Sizing => ffi::GDK_SIZING,
723            Self::Spider => ffi::GDK_SPIDER,
724            Self::Spraycan => ffi::GDK_SPRAYCAN,
725            Self::Star => ffi::GDK_STAR,
726            Self::Target => ffi::GDK_TARGET,
727            Self::Tcross => ffi::GDK_TCROSS,
728            Self::TopLeftArrow => ffi::GDK_TOP_LEFT_ARROW,
729            Self::TopLeftCorner => ffi::GDK_TOP_LEFT_CORNER,
730            Self::TopRightCorner => ffi::GDK_TOP_RIGHT_CORNER,
731            Self::TopSide => ffi::GDK_TOP_SIDE,
732            Self::TopTee => ffi::GDK_TOP_TEE,
733            Self::Trek => ffi::GDK_TREK,
734            Self::UlAngle => ffi::GDK_UL_ANGLE,
735            Self::Umbrella => ffi::GDK_UMBRELLA,
736            Self::UrAngle => ffi::GDK_UR_ANGLE,
737            Self::Watch => ffi::GDK_WATCH,
738            Self::Xterm => ffi::GDK_XTERM,
739            Self::LastCursor => ffi::GDK_LAST_CURSOR,
740            Self::BlankCursor => ffi::GDK_BLANK_CURSOR,
741            Self::CursorIsPixmap => ffi::GDK_CURSOR_IS_PIXMAP,
742            Self::__Unknown(value) => value,
743        }
744    }
745}
746
747#[doc(hidden)]
748impl FromGlib<ffi::GdkCursorType> for CursorType {
749    unsafe fn from_glib(value: ffi::GdkCursorType) -> Self {
750        skip_assert_initialized!();
751
752        match value {
753            ffi::GDK_X_CURSOR => Self::XCursor,
754            ffi::GDK_ARROW => Self::Arrow,
755            ffi::GDK_BASED_ARROW_DOWN => Self::BasedArrowDown,
756            ffi::GDK_BASED_ARROW_UP => Self::BasedArrowUp,
757            ffi::GDK_BOAT => Self::Boat,
758            ffi::GDK_BOGOSITY => Self::Bogosity,
759            ffi::GDK_BOTTOM_LEFT_CORNER => Self::BottomLeftCorner,
760            ffi::GDK_BOTTOM_RIGHT_CORNER => Self::BottomRightCorner,
761            ffi::GDK_BOTTOM_SIDE => Self::BottomSide,
762            ffi::GDK_BOTTOM_TEE => Self::BottomTee,
763            ffi::GDK_BOX_SPIRAL => Self::BoxSpiral,
764            ffi::GDK_CENTER_PTR => Self::CenterPtr,
765            ffi::GDK_CIRCLE => Self::Circle,
766            ffi::GDK_CLOCK => Self::Clock,
767            ffi::GDK_COFFEE_MUG => Self::CoffeeMug,
768            ffi::GDK_CROSS => Self::Cross,
769            ffi::GDK_CROSS_REVERSE => Self::CrossReverse,
770            ffi::GDK_CROSSHAIR => Self::Crosshair,
771            ffi::GDK_DIAMOND_CROSS => Self::DiamondCross,
772            ffi::GDK_DOT => Self::Dot,
773            ffi::GDK_DOTBOX => Self::Dotbox,
774            ffi::GDK_DOUBLE_ARROW => Self::DoubleArrow,
775            ffi::GDK_DRAFT_LARGE => Self::DraftLarge,
776            ffi::GDK_DRAFT_SMALL => Self::DraftSmall,
777            ffi::GDK_DRAPED_BOX => Self::DrapedBox,
778            ffi::GDK_EXCHANGE => Self::Exchange,
779            ffi::GDK_FLEUR => Self::Fleur,
780            ffi::GDK_GOBBLER => Self::Gobbler,
781            ffi::GDK_GUMBY => Self::Gumby,
782            ffi::GDK_HAND1 => Self::Hand1,
783            ffi::GDK_HAND2 => Self::Hand2,
784            ffi::GDK_HEART => Self::Heart,
785            ffi::GDK_ICON => Self::Icon,
786            ffi::GDK_IRON_CROSS => Self::IronCross,
787            ffi::GDK_LEFT_PTR => Self::LeftPtr,
788            ffi::GDK_LEFT_SIDE => Self::LeftSide,
789            ffi::GDK_LEFT_TEE => Self::LeftTee,
790            ffi::GDK_LEFTBUTTON => Self::Leftbutton,
791            ffi::GDK_LL_ANGLE => Self::LlAngle,
792            ffi::GDK_LR_ANGLE => Self::LrAngle,
793            ffi::GDK_MAN => Self::Man,
794            ffi::GDK_MIDDLEBUTTON => Self::Middlebutton,
795            ffi::GDK_MOUSE => Self::Mouse,
796            ffi::GDK_PENCIL => Self::Pencil,
797            ffi::GDK_PIRATE => Self::Pirate,
798            ffi::GDK_PLUS => Self::Plus,
799            ffi::GDK_QUESTION_ARROW => Self::QuestionArrow,
800            ffi::GDK_RIGHT_PTR => Self::RightPtr,
801            ffi::GDK_RIGHT_SIDE => Self::RightSide,
802            ffi::GDK_RIGHT_TEE => Self::RightTee,
803            ffi::GDK_RIGHTBUTTON => Self::Rightbutton,
804            ffi::GDK_RTL_LOGO => Self::RtlLogo,
805            ffi::GDK_SAILBOAT => Self::Sailboat,
806            ffi::GDK_SB_DOWN_ARROW => Self::SbDownArrow,
807            ffi::GDK_SB_H_DOUBLE_ARROW => Self::SbHDoubleArrow,
808            ffi::GDK_SB_LEFT_ARROW => Self::SbLeftArrow,
809            ffi::GDK_SB_RIGHT_ARROW => Self::SbRightArrow,
810            ffi::GDK_SB_UP_ARROW => Self::SbUpArrow,
811            ffi::GDK_SB_V_DOUBLE_ARROW => Self::SbVDoubleArrow,
812            ffi::GDK_SHUTTLE => Self::Shuttle,
813            ffi::GDK_SIZING => Self::Sizing,
814            ffi::GDK_SPIDER => Self::Spider,
815            ffi::GDK_SPRAYCAN => Self::Spraycan,
816            ffi::GDK_STAR => Self::Star,
817            ffi::GDK_TARGET => Self::Target,
818            ffi::GDK_TCROSS => Self::Tcross,
819            ffi::GDK_TOP_LEFT_ARROW => Self::TopLeftArrow,
820            ffi::GDK_TOP_LEFT_CORNER => Self::TopLeftCorner,
821            ffi::GDK_TOP_RIGHT_CORNER => Self::TopRightCorner,
822            ffi::GDK_TOP_SIDE => Self::TopSide,
823            ffi::GDK_TOP_TEE => Self::TopTee,
824            ffi::GDK_TREK => Self::Trek,
825            ffi::GDK_UL_ANGLE => Self::UlAngle,
826            ffi::GDK_UMBRELLA => Self::Umbrella,
827            ffi::GDK_UR_ANGLE => Self::UrAngle,
828            ffi::GDK_WATCH => Self::Watch,
829            ffi::GDK_XTERM => Self::Xterm,
830            ffi::GDK_LAST_CURSOR => Self::LastCursor,
831            ffi::GDK_BLANK_CURSOR => Self::BlankCursor,
832            ffi::GDK_CURSOR_IS_PIXMAP => Self::CursorIsPixmap,
833            value => Self::__Unknown(value),
834        }
835    }
836}
837
838impl StaticType for CursorType {
839    #[inline]
840    #[doc(alias = "gdk_cursor_type_get_type")]
841    fn static_type() -> glib::Type {
842        unsafe { from_glib(ffi::gdk_cursor_type_get_type()) }
843    }
844}
845
846impl glib::HasParamSpec for CursorType {
847    type ParamSpec = glib::ParamSpecEnum;
848    type SetValue = Self;
849    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
850
851    fn param_spec_builder() -> Self::BuilderFn {
852        Self::ParamSpec::builder_with_default
853    }
854}
855
856impl glib::value::ValueType for CursorType {
857    type Type = Self;
858}
859
860unsafe impl<'a> glib::value::FromValue<'a> for CursorType {
861    type Checker = glib::value::GenericValueTypeChecker<Self>;
862
863    #[inline]
864    unsafe fn from_value(value: &'a glib::Value) -> Self {
865        skip_assert_initialized!();
866        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
867    }
868}
869
870impl ToValue for CursorType {
871    #[inline]
872    fn to_value(&self) -> glib::Value {
873        let mut value = glib::Value::for_value_type::<Self>();
874        unsafe {
875            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
876        }
877        value
878    }
879
880    #[inline]
881    fn value_type(&self) -> glib::Type {
882        Self::static_type()
883    }
884}
885
886impl From<CursorType> for glib::Value {
887    #[inline]
888    fn from(v: CursorType) -> Self {
889        skip_assert_initialized!();
890        ToValue::to_value(&v)
891    }
892}
893
894/// A pad feature.
895#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
896#[non_exhaustive]
897#[doc(alias = "GdkDevicePadFeature")]
898pub enum DevicePadFeature {
899    /// a button
900    #[doc(alias = "GDK_DEVICE_PAD_FEATURE_BUTTON")]
901    Button,
902    /// a ring-shaped interactive area
903    #[doc(alias = "GDK_DEVICE_PAD_FEATURE_RING")]
904    Ring,
905    /// a straight interactive area
906    #[doc(alias = "GDK_DEVICE_PAD_FEATURE_STRIP")]
907    Strip,
908    #[doc(hidden)]
909    __Unknown(i32),
910}
911
912#[doc(hidden)]
913impl IntoGlib for DevicePadFeature {
914    type GlibType = ffi::GdkDevicePadFeature;
915
916    #[inline]
917    fn into_glib(self) -> ffi::GdkDevicePadFeature {
918        match self {
919            Self::Button => ffi::GDK_DEVICE_PAD_FEATURE_BUTTON,
920            Self::Ring => ffi::GDK_DEVICE_PAD_FEATURE_RING,
921            Self::Strip => ffi::GDK_DEVICE_PAD_FEATURE_STRIP,
922            Self::__Unknown(value) => value,
923        }
924    }
925}
926
927#[doc(hidden)]
928impl FromGlib<ffi::GdkDevicePadFeature> for DevicePadFeature {
929    #[inline]
930    unsafe fn from_glib(value: ffi::GdkDevicePadFeature) -> Self {
931        skip_assert_initialized!();
932
933        match value {
934            ffi::GDK_DEVICE_PAD_FEATURE_BUTTON => Self::Button,
935            ffi::GDK_DEVICE_PAD_FEATURE_RING => Self::Ring,
936            ffi::GDK_DEVICE_PAD_FEATURE_STRIP => Self::Strip,
937            value => Self::__Unknown(value),
938        }
939    }
940}
941
942impl StaticType for DevicePadFeature {
943    #[inline]
944    #[doc(alias = "gdk_device_pad_feature_get_type")]
945    fn static_type() -> glib::Type {
946        unsafe { from_glib(ffi::gdk_device_pad_feature_get_type()) }
947    }
948}
949
950impl glib::HasParamSpec for DevicePadFeature {
951    type ParamSpec = glib::ParamSpecEnum;
952    type SetValue = Self;
953    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
954
955    fn param_spec_builder() -> Self::BuilderFn {
956        Self::ParamSpec::builder_with_default
957    }
958}
959
960impl glib::value::ValueType for DevicePadFeature {
961    type Type = Self;
962}
963
964unsafe impl<'a> glib::value::FromValue<'a> for DevicePadFeature {
965    type Checker = glib::value::GenericValueTypeChecker<Self>;
966
967    #[inline]
968    unsafe fn from_value(value: &'a glib::Value) -> Self {
969        skip_assert_initialized!();
970        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
971    }
972}
973
974impl ToValue for DevicePadFeature {
975    #[inline]
976    fn to_value(&self) -> glib::Value {
977        let mut value = glib::Value::for_value_type::<Self>();
978        unsafe {
979            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
980        }
981        value
982    }
983
984    #[inline]
985    fn value_type(&self) -> glib::Type {
986        Self::static_type()
987    }
988}
989
990impl From<DevicePadFeature> for glib::Value {
991    #[inline]
992    fn from(v: DevicePadFeature) -> Self {
993        skip_assert_initialized!();
994        ToValue::to_value(&v)
995    }
996}
997
998/// Indicates the specific type of tool being used being a tablet. Such as an
999/// airbrush, pencil, etc.
1000#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1001#[non_exhaustive]
1002#[doc(alias = "GdkDeviceToolType")]
1003pub enum DeviceToolType {
1004    /// Tool is of an unknown type.
1005    #[doc(alias = "GDK_DEVICE_TOOL_TYPE_UNKNOWN")]
1006    Unknown,
1007    /// Tool is a standard tablet stylus.
1008    #[doc(alias = "GDK_DEVICE_TOOL_TYPE_PEN")]
1009    Pen,
1010    /// Tool is standard tablet eraser.
1011    #[doc(alias = "GDK_DEVICE_TOOL_TYPE_ERASER")]
1012    Eraser,
1013    /// Tool is a brush stylus.
1014    #[doc(alias = "GDK_DEVICE_TOOL_TYPE_BRUSH")]
1015    Brush,
1016    /// Tool is a pencil stylus.
1017    #[doc(alias = "GDK_DEVICE_TOOL_TYPE_PENCIL")]
1018    Pencil,
1019    /// Tool is an airbrush stylus.
1020    #[doc(alias = "GDK_DEVICE_TOOL_TYPE_AIRBRUSH")]
1021    Airbrush,
1022    /// Tool is a mouse.
1023    #[doc(alias = "GDK_DEVICE_TOOL_TYPE_MOUSE")]
1024    Mouse,
1025    /// Tool is a lens cursor.
1026    #[doc(alias = "GDK_DEVICE_TOOL_TYPE_LENS")]
1027    Lens,
1028    #[doc(hidden)]
1029    __Unknown(i32),
1030}
1031
1032#[doc(hidden)]
1033impl IntoGlib for DeviceToolType {
1034    type GlibType = ffi::GdkDeviceToolType;
1035
1036    #[inline]
1037    fn into_glib(self) -> ffi::GdkDeviceToolType {
1038        match self {
1039            Self::Unknown => ffi::GDK_DEVICE_TOOL_TYPE_UNKNOWN,
1040            Self::Pen => ffi::GDK_DEVICE_TOOL_TYPE_PEN,
1041            Self::Eraser => ffi::GDK_DEVICE_TOOL_TYPE_ERASER,
1042            Self::Brush => ffi::GDK_DEVICE_TOOL_TYPE_BRUSH,
1043            Self::Pencil => ffi::GDK_DEVICE_TOOL_TYPE_PENCIL,
1044            Self::Airbrush => ffi::GDK_DEVICE_TOOL_TYPE_AIRBRUSH,
1045            Self::Mouse => ffi::GDK_DEVICE_TOOL_TYPE_MOUSE,
1046            Self::Lens => ffi::GDK_DEVICE_TOOL_TYPE_LENS,
1047            Self::__Unknown(value) => value,
1048        }
1049    }
1050}
1051
1052#[doc(hidden)]
1053impl FromGlib<ffi::GdkDeviceToolType> for DeviceToolType {
1054    #[inline]
1055    unsafe fn from_glib(value: ffi::GdkDeviceToolType) -> Self {
1056        skip_assert_initialized!();
1057
1058        match value {
1059            ffi::GDK_DEVICE_TOOL_TYPE_UNKNOWN => Self::Unknown,
1060            ffi::GDK_DEVICE_TOOL_TYPE_PEN => Self::Pen,
1061            ffi::GDK_DEVICE_TOOL_TYPE_ERASER => Self::Eraser,
1062            ffi::GDK_DEVICE_TOOL_TYPE_BRUSH => Self::Brush,
1063            ffi::GDK_DEVICE_TOOL_TYPE_PENCIL => Self::Pencil,
1064            ffi::GDK_DEVICE_TOOL_TYPE_AIRBRUSH => Self::Airbrush,
1065            ffi::GDK_DEVICE_TOOL_TYPE_MOUSE => Self::Mouse,
1066            ffi::GDK_DEVICE_TOOL_TYPE_LENS => Self::Lens,
1067            value => Self::__Unknown(value),
1068        }
1069    }
1070}
1071
1072impl StaticType for DeviceToolType {
1073    #[inline]
1074    #[doc(alias = "gdk_device_tool_type_get_type")]
1075    fn static_type() -> glib::Type {
1076        unsafe { from_glib(ffi::gdk_device_tool_type_get_type()) }
1077    }
1078}
1079
1080impl glib::HasParamSpec for DeviceToolType {
1081    type ParamSpec = glib::ParamSpecEnum;
1082    type SetValue = Self;
1083    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1084
1085    fn param_spec_builder() -> Self::BuilderFn {
1086        Self::ParamSpec::builder_with_default
1087    }
1088}
1089
1090impl glib::value::ValueType for DeviceToolType {
1091    type Type = Self;
1092}
1093
1094unsafe impl<'a> glib::value::FromValue<'a> for DeviceToolType {
1095    type Checker = glib::value::GenericValueTypeChecker<Self>;
1096
1097    #[inline]
1098    unsafe fn from_value(value: &'a glib::Value) -> Self {
1099        skip_assert_initialized!();
1100        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
1101    }
1102}
1103
1104impl ToValue for DeviceToolType {
1105    #[inline]
1106    fn to_value(&self) -> glib::Value {
1107        let mut value = glib::Value::for_value_type::<Self>();
1108        unsafe {
1109            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1110        }
1111        value
1112    }
1113
1114    #[inline]
1115    fn value_type(&self) -> glib::Type {
1116        Self::static_type()
1117    }
1118}
1119
1120impl From<DeviceToolType> for glib::Value {
1121    #[inline]
1122    fn from(v: DeviceToolType) -> Self {
1123        skip_assert_initialized!();
1124        ToValue::to_value(&v)
1125    }
1126}
1127
1128/// Indicates the device type. See [above][GdkDeviceManager.description]
1129/// for more information about the meaning of these device types.
1130#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1131#[non_exhaustive]
1132#[doc(alias = "GdkDeviceType")]
1133pub enum DeviceType {
1134    /// Device is a master (or virtual) device. There will
1135    ///  be an associated focus indicator on the screen.
1136    #[doc(alias = "GDK_DEVICE_TYPE_MASTER")]
1137    Master,
1138    /// Device is a slave (or physical) device.
1139    #[doc(alias = "GDK_DEVICE_TYPE_SLAVE")]
1140    Slave,
1141    /// Device is a physical device, currently not attached to
1142    ///  any virtual device.
1143    #[doc(alias = "GDK_DEVICE_TYPE_FLOATING")]
1144    Floating,
1145    #[doc(hidden)]
1146    __Unknown(i32),
1147}
1148
1149#[doc(hidden)]
1150impl IntoGlib for DeviceType {
1151    type GlibType = ffi::GdkDeviceType;
1152
1153    #[inline]
1154    fn into_glib(self) -> ffi::GdkDeviceType {
1155        match self {
1156            Self::Master => ffi::GDK_DEVICE_TYPE_MASTER,
1157            Self::Slave => ffi::GDK_DEVICE_TYPE_SLAVE,
1158            Self::Floating => ffi::GDK_DEVICE_TYPE_FLOATING,
1159            Self::__Unknown(value) => value,
1160        }
1161    }
1162}
1163
1164#[doc(hidden)]
1165impl FromGlib<ffi::GdkDeviceType> for DeviceType {
1166    #[inline]
1167    unsafe fn from_glib(value: ffi::GdkDeviceType) -> Self {
1168        skip_assert_initialized!();
1169
1170        match value {
1171            ffi::GDK_DEVICE_TYPE_MASTER => Self::Master,
1172            ffi::GDK_DEVICE_TYPE_SLAVE => Self::Slave,
1173            ffi::GDK_DEVICE_TYPE_FLOATING => Self::Floating,
1174            value => Self::__Unknown(value),
1175        }
1176    }
1177}
1178
1179impl StaticType for DeviceType {
1180    #[inline]
1181    #[doc(alias = "gdk_device_type_get_type")]
1182    fn static_type() -> glib::Type {
1183        unsafe { from_glib(ffi::gdk_device_type_get_type()) }
1184    }
1185}
1186
1187impl glib::HasParamSpec for DeviceType {
1188    type ParamSpec = glib::ParamSpecEnum;
1189    type SetValue = Self;
1190    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1191
1192    fn param_spec_builder() -> Self::BuilderFn {
1193        Self::ParamSpec::builder_with_default
1194    }
1195}
1196
1197impl glib::value::ValueType for DeviceType {
1198    type Type = Self;
1199}
1200
1201unsafe impl<'a> glib::value::FromValue<'a> for DeviceType {
1202    type Checker = glib::value::GenericValueTypeChecker<Self>;
1203
1204    #[inline]
1205    unsafe fn from_value(value: &'a glib::Value) -> Self {
1206        skip_assert_initialized!();
1207        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
1208    }
1209}
1210
1211impl ToValue for DeviceType {
1212    #[inline]
1213    fn to_value(&self) -> glib::Value {
1214        let mut value = glib::Value::for_value_type::<Self>();
1215        unsafe {
1216            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1217        }
1218        value
1219    }
1220
1221    #[inline]
1222    fn value_type(&self) -> glib::Type {
1223        Self::static_type()
1224    }
1225}
1226
1227impl From<DeviceType> for glib::Value {
1228    #[inline]
1229    fn from(v: DeviceType) -> Self {
1230        skip_assert_initialized!();
1231        ToValue::to_value(&v)
1232    }
1233}
1234
1235/// Used in [`DragContext`][crate::DragContext] to the reason of a cancelled DND operation.
1236#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1237#[non_exhaustive]
1238#[doc(alias = "GdkDragCancelReason")]
1239pub enum DragCancelReason {
1240    /// There is no suitable drop target.
1241    #[doc(alias = "GDK_DRAG_CANCEL_NO_TARGET")]
1242    NoTarget,
1243    /// Drag cancelled by the user
1244    #[doc(alias = "GDK_DRAG_CANCEL_USER_CANCELLED")]
1245    UserCancelled,
1246    /// Unspecified error.
1247    #[doc(alias = "GDK_DRAG_CANCEL_ERROR")]
1248    Error,
1249    #[doc(hidden)]
1250    __Unknown(i32),
1251}
1252
1253#[doc(hidden)]
1254impl IntoGlib for DragCancelReason {
1255    type GlibType = ffi::GdkDragCancelReason;
1256
1257    #[inline]
1258    fn into_glib(self) -> ffi::GdkDragCancelReason {
1259        match self {
1260            Self::NoTarget => ffi::GDK_DRAG_CANCEL_NO_TARGET,
1261            Self::UserCancelled => ffi::GDK_DRAG_CANCEL_USER_CANCELLED,
1262            Self::Error => ffi::GDK_DRAG_CANCEL_ERROR,
1263            Self::__Unknown(value) => value,
1264        }
1265    }
1266}
1267
1268#[doc(hidden)]
1269impl FromGlib<ffi::GdkDragCancelReason> for DragCancelReason {
1270    #[inline]
1271    unsafe fn from_glib(value: ffi::GdkDragCancelReason) -> Self {
1272        skip_assert_initialized!();
1273
1274        match value {
1275            ffi::GDK_DRAG_CANCEL_NO_TARGET => Self::NoTarget,
1276            ffi::GDK_DRAG_CANCEL_USER_CANCELLED => Self::UserCancelled,
1277            ffi::GDK_DRAG_CANCEL_ERROR => Self::Error,
1278            value => Self::__Unknown(value),
1279        }
1280    }
1281}
1282
1283impl StaticType for DragCancelReason {
1284    #[inline]
1285    #[doc(alias = "gdk_drag_cancel_reason_get_type")]
1286    fn static_type() -> glib::Type {
1287        unsafe { from_glib(ffi::gdk_drag_cancel_reason_get_type()) }
1288    }
1289}
1290
1291impl glib::HasParamSpec for DragCancelReason {
1292    type ParamSpec = glib::ParamSpecEnum;
1293    type SetValue = Self;
1294    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1295
1296    fn param_spec_builder() -> Self::BuilderFn {
1297        Self::ParamSpec::builder_with_default
1298    }
1299}
1300
1301impl glib::value::ValueType for DragCancelReason {
1302    type Type = Self;
1303}
1304
1305unsafe impl<'a> glib::value::FromValue<'a> for DragCancelReason {
1306    type Checker = glib::value::GenericValueTypeChecker<Self>;
1307
1308    #[inline]
1309    unsafe fn from_value(value: &'a glib::Value) -> Self {
1310        skip_assert_initialized!();
1311        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
1312    }
1313}
1314
1315impl ToValue for DragCancelReason {
1316    #[inline]
1317    fn to_value(&self) -> glib::Value {
1318        let mut value = glib::Value::for_value_type::<Self>();
1319        unsafe {
1320            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1321        }
1322        value
1323    }
1324
1325    #[inline]
1326    fn value_type(&self) -> glib::Type {
1327        Self::static_type()
1328    }
1329}
1330
1331impl From<DragCancelReason> for glib::Value {
1332    #[inline]
1333    fn from(v: DragCancelReason) -> Self {
1334        skip_assert_initialized!();
1335        ToValue::to_value(&v)
1336    }
1337}
1338
1339/// Used in [`DragContext`][crate::DragContext] to indicate the protocol according to
1340/// which DND is done.
1341#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1342#[non_exhaustive]
1343#[doc(alias = "GdkDragProtocol")]
1344pub enum DragProtocol {
1345    /// no protocol.
1346    #[doc(alias = "GDK_DRAG_PROTO_NONE")]
1347    None,
1348    /// The Motif DND protocol. No longer supported
1349    #[doc(alias = "GDK_DRAG_PROTO_MOTIF")]
1350    Motif,
1351    /// The Xdnd protocol.
1352    #[doc(alias = "GDK_DRAG_PROTO_XDND")]
1353    Xdnd,
1354    /// An extension to the Xdnd protocol for
1355    ///  unclaimed root window drops.
1356    #[doc(alias = "GDK_DRAG_PROTO_ROOTWIN")]
1357    Rootwin,
1358    /// The simple WM_DROPFILES protocol.
1359    #[doc(alias = "GDK_DRAG_PROTO_WIN32_DROPFILES")]
1360    Win32Dropfiles,
1361    /// The complex OLE2 DND protocol (not implemented).
1362    #[doc(alias = "GDK_DRAG_PROTO_OLE2")]
1363    Ole2,
1364    /// Intra-application DND.
1365    #[doc(alias = "GDK_DRAG_PROTO_LOCAL")]
1366    Local,
1367    /// Wayland DND protocol.
1368    #[doc(alias = "GDK_DRAG_PROTO_WAYLAND")]
1369    Wayland,
1370    #[doc(hidden)]
1371    __Unknown(i32),
1372}
1373
1374#[doc(hidden)]
1375impl IntoGlib for DragProtocol {
1376    type GlibType = ffi::GdkDragProtocol;
1377
1378    #[inline]
1379    fn into_glib(self) -> ffi::GdkDragProtocol {
1380        match self {
1381            Self::None => ffi::GDK_DRAG_PROTO_NONE,
1382            Self::Motif => ffi::GDK_DRAG_PROTO_MOTIF,
1383            Self::Xdnd => ffi::GDK_DRAG_PROTO_XDND,
1384            Self::Rootwin => ffi::GDK_DRAG_PROTO_ROOTWIN,
1385            Self::Win32Dropfiles => ffi::GDK_DRAG_PROTO_WIN32_DROPFILES,
1386            Self::Ole2 => ffi::GDK_DRAG_PROTO_OLE2,
1387            Self::Local => ffi::GDK_DRAG_PROTO_LOCAL,
1388            Self::Wayland => ffi::GDK_DRAG_PROTO_WAYLAND,
1389            Self::__Unknown(value) => value,
1390        }
1391    }
1392}
1393
1394#[doc(hidden)]
1395impl FromGlib<ffi::GdkDragProtocol> for DragProtocol {
1396    #[inline]
1397    unsafe fn from_glib(value: ffi::GdkDragProtocol) -> Self {
1398        skip_assert_initialized!();
1399
1400        match value {
1401            ffi::GDK_DRAG_PROTO_NONE => Self::None,
1402            ffi::GDK_DRAG_PROTO_MOTIF => Self::Motif,
1403            ffi::GDK_DRAG_PROTO_XDND => Self::Xdnd,
1404            ffi::GDK_DRAG_PROTO_ROOTWIN => Self::Rootwin,
1405            ffi::GDK_DRAG_PROTO_WIN32_DROPFILES => Self::Win32Dropfiles,
1406            ffi::GDK_DRAG_PROTO_OLE2 => Self::Ole2,
1407            ffi::GDK_DRAG_PROTO_LOCAL => Self::Local,
1408            ffi::GDK_DRAG_PROTO_WAYLAND => Self::Wayland,
1409            value => Self::__Unknown(value),
1410        }
1411    }
1412}
1413
1414impl StaticType for DragProtocol {
1415    #[inline]
1416    #[doc(alias = "gdk_drag_protocol_get_type")]
1417    fn static_type() -> glib::Type {
1418        unsafe { from_glib(ffi::gdk_drag_protocol_get_type()) }
1419    }
1420}
1421
1422impl glib::HasParamSpec for DragProtocol {
1423    type ParamSpec = glib::ParamSpecEnum;
1424    type SetValue = Self;
1425    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1426
1427    fn param_spec_builder() -> Self::BuilderFn {
1428        Self::ParamSpec::builder_with_default
1429    }
1430}
1431
1432impl glib::value::ValueType for DragProtocol {
1433    type Type = Self;
1434}
1435
1436unsafe impl<'a> glib::value::FromValue<'a> for DragProtocol {
1437    type Checker = glib::value::GenericValueTypeChecker<Self>;
1438
1439    #[inline]
1440    unsafe fn from_value(value: &'a glib::Value) -> Self {
1441        skip_assert_initialized!();
1442        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
1443    }
1444}
1445
1446impl ToValue for DragProtocol {
1447    #[inline]
1448    fn to_value(&self) -> glib::Value {
1449        let mut value = glib::Value::for_value_type::<Self>();
1450        unsafe {
1451            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1452        }
1453        value
1454    }
1455
1456    #[inline]
1457    fn value_type(&self) -> glib::Type {
1458        Self::static_type()
1459    }
1460}
1461
1462impl From<DragProtocol> for glib::Value {
1463    #[inline]
1464    fn from(v: DragProtocol) -> Self {
1465        skip_assert_initialized!();
1466        ToValue::to_value(&v)
1467    }
1468}
1469
1470/// Specifies the type of the event.
1471///
1472/// Do not confuse these events with the signals that GTK+ widgets emit.
1473/// Although many of these events result in corresponding signals being emitted,
1474/// the events are often transformed or filtered along the way.
1475///
1476/// In some language bindings, the values `GDK_2BUTTON_PRESS` and
1477/// `GDK_3BUTTON_PRESS` would translate into something syntactically
1478/// invalid (eg `Gdk.EventType.2ButtonPress`, where a
1479/// symbol is not allowed to start with a number). In that case, the
1480/// aliases [`DoubleButtonPress`][Self::DoubleButtonPress] and [`TripleButtonPress`][Self::TripleButtonPress] can
1481/// be used instead.
1482#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1483#[non_exhaustive]
1484#[doc(alias = "GdkEventType")]
1485pub enum EventType {
1486    /// a special code to indicate a null event.
1487    #[doc(alias = "GDK_NOTHING")]
1488    Nothing,
1489    /// the window manager has requested that the toplevel window be
1490    ///  hidden or destroyed, usually when the user clicks on a special icon in the
1491    ///  title bar.
1492    #[doc(alias = "GDK_DELETE")]
1493    Delete,
1494    /// the window has been destroyed.
1495    #[doc(alias = "GDK_DESTROY")]
1496    Destroy,
1497    /// all or part of the window has become visible and needs to be
1498    ///  redrawn.
1499    #[doc(alias = "GDK_EXPOSE")]
1500    Expose,
1501    /// the pointer (usually a mouse) has moved.
1502    #[doc(alias = "GDK_MOTION_NOTIFY")]
1503    MotionNotify,
1504    /// a mouse button has been pressed.
1505    #[doc(alias = "GDK_BUTTON_PRESS")]
1506    ButtonPress,
1507    /// alias for `GDK_2BUTTON_PRESS`, added in 3.6.
1508    #[doc(alias = "GDK_DOUBLE_BUTTON_PRESS")]
1509    DoubleButtonPress,
1510    /// alias for `GDK_3BUTTON_PRESS`, added in 3.6.
1511    #[doc(alias = "GDK_TRIPLE_BUTTON_PRESS")]
1512    TripleButtonPress,
1513    /// a mouse button has been released.
1514    #[doc(alias = "GDK_BUTTON_RELEASE")]
1515    ButtonRelease,
1516    /// a key has been pressed.
1517    #[doc(alias = "GDK_KEY_PRESS")]
1518    KeyPress,
1519    /// a key has been released.
1520    #[doc(alias = "GDK_KEY_RELEASE")]
1521    KeyRelease,
1522    /// the pointer has entered the window.
1523    #[doc(alias = "GDK_ENTER_NOTIFY")]
1524    EnterNotify,
1525    /// the pointer has left the window.
1526    #[doc(alias = "GDK_LEAVE_NOTIFY")]
1527    LeaveNotify,
1528    /// the keyboard focus has entered or left the window.
1529    #[doc(alias = "GDK_FOCUS_CHANGE")]
1530    FocusChange,
1531    /// the size, position or stacking order of the window has changed.
1532    ///  Note that GTK+ discards these events for [`WindowType::Child`][crate::WindowType::Child] windows.
1533    #[doc(alias = "GDK_CONFIGURE")]
1534    Configure,
1535    /// the window has been mapped.
1536    #[doc(alias = "GDK_MAP")]
1537    Map,
1538    /// the window has been unmapped.
1539    #[doc(alias = "GDK_UNMAP")]
1540    Unmap,
1541    /// a property on the window has been changed or deleted.
1542    #[doc(alias = "GDK_PROPERTY_NOTIFY")]
1543    PropertyNotify,
1544    /// the application has lost ownership of a selection.
1545    #[doc(alias = "GDK_SELECTION_CLEAR")]
1546    SelectionClear,
1547    /// another application has requested a selection.
1548    #[doc(alias = "GDK_SELECTION_REQUEST")]
1549    SelectionRequest,
1550    /// a selection has been received.
1551    #[doc(alias = "GDK_SELECTION_NOTIFY")]
1552    SelectionNotify,
1553    /// an input device has moved into contact with a sensing
1554    ///  surface (e.g. a touchscreen or graphics tablet).
1555    #[doc(alias = "GDK_PROXIMITY_IN")]
1556    ProximityIn,
1557    /// an input device has moved out of contact with a sensing
1558    ///  surface.
1559    #[doc(alias = "GDK_PROXIMITY_OUT")]
1560    ProximityOut,
1561    /// the mouse has entered the window while a drag is in progress.
1562    #[doc(alias = "GDK_DRAG_ENTER")]
1563    DragEnter,
1564    /// the mouse has left the window while a drag is in progress.
1565    #[doc(alias = "GDK_DRAG_LEAVE")]
1566    DragLeave,
1567    /// the mouse has moved in the window while a drag is in
1568    ///  progress.
1569    #[doc(alias = "GDK_DRAG_MOTION")]
1570    DragMotion,
1571    /// the status of the drag operation initiated by the window
1572    ///  has changed.
1573    #[doc(alias = "GDK_DRAG_STATUS")]
1574    DragStatus,
1575    /// a drop operation onto the window has started.
1576    #[doc(alias = "GDK_DROP_START")]
1577    DropStart,
1578    /// the drop operation initiated by the window has completed.
1579    #[doc(alias = "GDK_DROP_FINISHED")]
1580    DropFinished,
1581    /// a message has been received from another application.
1582    #[doc(alias = "GDK_CLIENT_EVENT")]
1583    ClientEvent,
1584    /// the window visibility status has changed.
1585    #[doc(alias = "GDK_VISIBILITY_NOTIFY")]
1586    VisibilityNotify,
1587    /// the scroll wheel was turned
1588    #[doc(alias = "GDK_SCROLL")]
1589    Scroll,
1590    /// the state of a window has changed. See [`WindowState`][crate::WindowState]
1591    ///  for the possible window states
1592    #[doc(alias = "GDK_WINDOW_STATE")]
1593    WindowState,
1594    /// a setting has been modified.
1595    #[doc(alias = "GDK_SETTING")]
1596    Setting,
1597    /// the owner of a selection has changed. This event type
1598    ///  was added in 2.6
1599    #[doc(alias = "GDK_OWNER_CHANGE")]
1600    OwnerChange,
1601    /// a pointer or keyboard grab was broken. This event type
1602    ///  was added in 2.8.
1603    #[doc(alias = "GDK_GRAB_BROKEN")]
1604    GrabBroken,
1605    /// the content of the window has been changed. This event type
1606    ///  was added in 2.14.
1607    #[doc(alias = "GDK_DAMAGE")]
1608    Damage,
1609    /// A new touch event sequence has just started. This event
1610    ///  type was added in 3.4.
1611    #[doc(alias = "GDK_TOUCH_BEGIN")]
1612    TouchBegin,
1613    /// A touch event sequence has been updated. This event type
1614    ///  was added in 3.4.
1615    #[doc(alias = "GDK_TOUCH_UPDATE")]
1616    TouchUpdate,
1617    /// A touch event sequence has finished. This event type
1618    ///  was added in 3.4.
1619    #[doc(alias = "GDK_TOUCH_END")]
1620    TouchEnd,
1621    /// A touch event sequence has been canceled. This event type
1622    ///  was added in 3.4.
1623    #[doc(alias = "GDK_TOUCH_CANCEL")]
1624    TouchCancel,
1625    /// A touchpad swipe gesture event, the current state
1626    ///  is determined by its phase field. This event type was added in 3.18.
1627    #[doc(alias = "GDK_TOUCHPAD_SWIPE")]
1628    TouchpadSwipe,
1629    /// A touchpad pinch gesture event, the current state
1630    ///  is determined by its phase field. This event type was added in 3.18.
1631    #[doc(alias = "GDK_TOUCHPAD_PINCH")]
1632    TouchpadPinch,
1633    /// A tablet pad button press event. This event type
1634    ///  was added in 3.22.
1635    #[doc(alias = "GDK_PAD_BUTTON_PRESS")]
1636    PadButtonPress,
1637    /// A tablet pad button release event. This event type
1638    ///  was added in 3.22.
1639    #[doc(alias = "GDK_PAD_BUTTON_RELEASE")]
1640    PadButtonRelease,
1641    /// A tablet pad axis event from a "ring". This event type was
1642    ///  added in 3.22.
1643    #[doc(alias = "GDK_PAD_RING")]
1644    PadRing,
1645    /// A tablet pad axis event from a "strip". This event type was
1646    ///  added in 3.22.
1647    #[doc(alias = "GDK_PAD_STRIP")]
1648    PadStrip,
1649    /// A tablet pad group mode change. This event type was
1650    ///  added in 3.22.
1651    #[doc(alias = "GDK_PAD_GROUP_MODE")]
1652    PadGroupMode,
1653    #[doc(hidden)]
1654    __Unknown(i32),
1655}
1656
1657#[doc(hidden)]
1658impl IntoGlib for EventType {
1659    type GlibType = ffi::GdkEventType;
1660
1661    fn into_glib(self) -> ffi::GdkEventType {
1662        match self {
1663            Self::Nothing => ffi::GDK_NOTHING,
1664            Self::Delete => ffi::GDK_DELETE,
1665            Self::Destroy => ffi::GDK_DESTROY,
1666            Self::Expose => ffi::GDK_EXPOSE,
1667            Self::MotionNotify => ffi::GDK_MOTION_NOTIFY,
1668            Self::ButtonPress => ffi::GDK_BUTTON_PRESS,
1669            Self::DoubleButtonPress => ffi::GDK_DOUBLE_BUTTON_PRESS,
1670            Self::TripleButtonPress => ffi::GDK_TRIPLE_BUTTON_PRESS,
1671            Self::ButtonRelease => ffi::GDK_BUTTON_RELEASE,
1672            Self::KeyPress => ffi::GDK_KEY_PRESS,
1673            Self::KeyRelease => ffi::GDK_KEY_RELEASE,
1674            Self::EnterNotify => ffi::GDK_ENTER_NOTIFY,
1675            Self::LeaveNotify => ffi::GDK_LEAVE_NOTIFY,
1676            Self::FocusChange => ffi::GDK_FOCUS_CHANGE,
1677            Self::Configure => ffi::GDK_CONFIGURE,
1678            Self::Map => ffi::GDK_MAP,
1679            Self::Unmap => ffi::GDK_UNMAP,
1680            Self::PropertyNotify => ffi::GDK_PROPERTY_NOTIFY,
1681            Self::SelectionClear => ffi::GDK_SELECTION_CLEAR,
1682            Self::SelectionRequest => ffi::GDK_SELECTION_REQUEST,
1683            Self::SelectionNotify => ffi::GDK_SELECTION_NOTIFY,
1684            Self::ProximityIn => ffi::GDK_PROXIMITY_IN,
1685            Self::ProximityOut => ffi::GDK_PROXIMITY_OUT,
1686            Self::DragEnter => ffi::GDK_DRAG_ENTER,
1687            Self::DragLeave => ffi::GDK_DRAG_LEAVE,
1688            Self::DragMotion => ffi::GDK_DRAG_MOTION,
1689            Self::DragStatus => ffi::GDK_DRAG_STATUS,
1690            Self::DropStart => ffi::GDK_DROP_START,
1691            Self::DropFinished => ffi::GDK_DROP_FINISHED,
1692            Self::ClientEvent => ffi::GDK_CLIENT_EVENT,
1693            Self::VisibilityNotify => ffi::GDK_VISIBILITY_NOTIFY,
1694            Self::Scroll => ffi::GDK_SCROLL,
1695            Self::WindowState => ffi::GDK_WINDOW_STATE,
1696            Self::Setting => ffi::GDK_SETTING,
1697            Self::OwnerChange => ffi::GDK_OWNER_CHANGE,
1698            Self::GrabBroken => ffi::GDK_GRAB_BROKEN,
1699            Self::Damage => ffi::GDK_DAMAGE,
1700            Self::TouchBegin => ffi::GDK_TOUCH_BEGIN,
1701            Self::TouchUpdate => ffi::GDK_TOUCH_UPDATE,
1702            Self::TouchEnd => ffi::GDK_TOUCH_END,
1703            Self::TouchCancel => ffi::GDK_TOUCH_CANCEL,
1704            Self::TouchpadSwipe => ffi::GDK_TOUCHPAD_SWIPE,
1705            Self::TouchpadPinch => ffi::GDK_TOUCHPAD_PINCH,
1706            Self::PadButtonPress => ffi::GDK_PAD_BUTTON_PRESS,
1707            Self::PadButtonRelease => ffi::GDK_PAD_BUTTON_RELEASE,
1708            Self::PadRing => ffi::GDK_PAD_RING,
1709            Self::PadStrip => ffi::GDK_PAD_STRIP,
1710            Self::PadGroupMode => ffi::GDK_PAD_GROUP_MODE,
1711            Self::__Unknown(value) => value,
1712        }
1713    }
1714}
1715
1716#[doc(hidden)]
1717impl FromGlib<ffi::GdkEventType> for EventType {
1718    unsafe fn from_glib(value: ffi::GdkEventType) -> Self {
1719        skip_assert_initialized!();
1720
1721        match value {
1722            ffi::GDK_NOTHING => Self::Nothing,
1723            ffi::GDK_DELETE => Self::Delete,
1724            ffi::GDK_DESTROY => Self::Destroy,
1725            ffi::GDK_EXPOSE => Self::Expose,
1726            ffi::GDK_MOTION_NOTIFY => Self::MotionNotify,
1727            ffi::GDK_BUTTON_PRESS => Self::ButtonPress,
1728            ffi::GDK_DOUBLE_BUTTON_PRESS => Self::DoubleButtonPress,
1729            ffi::GDK_TRIPLE_BUTTON_PRESS => Self::TripleButtonPress,
1730            ffi::GDK_BUTTON_RELEASE => Self::ButtonRelease,
1731            ffi::GDK_KEY_PRESS => Self::KeyPress,
1732            ffi::GDK_KEY_RELEASE => Self::KeyRelease,
1733            ffi::GDK_ENTER_NOTIFY => Self::EnterNotify,
1734            ffi::GDK_LEAVE_NOTIFY => Self::LeaveNotify,
1735            ffi::GDK_FOCUS_CHANGE => Self::FocusChange,
1736            ffi::GDK_CONFIGURE => Self::Configure,
1737            ffi::GDK_MAP => Self::Map,
1738            ffi::GDK_UNMAP => Self::Unmap,
1739            ffi::GDK_PROPERTY_NOTIFY => Self::PropertyNotify,
1740            ffi::GDK_SELECTION_CLEAR => Self::SelectionClear,
1741            ffi::GDK_SELECTION_REQUEST => Self::SelectionRequest,
1742            ffi::GDK_SELECTION_NOTIFY => Self::SelectionNotify,
1743            ffi::GDK_PROXIMITY_IN => Self::ProximityIn,
1744            ffi::GDK_PROXIMITY_OUT => Self::ProximityOut,
1745            ffi::GDK_DRAG_ENTER => Self::DragEnter,
1746            ffi::GDK_DRAG_LEAVE => Self::DragLeave,
1747            ffi::GDK_DRAG_MOTION => Self::DragMotion,
1748            ffi::GDK_DRAG_STATUS => Self::DragStatus,
1749            ffi::GDK_DROP_START => Self::DropStart,
1750            ffi::GDK_DROP_FINISHED => Self::DropFinished,
1751            ffi::GDK_CLIENT_EVENT => Self::ClientEvent,
1752            ffi::GDK_VISIBILITY_NOTIFY => Self::VisibilityNotify,
1753            ffi::GDK_SCROLL => Self::Scroll,
1754            ffi::GDK_WINDOW_STATE => Self::WindowState,
1755            ffi::GDK_SETTING => Self::Setting,
1756            ffi::GDK_OWNER_CHANGE => Self::OwnerChange,
1757            ffi::GDK_GRAB_BROKEN => Self::GrabBroken,
1758            ffi::GDK_DAMAGE => Self::Damage,
1759            ffi::GDK_TOUCH_BEGIN => Self::TouchBegin,
1760            ffi::GDK_TOUCH_UPDATE => Self::TouchUpdate,
1761            ffi::GDK_TOUCH_END => Self::TouchEnd,
1762            ffi::GDK_TOUCH_CANCEL => Self::TouchCancel,
1763            ffi::GDK_TOUCHPAD_SWIPE => Self::TouchpadSwipe,
1764            ffi::GDK_TOUCHPAD_PINCH => Self::TouchpadPinch,
1765            ffi::GDK_PAD_BUTTON_PRESS => Self::PadButtonPress,
1766            ffi::GDK_PAD_BUTTON_RELEASE => Self::PadButtonRelease,
1767            ffi::GDK_PAD_RING => Self::PadRing,
1768            ffi::GDK_PAD_STRIP => Self::PadStrip,
1769            ffi::GDK_PAD_GROUP_MODE => Self::PadGroupMode,
1770            value => Self::__Unknown(value),
1771        }
1772    }
1773}
1774
1775impl StaticType for EventType {
1776    #[inline]
1777    #[doc(alias = "gdk_event_type_get_type")]
1778    fn static_type() -> glib::Type {
1779        unsafe { from_glib(ffi::gdk_event_type_get_type()) }
1780    }
1781}
1782
1783impl glib::HasParamSpec for EventType {
1784    type ParamSpec = glib::ParamSpecEnum;
1785    type SetValue = Self;
1786    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1787
1788    fn param_spec_builder() -> Self::BuilderFn {
1789        Self::ParamSpec::builder_with_default
1790    }
1791}
1792
1793impl glib::value::ValueType for EventType {
1794    type Type = Self;
1795}
1796
1797unsafe impl<'a> glib::value::FromValue<'a> for EventType {
1798    type Checker = glib::value::GenericValueTypeChecker<Self>;
1799
1800    #[inline]
1801    unsafe fn from_value(value: &'a glib::Value) -> Self {
1802        skip_assert_initialized!();
1803        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
1804    }
1805}
1806
1807impl ToValue for EventType {
1808    #[inline]
1809    fn to_value(&self) -> glib::Value {
1810        let mut value = glib::Value::for_value_type::<Self>();
1811        unsafe {
1812            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1813        }
1814        value
1815    }
1816
1817    #[inline]
1818    fn value_type(&self) -> glib::Type {
1819        Self::static_type()
1820    }
1821}
1822
1823impl From<EventType> for glib::Value {
1824    #[inline]
1825    fn from(v: EventType) -> Self {
1826        skip_assert_initialized!();
1827        ToValue::to_value(&v)
1828    }
1829}
1830
1831/// Indicates which monitor (in a multi-head setup) a window should span over
1832/// when in fullscreen mode.
1833#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1834#[non_exhaustive]
1835#[doc(alias = "GdkFullscreenMode")]
1836pub enum FullscreenMode {
1837    /// Fullscreen on current monitor only.
1838    #[doc(alias = "GDK_FULLSCREEN_ON_CURRENT_MONITOR")]
1839    CurrentMonitor,
1840    /// Span across all monitors when fullscreen.
1841    #[doc(alias = "GDK_FULLSCREEN_ON_ALL_MONITORS")]
1842    AllMonitors,
1843    #[doc(hidden)]
1844    __Unknown(i32),
1845}
1846
1847#[doc(hidden)]
1848impl IntoGlib for FullscreenMode {
1849    type GlibType = ffi::GdkFullscreenMode;
1850
1851    #[inline]
1852    fn into_glib(self) -> ffi::GdkFullscreenMode {
1853        match self {
1854            Self::CurrentMonitor => ffi::GDK_FULLSCREEN_ON_CURRENT_MONITOR,
1855            Self::AllMonitors => ffi::GDK_FULLSCREEN_ON_ALL_MONITORS,
1856            Self::__Unknown(value) => value,
1857        }
1858    }
1859}
1860
1861#[doc(hidden)]
1862impl FromGlib<ffi::GdkFullscreenMode> for FullscreenMode {
1863    #[inline]
1864    unsafe fn from_glib(value: ffi::GdkFullscreenMode) -> Self {
1865        skip_assert_initialized!();
1866
1867        match value {
1868            ffi::GDK_FULLSCREEN_ON_CURRENT_MONITOR => Self::CurrentMonitor,
1869            ffi::GDK_FULLSCREEN_ON_ALL_MONITORS => Self::AllMonitors,
1870            value => Self::__Unknown(value),
1871        }
1872    }
1873}
1874
1875impl StaticType for FullscreenMode {
1876    #[inline]
1877    #[doc(alias = "gdk_fullscreen_mode_get_type")]
1878    fn static_type() -> glib::Type {
1879        unsafe { from_glib(ffi::gdk_fullscreen_mode_get_type()) }
1880    }
1881}
1882
1883impl glib::HasParamSpec for FullscreenMode {
1884    type ParamSpec = glib::ParamSpecEnum;
1885    type SetValue = Self;
1886    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1887
1888    fn param_spec_builder() -> Self::BuilderFn {
1889        Self::ParamSpec::builder_with_default
1890    }
1891}
1892
1893impl glib::value::ValueType for FullscreenMode {
1894    type Type = Self;
1895}
1896
1897unsafe impl<'a> glib::value::FromValue<'a> for FullscreenMode {
1898    type Checker = glib::value::GenericValueTypeChecker<Self>;
1899
1900    #[inline]
1901    unsafe fn from_value(value: &'a glib::Value) -> Self {
1902        skip_assert_initialized!();
1903        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
1904    }
1905}
1906
1907impl ToValue for FullscreenMode {
1908    #[inline]
1909    fn to_value(&self) -> glib::Value {
1910        let mut value = glib::Value::for_value_type::<Self>();
1911        unsafe {
1912            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1913        }
1914        value
1915    }
1916
1917    #[inline]
1918    fn value_type(&self) -> glib::Type {
1919        Self::static_type()
1920    }
1921}
1922
1923impl From<FullscreenMode> for glib::Value {
1924    #[inline]
1925    fn from(v: FullscreenMode) -> Self {
1926        skip_assert_initialized!();
1927        ToValue::to_value(&v)
1928    }
1929}
1930
1931/// Error enumeration for [`GLContext`][crate::GLContext].
1932#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1933#[non_exhaustive]
1934#[doc(alias = "GdkGLError")]
1935pub enum GLError {
1936    /// OpenGL support is not available
1937    #[doc(alias = "GDK_GL_ERROR_NOT_AVAILABLE")]
1938    NotAvailable,
1939    /// The requested visual format is not supported
1940    #[doc(alias = "GDK_GL_ERROR_UNSUPPORTED_FORMAT")]
1941    UnsupportedFormat,
1942    /// The requested profile is not supported
1943    #[doc(alias = "GDK_GL_ERROR_UNSUPPORTED_PROFILE")]
1944    UnsupportedProfile,
1945    #[doc(hidden)]
1946    __Unknown(i32),
1947}
1948
1949#[doc(hidden)]
1950impl IntoGlib for GLError {
1951    type GlibType = ffi::GdkGLError;
1952
1953    #[inline]
1954    fn into_glib(self) -> ffi::GdkGLError {
1955        match self {
1956            Self::NotAvailable => ffi::GDK_GL_ERROR_NOT_AVAILABLE,
1957            Self::UnsupportedFormat => ffi::GDK_GL_ERROR_UNSUPPORTED_FORMAT,
1958            Self::UnsupportedProfile => ffi::GDK_GL_ERROR_UNSUPPORTED_PROFILE,
1959            Self::__Unknown(value) => value,
1960        }
1961    }
1962}
1963
1964#[doc(hidden)]
1965impl FromGlib<ffi::GdkGLError> for GLError {
1966    #[inline]
1967    unsafe fn from_glib(value: ffi::GdkGLError) -> Self {
1968        skip_assert_initialized!();
1969
1970        match value {
1971            ffi::GDK_GL_ERROR_NOT_AVAILABLE => Self::NotAvailable,
1972            ffi::GDK_GL_ERROR_UNSUPPORTED_FORMAT => Self::UnsupportedFormat,
1973            ffi::GDK_GL_ERROR_UNSUPPORTED_PROFILE => Self::UnsupportedProfile,
1974            value => Self::__Unknown(value),
1975        }
1976    }
1977}
1978
1979impl glib::error::ErrorDomain for GLError {
1980    #[inline]
1981    fn domain() -> glib::Quark {
1982        skip_assert_initialized!();
1983
1984        unsafe { from_glib(ffi::gdk_gl_error_quark()) }
1985    }
1986
1987    #[inline]
1988    fn code(self) -> i32 {
1989        self.into_glib()
1990    }
1991
1992    #[inline]
1993    #[allow(clippy::match_single_binding)]
1994    fn from(code: i32) -> Option<Self> {
1995        skip_assert_initialized!();
1996        match unsafe { from_glib(code) } {
1997            value => Some(value),
1998        }
1999    }
2000}
2001
2002impl StaticType for GLError {
2003    #[inline]
2004    #[doc(alias = "gdk_gl_error_get_type")]
2005    fn static_type() -> glib::Type {
2006        unsafe { from_glib(ffi::gdk_gl_error_get_type()) }
2007    }
2008}
2009
2010impl glib::HasParamSpec for GLError {
2011    type ParamSpec = glib::ParamSpecEnum;
2012    type SetValue = Self;
2013    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2014
2015    fn param_spec_builder() -> Self::BuilderFn {
2016        Self::ParamSpec::builder_with_default
2017    }
2018}
2019
2020impl glib::value::ValueType for GLError {
2021    type Type = Self;
2022}
2023
2024unsafe impl<'a> glib::value::FromValue<'a> for GLError {
2025    type Checker = glib::value::GenericValueTypeChecker<Self>;
2026
2027    #[inline]
2028    unsafe fn from_value(value: &'a glib::Value) -> Self {
2029        skip_assert_initialized!();
2030        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
2031    }
2032}
2033
2034impl ToValue for GLError {
2035    #[inline]
2036    fn to_value(&self) -> glib::Value {
2037        let mut value = glib::Value::for_value_type::<Self>();
2038        unsafe {
2039            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2040        }
2041        value
2042    }
2043
2044    #[inline]
2045    fn value_type(&self) -> glib::Type {
2046        Self::static_type()
2047    }
2048}
2049
2050impl From<GLError> for glib::Value {
2051    #[inline]
2052    fn from(v: GLError) -> Self {
2053        skip_assert_initialized!();
2054        ToValue::to_value(&v)
2055    }
2056}
2057
2058/// Defines how device grabs interact with other devices.
2059#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2060#[non_exhaustive]
2061#[doc(alias = "GdkGrabOwnership")]
2062pub enum GrabOwnership {
2063    /// All other devices’ events are allowed.
2064    #[doc(alias = "GDK_OWNERSHIP_NONE")]
2065    None,
2066    /// Other devices’ events are blocked for the grab window.
2067    #[doc(alias = "GDK_OWNERSHIP_WINDOW")]
2068    Window,
2069    /// Other devices’ events are blocked for the whole application.
2070    #[doc(alias = "GDK_OWNERSHIP_APPLICATION")]
2071    Application,
2072    #[doc(hidden)]
2073    __Unknown(i32),
2074}
2075
2076#[doc(hidden)]
2077impl IntoGlib for GrabOwnership {
2078    type GlibType = ffi::GdkGrabOwnership;
2079
2080    #[inline]
2081    fn into_glib(self) -> ffi::GdkGrabOwnership {
2082        match self {
2083            Self::None => ffi::GDK_OWNERSHIP_NONE,
2084            Self::Window => ffi::GDK_OWNERSHIP_WINDOW,
2085            Self::Application => ffi::GDK_OWNERSHIP_APPLICATION,
2086            Self::__Unknown(value) => value,
2087        }
2088    }
2089}
2090
2091#[doc(hidden)]
2092impl FromGlib<ffi::GdkGrabOwnership> for GrabOwnership {
2093    #[inline]
2094    unsafe fn from_glib(value: ffi::GdkGrabOwnership) -> Self {
2095        skip_assert_initialized!();
2096
2097        match value {
2098            ffi::GDK_OWNERSHIP_NONE => Self::None,
2099            ffi::GDK_OWNERSHIP_WINDOW => Self::Window,
2100            ffi::GDK_OWNERSHIP_APPLICATION => Self::Application,
2101            value => Self::__Unknown(value),
2102        }
2103    }
2104}
2105
2106impl StaticType for GrabOwnership {
2107    #[inline]
2108    #[doc(alias = "gdk_grab_ownership_get_type")]
2109    fn static_type() -> glib::Type {
2110        unsafe { from_glib(ffi::gdk_grab_ownership_get_type()) }
2111    }
2112}
2113
2114impl glib::HasParamSpec for GrabOwnership {
2115    type ParamSpec = glib::ParamSpecEnum;
2116    type SetValue = Self;
2117    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2118
2119    fn param_spec_builder() -> Self::BuilderFn {
2120        Self::ParamSpec::builder_with_default
2121    }
2122}
2123
2124impl glib::value::ValueType for GrabOwnership {
2125    type Type = Self;
2126}
2127
2128unsafe impl<'a> glib::value::FromValue<'a> for GrabOwnership {
2129    type Checker = glib::value::GenericValueTypeChecker<Self>;
2130
2131    #[inline]
2132    unsafe fn from_value(value: &'a glib::Value) -> Self {
2133        skip_assert_initialized!();
2134        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
2135    }
2136}
2137
2138impl ToValue for GrabOwnership {
2139    #[inline]
2140    fn to_value(&self) -> glib::Value {
2141        let mut value = glib::Value::for_value_type::<Self>();
2142        unsafe {
2143            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2144        }
2145        value
2146    }
2147
2148    #[inline]
2149    fn value_type(&self) -> glib::Type {
2150        Self::static_type()
2151    }
2152}
2153
2154impl From<GrabOwnership> for glib::Value {
2155    #[inline]
2156    fn from(v: GrabOwnership) -> Self {
2157        skip_assert_initialized!();
2158        ToValue::to_value(&v)
2159    }
2160}
2161
2162/// Returned by `gdk_device_grab()`, `gdk_pointer_grab()` and `gdk_keyboard_grab()` to
2163/// indicate success or the reason for the failure of the grab attempt.
2164#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2165#[non_exhaustive]
2166#[doc(alias = "GdkGrabStatus")]
2167pub enum GrabStatus {
2168    /// the resource was successfully grabbed.
2169    #[doc(alias = "GDK_GRAB_SUCCESS")]
2170    Success,
2171    /// the resource is actively grabbed by another client.
2172    #[doc(alias = "GDK_GRAB_ALREADY_GRABBED")]
2173    AlreadyGrabbed,
2174    /// the resource was grabbed more recently than the
2175    ///  specified time.
2176    #[doc(alias = "GDK_GRAB_INVALID_TIME")]
2177    InvalidTime,
2178    /// the grab window or the `confine_to` window are not
2179    ///  viewable.
2180    #[doc(alias = "GDK_GRAB_NOT_VIEWABLE")]
2181    NotViewable,
2182    /// the resource is frozen by an active grab of another client.
2183    #[doc(alias = "GDK_GRAB_FROZEN")]
2184    Frozen,
2185    /// the grab failed for some other reason. Since 3.16
2186    #[doc(alias = "GDK_GRAB_FAILED")]
2187    Failed,
2188    #[doc(hidden)]
2189    __Unknown(i32),
2190}
2191
2192#[doc(hidden)]
2193impl IntoGlib for GrabStatus {
2194    type GlibType = ffi::GdkGrabStatus;
2195
2196    #[inline]
2197    fn into_glib(self) -> ffi::GdkGrabStatus {
2198        match self {
2199            Self::Success => ffi::GDK_GRAB_SUCCESS,
2200            Self::AlreadyGrabbed => ffi::GDK_GRAB_ALREADY_GRABBED,
2201            Self::InvalidTime => ffi::GDK_GRAB_INVALID_TIME,
2202            Self::NotViewable => ffi::GDK_GRAB_NOT_VIEWABLE,
2203            Self::Frozen => ffi::GDK_GRAB_FROZEN,
2204            Self::Failed => ffi::GDK_GRAB_FAILED,
2205            Self::__Unknown(value) => value,
2206        }
2207    }
2208}
2209
2210#[doc(hidden)]
2211impl FromGlib<ffi::GdkGrabStatus> for GrabStatus {
2212    #[inline]
2213    unsafe fn from_glib(value: ffi::GdkGrabStatus) -> Self {
2214        skip_assert_initialized!();
2215
2216        match value {
2217            ffi::GDK_GRAB_SUCCESS => Self::Success,
2218            ffi::GDK_GRAB_ALREADY_GRABBED => Self::AlreadyGrabbed,
2219            ffi::GDK_GRAB_INVALID_TIME => Self::InvalidTime,
2220            ffi::GDK_GRAB_NOT_VIEWABLE => Self::NotViewable,
2221            ffi::GDK_GRAB_FROZEN => Self::Frozen,
2222            ffi::GDK_GRAB_FAILED => Self::Failed,
2223            value => Self::__Unknown(value),
2224        }
2225    }
2226}
2227
2228impl StaticType for GrabStatus {
2229    #[inline]
2230    #[doc(alias = "gdk_grab_status_get_type")]
2231    fn static_type() -> glib::Type {
2232        unsafe { from_glib(ffi::gdk_grab_status_get_type()) }
2233    }
2234}
2235
2236impl glib::HasParamSpec for GrabStatus {
2237    type ParamSpec = glib::ParamSpecEnum;
2238    type SetValue = Self;
2239    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2240
2241    fn param_spec_builder() -> Self::BuilderFn {
2242        Self::ParamSpec::builder_with_default
2243    }
2244}
2245
2246impl glib::value::ValueType for GrabStatus {
2247    type Type = Self;
2248}
2249
2250unsafe impl<'a> glib::value::FromValue<'a> for GrabStatus {
2251    type Checker = glib::value::GenericValueTypeChecker<Self>;
2252
2253    #[inline]
2254    unsafe fn from_value(value: &'a glib::Value) -> Self {
2255        skip_assert_initialized!();
2256        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
2257    }
2258}
2259
2260impl ToValue for GrabStatus {
2261    #[inline]
2262    fn to_value(&self) -> glib::Value {
2263        let mut value = glib::Value::for_value_type::<Self>();
2264        unsafe {
2265            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2266        }
2267        value
2268    }
2269
2270    #[inline]
2271    fn value_type(&self) -> glib::Type {
2272        Self::static_type()
2273    }
2274}
2275
2276impl From<GrabStatus> for glib::Value {
2277    #[inline]
2278    fn from(v: GrabStatus) -> Self {
2279        skip_assert_initialized!();
2280        ToValue::to_value(&v)
2281    }
2282}
2283
2284/// Defines the reference point of a window and the meaning of coordinates
2285/// passed to `gtk_window_move()`. See `gtk_window_move()` and the "implementation
2286/// notes" section of the
2287/// [Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec)
2288/// specification for more details.
2289#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2290#[non_exhaustive]
2291#[doc(alias = "GdkGravity")]
2292pub enum Gravity {
2293    /// the reference point is at the top left corner.
2294    #[doc(alias = "GDK_GRAVITY_NORTH_WEST")]
2295    NorthWest,
2296    /// the reference point is in the middle of the top edge.
2297    #[doc(alias = "GDK_GRAVITY_NORTH")]
2298    North,
2299    /// the reference point is at the top right corner.
2300    #[doc(alias = "GDK_GRAVITY_NORTH_EAST")]
2301    NorthEast,
2302    /// the reference point is at the middle of the left edge.
2303    #[doc(alias = "GDK_GRAVITY_WEST")]
2304    West,
2305    /// the reference point is at the center of the window.
2306    #[doc(alias = "GDK_GRAVITY_CENTER")]
2307    Center,
2308    /// the reference point is at the middle of the right edge.
2309    #[doc(alias = "GDK_GRAVITY_EAST")]
2310    East,
2311    /// the reference point is at the lower left corner.
2312    #[doc(alias = "GDK_GRAVITY_SOUTH_WEST")]
2313    SouthWest,
2314    /// the reference point is at the middle of the lower edge.
2315    #[doc(alias = "GDK_GRAVITY_SOUTH")]
2316    South,
2317    /// the reference point is at the lower right corner.
2318    #[doc(alias = "GDK_GRAVITY_SOUTH_EAST")]
2319    SouthEast,
2320    /// the reference point is at the top left corner of the
2321    ///  window itself, ignoring window manager decorations.
2322    #[doc(alias = "GDK_GRAVITY_STATIC")]
2323    Static,
2324    #[doc(hidden)]
2325    __Unknown(i32),
2326}
2327
2328#[doc(hidden)]
2329impl IntoGlib for Gravity {
2330    type GlibType = ffi::GdkGravity;
2331
2332    #[inline]
2333    fn into_glib(self) -> ffi::GdkGravity {
2334        match self {
2335            Self::NorthWest => ffi::GDK_GRAVITY_NORTH_WEST,
2336            Self::North => ffi::GDK_GRAVITY_NORTH,
2337            Self::NorthEast => ffi::GDK_GRAVITY_NORTH_EAST,
2338            Self::West => ffi::GDK_GRAVITY_WEST,
2339            Self::Center => ffi::GDK_GRAVITY_CENTER,
2340            Self::East => ffi::GDK_GRAVITY_EAST,
2341            Self::SouthWest => ffi::GDK_GRAVITY_SOUTH_WEST,
2342            Self::South => ffi::GDK_GRAVITY_SOUTH,
2343            Self::SouthEast => ffi::GDK_GRAVITY_SOUTH_EAST,
2344            Self::Static => ffi::GDK_GRAVITY_STATIC,
2345            Self::__Unknown(value) => value,
2346        }
2347    }
2348}
2349
2350#[doc(hidden)]
2351impl FromGlib<ffi::GdkGravity> for Gravity {
2352    #[inline]
2353    unsafe fn from_glib(value: ffi::GdkGravity) -> Self {
2354        skip_assert_initialized!();
2355
2356        match value {
2357            ffi::GDK_GRAVITY_NORTH_WEST => Self::NorthWest,
2358            ffi::GDK_GRAVITY_NORTH => Self::North,
2359            ffi::GDK_GRAVITY_NORTH_EAST => Self::NorthEast,
2360            ffi::GDK_GRAVITY_WEST => Self::West,
2361            ffi::GDK_GRAVITY_CENTER => Self::Center,
2362            ffi::GDK_GRAVITY_EAST => Self::East,
2363            ffi::GDK_GRAVITY_SOUTH_WEST => Self::SouthWest,
2364            ffi::GDK_GRAVITY_SOUTH => Self::South,
2365            ffi::GDK_GRAVITY_SOUTH_EAST => Self::SouthEast,
2366            ffi::GDK_GRAVITY_STATIC => Self::Static,
2367            value => Self::__Unknown(value),
2368        }
2369    }
2370}
2371
2372impl StaticType for Gravity {
2373    #[inline]
2374    #[doc(alias = "gdk_gravity_get_type")]
2375    fn static_type() -> glib::Type {
2376        unsafe { from_glib(ffi::gdk_gravity_get_type()) }
2377    }
2378}
2379
2380impl glib::HasParamSpec for Gravity {
2381    type ParamSpec = glib::ParamSpecEnum;
2382    type SetValue = Self;
2383    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2384
2385    fn param_spec_builder() -> Self::BuilderFn {
2386        Self::ParamSpec::builder_with_default
2387    }
2388}
2389
2390impl glib::value::ValueType for Gravity {
2391    type Type = Self;
2392}
2393
2394unsafe impl<'a> glib::value::FromValue<'a> for Gravity {
2395    type Checker = glib::value::GenericValueTypeChecker<Self>;
2396
2397    #[inline]
2398    unsafe fn from_value(value: &'a glib::Value) -> Self {
2399        skip_assert_initialized!();
2400        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
2401    }
2402}
2403
2404impl ToValue for Gravity {
2405    #[inline]
2406    fn to_value(&self) -> glib::Value {
2407        let mut value = glib::Value::for_value_type::<Self>();
2408        unsafe {
2409            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2410        }
2411        value
2412    }
2413
2414    #[inline]
2415    fn value_type(&self) -> glib::Type {
2416        Self::static_type()
2417    }
2418}
2419
2420impl From<Gravity> for glib::Value {
2421    #[inline]
2422    fn from(v: Gravity) -> Self {
2423        skip_assert_initialized!();
2424        ToValue::to_value(&v)
2425    }
2426}
2427
2428/// An enumeration that describes the mode of an input device.
2429#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2430#[non_exhaustive]
2431#[doc(alias = "GdkInputMode")]
2432pub enum InputMode {
2433    /// the device is disabled and will not report any events.
2434    #[doc(alias = "GDK_MODE_DISABLED")]
2435    Disabled,
2436    /// the device is enabled. The device’s coordinate space
2437    ///  maps to the entire screen.
2438    #[doc(alias = "GDK_MODE_SCREEN")]
2439    Screen,
2440    /// the device is enabled. The device’s coordinate space
2441    ///  is mapped to a single window. The manner in which this window
2442    ///  is chosen is undefined, but it will typically be the same
2443    ///  way in which the focus window for key events is determined.
2444    #[doc(alias = "GDK_MODE_WINDOW")]
2445    Window,
2446    #[doc(hidden)]
2447    __Unknown(i32),
2448}
2449
2450#[doc(hidden)]
2451impl IntoGlib for InputMode {
2452    type GlibType = ffi::GdkInputMode;
2453
2454    #[inline]
2455    fn into_glib(self) -> ffi::GdkInputMode {
2456        match self {
2457            Self::Disabled => ffi::GDK_MODE_DISABLED,
2458            Self::Screen => ffi::GDK_MODE_SCREEN,
2459            Self::Window => ffi::GDK_MODE_WINDOW,
2460            Self::__Unknown(value) => value,
2461        }
2462    }
2463}
2464
2465#[doc(hidden)]
2466impl FromGlib<ffi::GdkInputMode> for InputMode {
2467    #[inline]
2468    unsafe fn from_glib(value: ffi::GdkInputMode) -> Self {
2469        skip_assert_initialized!();
2470
2471        match value {
2472            ffi::GDK_MODE_DISABLED => Self::Disabled,
2473            ffi::GDK_MODE_SCREEN => Self::Screen,
2474            ffi::GDK_MODE_WINDOW => Self::Window,
2475            value => Self::__Unknown(value),
2476        }
2477    }
2478}
2479
2480impl StaticType for InputMode {
2481    #[inline]
2482    #[doc(alias = "gdk_input_mode_get_type")]
2483    fn static_type() -> glib::Type {
2484        unsafe { from_glib(ffi::gdk_input_mode_get_type()) }
2485    }
2486}
2487
2488impl glib::HasParamSpec for InputMode {
2489    type ParamSpec = glib::ParamSpecEnum;
2490    type SetValue = Self;
2491    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2492
2493    fn param_spec_builder() -> Self::BuilderFn {
2494        Self::ParamSpec::builder_with_default
2495    }
2496}
2497
2498impl glib::value::ValueType for InputMode {
2499    type Type = Self;
2500}
2501
2502unsafe impl<'a> glib::value::FromValue<'a> for InputMode {
2503    type Checker = glib::value::GenericValueTypeChecker<Self>;
2504
2505    #[inline]
2506    unsafe fn from_value(value: &'a glib::Value) -> Self {
2507        skip_assert_initialized!();
2508        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
2509    }
2510}
2511
2512impl ToValue for InputMode {
2513    #[inline]
2514    fn to_value(&self) -> glib::Value {
2515        let mut value = glib::Value::for_value_type::<Self>();
2516        unsafe {
2517            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2518        }
2519        value
2520    }
2521
2522    #[inline]
2523    fn value_type(&self) -> glib::Type {
2524        Self::static_type()
2525    }
2526}
2527
2528impl From<InputMode> for glib::Value {
2529    #[inline]
2530    fn from(v: InputMode) -> Self {
2531        skip_assert_initialized!();
2532        ToValue::to_value(&v)
2533    }
2534}
2535
2536/// An enumeration describing the type of an input device in general terms.
2537#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2538#[non_exhaustive]
2539#[doc(alias = "GdkInputSource")]
2540pub enum InputSource {
2541    /// the device is a mouse. (This will be reported for the core
2542    ///  pointer, even if it is something else, such as a trackball.)
2543    #[doc(alias = "GDK_SOURCE_MOUSE")]
2544    Mouse,
2545    /// the device is a stylus of a graphics tablet or similar device.
2546    #[doc(alias = "GDK_SOURCE_PEN")]
2547    Pen,
2548    /// the device is an eraser. Typically, this would be the other end
2549    ///  of a stylus on a graphics tablet.
2550    #[doc(alias = "GDK_SOURCE_ERASER")]
2551    Eraser,
2552    /// the device is a graphics tablet “puck” or similar device.
2553    #[doc(alias = "GDK_SOURCE_CURSOR")]
2554    Cursor,
2555    /// the device is a keyboard.
2556    #[doc(alias = "GDK_SOURCE_KEYBOARD")]
2557    Keyboard,
2558    /// the device is a direct-input touch device, such
2559    ///  as a touchscreen or tablet. This device type has been added in 3.4.
2560    #[doc(alias = "GDK_SOURCE_TOUCHSCREEN")]
2561    Touchscreen,
2562    /// the device is an indirect touch device, such
2563    ///  as a touchpad. This device type has been added in 3.4.
2564    #[doc(alias = "GDK_SOURCE_TOUCHPAD")]
2565    Touchpad,
2566    /// the device is a trackpoint. This device type has been
2567    ///  added in 3.22
2568    #[doc(alias = "GDK_SOURCE_TRACKPOINT")]
2569    Trackpoint,
2570    /// the device is a "pad", a collection of buttons,
2571    ///  rings and strips found in drawing tablets. This device type has been
2572    ///  added in 3.22.
2573    #[doc(alias = "GDK_SOURCE_TABLET_PAD")]
2574    TabletPad,
2575    #[doc(hidden)]
2576    __Unknown(i32),
2577}
2578
2579#[doc(hidden)]
2580impl IntoGlib for InputSource {
2581    type GlibType = ffi::GdkInputSource;
2582
2583    #[inline]
2584    fn into_glib(self) -> ffi::GdkInputSource {
2585        match self {
2586            Self::Mouse => ffi::GDK_SOURCE_MOUSE,
2587            Self::Pen => ffi::GDK_SOURCE_PEN,
2588            Self::Eraser => ffi::GDK_SOURCE_ERASER,
2589            Self::Cursor => ffi::GDK_SOURCE_CURSOR,
2590            Self::Keyboard => ffi::GDK_SOURCE_KEYBOARD,
2591            Self::Touchscreen => ffi::GDK_SOURCE_TOUCHSCREEN,
2592            Self::Touchpad => ffi::GDK_SOURCE_TOUCHPAD,
2593            Self::Trackpoint => ffi::GDK_SOURCE_TRACKPOINT,
2594            Self::TabletPad => ffi::GDK_SOURCE_TABLET_PAD,
2595            Self::__Unknown(value) => value,
2596        }
2597    }
2598}
2599
2600#[doc(hidden)]
2601impl FromGlib<ffi::GdkInputSource> for InputSource {
2602    #[inline]
2603    unsafe fn from_glib(value: ffi::GdkInputSource) -> Self {
2604        skip_assert_initialized!();
2605
2606        match value {
2607            ffi::GDK_SOURCE_MOUSE => Self::Mouse,
2608            ffi::GDK_SOURCE_PEN => Self::Pen,
2609            ffi::GDK_SOURCE_ERASER => Self::Eraser,
2610            ffi::GDK_SOURCE_CURSOR => Self::Cursor,
2611            ffi::GDK_SOURCE_KEYBOARD => Self::Keyboard,
2612            ffi::GDK_SOURCE_TOUCHSCREEN => Self::Touchscreen,
2613            ffi::GDK_SOURCE_TOUCHPAD => Self::Touchpad,
2614            ffi::GDK_SOURCE_TRACKPOINT => Self::Trackpoint,
2615            ffi::GDK_SOURCE_TABLET_PAD => Self::TabletPad,
2616            value => Self::__Unknown(value),
2617        }
2618    }
2619}
2620
2621impl StaticType for InputSource {
2622    #[inline]
2623    #[doc(alias = "gdk_input_source_get_type")]
2624    fn static_type() -> glib::Type {
2625        unsafe { from_glib(ffi::gdk_input_source_get_type()) }
2626    }
2627}
2628
2629impl glib::HasParamSpec for InputSource {
2630    type ParamSpec = glib::ParamSpecEnum;
2631    type SetValue = Self;
2632    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2633
2634    fn param_spec_builder() -> Self::BuilderFn {
2635        Self::ParamSpec::builder_with_default
2636    }
2637}
2638
2639impl glib::value::ValueType for InputSource {
2640    type Type = Self;
2641}
2642
2643unsafe impl<'a> glib::value::FromValue<'a> for InputSource {
2644    type Checker = glib::value::GenericValueTypeChecker<Self>;
2645
2646    #[inline]
2647    unsafe fn from_value(value: &'a glib::Value) -> Self {
2648        skip_assert_initialized!();
2649        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
2650    }
2651}
2652
2653impl ToValue for InputSource {
2654    #[inline]
2655    fn to_value(&self) -> glib::Value {
2656        let mut value = glib::Value::for_value_type::<Self>();
2657        unsafe {
2658            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2659        }
2660        value
2661    }
2662
2663    #[inline]
2664    fn value_type(&self) -> glib::Type {
2665        Self::static_type()
2666    }
2667}
2668
2669impl From<InputSource> for glib::Value {
2670    #[inline]
2671    fn from(v: InputSource) -> Self {
2672        skip_assert_initialized!();
2673        ToValue::to_value(&v)
2674    }
2675}
2676
2677/// This enum is used with [`Keymap::modifier_mask()`][crate::Keymap::modifier_mask()]
2678/// in order to determine what modifiers the
2679/// currently used windowing system backend uses for particular
2680/// purposes. For example, on X11/Windows, the Control key is used for
2681/// invoking menu shortcuts (accelerators), whereas on Apple computers
2682/// it’s the Command key (which correspond to [`ModifierType::CONTROL_MASK`][crate::ModifierType::CONTROL_MASK] and
2683/// [`ModifierType::MOD2_MASK`][crate::ModifierType::MOD2_MASK], respectively).
2684#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2685#[non_exhaustive]
2686#[doc(alias = "GdkModifierIntent")]
2687pub enum ModifierIntent {
2688    /// the primary modifier used to invoke
2689    ///  menu accelerators.
2690    #[doc(alias = "GDK_MODIFIER_INTENT_PRIMARY_ACCELERATOR")]
2691    PrimaryAccelerator,
2692    /// the modifier used to invoke context menus.
2693    ///  Note that mouse button 3 always triggers context menus. When this modifier
2694    ///  is not 0, it additionally triggers context menus when used with mouse button 1.
2695    #[doc(alias = "GDK_MODIFIER_INTENT_CONTEXT_MENU")]
2696    ContextMenu,
2697    /// the modifier used to extend selections
2698    ///  using `modifier`-click or `modifier`-cursor-key
2699    #[doc(alias = "GDK_MODIFIER_INTENT_EXTEND_SELECTION")]
2700    ExtendSelection,
2701    /// the modifier used to modify selections,
2702    ///  which in most cases means toggling the clicked item into or out of the selection.
2703    #[doc(alias = "GDK_MODIFIER_INTENT_MODIFY_SELECTION")]
2704    ModifySelection,
2705    /// when any of these modifiers is pressed, the
2706    ///  key event cannot produce a symbol directly. This is meant to be used for
2707    ///  input methods, and for use cases like typeahead search.
2708    #[doc(alias = "GDK_MODIFIER_INTENT_NO_TEXT_INPUT")]
2709    NoTextInput,
2710    /// the modifier that switches between keyboard
2711    ///  groups (AltGr on X11/Windows and Option/Alt on OS X).
2712    #[doc(alias = "GDK_MODIFIER_INTENT_SHIFT_GROUP")]
2713    ShiftGroup,
2714    /// The set of modifier masks accepted
2715    /// as modifiers in accelerators. Needed because Command is mapped to MOD2 on
2716    /// OSX, which is widely used, but on X11 MOD2 is NumLock and using that for a
2717    /// mod key is problematic at best.
2718    /// Ref: https://bugzilla.gnome.org/show_bug.cgi?id=736125.
2719    #[doc(alias = "GDK_MODIFIER_INTENT_DEFAULT_MOD_MASK")]
2720    DefaultModMask,
2721    #[doc(hidden)]
2722    __Unknown(i32),
2723}
2724
2725#[doc(hidden)]
2726impl IntoGlib for ModifierIntent {
2727    type GlibType = ffi::GdkModifierIntent;
2728
2729    #[inline]
2730    fn into_glib(self) -> ffi::GdkModifierIntent {
2731        match self {
2732            Self::PrimaryAccelerator => ffi::GDK_MODIFIER_INTENT_PRIMARY_ACCELERATOR,
2733            Self::ContextMenu => ffi::GDK_MODIFIER_INTENT_CONTEXT_MENU,
2734            Self::ExtendSelection => ffi::GDK_MODIFIER_INTENT_EXTEND_SELECTION,
2735            Self::ModifySelection => ffi::GDK_MODIFIER_INTENT_MODIFY_SELECTION,
2736            Self::NoTextInput => ffi::GDK_MODIFIER_INTENT_NO_TEXT_INPUT,
2737            Self::ShiftGroup => ffi::GDK_MODIFIER_INTENT_SHIFT_GROUP,
2738            Self::DefaultModMask => ffi::GDK_MODIFIER_INTENT_DEFAULT_MOD_MASK,
2739            Self::__Unknown(value) => value,
2740        }
2741    }
2742}
2743
2744#[doc(hidden)]
2745impl FromGlib<ffi::GdkModifierIntent> for ModifierIntent {
2746    #[inline]
2747    unsafe fn from_glib(value: ffi::GdkModifierIntent) -> Self {
2748        skip_assert_initialized!();
2749
2750        match value {
2751            ffi::GDK_MODIFIER_INTENT_PRIMARY_ACCELERATOR => Self::PrimaryAccelerator,
2752            ffi::GDK_MODIFIER_INTENT_CONTEXT_MENU => Self::ContextMenu,
2753            ffi::GDK_MODIFIER_INTENT_EXTEND_SELECTION => Self::ExtendSelection,
2754            ffi::GDK_MODIFIER_INTENT_MODIFY_SELECTION => Self::ModifySelection,
2755            ffi::GDK_MODIFIER_INTENT_NO_TEXT_INPUT => Self::NoTextInput,
2756            ffi::GDK_MODIFIER_INTENT_SHIFT_GROUP => Self::ShiftGroup,
2757            ffi::GDK_MODIFIER_INTENT_DEFAULT_MOD_MASK => Self::DefaultModMask,
2758            value => Self::__Unknown(value),
2759        }
2760    }
2761}
2762
2763impl StaticType for ModifierIntent {
2764    #[inline]
2765    #[doc(alias = "gdk_modifier_intent_get_type")]
2766    fn static_type() -> glib::Type {
2767        unsafe { from_glib(ffi::gdk_modifier_intent_get_type()) }
2768    }
2769}
2770
2771impl glib::HasParamSpec for ModifierIntent {
2772    type ParamSpec = glib::ParamSpecEnum;
2773    type SetValue = Self;
2774    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2775
2776    fn param_spec_builder() -> Self::BuilderFn {
2777        Self::ParamSpec::builder_with_default
2778    }
2779}
2780
2781impl glib::value::ValueType for ModifierIntent {
2782    type Type = Self;
2783}
2784
2785unsafe impl<'a> glib::value::FromValue<'a> for ModifierIntent {
2786    type Checker = glib::value::GenericValueTypeChecker<Self>;
2787
2788    #[inline]
2789    unsafe fn from_value(value: &'a glib::Value) -> Self {
2790        skip_assert_initialized!();
2791        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
2792    }
2793}
2794
2795impl ToValue for ModifierIntent {
2796    #[inline]
2797    fn to_value(&self) -> glib::Value {
2798        let mut value = glib::Value::for_value_type::<Self>();
2799        unsafe {
2800            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2801        }
2802        value
2803    }
2804
2805    #[inline]
2806    fn value_type(&self) -> glib::Type {
2807        Self::static_type()
2808    }
2809}
2810
2811impl From<ModifierIntent> for glib::Value {
2812    #[inline]
2813    fn from(v: ModifierIntent) -> Self {
2814        skip_assert_initialized!();
2815        ToValue::to_value(&v)
2816    }
2817}
2818
2819/// Specifies the kind of crossing for [`EventCrossing`][crate::EventCrossing].
2820///
2821/// See the X11 protocol specification of LeaveNotify for
2822/// full details of crossing event generation.
2823#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2824#[non_exhaustive]
2825#[doc(alias = "GdkNotifyType")]
2826pub enum NotifyType {
2827    /// the window is entered from an ancestor or
2828    ///  left towards an ancestor.
2829    #[doc(alias = "GDK_NOTIFY_ANCESTOR")]
2830    Ancestor,
2831    /// the pointer moves between an ancestor and an
2832    ///  inferior of the window.
2833    #[doc(alias = "GDK_NOTIFY_VIRTUAL")]
2834    Virtual,
2835    /// the window is entered from an inferior or
2836    ///  left towards an inferior.
2837    #[doc(alias = "GDK_NOTIFY_INFERIOR")]
2838    Inferior,
2839    /// the window is entered from or left towards
2840    ///  a window which is neither an ancestor nor an inferior.
2841    #[doc(alias = "GDK_NOTIFY_NONLINEAR")]
2842    Nonlinear,
2843    /// the pointer moves between two windows
2844    ///  which are not ancestors of each other and the window is part of
2845    ///  the ancestor chain between one of these windows and their least
2846    ///  common ancestor.
2847    #[doc(alias = "GDK_NOTIFY_NONLINEAR_VIRTUAL")]
2848    NonlinearVirtual,
2849    /// an unknown type of enter/leave event occurred.
2850    #[doc(alias = "GDK_NOTIFY_UNKNOWN")]
2851    Unknown,
2852    #[doc(hidden)]
2853    __Unknown(i32),
2854}
2855
2856#[doc(hidden)]
2857impl IntoGlib for NotifyType {
2858    type GlibType = ffi::GdkNotifyType;
2859
2860    #[inline]
2861    fn into_glib(self) -> ffi::GdkNotifyType {
2862        match self {
2863            Self::Ancestor => ffi::GDK_NOTIFY_ANCESTOR,
2864            Self::Virtual => ffi::GDK_NOTIFY_VIRTUAL,
2865            Self::Inferior => ffi::GDK_NOTIFY_INFERIOR,
2866            Self::Nonlinear => ffi::GDK_NOTIFY_NONLINEAR,
2867            Self::NonlinearVirtual => ffi::GDK_NOTIFY_NONLINEAR_VIRTUAL,
2868            Self::Unknown => ffi::GDK_NOTIFY_UNKNOWN,
2869            Self::__Unknown(value) => value,
2870        }
2871    }
2872}
2873
2874#[doc(hidden)]
2875impl FromGlib<ffi::GdkNotifyType> for NotifyType {
2876    #[inline]
2877    unsafe fn from_glib(value: ffi::GdkNotifyType) -> Self {
2878        skip_assert_initialized!();
2879
2880        match value {
2881            ffi::GDK_NOTIFY_ANCESTOR => Self::Ancestor,
2882            ffi::GDK_NOTIFY_VIRTUAL => Self::Virtual,
2883            ffi::GDK_NOTIFY_INFERIOR => Self::Inferior,
2884            ffi::GDK_NOTIFY_NONLINEAR => Self::Nonlinear,
2885            ffi::GDK_NOTIFY_NONLINEAR_VIRTUAL => Self::NonlinearVirtual,
2886            ffi::GDK_NOTIFY_UNKNOWN => Self::Unknown,
2887            value => Self::__Unknown(value),
2888        }
2889    }
2890}
2891
2892impl StaticType for NotifyType {
2893    #[inline]
2894    #[doc(alias = "gdk_notify_type_get_type")]
2895    fn static_type() -> glib::Type {
2896        unsafe { from_glib(ffi::gdk_notify_type_get_type()) }
2897    }
2898}
2899
2900impl glib::HasParamSpec for NotifyType {
2901    type ParamSpec = glib::ParamSpecEnum;
2902    type SetValue = Self;
2903    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2904
2905    fn param_spec_builder() -> Self::BuilderFn {
2906        Self::ParamSpec::builder_with_default
2907    }
2908}
2909
2910impl glib::value::ValueType for NotifyType {
2911    type Type = Self;
2912}
2913
2914unsafe impl<'a> glib::value::FromValue<'a> for NotifyType {
2915    type Checker = glib::value::GenericValueTypeChecker<Self>;
2916
2917    #[inline]
2918    unsafe fn from_value(value: &'a glib::Value) -> Self {
2919        skip_assert_initialized!();
2920        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
2921    }
2922}
2923
2924impl ToValue for NotifyType {
2925    #[inline]
2926    fn to_value(&self) -> glib::Value {
2927        let mut value = glib::Value::for_value_type::<Self>();
2928        unsafe {
2929            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2930        }
2931        value
2932    }
2933
2934    #[inline]
2935    fn value_type(&self) -> glib::Type {
2936        Self::static_type()
2937    }
2938}
2939
2940impl From<NotifyType> for glib::Value {
2941    #[inline]
2942    fn from(v: NotifyType) -> Self {
2943        skip_assert_initialized!();
2944        ToValue::to_value(&v)
2945    }
2946}
2947
2948/// Specifies why a selection ownership was changed.
2949#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2950#[non_exhaustive]
2951#[doc(alias = "GdkOwnerChange")]
2952pub enum OwnerChange {
2953    /// some other app claimed the ownership
2954    #[doc(alias = "GDK_OWNER_CHANGE_NEW_OWNER")]
2955    NewOwner,
2956    /// the window was destroyed
2957    #[doc(alias = "GDK_OWNER_CHANGE_DESTROY")]
2958    Destroy,
2959    /// the client was closed
2960    #[doc(alias = "GDK_OWNER_CHANGE_CLOSE")]
2961    Close,
2962    #[doc(hidden)]
2963    __Unknown(i32),
2964}
2965
2966#[doc(hidden)]
2967impl IntoGlib for OwnerChange {
2968    type GlibType = ffi::GdkOwnerChange;
2969
2970    #[inline]
2971    fn into_glib(self) -> ffi::GdkOwnerChange {
2972        match self {
2973            Self::NewOwner => ffi::GDK_OWNER_CHANGE_NEW_OWNER,
2974            Self::Destroy => ffi::GDK_OWNER_CHANGE_DESTROY,
2975            Self::Close => ffi::GDK_OWNER_CHANGE_CLOSE,
2976            Self::__Unknown(value) => value,
2977        }
2978    }
2979}
2980
2981#[doc(hidden)]
2982impl FromGlib<ffi::GdkOwnerChange> for OwnerChange {
2983    #[inline]
2984    unsafe fn from_glib(value: ffi::GdkOwnerChange) -> Self {
2985        skip_assert_initialized!();
2986
2987        match value {
2988            ffi::GDK_OWNER_CHANGE_NEW_OWNER => Self::NewOwner,
2989            ffi::GDK_OWNER_CHANGE_DESTROY => Self::Destroy,
2990            ffi::GDK_OWNER_CHANGE_CLOSE => Self::Close,
2991            value => Self::__Unknown(value),
2992        }
2993    }
2994}
2995
2996impl StaticType for OwnerChange {
2997    #[inline]
2998    #[doc(alias = "gdk_owner_change_get_type")]
2999    fn static_type() -> glib::Type {
3000        unsafe { from_glib(ffi::gdk_owner_change_get_type()) }
3001    }
3002}
3003
3004impl glib::HasParamSpec for OwnerChange {
3005    type ParamSpec = glib::ParamSpecEnum;
3006    type SetValue = Self;
3007    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3008
3009    fn param_spec_builder() -> Self::BuilderFn {
3010        Self::ParamSpec::builder_with_default
3011    }
3012}
3013
3014impl glib::value::ValueType for OwnerChange {
3015    type Type = Self;
3016}
3017
3018unsafe impl<'a> glib::value::FromValue<'a> for OwnerChange {
3019    type Checker = glib::value::GenericValueTypeChecker<Self>;
3020
3021    #[inline]
3022    unsafe fn from_value(value: &'a glib::Value) -> Self {
3023        skip_assert_initialized!();
3024        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
3025    }
3026}
3027
3028impl ToValue for OwnerChange {
3029    #[inline]
3030    fn to_value(&self) -> glib::Value {
3031        let mut value = glib::Value::for_value_type::<Self>();
3032        unsafe {
3033            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3034        }
3035        value
3036    }
3037
3038    #[inline]
3039    fn value_type(&self) -> glib::Type {
3040        Self::static_type()
3041    }
3042}
3043
3044impl From<OwnerChange> for glib::Value {
3045    #[inline]
3046    fn from(v: OwnerChange) -> Self {
3047        skip_assert_initialized!();
3048        ToValue::to_value(&v)
3049    }
3050}
3051
3052/// Describes how existing data is combined with new data when
3053/// using `gdk_property_change()`.
3054#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3055#[non_exhaustive]
3056#[doc(alias = "GdkPropMode")]
3057pub enum PropMode {
3058    /// the new data replaces the existing data.
3059    #[doc(alias = "GDK_PROP_MODE_REPLACE")]
3060    Replace,
3061    /// the new data is prepended to the existing data.
3062    #[doc(alias = "GDK_PROP_MODE_PREPEND")]
3063    Prepend,
3064    /// the new data is appended to the existing data.
3065    #[doc(alias = "GDK_PROP_MODE_APPEND")]
3066    Append,
3067    #[doc(hidden)]
3068    __Unknown(i32),
3069}
3070
3071#[doc(hidden)]
3072impl IntoGlib for PropMode {
3073    type GlibType = ffi::GdkPropMode;
3074
3075    #[inline]
3076    fn into_glib(self) -> ffi::GdkPropMode {
3077        match self {
3078            Self::Replace => ffi::GDK_PROP_MODE_REPLACE,
3079            Self::Prepend => ffi::GDK_PROP_MODE_PREPEND,
3080            Self::Append => ffi::GDK_PROP_MODE_APPEND,
3081            Self::__Unknown(value) => value,
3082        }
3083    }
3084}
3085
3086#[doc(hidden)]
3087impl FromGlib<ffi::GdkPropMode> for PropMode {
3088    #[inline]
3089    unsafe fn from_glib(value: ffi::GdkPropMode) -> Self {
3090        skip_assert_initialized!();
3091
3092        match value {
3093            ffi::GDK_PROP_MODE_REPLACE => Self::Replace,
3094            ffi::GDK_PROP_MODE_PREPEND => Self::Prepend,
3095            ffi::GDK_PROP_MODE_APPEND => Self::Append,
3096            value => Self::__Unknown(value),
3097        }
3098    }
3099}
3100
3101impl StaticType for PropMode {
3102    #[inline]
3103    #[doc(alias = "gdk_prop_mode_get_type")]
3104    fn static_type() -> glib::Type {
3105        unsafe { from_glib(ffi::gdk_prop_mode_get_type()) }
3106    }
3107}
3108
3109impl glib::HasParamSpec for PropMode {
3110    type ParamSpec = glib::ParamSpecEnum;
3111    type SetValue = Self;
3112    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3113
3114    fn param_spec_builder() -> Self::BuilderFn {
3115        Self::ParamSpec::builder_with_default
3116    }
3117}
3118
3119impl glib::value::ValueType for PropMode {
3120    type Type = Self;
3121}
3122
3123unsafe impl<'a> glib::value::FromValue<'a> for PropMode {
3124    type Checker = glib::value::GenericValueTypeChecker<Self>;
3125
3126    #[inline]
3127    unsafe fn from_value(value: &'a glib::Value) -> Self {
3128        skip_assert_initialized!();
3129        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
3130    }
3131}
3132
3133impl ToValue for PropMode {
3134    #[inline]
3135    fn to_value(&self) -> glib::Value {
3136        let mut value = glib::Value::for_value_type::<Self>();
3137        unsafe {
3138            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3139        }
3140        value
3141    }
3142
3143    #[inline]
3144    fn value_type(&self) -> glib::Type {
3145        Self::static_type()
3146    }
3147}
3148
3149impl From<PropMode> for glib::Value {
3150    #[inline]
3151    fn from(v: PropMode) -> Self {
3152        skip_assert_initialized!();
3153        ToValue::to_value(&v)
3154    }
3155}
3156
3157/// Specifies the type of a property change for a [`EventProperty`][crate::EventProperty].
3158#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3159#[non_exhaustive]
3160#[doc(alias = "GdkPropertyState")]
3161pub enum PropertyState {
3162    /// the property value was changed.
3163    #[doc(alias = "GDK_PROPERTY_NEW_VALUE")]
3164    NewValue,
3165    /// the property was deleted.
3166    #[doc(alias = "GDK_PROPERTY_DELETE")]
3167    Delete,
3168    #[doc(hidden)]
3169    __Unknown(i32),
3170}
3171
3172#[doc(hidden)]
3173impl IntoGlib for PropertyState {
3174    type GlibType = ffi::GdkPropertyState;
3175
3176    #[inline]
3177    fn into_glib(self) -> ffi::GdkPropertyState {
3178        match self {
3179            Self::NewValue => ffi::GDK_PROPERTY_NEW_VALUE,
3180            Self::Delete => ffi::GDK_PROPERTY_DELETE,
3181            Self::__Unknown(value) => value,
3182        }
3183    }
3184}
3185
3186#[doc(hidden)]
3187impl FromGlib<ffi::GdkPropertyState> for PropertyState {
3188    #[inline]
3189    unsafe fn from_glib(value: ffi::GdkPropertyState) -> Self {
3190        skip_assert_initialized!();
3191
3192        match value {
3193            ffi::GDK_PROPERTY_NEW_VALUE => Self::NewValue,
3194            ffi::GDK_PROPERTY_DELETE => Self::Delete,
3195            value => Self::__Unknown(value),
3196        }
3197    }
3198}
3199
3200impl StaticType for PropertyState {
3201    #[inline]
3202    #[doc(alias = "gdk_property_state_get_type")]
3203    fn static_type() -> glib::Type {
3204        unsafe { from_glib(ffi::gdk_property_state_get_type()) }
3205    }
3206}
3207
3208impl glib::HasParamSpec for PropertyState {
3209    type ParamSpec = glib::ParamSpecEnum;
3210    type SetValue = Self;
3211    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3212
3213    fn param_spec_builder() -> Self::BuilderFn {
3214        Self::ParamSpec::builder_with_default
3215    }
3216}
3217
3218impl glib::value::ValueType for PropertyState {
3219    type Type = Self;
3220}
3221
3222unsafe impl<'a> glib::value::FromValue<'a> for PropertyState {
3223    type Checker = glib::value::GenericValueTypeChecker<Self>;
3224
3225    #[inline]
3226    unsafe fn from_value(value: &'a glib::Value) -> Self {
3227        skip_assert_initialized!();
3228        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
3229    }
3230}
3231
3232impl ToValue for PropertyState {
3233    #[inline]
3234    fn to_value(&self) -> glib::Value {
3235        let mut value = glib::Value::for_value_type::<Self>();
3236        unsafe {
3237            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3238        }
3239        value
3240    }
3241
3242    #[inline]
3243    fn value_type(&self) -> glib::Type {
3244        Self::static_type()
3245    }
3246}
3247
3248impl From<PropertyState> for glib::Value {
3249    #[inline]
3250    fn from(v: PropertyState) -> Self {
3251        skip_assert_initialized!();
3252        ToValue::to_value(&v)
3253    }
3254}
3255
3256/// Specifies the direction for [`EventScroll`][crate::EventScroll].
3257#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3258#[non_exhaustive]
3259#[doc(alias = "GdkScrollDirection")]
3260pub enum ScrollDirection {
3261    /// the window is scrolled up.
3262    #[doc(alias = "GDK_SCROLL_UP")]
3263    Up,
3264    /// the window is scrolled down.
3265    #[doc(alias = "GDK_SCROLL_DOWN")]
3266    Down,
3267    /// the window is scrolled to the left.
3268    #[doc(alias = "GDK_SCROLL_LEFT")]
3269    Left,
3270    /// the window is scrolled to the right.
3271    #[doc(alias = "GDK_SCROLL_RIGHT")]
3272    Right,
3273    /// the scrolling is determined by the delta values
3274    ///  in [`EventScroll`][crate::EventScroll]. See `gdk_event_get_scroll_deltas()`. Since: 3.4
3275    #[doc(alias = "GDK_SCROLL_SMOOTH")]
3276    Smooth,
3277    #[doc(hidden)]
3278    __Unknown(i32),
3279}
3280
3281#[doc(hidden)]
3282impl IntoGlib for ScrollDirection {
3283    type GlibType = ffi::GdkScrollDirection;
3284
3285    #[inline]
3286    fn into_glib(self) -> ffi::GdkScrollDirection {
3287        match self {
3288            Self::Up => ffi::GDK_SCROLL_UP,
3289            Self::Down => ffi::GDK_SCROLL_DOWN,
3290            Self::Left => ffi::GDK_SCROLL_LEFT,
3291            Self::Right => ffi::GDK_SCROLL_RIGHT,
3292            Self::Smooth => ffi::GDK_SCROLL_SMOOTH,
3293            Self::__Unknown(value) => value,
3294        }
3295    }
3296}
3297
3298#[doc(hidden)]
3299impl FromGlib<ffi::GdkScrollDirection> for ScrollDirection {
3300    #[inline]
3301    unsafe fn from_glib(value: ffi::GdkScrollDirection) -> Self {
3302        skip_assert_initialized!();
3303
3304        match value {
3305            ffi::GDK_SCROLL_UP => Self::Up,
3306            ffi::GDK_SCROLL_DOWN => Self::Down,
3307            ffi::GDK_SCROLL_LEFT => Self::Left,
3308            ffi::GDK_SCROLL_RIGHT => Self::Right,
3309            ffi::GDK_SCROLL_SMOOTH => Self::Smooth,
3310            value => Self::__Unknown(value),
3311        }
3312    }
3313}
3314
3315impl StaticType for ScrollDirection {
3316    #[inline]
3317    #[doc(alias = "gdk_scroll_direction_get_type")]
3318    fn static_type() -> glib::Type {
3319        unsafe { from_glib(ffi::gdk_scroll_direction_get_type()) }
3320    }
3321}
3322
3323impl glib::HasParamSpec for ScrollDirection {
3324    type ParamSpec = glib::ParamSpecEnum;
3325    type SetValue = Self;
3326    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3327
3328    fn param_spec_builder() -> Self::BuilderFn {
3329        Self::ParamSpec::builder_with_default
3330    }
3331}
3332
3333impl glib::value::ValueType for ScrollDirection {
3334    type Type = Self;
3335}
3336
3337unsafe impl<'a> glib::value::FromValue<'a> for ScrollDirection {
3338    type Checker = glib::value::GenericValueTypeChecker<Self>;
3339
3340    #[inline]
3341    unsafe fn from_value(value: &'a glib::Value) -> Self {
3342        skip_assert_initialized!();
3343        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
3344    }
3345}
3346
3347impl ToValue for ScrollDirection {
3348    #[inline]
3349    fn to_value(&self) -> glib::Value {
3350        let mut value = glib::Value::for_value_type::<Self>();
3351        unsafe {
3352            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3353        }
3354        value
3355    }
3356
3357    #[inline]
3358    fn value_type(&self) -> glib::Type {
3359        Self::static_type()
3360    }
3361}
3362
3363impl From<ScrollDirection> for glib::Value {
3364    #[inline]
3365    fn from(v: ScrollDirection) -> Self {
3366        skip_assert_initialized!();
3367        ToValue::to_value(&v)
3368    }
3369}
3370
3371/// Specifies the kind of modification applied to a setting in a
3372/// [`EventSetting`][crate::EventSetting].
3373#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3374#[non_exhaustive]
3375#[doc(alias = "GdkSettingAction")]
3376pub enum SettingAction {
3377    /// a setting was added.
3378    #[doc(alias = "GDK_SETTING_ACTION_NEW")]
3379    New,
3380    /// a setting was changed.
3381    #[doc(alias = "GDK_SETTING_ACTION_CHANGED")]
3382    Changed,
3383    /// a setting was deleted.
3384    #[doc(alias = "GDK_SETTING_ACTION_DELETED")]
3385    Deleted,
3386    #[doc(hidden)]
3387    __Unknown(i32),
3388}
3389
3390#[doc(hidden)]
3391impl IntoGlib for SettingAction {
3392    type GlibType = ffi::GdkSettingAction;
3393
3394    #[inline]
3395    fn into_glib(self) -> ffi::GdkSettingAction {
3396        match self {
3397            Self::New => ffi::GDK_SETTING_ACTION_NEW,
3398            Self::Changed => ffi::GDK_SETTING_ACTION_CHANGED,
3399            Self::Deleted => ffi::GDK_SETTING_ACTION_DELETED,
3400            Self::__Unknown(value) => value,
3401        }
3402    }
3403}
3404
3405#[doc(hidden)]
3406impl FromGlib<ffi::GdkSettingAction> for SettingAction {
3407    #[inline]
3408    unsafe fn from_glib(value: ffi::GdkSettingAction) -> Self {
3409        skip_assert_initialized!();
3410
3411        match value {
3412            ffi::GDK_SETTING_ACTION_NEW => Self::New,
3413            ffi::GDK_SETTING_ACTION_CHANGED => Self::Changed,
3414            ffi::GDK_SETTING_ACTION_DELETED => Self::Deleted,
3415            value => Self::__Unknown(value),
3416        }
3417    }
3418}
3419
3420impl StaticType for SettingAction {
3421    #[inline]
3422    #[doc(alias = "gdk_setting_action_get_type")]
3423    fn static_type() -> glib::Type {
3424        unsafe { from_glib(ffi::gdk_setting_action_get_type()) }
3425    }
3426}
3427
3428impl glib::HasParamSpec for SettingAction {
3429    type ParamSpec = glib::ParamSpecEnum;
3430    type SetValue = Self;
3431    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3432
3433    fn param_spec_builder() -> Self::BuilderFn {
3434        Self::ParamSpec::builder_with_default
3435    }
3436}
3437
3438impl glib::value::ValueType for SettingAction {
3439    type Type = Self;
3440}
3441
3442unsafe impl<'a> glib::value::FromValue<'a> for SettingAction {
3443    type Checker = glib::value::GenericValueTypeChecker<Self>;
3444
3445    #[inline]
3446    unsafe fn from_value(value: &'a glib::Value) -> Self {
3447        skip_assert_initialized!();
3448        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
3449    }
3450}
3451
3452impl ToValue for SettingAction {
3453    #[inline]
3454    fn to_value(&self) -> glib::Value {
3455        let mut value = glib::Value::for_value_type::<Self>();
3456        unsafe {
3457            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3458        }
3459        value
3460    }
3461
3462    #[inline]
3463    fn value_type(&self) -> glib::Type {
3464        Self::static_type()
3465    }
3466}
3467
3468impl From<SettingAction> for glib::Value {
3469    #[inline]
3470    fn from(v: SettingAction) -> Self {
3471        skip_assert_initialized!();
3472        ToValue::to_value(&v)
3473    }
3474}
3475
3476/// This enumeration describes how the red, green and blue components
3477/// of physical pixels on an output device are laid out.
3478#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3479#[non_exhaustive]
3480#[doc(alias = "GdkSubpixelLayout")]
3481pub enum SubpixelLayout {
3482    /// The layout is not known
3483    #[doc(alias = "GDK_SUBPIXEL_LAYOUT_UNKNOWN")]
3484    Unknown,
3485    /// Not organized in this way
3486    #[doc(alias = "GDK_SUBPIXEL_LAYOUT_NONE")]
3487    None,
3488    /// The layout is horizontal, the order is RGB
3489    #[doc(alias = "GDK_SUBPIXEL_LAYOUT_HORIZONTAL_RGB")]
3490    HorizontalRgb,
3491    /// The layout is horizontal, the order is BGR
3492    #[doc(alias = "GDK_SUBPIXEL_LAYOUT_HORIZONTAL_BGR")]
3493    HorizontalBgr,
3494    /// The layout is vertical, the order is RGB
3495    #[doc(alias = "GDK_SUBPIXEL_LAYOUT_VERTICAL_RGB")]
3496    VerticalRgb,
3497    /// The layout is vertical, the order is BGR
3498    #[doc(alias = "GDK_SUBPIXEL_LAYOUT_VERTICAL_BGR")]
3499    VerticalBgr,
3500    #[doc(hidden)]
3501    __Unknown(i32),
3502}
3503
3504#[doc(hidden)]
3505impl IntoGlib for SubpixelLayout {
3506    type GlibType = ffi::GdkSubpixelLayout;
3507
3508    #[inline]
3509    fn into_glib(self) -> ffi::GdkSubpixelLayout {
3510        match self {
3511            Self::Unknown => ffi::GDK_SUBPIXEL_LAYOUT_UNKNOWN,
3512            Self::None => ffi::GDK_SUBPIXEL_LAYOUT_NONE,
3513            Self::HorizontalRgb => ffi::GDK_SUBPIXEL_LAYOUT_HORIZONTAL_RGB,
3514            Self::HorizontalBgr => ffi::GDK_SUBPIXEL_LAYOUT_HORIZONTAL_BGR,
3515            Self::VerticalRgb => ffi::GDK_SUBPIXEL_LAYOUT_VERTICAL_RGB,
3516            Self::VerticalBgr => ffi::GDK_SUBPIXEL_LAYOUT_VERTICAL_BGR,
3517            Self::__Unknown(value) => value,
3518        }
3519    }
3520}
3521
3522#[doc(hidden)]
3523impl FromGlib<ffi::GdkSubpixelLayout> for SubpixelLayout {
3524    #[inline]
3525    unsafe fn from_glib(value: ffi::GdkSubpixelLayout) -> Self {
3526        skip_assert_initialized!();
3527
3528        match value {
3529            ffi::GDK_SUBPIXEL_LAYOUT_UNKNOWN => Self::Unknown,
3530            ffi::GDK_SUBPIXEL_LAYOUT_NONE => Self::None,
3531            ffi::GDK_SUBPIXEL_LAYOUT_HORIZONTAL_RGB => Self::HorizontalRgb,
3532            ffi::GDK_SUBPIXEL_LAYOUT_HORIZONTAL_BGR => Self::HorizontalBgr,
3533            ffi::GDK_SUBPIXEL_LAYOUT_VERTICAL_RGB => Self::VerticalRgb,
3534            ffi::GDK_SUBPIXEL_LAYOUT_VERTICAL_BGR => Self::VerticalBgr,
3535            value => Self::__Unknown(value),
3536        }
3537    }
3538}
3539
3540impl StaticType for SubpixelLayout {
3541    #[inline]
3542    #[doc(alias = "gdk_subpixel_layout_get_type")]
3543    fn static_type() -> glib::Type {
3544        unsafe { from_glib(ffi::gdk_subpixel_layout_get_type()) }
3545    }
3546}
3547
3548impl glib::HasParamSpec for SubpixelLayout {
3549    type ParamSpec = glib::ParamSpecEnum;
3550    type SetValue = Self;
3551    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3552
3553    fn param_spec_builder() -> Self::BuilderFn {
3554        Self::ParamSpec::builder_with_default
3555    }
3556}
3557
3558impl glib::value::ValueType for SubpixelLayout {
3559    type Type = Self;
3560}
3561
3562unsafe impl<'a> glib::value::FromValue<'a> for SubpixelLayout {
3563    type Checker = glib::value::GenericValueTypeChecker<Self>;
3564
3565    #[inline]
3566    unsafe fn from_value(value: &'a glib::Value) -> Self {
3567        skip_assert_initialized!();
3568        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
3569    }
3570}
3571
3572impl ToValue for SubpixelLayout {
3573    #[inline]
3574    fn to_value(&self) -> glib::Value {
3575        let mut value = glib::Value::for_value_type::<Self>();
3576        unsafe {
3577            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3578        }
3579        value
3580    }
3581
3582    #[inline]
3583    fn value_type(&self) -> glib::Type {
3584        Self::static_type()
3585    }
3586}
3587
3588impl From<SubpixelLayout> for glib::Value {
3589    #[inline]
3590    fn from(v: SubpixelLayout) -> Self {
3591        skip_assert_initialized!();
3592        ToValue::to_value(&v)
3593    }
3594}
3595
3596/// Specifies the visiblity status of a window for a [`EventVisibility`][crate::EventVisibility].
3597#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3598#[non_exhaustive]
3599#[doc(alias = "GdkVisibilityState")]
3600pub enum VisibilityState {
3601    /// the window is completely visible.
3602    #[doc(alias = "GDK_VISIBILITY_UNOBSCURED")]
3603    Unobscured,
3604    /// the window is partially visible.
3605    #[doc(alias = "GDK_VISIBILITY_PARTIAL")]
3606    Partial,
3607    /// the window is not visible at all.
3608    #[doc(alias = "GDK_VISIBILITY_FULLY_OBSCURED")]
3609    FullyObscured,
3610    #[doc(hidden)]
3611    __Unknown(i32),
3612}
3613
3614#[doc(hidden)]
3615impl IntoGlib for VisibilityState {
3616    type GlibType = ffi::GdkVisibilityState;
3617
3618    #[inline]
3619    fn into_glib(self) -> ffi::GdkVisibilityState {
3620        match self {
3621            Self::Unobscured => ffi::GDK_VISIBILITY_UNOBSCURED,
3622            Self::Partial => ffi::GDK_VISIBILITY_PARTIAL,
3623            Self::FullyObscured => ffi::GDK_VISIBILITY_FULLY_OBSCURED,
3624            Self::__Unknown(value) => value,
3625        }
3626    }
3627}
3628
3629#[doc(hidden)]
3630impl FromGlib<ffi::GdkVisibilityState> for VisibilityState {
3631    #[inline]
3632    unsafe fn from_glib(value: ffi::GdkVisibilityState) -> Self {
3633        skip_assert_initialized!();
3634
3635        match value {
3636            ffi::GDK_VISIBILITY_UNOBSCURED => Self::Unobscured,
3637            ffi::GDK_VISIBILITY_PARTIAL => Self::Partial,
3638            ffi::GDK_VISIBILITY_FULLY_OBSCURED => Self::FullyObscured,
3639            value => Self::__Unknown(value),
3640        }
3641    }
3642}
3643
3644impl StaticType for VisibilityState {
3645    #[inline]
3646    #[doc(alias = "gdk_visibility_state_get_type")]
3647    fn static_type() -> glib::Type {
3648        unsafe { from_glib(ffi::gdk_visibility_state_get_type()) }
3649    }
3650}
3651
3652impl glib::HasParamSpec for VisibilityState {
3653    type ParamSpec = glib::ParamSpecEnum;
3654    type SetValue = Self;
3655    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3656
3657    fn param_spec_builder() -> Self::BuilderFn {
3658        Self::ParamSpec::builder_with_default
3659    }
3660}
3661
3662impl glib::value::ValueType for VisibilityState {
3663    type Type = Self;
3664}
3665
3666unsafe impl<'a> glib::value::FromValue<'a> for VisibilityState {
3667    type Checker = glib::value::GenericValueTypeChecker<Self>;
3668
3669    #[inline]
3670    unsafe fn from_value(value: &'a glib::Value) -> Self {
3671        skip_assert_initialized!();
3672        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
3673    }
3674}
3675
3676impl ToValue for VisibilityState {
3677    #[inline]
3678    fn to_value(&self) -> glib::Value {
3679        let mut value = glib::Value::for_value_type::<Self>();
3680        unsafe {
3681            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3682        }
3683        value
3684    }
3685
3686    #[inline]
3687    fn value_type(&self) -> glib::Type {
3688        Self::static_type()
3689    }
3690}
3691
3692impl From<VisibilityState> for glib::Value {
3693    #[inline]
3694    fn from(v: VisibilityState) -> Self {
3695        skip_assert_initialized!();
3696        ToValue::to_value(&v)
3697    }
3698}
3699
3700/// A set of values that describe the manner in which the pixel values
3701/// for a visual are converted into RGB values for display.
3702#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3703#[non_exhaustive]
3704#[doc(alias = "GdkVisualType")]
3705pub enum VisualType {
3706    /// Each pixel value indexes a grayscale value
3707    ///  directly.
3708    #[doc(alias = "GDK_VISUAL_STATIC_GRAY")]
3709    StaticGray,
3710    /// Each pixel is an index into a color map that
3711    ///  maps pixel values into grayscale values. The color map can be
3712    ///  changed by an application.
3713    #[doc(alias = "GDK_VISUAL_GRAYSCALE")]
3714    Grayscale,
3715    /// Each pixel value is an index into a predefined,
3716    ///  unmodifiable color map that maps pixel values into RGB values.
3717    #[doc(alias = "GDK_VISUAL_STATIC_COLOR")]
3718    StaticColor,
3719    /// Each pixel is an index into a color map that
3720    ///  maps pixel values into rgb values. The color map can be changed by
3721    ///  an application.
3722    #[doc(alias = "GDK_VISUAL_PSEUDO_COLOR")]
3723    PseudoColor,
3724    /// Each pixel value directly contains red, green,
3725    ///  and blue components. Use [`Visual::red_pixel_details()`][crate::Visual::red_pixel_details()], etc,
3726    ///  to obtain information about how the components are assembled into
3727    ///  a pixel value.
3728    #[doc(alias = "GDK_VISUAL_TRUE_COLOR")]
3729    TrueColor,
3730    /// Each pixel value contains red, green, and blue
3731    ///  components as for [`TrueColor`][Self::TrueColor], but the components are
3732    ///  mapped via a color table into the final output table instead of
3733    ///  being converted directly.
3734    #[doc(alias = "GDK_VISUAL_DIRECT_COLOR")]
3735    DirectColor,
3736    #[doc(hidden)]
3737    __Unknown(i32),
3738}
3739
3740#[doc(hidden)]
3741impl IntoGlib for VisualType {
3742    type GlibType = ffi::GdkVisualType;
3743
3744    #[inline]
3745    fn into_glib(self) -> ffi::GdkVisualType {
3746        match self {
3747            Self::StaticGray => ffi::GDK_VISUAL_STATIC_GRAY,
3748            Self::Grayscale => ffi::GDK_VISUAL_GRAYSCALE,
3749            Self::StaticColor => ffi::GDK_VISUAL_STATIC_COLOR,
3750            Self::PseudoColor => ffi::GDK_VISUAL_PSEUDO_COLOR,
3751            Self::TrueColor => ffi::GDK_VISUAL_TRUE_COLOR,
3752            Self::DirectColor => ffi::GDK_VISUAL_DIRECT_COLOR,
3753            Self::__Unknown(value) => value,
3754        }
3755    }
3756}
3757
3758#[doc(hidden)]
3759impl FromGlib<ffi::GdkVisualType> for VisualType {
3760    #[inline]
3761    unsafe fn from_glib(value: ffi::GdkVisualType) -> Self {
3762        skip_assert_initialized!();
3763
3764        match value {
3765            ffi::GDK_VISUAL_STATIC_GRAY => Self::StaticGray,
3766            ffi::GDK_VISUAL_GRAYSCALE => Self::Grayscale,
3767            ffi::GDK_VISUAL_STATIC_COLOR => Self::StaticColor,
3768            ffi::GDK_VISUAL_PSEUDO_COLOR => Self::PseudoColor,
3769            ffi::GDK_VISUAL_TRUE_COLOR => Self::TrueColor,
3770            ffi::GDK_VISUAL_DIRECT_COLOR => Self::DirectColor,
3771            value => Self::__Unknown(value),
3772        }
3773    }
3774}
3775
3776impl StaticType for VisualType {
3777    #[inline]
3778    #[doc(alias = "gdk_visual_type_get_type")]
3779    fn static_type() -> glib::Type {
3780        unsafe { from_glib(ffi::gdk_visual_type_get_type()) }
3781    }
3782}
3783
3784impl glib::HasParamSpec for VisualType {
3785    type ParamSpec = glib::ParamSpecEnum;
3786    type SetValue = Self;
3787    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3788
3789    fn param_spec_builder() -> Self::BuilderFn {
3790        Self::ParamSpec::builder_with_default
3791    }
3792}
3793
3794impl glib::value::ValueType for VisualType {
3795    type Type = Self;
3796}
3797
3798unsafe impl<'a> glib::value::FromValue<'a> for VisualType {
3799    type Checker = glib::value::GenericValueTypeChecker<Self>;
3800
3801    #[inline]
3802    unsafe fn from_value(value: &'a glib::Value) -> Self {
3803        skip_assert_initialized!();
3804        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
3805    }
3806}
3807
3808impl ToValue for VisualType {
3809    #[inline]
3810    fn to_value(&self) -> glib::Value {
3811        let mut value = glib::Value::for_value_type::<Self>();
3812        unsafe {
3813            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3814        }
3815        value
3816    }
3817
3818    #[inline]
3819    fn value_type(&self) -> glib::Type {
3820        Self::static_type()
3821    }
3822}
3823
3824impl From<VisualType> for glib::Value {
3825    #[inline]
3826    fn from(v: VisualType) -> Self {
3827        skip_assert_initialized!();
3828        ToValue::to_value(&v)
3829    }
3830}
3831
3832/// Determines a window edge or corner.
3833#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3834#[non_exhaustive]
3835#[doc(alias = "GdkWindowEdge")]
3836pub enum WindowEdge {
3837    /// the top left corner.
3838    #[doc(alias = "GDK_WINDOW_EDGE_NORTH_WEST")]
3839    NorthWest,
3840    /// the top edge.
3841    #[doc(alias = "GDK_WINDOW_EDGE_NORTH")]
3842    North,
3843    /// the top right corner.
3844    #[doc(alias = "GDK_WINDOW_EDGE_NORTH_EAST")]
3845    NorthEast,
3846    /// the left edge.
3847    #[doc(alias = "GDK_WINDOW_EDGE_WEST")]
3848    West,
3849    /// the right edge.
3850    #[doc(alias = "GDK_WINDOW_EDGE_EAST")]
3851    East,
3852    /// the lower left corner.
3853    #[doc(alias = "GDK_WINDOW_EDGE_SOUTH_WEST")]
3854    SouthWest,
3855    /// the lower edge.
3856    #[doc(alias = "GDK_WINDOW_EDGE_SOUTH")]
3857    South,
3858    /// the lower right corner.
3859    #[doc(alias = "GDK_WINDOW_EDGE_SOUTH_EAST")]
3860    SouthEast,
3861    #[doc(hidden)]
3862    __Unknown(i32),
3863}
3864
3865#[doc(hidden)]
3866impl IntoGlib for WindowEdge {
3867    type GlibType = ffi::GdkWindowEdge;
3868
3869    #[inline]
3870    fn into_glib(self) -> ffi::GdkWindowEdge {
3871        match self {
3872            Self::NorthWest => ffi::GDK_WINDOW_EDGE_NORTH_WEST,
3873            Self::North => ffi::GDK_WINDOW_EDGE_NORTH,
3874            Self::NorthEast => ffi::GDK_WINDOW_EDGE_NORTH_EAST,
3875            Self::West => ffi::GDK_WINDOW_EDGE_WEST,
3876            Self::East => ffi::GDK_WINDOW_EDGE_EAST,
3877            Self::SouthWest => ffi::GDK_WINDOW_EDGE_SOUTH_WEST,
3878            Self::South => ffi::GDK_WINDOW_EDGE_SOUTH,
3879            Self::SouthEast => ffi::GDK_WINDOW_EDGE_SOUTH_EAST,
3880            Self::__Unknown(value) => value,
3881        }
3882    }
3883}
3884
3885#[doc(hidden)]
3886impl FromGlib<ffi::GdkWindowEdge> for WindowEdge {
3887    #[inline]
3888    unsafe fn from_glib(value: ffi::GdkWindowEdge) -> Self {
3889        skip_assert_initialized!();
3890
3891        match value {
3892            ffi::GDK_WINDOW_EDGE_NORTH_WEST => Self::NorthWest,
3893            ffi::GDK_WINDOW_EDGE_NORTH => Self::North,
3894            ffi::GDK_WINDOW_EDGE_NORTH_EAST => Self::NorthEast,
3895            ffi::GDK_WINDOW_EDGE_WEST => Self::West,
3896            ffi::GDK_WINDOW_EDGE_EAST => Self::East,
3897            ffi::GDK_WINDOW_EDGE_SOUTH_WEST => Self::SouthWest,
3898            ffi::GDK_WINDOW_EDGE_SOUTH => Self::South,
3899            ffi::GDK_WINDOW_EDGE_SOUTH_EAST => Self::SouthEast,
3900            value => Self::__Unknown(value),
3901        }
3902    }
3903}
3904
3905impl StaticType for WindowEdge {
3906    #[inline]
3907    #[doc(alias = "gdk_window_edge_get_type")]
3908    fn static_type() -> glib::Type {
3909        unsafe { from_glib(ffi::gdk_window_edge_get_type()) }
3910    }
3911}
3912
3913impl glib::HasParamSpec for WindowEdge {
3914    type ParamSpec = glib::ParamSpecEnum;
3915    type SetValue = Self;
3916    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3917
3918    fn param_spec_builder() -> Self::BuilderFn {
3919        Self::ParamSpec::builder_with_default
3920    }
3921}
3922
3923impl glib::value::ValueType for WindowEdge {
3924    type Type = Self;
3925}
3926
3927unsafe impl<'a> glib::value::FromValue<'a> for WindowEdge {
3928    type Checker = glib::value::GenericValueTypeChecker<Self>;
3929
3930    #[inline]
3931    unsafe fn from_value(value: &'a glib::Value) -> Self {
3932        skip_assert_initialized!();
3933        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
3934    }
3935}
3936
3937impl ToValue for WindowEdge {
3938    #[inline]
3939    fn to_value(&self) -> glib::Value {
3940        let mut value = glib::Value::for_value_type::<Self>();
3941        unsafe {
3942            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3943        }
3944        value
3945    }
3946
3947    #[inline]
3948    fn value_type(&self) -> glib::Type {
3949        Self::static_type()
3950    }
3951}
3952
3953impl From<WindowEdge> for glib::Value {
3954    #[inline]
3955    fn from(v: WindowEdge) -> Self {
3956        skip_assert_initialized!();
3957        ToValue::to_value(&v)
3958    }
3959}
3960
3961/// Describes the kind of window.
3962#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3963#[non_exhaustive]
3964#[doc(alias = "GdkWindowType")]
3965pub enum WindowType {
3966    /// root window; this window has no parent, covers the entire
3967    ///  screen, and is created by the window system
3968    #[doc(alias = "GDK_WINDOW_ROOT")]
3969    Root,
3970    /// toplevel window (used to implement `GtkWindow`)
3971    #[doc(alias = "GDK_WINDOW_TOPLEVEL")]
3972    Toplevel,
3973    /// child window (used to implement e.g. `GtkEntry`)
3974    #[doc(alias = "GDK_WINDOW_CHILD")]
3975    Child,
3976    /// override redirect temporary window (used to implement
3977    ///  `GtkMenu`)
3978    #[doc(alias = "GDK_WINDOW_TEMP")]
3979    Temp,
3980    /// foreign window (see `gdk_window_foreign_new()`)
3981    #[doc(alias = "GDK_WINDOW_FOREIGN")]
3982    Foreign,
3983    /// offscreen window (see
3984    ///  [Offscreen Windows][OFFSCREEN-WINDOWS]). Since 2.18
3985    #[doc(alias = "GDK_WINDOW_OFFSCREEN")]
3986    Offscreen,
3987    /// subsurface-based window; This window is visually
3988    ///  tied to a toplevel, and is moved/stacked with it. Currently this window
3989    ///  type is only implemented in Wayland. Since 3.14
3990    #[doc(alias = "GDK_WINDOW_SUBSURFACE")]
3991    Subsurface,
3992    #[doc(hidden)]
3993    __Unknown(i32),
3994}
3995
3996#[doc(hidden)]
3997impl IntoGlib for WindowType {
3998    type GlibType = ffi::GdkWindowType;
3999
4000    #[inline]
4001    fn into_glib(self) -> ffi::GdkWindowType {
4002        match self {
4003            Self::Root => ffi::GDK_WINDOW_ROOT,
4004            Self::Toplevel => ffi::GDK_WINDOW_TOPLEVEL,
4005            Self::Child => ffi::GDK_WINDOW_CHILD,
4006            Self::Temp => ffi::GDK_WINDOW_TEMP,
4007            Self::Foreign => ffi::GDK_WINDOW_FOREIGN,
4008            Self::Offscreen => ffi::GDK_WINDOW_OFFSCREEN,
4009            Self::Subsurface => ffi::GDK_WINDOW_SUBSURFACE,
4010            Self::__Unknown(value) => value,
4011        }
4012    }
4013}
4014
4015#[doc(hidden)]
4016impl FromGlib<ffi::GdkWindowType> for WindowType {
4017    #[inline]
4018    unsafe fn from_glib(value: ffi::GdkWindowType) -> Self {
4019        skip_assert_initialized!();
4020
4021        match value {
4022            ffi::GDK_WINDOW_ROOT => Self::Root,
4023            ffi::GDK_WINDOW_TOPLEVEL => Self::Toplevel,
4024            ffi::GDK_WINDOW_CHILD => Self::Child,
4025            ffi::GDK_WINDOW_TEMP => Self::Temp,
4026            ffi::GDK_WINDOW_FOREIGN => Self::Foreign,
4027            ffi::GDK_WINDOW_OFFSCREEN => Self::Offscreen,
4028            ffi::GDK_WINDOW_SUBSURFACE => Self::Subsurface,
4029            value => Self::__Unknown(value),
4030        }
4031    }
4032}
4033
4034impl StaticType for WindowType {
4035    #[inline]
4036    #[doc(alias = "gdk_window_type_get_type")]
4037    fn static_type() -> glib::Type {
4038        unsafe { from_glib(ffi::gdk_window_type_get_type()) }
4039    }
4040}
4041
4042impl glib::HasParamSpec for WindowType {
4043    type ParamSpec = glib::ParamSpecEnum;
4044    type SetValue = Self;
4045    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4046
4047    fn param_spec_builder() -> Self::BuilderFn {
4048        Self::ParamSpec::builder_with_default
4049    }
4050}
4051
4052impl glib::value::ValueType for WindowType {
4053    type Type = Self;
4054}
4055
4056unsafe impl<'a> glib::value::FromValue<'a> for WindowType {
4057    type Checker = glib::value::GenericValueTypeChecker<Self>;
4058
4059    #[inline]
4060    unsafe fn from_value(value: &'a glib::Value) -> Self {
4061        skip_assert_initialized!();
4062        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
4063    }
4064}
4065
4066impl ToValue for WindowType {
4067    #[inline]
4068    fn to_value(&self) -> glib::Value {
4069        let mut value = glib::Value::for_value_type::<Self>();
4070        unsafe {
4071            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4072        }
4073        value
4074    }
4075
4076    #[inline]
4077    fn value_type(&self) -> glib::Type {
4078        Self::static_type()
4079    }
4080}
4081
4082impl From<WindowType> for glib::Value {
4083    #[inline]
4084    fn from(v: WindowType) -> Self {
4085        skip_assert_initialized!();
4086        ToValue::to_value(&v)
4087    }
4088}
4089
4090/// These are hints for the window manager that indicate what type of function
4091/// the window has. The window manager can use this when determining decoration
4092/// and behaviour of the window. The hint must be set before mapping the window.
4093///
4094/// See the [Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec)
4095/// specification for more details about window types.
4096#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4097#[non_exhaustive]
4098#[doc(alias = "GdkWindowTypeHint")]
4099pub enum WindowTypeHint {
4100    /// Normal toplevel window.
4101    #[doc(alias = "GDK_WINDOW_TYPE_HINT_NORMAL")]
4102    Normal,
4103    /// Dialog window.
4104    #[doc(alias = "GDK_WINDOW_TYPE_HINT_DIALOG")]
4105    Dialog,
4106    /// Window used to implement a menu; GTK+ uses
4107    ///  this hint only for torn-off menus, see `GtkTearoffMenuItem`.
4108    #[doc(alias = "GDK_WINDOW_TYPE_HINT_MENU")]
4109    Menu,
4110    /// Window used to implement toolbars.
4111    #[doc(alias = "GDK_WINDOW_TYPE_HINT_TOOLBAR")]
4112    Toolbar,
4113    /// Window used to display a splash
4114    ///  screen during application startup.
4115    #[doc(alias = "GDK_WINDOW_TYPE_HINT_SPLASHSCREEN")]
4116    Splashscreen,
4117    /// Utility windows which are not detached
4118    ///  toolbars or dialogs.
4119    #[doc(alias = "GDK_WINDOW_TYPE_HINT_UTILITY")]
4120    Utility,
4121    /// Used for creating dock or panel windows.
4122    #[doc(alias = "GDK_WINDOW_TYPE_HINT_DOCK")]
4123    Dock,
4124    /// Used for creating the desktop background
4125    ///  window.
4126    #[doc(alias = "GDK_WINDOW_TYPE_HINT_DESKTOP")]
4127    Desktop,
4128    /// A menu that belongs to a menubar.
4129    #[doc(alias = "GDK_WINDOW_TYPE_HINT_DROPDOWN_MENU")]
4130    DropdownMenu,
4131    /// A menu that does not belong to a menubar,
4132    ///  e.g. a context menu.
4133    #[doc(alias = "GDK_WINDOW_TYPE_HINT_POPUP_MENU")]
4134    PopupMenu,
4135    /// A tooltip.
4136    #[doc(alias = "GDK_WINDOW_TYPE_HINT_TOOLTIP")]
4137    Tooltip,
4138    /// A notification - typically a “bubble”
4139    ///  that belongs to a status icon.
4140    #[doc(alias = "GDK_WINDOW_TYPE_HINT_NOTIFICATION")]
4141    Notification,
4142    /// A popup from a combo box.
4143    #[doc(alias = "GDK_WINDOW_TYPE_HINT_COMBO")]
4144    Combo,
4145    /// A window that is used to implement a DND cursor.
4146    #[doc(alias = "GDK_WINDOW_TYPE_HINT_DND")]
4147    Dnd,
4148    #[doc(hidden)]
4149    __Unknown(i32),
4150}
4151
4152#[doc(hidden)]
4153impl IntoGlib for WindowTypeHint {
4154    type GlibType = ffi::GdkWindowTypeHint;
4155
4156    fn into_glib(self) -> ffi::GdkWindowTypeHint {
4157        match self {
4158            Self::Normal => ffi::GDK_WINDOW_TYPE_HINT_NORMAL,
4159            Self::Dialog => ffi::GDK_WINDOW_TYPE_HINT_DIALOG,
4160            Self::Menu => ffi::GDK_WINDOW_TYPE_HINT_MENU,
4161            Self::Toolbar => ffi::GDK_WINDOW_TYPE_HINT_TOOLBAR,
4162            Self::Splashscreen => ffi::GDK_WINDOW_TYPE_HINT_SPLASHSCREEN,
4163            Self::Utility => ffi::GDK_WINDOW_TYPE_HINT_UTILITY,
4164            Self::Dock => ffi::GDK_WINDOW_TYPE_HINT_DOCK,
4165            Self::Desktop => ffi::GDK_WINDOW_TYPE_HINT_DESKTOP,
4166            Self::DropdownMenu => ffi::GDK_WINDOW_TYPE_HINT_DROPDOWN_MENU,
4167            Self::PopupMenu => ffi::GDK_WINDOW_TYPE_HINT_POPUP_MENU,
4168            Self::Tooltip => ffi::GDK_WINDOW_TYPE_HINT_TOOLTIP,
4169            Self::Notification => ffi::GDK_WINDOW_TYPE_HINT_NOTIFICATION,
4170            Self::Combo => ffi::GDK_WINDOW_TYPE_HINT_COMBO,
4171            Self::Dnd => ffi::GDK_WINDOW_TYPE_HINT_DND,
4172            Self::__Unknown(value) => value,
4173        }
4174    }
4175}
4176
4177#[doc(hidden)]
4178impl FromGlib<ffi::GdkWindowTypeHint> for WindowTypeHint {
4179    unsafe fn from_glib(value: ffi::GdkWindowTypeHint) -> Self {
4180        skip_assert_initialized!();
4181
4182        match value {
4183            ffi::GDK_WINDOW_TYPE_HINT_NORMAL => Self::Normal,
4184            ffi::GDK_WINDOW_TYPE_HINT_DIALOG => Self::Dialog,
4185            ffi::GDK_WINDOW_TYPE_HINT_MENU => Self::Menu,
4186            ffi::GDK_WINDOW_TYPE_HINT_TOOLBAR => Self::Toolbar,
4187            ffi::GDK_WINDOW_TYPE_HINT_SPLASHSCREEN => Self::Splashscreen,
4188            ffi::GDK_WINDOW_TYPE_HINT_UTILITY => Self::Utility,
4189            ffi::GDK_WINDOW_TYPE_HINT_DOCK => Self::Dock,
4190            ffi::GDK_WINDOW_TYPE_HINT_DESKTOP => Self::Desktop,
4191            ffi::GDK_WINDOW_TYPE_HINT_DROPDOWN_MENU => Self::DropdownMenu,
4192            ffi::GDK_WINDOW_TYPE_HINT_POPUP_MENU => Self::PopupMenu,
4193            ffi::GDK_WINDOW_TYPE_HINT_TOOLTIP => Self::Tooltip,
4194            ffi::GDK_WINDOW_TYPE_HINT_NOTIFICATION => Self::Notification,
4195            ffi::GDK_WINDOW_TYPE_HINT_COMBO => Self::Combo,
4196            ffi::GDK_WINDOW_TYPE_HINT_DND => Self::Dnd,
4197            value => Self::__Unknown(value),
4198        }
4199    }
4200}
4201
4202impl StaticType for WindowTypeHint {
4203    #[inline]
4204    #[doc(alias = "gdk_window_type_hint_get_type")]
4205    fn static_type() -> glib::Type {
4206        unsafe { from_glib(ffi::gdk_window_type_hint_get_type()) }
4207    }
4208}
4209
4210impl glib::HasParamSpec for WindowTypeHint {
4211    type ParamSpec = glib::ParamSpecEnum;
4212    type SetValue = Self;
4213    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4214
4215    fn param_spec_builder() -> Self::BuilderFn {
4216        Self::ParamSpec::builder_with_default
4217    }
4218}
4219
4220impl glib::value::ValueType for WindowTypeHint {
4221    type Type = Self;
4222}
4223
4224unsafe impl<'a> glib::value::FromValue<'a> for WindowTypeHint {
4225    type Checker = glib::value::GenericValueTypeChecker<Self>;
4226
4227    #[inline]
4228    unsafe fn from_value(value: &'a glib::Value) -> Self {
4229        skip_assert_initialized!();
4230        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
4231    }
4232}
4233
4234impl ToValue for WindowTypeHint {
4235    #[inline]
4236    fn to_value(&self) -> glib::Value {
4237        let mut value = glib::Value::for_value_type::<Self>();
4238        unsafe {
4239            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4240        }
4241        value
4242    }
4243
4244    #[inline]
4245    fn value_type(&self) -> glib::Type {
4246        Self::static_type()
4247    }
4248}
4249
4250impl From<WindowTypeHint> for glib::Value {
4251    #[inline]
4252    fn from(v: WindowTypeHint) -> Self {
4253        skip_assert_initialized!();
4254        ToValue::to_value(&v)
4255    }
4256}
4257
4258/// [`InputOutput`][Self::InputOutput] windows are the standard kind of window you might expect.
4259/// Such windows receive events and are also displayed on screen.
4260/// [`InputOnly`][Self::InputOnly] windows are invisible; they are usually placed above other
4261/// windows in order to trap or filter the events. You can’t draw on
4262/// [`InputOnly`][Self::InputOnly] windows.
4263#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4264#[non_exhaustive]
4265#[doc(alias = "GdkWindowWindowClass")]
4266pub enum WindowWindowClass {
4267    /// window for graphics and events
4268    #[doc(alias = "GDK_INPUT_OUTPUT")]
4269    InputOutput,
4270    /// window for events only
4271    #[doc(alias = "GDK_INPUT_ONLY")]
4272    InputOnly,
4273    #[doc(hidden)]
4274    __Unknown(i32),
4275}
4276
4277#[doc(hidden)]
4278impl IntoGlib for WindowWindowClass {
4279    type GlibType = ffi::GdkWindowWindowClass;
4280
4281    #[inline]
4282    fn into_glib(self) -> ffi::GdkWindowWindowClass {
4283        match self {
4284            Self::InputOutput => ffi::GDK_INPUT_OUTPUT,
4285            Self::InputOnly => ffi::GDK_INPUT_ONLY,
4286            Self::__Unknown(value) => value,
4287        }
4288    }
4289}
4290
4291#[doc(hidden)]
4292impl FromGlib<ffi::GdkWindowWindowClass> for WindowWindowClass {
4293    #[inline]
4294    unsafe fn from_glib(value: ffi::GdkWindowWindowClass) -> Self {
4295        skip_assert_initialized!();
4296
4297        match value {
4298            ffi::GDK_INPUT_OUTPUT => Self::InputOutput,
4299            ffi::GDK_INPUT_ONLY => Self::InputOnly,
4300            value => Self::__Unknown(value),
4301        }
4302    }
4303}
4304
4305impl StaticType for WindowWindowClass {
4306    #[inline]
4307    #[doc(alias = "gdk_window_window_class_get_type")]
4308    fn static_type() -> glib::Type {
4309        unsafe { from_glib(ffi::gdk_window_window_class_get_type()) }
4310    }
4311}
4312
4313impl glib::HasParamSpec for WindowWindowClass {
4314    type ParamSpec = glib::ParamSpecEnum;
4315    type SetValue = Self;
4316    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4317
4318    fn param_spec_builder() -> Self::BuilderFn {
4319        Self::ParamSpec::builder_with_default
4320    }
4321}
4322
4323impl glib::value::ValueType for WindowWindowClass {
4324    type Type = Self;
4325}
4326
4327unsafe impl<'a> glib::value::FromValue<'a> for WindowWindowClass {
4328    type Checker = glib::value::GenericValueTypeChecker<Self>;
4329
4330    #[inline]
4331    unsafe fn from_value(value: &'a glib::Value) -> Self {
4332        skip_assert_initialized!();
4333        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
4334    }
4335}
4336
4337impl ToValue for WindowWindowClass {
4338    #[inline]
4339    fn to_value(&self) -> glib::Value {
4340        let mut value = glib::Value::for_value_type::<Self>();
4341        unsafe {
4342            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4343        }
4344        value
4345    }
4346
4347    #[inline]
4348    fn value_type(&self) -> glib::Type {
4349        Self::static_type()
4350    }
4351}
4352
4353impl From<WindowWindowClass> for glib::Value {
4354    #[inline]
4355    fn from(v: WindowWindowClass) -> Self {
4356        skip_assert_initialized!();
4357        ToValue::to_value(&v)
4358    }
4359}