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