1use crate::ffi;
6use glib::{prelude::*, translate::*};
7
8#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
14#[non_exhaustive]
15#[doc(alias = "GdkAxisUse")]
16pub enum AxisUse {
17 #[doc(alias = "GDK_AXIS_IGNORE")]
19 Ignore,
20 #[doc(alias = "GDK_AXIS_X")]
22 X,
23 #[doc(alias = "GDK_AXIS_Y")]
25 Y,
26 #[doc(alias = "GDK_AXIS_DELTA_X")]
28 DeltaX,
29 #[doc(alias = "GDK_AXIS_DELTA_Y")]
31 DeltaY,
32 #[doc(alias = "GDK_AXIS_PRESSURE")]
34 Pressure,
35 #[doc(alias = "GDK_AXIS_XTILT")]
37 Xtilt,
38 #[doc(alias = "GDK_AXIS_YTILT")]
40 Ytilt,
41 #[doc(alias = "GDK_AXIS_WHEEL")]
43 Wheel,
44 #[doc(alias = "GDK_AXIS_DISTANCE")]
46 Distance,
47 #[doc(alias = "GDK_AXIS_ROTATION")]
49 Rotation,
50 #[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#[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 #[doc(alias = "GDK_CICP_RANGE_NARROW")]
175 Narrow,
176 #[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#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
285#[non_exhaustive]
286#[doc(alias = "GdkCrossingMode")]
287pub enum CrossingMode {
288 #[doc(alias = "GDK_CROSSING_NORMAL")]
290 Normal,
291 #[doc(alias = "GDK_CROSSING_GRAB")]
293 Grab,
294 #[doc(alias = "GDK_CROSSING_UNGRAB")]
296 Ungrab,
297 #[doc(alias = "GDK_CROSSING_GTK_GRAB")]
299 GtkGrab,
300 #[doc(alias = "GDK_CROSSING_GTK_UNGRAB")]
302 GtkUngrab,
303 #[doc(alias = "GDK_CROSSING_STATE_CHANGED")]
306 StateChanged,
307 #[doc(alias = "GDK_CROSSING_TOUCH_BEGIN")]
310 TouchBegin,
311 #[doc(alias = "GDK_CROSSING_TOUCH_END")]
314 TouchEnd,
315 #[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#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
424#[non_exhaustive]
425#[doc(alias = "GdkDevicePadFeature")]
426pub enum DevicePadFeature {
427 #[doc(alias = "GDK_DEVICE_PAD_FEATURE_BUTTON")]
429 Button,
430 #[doc(alias = "GDK_DEVICE_PAD_FEATURE_RING")]
432 Ring,
433 #[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#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
529#[non_exhaustive]
530#[doc(alias = "GdkDeviceToolType")]
531pub enum DeviceToolType {
532 #[doc(alias = "GDK_DEVICE_TOOL_TYPE_UNKNOWN")]
534 Unknown,
535 #[doc(alias = "GDK_DEVICE_TOOL_TYPE_PEN")]
537 Pen,
538 #[doc(alias = "GDK_DEVICE_TOOL_TYPE_ERASER")]
540 Eraser,
541 #[doc(alias = "GDK_DEVICE_TOOL_TYPE_BRUSH")]
543 Brush,
544 #[doc(alias = "GDK_DEVICE_TOOL_TYPE_PENCIL")]
546 Pencil,
547 #[doc(alias = "GDK_DEVICE_TOOL_TYPE_AIRBRUSH")]
549 Airbrush,
550 #[doc(alias = "GDK_DEVICE_TOOL_TYPE_MOUSE")]
552 Mouse,
553 #[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#[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 #[doc(alias = "GDK_DMABUF_ERROR_NOT_AVAILABLE")]
666 NotAvailable,
667 #[doc(alias = "GDK_DMABUF_ERROR_UNSUPPORTED_FORMAT")]
669 UnsupportedFormat,
670 #[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#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
807#[non_exhaustive]
808#[doc(alias = "GdkDragCancelReason")]
809pub enum DragCancelReason {
810 #[doc(alias = "GDK_DRAG_CANCEL_NO_TARGET")]
812 NoTarget,
813 #[doc(alias = "GDK_DRAG_CANCEL_USER_CANCELLED")]
815 UserCancelled,
816 #[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#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
911#[non_exhaustive]
912#[doc(alias = "GdkEventType")]
913pub enum EventType {
914 #[doc(alias = "GDK_DELETE")]
918 Delete,
919 #[doc(alias = "GDK_MOTION_NOTIFY")]
921 MotionNotify,
922 #[doc(alias = "GDK_BUTTON_PRESS")]
924 ButtonPress,
925 #[doc(alias = "GDK_BUTTON_RELEASE")]
927 ButtonRelease,
928 #[doc(alias = "GDK_KEY_PRESS")]
930 KeyPress,
931 #[doc(alias = "GDK_KEY_RELEASE")]
933 KeyRelease,
934 #[doc(alias = "GDK_ENTER_NOTIFY")]
936 EnterNotify,
937 #[doc(alias = "GDK_LEAVE_NOTIFY")]
939 LeaveNotify,
940 #[doc(alias = "GDK_FOCUS_CHANGE")]
942 FocusChange,
943 #[doc(alias = "GDK_PROXIMITY_IN")]
946 ProximityIn,
947 #[doc(alias = "GDK_PROXIMITY_OUT")]
950 ProximityOut,
951 #[doc(alias = "GDK_DRAG_ENTER")]
953 DragEnter,
954 #[doc(alias = "GDK_DRAG_LEAVE")]
956 DragLeave,
957 #[doc(alias = "GDK_DRAG_MOTION")]
960 DragMotion,
961 #[doc(alias = "GDK_DROP_START")]
963 DropStart,
964 #[doc(alias = "GDK_SCROLL")]
966 Scroll,
967 #[doc(alias = "GDK_GRAB_BROKEN")]
969 GrabBroken,
970 #[doc(alias = "GDK_TOUCH_BEGIN")]
972 TouchBegin,
973 #[doc(alias = "GDK_TOUCH_UPDATE")]
975 TouchUpdate,
976 #[doc(alias = "GDK_TOUCH_END")]
978 TouchEnd,
979 #[doc(alias = "GDK_TOUCH_CANCEL")]
981 TouchCancel,
982 #[doc(alias = "GDK_TOUCHPAD_SWIPE")]
985 TouchpadSwipe,
986 #[doc(alias = "GDK_TOUCHPAD_PINCH")]
989 TouchpadPinch,
990 #[doc(alias = "GDK_PAD_BUTTON_PRESS")]
992 PadButtonPress,
993 #[doc(alias = "GDK_PAD_BUTTON_RELEASE")]
995 PadButtonRelease,
996 #[doc(alias = "GDK_PAD_RING")]
998 PadRing,
999 #[doc(alias = "GDK_PAD_STRIP")]
1001 PadStrip,
1002 #[doc(alias = "GDK_PAD_GROUP_MODE")]
1004 PadGroupMode,
1005 #[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#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1155#[non_exhaustive]
1156#[doc(alias = "GdkFullscreenMode")]
1157pub enum FullscreenMode {
1158 #[doc(alias = "GDK_FULLSCREEN_ON_CURRENT_MONITOR")]
1160 CurrentMonitor,
1161 #[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#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1254#[non_exhaustive]
1255#[doc(alias = "GdkGLError")]
1256pub enum GLError {
1257 #[doc(alias = "GDK_GL_ERROR_NOT_AVAILABLE")]
1259 NotAvailable,
1260 #[doc(alias = "GDK_GL_ERROR_UNSUPPORTED_FORMAT")]
1262 UnsupportedFormat,
1263 #[doc(alias = "GDK_GL_ERROR_UNSUPPORTED_PROFILE")]
1265 UnsupportedProfile,
1266 #[doc(alias = "GDK_GL_ERROR_COMPILATION_FAILED")]
1268 CompilationFailed,
1269 #[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#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1391#[non_exhaustive]
1392#[doc(alias = "GdkGravity")]
1393pub enum Gravity {
1394 #[doc(alias = "GDK_GRAVITY_NORTH_WEST")]
1396 NorthWest,
1397 #[doc(alias = "GDK_GRAVITY_NORTH")]
1399 North,
1400 #[doc(alias = "GDK_GRAVITY_NORTH_EAST")]
1402 NorthEast,
1403 #[doc(alias = "GDK_GRAVITY_WEST")]
1405 West,
1406 #[doc(alias = "GDK_GRAVITY_CENTER")]
1408 Center,
1409 #[doc(alias = "GDK_GRAVITY_EAST")]
1411 East,
1412 #[doc(alias = "GDK_GRAVITY_SOUTH_WEST")]
1414 SouthWest,
1415 #[doc(alias = "GDK_GRAVITY_SOUTH")]
1417 South,
1418 #[doc(alias = "GDK_GRAVITY_SOUTH_EAST")]
1420 SouthEast,
1421 #[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#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1531#[non_exhaustive]
1532#[doc(alias = "GdkInputSource")]
1533pub enum InputSource {
1534 #[doc(alias = "GDK_SOURCE_MOUSE")]
1537 Mouse,
1538 #[doc(alias = "GDK_SOURCE_PEN")]
1540 Pen,
1541 #[doc(alias = "GDK_SOURCE_KEYBOARD")]
1543 Keyboard,
1544 #[doc(alias = "GDK_SOURCE_TOUCHSCREEN")]
1547 Touchscreen,
1548 #[doc(alias = "GDK_SOURCE_TOUCHPAD")]
1551 Touchpad,
1552 #[doc(alias = "GDK_SOURCE_TRACKPOINT")]
1554 Trackpoint,
1555 #[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#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1661#[non_exhaustive]
1662#[doc(alias = "GdkKeyMatch")]
1663pub enum KeyMatch {
1664 #[doc(alias = "GDK_KEY_MATCH_NONE")]
1666 None,
1667 #[doc(alias = "GDK_KEY_MATCH_PARTIAL")]
1670 Partial,
1671 #[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#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1776#[non_exhaustive]
1777#[doc(alias = "GdkMemoryFormat")]
1778pub enum MemoryFormat {
1779 #[doc(alias = "GDK_MEMORY_B8G8R8A8_PREMULTIPLIED")]
1782 B8g8r8a8Premultiplied,
1783 #[doc(alias = "GDK_MEMORY_A8R8G8B8_PREMULTIPLIED")]
1786 A8r8g8b8Premultiplied,
1787 #[doc(alias = "GDK_MEMORY_R8G8B8A8_PREMULTIPLIED")]
1790 R8g8b8a8Premultiplied,
1791 #[doc(alias = "GDK_MEMORY_B8G8R8A8")]
1793 B8g8r8a8,
1794 #[doc(alias = "GDK_MEMORY_A8R8G8B8")]
1796 A8r8g8b8,
1797 #[doc(alias = "GDK_MEMORY_R8G8B8A8")]
1799 R8g8b8a8,
1800 #[doc(alias = "GDK_MEMORY_A8B8G8R8")]
1802 A8b8g8r8,
1803 #[doc(alias = "GDK_MEMORY_R8G8B8")]
1805 R8g8b8,
1806 #[doc(alias = "GDK_MEMORY_B8G8R8")]
1808 B8g8r8,
1809 #[cfg(feature = "v4_6")]
1811 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
1812 #[doc(alias = "GDK_MEMORY_R16G16B16")]
1813 R16g16b16,
1814 #[cfg(feature = "v4_6")]
1817 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
1818 #[doc(alias = "GDK_MEMORY_R16G16B16A16_PREMULTIPLIED")]
1819 R16g16b16a16Premultiplied,
1820 #[cfg(feature = "v4_6")]
1822 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
1823 #[doc(alias = "GDK_MEMORY_R16G16B16A16")]
1824 R16g16b16a16,
1825 #[cfg(feature = "v4_6")]
1827 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
1828 #[doc(alias = "GDK_MEMORY_R16G16B16_FLOAT")]
1829 R16g16b16Float,
1830 #[cfg(feature = "v4_6")]
1833 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
1834 #[doc(alias = "GDK_MEMORY_R16G16B16A16_FLOAT_PREMULTIPLIED")]
1835 R16g16b16a16FloatPremultiplied,
1836 #[cfg(feature = "v4_6")]
1838 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
1839 #[doc(alias = "GDK_MEMORY_R16G16B16A16_FLOAT")]
1840 R16g16b16a16Float,
1841 #[cfg(feature = "v4_6")]
1843 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
1844 #[doc(alias = "GDK_MEMORY_R32G32B32_FLOAT")]
1845 R32g32b32Float,
1846 #[cfg(feature = "v4_6")]
1849 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
1850 #[doc(alias = "GDK_MEMORY_R32G32B32A32_FLOAT_PREMULTIPLIED")]
1851 R32g32b32a32FloatPremultiplied,
1852 #[cfg(feature = "v4_6")]
1854 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
1855 #[doc(alias = "GDK_MEMORY_R32G32B32A32_FLOAT")]
1856 R32g32b32a32Float,
1857 #[cfg(feature = "v4_12")]
1860 #[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
1861 #[doc(alias = "GDK_MEMORY_G8A8_PREMULTIPLIED")]
1862 G8a8Premultiplied,
1863 #[cfg(feature = "v4_12")]
1865 #[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
1866 #[doc(alias = "GDK_MEMORY_G8A8")]
1867 G8a8,
1868 #[cfg(feature = "v4_12")]
1870 #[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
1871 #[doc(alias = "GDK_MEMORY_G8")]
1872 G8,
1873 #[cfg(feature = "v4_12")]
1876 #[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
1877 #[doc(alias = "GDK_MEMORY_G16A16_PREMULTIPLIED")]
1878 G16a16Premultiplied,
1879 #[cfg(feature = "v4_12")]
1881 #[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
1882 #[doc(alias = "GDK_MEMORY_G16A16")]
1883 G16a16,
1884 #[cfg(feature = "v4_12")]
1886 #[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
1887 #[doc(alias = "GDK_MEMORY_G16")]
1888 G16,
1889 #[cfg(feature = "v4_12")]
1891 #[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
1892 #[doc(alias = "GDK_MEMORY_A8")]
1893 A8,
1894 #[cfg(feature = "v4_12")]
1896 #[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
1897 #[doc(alias = "GDK_MEMORY_A16")]
1898 A16,
1899 #[cfg(feature = "v4_12")]
1901 #[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
1902 #[doc(alias = "GDK_MEMORY_A16_FLOAT")]
1903 A16Float,
1904 #[cfg(feature = "v4_12")]
1906 #[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
1907 #[doc(alias = "GDK_MEMORY_A32_FLOAT")]
1908 A32Float,
1909 #[cfg(feature = "v4_14")]
1912 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1913 #[doc(alias = "GDK_MEMORY_A8B8G8R8_PREMULTIPLIED")]
1914 A8b8g8r8Premultiplied,
1915 #[cfg(feature = "v4_14")]
1917 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1918 #[doc(alias = "GDK_MEMORY_B8G8R8X8")]
1919 B8g8r8x8,
1920 #[cfg(feature = "v4_14")]
1922 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1923 #[doc(alias = "GDK_MEMORY_X8R8G8B8")]
1924 X8r8g8b8,
1925 #[cfg(feature = "v4_14")]
1927 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1928 #[doc(alias = "GDK_MEMORY_R8G8B8X8")]
1929 R8g8b8x8,
1930 #[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#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2144#[non_exhaustive]
2145#[doc(alias = "GdkNotifyType")]
2146pub enum NotifyType {
2147 #[doc(alias = "GDK_NOTIFY_ANCESTOR")]
2150 Ancestor,
2151 #[doc(alias = "GDK_NOTIFY_VIRTUAL")]
2154 Virtual,
2155 #[doc(alias = "GDK_NOTIFY_INFERIOR")]
2158 Inferior,
2159 #[doc(alias = "GDK_NOTIFY_NONLINEAR")]
2162 Nonlinear,
2163 #[doc(alias = "GDK_NOTIFY_NONLINEAR_VIRTUAL")]
2168 NonlinearVirtual,
2169 #[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#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2270#[non_exhaustive]
2271#[doc(alias = "GdkScrollDirection")]
2272pub enum ScrollDirection {
2273 #[doc(alias = "GDK_SCROLL_UP")]
2275 Up,
2276 #[doc(alias = "GDK_SCROLL_DOWN")]
2278 Down,
2279 #[doc(alias = "GDK_SCROLL_LEFT")]
2281 Left,
2282 #[doc(alias = "GDK_SCROLL_RIGHT")]
2284 Right,
2285 #[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#[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 #[doc(alias = "GDK_SCROLL_UNIT_WHEEL")]
2407 Wheel,
2408 #[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#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2519#[non_exhaustive]
2520#[doc(alias = "GdkSubpixelLayout")]
2521pub enum SubpixelLayout {
2522 #[doc(alias = "GDK_SUBPIXEL_LAYOUT_UNKNOWN")]
2524 Unknown,
2525 #[doc(alias = "GDK_SUBPIXEL_LAYOUT_NONE")]
2527 None,
2528 #[doc(alias = "GDK_SUBPIXEL_LAYOUT_HORIZONTAL_RGB")]
2530 HorizontalRgb,
2531 #[doc(alias = "GDK_SUBPIXEL_LAYOUT_HORIZONTAL_BGR")]
2533 HorizontalBgr,
2534 #[doc(alias = "GDK_SUBPIXEL_LAYOUT_VERTICAL_RGB")]
2536 VerticalRgb,
2537 #[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#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2638#[non_exhaustive]
2639#[doc(alias = "GdkSurfaceEdge")]
2640pub enum SurfaceEdge {
2641 #[doc(alias = "GDK_SURFACE_EDGE_NORTH_WEST")]
2643 NorthWest,
2644 #[doc(alias = "GDK_SURFACE_EDGE_NORTH")]
2646 North,
2647 #[doc(alias = "GDK_SURFACE_EDGE_NORTH_EAST")]
2649 NorthEast,
2650 #[doc(alias = "GDK_SURFACE_EDGE_WEST")]
2652 West,
2653 #[doc(alias = "GDK_SURFACE_EDGE_EAST")]
2655 East,
2656 #[doc(alias = "GDK_SURFACE_EDGE_SOUTH_WEST")]
2658 SouthWest,
2659 #[doc(alias = "GDK_SURFACE_EDGE_SOUTH")]
2661 South,
2662 #[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#[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 #[doc(alias = "GDK_TEXTURE_ERROR_TOO_LARGE")]
2774 TooLarge,
2775 #[doc(alias = "GDK_TEXTURE_ERROR_CORRUPT_IMAGE")]
2777 CorruptImage,
2778 #[doc(alias = "GDK_TEXTURE_ERROR_UNSUPPORTED_CONTENT")]
2781 UnsupportedContent,
2782 #[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#[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 #[doc(alias = "GDK_TITLEBAR_GESTURE_DOUBLE_CLICK")]
2928 DoubleClick,
2929 #[doc(alias = "GDK_TITLEBAR_GESTURE_RIGHT_CLICK")]
2931 RightClick,
2932 #[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#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3060#[non_exhaustive]
3061#[doc(alias = "GdkTouchpadGesturePhase")]
3062pub enum TouchpadGesturePhase {
3063 #[doc(alias = "GDK_TOUCHPAD_GESTURE_PHASE_BEGIN")]
3065 Begin,
3066 #[doc(alias = "GDK_TOUCHPAD_GESTURE_PHASE_UPDATE")]
3068 Update,
3069 #[doc(alias = "GDK_TOUCHPAD_GESTURE_PHASE_END")]
3072 End,
3073 #[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#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3171#[non_exhaustive]
3172#[doc(alias = "GdkVulkanError")]
3173pub enum VulkanError {
3174 #[doc(alias = "GDK_VULKAN_ERROR_UNSUPPORTED")]
3177 Unsupported,
3178 #[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}