Skip to main content

gdk4/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#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
9#[non_exhaustive]
10#[doc(alias = "GdkAxisUse")]
11pub enum AxisUse {
12    #[doc(alias = "GDK_AXIS_IGNORE")]
13    Ignore,
14    #[doc(alias = "GDK_AXIS_X")]
15    X,
16    #[doc(alias = "GDK_AXIS_Y")]
17    Y,
18    #[doc(alias = "GDK_AXIS_DELTA_X")]
19    DeltaX,
20    #[doc(alias = "GDK_AXIS_DELTA_Y")]
21    DeltaY,
22    #[doc(alias = "GDK_AXIS_PRESSURE")]
23    Pressure,
24    #[doc(alias = "GDK_AXIS_XTILT")]
25    Xtilt,
26    #[doc(alias = "GDK_AXIS_YTILT")]
27    Ytilt,
28    #[doc(alias = "GDK_AXIS_WHEEL")]
29    Wheel,
30    #[doc(alias = "GDK_AXIS_DISTANCE")]
31    Distance,
32    #[doc(alias = "GDK_AXIS_ROTATION")]
33    Rotation,
34    #[doc(alias = "GDK_AXIS_SLIDER")]
35    Slider,
36    #[doc(hidden)]
37    __Unknown(i32),
38}
39
40#[doc(hidden)]
41impl IntoGlib for AxisUse {
42    type GlibType = ffi::GdkAxisUse;
43
44    #[inline]
45    fn into_glib(self) -> ffi::GdkAxisUse {
46        match self {
47            Self::Ignore => ffi::GDK_AXIS_IGNORE,
48            Self::X => ffi::GDK_AXIS_X,
49            Self::Y => ffi::GDK_AXIS_Y,
50            Self::DeltaX => ffi::GDK_AXIS_DELTA_X,
51            Self::DeltaY => ffi::GDK_AXIS_DELTA_Y,
52            Self::Pressure => ffi::GDK_AXIS_PRESSURE,
53            Self::Xtilt => ffi::GDK_AXIS_XTILT,
54            Self::Ytilt => ffi::GDK_AXIS_YTILT,
55            Self::Wheel => ffi::GDK_AXIS_WHEEL,
56            Self::Distance => ffi::GDK_AXIS_DISTANCE,
57            Self::Rotation => ffi::GDK_AXIS_ROTATION,
58            Self::Slider => ffi::GDK_AXIS_SLIDER,
59            Self::__Unknown(value) => value,
60        }
61    }
62}
63
64#[doc(hidden)]
65impl FromGlib<ffi::GdkAxisUse> for AxisUse {
66    #[inline]
67    unsafe fn from_glib(value: ffi::GdkAxisUse) -> Self {
68        skip_assert_initialized!();
69
70        match value {
71            ffi::GDK_AXIS_IGNORE => Self::Ignore,
72            ffi::GDK_AXIS_X => Self::X,
73            ffi::GDK_AXIS_Y => Self::Y,
74            ffi::GDK_AXIS_DELTA_X => Self::DeltaX,
75            ffi::GDK_AXIS_DELTA_Y => Self::DeltaY,
76            ffi::GDK_AXIS_PRESSURE => Self::Pressure,
77            ffi::GDK_AXIS_XTILT => Self::Xtilt,
78            ffi::GDK_AXIS_YTILT => Self::Ytilt,
79            ffi::GDK_AXIS_WHEEL => Self::Wheel,
80            ffi::GDK_AXIS_DISTANCE => Self::Distance,
81            ffi::GDK_AXIS_ROTATION => Self::Rotation,
82            ffi::GDK_AXIS_SLIDER => Self::Slider,
83            value => Self::__Unknown(value),
84        }
85    }
86}
87
88impl StaticType for AxisUse {
89    #[inline]
90    #[doc(alias = "gdk_axis_use_get_type")]
91    fn static_type() -> glib::Type {
92        unsafe { from_glib(ffi::gdk_axis_use_get_type()) }
93    }
94}
95
96impl glib::HasParamSpec for AxisUse {
97    type ParamSpec = glib::ParamSpecEnum;
98    type SetValue = Self;
99    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
100
101    fn param_spec_builder() -> Self::BuilderFn {
102        Self::ParamSpec::builder_with_default
103    }
104}
105
106impl glib::value::ValueType for AxisUse {
107    type Type = Self;
108}
109
110unsafe impl<'a> glib::value::FromValue<'a> for AxisUse {
111    type Checker = glib::value::GenericValueTypeChecker<Self>;
112
113    #[inline]
114    unsafe fn from_value(value: &'a glib::Value) -> Self {
115        skip_assert_initialized!();
116        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
117    }
118}
119
120impl ToValue for AxisUse {
121    #[inline]
122    fn to_value(&self) -> glib::Value {
123        let mut value = glib::Value::for_value_type::<Self>();
124        unsafe {
125            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
126        }
127        value
128    }
129
130    #[inline]
131    fn value_type(&self) -> glib::Type {
132        Self::static_type()
133    }
134}
135
136impl From<AxisUse> for glib::Value {
137    #[inline]
138    fn from(v: AxisUse) -> Self {
139        skip_assert_initialized!();
140        ToValue::to_value(&v)
141    }
142}
143
144#[cfg(feature = "v4_16")]
145#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
146#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
147#[non_exhaustive]
148#[doc(alias = "GdkCicpRange")]
149pub enum CicpRange {
150    #[doc(alias = "GDK_CICP_RANGE_NARROW")]
151    Narrow,
152    #[doc(alias = "GDK_CICP_RANGE_FULL")]
153    Full,
154    #[doc(hidden)]
155    __Unknown(i32),
156}
157
158#[cfg(feature = "v4_16")]
159#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
160#[doc(hidden)]
161impl IntoGlib for CicpRange {
162    type GlibType = ffi::GdkCicpRange;
163
164    #[inline]
165    fn into_glib(self) -> ffi::GdkCicpRange {
166        match self {
167            Self::Narrow => ffi::GDK_CICP_RANGE_NARROW,
168            Self::Full => ffi::GDK_CICP_RANGE_FULL,
169            Self::__Unknown(value) => value,
170        }
171    }
172}
173
174#[cfg(feature = "v4_16")]
175#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
176#[doc(hidden)]
177impl FromGlib<ffi::GdkCicpRange> for CicpRange {
178    #[inline]
179    unsafe fn from_glib(value: ffi::GdkCicpRange) -> Self {
180        skip_assert_initialized!();
181
182        match value {
183            ffi::GDK_CICP_RANGE_NARROW => Self::Narrow,
184            ffi::GDK_CICP_RANGE_FULL => Self::Full,
185            value => Self::__Unknown(value),
186        }
187    }
188}
189
190#[cfg(feature = "v4_16")]
191#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
192impl StaticType for CicpRange {
193    #[inline]
194    #[doc(alias = "gdk_cicp_range_get_type")]
195    fn static_type() -> glib::Type {
196        unsafe { from_glib(ffi::gdk_cicp_range_get_type()) }
197    }
198}
199
200#[cfg(feature = "v4_16")]
201#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
202impl glib::HasParamSpec for CicpRange {
203    type ParamSpec = glib::ParamSpecEnum;
204    type SetValue = Self;
205    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
206
207    fn param_spec_builder() -> Self::BuilderFn {
208        Self::ParamSpec::builder_with_default
209    }
210}
211
212#[cfg(feature = "v4_16")]
213#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
214impl glib::value::ValueType for CicpRange {
215    type Type = Self;
216}
217
218#[cfg(feature = "v4_16")]
219#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
220unsafe impl<'a> glib::value::FromValue<'a> for CicpRange {
221    type Checker = glib::value::GenericValueTypeChecker<Self>;
222
223    #[inline]
224    unsafe fn from_value(value: &'a glib::Value) -> Self {
225        skip_assert_initialized!();
226        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
227    }
228}
229
230#[cfg(feature = "v4_16")]
231#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
232impl ToValue for CicpRange {
233    #[inline]
234    fn to_value(&self) -> glib::Value {
235        let mut value = glib::Value::for_value_type::<Self>();
236        unsafe {
237            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
238        }
239        value
240    }
241
242    #[inline]
243    fn value_type(&self) -> glib::Type {
244        Self::static_type()
245    }
246}
247
248#[cfg(feature = "v4_16")]
249#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
250impl From<CicpRange> for glib::Value {
251    #[inline]
252    fn from(v: CicpRange) -> Self {
253        skip_assert_initialized!();
254        ToValue::to_value(&v)
255    }
256}
257
258#[cfg(feature = "v4_22")]
259#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
260#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
261#[non_exhaustive]
262#[doc(alias = "GdkColorChannel")]
263pub enum ColorChannel {
264    #[doc(alias = "GDK_COLOR_CHANNEL_RED")]
265    Red,
266    #[doc(alias = "GDK_COLOR_CHANNEL_GREEN")]
267    Green,
268    #[doc(alias = "GDK_COLOR_CHANNEL_BLUE")]
269    Blue,
270    #[doc(alias = "GDK_COLOR_CHANNEL_ALPHA")]
271    Alpha,
272    #[doc(hidden)]
273    __Unknown(i32),
274}
275
276#[cfg(feature = "v4_22")]
277#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
278#[doc(hidden)]
279impl IntoGlib for ColorChannel {
280    type GlibType = ffi::GdkColorChannel;
281
282    #[inline]
283    fn into_glib(self) -> ffi::GdkColorChannel {
284        match self {
285            Self::Red => ffi::GDK_COLOR_CHANNEL_RED,
286            Self::Green => ffi::GDK_COLOR_CHANNEL_GREEN,
287            Self::Blue => ffi::GDK_COLOR_CHANNEL_BLUE,
288            Self::Alpha => ffi::GDK_COLOR_CHANNEL_ALPHA,
289            Self::__Unknown(value) => value,
290        }
291    }
292}
293
294#[cfg(feature = "v4_22")]
295#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
296#[doc(hidden)]
297impl FromGlib<ffi::GdkColorChannel> for ColorChannel {
298    #[inline]
299    unsafe fn from_glib(value: ffi::GdkColorChannel) -> Self {
300        skip_assert_initialized!();
301
302        match value {
303            ffi::GDK_COLOR_CHANNEL_RED => Self::Red,
304            ffi::GDK_COLOR_CHANNEL_GREEN => Self::Green,
305            ffi::GDK_COLOR_CHANNEL_BLUE => Self::Blue,
306            ffi::GDK_COLOR_CHANNEL_ALPHA => Self::Alpha,
307            value => Self::__Unknown(value),
308        }
309    }
310}
311
312#[cfg(feature = "v4_22")]
313#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
314impl StaticType for ColorChannel {
315    #[inline]
316    #[doc(alias = "gdk_color_channel_get_type")]
317    fn static_type() -> glib::Type {
318        unsafe { from_glib(ffi::gdk_color_channel_get_type()) }
319    }
320}
321
322#[cfg(feature = "v4_22")]
323#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
324impl glib::HasParamSpec for ColorChannel {
325    type ParamSpec = glib::ParamSpecEnum;
326    type SetValue = Self;
327    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
328
329    fn param_spec_builder() -> Self::BuilderFn {
330        Self::ParamSpec::builder_with_default
331    }
332}
333
334#[cfg(feature = "v4_22")]
335#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
336impl glib::value::ValueType for ColorChannel {
337    type Type = Self;
338}
339
340#[cfg(feature = "v4_22")]
341#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
342unsafe impl<'a> glib::value::FromValue<'a> for ColorChannel {
343    type Checker = glib::value::GenericValueTypeChecker<Self>;
344
345    #[inline]
346    unsafe fn from_value(value: &'a glib::Value) -> Self {
347        skip_assert_initialized!();
348        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
349    }
350}
351
352#[cfg(feature = "v4_22")]
353#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
354impl ToValue for ColorChannel {
355    #[inline]
356    fn to_value(&self) -> glib::Value {
357        let mut value = glib::Value::for_value_type::<Self>();
358        unsafe {
359            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
360        }
361        value
362    }
363
364    #[inline]
365    fn value_type(&self) -> glib::Type {
366        Self::static_type()
367    }
368}
369
370#[cfg(feature = "v4_22")]
371#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
372impl From<ColorChannel> for glib::Value {
373    #[inline]
374    fn from(v: ColorChannel) -> Self {
375        skip_assert_initialized!();
376        ToValue::to_value(&v)
377    }
378}
379
380#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
381#[non_exhaustive]
382#[doc(alias = "GdkCrossingMode")]
383pub enum CrossingMode {
384    #[doc(alias = "GDK_CROSSING_NORMAL")]
385    Normal,
386    #[doc(alias = "GDK_CROSSING_GRAB")]
387    Grab,
388    #[doc(alias = "GDK_CROSSING_UNGRAB")]
389    Ungrab,
390    #[doc(alias = "GDK_CROSSING_GTK_GRAB")]
391    GtkGrab,
392    #[doc(alias = "GDK_CROSSING_GTK_UNGRAB")]
393    GtkUngrab,
394    #[doc(alias = "GDK_CROSSING_STATE_CHANGED")]
395    StateChanged,
396    #[doc(alias = "GDK_CROSSING_TOUCH_BEGIN")]
397    TouchBegin,
398    #[doc(alias = "GDK_CROSSING_TOUCH_END")]
399    TouchEnd,
400    #[doc(alias = "GDK_CROSSING_DEVICE_SWITCH")]
401    DeviceSwitch,
402    #[doc(hidden)]
403    __Unknown(i32),
404}
405
406#[doc(hidden)]
407impl IntoGlib for CrossingMode {
408    type GlibType = ffi::GdkCrossingMode;
409
410    #[inline]
411    fn into_glib(self) -> ffi::GdkCrossingMode {
412        match self {
413            Self::Normal => ffi::GDK_CROSSING_NORMAL,
414            Self::Grab => ffi::GDK_CROSSING_GRAB,
415            Self::Ungrab => ffi::GDK_CROSSING_UNGRAB,
416            Self::GtkGrab => ffi::GDK_CROSSING_GTK_GRAB,
417            Self::GtkUngrab => ffi::GDK_CROSSING_GTK_UNGRAB,
418            Self::StateChanged => ffi::GDK_CROSSING_STATE_CHANGED,
419            Self::TouchBegin => ffi::GDK_CROSSING_TOUCH_BEGIN,
420            Self::TouchEnd => ffi::GDK_CROSSING_TOUCH_END,
421            Self::DeviceSwitch => ffi::GDK_CROSSING_DEVICE_SWITCH,
422            Self::__Unknown(value) => value,
423        }
424    }
425}
426
427#[doc(hidden)]
428impl FromGlib<ffi::GdkCrossingMode> for CrossingMode {
429    #[inline]
430    unsafe fn from_glib(value: ffi::GdkCrossingMode) -> Self {
431        skip_assert_initialized!();
432
433        match value {
434            ffi::GDK_CROSSING_NORMAL => Self::Normal,
435            ffi::GDK_CROSSING_GRAB => Self::Grab,
436            ffi::GDK_CROSSING_UNGRAB => Self::Ungrab,
437            ffi::GDK_CROSSING_GTK_GRAB => Self::GtkGrab,
438            ffi::GDK_CROSSING_GTK_UNGRAB => Self::GtkUngrab,
439            ffi::GDK_CROSSING_STATE_CHANGED => Self::StateChanged,
440            ffi::GDK_CROSSING_TOUCH_BEGIN => Self::TouchBegin,
441            ffi::GDK_CROSSING_TOUCH_END => Self::TouchEnd,
442            ffi::GDK_CROSSING_DEVICE_SWITCH => Self::DeviceSwitch,
443            value => Self::__Unknown(value),
444        }
445    }
446}
447
448impl StaticType for CrossingMode {
449    #[inline]
450    #[doc(alias = "gdk_crossing_mode_get_type")]
451    fn static_type() -> glib::Type {
452        unsafe { from_glib(ffi::gdk_crossing_mode_get_type()) }
453    }
454}
455
456impl glib::HasParamSpec for CrossingMode {
457    type ParamSpec = glib::ParamSpecEnum;
458    type SetValue = Self;
459    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
460
461    fn param_spec_builder() -> Self::BuilderFn {
462        Self::ParamSpec::builder_with_default
463    }
464}
465
466impl glib::value::ValueType for CrossingMode {
467    type Type = Self;
468}
469
470unsafe impl<'a> glib::value::FromValue<'a> for CrossingMode {
471    type Checker = glib::value::GenericValueTypeChecker<Self>;
472
473    #[inline]
474    unsafe fn from_value(value: &'a glib::Value) -> Self {
475        skip_assert_initialized!();
476        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
477    }
478}
479
480impl ToValue for CrossingMode {
481    #[inline]
482    fn to_value(&self) -> glib::Value {
483        let mut value = glib::Value::for_value_type::<Self>();
484        unsafe {
485            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
486        }
487        value
488    }
489
490    #[inline]
491    fn value_type(&self) -> glib::Type {
492        Self::static_type()
493    }
494}
495
496impl From<CrossingMode> for glib::Value {
497    #[inline]
498    fn from(v: CrossingMode) -> Self {
499        skip_assert_initialized!();
500        ToValue::to_value(&v)
501    }
502}
503
504#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
505#[non_exhaustive]
506#[doc(alias = "GdkDevicePadFeature")]
507pub enum DevicePadFeature {
508    #[doc(alias = "GDK_DEVICE_PAD_FEATURE_BUTTON")]
509    Button,
510    #[doc(alias = "GDK_DEVICE_PAD_FEATURE_RING")]
511    Ring,
512    #[doc(alias = "GDK_DEVICE_PAD_FEATURE_STRIP")]
513    Strip,
514    #[doc(hidden)]
515    __Unknown(i32),
516}
517
518#[doc(hidden)]
519impl IntoGlib for DevicePadFeature {
520    type GlibType = ffi::GdkDevicePadFeature;
521
522    #[inline]
523    fn into_glib(self) -> ffi::GdkDevicePadFeature {
524        match self {
525            Self::Button => ffi::GDK_DEVICE_PAD_FEATURE_BUTTON,
526            Self::Ring => ffi::GDK_DEVICE_PAD_FEATURE_RING,
527            Self::Strip => ffi::GDK_DEVICE_PAD_FEATURE_STRIP,
528            Self::__Unknown(value) => value,
529        }
530    }
531}
532
533#[doc(hidden)]
534impl FromGlib<ffi::GdkDevicePadFeature> for DevicePadFeature {
535    #[inline]
536    unsafe fn from_glib(value: ffi::GdkDevicePadFeature) -> Self {
537        skip_assert_initialized!();
538
539        match value {
540            ffi::GDK_DEVICE_PAD_FEATURE_BUTTON => Self::Button,
541            ffi::GDK_DEVICE_PAD_FEATURE_RING => Self::Ring,
542            ffi::GDK_DEVICE_PAD_FEATURE_STRIP => Self::Strip,
543            value => Self::__Unknown(value),
544        }
545    }
546}
547
548impl StaticType for DevicePadFeature {
549    #[inline]
550    #[doc(alias = "gdk_device_pad_feature_get_type")]
551    fn static_type() -> glib::Type {
552        unsafe { from_glib(ffi::gdk_device_pad_feature_get_type()) }
553    }
554}
555
556impl glib::HasParamSpec for DevicePadFeature {
557    type ParamSpec = glib::ParamSpecEnum;
558    type SetValue = Self;
559    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
560
561    fn param_spec_builder() -> Self::BuilderFn {
562        Self::ParamSpec::builder_with_default
563    }
564}
565
566impl glib::value::ValueType for DevicePadFeature {
567    type Type = Self;
568}
569
570unsafe impl<'a> glib::value::FromValue<'a> for DevicePadFeature {
571    type Checker = glib::value::GenericValueTypeChecker<Self>;
572
573    #[inline]
574    unsafe fn from_value(value: &'a glib::Value) -> Self {
575        skip_assert_initialized!();
576        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
577    }
578}
579
580impl ToValue for DevicePadFeature {
581    #[inline]
582    fn to_value(&self) -> glib::Value {
583        let mut value = glib::Value::for_value_type::<Self>();
584        unsafe {
585            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
586        }
587        value
588    }
589
590    #[inline]
591    fn value_type(&self) -> glib::Type {
592        Self::static_type()
593    }
594}
595
596impl From<DevicePadFeature> for glib::Value {
597    #[inline]
598    fn from(v: DevicePadFeature) -> Self {
599        skip_assert_initialized!();
600        ToValue::to_value(&v)
601    }
602}
603
604#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
605#[non_exhaustive]
606#[doc(alias = "GdkDeviceToolType")]
607pub enum DeviceToolType {
608    #[doc(alias = "GDK_DEVICE_TOOL_TYPE_UNKNOWN")]
609    Unknown,
610    #[doc(alias = "GDK_DEVICE_TOOL_TYPE_PEN")]
611    Pen,
612    #[doc(alias = "GDK_DEVICE_TOOL_TYPE_ERASER")]
613    Eraser,
614    #[doc(alias = "GDK_DEVICE_TOOL_TYPE_BRUSH")]
615    Brush,
616    #[doc(alias = "GDK_DEVICE_TOOL_TYPE_PENCIL")]
617    Pencil,
618    #[doc(alias = "GDK_DEVICE_TOOL_TYPE_AIRBRUSH")]
619    Airbrush,
620    #[doc(alias = "GDK_DEVICE_TOOL_TYPE_MOUSE")]
621    Mouse,
622    #[doc(alias = "GDK_DEVICE_TOOL_TYPE_LENS")]
623    Lens,
624    #[doc(hidden)]
625    __Unknown(i32),
626}
627
628#[doc(hidden)]
629impl IntoGlib for DeviceToolType {
630    type GlibType = ffi::GdkDeviceToolType;
631
632    #[inline]
633    fn into_glib(self) -> ffi::GdkDeviceToolType {
634        match self {
635            Self::Unknown => ffi::GDK_DEVICE_TOOL_TYPE_UNKNOWN,
636            Self::Pen => ffi::GDK_DEVICE_TOOL_TYPE_PEN,
637            Self::Eraser => ffi::GDK_DEVICE_TOOL_TYPE_ERASER,
638            Self::Brush => ffi::GDK_DEVICE_TOOL_TYPE_BRUSH,
639            Self::Pencil => ffi::GDK_DEVICE_TOOL_TYPE_PENCIL,
640            Self::Airbrush => ffi::GDK_DEVICE_TOOL_TYPE_AIRBRUSH,
641            Self::Mouse => ffi::GDK_DEVICE_TOOL_TYPE_MOUSE,
642            Self::Lens => ffi::GDK_DEVICE_TOOL_TYPE_LENS,
643            Self::__Unknown(value) => value,
644        }
645    }
646}
647
648#[doc(hidden)]
649impl FromGlib<ffi::GdkDeviceToolType> for DeviceToolType {
650    #[inline]
651    unsafe fn from_glib(value: ffi::GdkDeviceToolType) -> Self {
652        skip_assert_initialized!();
653
654        match value {
655            ffi::GDK_DEVICE_TOOL_TYPE_UNKNOWN => Self::Unknown,
656            ffi::GDK_DEVICE_TOOL_TYPE_PEN => Self::Pen,
657            ffi::GDK_DEVICE_TOOL_TYPE_ERASER => Self::Eraser,
658            ffi::GDK_DEVICE_TOOL_TYPE_BRUSH => Self::Brush,
659            ffi::GDK_DEVICE_TOOL_TYPE_PENCIL => Self::Pencil,
660            ffi::GDK_DEVICE_TOOL_TYPE_AIRBRUSH => Self::Airbrush,
661            ffi::GDK_DEVICE_TOOL_TYPE_MOUSE => Self::Mouse,
662            ffi::GDK_DEVICE_TOOL_TYPE_LENS => Self::Lens,
663            value => Self::__Unknown(value),
664        }
665    }
666}
667
668impl StaticType for DeviceToolType {
669    #[inline]
670    #[doc(alias = "gdk_device_tool_type_get_type")]
671    fn static_type() -> glib::Type {
672        unsafe { from_glib(ffi::gdk_device_tool_type_get_type()) }
673    }
674}
675
676impl glib::HasParamSpec for DeviceToolType {
677    type ParamSpec = glib::ParamSpecEnum;
678    type SetValue = Self;
679    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
680
681    fn param_spec_builder() -> Self::BuilderFn {
682        Self::ParamSpec::builder_with_default
683    }
684}
685
686impl glib::value::ValueType for DeviceToolType {
687    type Type = Self;
688}
689
690unsafe impl<'a> glib::value::FromValue<'a> for DeviceToolType {
691    type Checker = glib::value::GenericValueTypeChecker<Self>;
692
693    #[inline]
694    unsafe fn from_value(value: &'a glib::Value) -> Self {
695        skip_assert_initialized!();
696        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
697    }
698}
699
700impl ToValue for DeviceToolType {
701    #[inline]
702    fn to_value(&self) -> glib::Value {
703        let mut value = glib::Value::for_value_type::<Self>();
704        unsafe {
705            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
706        }
707        value
708    }
709
710    #[inline]
711    fn value_type(&self) -> glib::Type {
712        Self::static_type()
713    }
714}
715
716impl From<DeviceToolType> for glib::Value {
717    #[inline]
718    fn from(v: DeviceToolType) -> Self {
719        skip_assert_initialized!();
720        ToValue::to_value(&v)
721    }
722}
723
724#[cfg(feature = "v4_14")]
725#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
726#[cfg(target_os = "linux")]
727#[cfg_attr(docsrs, doc(cfg(target_os = "linux")))]
728#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
729#[non_exhaustive]
730#[doc(alias = "GdkDmabufError")]
731pub enum DmabufError {
732    #[doc(alias = "GDK_DMABUF_ERROR_NOT_AVAILABLE")]
733    NotAvailable,
734    #[doc(alias = "GDK_DMABUF_ERROR_UNSUPPORTED_FORMAT")]
735    UnsupportedFormat,
736    #[doc(alias = "GDK_DMABUF_ERROR_CREATION_FAILED")]
737    CreationFailed,
738    #[doc(hidden)]
739    __Unknown(i32),
740}
741
742#[cfg(feature = "v4_14")]
743#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
744#[cfg(target_os = "linux")]
745#[doc(hidden)]
746impl IntoGlib for DmabufError {
747    type GlibType = ffi::GdkDmabufError;
748
749    #[inline]
750    fn into_glib(self) -> ffi::GdkDmabufError {
751        match self {
752            Self::NotAvailable => ffi::GDK_DMABUF_ERROR_NOT_AVAILABLE,
753            Self::UnsupportedFormat => ffi::GDK_DMABUF_ERROR_UNSUPPORTED_FORMAT,
754            Self::CreationFailed => ffi::GDK_DMABUF_ERROR_CREATION_FAILED,
755            Self::__Unknown(value) => value,
756        }
757    }
758}
759
760#[cfg(feature = "v4_14")]
761#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
762#[cfg(target_os = "linux")]
763#[doc(hidden)]
764impl FromGlib<ffi::GdkDmabufError> for DmabufError {
765    #[inline]
766    unsafe fn from_glib(value: ffi::GdkDmabufError) -> Self {
767        skip_assert_initialized!();
768
769        match value {
770            ffi::GDK_DMABUF_ERROR_NOT_AVAILABLE => Self::NotAvailable,
771            ffi::GDK_DMABUF_ERROR_UNSUPPORTED_FORMAT => Self::UnsupportedFormat,
772            ffi::GDK_DMABUF_ERROR_CREATION_FAILED => Self::CreationFailed,
773            value => Self::__Unknown(value),
774        }
775    }
776}
777
778#[cfg(feature = "v4_14")]
779#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
780#[cfg(target_os = "linux")]
781impl glib::error::ErrorDomain for DmabufError {
782    #[inline]
783    fn domain() -> glib::Quark {
784        skip_assert_initialized!();
785
786        unsafe { from_glib(ffi::gdk_dmabuf_error_quark()) }
787    }
788
789    #[inline]
790    fn code(self) -> i32 {
791        self.into_glib()
792    }
793
794    #[inline]
795    #[allow(clippy::match_single_binding)]
796    fn from(code: i32) -> Option<Self> {
797        skip_assert_initialized!();
798        match unsafe { from_glib(code) } {
799            value => Some(value),
800        }
801    }
802}
803
804#[cfg(feature = "v4_14")]
805#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
806#[cfg(target_os = "linux")]
807impl StaticType for DmabufError {
808    #[inline]
809    #[doc(alias = "gdk_dmabuf_error_get_type")]
810    fn static_type() -> glib::Type {
811        unsafe { from_glib(ffi::gdk_dmabuf_error_get_type()) }
812    }
813}
814
815#[cfg(feature = "v4_14")]
816#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
817#[cfg(target_os = "linux")]
818impl glib::HasParamSpec for DmabufError {
819    type ParamSpec = glib::ParamSpecEnum;
820    type SetValue = Self;
821    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
822
823    fn param_spec_builder() -> Self::BuilderFn {
824        Self::ParamSpec::builder_with_default
825    }
826}
827
828#[cfg(feature = "v4_14")]
829#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
830#[cfg(target_os = "linux")]
831impl glib::value::ValueType for DmabufError {
832    type Type = Self;
833}
834
835#[cfg(feature = "v4_14")]
836#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
837#[cfg(target_os = "linux")]
838unsafe impl<'a> glib::value::FromValue<'a> for DmabufError {
839    type Checker = glib::value::GenericValueTypeChecker<Self>;
840
841    #[inline]
842    unsafe fn from_value(value: &'a glib::Value) -> Self {
843        skip_assert_initialized!();
844        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
845    }
846}
847
848#[cfg(feature = "v4_14")]
849#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
850#[cfg(target_os = "linux")]
851impl ToValue for DmabufError {
852    #[inline]
853    fn to_value(&self) -> glib::Value {
854        let mut value = glib::Value::for_value_type::<Self>();
855        unsafe {
856            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
857        }
858        value
859    }
860
861    #[inline]
862    fn value_type(&self) -> glib::Type {
863        Self::static_type()
864    }
865}
866
867#[cfg(feature = "v4_14")]
868#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
869#[cfg(target_os = "linux")]
870impl From<DmabufError> for glib::Value {
871    #[inline]
872    fn from(v: DmabufError) -> Self {
873        skip_assert_initialized!();
874        ToValue::to_value(&v)
875    }
876}
877
878#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
879#[non_exhaustive]
880#[doc(alias = "GdkDragCancelReason")]
881pub enum DragCancelReason {
882    #[doc(alias = "GDK_DRAG_CANCEL_NO_TARGET")]
883    NoTarget,
884    #[doc(alias = "GDK_DRAG_CANCEL_USER_CANCELLED")]
885    UserCancelled,
886    #[doc(alias = "GDK_DRAG_CANCEL_ERROR")]
887    Error,
888    #[doc(hidden)]
889    __Unknown(i32),
890}
891
892#[doc(hidden)]
893impl IntoGlib for DragCancelReason {
894    type GlibType = ffi::GdkDragCancelReason;
895
896    #[inline]
897    fn into_glib(self) -> ffi::GdkDragCancelReason {
898        match self {
899            Self::NoTarget => ffi::GDK_DRAG_CANCEL_NO_TARGET,
900            Self::UserCancelled => ffi::GDK_DRAG_CANCEL_USER_CANCELLED,
901            Self::Error => ffi::GDK_DRAG_CANCEL_ERROR,
902            Self::__Unknown(value) => value,
903        }
904    }
905}
906
907#[doc(hidden)]
908impl FromGlib<ffi::GdkDragCancelReason> for DragCancelReason {
909    #[inline]
910    unsafe fn from_glib(value: ffi::GdkDragCancelReason) -> Self {
911        skip_assert_initialized!();
912
913        match value {
914            ffi::GDK_DRAG_CANCEL_NO_TARGET => Self::NoTarget,
915            ffi::GDK_DRAG_CANCEL_USER_CANCELLED => Self::UserCancelled,
916            ffi::GDK_DRAG_CANCEL_ERROR => Self::Error,
917            value => Self::__Unknown(value),
918        }
919    }
920}
921
922impl StaticType for DragCancelReason {
923    #[inline]
924    #[doc(alias = "gdk_drag_cancel_reason_get_type")]
925    fn static_type() -> glib::Type {
926        unsafe { from_glib(ffi::gdk_drag_cancel_reason_get_type()) }
927    }
928}
929
930impl glib::HasParamSpec for DragCancelReason {
931    type ParamSpec = glib::ParamSpecEnum;
932    type SetValue = Self;
933    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
934
935    fn param_spec_builder() -> Self::BuilderFn {
936        Self::ParamSpec::builder_with_default
937    }
938}
939
940impl glib::value::ValueType for DragCancelReason {
941    type Type = Self;
942}
943
944unsafe impl<'a> glib::value::FromValue<'a> for DragCancelReason {
945    type Checker = glib::value::GenericValueTypeChecker<Self>;
946
947    #[inline]
948    unsafe fn from_value(value: &'a glib::Value) -> Self {
949        skip_assert_initialized!();
950        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
951    }
952}
953
954impl ToValue for DragCancelReason {
955    #[inline]
956    fn to_value(&self) -> glib::Value {
957        let mut value = glib::Value::for_value_type::<Self>();
958        unsafe {
959            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
960        }
961        value
962    }
963
964    #[inline]
965    fn value_type(&self) -> glib::Type {
966        Self::static_type()
967    }
968}
969
970impl From<DragCancelReason> for glib::Value {
971    #[inline]
972    fn from(v: DragCancelReason) -> Self {
973        skip_assert_initialized!();
974        ToValue::to_value(&v)
975    }
976}
977
978#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
979#[non_exhaustive]
980#[doc(alias = "GdkEventType")]
981pub enum EventType {
982    #[doc(alias = "GDK_DELETE")]
983    Delete,
984    #[doc(alias = "GDK_MOTION_NOTIFY")]
985    MotionNotify,
986    #[doc(alias = "GDK_BUTTON_PRESS")]
987    ButtonPress,
988    #[doc(alias = "GDK_BUTTON_RELEASE")]
989    ButtonRelease,
990    #[doc(alias = "GDK_KEY_PRESS")]
991    KeyPress,
992    #[doc(alias = "GDK_KEY_RELEASE")]
993    KeyRelease,
994    #[doc(alias = "GDK_ENTER_NOTIFY")]
995    EnterNotify,
996    #[doc(alias = "GDK_LEAVE_NOTIFY")]
997    LeaveNotify,
998    #[doc(alias = "GDK_FOCUS_CHANGE")]
999    FocusChange,
1000    #[doc(alias = "GDK_PROXIMITY_IN")]
1001    ProximityIn,
1002    #[doc(alias = "GDK_PROXIMITY_OUT")]
1003    ProximityOut,
1004    #[doc(alias = "GDK_DRAG_ENTER")]
1005    DragEnter,
1006    #[doc(alias = "GDK_DRAG_LEAVE")]
1007    DragLeave,
1008    #[doc(alias = "GDK_DRAG_MOTION")]
1009    DragMotion,
1010    #[doc(alias = "GDK_DROP_START")]
1011    DropStart,
1012    #[doc(alias = "GDK_SCROLL")]
1013    Scroll,
1014    #[doc(alias = "GDK_GRAB_BROKEN")]
1015    GrabBroken,
1016    #[doc(alias = "GDK_TOUCH_BEGIN")]
1017    TouchBegin,
1018    #[doc(alias = "GDK_TOUCH_UPDATE")]
1019    TouchUpdate,
1020    #[doc(alias = "GDK_TOUCH_END")]
1021    TouchEnd,
1022    #[doc(alias = "GDK_TOUCH_CANCEL")]
1023    TouchCancel,
1024    #[doc(alias = "GDK_TOUCHPAD_SWIPE")]
1025    TouchpadSwipe,
1026    #[doc(alias = "GDK_TOUCHPAD_PINCH")]
1027    TouchpadPinch,
1028    #[doc(alias = "GDK_PAD_BUTTON_PRESS")]
1029    PadButtonPress,
1030    #[doc(alias = "GDK_PAD_BUTTON_RELEASE")]
1031    PadButtonRelease,
1032    #[doc(alias = "GDK_PAD_RING")]
1033    PadRing,
1034    #[doc(alias = "GDK_PAD_STRIP")]
1035    PadStrip,
1036    #[doc(alias = "GDK_PAD_GROUP_MODE")]
1037    PadGroupMode,
1038    #[cfg(feature = "v4_8")]
1039    #[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
1040    #[doc(alias = "GDK_TOUCHPAD_HOLD")]
1041    TouchpadHold,
1042    #[cfg(feature = "v4_20")]
1043    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1044    #[doc(alias = "GDK_PAD_DIAL")]
1045    PadDial,
1046    #[doc(hidden)]
1047    __Unknown(i32),
1048}
1049
1050#[doc(hidden)]
1051impl IntoGlib for EventType {
1052    type GlibType = ffi::GdkEventType;
1053
1054    fn into_glib(self) -> ffi::GdkEventType {
1055        match self {
1056            Self::Delete => ffi::GDK_DELETE,
1057            Self::MotionNotify => ffi::GDK_MOTION_NOTIFY,
1058            Self::ButtonPress => ffi::GDK_BUTTON_PRESS,
1059            Self::ButtonRelease => ffi::GDK_BUTTON_RELEASE,
1060            Self::KeyPress => ffi::GDK_KEY_PRESS,
1061            Self::KeyRelease => ffi::GDK_KEY_RELEASE,
1062            Self::EnterNotify => ffi::GDK_ENTER_NOTIFY,
1063            Self::LeaveNotify => ffi::GDK_LEAVE_NOTIFY,
1064            Self::FocusChange => ffi::GDK_FOCUS_CHANGE,
1065            Self::ProximityIn => ffi::GDK_PROXIMITY_IN,
1066            Self::ProximityOut => ffi::GDK_PROXIMITY_OUT,
1067            Self::DragEnter => ffi::GDK_DRAG_ENTER,
1068            Self::DragLeave => ffi::GDK_DRAG_LEAVE,
1069            Self::DragMotion => ffi::GDK_DRAG_MOTION,
1070            Self::DropStart => ffi::GDK_DROP_START,
1071            Self::Scroll => ffi::GDK_SCROLL,
1072            Self::GrabBroken => ffi::GDK_GRAB_BROKEN,
1073            Self::TouchBegin => ffi::GDK_TOUCH_BEGIN,
1074            Self::TouchUpdate => ffi::GDK_TOUCH_UPDATE,
1075            Self::TouchEnd => ffi::GDK_TOUCH_END,
1076            Self::TouchCancel => ffi::GDK_TOUCH_CANCEL,
1077            Self::TouchpadSwipe => ffi::GDK_TOUCHPAD_SWIPE,
1078            Self::TouchpadPinch => ffi::GDK_TOUCHPAD_PINCH,
1079            Self::PadButtonPress => ffi::GDK_PAD_BUTTON_PRESS,
1080            Self::PadButtonRelease => ffi::GDK_PAD_BUTTON_RELEASE,
1081            Self::PadRing => ffi::GDK_PAD_RING,
1082            Self::PadStrip => ffi::GDK_PAD_STRIP,
1083            Self::PadGroupMode => ffi::GDK_PAD_GROUP_MODE,
1084            #[cfg(feature = "v4_8")]
1085            Self::TouchpadHold => ffi::GDK_TOUCHPAD_HOLD,
1086            #[cfg(feature = "v4_20")]
1087            Self::PadDial => ffi::GDK_PAD_DIAL,
1088            Self::__Unknown(value) => value,
1089        }
1090    }
1091}
1092
1093#[doc(hidden)]
1094impl FromGlib<ffi::GdkEventType> for EventType {
1095    unsafe fn from_glib(value: ffi::GdkEventType) -> Self {
1096        skip_assert_initialized!();
1097
1098        match value {
1099            ffi::GDK_DELETE => Self::Delete,
1100            ffi::GDK_MOTION_NOTIFY => Self::MotionNotify,
1101            ffi::GDK_BUTTON_PRESS => Self::ButtonPress,
1102            ffi::GDK_BUTTON_RELEASE => Self::ButtonRelease,
1103            ffi::GDK_KEY_PRESS => Self::KeyPress,
1104            ffi::GDK_KEY_RELEASE => Self::KeyRelease,
1105            ffi::GDK_ENTER_NOTIFY => Self::EnterNotify,
1106            ffi::GDK_LEAVE_NOTIFY => Self::LeaveNotify,
1107            ffi::GDK_FOCUS_CHANGE => Self::FocusChange,
1108            ffi::GDK_PROXIMITY_IN => Self::ProximityIn,
1109            ffi::GDK_PROXIMITY_OUT => Self::ProximityOut,
1110            ffi::GDK_DRAG_ENTER => Self::DragEnter,
1111            ffi::GDK_DRAG_LEAVE => Self::DragLeave,
1112            ffi::GDK_DRAG_MOTION => Self::DragMotion,
1113            ffi::GDK_DROP_START => Self::DropStart,
1114            ffi::GDK_SCROLL => Self::Scroll,
1115            ffi::GDK_GRAB_BROKEN => Self::GrabBroken,
1116            ffi::GDK_TOUCH_BEGIN => Self::TouchBegin,
1117            ffi::GDK_TOUCH_UPDATE => Self::TouchUpdate,
1118            ffi::GDK_TOUCH_END => Self::TouchEnd,
1119            ffi::GDK_TOUCH_CANCEL => Self::TouchCancel,
1120            ffi::GDK_TOUCHPAD_SWIPE => Self::TouchpadSwipe,
1121            ffi::GDK_TOUCHPAD_PINCH => Self::TouchpadPinch,
1122            ffi::GDK_PAD_BUTTON_PRESS => Self::PadButtonPress,
1123            ffi::GDK_PAD_BUTTON_RELEASE => Self::PadButtonRelease,
1124            ffi::GDK_PAD_RING => Self::PadRing,
1125            ffi::GDK_PAD_STRIP => Self::PadStrip,
1126            ffi::GDK_PAD_GROUP_MODE => Self::PadGroupMode,
1127            #[cfg(feature = "v4_8")]
1128            ffi::GDK_TOUCHPAD_HOLD => Self::TouchpadHold,
1129            #[cfg(feature = "v4_20")]
1130            ffi::GDK_PAD_DIAL => Self::PadDial,
1131            value => Self::__Unknown(value),
1132        }
1133    }
1134}
1135
1136impl StaticType for EventType {
1137    #[inline]
1138    #[doc(alias = "gdk_event_type_get_type")]
1139    fn static_type() -> glib::Type {
1140        unsafe { from_glib(ffi::gdk_event_type_get_type()) }
1141    }
1142}
1143
1144impl glib::HasParamSpec for EventType {
1145    type ParamSpec = glib::ParamSpecEnum;
1146    type SetValue = Self;
1147    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1148
1149    fn param_spec_builder() -> Self::BuilderFn {
1150        Self::ParamSpec::builder_with_default
1151    }
1152}
1153
1154impl glib::value::ValueType for EventType {
1155    type Type = Self;
1156}
1157
1158unsafe impl<'a> glib::value::FromValue<'a> for EventType {
1159    type Checker = glib::value::GenericValueTypeChecker<Self>;
1160
1161    #[inline]
1162    unsafe fn from_value(value: &'a glib::Value) -> Self {
1163        skip_assert_initialized!();
1164        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
1165    }
1166}
1167
1168impl ToValue for EventType {
1169    #[inline]
1170    fn to_value(&self) -> glib::Value {
1171        let mut value = glib::Value::for_value_type::<Self>();
1172        unsafe {
1173            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1174        }
1175        value
1176    }
1177
1178    #[inline]
1179    fn value_type(&self) -> glib::Type {
1180        Self::static_type()
1181    }
1182}
1183
1184impl From<EventType> for glib::Value {
1185    #[inline]
1186    fn from(v: EventType) -> Self {
1187        skip_assert_initialized!();
1188        ToValue::to_value(&v)
1189    }
1190}
1191
1192#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1193#[non_exhaustive]
1194#[doc(alias = "GdkFullscreenMode")]
1195pub enum FullscreenMode {
1196    #[doc(alias = "GDK_FULLSCREEN_ON_CURRENT_MONITOR")]
1197    CurrentMonitor,
1198    #[doc(alias = "GDK_FULLSCREEN_ON_ALL_MONITORS")]
1199    AllMonitors,
1200    #[doc(hidden)]
1201    __Unknown(i32),
1202}
1203
1204#[doc(hidden)]
1205impl IntoGlib for FullscreenMode {
1206    type GlibType = ffi::GdkFullscreenMode;
1207
1208    #[inline]
1209    fn into_glib(self) -> ffi::GdkFullscreenMode {
1210        match self {
1211            Self::CurrentMonitor => ffi::GDK_FULLSCREEN_ON_CURRENT_MONITOR,
1212            Self::AllMonitors => ffi::GDK_FULLSCREEN_ON_ALL_MONITORS,
1213            Self::__Unknown(value) => value,
1214        }
1215    }
1216}
1217
1218#[doc(hidden)]
1219impl FromGlib<ffi::GdkFullscreenMode> for FullscreenMode {
1220    #[inline]
1221    unsafe fn from_glib(value: ffi::GdkFullscreenMode) -> Self {
1222        skip_assert_initialized!();
1223
1224        match value {
1225            ffi::GDK_FULLSCREEN_ON_CURRENT_MONITOR => Self::CurrentMonitor,
1226            ffi::GDK_FULLSCREEN_ON_ALL_MONITORS => Self::AllMonitors,
1227            value => Self::__Unknown(value),
1228        }
1229    }
1230}
1231
1232impl StaticType for FullscreenMode {
1233    #[inline]
1234    #[doc(alias = "gdk_fullscreen_mode_get_type")]
1235    fn static_type() -> glib::Type {
1236        unsafe { from_glib(ffi::gdk_fullscreen_mode_get_type()) }
1237    }
1238}
1239
1240impl glib::HasParamSpec for FullscreenMode {
1241    type ParamSpec = glib::ParamSpecEnum;
1242    type SetValue = Self;
1243    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1244
1245    fn param_spec_builder() -> Self::BuilderFn {
1246        Self::ParamSpec::builder_with_default
1247    }
1248}
1249
1250impl glib::value::ValueType for FullscreenMode {
1251    type Type = Self;
1252}
1253
1254unsafe impl<'a> glib::value::FromValue<'a> for FullscreenMode {
1255    type Checker = glib::value::GenericValueTypeChecker<Self>;
1256
1257    #[inline]
1258    unsafe fn from_value(value: &'a glib::Value) -> Self {
1259        skip_assert_initialized!();
1260        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
1261    }
1262}
1263
1264impl ToValue for FullscreenMode {
1265    #[inline]
1266    fn to_value(&self) -> glib::Value {
1267        let mut value = glib::Value::for_value_type::<Self>();
1268        unsafe {
1269            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1270        }
1271        value
1272    }
1273
1274    #[inline]
1275    fn value_type(&self) -> glib::Type {
1276        Self::static_type()
1277    }
1278}
1279
1280impl From<FullscreenMode> for glib::Value {
1281    #[inline]
1282    fn from(v: FullscreenMode) -> Self {
1283        skip_assert_initialized!();
1284        ToValue::to_value(&v)
1285    }
1286}
1287
1288#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1289#[non_exhaustive]
1290#[doc(alias = "GdkGLError")]
1291pub enum GLError {
1292    #[doc(alias = "GDK_GL_ERROR_NOT_AVAILABLE")]
1293    NotAvailable,
1294    #[doc(alias = "GDK_GL_ERROR_UNSUPPORTED_FORMAT")]
1295    UnsupportedFormat,
1296    #[doc(alias = "GDK_GL_ERROR_UNSUPPORTED_PROFILE")]
1297    UnsupportedProfile,
1298    #[doc(alias = "GDK_GL_ERROR_COMPILATION_FAILED")]
1299    CompilationFailed,
1300    #[doc(alias = "GDK_GL_ERROR_LINK_FAILED")]
1301    LinkFailed,
1302    #[doc(hidden)]
1303    __Unknown(i32),
1304}
1305
1306#[doc(hidden)]
1307impl IntoGlib for GLError {
1308    type GlibType = ffi::GdkGLError;
1309
1310    #[inline]
1311    fn into_glib(self) -> ffi::GdkGLError {
1312        match self {
1313            Self::NotAvailable => ffi::GDK_GL_ERROR_NOT_AVAILABLE,
1314            Self::UnsupportedFormat => ffi::GDK_GL_ERROR_UNSUPPORTED_FORMAT,
1315            Self::UnsupportedProfile => ffi::GDK_GL_ERROR_UNSUPPORTED_PROFILE,
1316            Self::CompilationFailed => ffi::GDK_GL_ERROR_COMPILATION_FAILED,
1317            Self::LinkFailed => ffi::GDK_GL_ERROR_LINK_FAILED,
1318            Self::__Unknown(value) => value,
1319        }
1320    }
1321}
1322
1323#[doc(hidden)]
1324impl FromGlib<ffi::GdkGLError> for GLError {
1325    #[inline]
1326    unsafe fn from_glib(value: ffi::GdkGLError) -> Self {
1327        skip_assert_initialized!();
1328
1329        match value {
1330            ffi::GDK_GL_ERROR_NOT_AVAILABLE => Self::NotAvailable,
1331            ffi::GDK_GL_ERROR_UNSUPPORTED_FORMAT => Self::UnsupportedFormat,
1332            ffi::GDK_GL_ERROR_UNSUPPORTED_PROFILE => Self::UnsupportedProfile,
1333            ffi::GDK_GL_ERROR_COMPILATION_FAILED => Self::CompilationFailed,
1334            ffi::GDK_GL_ERROR_LINK_FAILED => Self::LinkFailed,
1335            value => Self::__Unknown(value),
1336        }
1337    }
1338}
1339
1340impl glib::error::ErrorDomain for GLError {
1341    #[inline]
1342    fn domain() -> glib::Quark {
1343        skip_assert_initialized!();
1344
1345        unsafe { from_glib(ffi::gdk_gl_error_quark()) }
1346    }
1347
1348    #[inline]
1349    fn code(self) -> i32 {
1350        self.into_glib()
1351    }
1352
1353    #[inline]
1354    #[allow(clippy::match_single_binding)]
1355    fn from(code: i32) -> Option<Self> {
1356        skip_assert_initialized!();
1357        match unsafe { from_glib(code) } {
1358            value => Some(value),
1359        }
1360    }
1361}
1362
1363impl StaticType for GLError {
1364    #[inline]
1365    #[doc(alias = "gdk_gl_error_get_type")]
1366    fn static_type() -> glib::Type {
1367        unsafe { from_glib(ffi::gdk_gl_error_get_type()) }
1368    }
1369}
1370
1371impl glib::HasParamSpec for GLError {
1372    type ParamSpec = glib::ParamSpecEnum;
1373    type SetValue = Self;
1374    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1375
1376    fn param_spec_builder() -> Self::BuilderFn {
1377        Self::ParamSpec::builder_with_default
1378    }
1379}
1380
1381impl glib::value::ValueType for GLError {
1382    type Type = Self;
1383}
1384
1385unsafe impl<'a> glib::value::FromValue<'a> for GLError {
1386    type Checker = glib::value::GenericValueTypeChecker<Self>;
1387
1388    #[inline]
1389    unsafe fn from_value(value: &'a glib::Value) -> Self {
1390        skip_assert_initialized!();
1391        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
1392    }
1393}
1394
1395impl ToValue for GLError {
1396    #[inline]
1397    fn to_value(&self) -> glib::Value {
1398        let mut value = glib::Value::for_value_type::<Self>();
1399        unsafe {
1400            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1401        }
1402        value
1403    }
1404
1405    #[inline]
1406    fn value_type(&self) -> glib::Type {
1407        Self::static_type()
1408    }
1409}
1410
1411impl From<GLError> for glib::Value {
1412    #[inline]
1413    fn from(v: GLError) -> Self {
1414        skip_assert_initialized!();
1415        ToValue::to_value(&v)
1416    }
1417}
1418
1419#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1420#[non_exhaustive]
1421#[doc(alias = "GdkGravity")]
1422pub enum Gravity {
1423    #[doc(alias = "GDK_GRAVITY_NORTH_WEST")]
1424    NorthWest,
1425    #[doc(alias = "GDK_GRAVITY_NORTH")]
1426    North,
1427    #[doc(alias = "GDK_GRAVITY_NORTH_EAST")]
1428    NorthEast,
1429    #[doc(alias = "GDK_GRAVITY_WEST")]
1430    West,
1431    #[doc(alias = "GDK_GRAVITY_CENTER")]
1432    Center,
1433    #[doc(alias = "GDK_GRAVITY_EAST")]
1434    East,
1435    #[doc(alias = "GDK_GRAVITY_SOUTH_WEST")]
1436    SouthWest,
1437    #[doc(alias = "GDK_GRAVITY_SOUTH")]
1438    South,
1439    #[doc(alias = "GDK_GRAVITY_SOUTH_EAST")]
1440    SouthEast,
1441    #[doc(alias = "GDK_GRAVITY_STATIC")]
1442    Static,
1443    #[doc(hidden)]
1444    __Unknown(i32),
1445}
1446
1447#[doc(hidden)]
1448impl IntoGlib for Gravity {
1449    type GlibType = ffi::GdkGravity;
1450
1451    #[inline]
1452    fn into_glib(self) -> ffi::GdkGravity {
1453        match self {
1454            Self::NorthWest => ffi::GDK_GRAVITY_NORTH_WEST,
1455            Self::North => ffi::GDK_GRAVITY_NORTH,
1456            Self::NorthEast => ffi::GDK_GRAVITY_NORTH_EAST,
1457            Self::West => ffi::GDK_GRAVITY_WEST,
1458            Self::Center => ffi::GDK_GRAVITY_CENTER,
1459            Self::East => ffi::GDK_GRAVITY_EAST,
1460            Self::SouthWest => ffi::GDK_GRAVITY_SOUTH_WEST,
1461            Self::South => ffi::GDK_GRAVITY_SOUTH,
1462            Self::SouthEast => ffi::GDK_GRAVITY_SOUTH_EAST,
1463            Self::Static => ffi::GDK_GRAVITY_STATIC,
1464            Self::__Unknown(value) => value,
1465        }
1466    }
1467}
1468
1469#[doc(hidden)]
1470impl FromGlib<ffi::GdkGravity> for Gravity {
1471    #[inline]
1472    unsafe fn from_glib(value: ffi::GdkGravity) -> Self {
1473        skip_assert_initialized!();
1474
1475        match value {
1476            ffi::GDK_GRAVITY_NORTH_WEST => Self::NorthWest,
1477            ffi::GDK_GRAVITY_NORTH => Self::North,
1478            ffi::GDK_GRAVITY_NORTH_EAST => Self::NorthEast,
1479            ffi::GDK_GRAVITY_WEST => Self::West,
1480            ffi::GDK_GRAVITY_CENTER => Self::Center,
1481            ffi::GDK_GRAVITY_EAST => Self::East,
1482            ffi::GDK_GRAVITY_SOUTH_WEST => Self::SouthWest,
1483            ffi::GDK_GRAVITY_SOUTH => Self::South,
1484            ffi::GDK_GRAVITY_SOUTH_EAST => Self::SouthEast,
1485            ffi::GDK_GRAVITY_STATIC => Self::Static,
1486            value => Self::__Unknown(value),
1487        }
1488    }
1489}
1490
1491impl StaticType for Gravity {
1492    #[inline]
1493    #[doc(alias = "gdk_gravity_get_type")]
1494    fn static_type() -> glib::Type {
1495        unsafe { from_glib(ffi::gdk_gravity_get_type()) }
1496    }
1497}
1498
1499impl glib::HasParamSpec for Gravity {
1500    type ParamSpec = glib::ParamSpecEnum;
1501    type SetValue = Self;
1502    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1503
1504    fn param_spec_builder() -> Self::BuilderFn {
1505        Self::ParamSpec::builder_with_default
1506    }
1507}
1508
1509impl glib::value::ValueType for Gravity {
1510    type Type = Self;
1511}
1512
1513unsafe impl<'a> glib::value::FromValue<'a> for Gravity {
1514    type Checker = glib::value::GenericValueTypeChecker<Self>;
1515
1516    #[inline]
1517    unsafe fn from_value(value: &'a glib::Value) -> Self {
1518        skip_assert_initialized!();
1519        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
1520    }
1521}
1522
1523impl ToValue for Gravity {
1524    #[inline]
1525    fn to_value(&self) -> glib::Value {
1526        let mut value = glib::Value::for_value_type::<Self>();
1527        unsafe {
1528            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1529        }
1530        value
1531    }
1532
1533    #[inline]
1534    fn value_type(&self) -> glib::Type {
1535        Self::static_type()
1536    }
1537}
1538
1539impl From<Gravity> for glib::Value {
1540    #[inline]
1541    fn from(v: Gravity) -> Self {
1542        skip_assert_initialized!();
1543        ToValue::to_value(&v)
1544    }
1545}
1546
1547#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1548#[non_exhaustive]
1549#[doc(alias = "GdkInputSource")]
1550pub enum InputSource {
1551    #[doc(alias = "GDK_SOURCE_MOUSE")]
1552    Mouse,
1553    #[doc(alias = "GDK_SOURCE_PEN")]
1554    Pen,
1555    #[doc(alias = "GDK_SOURCE_KEYBOARD")]
1556    Keyboard,
1557    #[doc(alias = "GDK_SOURCE_TOUCHSCREEN")]
1558    Touchscreen,
1559    #[doc(alias = "GDK_SOURCE_TOUCHPAD")]
1560    Touchpad,
1561    #[doc(alias = "GDK_SOURCE_TRACKPOINT")]
1562    Trackpoint,
1563    #[doc(alias = "GDK_SOURCE_TABLET_PAD")]
1564    TabletPad,
1565    #[doc(hidden)]
1566    __Unknown(i32),
1567}
1568
1569#[doc(hidden)]
1570impl IntoGlib for InputSource {
1571    type GlibType = ffi::GdkInputSource;
1572
1573    #[inline]
1574    fn into_glib(self) -> ffi::GdkInputSource {
1575        match self {
1576            Self::Mouse => ffi::GDK_SOURCE_MOUSE,
1577            Self::Pen => ffi::GDK_SOURCE_PEN,
1578            Self::Keyboard => ffi::GDK_SOURCE_KEYBOARD,
1579            Self::Touchscreen => ffi::GDK_SOURCE_TOUCHSCREEN,
1580            Self::Touchpad => ffi::GDK_SOURCE_TOUCHPAD,
1581            Self::Trackpoint => ffi::GDK_SOURCE_TRACKPOINT,
1582            Self::TabletPad => ffi::GDK_SOURCE_TABLET_PAD,
1583            Self::__Unknown(value) => value,
1584        }
1585    }
1586}
1587
1588#[doc(hidden)]
1589impl FromGlib<ffi::GdkInputSource> for InputSource {
1590    #[inline]
1591    unsafe fn from_glib(value: ffi::GdkInputSource) -> Self {
1592        skip_assert_initialized!();
1593
1594        match value {
1595            ffi::GDK_SOURCE_MOUSE => Self::Mouse,
1596            ffi::GDK_SOURCE_PEN => Self::Pen,
1597            ffi::GDK_SOURCE_KEYBOARD => Self::Keyboard,
1598            ffi::GDK_SOURCE_TOUCHSCREEN => Self::Touchscreen,
1599            ffi::GDK_SOURCE_TOUCHPAD => Self::Touchpad,
1600            ffi::GDK_SOURCE_TRACKPOINT => Self::Trackpoint,
1601            ffi::GDK_SOURCE_TABLET_PAD => Self::TabletPad,
1602            value => Self::__Unknown(value),
1603        }
1604    }
1605}
1606
1607impl StaticType for InputSource {
1608    #[inline]
1609    #[doc(alias = "gdk_input_source_get_type")]
1610    fn static_type() -> glib::Type {
1611        unsafe { from_glib(ffi::gdk_input_source_get_type()) }
1612    }
1613}
1614
1615impl glib::HasParamSpec for InputSource {
1616    type ParamSpec = glib::ParamSpecEnum;
1617    type SetValue = Self;
1618    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1619
1620    fn param_spec_builder() -> Self::BuilderFn {
1621        Self::ParamSpec::builder_with_default
1622    }
1623}
1624
1625impl glib::value::ValueType for InputSource {
1626    type Type = Self;
1627}
1628
1629unsafe impl<'a> glib::value::FromValue<'a> for InputSource {
1630    type Checker = glib::value::GenericValueTypeChecker<Self>;
1631
1632    #[inline]
1633    unsafe fn from_value(value: &'a glib::Value) -> Self {
1634        skip_assert_initialized!();
1635        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
1636    }
1637}
1638
1639impl ToValue for InputSource {
1640    #[inline]
1641    fn to_value(&self) -> glib::Value {
1642        let mut value = glib::Value::for_value_type::<Self>();
1643        unsafe {
1644            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1645        }
1646        value
1647    }
1648
1649    #[inline]
1650    fn value_type(&self) -> glib::Type {
1651        Self::static_type()
1652    }
1653}
1654
1655impl From<InputSource> for glib::Value {
1656    #[inline]
1657    fn from(v: InputSource) -> Self {
1658        skip_assert_initialized!();
1659        ToValue::to_value(&v)
1660    }
1661}
1662
1663#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1664#[non_exhaustive]
1665#[doc(alias = "GdkKeyMatch")]
1666pub enum KeyMatch {
1667    #[doc(alias = "GDK_KEY_MATCH_NONE")]
1668    None,
1669    #[doc(alias = "GDK_KEY_MATCH_PARTIAL")]
1670    Partial,
1671    #[doc(alias = "GDK_KEY_MATCH_EXACT")]
1672    Exact,
1673    #[doc(hidden)]
1674    __Unknown(i32),
1675}
1676
1677#[doc(hidden)]
1678impl IntoGlib for KeyMatch {
1679    type GlibType = ffi::GdkKeyMatch;
1680
1681    #[inline]
1682    fn into_glib(self) -> ffi::GdkKeyMatch {
1683        match self {
1684            Self::None => ffi::GDK_KEY_MATCH_NONE,
1685            Self::Partial => ffi::GDK_KEY_MATCH_PARTIAL,
1686            Self::Exact => ffi::GDK_KEY_MATCH_EXACT,
1687            Self::__Unknown(value) => value,
1688        }
1689    }
1690}
1691
1692#[doc(hidden)]
1693impl FromGlib<ffi::GdkKeyMatch> for KeyMatch {
1694    #[inline]
1695    unsafe fn from_glib(value: ffi::GdkKeyMatch) -> Self {
1696        skip_assert_initialized!();
1697
1698        match value {
1699            ffi::GDK_KEY_MATCH_NONE => Self::None,
1700            ffi::GDK_KEY_MATCH_PARTIAL => Self::Partial,
1701            ffi::GDK_KEY_MATCH_EXACT => Self::Exact,
1702            value => Self::__Unknown(value),
1703        }
1704    }
1705}
1706
1707impl StaticType for KeyMatch {
1708    #[inline]
1709    #[doc(alias = "gdk_key_match_get_type")]
1710    fn static_type() -> glib::Type {
1711        unsafe { from_glib(ffi::gdk_key_match_get_type()) }
1712    }
1713}
1714
1715impl glib::HasParamSpec for KeyMatch {
1716    type ParamSpec = glib::ParamSpecEnum;
1717    type SetValue = Self;
1718    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1719
1720    fn param_spec_builder() -> Self::BuilderFn {
1721        Self::ParamSpec::builder_with_default
1722    }
1723}
1724
1725impl glib::value::ValueType for KeyMatch {
1726    type Type = Self;
1727}
1728
1729unsafe impl<'a> glib::value::FromValue<'a> for KeyMatch {
1730    type Checker = glib::value::GenericValueTypeChecker<Self>;
1731
1732    #[inline]
1733    unsafe fn from_value(value: &'a glib::Value) -> Self {
1734        skip_assert_initialized!();
1735        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
1736    }
1737}
1738
1739impl ToValue for KeyMatch {
1740    #[inline]
1741    fn to_value(&self) -> glib::Value {
1742        let mut value = glib::Value::for_value_type::<Self>();
1743        unsafe {
1744            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1745        }
1746        value
1747    }
1748
1749    #[inline]
1750    fn value_type(&self) -> glib::Type {
1751        Self::static_type()
1752    }
1753}
1754
1755impl From<KeyMatch> for glib::Value {
1756    #[inline]
1757    fn from(v: KeyMatch) -> Self {
1758        skip_assert_initialized!();
1759        ToValue::to_value(&v)
1760    }
1761}
1762
1763#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1764#[non_exhaustive]
1765#[doc(alias = "GdkMemoryFormat")]
1766pub enum MemoryFormat {
1767    #[doc(alias = "GDK_MEMORY_B8G8R8A8_PREMULTIPLIED")]
1768    B8g8r8a8Premultiplied,
1769    #[doc(alias = "GDK_MEMORY_A8R8G8B8_PREMULTIPLIED")]
1770    A8r8g8b8Premultiplied,
1771    #[doc(alias = "GDK_MEMORY_R8G8B8A8_PREMULTIPLIED")]
1772    R8g8b8a8Premultiplied,
1773    #[doc(alias = "GDK_MEMORY_B8G8R8A8")]
1774    B8g8r8a8,
1775    #[doc(alias = "GDK_MEMORY_A8R8G8B8")]
1776    A8r8g8b8,
1777    #[doc(alias = "GDK_MEMORY_R8G8B8A8")]
1778    R8g8b8a8,
1779    #[doc(alias = "GDK_MEMORY_A8B8G8R8")]
1780    A8b8g8r8,
1781    #[doc(alias = "GDK_MEMORY_R8G8B8")]
1782    R8g8b8,
1783    #[doc(alias = "GDK_MEMORY_B8G8R8")]
1784    B8g8r8,
1785    #[cfg(feature = "v4_6")]
1786    #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
1787    #[doc(alias = "GDK_MEMORY_R16G16B16")]
1788    R16g16b16,
1789    #[cfg(feature = "v4_6")]
1790    #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
1791    #[doc(alias = "GDK_MEMORY_R16G16B16A16_PREMULTIPLIED")]
1792    R16g16b16a16Premultiplied,
1793    #[cfg(feature = "v4_6")]
1794    #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
1795    #[doc(alias = "GDK_MEMORY_R16G16B16A16")]
1796    R16g16b16a16,
1797    #[cfg(feature = "v4_6")]
1798    #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
1799    #[doc(alias = "GDK_MEMORY_R16G16B16_FLOAT")]
1800    R16g16b16Float,
1801    #[cfg(feature = "v4_6")]
1802    #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
1803    #[doc(alias = "GDK_MEMORY_R16G16B16A16_FLOAT_PREMULTIPLIED")]
1804    R16g16b16a16FloatPremultiplied,
1805    #[cfg(feature = "v4_6")]
1806    #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
1807    #[doc(alias = "GDK_MEMORY_R16G16B16A16_FLOAT")]
1808    R16g16b16a16Float,
1809    #[cfg(feature = "v4_6")]
1810    #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
1811    #[doc(alias = "GDK_MEMORY_R32G32B32_FLOAT")]
1812    R32g32b32Float,
1813    #[cfg(feature = "v4_6")]
1814    #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
1815    #[doc(alias = "GDK_MEMORY_R32G32B32A32_FLOAT_PREMULTIPLIED")]
1816    R32g32b32a32FloatPremultiplied,
1817    #[cfg(feature = "v4_6")]
1818    #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
1819    #[doc(alias = "GDK_MEMORY_R32G32B32A32_FLOAT")]
1820    R32g32b32a32Float,
1821    #[cfg(feature = "v4_12")]
1822    #[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
1823    #[doc(alias = "GDK_MEMORY_G8A8_PREMULTIPLIED")]
1824    G8a8Premultiplied,
1825    #[cfg(feature = "v4_12")]
1826    #[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
1827    #[doc(alias = "GDK_MEMORY_G8A8")]
1828    G8a8,
1829    #[cfg(feature = "v4_12")]
1830    #[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
1831    #[doc(alias = "GDK_MEMORY_G8")]
1832    G8,
1833    #[cfg(feature = "v4_12")]
1834    #[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
1835    #[doc(alias = "GDK_MEMORY_G16A16_PREMULTIPLIED")]
1836    G16a16Premultiplied,
1837    #[cfg(feature = "v4_12")]
1838    #[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
1839    #[doc(alias = "GDK_MEMORY_G16A16")]
1840    G16a16,
1841    #[cfg(feature = "v4_12")]
1842    #[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
1843    #[doc(alias = "GDK_MEMORY_G16")]
1844    G16,
1845    #[cfg(feature = "v4_12")]
1846    #[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
1847    #[doc(alias = "GDK_MEMORY_A8")]
1848    A8,
1849    #[cfg(feature = "v4_12")]
1850    #[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
1851    #[doc(alias = "GDK_MEMORY_A16")]
1852    A16,
1853    #[cfg(feature = "v4_12")]
1854    #[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
1855    #[doc(alias = "GDK_MEMORY_A16_FLOAT")]
1856    A16Float,
1857    #[cfg(feature = "v4_12")]
1858    #[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
1859    #[doc(alias = "GDK_MEMORY_A32_FLOAT")]
1860    A32Float,
1861    #[cfg(feature = "v4_14")]
1862    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1863    #[doc(alias = "GDK_MEMORY_A8B8G8R8_PREMULTIPLIED")]
1864    A8b8g8r8Premultiplied,
1865    #[cfg(feature = "v4_14")]
1866    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1867    #[doc(alias = "GDK_MEMORY_B8G8R8X8")]
1868    B8g8r8x8,
1869    #[cfg(feature = "v4_14")]
1870    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1871    #[doc(alias = "GDK_MEMORY_X8R8G8B8")]
1872    X8r8g8b8,
1873    #[cfg(feature = "v4_14")]
1874    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1875    #[doc(alias = "GDK_MEMORY_R8G8B8X8")]
1876    R8g8b8x8,
1877    #[cfg(feature = "v4_14")]
1878    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1879    #[doc(alias = "GDK_MEMORY_X8B8G8R8")]
1880    X8b8g8r8,
1881    #[cfg(feature = "v4_20")]
1882    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1883    #[doc(alias = "GDK_MEMORY_G8_B8R8_420")]
1884    G8B8r8420,
1885    #[cfg(feature = "v4_20")]
1886    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1887    #[doc(alias = "GDK_MEMORY_G8_R8B8_420")]
1888    G8R8b8420,
1889    #[cfg(feature = "v4_20")]
1890    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1891    #[doc(alias = "GDK_MEMORY_G8_B8R8_422")]
1892    G8B8r8422,
1893    #[cfg(feature = "v4_20")]
1894    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1895    #[doc(alias = "GDK_MEMORY_G8_R8B8_422")]
1896    G8R8b8422,
1897    #[cfg(feature = "v4_20")]
1898    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1899    #[doc(alias = "GDK_MEMORY_G8_B8R8_444")]
1900    G8B8r8444,
1901    #[cfg(feature = "v4_20")]
1902    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1903    #[doc(alias = "GDK_MEMORY_G8_R8B8_444")]
1904    G8R8b8444,
1905    #[cfg(feature = "v4_20")]
1906    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1907    #[doc(alias = "GDK_MEMORY_G10X6_B10X6R10X6_420")]
1908    G10x6B10x6r10x6420,
1909    #[cfg(feature = "v4_20")]
1910    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1911    #[doc(alias = "GDK_MEMORY_G12X4_B12X4R12X4_420")]
1912    G12x4B12x4r12x4420,
1913    #[cfg(feature = "v4_20")]
1914    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1915    #[doc(alias = "GDK_MEMORY_G16_B16R16_420")]
1916    G16B16r16420,
1917    #[cfg(feature = "v4_20")]
1918    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1919    #[doc(alias = "GDK_MEMORY_G8_B8_R8_410")]
1920    G8B8R8410,
1921    #[cfg(feature = "v4_20")]
1922    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1923    #[doc(alias = "GDK_MEMORY_G8_R8_B8_410")]
1924    G8R8B8410,
1925    #[cfg(feature = "v4_20")]
1926    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1927    #[doc(alias = "GDK_MEMORY_G8_B8_R8_411")]
1928    G8B8R8411,
1929    #[cfg(feature = "v4_20")]
1930    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1931    #[doc(alias = "GDK_MEMORY_G8_R8_B8_411")]
1932    G8R8B8411,
1933    #[cfg(feature = "v4_20")]
1934    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1935    #[doc(alias = "GDK_MEMORY_G8_B8_R8_420")]
1936    G8B8R8420,
1937    #[cfg(feature = "v4_20")]
1938    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1939    #[doc(alias = "GDK_MEMORY_G8_R8_B8_420")]
1940    G8R8B8420,
1941    #[cfg(feature = "v4_20")]
1942    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1943    #[doc(alias = "GDK_MEMORY_G8_B8_R8_422")]
1944    G8B8R8422,
1945    #[cfg(feature = "v4_20")]
1946    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1947    #[doc(alias = "GDK_MEMORY_G8_R8_B8_422")]
1948    G8R8B8422,
1949    #[cfg(feature = "v4_20")]
1950    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1951    #[doc(alias = "GDK_MEMORY_G8_B8_R8_444")]
1952    G8B8R8444,
1953    #[cfg(feature = "v4_20")]
1954    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1955    #[doc(alias = "GDK_MEMORY_G8_R8_B8_444")]
1956    G8R8B8444,
1957    #[cfg(feature = "v4_20")]
1958    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1959    #[doc(alias = "GDK_MEMORY_G8B8G8R8_422")]
1960    G8b8g8r8422,
1961    #[cfg(feature = "v4_20")]
1962    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1963    #[doc(alias = "GDK_MEMORY_G8R8G8B8_422")]
1964    G8r8g8b8422,
1965    #[cfg(feature = "v4_20")]
1966    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1967    #[doc(alias = "GDK_MEMORY_R8G8B8G8_422")]
1968    R8g8b8g8422,
1969    #[cfg(feature = "v4_20")]
1970    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1971    #[doc(alias = "GDK_MEMORY_B8G8R8G8_422")]
1972    B8g8r8g8422,
1973    #[cfg(feature = "v4_20")]
1974    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1975    #[doc(alias = "GDK_MEMORY_X6G10_X6B10_X6R10_420")]
1976    X6g10X6b10X6r10420,
1977    #[cfg(feature = "v4_20")]
1978    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1979    #[doc(alias = "GDK_MEMORY_X6G10_X6B10_X6R10_422")]
1980    X6g10X6b10X6r10422,
1981    #[cfg(feature = "v4_20")]
1982    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1983    #[doc(alias = "GDK_MEMORY_X6G10_X6B10_X6R10_444")]
1984    X6g10X6b10X6r10444,
1985    #[cfg(feature = "v4_20")]
1986    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1987    #[doc(alias = "GDK_MEMORY_X4G12_X4B12_X4R12_420")]
1988    X4g12X4b12X4r12420,
1989    #[cfg(feature = "v4_20")]
1990    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1991    #[doc(alias = "GDK_MEMORY_X4G12_X4B12_X4R12_422")]
1992    X4g12X4b12X4r12422,
1993    #[cfg(feature = "v4_20")]
1994    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1995    #[doc(alias = "GDK_MEMORY_X4G12_X4B12_X4R12_444")]
1996    X4g12X4b12X4r12444,
1997    #[cfg(feature = "v4_20")]
1998    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1999    #[doc(alias = "GDK_MEMORY_G16_B16_R16_420")]
2000    G16B16R16420,
2001    #[cfg(feature = "v4_20")]
2002    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
2003    #[doc(alias = "GDK_MEMORY_G16_B16_R16_422")]
2004    G16B16R16422,
2005    #[cfg(feature = "v4_20")]
2006    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
2007    #[doc(alias = "GDK_MEMORY_G16_B16_R16_444")]
2008    G16B16R16444,
2009    #[cfg(feature = "v4_24")]
2010    #[cfg_attr(docsrs, doc(cfg(feature = "v4_24")))]
2011    #[doc(alias = "GDK_MEMORY_ARGB2101010_PREMULTIPLIED")]
2012    Argb2101010Premultiplied,
2013    #[cfg(feature = "v4_24")]
2014    #[cfg_attr(docsrs, doc(cfg(feature = "v4_24")))]
2015    #[doc(alias = "GDK_MEMORY_ARGB2101010")]
2016    Argb2101010,
2017    #[cfg(feature = "v4_24")]
2018    #[cfg_attr(docsrs, doc(cfg(feature = "v4_24")))]
2019    #[doc(alias = "GDK_MEMORY_XRGB2101010")]
2020    Xrgb2101010,
2021    #[doc(alias = "GDK_MEMORY_ABGR2101010_PREMULTIPLIED")]
2022    Abgr2101010Premultiplied,
2023    #[cfg(feature = "v4_24")]
2024    #[cfg_attr(docsrs, doc(cfg(feature = "v4_24")))]
2025    #[doc(alias = "GDK_MEMORY_ABGR2101010")]
2026    Abgr2101010,
2027    #[cfg(feature = "v4_24")]
2028    #[cfg_attr(docsrs, doc(cfg(feature = "v4_24")))]
2029    #[doc(alias = "GDK_MEMORY_XBGR2101010")]
2030    Xbgr2101010,
2031    #[doc(hidden)]
2032    __Unknown(i32),
2033}
2034
2035#[doc(hidden)]
2036impl IntoGlib for MemoryFormat {
2037    type GlibType = ffi::GdkMemoryFormat;
2038
2039    fn into_glib(self) -> ffi::GdkMemoryFormat {
2040        match self {
2041            Self::B8g8r8a8Premultiplied => ffi::GDK_MEMORY_B8G8R8A8_PREMULTIPLIED,
2042            Self::A8r8g8b8Premultiplied => ffi::GDK_MEMORY_A8R8G8B8_PREMULTIPLIED,
2043            Self::R8g8b8a8Premultiplied => ffi::GDK_MEMORY_R8G8B8A8_PREMULTIPLIED,
2044            Self::B8g8r8a8 => ffi::GDK_MEMORY_B8G8R8A8,
2045            Self::A8r8g8b8 => ffi::GDK_MEMORY_A8R8G8B8,
2046            Self::R8g8b8a8 => ffi::GDK_MEMORY_R8G8B8A8,
2047            Self::A8b8g8r8 => ffi::GDK_MEMORY_A8B8G8R8,
2048            Self::R8g8b8 => ffi::GDK_MEMORY_R8G8B8,
2049            Self::B8g8r8 => ffi::GDK_MEMORY_B8G8R8,
2050            #[cfg(feature = "v4_6")]
2051            Self::R16g16b16 => ffi::GDK_MEMORY_R16G16B16,
2052            #[cfg(feature = "v4_6")]
2053            Self::R16g16b16a16Premultiplied => ffi::GDK_MEMORY_R16G16B16A16_PREMULTIPLIED,
2054            #[cfg(feature = "v4_6")]
2055            Self::R16g16b16a16 => ffi::GDK_MEMORY_R16G16B16A16,
2056            #[cfg(feature = "v4_6")]
2057            Self::R16g16b16Float => ffi::GDK_MEMORY_R16G16B16_FLOAT,
2058            #[cfg(feature = "v4_6")]
2059            Self::R16g16b16a16FloatPremultiplied => {
2060                ffi::GDK_MEMORY_R16G16B16A16_FLOAT_PREMULTIPLIED
2061            }
2062            #[cfg(feature = "v4_6")]
2063            Self::R16g16b16a16Float => ffi::GDK_MEMORY_R16G16B16A16_FLOAT,
2064            #[cfg(feature = "v4_6")]
2065            Self::R32g32b32Float => ffi::GDK_MEMORY_R32G32B32_FLOAT,
2066            #[cfg(feature = "v4_6")]
2067            Self::R32g32b32a32FloatPremultiplied => {
2068                ffi::GDK_MEMORY_R32G32B32A32_FLOAT_PREMULTIPLIED
2069            }
2070            #[cfg(feature = "v4_6")]
2071            Self::R32g32b32a32Float => ffi::GDK_MEMORY_R32G32B32A32_FLOAT,
2072            #[cfg(feature = "v4_12")]
2073            Self::G8a8Premultiplied => ffi::GDK_MEMORY_G8A8_PREMULTIPLIED,
2074            #[cfg(feature = "v4_12")]
2075            Self::G8a8 => ffi::GDK_MEMORY_G8A8,
2076            #[cfg(feature = "v4_12")]
2077            Self::G8 => ffi::GDK_MEMORY_G8,
2078            #[cfg(feature = "v4_12")]
2079            Self::G16a16Premultiplied => ffi::GDK_MEMORY_G16A16_PREMULTIPLIED,
2080            #[cfg(feature = "v4_12")]
2081            Self::G16a16 => ffi::GDK_MEMORY_G16A16,
2082            #[cfg(feature = "v4_12")]
2083            Self::G16 => ffi::GDK_MEMORY_G16,
2084            #[cfg(feature = "v4_12")]
2085            Self::A8 => ffi::GDK_MEMORY_A8,
2086            #[cfg(feature = "v4_12")]
2087            Self::A16 => ffi::GDK_MEMORY_A16,
2088            #[cfg(feature = "v4_12")]
2089            Self::A16Float => ffi::GDK_MEMORY_A16_FLOAT,
2090            #[cfg(feature = "v4_12")]
2091            Self::A32Float => ffi::GDK_MEMORY_A32_FLOAT,
2092            #[cfg(feature = "v4_14")]
2093            Self::A8b8g8r8Premultiplied => ffi::GDK_MEMORY_A8B8G8R8_PREMULTIPLIED,
2094            #[cfg(feature = "v4_14")]
2095            Self::B8g8r8x8 => ffi::GDK_MEMORY_B8G8R8X8,
2096            #[cfg(feature = "v4_14")]
2097            Self::X8r8g8b8 => ffi::GDK_MEMORY_X8R8G8B8,
2098            #[cfg(feature = "v4_14")]
2099            Self::R8g8b8x8 => ffi::GDK_MEMORY_R8G8B8X8,
2100            #[cfg(feature = "v4_14")]
2101            Self::X8b8g8r8 => ffi::GDK_MEMORY_X8B8G8R8,
2102            #[cfg(feature = "v4_20")]
2103            Self::G8B8r8420 => ffi::GDK_MEMORY_G8_B8R8_420,
2104            #[cfg(feature = "v4_20")]
2105            Self::G8R8b8420 => ffi::GDK_MEMORY_G8_R8B8_420,
2106            #[cfg(feature = "v4_20")]
2107            Self::G8B8r8422 => ffi::GDK_MEMORY_G8_B8R8_422,
2108            #[cfg(feature = "v4_20")]
2109            Self::G8R8b8422 => ffi::GDK_MEMORY_G8_R8B8_422,
2110            #[cfg(feature = "v4_20")]
2111            Self::G8B8r8444 => ffi::GDK_MEMORY_G8_B8R8_444,
2112            #[cfg(feature = "v4_20")]
2113            Self::G8R8b8444 => ffi::GDK_MEMORY_G8_R8B8_444,
2114            #[cfg(feature = "v4_20")]
2115            Self::G10x6B10x6r10x6420 => ffi::GDK_MEMORY_G10X6_B10X6R10X6_420,
2116            #[cfg(feature = "v4_20")]
2117            Self::G12x4B12x4r12x4420 => ffi::GDK_MEMORY_G12X4_B12X4R12X4_420,
2118            #[cfg(feature = "v4_20")]
2119            Self::G16B16r16420 => ffi::GDK_MEMORY_G16_B16R16_420,
2120            #[cfg(feature = "v4_20")]
2121            Self::G8B8R8410 => ffi::GDK_MEMORY_G8_B8_R8_410,
2122            #[cfg(feature = "v4_20")]
2123            Self::G8R8B8410 => ffi::GDK_MEMORY_G8_R8_B8_410,
2124            #[cfg(feature = "v4_20")]
2125            Self::G8B8R8411 => ffi::GDK_MEMORY_G8_B8_R8_411,
2126            #[cfg(feature = "v4_20")]
2127            Self::G8R8B8411 => ffi::GDK_MEMORY_G8_R8_B8_411,
2128            #[cfg(feature = "v4_20")]
2129            Self::G8B8R8420 => ffi::GDK_MEMORY_G8_B8_R8_420,
2130            #[cfg(feature = "v4_20")]
2131            Self::G8R8B8420 => ffi::GDK_MEMORY_G8_R8_B8_420,
2132            #[cfg(feature = "v4_20")]
2133            Self::G8B8R8422 => ffi::GDK_MEMORY_G8_B8_R8_422,
2134            #[cfg(feature = "v4_20")]
2135            Self::G8R8B8422 => ffi::GDK_MEMORY_G8_R8_B8_422,
2136            #[cfg(feature = "v4_20")]
2137            Self::G8B8R8444 => ffi::GDK_MEMORY_G8_B8_R8_444,
2138            #[cfg(feature = "v4_20")]
2139            Self::G8R8B8444 => ffi::GDK_MEMORY_G8_R8_B8_444,
2140            #[cfg(feature = "v4_20")]
2141            Self::G8b8g8r8422 => ffi::GDK_MEMORY_G8B8G8R8_422,
2142            #[cfg(feature = "v4_20")]
2143            Self::G8r8g8b8422 => ffi::GDK_MEMORY_G8R8G8B8_422,
2144            #[cfg(feature = "v4_20")]
2145            Self::R8g8b8g8422 => ffi::GDK_MEMORY_R8G8B8G8_422,
2146            #[cfg(feature = "v4_20")]
2147            Self::B8g8r8g8422 => ffi::GDK_MEMORY_B8G8R8G8_422,
2148            #[cfg(feature = "v4_20")]
2149            Self::X6g10X6b10X6r10420 => ffi::GDK_MEMORY_X6G10_X6B10_X6R10_420,
2150            #[cfg(feature = "v4_20")]
2151            Self::X6g10X6b10X6r10422 => ffi::GDK_MEMORY_X6G10_X6B10_X6R10_422,
2152            #[cfg(feature = "v4_20")]
2153            Self::X6g10X6b10X6r10444 => ffi::GDK_MEMORY_X6G10_X6B10_X6R10_444,
2154            #[cfg(feature = "v4_20")]
2155            Self::X4g12X4b12X4r12420 => ffi::GDK_MEMORY_X4G12_X4B12_X4R12_420,
2156            #[cfg(feature = "v4_20")]
2157            Self::X4g12X4b12X4r12422 => ffi::GDK_MEMORY_X4G12_X4B12_X4R12_422,
2158            #[cfg(feature = "v4_20")]
2159            Self::X4g12X4b12X4r12444 => ffi::GDK_MEMORY_X4G12_X4B12_X4R12_444,
2160            #[cfg(feature = "v4_20")]
2161            Self::G16B16R16420 => ffi::GDK_MEMORY_G16_B16_R16_420,
2162            #[cfg(feature = "v4_20")]
2163            Self::G16B16R16422 => ffi::GDK_MEMORY_G16_B16_R16_422,
2164            #[cfg(feature = "v4_20")]
2165            Self::G16B16R16444 => ffi::GDK_MEMORY_G16_B16_R16_444,
2166            #[cfg(feature = "v4_24")]
2167            Self::Argb2101010Premultiplied => ffi::GDK_MEMORY_ARGB2101010_PREMULTIPLIED,
2168            #[cfg(feature = "v4_24")]
2169            Self::Argb2101010 => ffi::GDK_MEMORY_ARGB2101010,
2170            #[cfg(feature = "v4_24")]
2171            Self::Xrgb2101010 => ffi::GDK_MEMORY_XRGB2101010,
2172            Self::Abgr2101010Premultiplied => ffi::GDK_MEMORY_ABGR2101010_PREMULTIPLIED,
2173            #[cfg(feature = "v4_24")]
2174            Self::Abgr2101010 => ffi::GDK_MEMORY_ABGR2101010,
2175            #[cfg(feature = "v4_24")]
2176            Self::Xbgr2101010 => ffi::GDK_MEMORY_XBGR2101010,
2177            Self::__Unknown(value) => value,
2178        }
2179    }
2180}
2181
2182#[doc(hidden)]
2183impl FromGlib<ffi::GdkMemoryFormat> for MemoryFormat {
2184    unsafe fn from_glib(value: ffi::GdkMemoryFormat) -> Self {
2185        skip_assert_initialized!();
2186
2187        match value {
2188            ffi::GDK_MEMORY_B8G8R8A8_PREMULTIPLIED => Self::B8g8r8a8Premultiplied,
2189            ffi::GDK_MEMORY_A8R8G8B8_PREMULTIPLIED => Self::A8r8g8b8Premultiplied,
2190            ffi::GDK_MEMORY_R8G8B8A8_PREMULTIPLIED => Self::R8g8b8a8Premultiplied,
2191            ffi::GDK_MEMORY_B8G8R8A8 => Self::B8g8r8a8,
2192            ffi::GDK_MEMORY_A8R8G8B8 => Self::A8r8g8b8,
2193            ffi::GDK_MEMORY_R8G8B8A8 => Self::R8g8b8a8,
2194            ffi::GDK_MEMORY_A8B8G8R8 => Self::A8b8g8r8,
2195            ffi::GDK_MEMORY_R8G8B8 => Self::R8g8b8,
2196            ffi::GDK_MEMORY_B8G8R8 => Self::B8g8r8,
2197            #[cfg(feature = "v4_6")]
2198            ffi::GDK_MEMORY_R16G16B16 => Self::R16g16b16,
2199            #[cfg(feature = "v4_6")]
2200            ffi::GDK_MEMORY_R16G16B16A16_PREMULTIPLIED => Self::R16g16b16a16Premultiplied,
2201            #[cfg(feature = "v4_6")]
2202            ffi::GDK_MEMORY_R16G16B16A16 => Self::R16g16b16a16,
2203            #[cfg(feature = "v4_6")]
2204            ffi::GDK_MEMORY_R16G16B16_FLOAT => Self::R16g16b16Float,
2205            #[cfg(feature = "v4_6")]
2206            ffi::GDK_MEMORY_R16G16B16A16_FLOAT_PREMULTIPLIED => {
2207                Self::R16g16b16a16FloatPremultiplied
2208            }
2209            #[cfg(feature = "v4_6")]
2210            ffi::GDK_MEMORY_R16G16B16A16_FLOAT => Self::R16g16b16a16Float,
2211            #[cfg(feature = "v4_6")]
2212            ffi::GDK_MEMORY_R32G32B32_FLOAT => Self::R32g32b32Float,
2213            #[cfg(feature = "v4_6")]
2214            ffi::GDK_MEMORY_R32G32B32A32_FLOAT_PREMULTIPLIED => {
2215                Self::R32g32b32a32FloatPremultiplied
2216            }
2217            #[cfg(feature = "v4_6")]
2218            ffi::GDK_MEMORY_R32G32B32A32_FLOAT => Self::R32g32b32a32Float,
2219            #[cfg(feature = "v4_12")]
2220            ffi::GDK_MEMORY_G8A8_PREMULTIPLIED => Self::G8a8Premultiplied,
2221            #[cfg(feature = "v4_12")]
2222            ffi::GDK_MEMORY_G8A8 => Self::G8a8,
2223            #[cfg(feature = "v4_12")]
2224            ffi::GDK_MEMORY_G8 => Self::G8,
2225            #[cfg(feature = "v4_12")]
2226            ffi::GDK_MEMORY_G16A16_PREMULTIPLIED => Self::G16a16Premultiplied,
2227            #[cfg(feature = "v4_12")]
2228            ffi::GDK_MEMORY_G16A16 => Self::G16a16,
2229            #[cfg(feature = "v4_12")]
2230            ffi::GDK_MEMORY_G16 => Self::G16,
2231            #[cfg(feature = "v4_12")]
2232            ffi::GDK_MEMORY_A8 => Self::A8,
2233            #[cfg(feature = "v4_12")]
2234            ffi::GDK_MEMORY_A16 => Self::A16,
2235            #[cfg(feature = "v4_12")]
2236            ffi::GDK_MEMORY_A16_FLOAT => Self::A16Float,
2237            #[cfg(feature = "v4_12")]
2238            ffi::GDK_MEMORY_A32_FLOAT => Self::A32Float,
2239            #[cfg(feature = "v4_14")]
2240            ffi::GDK_MEMORY_A8B8G8R8_PREMULTIPLIED => Self::A8b8g8r8Premultiplied,
2241            #[cfg(feature = "v4_14")]
2242            ffi::GDK_MEMORY_B8G8R8X8 => Self::B8g8r8x8,
2243            #[cfg(feature = "v4_14")]
2244            ffi::GDK_MEMORY_X8R8G8B8 => Self::X8r8g8b8,
2245            #[cfg(feature = "v4_14")]
2246            ffi::GDK_MEMORY_R8G8B8X8 => Self::R8g8b8x8,
2247            #[cfg(feature = "v4_14")]
2248            ffi::GDK_MEMORY_X8B8G8R8 => Self::X8b8g8r8,
2249            #[cfg(feature = "v4_20")]
2250            ffi::GDK_MEMORY_G8_B8R8_420 => Self::G8B8r8420,
2251            #[cfg(feature = "v4_20")]
2252            ffi::GDK_MEMORY_G8_R8B8_420 => Self::G8R8b8420,
2253            #[cfg(feature = "v4_20")]
2254            ffi::GDK_MEMORY_G8_B8R8_422 => Self::G8B8r8422,
2255            #[cfg(feature = "v4_20")]
2256            ffi::GDK_MEMORY_G8_R8B8_422 => Self::G8R8b8422,
2257            #[cfg(feature = "v4_20")]
2258            ffi::GDK_MEMORY_G8_B8R8_444 => Self::G8B8r8444,
2259            #[cfg(feature = "v4_20")]
2260            ffi::GDK_MEMORY_G8_R8B8_444 => Self::G8R8b8444,
2261            #[cfg(feature = "v4_20")]
2262            ffi::GDK_MEMORY_G10X6_B10X6R10X6_420 => Self::G10x6B10x6r10x6420,
2263            #[cfg(feature = "v4_20")]
2264            ffi::GDK_MEMORY_G12X4_B12X4R12X4_420 => Self::G12x4B12x4r12x4420,
2265            #[cfg(feature = "v4_20")]
2266            ffi::GDK_MEMORY_G16_B16R16_420 => Self::G16B16r16420,
2267            #[cfg(feature = "v4_20")]
2268            ffi::GDK_MEMORY_G8_B8_R8_410 => Self::G8B8R8410,
2269            #[cfg(feature = "v4_20")]
2270            ffi::GDK_MEMORY_G8_R8_B8_410 => Self::G8R8B8410,
2271            #[cfg(feature = "v4_20")]
2272            ffi::GDK_MEMORY_G8_B8_R8_411 => Self::G8B8R8411,
2273            #[cfg(feature = "v4_20")]
2274            ffi::GDK_MEMORY_G8_R8_B8_411 => Self::G8R8B8411,
2275            #[cfg(feature = "v4_20")]
2276            ffi::GDK_MEMORY_G8_B8_R8_420 => Self::G8B8R8420,
2277            #[cfg(feature = "v4_20")]
2278            ffi::GDK_MEMORY_G8_R8_B8_420 => Self::G8R8B8420,
2279            #[cfg(feature = "v4_20")]
2280            ffi::GDK_MEMORY_G8_B8_R8_422 => Self::G8B8R8422,
2281            #[cfg(feature = "v4_20")]
2282            ffi::GDK_MEMORY_G8_R8_B8_422 => Self::G8R8B8422,
2283            #[cfg(feature = "v4_20")]
2284            ffi::GDK_MEMORY_G8_B8_R8_444 => Self::G8B8R8444,
2285            #[cfg(feature = "v4_20")]
2286            ffi::GDK_MEMORY_G8_R8_B8_444 => Self::G8R8B8444,
2287            #[cfg(feature = "v4_20")]
2288            ffi::GDK_MEMORY_G8B8G8R8_422 => Self::G8b8g8r8422,
2289            #[cfg(feature = "v4_20")]
2290            ffi::GDK_MEMORY_G8R8G8B8_422 => Self::G8r8g8b8422,
2291            #[cfg(feature = "v4_20")]
2292            ffi::GDK_MEMORY_R8G8B8G8_422 => Self::R8g8b8g8422,
2293            #[cfg(feature = "v4_20")]
2294            ffi::GDK_MEMORY_B8G8R8G8_422 => Self::B8g8r8g8422,
2295            #[cfg(feature = "v4_20")]
2296            ffi::GDK_MEMORY_X6G10_X6B10_X6R10_420 => Self::X6g10X6b10X6r10420,
2297            #[cfg(feature = "v4_20")]
2298            ffi::GDK_MEMORY_X6G10_X6B10_X6R10_422 => Self::X6g10X6b10X6r10422,
2299            #[cfg(feature = "v4_20")]
2300            ffi::GDK_MEMORY_X6G10_X6B10_X6R10_444 => Self::X6g10X6b10X6r10444,
2301            #[cfg(feature = "v4_20")]
2302            ffi::GDK_MEMORY_X4G12_X4B12_X4R12_420 => Self::X4g12X4b12X4r12420,
2303            #[cfg(feature = "v4_20")]
2304            ffi::GDK_MEMORY_X4G12_X4B12_X4R12_422 => Self::X4g12X4b12X4r12422,
2305            #[cfg(feature = "v4_20")]
2306            ffi::GDK_MEMORY_X4G12_X4B12_X4R12_444 => Self::X4g12X4b12X4r12444,
2307            #[cfg(feature = "v4_20")]
2308            ffi::GDK_MEMORY_G16_B16_R16_420 => Self::G16B16R16420,
2309            #[cfg(feature = "v4_20")]
2310            ffi::GDK_MEMORY_G16_B16_R16_422 => Self::G16B16R16422,
2311            #[cfg(feature = "v4_20")]
2312            ffi::GDK_MEMORY_G16_B16_R16_444 => Self::G16B16R16444,
2313            #[cfg(feature = "v4_24")]
2314            ffi::GDK_MEMORY_ARGB2101010_PREMULTIPLIED => Self::Argb2101010Premultiplied,
2315            #[cfg(feature = "v4_24")]
2316            ffi::GDK_MEMORY_ARGB2101010 => Self::Argb2101010,
2317            #[cfg(feature = "v4_24")]
2318            ffi::GDK_MEMORY_XRGB2101010 => Self::Xrgb2101010,
2319            ffi::GDK_MEMORY_ABGR2101010_PREMULTIPLIED => Self::Abgr2101010Premultiplied,
2320            #[cfg(feature = "v4_24")]
2321            ffi::GDK_MEMORY_ABGR2101010 => Self::Abgr2101010,
2322            #[cfg(feature = "v4_24")]
2323            ffi::GDK_MEMORY_XBGR2101010 => Self::Xbgr2101010,
2324            value => Self::__Unknown(value),
2325        }
2326    }
2327}
2328
2329impl StaticType for MemoryFormat {
2330    #[inline]
2331    #[doc(alias = "gdk_memory_format_get_type")]
2332    fn static_type() -> glib::Type {
2333        unsafe { from_glib(ffi::gdk_memory_format_get_type()) }
2334    }
2335}
2336
2337impl glib::HasParamSpec for MemoryFormat {
2338    type ParamSpec = glib::ParamSpecEnum;
2339    type SetValue = Self;
2340    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2341
2342    fn param_spec_builder() -> Self::BuilderFn {
2343        Self::ParamSpec::builder_with_default
2344    }
2345}
2346
2347impl glib::value::ValueType for MemoryFormat {
2348    type Type = Self;
2349}
2350
2351unsafe impl<'a> glib::value::FromValue<'a> for MemoryFormat {
2352    type Checker = glib::value::GenericValueTypeChecker<Self>;
2353
2354    #[inline]
2355    unsafe fn from_value(value: &'a glib::Value) -> Self {
2356        skip_assert_initialized!();
2357        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
2358    }
2359}
2360
2361impl ToValue for MemoryFormat {
2362    #[inline]
2363    fn to_value(&self) -> glib::Value {
2364        let mut value = glib::Value::for_value_type::<Self>();
2365        unsafe {
2366            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2367        }
2368        value
2369    }
2370
2371    #[inline]
2372    fn value_type(&self) -> glib::Type {
2373        Self::static_type()
2374    }
2375}
2376
2377impl From<MemoryFormat> for glib::Value {
2378    #[inline]
2379    fn from(v: MemoryFormat) -> Self {
2380        skip_assert_initialized!();
2381        ToValue::to_value(&v)
2382    }
2383}
2384
2385#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2386#[non_exhaustive]
2387#[doc(alias = "GdkNotifyType")]
2388pub enum NotifyType {
2389    #[doc(alias = "GDK_NOTIFY_ANCESTOR")]
2390    Ancestor,
2391    #[doc(alias = "GDK_NOTIFY_VIRTUAL")]
2392    Virtual,
2393    #[doc(alias = "GDK_NOTIFY_INFERIOR")]
2394    Inferior,
2395    #[doc(alias = "GDK_NOTIFY_NONLINEAR")]
2396    Nonlinear,
2397    #[doc(alias = "GDK_NOTIFY_NONLINEAR_VIRTUAL")]
2398    NonlinearVirtual,
2399    #[doc(alias = "GDK_NOTIFY_UNKNOWN")]
2400    Unknown,
2401    #[doc(hidden)]
2402    __Unknown(i32),
2403}
2404
2405#[doc(hidden)]
2406impl IntoGlib for NotifyType {
2407    type GlibType = ffi::GdkNotifyType;
2408
2409    #[inline]
2410    fn into_glib(self) -> ffi::GdkNotifyType {
2411        match self {
2412            Self::Ancestor => ffi::GDK_NOTIFY_ANCESTOR,
2413            Self::Virtual => ffi::GDK_NOTIFY_VIRTUAL,
2414            Self::Inferior => ffi::GDK_NOTIFY_INFERIOR,
2415            Self::Nonlinear => ffi::GDK_NOTIFY_NONLINEAR,
2416            Self::NonlinearVirtual => ffi::GDK_NOTIFY_NONLINEAR_VIRTUAL,
2417            Self::Unknown => ffi::GDK_NOTIFY_UNKNOWN,
2418            Self::__Unknown(value) => value,
2419        }
2420    }
2421}
2422
2423#[doc(hidden)]
2424impl FromGlib<ffi::GdkNotifyType> for NotifyType {
2425    #[inline]
2426    unsafe fn from_glib(value: ffi::GdkNotifyType) -> Self {
2427        skip_assert_initialized!();
2428
2429        match value {
2430            ffi::GDK_NOTIFY_ANCESTOR => Self::Ancestor,
2431            ffi::GDK_NOTIFY_VIRTUAL => Self::Virtual,
2432            ffi::GDK_NOTIFY_INFERIOR => Self::Inferior,
2433            ffi::GDK_NOTIFY_NONLINEAR => Self::Nonlinear,
2434            ffi::GDK_NOTIFY_NONLINEAR_VIRTUAL => Self::NonlinearVirtual,
2435            ffi::GDK_NOTIFY_UNKNOWN => Self::Unknown,
2436            value => Self::__Unknown(value),
2437        }
2438    }
2439}
2440
2441impl StaticType for NotifyType {
2442    #[inline]
2443    #[doc(alias = "gdk_notify_type_get_type")]
2444    fn static_type() -> glib::Type {
2445        unsafe { from_glib(ffi::gdk_notify_type_get_type()) }
2446    }
2447}
2448
2449impl glib::HasParamSpec for NotifyType {
2450    type ParamSpec = glib::ParamSpecEnum;
2451    type SetValue = Self;
2452    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2453
2454    fn param_spec_builder() -> Self::BuilderFn {
2455        Self::ParamSpec::builder_with_default
2456    }
2457}
2458
2459impl glib::value::ValueType for NotifyType {
2460    type Type = Self;
2461}
2462
2463unsafe impl<'a> glib::value::FromValue<'a> for NotifyType {
2464    type Checker = glib::value::GenericValueTypeChecker<Self>;
2465
2466    #[inline]
2467    unsafe fn from_value(value: &'a glib::Value) -> Self {
2468        skip_assert_initialized!();
2469        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
2470    }
2471}
2472
2473impl ToValue for NotifyType {
2474    #[inline]
2475    fn to_value(&self) -> glib::Value {
2476        let mut value = glib::Value::for_value_type::<Self>();
2477        unsafe {
2478            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2479        }
2480        value
2481    }
2482
2483    #[inline]
2484    fn value_type(&self) -> glib::Type {
2485        Self::static_type()
2486    }
2487}
2488
2489impl From<NotifyType> for glib::Value {
2490    #[inline]
2491    fn from(v: NotifyType) -> Self {
2492        skip_assert_initialized!();
2493        ToValue::to_value(&v)
2494    }
2495}
2496
2497#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2498#[non_exhaustive]
2499#[doc(alias = "GdkScrollDirection")]
2500pub enum ScrollDirection {
2501    #[doc(alias = "GDK_SCROLL_UP")]
2502    Up,
2503    #[doc(alias = "GDK_SCROLL_DOWN")]
2504    Down,
2505    #[doc(alias = "GDK_SCROLL_LEFT")]
2506    Left,
2507    #[doc(alias = "GDK_SCROLL_RIGHT")]
2508    Right,
2509    #[doc(alias = "GDK_SCROLL_SMOOTH")]
2510    Smooth,
2511    #[doc(hidden)]
2512    __Unknown(i32),
2513}
2514
2515#[doc(hidden)]
2516impl IntoGlib for ScrollDirection {
2517    type GlibType = ffi::GdkScrollDirection;
2518
2519    #[inline]
2520    fn into_glib(self) -> ffi::GdkScrollDirection {
2521        match self {
2522            Self::Up => ffi::GDK_SCROLL_UP,
2523            Self::Down => ffi::GDK_SCROLL_DOWN,
2524            Self::Left => ffi::GDK_SCROLL_LEFT,
2525            Self::Right => ffi::GDK_SCROLL_RIGHT,
2526            Self::Smooth => ffi::GDK_SCROLL_SMOOTH,
2527            Self::__Unknown(value) => value,
2528        }
2529    }
2530}
2531
2532#[doc(hidden)]
2533impl FromGlib<ffi::GdkScrollDirection> for ScrollDirection {
2534    #[inline]
2535    unsafe fn from_glib(value: ffi::GdkScrollDirection) -> Self {
2536        skip_assert_initialized!();
2537
2538        match value {
2539            ffi::GDK_SCROLL_UP => Self::Up,
2540            ffi::GDK_SCROLL_DOWN => Self::Down,
2541            ffi::GDK_SCROLL_LEFT => Self::Left,
2542            ffi::GDK_SCROLL_RIGHT => Self::Right,
2543            ffi::GDK_SCROLL_SMOOTH => Self::Smooth,
2544            value => Self::__Unknown(value),
2545        }
2546    }
2547}
2548
2549impl StaticType for ScrollDirection {
2550    #[inline]
2551    #[doc(alias = "gdk_scroll_direction_get_type")]
2552    fn static_type() -> glib::Type {
2553        unsafe { from_glib(ffi::gdk_scroll_direction_get_type()) }
2554    }
2555}
2556
2557impl glib::HasParamSpec for ScrollDirection {
2558    type ParamSpec = glib::ParamSpecEnum;
2559    type SetValue = Self;
2560    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2561
2562    fn param_spec_builder() -> Self::BuilderFn {
2563        Self::ParamSpec::builder_with_default
2564    }
2565}
2566
2567impl glib::value::ValueType for ScrollDirection {
2568    type Type = Self;
2569}
2570
2571unsafe impl<'a> glib::value::FromValue<'a> for ScrollDirection {
2572    type Checker = glib::value::GenericValueTypeChecker<Self>;
2573
2574    #[inline]
2575    unsafe fn from_value(value: &'a glib::Value) -> Self {
2576        skip_assert_initialized!();
2577        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
2578    }
2579}
2580
2581impl ToValue for ScrollDirection {
2582    #[inline]
2583    fn to_value(&self) -> glib::Value {
2584        let mut value = glib::Value::for_value_type::<Self>();
2585        unsafe {
2586            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2587        }
2588        value
2589    }
2590
2591    #[inline]
2592    fn value_type(&self) -> glib::Type {
2593        Self::static_type()
2594    }
2595}
2596
2597impl From<ScrollDirection> for glib::Value {
2598    #[inline]
2599    fn from(v: ScrollDirection) -> Self {
2600        skip_assert_initialized!();
2601        ToValue::to_value(&v)
2602    }
2603}
2604
2605#[cfg(feature = "v4_20")]
2606#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
2607#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2608#[non_exhaustive]
2609#[doc(alias = "GdkScrollRelativeDirection")]
2610pub enum ScrollRelativeDirection {
2611    #[doc(alias = "GDK_SCROLL_RELATIVE_DIRECTION_IDENTICAL")]
2612    Identical,
2613    #[doc(alias = "GDK_SCROLL_RELATIVE_DIRECTION_INVERTED")]
2614    Inverted,
2615    #[doc(alias = "GDK_SCROLL_RELATIVE_DIRECTION_UNKNOWN")]
2616    Unknown,
2617    #[doc(hidden)]
2618    __Unknown(i32),
2619}
2620
2621#[cfg(feature = "v4_20")]
2622#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
2623#[doc(hidden)]
2624impl IntoGlib for ScrollRelativeDirection {
2625    type GlibType = ffi::GdkScrollRelativeDirection;
2626
2627    #[inline]
2628    fn into_glib(self) -> ffi::GdkScrollRelativeDirection {
2629        match self {
2630            Self::Identical => ffi::GDK_SCROLL_RELATIVE_DIRECTION_IDENTICAL,
2631            Self::Inverted => ffi::GDK_SCROLL_RELATIVE_DIRECTION_INVERTED,
2632            Self::Unknown => ffi::GDK_SCROLL_RELATIVE_DIRECTION_UNKNOWN,
2633            Self::__Unknown(value) => value,
2634        }
2635    }
2636}
2637
2638#[cfg(feature = "v4_20")]
2639#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
2640#[doc(hidden)]
2641impl FromGlib<ffi::GdkScrollRelativeDirection> for ScrollRelativeDirection {
2642    #[inline]
2643    unsafe fn from_glib(value: ffi::GdkScrollRelativeDirection) -> Self {
2644        skip_assert_initialized!();
2645
2646        match value {
2647            ffi::GDK_SCROLL_RELATIVE_DIRECTION_IDENTICAL => Self::Identical,
2648            ffi::GDK_SCROLL_RELATIVE_DIRECTION_INVERTED => Self::Inverted,
2649            ffi::GDK_SCROLL_RELATIVE_DIRECTION_UNKNOWN => Self::Unknown,
2650            value => Self::__Unknown(value),
2651        }
2652    }
2653}
2654
2655#[cfg(feature = "v4_20")]
2656#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
2657impl StaticType for ScrollRelativeDirection {
2658    #[inline]
2659    #[doc(alias = "gdk_scroll_relative_direction_get_type")]
2660    fn static_type() -> glib::Type {
2661        unsafe { from_glib(ffi::gdk_scroll_relative_direction_get_type()) }
2662    }
2663}
2664
2665#[cfg(feature = "v4_20")]
2666#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
2667impl glib::HasParamSpec for ScrollRelativeDirection {
2668    type ParamSpec = glib::ParamSpecEnum;
2669    type SetValue = Self;
2670    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2671
2672    fn param_spec_builder() -> Self::BuilderFn {
2673        Self::ParamSpec::builder_with_default
2674    }
2675}
2676
2677#[cfg(feature = "v4_20")]
2678#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
2679impl glib::value::ValueType for ScrollRelativeDirection {
2680    type Type = Self;
2681}
2682
2683#[cfg(feature = "v4_20")]
2684#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
2685unsafe impl<'a> glib::value::FromValue<'a> for ScrollRelativeDirection {
2686    type Checker = glib::value::GenericValueTypeChecker<Self>;
2687
2688    #[inline]
2689    unsafe fn from_value(value: &'a glib::Value) -> Self {
2690        skip_assert_initialized!();
2691        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
2692    }
2693}
2694
2695#[cfg(feature = "v4_20")]
2696#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
2697impl ToValue for ScrollRelativeDirection {
2698    #[inline]
2699    fn to_value(&self) -> glib::Value {
2700        let mut value = glib::Value::for_value_type::<Self>();
2701        unsafe {
2702            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2703        }
2704        value
2705    }
2706
2707    #[inline]
2708    fn value_type(&self) -> glib::Type {
2709        Self::static_type()
2710    }
2711}
2712
2713#[cfg(feature = "v4_20")]
2714#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
2715impl From<ScrollRelativeDirection> for glib::Value {
2716    #[inline]
2717    fn from(v: ScrollRelativeDirection) -> Self {
2718        skip_assert_initialized!();
2719        ToValue::to_value(&v)
2720    }
2721}
2722
2723#[cfg(feature = "v4_8")]
2724#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
2725#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2726#[non_exhaustive]
2727#[doc(alias = "GdkScrollUnit")]
2728pub enum ScrollUnit {
2729    #[doc(alias = "GDK_SCROLL_UNIT_WHEEL")]
2730    Wheel,
2731    #[doc(alias = "GDK_SCROLL_UNIT_SURFACE")]
2732    Surface,
2733    #[doc(hidden)]
2734    __Unknown(i32),
2735}
2736
2737#[cfg(feature = "v4_8")]
2738#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
2739#[doc(hidden)]
2740impl IntoGlib for ScrollUnit {
2741    type GlibType = ffi::GdkScrollUnit;
2742
2743    #[inline]
2744    fn into_glib(self) -> ffi::GdkScrollUnit {
2745        match self {
2746            Self::Wheel => ffi::GDK_SCROLL_UNIT_WHEEL,
2747            Self::Surface => ffi::GDK_SCROLL_UNIT_SURFACE,
2748            Self::__Unknown(value) => value,
2749        }
2750    }
2751}
2752
2753#[cfg(feature = "v4_8")]
2754#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
2755#[doc(hidden)]
2756impl FromGlib<ffi::GdkScrollUnit> for ScrollUnit {
2757    #[inline]
2758    unsafe fn from_glib(value: ffi::GdkScrollUnit) -> Self {
2759        skip_assert_initialized!();
2760
2761        match value {
2762            ffi::GDK_SCROLL_UNIT_WHEEL => Self::Wheel,
2763            ffi::GDK_SCROLL_UNIT_SURFACE => Self::Surface,
2764            value => Self::__Unknown(value),
2765        }
2766    }
2767}
2768
2769#[cfg(feature = "v4_8")]
2770#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
2771impl StaticType for ScrollUnit {
2772    #[inline]
2773    #[doc(alias = "gdk_scroll_unit_get_type")]
2774    fn static_type() -> glib::Type {
2775        unsafe { from_glib(ffi::gdk_scroll_unit_get_type()) }
2776    }
2777}
2778
2779#[cfg(feature = "v4_8")]
2780#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
2781impl glib::HasParamSpec for ScrollUnit {
2782    type ParamSpec = glib::ParamSpecEnum;
2783    type SetValue = Self;
2784    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2785
2786    fn param_spec_builder() -> Self::BuilderFn {
2787        Self::ParamSpec::builder_with_default
2788    }
2789}
2790
2791#[cfg(feature = "v4_8")]
2792#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
2793impl glib::value::ValueType for ScrollUnit {
2794    type Type = Self;
2795}
2796
2797#[cfg(feature = "v4_8")]
2798#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
2799unsafe impl<'a> glib::value::FromValue<'a> for ScrollUnit {
2800    type Checker = glib::value::GenericValueTypeChecker<Self>;
2801
2802    #[inline]
2803    unsafe fn from_value(value: &'a glib::Value) -> Self {
2804        skip_assert_initialized!();
2805        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
2806    }
2807}
2808
2809#[cfg(feature = "v4_8")]
2810#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
2811impl ToValue for ScrollUnit {
2812    #[inline]
2813    fn to_value(&self) -> glib::Value {
2814        let mut value = glib::Value::for_value_type::<Self>();
2815        unsafe {
2816            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2817        }
2818        value
2819    }
2820
2821    #[inline]
2822    fn value_type(&self) -> glib::Type {
2823        Self::static_type()
2824    }
2825}
2826
2827#[cfg(feature = "v4_8")]
2828#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
2829impl From<ScrollUnit> for glib::Value {
2830    #[inline]
2831    fn from(v: ScrollUnit) -> Self {
2832        skip_assert_initialized!();
2833        ToValue::to_value(&v)
2834    }
2835}
2836
2837#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2838#[non_exhaustive]
2839#[doc(alias = "GdkSubpixelLayout")]
2840pub enum SubpixelLayout {
2841    #[doc(alias = "GDK_SUBPIXEL_LAYOUT_UNKNOWN")]
2842    Unknown,
2843    #[doc(alias = "GDK_SUBPIXEL_LAYOUT_NONE")]
2844    None,
2845    #[doc(alias = "GDK_SUBPIXEL_LAYOUT_HORIZONTAL_RGB")]
2846    HorizontalRgb,
2847    #[doc(alias = "GDK_SUBPIXEL_LAYOUT_HORIZONTAL_BGR")]
2848    HorizontalBgr,
2849    #[doc(alias = "GDK_SUBPIXEL_LAYOUT_VERTICAL_RGB")]
2850    VerticalRgb,
2851    #[doc(alias = "GDK_SUBPIXEL_LAYOUT_VERTICAL_BGR")]
2852    VerticalBgr,
2853    #[doc(hidden)]
2854    __Unknown(i32),
2855}
2856
2857#[doc(hidden)]
2858impl IntoGlib for SubpixelLayout {
2859    type GlibType = ffi::GdkSubpixelLayout;
2860
2861    #[inline]
2862    fn into_glib(self) -> ffi::GdkSubpixelLayout {
2863        match self {
2864            Self::Unknown => ffi::GDK_SUBPIXEL_LAYOUT_UNKNOWN,
2865            Self::None => ffi::GDK_SUBPIXEL_LAYOUT_NONE,
2866            Self::HorizontalRgb => ffi::GDK_SUBPIXEL_LAYOUT_HORIZONTAL_RGB,
2867            Self::HorizontalBgr => ffi::GDK_SUBPIXEL_LAYOUT_HORIZONTAL_BGR,
2868            Self::VerticalRgb => ffi::GDK_SUBPIXEL_LAYOUT_VERTICAL_RGB,
2869            Self::VerticalBgr => ffi::GDK_SUBPIXEL_LAYOUT_VERTICAL_BGR,
2870            Self::__Unknown(value) => value,
2871        }
2872    }
2873}
2874
2875#[doc(hidden)]
2876impl FromGlib<ffi::GdkSubpixelLayout> for SubpixelLayout {
2877    #[inline]
2878    unsafe fn from_glib(value: ffi::GdkSubpixelLayout) -> Self {
2879        skip_assert_initialized!();
2880
2881        match value {
2882            ffi::GDK_SUBPIXEL_LAYOUT_UNKNOWN => Self::Unknown,
2883            ffi::GDK_SUBPIXEL_LAYOUT_NONE => Self::None,
2884            ffi::GDK_SUBPIXEL_LAYOUT_HORIZONTAL_RGB => Self::HorizontalRgb,
2885            ffi::GDK_SUBPIXEL_LAYOUT_HORIZONTAL_BGR => Self::HorizontalBgr,
2886            ffi::GDK_SUBPIXEL_LAYOUT_VERTICAL_RGB => Self::VerticalRgb,
2887            ffi::GDK_SUBPIXEL_LAYOUT_VERTICAL_BGR => Self::VerticalBgr,
2888            value => Self::__Unknown(value),
2889        }
2890    }
2891}
2892
2893impl StaticType for SubpixelLayout {
2894    #[inline]
2895    #[doc(alias = "gdk_subpixel_layout_get_type")]
2896    fn static_type() -> glib::Type {
2897        unsafe { from_glib(ffi::gdk_subpixel_layout_get_type()) }
2898    }
2899}
2900
2901impl glib::HasParamSpec for SubpixelLayout {
2902    type ParamSpec = glib::ParamSpecEnum;
2903    type SetValue = Self;
2904    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2905
2906    fn param_spec_builder() -> Self::BuilderFn {
2907        Self::ParamSpec::builder_with_default
2908    }
2909}
2910
2911impl glib::value::ValueType for SubpixelLayout {
2912    type Type = Self;
2913}
2914
2915unsafe impl<'a> glib::value::FromValue<'a> for SubpixelLayout {
2916    type Checker = glib::value::GenericValueTypeChecker<Self>;
2917
2918    #[inline]
2919    unsafe fn from_value(value: &'a glib::Value) -> Self {
2920        skip_assert_initialized!();
2921        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
2922    }
2923}
2924
2925impl ToValue for SubpixelLayout {
2926    #[inline]
2927    fn to_value(&self) -> glib::Value {
2928        let mut value = glib::Value::for_value_type::<Self>();
2929        unsafe {
2930            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2931        }
2932        value
2933    }
2934
2935    #[inline]
2936    fn value_type(&self) -> glib::Type {
2937        Self::static_type()
2938    }
2939}
2940
2941impl From<SubpixelLayout> for glib::Value {
2942    #[inline]
2943    fn from(v: SubpixelLayout) -> Self {
2944        skip_assert_initialized!();
2945        ToValue::to_value(&v)
2946    }
2947}
2948
2949#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2950#[non_exhaustive]
2951#[doc(alias = "GdkSurfaceEdge")]
2952pub enum SurfaceEdge {
2953    #[doc(alias = "GDK_SURFACE_EDGE_NORTH_WEST")]
2954    NorthWest,
2955    #[doc(alias = "GDK_SURFACE_EDGE_NORTH")]
2956    North,
2957    #[doc(alias = "GDK_SURFACE_EDGE_NORTH_EAST")]
2958    NorthEast,
2959    #[doc(alias = "GDK_SURFACE_EDGE_WEST")]
2960    West,
2961    #[doc(alias = "GDK_SURFACE_EDGE_EAST")]
2962    East,
2963    #[doc(alias = "GDK_SURFACE_EDGE_SOUTH_WEST")]
2964    SouthWest,
2965    #[doc(alias = "GDK_SURFACE_EDGE_SOUTH")]
2966    South,
2967    #[doc(alias = "GDK_SURFACE_EDGE_SOUTH_EAST")]
2968    SouthEast,
2969    #[doc(hidden)]
2970    __Unknown(i32),
2971}
2972
2973#[doc(hidden)]
2974impl IntoGlib for SurfaceEdge {
2975    type GlibType = ffi::GdkSurfaceEdge;
2976
2977    #[inline]
2978    fn into_glib(self) -> ffi::GdkSurfaceEdge {
2979        match self {
2980            Self::NorthWest => ffi::GDK_SURFACE_EDGE_NORTH_WEST,
2981            Self::North => ffi::GDK_SURFACE_EDGE_NORTH,
2982            Self::NorthEast => ffi::GDK_SURFACE_EDGE_NORTH_EAST,
2983            Self::West => ffi::GDK_SURFACE_EDGE_WEST,
2984            Self::East => ffi::GDK_SURFACE_EDGE_EAST,
2985            Self::SouthWest => ffi::GDK_SURFACE_EDGE_SOUTH_WEST,
2986            Self::South => ffi::GDK_SURFACE_EDGE_SOUTH,
2987            Self::SouthEast => ffi::GDK_SURFACE_EDGE_SOUTH_EAST,
2988            Self::__Unknown(value) => value,
2989        }
2990    }
2991}
2992
2993#[doc(hidden)]
2994impl FromGlib<ffi::GdkSurfaceEdge> for SurfaceEdge {
2995    #[inline]
2996    unsafe fn from_glib(value: ffi::GdkSurfaceEdge) -> Self {
2997        skip_assert_initialized!();
2998
2999        match value {
3000            ffi::GDK_SURFACE_EDGE_NORTH_WEST => Self::NorthWest,
3001            ffi::GDK_SURFACE_EDGE_NORTH => Self::North,
3002            ffi::GDK_SURFACE_EDGE_NORTH_EAST => Self::NorthEast,
3003            ffi::GDK_SURFACE_EDGE_WEST => Self::West,
3004            ffi::GDK_SURFACE_EDGE_EAST => Self::East,
3005            ffi::GDK_SURFACE_EDGE_SOUTH_WEST => Self::SouthWest,
3006            ffi::GDK_SURFACE_EDGE_SOUTH => Self::South,
3007            ffi::GDK_SURFACE_EDGE_SOUTH_EAST => Self::SouthEast,
3008            value => Self::__Unknown(value),
3009        }
3010    }
3011}
3012
3013impl StaticType for SurfaceEdge {
3014    #[inline]
3015    #[doc(alias = "gdk_surface_edge_get_type")]
3016    fn static_type() -> glib::Type {
3017        unsafe { from_glib(ffi::gdk_surface_edge_get_type()) }
3018    }
3019}
3020
3021impl glib::HasParamSpec for SurfaceEdge {
3022    type ParamSpec = glib::ParamSpecEnum;
3023    type SetValue = Self;
3024    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3025
3026    fn param_spec_builder() -> Self::BuilderFn {
3027        Self::ParamSpec::builder_with_default
3028    }
3029}
3030
3031impl glib::value::ValueType for SurfaceEdge {
3032    type Type = Self;
3033}
3034
3035unsafe impl<'a> glib::value::FromValue<'a> for SurfaceEdge {
3036    type Checker = glib::value::GenericValueTypeChecker<Self>;
3037
3038    #[inline]
3039    unsafe fn from_value(value: &'a glib::Value) -> Self {
3040        skip_assert_initialized!();
3041        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
3042    }
3043}
3044
3045impl ToValue for SurfaceEdge {
3046    #[inline]
3047    fn to_value(&self) -> glib::Value {
3048        let mut value = glib::Value::for_value_type::<Self>();
3049        unsafe {
3050            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3051        }
3052        value
3053    }
3054
3055    #[inline]
3056    fn value_type(&self) -> glib::Type {
3057        Self::static_type()
3058    }
3059}
3060
3061impl From<SurfaceEdge> for glib::Value {
3062    #[inline]
3063    fn from(v: SurfaceEdge) -> Self {
3064        skip_assert_initialized!();
3065        ToValue::to_value(&v)
3066    }
3067}
3068
3069#[cfg(feature = "v4_6")]
3070#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
3071#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3072#[non_exhaustive]
3073#[doc(alias = "GdkTextureError")]
3074pub enum TextureError {
3075    #[doc(alias = "GDK_TEXTURE_ERROR_TOO_LARGE")]
3076    TooLarge,
3077    #[doc(alias = "GDK_TEXTURE_ERROR_CORRUPT_IMAGE")]
3078    CorruptImage,
3079    #[doc(alias = "GDK_TEXTURE_ERROR_UNSUPPORTED_CONTENT")]
3080    UnsupportedContent,
3081    #[doc(alias = "GDK_TEXTURE_ERROR_UNSUPPORTED_FORMAT")]
3082    UnsupportedFormat,
3083    #[doc(hidden)]
3084    __Unknown(i32),
3085}
3086
3087#[cfg(feature = "v4_6")]
3088#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
3089#[doc(hidden)]
3090impl IntoGlib for TextureError {
3091    type GlibType = ffi::GdkTextureError;
3092
3093    #[inline]
3094    fn into_glib(self) -> ffi::GdkTextureError {
3095        match self {
3096            Self::TooLarge => ffi::GDK_TEXTURE_ERROR_TOO_LARGE,
3097            Self::CorruptImage => ffi::GDK_TEXTURE_ERROR_CORRUPT_IMAGE,
3098            Self::UnsupportedContent => ffi::GDK_TEXTURE_ERROR_UNSUPPORTED_CONTENT,
3099            Self::UnsupportedFormat => ffi::GDK_TEXTURE_ERROR_UNSUPPORTED_FORMAT,
3100            Self::__Unknown(value) => value,
3101        }
3102    }
3103}
3104
3105#[cfg(feature = "v4_6")]
3106#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
3107#[doc(hidden)]
3108impl FromGlib<ffi::GdkTextureError> for TextureError {
3109    #[inline]
3110    unsafe fn from_glib(value: ffi::GdkTextureError) -> Self {
3111        skip_assert_initialized!();
3112
3113        match value {
3114            ffi::GDK_TEXTURE_ERROR_TOO_LARGE => Self::TooLarge,
3115            ffi::GDK_TEXTURE_ERROR_CORRUPT_IMAGE => Self::CorruptImage,
3116            ffi::GDK_TEXTURE_ERROR_UNSUPPORTED_CONTENT => Self::UnsupportedContent,
3117            ffi::GDK_TEXTURE_ERROR_UNSUPPORTED_FORMAT => Self::UnsupportedFormat,
3118            value => Self::__Unknown(value),
3119        }
3120    }
3121}
3122
3123#[cfg(feature = "v4_6")]
3124#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
3125impl glib::error::ErrorDomain for TextureError {
3126    #[inline]
3127    fn domain() -> glib::Quark {
3128        skip_assert_initialized!();
3129
3130        unsafe { from_glib(ffi::gdk_texture_error_quark()) }
3131    }
3132
3133    #[inline]
3134    fn code(self) -> i32 {
3135        self.into_glib()
3136    }
3137
3138    #[inline]
3139    #[allow(clippy::match_single_binding)]
3140    fn from(code: i32) -> Option<Self> {
3141        skip_assert_initialized!();
3142        match unsafe { from_glib(code) } {
3143            value => Some(value),
3144        }
3145    }
3146}
3147
3148#[cfg(feature = "v4_6")]
3149#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
3150impl StaticType for TextureError {
3151    #[inline]
3152    #[doc(alias = "gdk_texture_error_get_type")]
3153    fn static_type() -> glib::Type {
3154        unsafe { from_glib(ffi::gdk_texture_error_get_type()) }
3155    }
3156}
3157
3158#[cfg(feature = "v4_6")]
3159#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
3160impl glib::HasParamSpec for TextureError {
3161    type ParamSpec = glib::ParamSpecEnum;
3162    type SetValue = Self;
3163    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3164
3165    fn param_spec_builder() -> Self::BuilderFn {
3166        Self::ParamSpec::builder_with_default
3167    }
3168}
3169
3170#[cfg(feature = "v4_6")]
3171#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
3172impl glib::value::ValueType for TextureError {
3173    type Type = Self;
3174}
3175
3176#[cfg(feature = "v4_6")]
3177#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
3178unsafe impl<'a> glib::value::FromValue<'a> for TextureError {
3179    type Checker = glib::value::GenericValueTypeChecker<Self>;
3180
3181    #[inline]
3182    unsafe fn from_value(value: &'a glib::Value) -> Self {
3183        skip_assert_initialized!();
3184        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
3185    }
3186}
3187
3188#[cfg(feature = "v4_6")]
3189#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
3190impl ToValue for TextureError {
3191    #[inline]
3192    fn to_value(&self) -> glib::Value {
3193        let mut value = glib::Value::for_value_type::<Self>();
3194        unsafe {
3195            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3196        }
3197        value
3198    }
3199
3200    #[inline]
3201    fn value_type(&self) -> glib::Type {
3202        Self::static_type()
3203    }
3204}
3205
3206#[cfg(feature = "v4_6")]
3207#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
3208impl From<TextureError> for glib::Value {
3209    #[inline]
3210    fn from(v: TextureError) -> Self {
3211        skip_assert_initialized!();
3212        ToValue::to_value(&v)
3213    }
3214}
3215
3216#[cfg(feature = "v4_4")]
3217#[cfg_attr(docsrs, doc(cfg(feature = "v4_4")))]
3218#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3219#[non_exhaustive]
3220#[doc(alias = "GdkTitlebarGesture")]
3221pub enum TitlebarGesture {
3222    #[doc(alias = "GDK_TITLEBAR_GESTURE_DOUBLE_CLICK")]
3223    DoubleClick,
3224    #[doc(alias = "GDK_TITLEBAR_GESTURE_RIGHT_CLICK")]
3225    RightClick,
3226    #[doc(alias = "GDK_TITLEBAR_GESTURE_MIDDLE_CLICK")]
3227    MiddleClick,
3228    #[doc(hidden)]
3229    __Unknown(i32),
3230}
3231
3232#[cfg(feature = "v4_4")]
3233#[cfg_attr(docsrs, doc(cfg(feature = "v4_4")))]
3234#[doc(hidden)]
3235impl IntoGlib for TitlebarGesture {
3236    type GlibType = ffi::GdkTitlebarGesture;
3237
3238    #[inline]
3239    fn into_glib(self) -> ffi::GdkTitlebarGesture {
3240        match self {
3241            Self::DoubleClick => ffi::GDK_TITLEBAR_GESTURE_DOUBLE_CLICK,
3242            Self::RightClick => ffi::GDK_TITLEBAR_GESTURE_RIGHT_CLICK,
3243            Self::MiddleClick => ffi::GDK_TITLEBAR_GESTURE_MIDDLE_CLICK,
3244            Self::__Unknown(value) => value,
3245        }
3246    }
3247}
3248
3249#[cfg(feature = "v4_4")]
3250#[cfg_attr(docsrs, doc(cfg(feature = "v4_4")))]
3251#[doc(hidden)]
3252impl FromGlib<ffi::GdkTitlebarGesture> for TitlebarGesture {
3253    #[inline]
3254    unsafe fn from_glib(value: ffi::GdkTitlebarGesture) -> Self {
3255        skip_assert_initialized!();
3256
3257        match value {
3258            ffi::GDK_TITLEBAR_GESTURE_DOUBLE_CLICK => Self::DoubleClick,
3259            ffi::GDK_TITLEBAR_GESTURE_RIGHT_CLICK => Self::RightClick,
3260            ffi::GDK_TITLEBAR_GESTURE_MIDDLE_CLICK => Self::MiddleClick,
3261            value => Self::__Unknown(value),
3262        }
3263    }
3264}
3265
3266#[cfg(feature = "v4_4")]
3267#[cfg_attr(docsrs, doc(cfg(feature = "v4_4")))]
3268impl StaticType for TitlebarGesture {
3269    #[inline]
3270    #[doc(alias = "gdk_titlebar_gesture_get_type")]
3271    fn static_type() -> glib::Type {
3272        unsafe { from_glib(ffi::gdk_titlebar_gesture_get_type()) }
3273    }
3274}
3275
3276#[cfg(feature = "v4_4")]
3277#[cfg_attr(docsrs, doc(cfg(feature = "v4_4")))]
3278impl glib::HasParamSpec for TitlebarGesture {
3279    type ParamSpec = glib::ParamSpecEnum;
3280    type SetValue = Self;
3281    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3282
3283    fn param_spec_builder() -> Self::BuilderFn {
3284        Self::ParamSpec::builder_with_default
3285    }
3286}
3287
3288#[cfg(feature = "v4_4")]
3289#[cfg_attr(docsrs, doc(cfg(feature = "v4_4")))]
3290impl glib::value::ValueType for TitlebarGesture {
3291    type Type = Self;
3292}
3293
3294#[cfg(feature = "v4_4")]
3295#[cfg_attr(docsrs, doc(cfg(feature = "v4_4")))]
3296unsafe impl<'a> glib::value::FromValue<'a> for TitlebarGesture {
3297    type Checker = glib::value::GenericValueTypeChecker<Self>;
3298
3299    #[inline]
3300    unsafe fn from_value(value: &'a glib::Value) -> Self {
3301        skip_assert_initialized!();
3302        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
3303    }
3304}
3305
3306#[cfg(feature = "v4_4")]
3307#[cfg_attr(docsrs, doc(cfg(feature = "v4_4")))]
3308impl ToValue for TitlebarGesture {
3309    #[inline]
3310    fn to_value(&self) -> glib::Value {
3311        let mut value = glib::Value::for_value_type::<Self>();
3312        unsafe {
3313            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3314        }
3315        value
3316    }
3317
3318    #[inline]
3319    fn value_type(&self) -> glib::Type {
3320        Self::static_type()
3321    }
3322}
3323
3324#[cfg(feature = "v4_4")]
3325#[cfg_attr(docsrs, doc(cfg(feature = "v4_4")))]
3326impl From<TitlebarGesture> for glib::Value {
3327    #[inline]
3328    fn from(v: TitlebarGesture) -> Self {
3329        skip_assert_initialized!();
3330        ToValue::to_value(&v)
3331    }
3332}
3333
3334#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3335#[non_exhaustive]
3336#[doc(alias = "GdkTouchpadGesturePhase")]
3337pub enum TouchpadGesturePhase {
3338    #[doc(alias = "GDK_TOUCHPAD_GESTURE_PHASE_BEGIN")]
3339    Begin,
3340    #[doc(alias = "GDK_TOUCHPAD_GESTURE_PHASE_UPDATE")]
3341    Update,
3342    #[doc(alias = "GDK_TOUCHPAD_GESTURE_PHASE_END")]
3343    End,
3344    #[doc(alias = "GDK_TOUCHPAD_GESTURE_PHASE_CANCEL")]
3345    Cancel,
3346    #[doc(hidden)]
3347    __Unknown(i32),
3348}
3349
3350#[doc(hidden)]
3351impl IntoGlib for TouchpadGesturePhase {
3352    type GlibType = ffi::GdkTouchpadGesturePhase;
3353
3354    #[inline]
3355    fn into_glib(self) -> ffi::GdkTouchpadGesturePhase {
3356        match self {
3357            Self::Begin => ffi::GDK_TOUCHPAD_GESTURE_PHASE_BEGIN,
3358            Self::Update => ffi::GDK_TOUCHPAD_GESTURE_PHASE_UPDATE,
3359            Self::End => ffi::GDK_TOUCHPAD_GESTURE_PHASE_END,
3360            Self::Cancel => ffi::GDK_TOUCHPAD_GESTURE_PHASE_CANCEL,
3361            Self::__Unknown(value) => value,
3362        }
3363    }
3364}
3365
3366#[doc(hidden)]
3367impl FromGlib<ffi::GdkTouchpadGesturePhase> for TouchpadGesturePhase {
3368    #[inline]
3369    unsafe fn from_glib(value: ffi::GdkTouchpadGesturePhase) -> Self {
3370        skip_assert_initialized!();
3371
3372        match value {
3373            ffi::GDK_TOUCHPAD_GESTURE_PHASE_BEGIN => Self::Begin,
3374            ffi::GDK_TOUCHPAD_GESTURE_PHASE_UPDATE => Self::Update,
3375            ffi::GDK_TOUCHPAD_GESTURE_PHASE_END => Self::End,
3376            ffi::GDK_TOUCHPAD_GESTURE_PHASE_CANCEL => Self::Cancel,
3377            value => Self::__Unknown(value),
3378        }
3379    }
3380}
3381
3382impl StaticType for TouchpadGesturePhase {
3383    #[inline]
3384    #[doc(alias = "gdk_touchpad_gesture_phase_get_type")]
3385    fn static_type() -> glib::Type {
3386        unsafe { from_glib(ffi::gdk_touchpad_gesture_phase_get_type()) }
3387    }
3388}
3389
3390impl glib::HasParamSpec for TouchpadGesturePhase {
3391    type ParamSpec = glib::ParamSpecEnum;
3392    type SetValue = Self;
3393    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3394
3395    fn param_spec_builder() -> Self::BuilderFn {
3396        Self::ParamSpec::builder_with_default
3397    }
3398}
3399
3400impl glib::value::ValueType for TouchpadGesturePhase {
3401    type Type = Self;
3402}
3403
3404unsafe impl<'a> glib::value::FromValue<'a> for TouchpadGesturePhase {
3405    type Checker = glib::value::GenericValueTypeChecker<Self>;
3406
3407    #[inline]
3408    unsafe fn from_value(value: &'a glib::Value) -> Self {
3409        skip_assert_initialized!();
3410        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
3411    }
3412}
3413
3414impl ToValue for TouchpadGesturePhase {
3415    #[inline]
3416    fn to_value(&self) -> glib::Value {
3417        let mut value = glib::Value::for_value_type::<Self>();
3418        unsafe {
3419            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3420        }
3421        value
3422    }
3423
3424    #[inline]
3425    fn value_type(&self) -> glib::Type {
3426        Self::static_type()
3427    }
3428}
3429
3430impl From<TouchpadGesturePhase> for glib::Value {
3431    #[inline]
3432    fn from(v: TouchpadGesturePhase) -> Self {
3433        skip_assert_initialized!();
3434        ToValue::to_value(&v)
3435    }
3436}
3437
3438#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3439#[non_exhaustive]
3440#[doc(alias = "GdkVulkanError")]
3441pub enum VulkanError {
3442    #[doc(alias = "GDK_VULKAN_ERROR_UNSUPPORTED")]
3443    Unsupported,
3444    #[doc(alias = "GDK_VULKAN_ERROR_NOT_AVAILABLE")]
3445    NotAvailable,
3446    #[doc(hidden)]
3447    __Unknown(i32),
3448}
3449
3450#[doc(hidden)]
3451impl IntoGlib for VulkanError {
3452    type GlibType = ffi::GdkVulkanError;
3453
3454    #[inline]
3455    fn into_glib(self) -> ffi::GdkVulkanError {
3456        match self {
3457            Self::Unsupported => ffi::GDK_VULKAN_ERROR_UNSUPPORTED,
3458            Self::NotAvailable => ffi::GDK_VULKAN_ERROR_NOT_AVAILABLE,
3459            Self::__Unknown(value) => value,
3460        }
3461    }
3462}
3463
3464#[doc(hidden)]
3465impl FromGlib<ffi::GdkVulkanError> for VulkanError {
3466    #[inline]
3467    unsafe fn from_glib(value: ffi::GdkVulkanError) -> Self {
3468        skip_assert_initialized!();
3469
3470        match value {
3471            ffi::GDK_VULKAN_ERROR_UNSUPPORTED => Self::Unsupported,
3472            ffi::GDK_VULKAN_ERROR_NOT_AVAILABLE => Self::NotAvailable,
3473            value => Self::__Unknown(value),
3474        }
3475    }
3476}
3477
3478impl glib::error::ErrorDomain for VulkanError {
3479    #[inline]
3480    fn domain() -> glib::Quark {
3481        skip_assert_initialized!();
3482
3483        unsafe { from_glib(ffi::gdk_vulkan_error_quark()) }
3484    }
3485
3486    #[inline]
3487    fn code(self) -> i32 {
3488        self.into_glib()
3489    }
3490
3491    #[inline]
3492    #[allow(clippy::match_single_binding)]
3493    fn from(code: i32) -> Option<Self> {
3494        skip_assert_initialized!();
3495        match unsafe { from_glib(code) } {
3496            value => Some(value),
3497        }
3498    }
3499}
3500
3501impl StaticType for VulkanError {
3502    #[inline]
3503    #[doc(alias = "gdk_vulkan_error_get_type")]
3504    fn static_type() -> glib::Type {
3505        unsafe { from_glib(ffi::gdk_vulkan_error_get_type()) }
3506    }
3507}
3508
3509impl glib::HasParamSpec for VulkanError {
3510    type ParamSpec = glib::ParamSpecEnum;
3511    type SetValue = Self;
3512    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3513
3514    fn param_spec_builder() -> Self::BuilderFn {
3515        Self::ParamSpec::builder_with_default
3516    }
3517}
3518
3519impl glib::value::ValueType for VulkanError {
3520    type Type = Self;
3521}
3522
3523unsafe impl<'a> glib::value::FromValue<'a> for VulkanError {
3524    type Checker = glib::value::GenericValueTypeChecker<Self>;
3525
3526    #[inline]
3527    unsafe fn from_value(value: &'a glib::Value) -> Self {
3528        skip_assert_initialized!();
3529        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
3530    }
3531}
3532
3533impl ToValue for VulkanError {
3534    #[inline]
3535    fn to_value(&self) -> glib::Value {
3536        let mut value = glib::Value::for_value_type::<Self>();
3537        unsafe {
3538            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3539        }
3540        value
3541    }
3542
3543    #[inline]
3544    fn value_type(&self) -> glib::Type {
3545        Self::static_type()
3546    }
3547}
3548
3549impl From<VulkanError> for glib::Value {
3550    #[inline]
3551    fn from(v: VulkanError) -> Self {
3552        skip_assert_initialized!();
3553        ToValue::to_value(&v)
3554    }
3555}