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