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_PRESSURE")]
19 Pressure,
20 #[doc(alias = "GDK_AXIS_XTILT")]
21 Xtilt,
22 #[doc(alias = "GDK_AXIS_YTILT")]
23 Ytilt,
24 #[doc(alias = "GDK_AXIS_WHEEL")]
25 Wheel,
26 #[doc(alias = "GDK_AXIS_DISTANCE")]
27 Distance,
28 #[doc(alias = "GDK_AXIS_ROTATION")]
29 Rotation,
30 #[doc(alias = "GDK_AXIS_SLIDER")]
31 Slider,
32 #[doc(alias = "GDK_AXIS_LAST")]
33 Last,
34 #[doc(hidden)]
35 __Unknown(i32),
36}
37
38#[doc(hidden)]
39impl IntoGlib for AxisUse {
40 type GlibType = ffi::GdkAxisUse;
41
42 #[inline]
43 fn into_glib(self) -> ffi::GdkAxisUse {
44 match self {
45 Self::Ignore => ffi::GDK_AXIS_IGNORE,
46 Self::X => ffi::GDK_AXIS_X,
47 Self::Y => ffi::GDK_AXIS_Y,
48 Self::Pressure => ffi::GDK_AXIS_PRESSURE,
49 Self::Xtilt => ffi::GDK_AXIS_XTILT,
50 Self::Ytilt => ffi::GDK_AXIS_YTILT,
51 Self::Wheel => ffi::GDK_AXIS_WHEEL,
52 Self::Distance => ffi::GDK_AXIS_DISTANCE,
53 Self::Rotation => ffi::GDK_AXIS_ROTATION,
54 Self::Slider => ffi::GDK_AXIS_SLIDER,
55 Self::Last => ffi::GDK_AXIS_LAST,
56 Self::__Unknown(value) => value,
57 }
58 }
59}
60
61#[doc(hidden)]
62impl FromGlib<ffi::GdkAxisUse> for AxisUse {
63 #[inline]
64 unsafe fn from_glib(value: ffi::GdkAxisUse) -> Self {
65 skip_assert_initialized!();
66
67 match value {
68 ffi::GDK_AXIS_IGNORE => Self::Ignore,
69 ffi::GDK_AXIS_X => Self::X,
70 ffi::GDK_AXIS_Y => Self::Y,
71 ffi::GDK_AXIS_PRESSURE => Self::Pressure,
72 ffi::GDK_AXIS_XTILT => Self::Xtilt,
73 ffi::GDK_AXIS_YTILT => Self::Ytilt,
74 ffi::GDK_AXIS_WHEEL => Self::Wheel,
75 ffi::GDK_AXIS_DISTANCE => Self::Distance,
76 ffi::GDK_AXIS_ROTATION => Self::Rotation,
77 ffi::GDK_AXIS_SLIDER => Self::Slider,
78 ffi::GDK_AXIS_LAST => Self::Last,
79 value => Self::__Unknown(value),
80 }
81 }
82}
83
84impl StaticType for AxisUse {
85 #[inline]
86 #[doc(alias = "gdk_axis_use_get_type")]
87 fn static_type() -> glib::Type {
88 unsafe { from_glib(ffi::gdk_axis_use_get_type()) }
89 }
90}
91
92impl glib::HasParamSpec for AxisUse {
93 type ParamSpec = glib::ParamSpecEnum;
94 type SetValue = Self;
95 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
96
97 fn param_spec_builder() -> Self::BuilderFn {
98 Self::ParamSpec::builder_with_default
99 }
100}
101
102impl glib::value::ValueType for AxisUse {
103 type Type = Self;
104}
105
106unsafe impl<'a> glib::value::FromValue<'a> for AxisUse {
107 type Checker = glib::value::GenericValueTypeChecker<Self>;
108
109 #[inline]
110 unsafe fn from_value(value: &'a glib::Value) -> Self {
111 skip_assert_initialized!();
112 unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
113 }
114}
115
116impl ToValue for AxisUse {
117 #[inline]
118 fn to_value(&self) -> glib::Value {
119 let mut value = glib::Value::for_value_type::<Self>();
120 unsafe {
121 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
122 }
123 value
124 }
125
126 #[inline]
127 fn value_type(&self) -> glib::Type {
128 Self::static_type()
129 }
130}
131
132impl From<AxisUse> for glib::Value {
133 #[inline]
134 fn from(v: AxisUse) -> Self {
135 skip_assert_initialized!();
136 ToValue::to_value(&v)
137 }
138}
139
140#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
141#[non_exhaustive]
142#[doc(alias = "GdkByteOrder")]
143pub enum ByteOrder {
144 #[doc(alias = "GDK_LSB_FIRST")]
145 LsbFirst,
146 #[doc(alias = "GDK_MSB_FIRST")]
147 MsbFirst,
148 #[doc(hidden)]
149 __Unknown(i32),
150}
151
152#[doc(hidden)]
153impl IntoGlib for ByteOrder {
154 type GlibType = ffi::GdkByteOrder;
155
156 #[inline]
157 fn into_glib(self) -> ffi::GdkByteOrder {
158 match self {
159 Self::LsbFirst => ffi::GDK_LSB_FIRST,
160 Self::MsbFirst => ffi::GDK_MSB_FIRST,
161 Self::__Unknown(value) => value,
162 }
163 }
164}
165
166#[doc(hidden)]
167impl FromGlib<ffi::GdkByteOrder> for ByteOrder {
168 #[inline]
169 unsafe fn from_glib(value: ffi::GdkByteOrder) -> Self {
170 skip_assert_initialized!();
171
172 match value {
173 ffi::GDK_LSB_FIRST => Self::LsbFirst,
174 ffi::GDK_MSB_FIRST => Self::MsbFirst,
175 value => Self::__Unknown(value),
176 }
177 }
178}
179
180impl StaticType for ByteOrder {
181 #[inline]
182 #[doc(alias = "gdk_byte_order_get_type")]
183 fn static_type() -> glib::Type {
184 unsafe { from_glib(ffi::gdk_byte_order_get_type()) }
185 }
186}
187
188impl glib::HasParamSpec for ByteOrder {
189 type ParamSpec = glib::ParamSpecEnum;
190 type SetValue = Self;
191 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
192
193 fn param_spec_builder() -> Self::BuilderFn {
194 Self::ParamSpec::builder_with_default
195 }
196}
197
198impl glib::value::ValueType for ByteOrder {
199 type Type = Self;
200}
201
202unsafe impl<'a> glib::value::FromValue<'a> for ByteOrder {
203 type Checker = glib::value::GenericValueTypeChecker<Self>;
204
205 #[inline]
206 unsafe fn from_value(value: &'a glib::Value) -> Self {
207 skip_assert_initialized!();
208 unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
209 }
210}
211
212impl ToValue for ByteOrder {
213 #[inline]
214 fn to_value(&self) -> glib::Value {
215 let mut value = glib::Value::for_value_type::<Self>();
216 unsafe {
217 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
218 }
219 value
220 }
221
222 #[inline]
223 fn value_type(&self) -> glib::Type {
224 Self::static_type()
225 }
226}
227
228impl From<ByteOrder> for glib::Value {
229 #[inline]
230 fn from(v: ByteOrder) -> Self {
231 skip_assert_initialized!();
232 ToValue::to_value(&v)
233 }
234}
235
236#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
237#[non_exhaustive]
238#[doc(alias = "GdkCrossingMode")]
239pub enum CrossingMode {
240 #[doc(alias = "GDK_CROSSING_NORMAL")]
241 Normal,
242 #[doc(alias = "GDK_CROSSING_GRAB")]
243 Grab,
244 #[doc(alias = "GDK_CROSSING_UNGRAB")]
245 Ungrab,
246 #[doc(alias = "GDK_CROSSING_GTK_GRAB")]
247 GtkGrab,
248 #[doc(alias = "GDK_CROSSING_GTK_UNGRAB")]
249 GtkUngrab,
250 #[doc(alias = "GDK_CROSSING_STATE_CHANGED")]
251 StateChanged,
252 #[doc(alias = "GDK_CROSSING_TOUCH_BEGIN")]
253 TouchBegin,
254 #[doc(alias = "GDK_CROSSING_TOUCH_END")]
255 TouchEnd,
256 #[doc(alias = "GDK_CROSSING_DEVICE_SWITCH")]
257 DeviceSwitch,
258 #[doc(hidden)]
259 __Unknown(i32),
260}
261
262#[doc(hidden)]
263impl IntoGlib for CrossingMode {
264 type GlibType = ffi::GdkCrossingMode;
265
266 #[inline]
267 fn into_glib(self) -> ffi::GdkCrossingMode {
268 match self {
269 Self::Normal => ffi::GDK_CROSSING_NORMAL,
270 Self::Grab => ffi::GDK_CROSSING_GRAB,
271 Self::Ungrab => ffi::GDK_CROSSING_UNGRAB,
272 Self::GtkGrab => ffi::GDK_CROSSING_GTK_GRAB,
273 Self::GtkUngrab => ffi::GDK_CROSSING_GTK_UNGRAB,
274 Self::StateChanged => ffi::GDK_CROSSING_STATE_CHANGED,
275 Self::TouchBegin => ffi::GDK_CROSSING_TOUCH_BEGIN,
276 Self::TouchEnd => ffi::GDK_CROSSING_TOUCH_END,
277 Self::DeviceSwitch => ffi::GDK_CROSSING_DEVICE_SWITCH,
278 Self::__Unknown(value) => value,
279 }
280 }
281}
282
283#[doc(hidden)]
284impl FromGlib<ffi::GdkCrossingMode> for CrossingMode {
285 #[inline]
286 unsafe fn from_glib(value: ffi::GdkCrossingMode) -> Self {
287 skip_assert_initialized!();
288
289 match value {
290 ffi::GDK_CROSSING_NORMAL => Self::Normal,
291 ffi::GDK_CROSSING_GRAB => Self::Grab,
292 ffi::GDK_CROSSING_UNGRAB => Self::Ungrab,
293 ffi::GDK_CROSSING_GTK_GRAB => Self::GtkGrab,
294 ffi::GDK_CROSSING_GTK_UNGRAB => Self::GtkUngrab,
295 ffi::GDK_CROSSING_STATE_CHANGED => Self::StateChanged,
296 ffi::GDK_CROSSING_TOUCH_BEGIN => Self::TouchBegin,
297 ffi::GDK_CROSSING_TOUCH_END => Self::TouchEnd,
298 ffi::GDK_CROSSING_DEVICE_SWITCH => Self::DeviceSwitch,
299 value => Self::__Unknown(value),
300 }
301 }
302}
303
304impl StaticType for CrossingMode {
305 #[inline]
306 #[doc(alias = "gdk_crossing_mode_get_type")]
307 fn static_type() -> glib::Type {
308 unsafe { from_glib(ffi::gdk_crossing_mode_get_type()) }
309 }
310}
311
312impl glib::HasParamSpec for CrossingMode {
313 type ParamSpec = glib::ParamSpecEnum;
314 type SetValue = Self;
315 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
316
317 fn param_spec_builder() -> Self::BuilderFn {
318 Self::ParamSpec::builder_with_default
319 }
320}
321
322impl glib::value::ValueType for CrossingMode {
323 type Type = Self;
324}
325
326unsafe impl<'a> glib::value::FromValue<'a> for CrossingMode {
327 type Checker = glib::value::GenericValueTypeChecker<Self>;
328
329 #[inline]
330 unsafe fn from_value(value: &'a glib::Value) -> Self {
331 skip_assert_initialized!();
332 unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
333 }
334}
335
336impl ToValue for CrossingMode {
337 #[inline]
338 fn to_value(&self) -> glib::Value {
339 let mut value = glib::Value::for_value_type::<Self>();
340 unsafe {
341 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
342 }
343 value
344 }
345
346 #[inline]
347 fn value_type(&self) -> glib::Type {
348 Self::static_type()
349 }
350}
351
352impl From<CrossingMode> for glib::Value {
353 #[inline]
354 fn from(v: CrossingMode) -> Self {
355 skip_assert_initialized!();
356 ToValue::to_value(&v)
357 }
358}
359
360#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
361#[non_exhaustive]
362#[doc(alias = "GdkCursorType")]
363pub enum CursorType {
364 #[doc(alias = "GDK_X_CURSOR")]
365 XCursor,
366 #[doc(alias = "GDK_ARROW")]
367 Arrow,
368 #[doc(alias = "GDK_BASED_ARROW_DOWN")]
369 BasedArrowDown,
370 #[doc(alias = "GDK_BASED_ARROW_UP")]
371 BasedArrowUp,
372 #[doc(alias = "GDK_BOAT")]
373 Boat,
374 #[doc(alias = "GDK_BOGOSITY")]
375 Bogosity,
376 #[doc(alias = "GDK_BOTTOM_LEFT_CORNER")]
377 BottomLeftCorner,
378 #[doc(alias = "GDK_BOTTOM_RIGHT_CORNER")]
379 BottomRightCorner,
380 #[doc(alias = "GDK_BOTTOM_SIDE")]
381 BottomSide,
382 #[doc(alias = "GDK_BOTTOM_TEE")]
383 BottomTee,
384 #[doc(alias = "GDK_BOX_SPIRAL")]
385 BoxSpiral,
386 #[doc(alias = "GDK_CENTER_PTR")]
387 CenterPtr,
388 #[doc(alias = "GDK_CIRCLE")]
389 Circle,
390 #[doc(alias = "GDK_CLOCK")]
391 Clock,
392 #[doc(alias = "GDK_COFFEE_MUG")]
393 CoffeeMug,
394 #[doc(alias = "GDK_CROSS")]
395 Cross,
396 #[doc(alias = "GDK_CROSS_REVERSE")]
397 CrossReverse,
398 #[doc(alias = "GDK_CROSSHAIR")]
399 Crosshair,
400 #[doc(alias = "GDK_DIAMOND_CROSS")]
401 DiamondCross,
402 #[doc(alias = "GDK_DOT")]
403 Dot,
404 #[doc(alias = "GDK_DOTBOX")]
405 Dotbox,
406 #[doc(alias = "GDK_DOUBLE_ARROW")]
407 DoubleArrow,
408 #[doc(alias = "GDK_DRAFT_LARGE")]
409 DraftLarge,
410 #[doc(alias = "GDK_DRAFT_SMALL")]
411 DraftSmall,
412 #[doc(alias = "GDK_DRAPED_BOX")]
413 DrapedBox,
414 #[doc(alias = "GDK_EXCHANGE")]
415 Exchange,
416 #[doc(alias = "GDK_FLEUR")]
417 Fleur,
418 #[doc(alias = "GDK_GOBBLER")]
419 Gobbler,
420 #[doc(alias = "GDK_GUMBY")]
421 Gumby,
422 #[doc(alias = "GDK_HAND1")]
423 Hand1,
424 #[doc(alias = "GDK_HAND2")]
425 Hand2,
426 #[doc(alias = "GDK_HEART")]
427 Heart,
428 #[doc(alias = "GDK_ICON")]
429 Icon,
430 #[doc(alias = "GDK_IRON_CROSS")]
431 IronCross,
432 #[doc(alias = "GDK_LEFT_PTR")]
433 LeftPtr,
434 #[doc(alias = "GDK_LEFT_SIDE")]
435 LeftSide,
436 #[doc(alias = "GDK_LEFT_TEE")]
437 LeftTee,
438 #[doc(alias = "GDK_LEFTBUTTON")]
439 Leftbutton,
440 #[doc(alias = "GDK_LL_ANGLE")]
441 LlAngle,
442 #[doc(alias = "GDK_LR_ANGLE")]
443 LrAngle,
444 #[doc(alias = "GDK_MAN")]
445 Man,
446 #[doc(alias = "GDK_MIDDLEBUTTON")]
447 Middlebutton,
448 #[doc(alias = "GDK_MOUSE")]
449 Mouse,
450 #[doc(alias = "GDK_PENCIL")]
451 Pencil,
452 #[doc(alias = "GDK_PIRATE")]
453 Pirate,
454 #[doc(alias = "GDK_PLUS")]
455 Plus,
456 #[doc(alias = "GDK_QUESTION_ARROW")]
457 QuestionArrow,
458 #[doc(alias = "GDK_RIGHT_PTR")]
459 RightPtr,
460 #[doc(alias = "GDK_RIGHT_SIDE")]
461 RightSide,
462 #[doc(alias = "GDK_RIGHT_TEE")]
463 RightTee,
464 #[doc(alias = "GDK_RIGHTBUTTON")]
465 Rightbutton,
466 #[doc(alias = "GDK_RTL_LOGO")]
467 RtlLogo,
468 #[doc(alias = "GDK_SAILBOAT")]
469 Sailboat,
470 #[doc(alias = "GDK_SB_DOWN_ARROW")]
471 SbDownArrow,
472 #[doc(alias = "GDK_SB_H_DOUBLE_ARROW")]
473 SbHDoubleArrow,
474 #[doc(alias = "GDK_SB_LEFT_ARROW")]
475 SbLeftArrow,
476 #[doc(alias = "GDK_SB_RIGHT_ARROW")]
477 SbRightArrow,
478 #[doc(alias = "GDK_SB_UP_ARROW")]
479 SbUpArrow,
480 #[doc(alias = "GDK_SB_V_DOUBLE_ARROW")]
481 SbVDoubleArrow,
482 #[doc(alias = "GDK_SHUTTLE")]
483 Shuttle,
484 #[doc(alias = "GDK_SIZING")]
485 Sizing,
486 #[doc(alias = "GDK_SPIDER")]
487 Spider,
488 #[doc(alias = "GDK_SPRAYCAN")]
489 Spraycan,
490 #[doc(alias = "GDK_STAR")]
491 Star,
492 #[doc(alias = "GDK_TARGET")]
493 Target,
494 #[doc(alias = "GDK_TCROSS")]
495 Tcross,
496 #[doc(alias = "GDK_TOP_LEFT_ARROW")]
497 TopLeftArrow,
498 #[doc(alias = "GDK_TOP_LEFT_CORNER")]
499 TopLeftCorner,
500 #[doc(alias = "GDK_TOP_RIGHT_CORNER")]
501 TopRightCorner,
502 #[doc(alias = "GDK_TOP_SIDE")]
503 TopSide,
504 #[doc(alias = "GDK_TOP_TEE")]
505 TopTee,
506 #[doc(alias = "GDK_TREK")]
507 Trek,
508 #[doc(alias = "GDK_UL_ANGLE")]
509 UlAngle,
510 #[doc(alias = "GDK_UMBRELLA")]
511 Umbrella,
512 #[doc(alias = "GDK_UR_ANGLE")]
513 UrAngle,
514 #[doc(alias = "GDK_WATCH")]
515 Watch,
516 #[doc(alias = "GDK_XTERM")]
517 Xterm,
518 #[doc(alias = "GDK_LAST_CURSOR")]
519 LastCursor,
520 #[doc(alias = "GDK_BLANK_CURSOR")]
521 BlankCursor,
522 #[doc(alias = "GDK_CURSOR_IS_PIXMAP")]
523 CursorIsPixmap,
524 #[doc(hidden)]
525 __Unknown(i32),
526}
527
528#[doc(hidden)]
529impl IntoGlib for CursorType {
530 type GlibType = ffi::GdkCursorType;
531
532 fn into_glib(self) -> ffi::GdkCursorType {
533 match self {
534 Self::XCursor => ffi::GDK_X_CURSOR,
535 Self::Arrow => ffi::GDK_ARROW,
536 Self::BasedArrowDown => ffi::GDK_BASED_ARROW_DOWN,
537 Self::BasedArrowUp => ffi::GDK_BASED_ARROW_UP,
538 Self::Boat => ffi::GDK_BOAT,
539 Self::Bogosity => ffi::GDK_BOGOSITY,
540 Self::BottomLeftCorner => ffi::GDK_BOTTOM_LEFT_CORNER,
541 Self::BottomRightCorner => ffi::GDK_BOTTOM_RIGHT_CORNER,
542 Self::BottomSide => ffi::GDK_BOTTOM_SIDE,
543 Self::BottomTee => ffi::GDK_BOTTOM_TEE,
544 Self::BoxSpiral => ffi::GDK_BOX_SPIRAL,
545 Self::CenterPtr => ffi::GDK_CENTER_PTR,
546 Self::Circle => ffi::GDK_CIRCLE,
547 Self::Clock => ffi::GDK_CLOCK,
548 Self::CoffeeMug => ffi::GDK_COFFEE_MUG,
549 Self::Cross => ffi::GDK_CROSS,
550 Self::CrossReverse => ffi::GDK_CROSS_REVERSE,
551 Self::Crosshair => ffi::GDK_CROSSHAIR,
552 Self::DiamondCross => ffi::GDK_DIAMOND_CROSS,
553 Self::Dot => ffi::GDK_DOT,
554 Self::Dotbox => ffi::GDK_DOTBOX,
555 Self::DoubleArrow => ffi::GDK_DOUBLE_ARROW,
556 Self::DraftLarge => ffi::GDK_DRAFT_LARGE,
557 Self::DraftSmall => ffi::GDK_DRAFT_SMALL,
558 Self::DrapedBox => ffi::GDK_DRAPED_BOX,
559 Self::Exchange => ffi::GDK_EXCHANGE,
560 Self::Fleur => ffi::GDK_FLEUR,
561 Self::Gobbler => ffi::GDK_GOBBLER,
562 Self::Gumby => ffi::GDK_GUMBY,
563 Self::Hand1 => ffi::GDK_HAND1,
564 Self::Hand2 => ffi::GDK_HAND2,
565 Self::Heart => ffi::GDK_HEART,
566 Self::Icon => ffi::GDK_ICON,
567 Self::IronCross => ffi::GDK_IRON_CROSS,
568 Self::LeftPtr => ffi::GDK_LEFT_PTR,
569 Self::LeftSide => ffi::GDK_LEFT_SIDE,
570 Self::LeftTee => ffi::GDK_LEFT_TEE,
571 Self::Leftbutton => ffi::GDK_LEFTBUTTON,
572 Self::LlAngle => ffi::GDK_LL_ANGLE,
573 Self::LrAngle => ffi::GDK_LR_ANGLE,
574 Self::Man => ffi::GDK_MAN,
575 Self::Middlebutton => ffi::GDK_MIDDLEBUTTON,
576 Self::Mouse => ffi::GDK_MOUSE,
577 Self::Pencil => ffi::GDK_PENCIL,
578 Self::Pirate => ffi::GDK_PIRATE,
579 Self::Plus => ffi::GDK_PLUS,
580 Self::QuestionArrow => ffi::GDK_QUESTION_ARROW,
581 Self::RightPtr => ffi::GDK_RIGHT_PTR,
582 Self::RightSide => ffi::GDK_RIGHT_SIDE,
583 Self::RightTee => ffi::GDK_RIGHT_TEE,
584 Self::Rightbutton => ffi::GDK_RIGHTBUTTON,
585 Self::RtlLogo => ffi::GDK_RTL_LOGO,
586 Self::Sailboat => ffi::GDK_SAILBOAT,
587 Self::SbDownArrow => ffi::GDK_SB_DOWN_ARROW,
588 Self::SbHDoubleArrow => ffi::GDK_SB_H_DOUBLE_ARROW,
589 Self::SbLeftArrow => ffi::GDK_SB_LEFT_ARROW,
590 Self::SbRightArrow => ffi::GDK_SB_RIGHT_ARROW,
591 Self::SbUpArrow => ffi::GDK_SB_UP_ARROW,
592 Self::SbVDoubleArrow => ffi::GDK_SB_V_DOUBLE_ARROW,
593 Self::Shuttle => ffi::GDK_SHUTTLE,
594 Self::Sizing => ffi::GDK_SIZING,
595 Self::Spider => ffi::GDK_SPIDER,
596 Self::Spraycan => ffi::GDK_SPRAYCAN,
597 Self::Star => ffi::GDK_STAR,
598 Self::Target => ffi::GDK_TARGET,
599 Self::Tcross => ffi::GDK_TCROSS,
600 Self::TopLeftArrow => ffi::GDK_TOP_LEFT_ARROW,
601 Self::TopLeftCorner => ffi::GDK_TOP_LEFT_CORNER,
602 Self::TopRightCorner => ffi::GDK_TOP_RIGHT_CORNER,
603 Self::TopSide => ffi::GDK_TOP_SIDE,
604 Self::TopTee => ffi::GDK_TOP_TEE,
605 Self::Trek => ffi::GDK_TREK,
606 Self::UlAngle => ffi::GDK_UL_ANGLE,
607 Self::Umbrella => ffi::GDK_UMBRELLA,
608 Self::UrAngle => ffi::GDK_UR_ANGLE,
609 Self::Watch => ffi::GDK_WATCH,
610 Self::Xterm => ffi::GDK_XTERM,
611 Self::LastCursor => ffi::GDK_LAST_CURSOR,
612 Self::BlankCursor => ffi::GDK_BLANK_CURSOR,
613 Self::CursorIsPixmap => ffi::GDK_CURSOR_IS_PIXMAP,
614 Self::__Unknown(value) => value,
615 }
616 }
617}
618
619#[doc(hidden)]
620impl FromGlib<ffi::GdkCursorType> for CursorType {
621 unsafe fn from_glib(value: ffi::GdkCursorType) -> Self {
622 skip_assert_initialized!();
623
624 match value {
625 ffi::GDK_X_CURSOR => Self::XCursor,
626 ffi::GDK_ARROW => Self::Arrow,
627 ffi::GDK_BASED_ARROW_DOWN => Self::BasedArrowDown,
628 ffi::GDK_BASED_ARROW_UP => Self::BasedArrowUp,
629 ffi::GDK_BOAT => Self::Boat,
630 ffi::GDK_BOGOSITY => Self::Bogosity,
631 ffi::GDK_BOTTOM_LEFT_CORNER => Self::BottomLeftCorner,
632 ffi::GDK_BOTTOM_RIGHT_CORNER => Self::BottomRightCorner,
633 ffi::GDK_BOTTOM_SIDE => Self::BottomSide,
634 ffi::GDK_BOTTOM_TEE => Self::BottomTee,
635 ffi::GDK_BOX_SPIRAL => Self::BoxSpiral,
636 ffi::GDK_CENTER_PTR => Self::CenterPtr,
637 ffi::GDK_CIRCLE => Self::Circle,
638 ffi::GDK_CLOCK => Self::Clock,
639 ffi::GDK_COFFEE_MUG => Self::CoffeeMug,
640 ffi::GDK_CROSS => Self::Cross,
641 ffi::GDK_CROSS_REVERSE => Self::CrossReverse,
642 ffi::GDK_CROSSHAIR => Self::Crosshair,
643 ffi::GDK_DIAMOND_CROSS => Self::DiamondCross,
644 ffi::GDK_DOT => Self::Dot,
645 ffi::GDK_DOTBOX => Self::Dotbox,
646 ffi::GDK_DOUBLE_ARROW => Self::DoubleArrow,
647 ffi::GDK_DRAFT_LARGE => Self::DraftLarge,
648 ffi::GDK_DRAFT_SMALL => Self::DraftSmall,
649 ffi::GDK_DRAPED_BOX => Self::DrapedBox,
650 ffi::GDK_EXCHANGE => Self::Exchange,
651 ffi::GDK_FLEUR => Self::Fleur,
652 ffi::GDK_GOBBLER => Self::Gobbler,
653 ffi::GDK_GUMBY => Self::Gumby,
654 ffi::GDK_HAND1 => Self::Hand1,
655 ffi::GDK_HAND2 => Self::Hand2,
656 ffi::GDK_HEART => Self::Heart,
657 ffi::GDK_ICON => Self::Icon,
658 ffi::GDK_IRON_CROSS => Self::IronCross,
659 ffi::GDK_LEFT_PTR => Self::LeftPtr,
660 ffi::GDK_LEFT_SIDE => Self::LeftSide,
661 ffi::GDK_LEFT_TEE => Self::LeftTee,
662 ffi::GDK_LEFTBUTTON => Self::Leftbutton,
663 ffi::GDK_LL_ANGLE => Self::LlAngle,
664 ffi::GDK_LR_ANGLE => Self::LrAngle,
665 ffi::GDK_MAN => Self::Man,
666 ffi::GDK_MIDDLEBUTTON => Self::Middlebutton,
667 ffi::GDK_MOUSE => Self::Mouse,
668 ffi::GDK_PENCIL => Self::Pencil,
669 ffi::GDK_PIRATE => Self::Pirate,
670 ffi::GDK_PLUS => Self::Plus,
671 ffi::GDK_QUESTION_ARROW => Self::QuestionArrow,
672 ffi::GDK_RIGHT_PTR => Self::RightPtr,
673 ffi::GDK_RIGHT_SIDE => Self::RightSide,
674 ffi::GDK_RIGHT_TEE => Self::RightTee,
675 ffi::GDK_RIGHTBUTTON => Self::Rightbutton,
676 ffi::GDK_RTL_LOGO => Self::RtlLogo,
677 ffi::GDK_SAILBOAT => Self::Sailboat,
678 ffi::GDK_SB_DOWN_ARROW => Self::SbDownArrow,
679 ffi::GDK_SB_H_DOUBLE_ARROW => Self::SbHDoubleArrow,
680 ffi::GDK_SB_LEFT_ARROW => Self::SbLeftArrow,
681 ffi::GDK_SB_RIGHT_ARROW => Self::SbRightArrow,
682 ffi::GDK_SB_UP_ARROW => Self::SbUpArrow,
683 ffi::GDK_SB_V_DOUBLE_ARROW => Self::SbVDoubleArrow,
684 ffi::GDK_SHUTTLE => Self::Shuttle,
685 ffi::GDK_SIZING => Self::Sizing,
686 ffi::GDK_SPIDER => Self::Spider,
687 ffi::GDK_SPRAYCAN => Self::Spraycan,
688 ffi::GDK_STAR => Self::Star,
689 ffi::GDK_TARGET => Self::Target,
690 ffi::GDK_TCROSS => Self::Tcross,
691 ffi::GDK_TOP_LEFT_ARROW => Self::TopLeftArrow,
692 ffi::GDK_TOP_LEFT_CORNER => Self::TopLeftCorner,
693 ffi::GDK_TOP_RIGHT_CORNER => Self::TopRightCorner,
694 ffi::GDK_TOP_SIDE => Self::TopSide,
695 ffi::GDK_TOP_TEE => Self::TopTee,
696 ffi::GDK_TREK => Self::Trek,
697 ffi::GDK_UL_ANGLE => Self::UlAngle,
698 ffi::GDK_UMBRELLA => Self::Umbrella,
699 ffi::GDK_UR_ANGLE => Self::UrAngle,
700 ffi::GDK_WATCH => Self::Watch,
701 ffi::GDK_XTERM => Self::Xterm,
702 ffi::GDK_LAST_CURSOR => Self::LastCursor,
703 ffi::GDK_BLANK_CURSOR => Self::BlankCursor,
704 ffi::GDK_CURSOR_IS_PIXMAP => Self::CursorIsPixmap,
705 value => Self::__Unknown(value),
706 }
707 }
708}
709
710impl StaticType for CursorType {
711 #[inline]
712 #[doc(alias = "gdk_cursor_type_get_type")]
713 fn static_type() -> glib::Type {
714 unsafe { from_glib(ffi::gdk_cursor_type_get_type()) }
715 }
716}
717
718impl glib::HasParamSpec for CursorType {
719 type ParamSpec = glib::ParamSpecEnum;
720 type SetValue = Self;
721 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
722
723 fn param_spec_builder() -> Self::BuilderFn {
724 Self::ParamSpec::builder_with_default
725 }
726}
727
728impl glib::value::ValueType for CursorType {
729 type Type = Self;
730}
731
732unsafe impl<'a> glib::value::FromValue<'a> for CursorType {
733 type Checker = glib::value::GenericValueTypeChecker<Self>;
734
735 #[inline]
736 unsafe fn from_value(value: &'a glib::Value) -> Self {
737 skip_assert_initialized!();
738 unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
739 }
740}
741
742impl ToValue for CursorType {
743 #[inline]
744 fn to_value(&self) -> glib::Value {
745 let mut value = glib::Value::for_value_type::<Self>();
746 unsafe {
747 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
748 }
749 value
750 }
751
752 #[inline]
753 fn value_type(&self) -> glib::Type {
754 Self::static_type()
755 }
756}
757
758impl From<CursorType> for glib::Value {
759 #[inline]
760 fn from(v: CursorType) -> Self {
761 skip_assert_initialized!();
762 ToValue::to_value(&v)
763 }
764}
765
766#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
767#[non_exhaustive]
768#[doc(alias = "GdkDevicePadFeature")]
769pub enum DevicePadFeature {
770 #[doc(alias = "GDK_DEVICE_PAD_FEATURE_BUTTON")]
771 Button,
772 #[doc(alias = "GDK_DEVICE_PAD_FEATURE_RING")]
773 Ring,
774 #[doc(alias = "GDK_DEVICE_PAD_FEATURE_STRIP")]
775 Strip,
776 #[doc(hidden)]
777 __Unknown(i32),
778}
779
780#[doc(hidden)]
781impl IntoGlib for DevicePadFeature {
782 type GlibType = ffi::GdkDevicePadFeature;
783
784 #[inline]
785 fn into_glib(self) -> ffi::GdkDevicePadFeature {
786 match self {
787 Self::Button => ffi::GDK_DEVICE_PAD_FEATURE_BUTTON,
788 Self::Ring => ffi::GDK_DEVICE_PAD_FEATURE_RING,
789 Self::Strip => ffi::GDK_DEVICE_PAD_FEATURE_STRIP,
790 Self::__Unknown(value) => value,
791 }
792 }
793}
794
795#[doc(hidden)]
796impl FromGlib<ffi::GdkDevicePadFeature> for DevicePadFeature {
797 #[inline]
798 unsafe fn from_glib(value: ffi::GdkDevicePadFeature) -> Self {
799 skip_assert_initialized!();
800
801 match value {
802 ffi::GDK_DEVICE_PAD_FEATURE_BUTTON => Self::Button,
803 ffi::GDK_DEVICE_PAD_FEATURE_RING => Self::Ring,
804 ffi::GDK_DEVICE_PAD_FEATURE_STRIP => Self::Strip,
805 value => Self::__Unknown(value),
806 }
807 }
808}
809
810impl StaticType for DevicePadFeature {
811 #[inline]
812 #[doc(alias = "gdk_device_pad_feature_get_type")]
813 fn static_type() -> glib::Type {
814 unsafe { from_glib(ffi::gdk_device_pad_feature_get_type()) }
815 }
816}
817
818impl glib::HasParamSpec for DevicePadFeature {
819 type ParamSpec = glib::ParamSpecEnum;
820 type SetValue = Self;
821 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
822
823 fn param_spec_builder() -> Self::BuilderFn {
824 Self::ParamSpec::builder_with_default
825 }
826}
827
828impl glib::value::ValueType for DevicePadFeature {
829 type Type = Self;
830}
831
832unsafe impl<'a> glib::value::FromValue<'a> for DevicePadFeature {
833 type Checker = glib::value::GenericValueTypeChecker<Self>;
834
835 #[inline]
836 unsafe fn from_value(value: &'a glib::Value) -> Self {
837 skip_assert_initialized!();
838 unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
839 }
840}
841
842impl ToValue for DevicePadFeature {
843 #[inline]
844 fn to_value(&self) -> glib::Value {
845 let mut value = glib::Value::for_value_type::<Self>();
846 unsafe {
847 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
848 }
849 value
850 }
851
852 #[inline]
853 fn value_type(&self) -> glib::Type {
854 Self::static_type()
855 }
856}
857
858impl From<DevicePadFeature> for glib::Value {
859 #[inline]
860 fn from(v: DevicePadFeature) -> Self {
861 skip_assert_initialized!();
862 ToValue::to_value(&v)
863 }
864}
865
866#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
867#[non_exhaustive]
868#[doc(alias = "GdkDeviceToolType")]
869pub enum DeviceToolType {
870 #[doc(alias = "GDK_DEVICE_TOOL_TYPE_UNKNOWN")]
871 Unknown,
872 #[doc(alias = "GDK_DEVICE_TOOL_TYPE_PEN")]
873 Pen,
874 #[doc(alias = "GDK_DEVICE_TOOL_TYPE_ERASER")]
875 Eraser,
876 #[doc(alias = "GDK_DEVICE_TOOL_TYPE_BRUSH")]
877 Brush,
878 #[doc(alias = "GDK_DEVICE_TOOL_TYPE_PENCIL")]
879 Pencil,
880 #[doc(alias = "GDK_DEVICE_TOOL_TYPE_AIRBRUSH")]
881 Airbrush,
882 #[doc(alias = "GDK_DEVICE_TOOL_TYPE_MOUSE")]
883 Mouse,
884 #[doc(alias = "GDK_DEVICE_TOOL_TYPE_LENS")]
885 Lens,
886 #[doc(hidden)]
887 __Unknown(i32),
888}
889
890#[doc(hidden)]
891impl IntoGlib for DeviceToolType {
892 type GlibType = ffi::GdkDeviceToolType;
893
894 #[inline]
895 fn into_glib(self) -> ffi::GdkDeviceToolType {
896 match self {
897 Self::Unknown => ffi::GDK_DEVICE_TOOL_TYPE_UNKNOWN,
898 Self::Pen => ffi::GDK_DEVICE_TOOL_TYPE_PEN,
899 Self::Eraser => ffi::GDK_DEVICE_TOOL_TYPE_ERASER,
900 Self::Brush => ffi::GDK_DEVICE_TOOL_TYPE_BRUSH,
901 Self::Pencil => ffi::GDK_DEVICE_TOOL_TYPE_PENCIL,
902 Self::Airbrush => ffi::GDK_DEVICE_TOOL_TYPE_AIRBRUSH,
903 Self::Mouse => ffi::GDK_DEVICE_TOOL_TYPE_MOUSE,
904 Self::Lens => ffi::GDK_DEVICE_TOOL_TYPE_LENS,
905 Self::__Unknown(value) => value,
906 }
907 }
908}
909
910#[doc(hidden)]
911impl FromGlib<ffi::GdkDeviceToolType> for DeviceToolType {
912 #[inline]
913 unsafe fn from_glib(value: ffi::GdkDeviceToolType) -> Self {
914 skip_assert_initialized!();
915
916 match value {
917 ffi::GDK_DEVICE_TOOL_TYPE_UNKNOWN => Self::Unknown,
918 ffi::GDK_DEVICE_TOOL_TYPE_PEN => Self::Pen,
919 ffi::GDK_DEVICE_TOOL_TYPE_ERASER => Self::Eraser,
920 ffi::GDK_DEVICE_TOOL_TYPE_BRUSH => Self::Brush,
921 ffi::GDK_DEVICE_TOOL_TYPE_PENCIL => Self::Pencil,
922 ffi::GDK_DEVICE_TOOL_TYPE_AIRBRUSH => Self::Airbrush,
923 ffi::GDK_DEVICE_TOOL_TYPE_MOUSE => Self::Mouse,
924 ffi::GDK_DEVICE_TOOL_TYPE_LENS => Self::Lens,
925 value => Self::__Unknown(value),
926 }
927 }
928}
929
930impl StaticType for DeviceToolType {
931 #[inline]
932 #[doc(alias = "gdk_device_tool_type_get_type")]
933 fn static_type() -> glib::Type {
934 unsafe { from_glib(ffi::gdk_device_tool_type_get_type()) }
935 }
936}
937
938impl glib::HasParamSpec for DeviceToolType {
939 type ParamSpec = glib::ParamSpecEnum;
940 type SetValue = Self;
941 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
942
943 fn param_spec_builder() -> Self::BuilderFn {
944 Self::ParamSpec::builder_with_default
945 }
946}
947
948impl glib::value::ValueType for DeviceToolType {
949 type Type = Self;
950}
951
952unsafe impl<'a> glib::value::FromValue<'a> for DeviceToolType {
953 type Checker = glib::value::GenericValueTypeChecker<Self>;
954
955 #[inline]
956 unsafe fn from_value(value: &'a glib::Value) -> Self {
957 skip_assert_initialized!();
958 unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
959 }
960}
961
962impl ToValue for DeviceToolType {
963 #[inline]
964 fn to_value(&self) -> glib::Value {
965 let mut value = glib::Value::for_value_type::<Self>();
966 unsafe {
967 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
968 }
969 value
970 }
971
972 #[inline]
973 fn value_type(&self) -> glib::Type {
974 Self::static_type()
975 }
976}
977
978impl From<DeviceToolType> for glib::Value {
979 #[inline]
980 fn from(v: DeviceToolType) -> Self {
981 skip_assert_initialized!();
982 ToValue::to_value(&v)
983 }
984}
985
986#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
987#[non_exhaustive]
988#[doc(alias = "GdkDeviceType")]
989pub enum DeviceType {
990 #[doc(alias = "GDK_DEVICE_TYPE_MASTER")]
991 Master,
992 #[doc(alias = "GDK_DEVICE_TYPE_SLAVE")]
993 Slave,
994 #[doc(alias = "GDK_DEVICE_TYPE_FLOATING")]
995 Floating,
996 #[doc(hidden)]
997 __Unknown(i32),
998}
999
1000#[doc(hidden)]
1001impl IntoGlib for DeviceType {
1002 type GlibType = ffi::GdkDeviceType;
1003
1004 #[inline]
1005 fn into_glib(self) -> ffi::GdkDeviceType {
1006 match self {
1007 Self::Master => ffi::GDK_DEVICE_TYPE_MASTER,
1008 Self::Slave => ffi::GDK_DEVICE_TYPE_SLAVE,
1009 Self::Floating => ffi::GDK_DEVICE_TYPE_FLOATING,
1010 Self::__Unknown(value) => value,
1011 }
1012 }
1013}
1014
1015#[doc(hidden)]
1016impl FromGlib<ffi::GdkDeviceType> for DeviceType {
1017 #[inline]
1018 unsafe fn from_glib(value: ffi::GdkDeviceType) -> Self {
1019 skip_assert_initialized!();
1020
1021 match value {
1022 ffi::GDK_DEVICE_TYPE_MASTER => Self::Master,
1023 ffi::GDK_DEVICE_TYPE_SLAVE => Self::Slave,
1024 ffi::GDK_DEVICE_TYPE_FLOATING => Self::Floating,
1025 value => Self::__Unknown(value),
1026 }
1027 }
1028}
1029
1030impl StaticType for DeviceType {
1031 #[inline]
1032 #[doc(alias = "gdk_device_type_get_type")]
1033 fn static_type() -> glib::Type {
1034 unsafe { from_glib(ffi::gdk_device_type_get_type()) }
1035 }
1036}
1037
1038impl glib::HasParamSpec for DeviceType {
1039 type ParamSpec = glib::ParamSpecEnum;
1040 type SetValue = Self;
1041 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1042
1043 fn param_spec_builder() -> Self::BuilderFn {
1044 Self::ParamSpec::builder_with_default
1045 }
1046}
1047
1048impl glib::value::ValueType for DeviceType {
1049 type Type = Self;
1050}
1051
1052unsafe impl<'a> glib::value::FromValue<'a> for DeviceType {
1053 type Checker = glib::value::GenericValueTypeChecker<Self>;
1054
1055 #[inline]
1056 unsafe fn from_value(value: &'a glib::Value) -> Self {
1057 skip_assert_initialized!();
1058 unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
1059 }
1060}
1061
1062impl ToValue for DeviceType {
1063 #[inline]
1064 fn to_value(&self) -> glib::Value {
1065 let mut value = glib::Value::for_value_type::<Self>();
1066 unsafe {
1067 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1068 }
1069 value
1070 }
1071
1072 #[inline]
1073 fn value_type(&self) -> glib::Type {
1074 Self::static_type()
1075 }
1076}
1077
1078impl From<DeviceType> for glib::Value {
1079 #[inline]
1080 fn from(v: DeviceType) -> Self {
1081 skip_assert_initialized!();
1082 ToValue::to_value(&v)
1083 }
1084}
1085
1086#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1087#[non_exhaustive]
1088#[doc(alias = "GdkDragCancelReason")]
1089pub enum DragCancelReason {
1090 #[doc(alias = "GDK_DRAG_CANCEL_NO_TARGET")]
1091 NoTarget,
1092 #[doc(alias = "GDK_DRAG_CANCEL_USER_CANCELLED")]
1093 UserCancelled,
1094 #[doc(alias = "GDK_DRAG_CANCEL_ERROR")]
1095 Error,
1096 #[doc(hidden)]
1097 __Unknown(i32),
1098}
1099
1100#[doc(hidden)]
1101impl IntoGlib for DragCancelReason {
1102 type GlibType = ffi::GdkDragCancelReason;
1103
1104 #[inline]
1105 fn into_glib(self) -> ffi::GdkDragCancelReason {
1106 match self {
1107 Self::NoTarget => ffi::GDK_DRAG_CANCEL_NO_TARGET,
1108 Self::UserCancelled => ffi::GDK_DRAG_CANCEL_USER_CANCELLED,
1109 Self::Error => ffi::GDK_DRAG_CANCEL_ERROR,
1110 Self::__Unknown(value) => value,
1111 }
1112 }
1113}
1114
1115#[doc(hidden)]
1116impl FromGlib<ffi::GdkDragCancelReason> for DragCancelReason {
1117 #[inline]
1118 unsafe fn from_glib(value: ffi::GdkDragCancelReason) -> Self {
1119 skip_assert_initialized!();
1120
1121 match value {
1122 ffi::GDK_DRAG_CANCEL_NO_TARGET => Self::NoTarget,
1123 ffi::GDK_DRAG_CANCEL_USER_CANCELLED => Self::UserCancelled,
1124 ffi::GDK_DRAG_CANCEL_ERROR => Self::Error,
1125 value => Self::__Unknown(value),
1126 }
1127 }
1128}
1129
1130impl StaticType for DragCancelReason {
1131 #[inline]
1132 #[doc(alias = "gdk_drag_cancel_reason_get_type")]
1133 fn static_type() -> glib::Type {
1134 unsafe { from_glib(ffi::gdk_drag_cancel_reason_get_type()) }
1135 }
1136}
1137
1138impl glib::HasParamSpec for DragCancelReason {
1139 type ParamSpec = glib::ParamSpecEnum;
1140 type SetValue = Self;
1141 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1142
1143 fn param_spec_builder() -> Self::BuilderFn {
1144 Self::ParamSpec::builder_with_default
1145 }
1146}
1147
1148impl glib::value::ValueType for DragCancelReason {
1149 type Type = Self;
1150}
1151
1152unsafe impl<'a> glib::value::FromValue<'a> for DragCancelReason {
1153 type Checker = glib::value::GenericValueTypeChecker<Self>;
1154
1155 #[inline]
1156 unsafe fn from_value(value: &'a glib::Value) -> Self {
1157 skip_assert_initialized!();
1158 unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
1159 }
1160}
1161
1162impl ToValue for DragCancelReason {
1163 #[inline]
1164 fn to_value(&self) -> glib::Value {
1165 let mut value = glib::Value::for_value_type::<Self>();
1166 unsafe {
1167 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1168 }
1169 value
1170 }
1171
1172 #[inline]
1173 fn value_type(&self) -> glib::Type {
1174 Self::static_type()
1175 }
1176}
1177
1178impl From<DragCancelReason> for glib::Value {
1179 #[inline]
1180 fn from(v: DragCancelReason) -> Self {
1181 skip_assert_initialized!();
1182 ToValue::to_value(&v)
1183 }
1184}
1185
1186#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1187#[non_exhaustive]
1188#[doc(alias = "GdkDragProtocol")]
1189pub enum DragProtocol {
1190 #[doc(alias = "GDK_DRAG_PROTO_NONE")]
1191 None,
1192 #[doc(alias = "GDK_DRAG_PROTO_MOTIF")]
1193 Motif,
1194 #[doc(alias = "GDK_DRAG_PROTO_XDND")]
1195 Xdnd,
1196 #[doc(alias = "GDK_DRAG_PROTO_ROOTWIN")]
1197 Rootwin,
1198 #[doc(alias = "GDK_DRAG_PROTO_WIN32_DROPFILES")]
1199 Win32Dropfiles,
1200 #[doc(alias = "GDK_DRAG_PROTO_OLE2")]
1201 Ole2,
1202 #[doc(alias = "GDK_DRAG_PROTO_LOCAL")]
1203 Local,
1204 #[doc(alias = "GDK_DRAG_PROTO_WAYLAND")]
1205 Wayland,
1206 #[doc(hidden)]
1207 __Unknown(i32),
1208}
1209
1210#[doc(hidden)]
1211impl IntoGlib for DragProtocol {
1212 type GlibType = ffi::GdkDragProtocol;
1213
1214 #[inline]
1215 fn into_glib(self) -> ffi::GdkDragProtocol {
1216 match self {
1217 Self::None => ffi::GDK_DRAG_PROTO_NONE,
1218 Self::Motif => ffi::GDK_DRAG_PROTO_MOTIF,
1219 Self::Xdnd => ffi::GDK_DRAG_PROTO_XDND,
1220 Self::Rootwin => ffi::GDK_DRAG_PROTO_ROOTWIN,
1221 Self::Win32Dropfiles => ffi::GDK_DRAG_PROTO_WIN32_DROPFILES,
1222 Self::Ole2 => ffi::GDK_DRAG_PROTO_OLE2,
1223 Self::Local => ffi::GDK_DRAG_PROTO_LOCAL,
1224 Self::Wayland => ffi::GDK_DRAG_PROTO_WAYLAND,
1225 Self::__Unknown(value) => value,
1226 }
1227 }
1228}
1229
1230#[doc(hidden)]
1231impl FromGlib<ffi::GdkDragProtocol> for DragProtocol {
1232 #[inline]
1233 unsafe fn from_glib(value: ffi::GdkDragProtocol) -> Self {
1234 skip_assert_initialized!();
1235
1236 match value {
1237 ffi::GDK_DRAG_PROTO_NONE => Self::None,
1238 ffi::GDK_DRAG_PROTO_MOTIF => Self::Motif,
1239 ffi::GDK_DRAG_PROTO_XDND => Self::Xdnd,
1240 ffi::GDK_DRAG_PROTO_ROOTWIN => Self::Rootwin,
1241 ffi::GDK_DRAG_PROTO_WIN32_DROPFILES => Self::Win32Dropfiles,
1242 ffi::GDK_DRAG_PROTO_OLE2 => Self::Ole2,
1243 ffi::GDK_DRAG_PROTO_LOCAL => Self::Local,
1244 ffi::GDK_DRAG_PROTO_WAYLAND => Self::Wayland,
1245 value => Self::__Unknown(value),
1246 }
1247 }
1248}
1249
1250impl StaticType for DragProtocol {
1251 #[inline]
1252 #[doc(alias = "gdk_drag_protocol_get_type")]
1253 fn static_type() -> glib::Type {
1254 unsafe { from_glib(ffi::gdk_drag_protocol_get_type()) }
1255 }
1256}
1257
1258impl glib::HasParamSpec for DragProtocol {
1259 type ParamSpec = glib::ParamSpecEnum;
1260 type SetValue = Self;
1261 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1262
1263 fn param_spec_builder() -> Self::BuilderFn {
1264 Self::ParamSpec::builder_with_default
1265 }
1266}
1267
1268impl glib::value::ValueType for DragProtocol {
1269 type Type = Self;
1270}
1271
1272unsafe impl<'a> glib::value::FromValue<'a> for DragProtocol {
1273 type Checker = glib::value::GenericValueTypeChecker<Self>;
1274
1275 #[inline]
1276 unsafe fn from_value(value: &'a glib::Value) -> Self {
1277 skip_assert_initialized!();
1278 unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
1279 }
1280}
1281
1282impl ToValue for DragProtocol {
1283 #[inline]
1284 fn to_value(&self) -> glib::Value {
1285 let mut value = glib::Value::for_value_type::<Self>();
1286 unsafe {
1287 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1288 }
1289 value
1290 }
1291
1292 #[inline]
1293 fn value_type(&self) -> glib::Type {
1294 Self::static_type()
1295 }
1296}
1297
1298impl From<DragProtocol> for glib::Value {
1299 #[inline]
1300 fn from(v: DragProtocol) -> Self {
1301 skip_assert_initialized!();
1302 ToValue::to_value(&v)
1303 }
1304}
1305
1306#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1307#[non_exhaustive]
1308#[doc(alias = "GdkEventType")]
1309pub enum EventType {
1310 #[doc(alias = "GDK_NOTHING")]
1311 Nothing,
1312 #[doc(alias = "GDK_DELETE")]
1313 Delete,
1314 #[doc(alias = "GDK_DESTROY")]
1315 Destroy,
1316 #[doc(alias = "GDK_EXPOSE")]
1317 Expose,
1318 #[doc(alias = "GDK_MOTION_NOTIFY")]
1319 MotionNotify,
1320 #[doc(alias = "GDK_BUTTON_PRESS")]
1321 ButtonPress,
1322 #[doc(alias = "GDK_DOUBLE_BUTTON_PRESS")]
1323 DoubleButtonPress,
1324 #[doc(alias = "GDK_TRIPLE_BUTTON_PRESS")]
1325 TripleButtonPress,
1326 #[doc(alias = "GDK_BUTTON_RELEASE")]
1327 ButtonRelease,
1328 #[doc(alias = "GDK_KEY_PRESS")]
1329 KeyPress,
1330 #[doc(alias = "GDK_KEY_RELEASE")]
1331 KeyRelease,
1332 #[doc(alias = "GDK_ENTER_NOTIFY")]
1333 EnterNotify,
1334 #[doc(alias = "GDK_LEAVE_NOTIFY")]
1335 LeaveNotify,
1336 #[doc(alias = "GDK_FOCUS_CHANGE")]
1337 FocusChange,
1338 #[doc(alias = "GDK_CONFIGURE")]
1339 Configure,
1340 #[doc(alias = "GDK_MAP")]
1341 Map,
1342 #[doc(alias = "GDK_UNMAP")]
1343 Unmap,
1344 #[doc(alias = "GDK_PROPERTY_NOTIFY")]
1345 PropertyNotify,
1346 #[doc(alias = "GDK_SELECTION_CLEAR")]
1347 SelectionClear,
1348 #[doc(alias = "GDK_SELECTION_REQUEST")]
1349 SelectionRequest,
1350 #[doc(alias = "GDK_SELECTION_NOTIFY")]
1351 SelectionNotify,
1352 #[doc(alias = "GDK_PROXIMITY_IN")]
1353 ProximityIn,
1354 #[doc(alias = "GDK_PROXIMITY_OUT")]
1355 ProximityOut,
1356 #[doc(alias = "GDK_DRAG_ENTER")]
1357 DragEnter,
1358 #[doc(alias = "GDK_DRAG_LEAVE")]
1359 DragLeave,
1360 #[doc(alias = "GDK_DRAG_MOTION")]
1361 DragMotion,
1362 #[doc(alias = "GDK_DRAG_STATUS")]
1363 DragStatus,
1364 #[doc(alias = "GDK_DROP_START")]
1365 DropStart,
1366 #[doc(alias = "GDK_DROP_FINISHED")]
1367 DropFinished,
1368 #[doc(alias = "GDK_CLIENT_EVENT")]
1369 ClientEvent,
1370 #[doc(alias = "GDK_VISIBILITY_NOTIFY")]
1371 VisibilityNotify,
1372 #[doc(alias = "GDK_SCROLL")]
1373 Scroll,
1374 #[doc(alias = "GDK_WINDOW_STATE")]
1375 WindowState,
1376 #[doc(alias = "GDK_SETTING")]
1377 Setting,
1378 #[doc(alias = "GDK_OWNER_CHANGE")]
1379 OwnerChange,
1380 #[doc(alias = "GDK_GRAB_BROKEN")]
1381 GrabBroken,
1382 #[doc(alias = "GDK_DAMAGE")]
1383 Damage,
1384 #[doc(alias = "GDK_TOUCH_BEGIN")]
1385 TouchBegin,
1386 #[doc(alias = "GDK_TOUCH_UPDATE")]
1387 TouchUpdate,
1388 #[doc(alias = "GDK_TOUCH_END")]
1389 TouchEnd,
1390 #[doc(alias = "GDK_TOUCH_CANCEL")]
1391 TouchCancel,
1392 #[doc(alias = "GDK_TOUCHPAD_SWIPE")]
1393 TouchpadSwipe,
1394 #[doc(alias = "GDK_TOUCHPAD_PINCH")]
1395 TouchpadPinch,
1396 #[doc(alias = "GDK_PAD_BUTTON_PRESS")]
1397 PadButtonPress,
1398 #[doc(alias = "GDK_PAD_BUTTON_RELEASE")]
1399 PadButtonRelease,
1400 #[doc(alias = "GDK_PAD_RING")]
1401 PadRing,
1402 #[doc(alias = "GDK_PAD_STRIP")]
1403 PadStrip,
1404 #[doc(alias = "GDK_PAD_GROUP_MODE")]
1405 PadGroupMode,
1406 #[doc(hidden)]
1407 __Unknown(i32),
1408}
1409
1410#[doc(hidden)]
1411impl IntoGlib for EventType {
1412 type GlibType = ffi::GdkEventType;
1413
1414 fn into_glib(self) -> ffi::GdkEventType {
1415 match self {
1416 Self::Nothing => ffi::GDK_NOTHING,
1417 Self::Delete => ffi::GDK_DELETE,
1418 Self::Destroy => ffi::GDK_DESTROY,
1419 Self::Expose => ffi::GDK_EXPOSE,
1420 Self::MotionNotify => ffi::GDK_MOTION_NOTIFY,
1421 Self::ButtonPress => ffi::GDK_BUTTON_PRESS,
1422 Self::DoubleButtonPress => ffi::GDK_DOUBLE_BUTTON_PRESS,
1423 Self::TripleButtonPress => ffi::GDK_TRIPLE_BUTTON_PRESS,
1424 Self::ButtonRelease => ffi::GDK_BUTTON_RELEASE,
1425 Self::KeyPress => ffi::GDK_KEY_PRESS,
1426 Self::KeyRelease => ffi::GDK_KEY_RELEASE,
1427 Self::EnterNotify => ffi::GDK_ENTER_NOTIFY,
1428 Self::LeaveNotify => ffi::GDK_LEAVE_NOTIFY,
1429 Self::FocusChange => ffi::GDK_FOCUS_CHANGE,
1430 Self::Configure => ffi::GDK_CONFIGURE,
1431 Self::Map => ffi::GDK_MAP,
1432 Self::Unmap => ffi::GDK_UNMAP,
1433 Self::PropertyNotify => ffi::GDK_PROPERTY_NOTIFY,
1434 Self::SelectionClear => ffi::GDK_SELECTION_CLEAR,
1435 Self::SelectionRequest => ffi::GDK_SELECTION_REQUEST,
1436 Self::SelectionNotify => ffi::GDK_SELECTION_NOTIFY,
1437 Self::ProximityIn => ffi::GDK_PROXIMITY_IN,
1438 Self::ProximityOut => ffi::GDK_PROXIMITY_OUT,
1439 Self::DragEnter => ffi::GDK_DRAG_ENTER,
1440 Self::DragLeave => ffi::GDK_DRAG_LEAVE,
1441 Self::DragMotion => ffi::GDK_DRAG_MOTION,
1442 Self::DragStatus => ffi::GDK_DRAG_STATUS,
1443 Self::DropStart => ffi::GDK_DROP_START,
1444 Self::DropFinished => ffi::GDK_DROP_FINISHED,
1445 Self::ClientEvent => ffi::GDK_CLIENT_EVENT,
1446 Self::VisibilityNotify => ffi::GDK_VISIBILITY_NOTIFY,
1447 Self::Scroll => ffi::GDK_SCROLL,
1448 Self::WindowState => ffi::GDK_WINDOW_STATE,
1449 Self::Setting => ffi::GDK_SETTING,
1450 Self::OwnerChange => ffi::GDK_OWNER_CHANGE,
1451 Self::GrabBroken => ffi::GDK_GRAB_BROKEN,
1452 Self::Damage => ffi::GDK_DAMAGE,
1453 Self::TouchBegin => ffi::GDK_TOUCH_BEGIN,
1454 Self::TouchUpdate => ffi::GDK_TOUCH_UPDATE,
1455 Self::TouchEnd => ffi::GDK_TOUCH_END,
1456 Self::TouchCancel => ffi::GDK_TOUCH_CANCEL,
1457 Self::TouchpadSwipe => ffi::GDK_TOUCHPAD_SWIPE,
1458 Self::TouchpadPinch => ffi::GDK_TOUCHPAD_PINCH,
1459 Self::PadButtonPress => ffi::GDK_PAD_BUTTON_PRESS,
1460 Self::PadButtonRelease => ffi::GDK_PAD_BUTTON_RELEASE,
1461 Self::PadRing => ffi::GDK_PAD_RING,
1462 Self::PadStrip => ffi::GDK_PAD_STRIP,
1463 Self::PadGroupMode => ffi::GDK_PAD_GROUP_MODE,
1464 Self::__Unknown(value) => value,
1465 }
1466 }
1467}
1468
1469#[doc(hidden)]
1470impl FromGlib<ffi::GdkEventType> for EventType {
1471 unsafe fn from_glib(value: ffi::GdkEventType) -> Self {
1472 skip_assert_initialized!();
1473
1474 match value {
1475 ffi::GDK_NOTHING => Self::Nothing,
1476 ffi::GDK_DELETE => Self::Delete,
1477 ffi::GDK_DESTROY => Self::Destroy,
1478 ffi::GDK_EXPOSE => Self::Expose,
1479 ffi::GDK_MOTION_NOTIFY => Self::MotionNotify,
1480 ffi::GDK_BUTTON_PRESS => Self::ButtonPress,
1481 ffi::GDK_DOUBLE_BUTTON_PRESS => Self::DoubleButtonPress,
1482 ffi::GDK_TRIPLE_BUTTON_PRESS => Self::TripleButtonPress,
1483 ffi::GDK_BUTTON_RELEASE => Self::ButtonRelease,
1484 ffi::GDK_KEY_PRESS => Self::KeyPress,
1485 ffi::GDK_KEY_RELEASE => Self::KeyRelease,
1486 ffi::GDK_ENTER_NOTIFY => Self::EnterNotify,
1487 ffi::GDK_LEAVE_NOTIFY => Self::LeaveNotify,
1488 ffi::GDK_FOCUS_CHANGE => Self::FocusChange,
1489 ffi::GDK_CONFIGURE => Self::Configure,
1490 ffi::GDK_MAP => Self::Map,
1491 ffi::GDK_UNMAP => Self::Unmap,
1492 ffi::GDK_PROPERTY_NOTIFY => Self::PropertyNotify,
1493 ffi::GDK_SELECTION_CLEAR => Self::SelectionClear,
1494 ffi::GDK_SELECTION_REQUEST => Self::SelectionRequest,
1495 ffi::GDK_SELECTION_NOTIFY => Self::SelectionNotify,
1496 ffi::GDK_PROXIMITY_IN => Self::ProximityIn,
1497 ffi::GDK_PROXIMITY_OUT => Self::ProximityOut,
1498 ffi::GDK_DRAG_ENTER => Self::DragEnter,
1499 ffi::GDK_DRAG_LEAVE => Self::DragLeave,
1500 ffi::GDK_DRAG_MOTION => Self::DragMotion,
1501 ffi::GDK_DRAG_STATUS => Self::DragStatus,
1502 ffi::GDK_DROP_START => Self::DropStart,
1503 ffi::GDK_DROP_FINISHED => Self::DropFinished,
1504 ffi::GDK_CLIENT_EVENT => Self::ClientEvent,
1505 ffi::GDK_VISIBILITY_NOTIFY => Self::VisibilityNotify,
1506 ffi::GDK_SCROLL => Self::Scroll,
1507 ffi::GDK_WINDOW_STATE => Self::WindowState,
1508 ffi::GDK_SETTING => Self::Setting,
1509 ffi::GDK_OWNER_CHANGE => Self::OwnerChange,
1510 ffi::GDK_GRAB_BROKEN => Self::GrabBroken,
1511 ffi::GDK_DAMAGE => Self::Damage,
1512 ffi::GDK_TOUCH_BEGIN => Self::TouchBegin,
1513 ffi::GDK_TOUCH_UPDATE => Self::TouchUpdate,
1514 ffi::GDK_TOUCH_END => Self::TouchEnd,
1515 ffi::GDK_TOUCH_CANCEL => Self::TouchCancel,
1516 ffi::GDK_TOUCHPAD_SWIPE => Self::TouchpadSwipe,
1517 ffi::GDK_TOUCHPAD_PINCH => Self::TouchpadPinch,
1518 ffi::GDK_PAD_BUTTON_PRESS => Self::PadButtonPress,
1519 ffi::GDK_PAD_BUTTON_RELEASE => Self::PadButtonRelease,
1520 ffi::GDK_PAD_RING => Self::PadRing,
1521 ffi::GDK_PAD_STRIP => Self::PadStrip,
1522 ffi::GDK_PAD_GROUP_MODE => Self::PadGroupMode,
1523 value => Self::__Unknown(value),
1524 }
1525 }
1526}
1527
1528impl StaticType for EventType {
1529 #[inline]
1530 #[doc(alias = "gdk_event_type_get_type")]
1531 fn static_type() -> glib::Type {
1532 unsafe { from_glib(ffi::gdk_event_type_get_type()) }
1533 }
1534}
1535
1536impl glib::HasParamSpec for EventType {
1537 type ParamSpec = glib::ParamSpecEnum;
1538 type SetValue = Self;
1539 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1540
1541 fn param_spec_builder() -> Self::BuilderFn {
1542 Self::ParamSpec::builder_with_default
1543 }
1544}
1545
1546impl glib::value::ValueType for EventType {
1547 type Type = Self;
1548}
1549
1550unsafe impl<'a> glib::value::FromValue<'a> for EventType {
1551 type Checker = glib::value::GenericValueTypeChecker<Self>;
1552
1553 #[inline]
1554 unsafe fn from_value(value: &'a glib::Value) -> Self {
1555 skip_assert_initialized!();
1556 unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
1557 }
1558}
1559
1560impl ToValue for EventType {
1561 #[inline]
1562 fn to_value(&self) -> glib::Value {
1563 let mut value = glib::Value::for_value_type::<Self>();
1564 unsafe {
1565 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1566 }
1567 value
1568 }
1569
1570 #[inline]
1571 fn value_type(&self) -> glib::Type {
1572 Self::static_type()
1573 }
1574}
1575
1576impl From<EventType> for glib::Value {
1577 #[inline]
1578 fn from(v: EventType) -> Self {
1579 skip_assert_initialized!();
1580 ToValue::to_value(&v)
1581 }
1582}
1583
1584#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1585#[non_exhaustive]
1586#[doc(alias = "GdkFullscreenMode")]
1587pub enum FullscreenMode {
1588 #[doc(alias = "GDK_FULLSCREEN_ON_CURRENT_MONITOR")]
1589 CurrentMonitor,
1590 #[doc(alias = "GDK_FULLSCREEN_ON_ALL_MONITORS")]
1591 AllMonitors,
1592 #[doc(hidden)]
1593 __Unknown(i32),
1594}
1595
1596#[doc(hidden)]
1597impl IntoGlib for FullscreenMode {
1598 type GlibType = ffi::GdkFullscreenMode;
1599
1600 #[inline]
1601 fn into_glib(self) -> ffi::GdkFullscreenMode {
1602 match self {
1603 Self::CurrentMonitor => ffi::GDK_FULLSCREEN_ON_CURRENT_MONITOR,
1604 Self::AllMonitors => ffi::GDK_FULLSCREEN_ON_ALL_MONITORS,
1605 Self::__Unknown(value) => value,
1606 }
1607 }
1608}
1609
1610#[doc(hidden)]
1611impl FromGlib<ffi::GdkFullscreenMode> for FullscreenMode {
1612 #[inline]
1613 unsafe fn from_glib(value: ffi::GdkFullscreenMode) -> Self {
1614 skip_assert_initialized!();
1615
1616 match value {
1617 ffi::GDK_FULLSCREEN_ON_CURRENT_MONITOR => Self::CurrentMonitor,
1618 ffi::GDK_FULLSCREEN_ON_ALL_MONITORS => Self::AllMonitors,
1619 value => Self::__Unknown(value),
1620 }
1621 }
1622}
1623
1624impl StaticType for FullscreenMode {
1625 #[inline]
1626 #[doc(alias = "gdk_fullscreen_mode_get_type")]
1627 fn static_type() -> glib::Type {
1628 unsafe { from_glib(ffi::gdk_fullscreen_mode_get_type()) }
1629 }
1630}
1631
1632impl glib::HasParamSpec for FullscreenMode {
1633 type ParamSpec = glib::ParamSpecEnum;
1634 type SetValue = Self;
1635 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1636
1637 fn param_spec_builder() -> Self::BuilderFn {
1638 Self::ParamSpec::builder_with_default
1639 }
1640}
1641
1642impl glib::value::ValueType for FullscreenMode {
1643 type Type = Self;
1644}
1645
1646unsafe impl<'a> glib::value::FromValue<'a> for FullscreenMode {
1647 type Checker = glib::value::GenericValueTypeChecker<Self>;
1648
1649 #[inline]
1650 unsafe fn from_value(value: &'a glib::Value) -> Self {
1651 skip_assert_initialized!();
1652 unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
1653 }
1654}
1655
1656impl ToValue for FullscreenMode {
1657 #[inline]
1658 fn to_value(&self) -> glib::Value {
1659 let mut value = glib::Value::for_value_type::<Self>();
1660 unsafe {
1661 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1662 }
1663 value
1664 }
1665
1666 #[inline]
1667 fn value_type(&self) -> glib::Type {
1668 Self::static_type()
1669 }
1670}
1671
1672impl From<FullscreenMode> for glib::Value {
1673 #[inline]
1674 fn from(v: FullscreenMode) -> Self {
1675 skip_assert_initialized!();
1676 ToValue::to_value(&v)
1677 }
1678}
1679
1680#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1681#[non_exhaustive]
1682#[doc(alias = "GdkGLError")]
1683pub enum GLError {
1684 #[doc(alias = "GDK_GL_ERROR_NOT_AVAILABLE")]
1685 NotAvailable,
1686 #[doc(alias = "GDK_GL_ERROR_UNSUPPORTED_FORMAT")]
1687 UnsupportedFormat,
1688 #[doc(alias = "GDK_GL_ERROR_UNSUPPORTED_PROFILE")]
1689 UnsupportedProfile,
1690 #[doc(hidden)]
1691 __Unknown(i32),
1692}
1693
1694#[doc(hidden)]
1695impl IntoGlib for GLError {
1696 type GlibType = ffi::GdkGLError;
1697
1698 #[inline]
1699 fn into_glib(self) -> ffi::GdkGLError {
1700 match self {
1701 Self::NotAvailable => ffi::GDK_GL_ERROR_NOT_AVAILABLE,
1702 Self::UnsupportedFormat => ffi::GDK_GL_ERROR_UNSUPPORTED_FORMAT,
1703 Self::UnsupportedProfile => ffi::GDK_GL_ERROR_UNSUPPORTED_PROFILE,
1704 Self::__Unknown(value) => value,
1705 }
1706 }
1707}
1708
1709#[doc(hidden)]
1710impl FromGlib<ffi::GdkGLError> for GLError {
1711 #[inline]
1712 unsafe fn from_glib(value: ffi::GdkGLError) -> Self {
1713 skip_assert_initialized!();
1714
1715 match value {
1716 ffi::GDK_GL_ERROR_NOT_AVAILABLE => Self::NotAvailable,
1717 ffi::GDK_GL_ERROR_UNSUPPORTED_FORMAT => Self::UnsupportedFormat,
1718 ffi::GDK_GL_ERROR_UNSUPPORTED_PROFILE => Self::UnsupportedProfile,
1719 value => Self::__Unknown(value),
1720 }
1721 }
1722}
1723
1724impl glib::error::ErrorDomain for GLError {
1725 #[inline]
1726 fn domain() -> glib::Quark {
1727 skip_assert_initialized!();
1728
1729 unsafe { from_glib(ffi::gdk_gl_error_quark()) }
1730 }
1731
1732 #[inline]
1733 fn code(self) -> i32 {
1734 self.into_glib()
1735 }
1736
1737 #[inline]
1738 #[allow(clippy::match_single_binding)]
1739 fn from(code: i32) -> Option<Self> {
1740 skip_assert_initialized!();
1741 match unsafe { from_glib(code) } {
1742 value => Some(value),
1743 }
1744 }
1745}
1746
1747impl StaticType for GLError {
1748 #[inline]
1749 #[doc(alias = "gdk_gl_error_get_type")]
1750 fn static_type() -> glib::Type {
1751 unsafe { from_glib(ffi::gdk_gl_error_get_type()) }
1752 }
1753}
1754
1755impl glib::HasParamSpec for GLError {
1756 type ParamSpec = glib::ParamSpecEnum;
1757 type SetValue = Self;
1758 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1759
1760 fn param_spec_builder() -> Self::BuilderFn {
1761 Self::ParamSpec::builder_with_default
1762 }
1763}
1764
1765impl glib::value::ValueType for GLError {
1766 type Type = Self;
1767}
1768
1769unsafe impl<'a> glib::value::FromValue<'a> for GLError {
1770 type Checker = glib::value::GenericValueTypeChecker<Self>;
1771
1772 #[inline]
1773 unsafe fn from_value(value: &'a glib::Value) -> Self {
1774 skip_assert_initialized!();
1775 unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
1776 }
1777}
1778
1779impl ToValue for GLError {
1780 #[inline]
1781 fn to_value(&self) -> glib::Value {
1782 let mut value = glib::Value::for_value_type::<Self>();
1783 unsafe {
1784 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1785 }
1786 value
1787 }
1788
1789 #[inline]
1790 fn value_type(&self) -> glib::Type {
1791 Self::static_type()
1792 }
1793}
1794
1795impl From<GLError> for glib::Value {
1796 #[inline]
1797 fn from(v: GLError) -> Self {
1798 skip_assert_initialized!();
1799 ToValue::to_value(&v)
1800 }
1801}
1802
1803#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1804#[non_exhaustive]
1805#[doc(alias = "GdkGrabOwnership")]
1806pub enum GrabOwnership {
1807 #[doc(alias = "GDK_OWNERSHIP_NONE")]
1808 None,
1809 #[doc(alias = "GDK_OWNERSHIP_WINDOW")]
1810 Window,
1811 #[doc(alias = "GDK_OWNERSHIP_APPLICATION")]
1812 Application,
1813 #[doc(hidden)]
1814 __Unknown(i32),
1815}
1816
1817#[doc(hidden)]
1818impl IntoGlib for GrabOwnership {
1819 type GlibType = ffi::GdkGrabOwnership;
1820
1821 #[inline]
1822 fn into_glib(self) -> ffi::GdkGrabOwnership {
1823 match self {
1824 Self::None => ffi::GDK_OWNERSHIP_NONE,
1825 Self::Window => ffi::GDK_OWNERSHIP_WINDOW,
1826 Self::Application => ffi::GDK_OWNERSHIP_APPLICATION,
1827 Self::__Unknown(value) => value,
1828 }
1829 }
1830}
1831
1832#[doc(hidden)]
1833impl FromGlib<ffi::GdkGrabOwnership> for GrabOwnership {
1834 #[inline]
1835 unsafe fn from_glib(value: ffi::GdkGrabOwnership) -> Self {
1836 skip_assert_initialized!();
1837
1838 match value {
1839 ffi::GDK_OWNERSHIP_NONE => Self::None,
1840 ffi::GDK_OWNERSHIP_WINDOW => Self::Window,
1841 ffi::GDK_OWNERSHIP_APPLICATION => Self::Application,
1842 value => Self::__Unknown(value),
1843 }
1844 }
1845}
1846
1847impl StaticType for GrabOwnership {
1848 #[inline]
1849 #[doc(alias = "gdk_grab_ownership_get_type")]
1850 fn static_type() -> glib::Type {
1851 unsafe { from_glib(ffi::gdk_grab_ownership_get_type()) }
1852 }
1853}
1854
1855impl glib::HasParamSpec for GrabOwnership {
1856 type ParamSpec = glib::ParamSpecEnum;
1857 type SetValue = Self;
1858 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1859
1860 fn param_spec_builder() -> Self::BuilderFn {
1861 Self::ParamSpec::builder_with_default
1862 }
1863}
1864
1865impl glib::value::ValueType for GrabOwnership {
1866 type Type = Self;
1867}
1868
1869unsafe impl<'a> glib::value::FromValue<'a> for GrabOwnership {
1870 type Checker = glib::value::GenericValueTypeChecker<Self>;
1871
1872 #[inline]
1873 unsafe fn from_value(value: &'a glib::Value) -> Self {
1874 skip_assert_initialized!();
1875 unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
1876 }
1877}
1878
1879impl ToValue for GrabOwnership {
1880 #[inline]
1881 fn to_value(&self) -> glib::Value {
1882 let mut value = glib::Value::for_value_type::<Self>();
1883 unsafe {
1884 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1885 }
1886 value
1887 }
1888
1889 #[inline]
1890 fn value_type(&self) -> glib::Type {
1891 Self::static_type()
1892 }
1893}
1894
1895impl From<GrabOwnership> for glib::Value {
1896 #[inline]
1897 fn from(v: GrabOwnership) -> Self {
1898 skip_assert_initialized!();
1899 ToValue::to_value(&v)
1900 }
1901}
1902
1903#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1904#[non_exhaustive]
1905#[doc(alias = "GdkGrabStatus")]
1906pub enum GrabStatus {
1907 #[doc(alias = "GDK_GRAB_SUCCESS")]
1908 Success,
1909 #[doc(alias = "GDK_GRAB_ALREADY_GRABBED")]
1910 AlreadyGrabbed,
1911 #[doc(alias = "GDK_GRAB_INVALID_TIME")]
1912 InvalidTime,
1913 #[doc(alias = "GDK_GRAB_NOT_VIEWABLE")]
1914 NotViewable,
1915 #[doc(alias = "GDK_GRAB_FROZEN")]
1916 Frozen,
1917 #[doc(alias = "GDK_GRAB_FAILED")]
1918 Failed,
1919 #[doc(hidden)]
1920 __Unknown(i32),
1921}
1922
1923#[doc(hidden)]
1924impl IntoGlib for GrabStatus {
1925 type GlibType = ffi::GdkGrabStatus;
1926
1927 #[inline]
1928 fn into_glib(self) -> ffi::GdkGrabStatus {
1929 match self {
1930 Self::Success => ffi::GDK_GRAB_SUCCESS,
1931 Self::AlreadyGrabbed => ffi::GDK_GRAB_ALREADY_GRABBED,
1932 Self::InvalidTime => ffi::GDK_GRAB_INVALID_TIME,
1933 Self::NotViewable => ffi::GDK_GRAB_NOT_VIEWABLE,
1934 Self::Frozen => ffi::GDK_GRAB_FROZEN,
1935 Self::Failed => ffi::GDK_GRAB_FAILED,
1936 Self::__Unknown(value) => value,
1937 }
1938 }
1939}
1940
1941#[doc(hidden)]
1942impl FromGlib<ffi::GdkGrabStatus> for GrabStatus {
1943 #[inline]
1944 unsafe fn from_glib(value: ffi::GdkGrabStatus) -> Self {
1945 skip_assert_initialized!();
1946
1947 match value {
1948 ffi::GDK_GRAB_SUCCESS => Self::Success,
1949 ffi::GDK_GRAB_ALREADY_GRABBED => Self::AlreadyGrabbed,
1950 ffi::GDK_GRAB_INVALID_TIME => Self::InvalidTime,
1951 ffi::GDK_GRAB_NOT_VIEWABLE => Self::NotViewable,
1952 ffi::GDK_GRAB_FROZEN => Self::Frozen,
1953 ffi::GDK_GRAB_FAILED => Self::Failed,
1954 value => Self::__Unknown(value),
1955 }
1956 }
1957}
1958
1959impl StaticType for GrabStatus {
1960 #[inline]
1961 #[doc(alias = "gdk_grab_status_get_type")]
1962 fn static_type() -> glib::Type {
1963 unsafe { from_glib(ffi::gdk_grab_status_get_type()) }
1964 }
1965}
1966
1967impl glib::HasParamSpec for GrabStatus {
1968 type ParamSpec = glib::ParamSpecEnum;
1969 type SetValue = Self;
1970 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1971
1972 fn param_spec_builder() -> Self::BuilderFn {
1973 Self::ParamSpec::builder_with_default
1974 }
1975}
1976
1977impl glib::value::ValueType for GrabStatus {
1978 type Type = Self;
1979}
1980
1981unsafe impl<'a> glib::value::FromValue<'a> for GrabStatus {
1982 type Checker = glib::value::GenericValueTypeChecker<Self>;
1983
1984 #[inline]
1985 unsafe fn from_value(value: &'a glib::Value) -> Self {
1986 skip_assert_initialized!();
1987 unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
1988 }
1989}
1990
1991impl ToValue for GrabStatus {
1992 #[inline]
1993 fn to_value(&self) -> glib::Value {
1994 let mut value = glib::Value::for_value_type::<Self>();
1995 unsafe {
1996 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1997 }
1998 value
1999 }
2000
2001 #[inline]
2002 fn value_type(&self) -> glib::Type {
2003 Self::static_type()
2004 }
2005}
2006
2007impl From<GrabStatus> for glib::Value {
2008 #[inline]
2009 fn from(v: GrabStatus) -> Self {
2010 skip_assert_initialized!();
2011 ToValue::to_value(&v)
2012 }
2013}
2014
2015#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2016#[non_exhaustive]
2017#[doc(alias = "GdkGravity")]
2018pub enum Gravity {
2019 #[doc(alias = "GDK_GRAVITY_NORTH_WEST")]
2020 NorthWest,
2021 #[doc(alias = "GDK_GRAVITY_NORTH")]
2022 North,
2023 #[doc(alias = "GDK_GRAVITY_NORTH_EAST")]
2024 NorthEast,
2025 #[doc(alias = "GDK_GRAVITY_WEST")]
2026 West,
2027 #[doc(alias = "GDK_GRAVITY_CENTER")]
2028 Center,
2029 #[doc(alias = "GDK_GRAVITY_EAST")]
2030 East,
2031 #[doc(alias = "GDK_GRAVITY_SOUTH_WEST")]
2032 SouthWest,
2033 #[doc(alias = "GDK_GRAVITY_SOUTH")]
2034 South,
2035 #[doc(alias = "GDK_GRAVITY_SOUTH_EAST")]
2036 SouthEast,
2037 #[doc(alias = "GDK_GRAVITY_STATIC")]
2038 Static,
2039 #[doc(hidden)]
2040 __Unknown(i32),
2041}
2042
2043#[doc(hidden)]
2044impl IntoGlib for Gravity {
2045 type GlibType = ffi::GdkGravity;
2046
2047 #[inline]
2048 fn into_glib(self) -> ffi::GdkGravity {
2049 match self {
2050 Self::NorthWest => ffi::GDK_GRAVITY_NORTH_WEST,
2051 Self::North => ffi::GDK_GRAVITY_NORTH,
2052 Self::NorthEast => ffi::GDK_GRAVITY_NORTH_EAST,
2053 Self::West => ffi::GDK_GRAVITY_WEST,
2054 Self::Center => ffi::GDK_GRAVITY_CENTER,
2055 Self::East => ffi::GDK_GRAVITY_EAST,
2056 Self::SouthWest => ffi::GDK_GRAVITY_SOUTH_WEST,
2057 Self::South => ffi::GDK_GRAVITY_SOUTH,
2058 Self::SouthEast => ffi::GDK_GRAVITY_SOUTH_EAST,
2059 Self::Static => ffi::GDK_GRAVITY_STATIC,
2060 Self::__Unknown(value) => value,
2061 }
2062 }
2063}
2064
2065#[doc(hidden)]
2066impl FromGlib<ffi::GdkGravity> for Gravity {
2067 #[inline]
2068 unsafe fn from_glib(value: ffi::GdkGravity) -> Self {
2069 skip_assert_initialized!();
2070
2071 match value {
2072 ffi::GDK_GRAVITY_NORTH_WEST => Self::NorthWest,
2073 ffi::GDK_GRAVITY_NORTH => Self::North,
2074 ffi::GDK_GRAVITY_NORTH_EAST => Self::NorthEast,
2075 ffi::GDK_GRAVITY_WEST => Self::West,
2076 ffi::GDK_GRAVITY_CENTER => Self::Center,
2077 ffi::GDK_GRAVITY_EAST => Self::East,
2078 ffi::GDK_GRAVITY_SOUTH_WEST => Self::SouthWest,
2079 ffi::GDK_GRAVITY_SOUTH => Self::South,
2080 ffi::GDK_GRAVITY_SOUTH_EAST => Self::SouthEast,
2081 ffi::GDK_GRAVITY_STATIC => Self::Static,
2082 value => Self::__Unknown(value),
2083 }
2084 }
2085}
2086
2087impl StaticType for Gravity {
2088 #[inline]
2089 #[doc(alias = "gdk_gravity_get_type")]
2090 fn static_type() -> glib::Type {
2091 unsafe { from_glib(ffi::gdk_gravity_get_type()) }
2092 }
2093}
2094
2095impl glib::HasParamSpec for Gravity {
2096 type ParamSpec = glib::ParamSpecEnum;
2097 type SetValue = Self;
2098 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2099
2100 fn param_spec_builder() -> Self::BuilderFn {
2101 Self::ParamSpec::builder_with_default
2102 }
2103}
2104
2105impl glib::value::ValueType for Gravity {
2106 type Type = Self;
2107}
2108
2109unsafe impl<'a> glib::value::FromValue<'a> for Gravity {
2110 type Checker = glib::value::GenericValueTypeChecker<Self>;
2111
2112 #[inline]
2113 unsafe fn from_value(value: &'a glib::Value) -> Self {
2114 skip_assert_initialized!();
2115 unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
2116 }
2117}
2118
2119impl ToValue for Gravity {
2120 #[inline]
2121 fn to_value(&self) -> glib::Value {
2122 let mut value = glib::Value::for_value_type::<Self>();
2123 unsafe {
2124 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2125 }
2126 value
2127 }
2128
2129 #[inline]
2130 fn value_type(&self) -> glib::Type {
2131 Self::static_type()
2132 }
2133}
2134
2135impl From<Gravity> for glib::Value {
2136 #[inline]
2137 fn from(v: Gravity) -> Self {
2138 skip_assert_initialized!();
2139 ToValue::to_value(&v)
2140 }
2141}
2142
2143#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2144#[non_exhaustive]
2145#[doc(alias = "GdkInputMode")]
2146pub enum InputMode {
2147 #[doc(alias = "GDK_MODE_DISABLED")]
2148 Disabled,
2149 #[doc(alias = "GDK_MODE_SCREEN")]
2150 Screen,
2151 #[doc(alias = "GDK_MODE_WINDOW")]
2152 Window,
2153 #[doc(hidden)]
2154 __Unknown(i32),
2155}
2156
2157#[doc(hidden)]
2158impl IntoGlib for InputMode {
2159 type GlibType = ffi::GdkInputMode;
2160
2161 #[inline]
2162 fn into_glib(self) -> ffi::GdkInputMode {
2163 match self {
2164 Self::Disabled => ffi::GDK_MODE_DISABLED,
2165 Self::Screen => ffi::GDK_MODE_SCREEN,
2166 Self::Window => ffi::GDK_MODE_WINDOW,
2167 Self::__Unknown(value) => value,
2168 }
2169 }
2170}
2171
2172#[doc(hidden)]
2173impl FromGlib<ffi::GdkInputMode> for InputMode {
2174 #[inline]
2175 unsafe fn from_glib(value: ffi::GdkInputMode) -> Self {
2176 skip_assert_initialized!();
2177
2178 match value {
2179 ffi::GDK_MODE_DISABLED => Self::Disabled,
2180 ffi::GDK_MODE_SCREEN => Self::Screen,
2181 ffi::GDK_MODE_WINDOW => Self::Window,
2182 value => Self::__Unknown(value),
2183 }
2184 }
2185}
2186
2187impl StaticType for InputMode {
2188 #[inline]
2189 #[doc(alias = "gdk_input_mode_get_type")]
2190 fn static_type() -> glib::Type {
2191 unsafe { from_glib(ffi::gdk_input_mode_get_type()) }
2192 }
2193}
2194
2195impl glib::HasParamSpec for InputMode {
2196 type ParamSpec = glib::ParamSpecEnum;
2197 type SetValue = Self;
2198 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2199
2200 fn param_spec_builder() -> Self::BuilderFn {
2201 Self::ParamSpec::builder_with_default
2202 }
2203}
2204
2205impl glib::value::ValueType for InputMode {
2206 type Type = Self;
2207}
2208
2209unsafe impl<'a> glib::value::FromValue<'a> for InputMode {
2210 type Checker = glib::value::GenericValueTypeChecker<Self>;
2211
2212 #[inline]
2213 unsafe fn from_value(value: &'a glib::Value) -> Self {
2214 skip_assert_initialized!();
2215 unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
2216 }
2217}
2218
2219impl ToValue for InputMode {
2220 #[inline]
2221 fn to_value(&self) -> glib::Value {
2222 let mut value = glib::Value::for_value_type::<Self>();
2223 unsafe {
2224 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2225 }
2226 value
2227 }
2228
2229 #[inline]
2230 fn value_type(&self) -> glib::Type {
2231 Self::static_type()
2232 }
2233}
2234
2235impl From<InputMode> for glib::Value {
2236 #[inline]
2237 fn from(v: InputMode) -> Self {
2238 skip_assert_initialized!();
2239 ToValue::to_value(&v)
2240 }
2241}
2242
2243#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2244#[non_exhaustive]
2245#[doc(alias = "GdkInputSource")]
2246pub enum InputSource {
2247 #[doc(alias = "GDK_SOURCE_MOUSE")]
2248 Mouse,
2249 #[doc(alias = "GDK_SOURCE_PEN")]
2250 Pen,
2251 #[doc(alias = "GDK_SOURCE_ERASER")]
2252 Eraser,
2253 #[doc(alias = "GDK_SOURCE_CURSOR")]
2254 Cursor,
2255 #[doc(alias = "GDK_SOURCE_KEYBOARD")]
2256 Keyboard,
2257 #[doc(alias = "GDK_SOURCE_TOUCHSCREEN")]
2258 Touchscreen,
2259 #[doc(alias = "GDK_SOURCE_TOUCHPAD")]
2260 Touchpad,
2261 #[doc(alias = "GDK_SOURCE_TRACKPOINT")]
2262 Trackpoint,
2263 #[doc(alias = "GDK_SOURCE_TABLET_PAD")]
2264 TabletPad,
2265 #[doc(hidden)]
2266 __Unknown(i32),
2267}
2268
2269#[doc(hidden)]
2270impl IntoGlib for InputSource {
2271 type GlibType = ffi::GdkInputSource;
2272
2273 #[inline]
2274 fn into_glib(self) -> ffi::GdkInputSource {
2275 match self {
2276 Self::Mouse => ffi::GDK_SOURCE_MOUSE,
2277 Self::Pen => ffi::GDK_SOURCE_PEN,
2278 Self::Eraser => ffi::GDK_SOURCE_ERASER,
2279 Self::Cursor => ffi::GDK_SOURCE_CURSOR,
2280 Self::Keyboard => ffi::GDK_SOURCE_KEYBOARD,
2281 Self::Touchscreen => ffi::GDK_SOURCE_TOUCHSCREEN,
2282 Self::Touchpad => ffi::GDK_SOURCE_TOUCHPAD,
2283 Self::Trackpoint => ffi::GDK_SOURCE_TRACKPOINT,
2284 Self::TabletPad => ffi::GDK_SOURCE_TABLET_PAD,
2285 Self::__Unknown(value) => value,
2286 }
2287 }
2288}
2289
2290#[doc(hidden)]
2291impl FromGlib<ffi::GdkInputSource> for InputSource {
2292 #[inline]
2293 unsafe fn from_glib(value: ffi::GdkInputSource) -> Self {
2294 skip_assert_initialized!();
2295
2296 match value {
2297 ffi::GDK_SOURCE_MOUSE => Self::Mouse,
2298 ffi::GDK_SOURCE_PEN => Self::Pen,
2299 ffi::GDK_SOURCE_ERASER => Self::Eraser,
2300 ffi::GDK_SOURCE_CURSOR => Self::Cursor,
2301 ffi::GDK_SOURCE_KEYBOARD => Self::Keyboard,
2302 ffi::GDK_SOURCE_TOUCHSCREEN => Self::Touchscreen,
2303 ffi::GDK_SOURCE_TOUCHPAD => Self::Touchpad,
2304 ffi::GDK_SOURCE_TRACKPOINT => Self::Trackpoint,
2305 ffi::GDK_SOURCE_TABLET_PAD => Self::TabletPad,
2306 value => Self::__Unknown(value),
2307 }
2308 }
2309}
2310
2311impl StaticType for InputSource {
2312 #[inline]
2313 #[doc(alias = "gdk_input_source_get_type")]
2314 fn static_type() -> glib::Type {
2315 unsafe { from_glib(ffi::gdk_input_source_get_type()) }
2316 }
2317}
2318
2319impl glib::HasParamSpec for InputSource {
2320 type ParamSpec = glib::ParamSpecEnum;
2321 type SetValue = Self;
2322 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2323
2324 fn param_spec_builder() -> Self::BuilderFn {
2325 Self::ParamSpec::builder_with_default
2326 }
2327}
2328
2329impl glib::value::ValueType for InputSource {
2330 type Type = Self;
2331}
2332
2333unsafe impl<'a> glib::value::FromValue<'a> for InputSource {
2334 type Checker = glib::value::GenericValueTypeChecker<Self>;
2335
2336 #[inline]
2337 unsafe fn from_value(value: &'a glib::Value) -> Self {
2338 skip_assert_initialized!();
2339 unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
2340 }
2341}
2342
2343impl ToValue for InputSource {
2344 #[inline]
2345 fn to_value(&self) -> glib::Value {
2346 let mut value = glib::Value::for_value_type::<Self>();
2347 unsafe {
2348 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2349 }
2350 value
2351 }
2352
2353 #[inline]
2354 fn value_type(&self) -> glib::Type {
2355 Self::static_type()
2356 }
2357}
2358
2359impl From<InputSource> for glib::Value {
2360 #[inline]
2361 fn from(v: InputSource) -> Self {
2362 skip_assert_initialized!();
2363 ToValue::to_value(&v)
2364 }
2365}
2366
2367#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2368#[non_exhaustive]
2369#[doc(alias = "GdkModifierIntent")]
2370pub enum ModifierIntent {
2371 #[doc(alias = "GDK_MODIFIER_INTENT_PRIMARY_ACCELERATOR")]
2372 PrimaryAccelerator,
2373 #[doc(alias = "GDK_MODIFIER_INTENT_CONTEXT_MENU")]
2374 ContextMenu,
2375 #[doc(alias = "GDK_MODIFIER_INTENT_EXTEND_SELECTION")]
2376 ExtendSelection,
2377 #[doc(alias = "GDK_MODIFIER_INTENT_MODIFY_SELECTION")]
2378 ModifySelection,
2379 #[doc(alias = "GDK_MODIFIER_INTENT_NO_TEXT_INPUT")]
2380 NoTextInput,
2381 #[doc(alias = "GDK_MODIFIER_INTENT_SHIFT_GROUP")]
2382 ShiftGroup,
2383 #[doc(alias = "GDK_MODIFIER_INTENT_DEFAULT_MOD_MASK")]
2384 DefaultModMask,
2385 #[doc(hidden)]
2386 __Unknown(i32),
2387}
2388
2389#[doc(hidden)]
2390impl IntoGlib for ModifierIntent {
2391 type GlibType = ffi::GdkModifierIntent;
2392
2393 #[inline]
2394 fn into_glib(self) -> ffi::GdkModifierIntent {
2395 match self {
2396 Self::PrimaryAccelerator => ffi::GDK_MODIFIER_INTENT_PRIMARY_ACCELERATOR,
2397 Self::ContextMenu => ffi::GDK_MODIFIER_INTENT_CONTEXT_MENU,
2398 Self::ExtendSelection => ffi::GDK_MODIFIER_INTENT_EXTEND_SELECTION,
2399 Self::ModifySelection => ffi::GDK_MODIFIER_INTENT_MODIFY_SELECTION,
2400 Self::NoTextInput => ffi::GDK_MODIFIER_INTENT_NO_TEXT_INPUT,
2401 Self::ShiftGroup => ffi::GDK_MODIFIER_INTENT_SHIFT_GROUP,
2402 Self::DefaultModMask => ffi::GDK_MODIFIER_INTENT_DEFAULT_MOD_MASK,
2403 Self::__Unknown(value) => value,
2404 }
2405 }
2406}
2407
2408#[doc(hidden)]
2409impl FromGlib<ffi::GdkModifierIntent> for ModifierIntent {
2410 #[inline]
2411 unsafe fn from_glib(value: ffi::GdkModifierIntent) -> Self {
2412 skip_assert_initialized!();
2413
2414 match value {
2415 ffi::GDK_MODIFIER_INTENT_PRIMARY_ACCELERATOR => Self::PrimaryAccelerator,
2416 ffi::GDK_MODIFIER_INTENT_CONTEXT_MENU => Self::ContextMenu,
2417 ffi::GDK_MODIFIER_INTENT_EXTEND_SELECTION => Self::ExtendSelection,
2418 ffi::GDK_MODIFIER_INTENT_MODIFY_SELECTION => Self::ModifySelection,
2419 ffi::GDK_MODIFIER_INTENT_NO_TEXT_INPUT => Self::NoTextInput,
2420 ffi::GDK_MODIFIER_INTENT_SHIFT_GROUP => Self::ShiftGroup,
2421 ffi::GDK_MODIFIER_INTENT_DEFAULT_MOD_MASK => Self::DefaultModMask,
2422 value => Self::__Unknown(value),
2423 }
2424 }
2425}
2426
2427impl StaticType for ModifierIntent {
2428 #[inline]
2429 #[doc(alias = "gdk_modifier_intent_get_type")]
2430 fn static_type() -> glib::Type {
2431 unsafe { from_glib(ffi::gdk_modifier_intent_get_type()) }
2432 }
2433}
2434
2435impl glib::HasParamSpec for ModifierIntent {
2436 type ParamSpec = glib::ParamSpecEnum;
2437 type SetValue = Self;
2438 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2439
2440 fn param_spec_builder() -> Self::BuilderFn {
2441 Self::ParamSpec::builder_with_default
2442 }
2443}
2444
2445impl glib::value::ValueType for ModifierIntent {
2446 type Type = Self;
2447}
2448
2449unsafe impl<'a> glib::value::FromValue<'a> for ModifierIntent {
2450 type Checker = glib::value::GenericValueTypeChecker<Self>;
2451
2452 #[inline]
2453 unsafe fn from_value(value: &'a glib::Value) -> Self {
2454 skip_assert_initialized!();
2455 unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
2456 }
2457}
2458
2459impl ToValue for ModifierIntent {
2460 #[inline]
2461 fn to_value(&self) -> glib::Value {
2462 let mut value = glib::Value::for_value_type::<Self>();
2463 unsafe {
2464 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2465 }
2466 value
2467 }
2468
2469 #[inline]
2470 fn value_type(&self) -> glib::Type {
2471 Self::static_type()
2472 }
2473}
2474
2475impl From<ModifierIntent> for glib::Value {
2476 #[inline]
2477 fn from(v: ModifierIntent) -> Self {
2478 skip_assert_initialized!();
2479 ToValue::to_value(&v)
2480 }
2481}
2482
2483#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2484#[non_exhaustive]
2485#[doc(alias = "GdkNotifyType")]
2486pub enum NotifyType {
2487 #[doc(alias = "GDK_NOTIFY_ANCESTOR")]
2488 Ancestor,
2489 #[doc(alias = "GDK_NOTIFY_VIRTUAL")]
2490 Virtual,
2491 #[doc(alias = "GDK_NOTIFY_INFERIOR")]
2492 Inferior,
2493 #[doc(alias = "GDK_NOTIFY_NONLINEAR")]
2494 Nonlinear,
2495 #[doc(alias = "GDK_NOTIFY_NONLINEAR_VIRTUAL")]
2496 NonlinearVirtual,
2497 #[doc(alias = "GDK_NOTIFY_UNKNOWN")]
2498 Unknown,
2499 #[doc(hidden)]
2500 __Unknown(i32),
2501}
2502
2503#[doc(hidden)]
2504impl IntoGlib for NotifyType {
2505 type GlibType = ffi::GdkNotifyType;
2506
2507 #[inline]
2508 fn into_glib(self) -> ffi::GdkNotifyType {
2509 match self {
2510 Self::Ancestor => ffi::GDK_NOTIFY_ANCESTOR,
2511 Self::Virtual => ffi::GDK_NOTIFY_VIRTUAL,
2512 Self::Inferior => ffi::GDK_NOTIFY_INFERIOR,
2513 Self::Nonlinear => ffi::GDK_NOTIFY_NONLINEAR,
2514 Self::NonlinearVirtual => ffi::GDK_NOTIFY_NONLINEAR_VIRTUAL,
2515 Self::Unknown => ffi::GDK_NOTIFY_UNKNOWN,
2516 Self::__Unknown(value) => value,
2517 }
2518 }
2519}
2520
2521#[doc(hidden)]
2522impl FromGlib<ffi::GdkNotifyType> for NotifyType {
2523 #[inline]
2524 unsafe fn from_glib(value: ffi::GdkNotifyType) -> Self {
2525 skip_assert_initialized!();
2526
2527 match value {
2528 ffi::GDK_NOTIFY_ANCESTOR => Self::Ancestor,
2529 ffi::GDK_NOTIFY_VIRTUAL => Self::Virtual,
2530 ffi::GDK_NOTIFY_INFERIOR => Self::Inferior,
2531 ffi::GDK_NOTIFY_NONLINEAR => Self::Nonlinear,
2532 ffi::GDK_NOTIFY_NONLINEAR_VIRTUAL => Self::NonlinearVirtual,
2533 ffi::GDK_NOTIFY_UNKNOWN => Self::Unknown,
2534 value => Self::__Unknown(value),
2535 }
2536 }
2537}
2538
2539impl StaticType for NotifyType {
2540 #[inline]
2541 #[doc(alias = "gdk_notify_type_get_type")]
2542 fn static_type() -> glib::Type {
2543 unsafe { from_glib(ffi::gdk_notify_type_get_type()) }
2544 }
2545}
2546
2547impl glib::HasParamSpec for NotifyType {
2548 type ParamSpec = glib::ParamSpecEnum;
2549 type SetValue = Self;
2550 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2551
2552 fn param_spec_builder() -> Self::BuilderFn {
2553 Self::ParamSpec::builder_with_default
2554 }
2555}
2556
2557impl glib::value::ValueType for NotifyType {
2558 type Type = Self;
2559}
2560
2561unsafe impl<'a> glib::value::FromValue<'a> for NotifyType {
2562 type Checker = glib::value::GenericValueTypeChecker<Self>;
2563
2564 #[inline]
2565 unsafe fn from_value(value: &'a glib::Value) -> Self {
2566 skip_assert_initialized!();
2567 unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
2568 }
2569}
2570
2571impl ToValue for NotifyType {
2572 #[inline]
2573 fn to_value(&self) -> glib::Value {
2574 let mut value = glib::Value::for_value_type::<Self>();
2575 unsafe {
2576 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2577 }
2578 value
2579 }
2580
2581 #[inline]
2582 fn value_type(&self) -> glib::Type {
2583 Self::static_type()
2584 }
2585}
2586
2587impl From<NotifyType> for glib::Value {
2588 #[inline]
2589 fn from(v: NotifyType) -> Self {
2590 skip_assert_initialized!();
2591 ToValue::to_value(&v)
2592 }
2593}
2594
2595#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2596#[non_exhaustive]
2597#[doc(alias = "GdkOwnerChange")]
2598pub enum OwnerChange {
2599 #[doc(alias = "GDK_OWNER_CHANGE_NEW_OWNER")]
2600 NewOwner,
2601 #[doc(alias = "GDK_OWNER_CHANGE_DESTROY")]
2602 Destroy,
2603 #[doc(alias = "GDK_OWNER_CHANGE_CLOSE")]
2604 Close,
2605 #[doc(hidden)]
2606 __Unknown(i32),
2607}
2608
2609#[doc(hidden)]
2610impl IntoGlib for OwnerChange {
2611 type GlibType = ffi::GdkOwnerChange;
2612
2613 #[inline]
2614 fn into_glib(self) -> ffi::GdkOwnerChange {
2615 match self {
2616 Self::NewOwner => ffi::GDK_OWNER_CHANGE_NEW_OWNER,
2617 Self::Destroy => ffi::GDK_OWNER_CHANGE_DESTROY,
2618 Self::Close => ffi::GDK_OWNER_CHANGE_CLOSE,
2619 Self::__Unknown(value) => value,
2620 }
2621 }
2622}
2623
2624#[doc(hidden)]
2625impl FromGlib<ffi::GdkOwnerChange> for OwnerChange {
2626 #[inline]
2627 unsafe fn from_glib(value: ffi::GdkOwnerChange) -> Self {
2628 skip_assert_initialized!();
2629
2630 match value {
2631 ffi::GDK_OWNER_CHANGE_NEW_OWNER => Self::NewOwner,
2632 ffi::GDK_OWNER_CHANGE_DESTROY => Self::Destroy,
2633 ffi::GDK_OWNER_CHANGE_CLOSE => Self::Close,
2634 value => Self::__Unknown(value),
2635 }
2636 }
2637}
2638
2639impl StaticType for OwnerChange {
2640 #[inline]
2641 #[doc(alias = "gdk_owner_change_get_type")]
2642 fn static_type() -> glib::Type {
2643 unsafe { from_glib(ffi::gdk_owner_change_get_type()) }
2644 }
2645}
2646
2647impl glib::HasParamSpec for OwnerChange {
2648 type ParamSpec = glib::ParamSpecEnum;
2649 type SetValue = Self;
2650 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2651
2652 fn param_spec_builder() -> Self::BuilderFn {
2653 Self::ParamSpec::builder_with_default
2654 }
2655}
2656
2657impl glib::value::ValueType for OwnerChange {
2658 type Type = Self;
2659}
2660
2661unsafe impl<'a> glib::value::FromValue<'a> for OwnerChange {
2662 type Checker = glib::value::GenericValueTypeChecker<Self>;
2663
2664 #[inline]
2665 unsafe fn from_value(value: &'a glib::Value) -> Self {
2666 skip_assert_initialized!();
2667 unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
2668 }
2669}
2670
2671impl ToValue for OwnerChange {
2672 #[inline]
2673 fn to_value(&self) -> glib::Value {
2674 let mut value = glib::Value::for_value_type::<Self>();
2675 unsafe {
2676 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2677 }
2678 value
2679 }
2680
2681 #[inline]
2682 fn value_type(&self) -> glib::Type {
2683 Self::static_type()
2684 }
2685}
2686
2687impl From<OwnerChange> for glib::Value {
2688 #[inline]
2689 fn from(v: OwnerChange) -> Self {
2690 skip_assert_initialized!();
2691 ToValue::to_value(&v)
2692 }
2693}
2694
2695#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2696#[non_exhaustive]
2697#[doc(alias = "GdkPropMode")]
2698pub enum PropMode {
2699 #[doc(alias = "GDK_PROP_MODE_REPLACE")]
2700 Replace,
2701 #[doc(alias = "GDK_PROP_MODE_PREPEND")]
2702 Prepend,
2703 #[doc(alias = "GDK_PROP_MODE_APPEND")]
2704 Append,
2705 #[doc(hidden)]
2706 __Unknown(i32),
2707}
2708
2709#[doc(hidden)]
2710impl IntoGlib for PropMode {
2711 type GlibType = ffi::GdkPropMode;
2712
2713 #[inline]
2714 fn into_glib(self) -> ffi::GdkPropMode {
2715 match self {
2716 Self::Replace => ffi::GDK_PROP_MODE_REPLACE,
2717 Self::Prepend => ffi::GDK_PROP_MODE_PREPEND,
2718 Self::Append => ffi::GDK_PROP_MODE_APPEND,
2719 Self::__Unknown(value) => value,
2720 }
2721 }
2722}
2723
2724#[doc(hidden)]
2725impl FromGlib<ffi::GdkPropMode> for PropMode {
2726 #[inline]
2727 unsafe fn from_glib(value: ffi::GdkPropMode) -> Self {
2728 skip_assert_initialized!();
2729
2730 match value {
2731 ffi::GDK_PROP_MODE_REPLACE => Self::Replace,
2732 ffi::GDK_PROP_MODE_PREPEND => Self::Prepend,
2733 ffi::GDK_PROP_MODE_APPEND => Self::Append,
2734 value => Self::__Unknown(value),
2735 }
2736 }
2737}
2738
2739impl StaticType for PropMode {
2740 #[inline]
2741 #[doc(alias = "gdk_prop_mode_get_type")]
2742 fn static_type() -> glib::Type {
2743 unsafe { from_glib(ffi::gdk_prop_mode_get_type()) }
2744 }
2745}
2746
2747impl glib::HasParamSpec for PropMode {
2748 type ParamSpec = glib::ParamSpecEnum;
2749 type SetValue = Self;
2750 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2751
2752 fn param_spec_builder() -> Self::BuilderFn {
2753 Self::ParamSpec::builder_with_default
2754 }
2755}
2756
2757impl glib::value::ValueType for PropMode {
2758 type Type = Self;
2759}
2760
2761unsafe impl<'a> glib::value::FromValue<'a> for PropMode {
2762 type Checker = glib::value::GenericValueTypeChecker<Self>;
2763
2764 #[inline]
2765 unsafe fn from_value(value: &'a glib::Value) -> Self {
2766 skip_assert_initialized!();
2767 unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
2768 }
2769}
2770
2771impl ToValue for PropMode {
2772 #[inline]
2773 fn to_value(&self) -> glib::Value {
2774 let mut value = glib::Value::for_value_type::<Self>();
2775 unsafe {
2776 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2777 }
2778 value
2779 }
2780
2781 #[inline]
2782 fn value_type(&self) -> glib::Type {
2783 Self::static_type()
2784 }
2785}
2786
2787impl From<PropMode> for glib::Value {
2788 #[inline]
2789 fn from(v: PropMode) -> Self {
2790 skip_assert_initialized!();
2791 ToValue::to_value(&v)
2792 }
2793}
2794
2795#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2796#[non_exhaustive]
2797#[doc(alias = "GdkPropertyState")]
2798pub enum PropertyState {
2799 #[doc(alias = "GDK_PROPERTY_NEW_VALUE")]
2800 NewValue,
2801 #[doc(alias = "GDK_PROPERTY_DELETE")]
2802 Delete,
2803 #[doc(hidden)]
2804 __Unknown(i32),
2805}
2806
2807#[doc(hidden)]
2808impl IntoGlib for PropertyState {
2809 type GlibType = ffi::GdkPropertyState;
2810
2811 #[inline]
2812 fn into_glib(self) -> ffi::GdkPropertyState {
2813 match self {
2814 Self::NewValue => ffi::GDK_PROPERTY_NEW_VALUE,
2815 Self::Delete => ffi::GDK_PROPERTY_DELETE,
2816 Self::__Unknown(value) => value,
2817 }
2818 }
2819}
2820
2821#[doc(hidden)]
2822impl FromGlib<ffi::GdkPropertyState> for PropertyState {
2823 #[inline]
2824 unsafe fn from_glib(value: ffi::GdkPropertyState) -> Self {
2825 skip_assert_initialized!();
2826
2827 match value {
2828 ffi::GDK_PROPERTY_NEW_VALUE => Self::NewValue,
2829 ffi::GDK_PROPERTY_DELETE => Self::Delete,
2830 value => Self::__Unknown(value),
2831 }
2832 }
2833}
2834
2835impl StaticType for PropertyState {
2836 #[inline]
2837 #[doc(alias = "gdk_property_state_get_type")]
2838 fn static_type() -> glib::Type {
2839 unsafe { from_glib(ffi::gdk_property_state_get_type()) }
2840 }
2841}
2842
2843impl glib::HasParamSpec for PropertyState {
2844 type ParamSpec = glib::ParamSpecEnum;
2845 type SetValue = Self;
2846 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2847
2848 fn param_spec_builder() -> Self::BuilderFn {
2849 Self::ParamSpec::builder_with_default
2850 }
2851}
2852
2853impl glib::value::ValueType for PropertyState {
2854 type Type = Self;
2855}
2856
2857unsafe impl<'a> glib::value::FromValue<'a> for PropertyState {
2858 type Checker = glib::value::GenericValueTypeChecker<Self>;
2859
2860 #[inline]
2861 unsafe fn from_value(value: &'a glib::Value) -> Self {
2862 skip_assert_initialized!();
2863 unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
2864 }
2865}
2866
2867impl ToValue for PropertyState {
2868 #[inline]
2869 fn to_value(&self) -> glib::Value {
2870 let mut value = glib::Value::for_value_type::<Self>();
2871 unsafe {
2872 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2873 }
2874 value
2875 }
2876
2877 #[inline]
2878 fn value_type(&self) -> glib::Type {
2879 Self::static_type()
2880 }
2881}
2882
2883impl From<PropertyState> for glib::Value {
2884 #[inline]
2885 fn from(v: PropertyState) -> Self {
2886 skip_assert_initialized!();
2887 ToValue::to_value(&v)
2888 }
2889}
2890
2891#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2892#[non_exhaustive]
2893#[doc(alias = "GdkScrollDirection")]
2894pub enum ScrollDirection {
2895 #[doc(alias = "GDK_SCROLL_UP")]
2896 Up,
2897 #[doc(alias = "GDK_SCROLL_DOWN")]
2898 Down,
2899 #[doc(alias = "GDK_SCROLL_LEFT")]
2900 Left,
2901 #[doc(alias = "GDK_SCROLL_RIGHT")]
2902 Right,
2903 #[doc(alias = "GDK_SCROLL_SMOOTH")]
2904 Smooth,
2905 #[doc(hidden)]
2906 __Unknown(i32),
2907}
2908
2909#[doc(hidden)]
2910impl IntoGlib for ScrollDirection {
2911 type GlibType = ffi::GdkScrollDirection;
2912
2913 #[inline]
2914 fn into_glib(self) -> ffi::GdkScrollDirection {
2915 match self {
2916 Self::Up => ffi::GDK_SCROLL_UP,
2917 Self::Down => ffi::GDK_SCROLL_DOWN,
2918 Self::Left => ffi::GDK_SCROLL_LEFT,
2919 Self::Right => ffi::GDK_SCROLL_RIGHT,
2920 Self::Smooth => ffi::GDK_SCROLL_SMOOTH,
2921 Self::__Unknown(value) => value,
2922 }
2923 }
2924}
2925
2926#[doc(hidden)]
2927impl FromGlib<ffi::GdkScrollDirection> for ScrollDirection {
2928 #[inline]
2929 unsafe fn from_glib(value: ffi::GdkScrollDirection) -> Self {
2930 skip_assert_initialized!();
2931
2932 match value {
2933 ffi::GDK_SCROLL_UP => Self::Up,
2934 ffi::GDK_SCROLL_DOWN => Self::Down,
2935 ffi::GDK_SCROLL_LEFT => Self::Left,
2936 ffi::GDK_SCROLL_RIGHT => Self::Right,
2937 ffi::GDK_SCROLL_SMOOTH => Self::Smooth,
2938 value => Self::__Unknown(value),
2939 }
2940 }
2941}
2942
2943impl StaticType for ScrollDirection {
2944 #[inline]
2945 #[doc(alias = "gdk_scroll_direction_get_type")]
2946 fn static_type() -> glib::Type {
2947 unsafe { from_glib(ffi::gdk_scroll_direction_get_type()) }
2948 }
2949}
2950
2951impl glib::HasParamSpec for ScrollDirection {
2952 type ParamSpec = glib::ParamSpecEnum;
2953 type SetValue = Self;
2954 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2955
2956 fn param_spec_builder() -> Self::BuilderFn {
2957 Self::ParamSpec::builder_with_default
2958 }
2959}
2960
2961impl glib::value::ValueType for ScrollDirection {
2962 type Type = Self;
2963}
2964
2965unsafe impl<'a> glib::value::FromValue<'a> for ScrollDirection {
2966 type Checker = glib::value::GenericValueTypeChecker<Self>;
2967
2968 #[inline]
2969 unsafe fn from_value(value: &'a glib::Value) -> Self {
2970 skip_assert_initialized!();
2971 unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
2972 }
2973}
2974
2975impl ToValue for ScrollDirection {
2976 #[inline]
2977 fn to_value(&self) -> glib::Value {
2978 let mut value = glib::Value::for_value_type::<Self>();
2979 unsafe {
2980 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2981 }
2982 value
2983 }
2984
2985 #[inline]
2986 fn value_type(&self) -> glib::Type {
2987 Self::static_type()
2988 }
2989}
2990
2991impl From<ScrollDirection> for glib::Value {
2992 #[inline]
2993 fn from(v: ScrollDirection) -> Self {
2994 skip_assert_initialized!();
2995 ToValue::to_value(&v)
2996 }
2997}
2998
2999#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3000#[non_exhaustive]
3001#[doc(alias = "GdkSettingAction")]
3002pub enum SettingAction {
3003 #[doc(alias = "GDK_SETTING_ACTION_NEW")]
3004 New,
3005 #[doc(alias = "GDK_SETTING_ACTION_CHANGED")]
3006 Changed,
3007 #[doc(alias = "GDK_SETTING_ACTION_DELETED")]
3008 Deleted,
3009 #[doc(hidden)]
3010 __Unknown(i32),
3011}
3012
3013#[doc(hidden)]
3014impl IntoGlib for SettingAction {
3015 type GlibType = ffi::GdkSettingAction;
3016
3017 #[inline]
3018 fn into_glib(self) -> ffi::GdkSettingAction {
3019 match self {
3020 Self::New => ffi::GDK_SETTING_ACTION_NEW,
3021 Self::Changed => ffi::GDK_SETTING_ACTION_CHANGED,
3022 Self::Deleted => ffi::GDK_SETTING_ACTION_DELETED,
3023 Self::__Unknown(value) => value,
3024 }
3025 }
3026}
3027
3028#[doc(hidden)]
3029impl FromGlib<ffi::GdkSettingAction> for SettingAction {
3030 #[inline]
3031 unsafe fn from_glib(value: ffi::GdkSettingAction) -> Self {
3032 skip_assert_initialized!();
3033
3034 match value {
3035 ffi::GDK_SETTING_ACTION_NEW => Self::New,
3036 ffi::GDK_SETTING_ACTION_CHANGED => Self::Changed,
3037 ffi::GDK_SETTING_ACTION_DELETED => Self::Deleted,
3038 value => Self::__Unknown(value),
3039 }
3040 }
3041}
3042
3043impl StaticType for SettingAction {
3044 #[inline]
3045 #[doc(alias = "gdk_setting_action_get_type")]
3046 fn static_type() -> glib::Type {
3047 unsafe { from_glib(ffi::gdk_setting_action_get_type()) }
3048 }
3049}
3050
3051impl glib::HasParamSpec for SettingAction {
3052 type ParamSpec = glib::ParamSpecEnum;
3053 type SetValue = Self;
3054 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3055
3056 fn param_spec_builder() -> Self::BuilderFn {
3057 Self::ParamSpec::builder_with_default
3058 }
3059}
3060
3061impl glib::value::ValueType for SettingAction {
3062 type Type = Self;
3063}
3064
3065unsafe impl<'a> glib::value::FromValue<'a> for SettingAction {
3066 type Checker = glib::value::GenericValueTypeChecker<Self>;
3067
3068 #[inline]
3069 unsafe fn from_value(value: &'a glib::Value) -> Self {
3070 skip_assert_initialized!();
3071 unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
3072 }
3073}
3074
3075impl ToValue for SettingAction {
3076 #[inline]
3077 fn to_value(&self) -> glib::Value {
3078 let mut value = glib::Value::for_value_type::<Self>();
3079 unsafe {
3080 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3081 }
3082 value
3083 }
3084
3085 #[inline]
3086 fn value_type(&self) -> glib::Type {
3087 Self::static_type()
3088 }
3089}
3090
3091impl From<SettingAction> for glib::Value {
3092 #[inline]
3093 fn from(v: SettingAction) -> Self {
3094 skip_assert_initialized!();
3095 ToValue::to_value(&v)
3096 }
3097}
3098
3099#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3100#[non_exhaustive]
3101#[doc(alias = "GdkSubpixelLayout")]
3102pub enum SubpixelLayout {
3103 #[doc(alias = "GDK_SUBPIXEL_LAYOUT_UNKNOWN")]
3104 Unknown,
3105 #[doc(alias = "GDK_SUBPIXEL_LAYOUT_NONE")]
3106 None,
3107 #[doc(alias = "GDK_SUBPIXEL_LAYOUT_HORIZONTAL_RGB")]
3108 HorizontalRgb,
3109 #[doc(alias = "GDK_SUBPIXEL_LAYOUT_HORIZONTAL_BGR")]
3110 HorizontalBgr,
3111 #[doc(alias = "GDK_SUBPIXEL_LAYOUT_VERTICAL_RGB")]
3112 VerticalRgb,
3113 #[doc(alias = "GDK_SUBPIXEL_LAYOUT_VERTICAL_BGR")]
3114 VerticalBgr,
3115 #[doc(hidden)]
3116 __Unknown(i32),
3117}
3118
3119#[doc(hidden)]
3120impl IntoGlib for SubpixelLayout {
3121 type GlibType = ffi::GdkSubpixelLayout;
3122
3123 #[inline]
3124 fn into_glib(self) -> ffi::GdkSubpixelLayout {
3125 match self {
3126 Self::Unknown => ffi::GDK_SUBPIXEL_LAYOUT_UNKNOWN,
3127 Self::None => ffi::GDK_SUBPIXEL_LAYOUT_NONE,
3128 Self::HorizontalRgb => ffi::GDK_SUBPIXEL_LAYOUT_HORIZONTAL_RGB,
3129 Self::HorizontalBgr => ffi::GDK_SUBPIXEL_LAYOUT_HORIZONTAL_BGR,
3130 Self::VerticalRgb => ffi::GDK_SUBPIXEL_LAYOUT_VERTICAL_RGB,
3131 Self::VerticalBgr => ffi::GDK_SUBPIXEL_LAYOUT_VERTICAL_BGR,
3132 Self::__Unknown(value) => value,
3133 }
3134 }
3135}
3136
3137#[doc(hidden)]
3138impl FromGlib<ffi::GdkSubpixelLayout> for SubpixelLayout {
3139 #[inline]
3140 unsafe fn from_glib(value: ffi::GdkSubpixelLayout) -> Self {
3141 skip_assert_initialized!();
3142
3143 match value {
3144 ffi::GDK_SUBPIXEL_LAYOUT_UNKNOWN => Self::Unknown,
3145 ffi::GDK_SUBPIXEL_LAYOUT_NONE => Self::None,
3146 ffi::GDK_SUBPIXEL_LAYOUT_HORIZONTAL_RGB => Self::HorizontalRgb,
3147 ffi::GDK_SUBPIXEL_LAYOUT_HORIZONTAL_BGR => Self::HorizontalBgr,
3148 ffi::GDK_SUBPIXEL_LAYOUT_VERTICAL_RGB => Self::VerticalRgb,
3149 ffi::GDK_SUBPIXEL_LAYOUT_VERTICAL_BGR => Self::VerticalBgr,
3150 value => Self::__Unknown(value),
3151 }
3152 }
3153}
3154
3155impl StaticType for SubpixelLayout {
3156 #[inline]
3157 #[doc(alias = "gdk_subpixel_layout_get_type")]
3158 fn static_type() -> glib::Type {
3159 unsafe { from_glib(ffi::gdk_subpixel_layout_get_type()) }
3160 }
3161}
3162
3163impl glib::HasParamSpec for SubpixelLayout {
3164 type ParamSpec = glib::ParamSpecEnum;
3165 type SetValue = Self;
3166 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3167
3168 fn param_spec_builder() -> Self::BuilderFn {
3169 Self::ParamSpec::builder_with_default
3170 }
3171}
3172
3173impl glib::value::ValueType for SubpixelLayout {
3174 type Type = Self;
3175}
3176
3177unsafe impl<'a> glib::value::FromValue<'a> for SubpixelLayout {
3178 type Checker = glib::value::GenericValueTypeChecker<Self>;
3179
3180 #[inline]
3181 unsafe fn from_value(value: &'a glib::Value) -> Self {
3182 skip_assert_initialized!();
3183 unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
3184 }
3185}
3186
3187impl ToValue for SubpixelLayout {
3188 #[inline]
3189 fn to_value(&self) -> glib::Value {
3190 let mut value = glib::Value::for_value_type::<Self>();
3191 unsafe {
3192 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3193 }
3194 value
3195 }
3196
3197 #[inline]
3198 fn value_type(&self) -> glib::Type {
3199 Self::static_type()
3200 }
3201}
3202
3203impl From<SubpixelLayout> for glib::Value {
3204 #[inline]
3205 fn from(v: SubpixelLayout) -> Self {
3206 skip_assert_initialized!();
3207 ToValue::to_value(&v)
3208 }
3209}
3210
3211#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3212#[non_exhaustive]
3213#[doc(alias = "GdkVisibilityState")]
3214pub enum VisibilityState {
3215 #[doc(alias = "GDK_VISIBILITY_UNOBSCURED")]
3216 Unobscured,
3217 #[doc(alias = "GDK_VISIBILITY_PARTIAL")]
3218 Partial,
3219 #[doc(alias = "GDK_VISIBILITY_FULLY_OBSCURED")]
3220 FullyObscured,
3221 #[doc(hidden)]
3222 __Unknown(i32),
3223}
3224
3225#[doc(hidden)]
3226impl IntoGlib for VisibilityState {
3227 type GlibType = ffi::GdkVisibilityState;
3228
3229 #[inline]
3230 fn into_glib(self) -> ffi::GdkVisibilityState {
3231 match self {
3232 Self::Unobscured => ffi::GDK_VISIBILITY_UNOBSCURED,
3233 Self::Partial => ffi::GDK_VISIBILITY_PARTIAL,
3234 Self::FullyObscured => ffi::GDK_VISIBILITY_FULLY_OBSCURED,
3235 Self::__Unknown(value) => value,
3236 }
3237 }
3238}
3239
3240#[doc(hidden)]
3241impl FromGlib<ffi::GdkVisibilityState> for VisibilityState {
3242 #[inline]
3243 unsafe fn from_glib(value: ffi::GdkVisibilityState) -> Self {
3244 skip_assert_initialized!();
3245
3246 match value {
3247 ffi::GDK_VISIBILITY_UNOBSCURED => Self::Unobscured,
3248 ffi::GDK_VISIBILITY_PARTIAL => Self::Partial,
3249 ffi::GDK_VISIBILITY_FULLY_OBSCURED => Self::FullyObscured,
3250 value => Self::__Unknown(value),
3251 }
3252 }
3253}
3254
3255impl StaticType for VisibilityState {
3256 #[inline]
3257 #[doc(alias = "gdk_visibility_state_get_type")]
3258 fn static_type() -> glib::Type {
3259 unsafe { from_glib(ffi::gdk_visibility_state_get_type()) }
3260 }
3261}
3262
3263impl glib::HasParamSpec for VisibilityState {
3264 type ParamSpec = glib::ParamSpecEnum;
3265 type SetValue = Self;
3266 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3267
3268 fn param_spec_builder() -> Self::BuilderFn {
3269 Self::ParamSpec::builder_with_default
3270 }
3271}
3272
3273impl glib::value::ValueType for VisibilityState {
3274 type Type = Self;
3275}
3276
3277unsafe impl<'a> glib::value::FromValue<'a> for VisibilityState {
3278 type Checker = glib::value::GenericValueTypeChecker<Self>;
3279
3280 #[inline]
3281 unsafe fn from_value(value: &'a glib::Value) -> Self {
3282 skip_assert_initialized!();
3283 unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
3284 }
3285}
3286
3287impl ToValue for VisibilityState {
3288 #[inline]
3289 fn to_value(&self) -> glib::Value {
3290 let mut value = glib::Value::for_value_type::<Self>();
3291 unsafe {
3292 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3293 }
3294 value
3295 }
3296
3297 #[inline]
3298 fn value_type(&self) -> glib::Type {
3299 Self::static_type()
3300 }
3301}
3302
3303impl From<VisibilityState> for glib::Value {
3304 #[inline]
3305 fn from(v: VisibilityState) -> Self {
3306 skip_assert_initialized!();
3307 ToValue::to_value(&v)
3308 }
3309}
3310
3311#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3312#[non_exhaustive]
3313#[doc(alias = "GdkVisualType")]
3314pub enum VisualType {
3315 #[doc(alias = "GDK_VISUAL_STATIC_GRAY")]
3316 StaticGray,
3317 #[doc(alias = "GDK_VISUAL_GRAYSCALE")]
3318 Grayscale,
3319 #[doc(alias = "GDK_VISUAL_STATIC_COLOR")]
3320 StaticColor,
3321 #[doc(alias = "GDK_VISUAL_PSEUDO_COLOR")]
3322 PseudoColor,
3323 #[doc(alias = "GDK_VISUAL_TRUE_COLOR")]
3324 TrueColor,
3325 #[doc(alias = "GDK_VISUAL_DIRECT_COLOR")]
3326 DirectColor,
3327 #[doc(hidden)]
3328 __Unknown(i32),
3329}
3330
3331#[doc(hidden)]
3332impl IntoGlib for VisualType {
3333 type GlibType = ffi::GdkVisualType;
3334
3335 #[inline]
3336 fn into_glib(self) -> ffi::GdkVisualType {
3337 match self {
3338 Self::StaticGray => ffi::GDK_VISUAL_STATIC_GRAY,
3339 Self::Grayscale => ffi::GDK_VISUAL_GRAYSCALE,
3340 Self::StaticColor => ffi::GDK_VISUAL_STATIC_COLOR,
3341 Self::PseudoColor => ffi::GDK_VISUAL_PSEUDO_COLOR,
3342 Self::TrueColor => ffi::GDK_VISUAL_TRUE_COLOR,
3343 Self::DirectColor => ffi::GDK_VISUAL_DIRECT_COLOR,
3344 Self::__Unknown(value) => value,
3345 }
3346 }
3347}
3348
3349#[doc(hidden)]
3350impl FromGlib<ffi::GdkVisualType> for VisualType {
3351 #[inline]
3352 unsafe fn from_glib(value: ffi::GdkVisualType) -> Self {
3353 skip_assert_initialized!();
3354
3355 match value {
3356 ffi::GDK_VISUAL_STATIC_GRAY => Self::StaticGray,
3357 ffi::GDK_VISUAL_GRAYSCALE => Self::Grayscale,
3358 ffi::GDK_VISUAL_STATIC_COLOR => Self::StaticColor,
3359 ffi::GDK_VISUAL_PSEUDO_COLOR => Self::PseudoColor,
3360 ffi::GDK_VISUAL_TRUE_COLOR => Self::TrueColor,
3361 ffi::GDK_VISUAL_DIRECT_COLOR => Self::DirectColor,
3362 value => Self::__Unknown(value),
3363 }
3364 }
3365}
3366
3367impl StaticType for VisualType {
3368 #[inline]
3369 #[doc(alias = "gdk_visual_type_get_type")]
3370 fn static_type() -> glib::Type {
3371 unsafe { from_glib(ffi::gdk_visual_type_get_type()) }
3372 }
3373}
3374
3375impl glib::HasParamSpec for VisualType {
3376 type ParamSpec = glib::ParamSpecEnum;
3377 type SetValue = Self;
3378 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3379
3380 fn param_spec_builder() -> Self::BuilderFn {
3381 Self::ParamSpec::builder_with_default
3382 }
3383}
3384
3385impl glib::value::ValueType for VisualType {
3386 type Type = Self;
3387}
3388
3389unsafe impl<'a> glib::value::FromValue<'a> for VisualType {
3390 type Checker = glib::value::GenericValueTypeChecker<Self>;
3391
3392 #[inline]
3393 unsafe fn from_value(value: &'a glib::Value) -> Self {
3394 skip_assert_initialized!();
3395 unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
3396 }
3397}
3398
3399impl ToValue for VisualType {
3400 #[inline]
3401 fn to_value(&self) -> glib::Value {
3402 let mut value = glib::Value::for_value_type::<Self>();
3403 unsafe {
3404 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3405 }
3406 value
3407 }
3408
3409 #[inline]
3410 fn value_type(&self) -> glib::Type {
3411 Self::static_type()
3412 }
3413}
3414
3415impl From<VisualType> for glib::Value {
3416 #[inline]
3417 fn from(v: VisualType) -> Self {
3418 skip_assert_initialized!();
3419 ToValue::to_value(&v)
3420 }
3421}
3422
3423#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3424#[non_exhaustive]
3425#[doc(alias = "GdkWindowEdge")]
3426pub enum WindowEdge {
3427 #[doc(alias = "GDK_WINDOW_EDGE_NORTH_WEST")]
3428 NorthWest,
3429 #[doc(alias = "GDK_WINDOW_EDGE_NORTH")]
3430 North,
3431 #[doc(alias = "GDK_WINDOW_EDGE_NORTH_EAST")]
3432 NorthEast,
3433 #[doc(alias = "GDK_WINDOW_EDGE_WEST")]
3434 West,
3435 #[doc(alias = "GDK_WINDOW_EDGE_EAST")]
3436 East,
3437 #[doc(alias = "GDK_WINDOW_EDGE_SOUTH_WEST")]
3438 SouthWest,
3439 #[doc(alias = "GDK_WINDOW_EDGE_SOUTH")]
3440 South,
3441 #[doc(alias = "GDK_WINDOW_EDGE_SOUTH_EAST")]
3442 SouthEast,
3443 #[doc(hidden)]
3444 __Unknown(i32),
3445}
3446
3447#[doc(hidden)]
3448impl IntoGlib for WindowEdge {
3449 type GlibType = ffi::GdkWindowEdge;
3450
3451 #[inline]
3452 fn into_glib(self) -> ffi::GdkWindowEdge {
3453 match self {
3454 Self::NorthWest => ffi::GDK_WINDOW_EDGE_NORTH_WEST,
3455 Self::North => ffi::GDK_WINDOW_EDGE_NORTH,
3456 Self::NorthEast => ffi::GDK_WINDOW_EDGE_NORTH_EAST,
3457 Self::West => ffi::GDK_WINDOW_EDGE_WEST,
3458 Self::East => ffi::GDK_WINDOW_EDGE_EAST,
3459 Self::SouthWest => ffi::GDK_WINDOW_EDGE_SOUTH_WEST,
3460 Self::South => ffi::GDK_WINDOW_EDGE_SOUTH,
3461 Self::SouthEast => ffi::GDK_WINDOW_EDGE_SOUTH_EAST,
3462 Self::__Unknown(value) => value,
3463 }
3464 }
3465}
3466
3467#[doc(hidden)]
3468impl FromGlib<ffi::GdkWindowEdge> for WindowEdge {
3469 #[inline]
3470 unsafe fn from_glib(value: ffi::GdkWindowEdge) -> Self {
3471 skip_assert_initialized!();
3472
3473 match value {
3474 ffi::GDK_WINDOW_EDGE_NORTH_WEST => Self::NorthWest,
3475 ffi::GDK_WINDOW_EDGE_NORTH => Self::North,
3476 ffi::GDK_WINDOW_EDGE_NORTH_EAST => Self::NorthEast,
3477 ffi::GDK_WINDOW_EDGE_WEST => Self::West,
3478 ffi::GDK_WINDOW_EDGE_EAST => Self::East,
3479 ffi::GDK_WINDOW_EDGE_SOUTH_WEST => Self::SouthWest,
3480 ffi::GDK_WINDOW_EDGE_SOUTH => Self::South,
3481 ffi::GDK_WINDOW_EDGE_SOUTH_EAST => Self::SouthEast,
3482 value => Self::__Unknown(value),
3483 }
3484 }
3485}
3486
3487impl StaticType for WindowEdge {
3488 #[inline]
3489 #[doc(alias = "gdk_window_edge_get_type")]
3490 fn static_type() -> glib::Type {
3491 unsafe { from_glib(ffi::gdk_window_edge_get_type()) }
3492 }
3493}
3494
3495impl glib::HasParamSpec for WindowEdge {
3496 type ParamSpec = glib::ParamSpecEnum;
3497 type SetValue = Self;
3498 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3499
3500 fn param_spec_builder() -> Self::BuilderFn {
3501 Self::ParamSpec::builder_with_default
3502 }
3503}
3504
3505impl glib::value::ValueType for WindowEdge {
3506 type Type = Self;
3507}
3508
3509unsafe impl<'a> glib::value::FromValue<'a> for WindowEdge {
3510 type Checker = glib::value::GenericValueTypeChecker<Self>;
3511
3512 #[inline]
3513 unsafe fn from_value(value: &'a glib::Value) -> Self {
3514 skip_assert_initialized!();
3515 unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
3516 }
3517}
3518
3519impl ToValue for WindowEdge {
3520 #[inline]
3521 fn to_value(&self) -> glib::Value {
3522 let mut value = glib::Value::for_value_type::<Self>();
3523 unsafe {
3524 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3525 }
3526 value
3527 }
3528
3529 #[inline]
3530 fn value_type(&self) -> glib::Type {
3531 Self::static_type()
3532 }
3533}
3534
3535impl From<WindowEdge> for glib::Value {
3536 #[inline]
3537 fn from(v: WindowEdge) -> Self {
3538 skip_assert_initialized!();
3539 ToValue::to_value(&v)
3540 }
3541}
3542
3543#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3544#[non_exhaustive]
3545#[doc(alias = "GdkWindowType")]
3546pub enum WindowType {
3547 #[doc(alias = "GDK_WINDOW_ROOT")]
3548 Root,
3549 #[doc(alias = "GDK_WINDOW_TOPLEVEL")]
3550 Toplevel,
3551 #[doc(alias = "GDK_WINDOW_CHILD")]
3552 Child,
3553 #[doc(alias = "GDK_WINDOW_TEMP")]
3554 Temp,
3555 #[doc(alias = "GDK_WINDOW_FOREIGN")]
3556 Foreign,
3557 #[doc(alias = "GDK_WINDOW_OFFSCREEN")]
3558 Offscreen,
3559 #[doc(alias = "GDK_WINDOW_SUBSURFACE")]
3560 Subsurface,
3561 #[doc(hidden)]
3562 __Unknown(i32),
3563}
3564
3565#[doc(hidden)]
3566impl IntoGlib for WindowType {
3567 type GlibType = ffi::GdkWindowType;
3568
3569 #[inline]
3570 fn into_glib(self) -> ffi::GdkWindowType {
3571 match self {
3572 Self::Root => ffi::GDK_WINDOW_ROOT,
3573 Self::Toplevel => ffi::GDK_WINDOW_TOPLEVEL,
3574 Self::Child => ffi::GDK_WINDOW_CHILD,
3575 Self::Temp => ffi::GDK_WINDOW_TEMP,
3576 Self::Foreign => ffi::GDK_WINDOW_FOREIGN,
3577 Self::Offscreen => ffi::GDK_WINDOW_OFFSCREEN,
3578 Self::Subsurface => ffi::GDK_WINDOW_SUBSURFACE,
3579 Self::__Unknown(value) => value,
3580 }
3581 }
3582}
3583
3584#[doc(hidden)]
3585impl FromGlib<ffi::GdkWindowType> for WindowType {
3586 #[inline]
3587 unsafe fn from_glib(value: ffi::GdkWindowType) -> Self {
3588 skip_assert_initialized!();
3589
3590 match value {
3591 ffi::GDK_WINDOW_ROOT => Self::Root,
3592 ffi::GDK_WINDOW_TOPLEVEL => Self::Toplevel,
3593 ffi::GDK_WINDOW_CHILD => Self::Child,
3594 ffi::GDK_WINDOW_TEMP => Self::Temp,
3595 ffi::GDK_WINDOW_FOREIGN => Self::Foreign,
3596 ffi::GDK_WINDOW_OFFSCREEN => Self::Offscreen,
3597 ffi::GDK_WINDOW_SUBSURFACE => Self::Subsurface,
3598 value => Self::__Unknown(value),
3599 }
3600 }
3601}
3602
3603impl StaticType for WindowType {
3604 #[inline]
3605 #[doc(alias = "gdk_window_type_get_type")]
3606 fn static_type() -> glib::Type {
3607 unsafe { from_glib(ffi::gdk_window_type_get_type()) }
3608 }
3609}
3610
3611impl glib::HasParamSpec for WindowType {
3612 type ParamSpec = glib::ParamSpecEnum;
3613 type SetValue = Self;
3614 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3615
3616 fn param_spec_builder() -> Self::BuilderFn {
3617 Self::ParamSpec::builder_with_default
3618 }
3619}
3620
3621impl glib::value::ValueType for WindowType {
3622 type Type = Self;
3623}
3624
3625unsafe impl<'a> glib::value::FromValue<'a> for WindowType {
3626 type Checker = glib::value::GenericValueTypeChecker<Self>;
3627
3628 #[inline]
3629 unsafe fn from_value(value: &'a glib::Value) -> Self {
3630 skip_assert_initialized!();
3631 unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
3632 }
3633}
3634
3635impl ToValue for WindowType {
3636 #[inline]
3637 fn to_value(&self) -> glib::Value {
3638 let mut value = glib::Value::for_value_type::<Self>();
3639 unsafe {
3640 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3641 }
3642 value
3643 }
3644
3645 #[inline]
3646 fn value_type(&self) -> glib::Type {
3647 Self::static_type()
3648 }
3649}
3650
3651impl From<WindowType> for glib::Value {
3652 #[inline]
3653 fn from(v: WindowType) -> Self {
3654 skip_assert_initialized!();
3655 ToValue::to_value(&v)
3656 }
3657}
3658
3659#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3660#[non_exhaustive]
3661#[doc(alias = "GdkWindowTypeHint")]
3662pub enum WindowTypeHint {
3663 #[doc(alias = "GDK_WINDOW_TYPE_HINT_NORMAL")]
3664 Normal,
3665 #[doc(alias = "GDK_WINDOW_TYPE_HINT_DIALOG")]
3666 Dialog,
3667 #[doc(alias = "GDK_WINDOW_TYPE_HINT_MENU")]
3668 Menu,
3669 #[doc(alias = "GDK_WINDOW_TYPE_HINT_TOOLBAR")]
3670 Toolbar,
3671 #[doc(alias = "GDK_WINDOW_TYPE_HINT_SPLASHSCREEN")]
3672 Splashscreen,
3673 #[doc(alias = "GDK_WINDOW_TYPE_HINT_UTILITY")]
3674 Utility,
3675 #[doc(alias = "GDK_WINDOW_TYPE_HINT_DOCK")]
3676 Dock,
3677 #[doc(alias = "GDK_WINDOW_TYPE_HINT_DESKTOP")]
3678 Desktop,
3679 #[doc(alias = "GDK_WINDOW_TYPE_HINT_DROPDOWN_MENU")]
3680 DropdownMenu,
3681 #[doc(alias = "GDK_WINDOW_TYPE_HINT_POPUP_MENU")]
3682 PopupMenu,
3683 #[doc(alias = "GDK_WINDOW_TYPE_HINT_TOOLTIP")]
3684 Tooltip,
3685 #[doc(alias = "GDK_WINDOW_TYPE_HINT_NOTIFICATION")]
3686 Notification,
3687 #[doc(alias = "GDK_WINDOW_TYPE_HINT_COMBO")]
3688 Combo,
3689 #[doc(alias = "GDK_WINDOW_TYPE_HINT_DND")]
3690 Dnd,
3691 #[doc(hidden)]
3692 __Unknown(i32),
3693}
3694
3695#[doc(hidden)]
3696impl IntoGlib for WindowTypeHint {
3697 type GlibType = ffi::GdkWindowTypeHint;
3698
3699 fn into_glib(self) -> ffi::GdkWindowTypeHint {
3700 match self {
3701 Self::Normal => ffi::GDK_WINDOW_TYPE_HINT_NORMAL,
3702 Self::Dialog => ffi::GDK_WINDOW_TYPE_HINT_DIALOG,
3703 Self::Menu => ffi::GDK_WINDOW_TYPE_HINT_MENU,
3704 Self::Toolbar => ffi::GDK_WINDOW_TYPE_HINT_TOOLBAR,
3705 Self::Splashscreen => ffi::GDK_WINDOW_TYPE_HINT_SPLASHSCREEN,
3706 Self::Utility => ffi::GDK_WINDOW_TYPE_HINT_UTILITY,
3707 Self::Dock => ffi::GDK_WINDOW_TYPE_HINT_DOCK,
3708 Self::Desktop => ffi::GDK_WINDOW_TYPE_HINT_DESKTOP,
3709 Self::DropdownMenu => ffi::GDK_WINDOW_TYPE_HINT_DROPDOWN_MENU,
3710 Self::PopupMenu => ffi::GDK_WINDOW_TYPE_HINT_POPUP_MENU,
3711 Self::Tooltip => ffi::GDK_WINDOW_TYPE_HINT_TOOLTIP,
3712 Self::Notification => ffi::GDK_WINDOW_TYPE_HINT_NOTIFICATION,
3713 Self::Combo => ffi::GDK_WINDOW_TYPE_HINT_COMBO,
3714 Self::Dnd => ffi::GDK_WINDOW_TYPE_HINT_DND,
3715 Self::__Unknown(value) => value,
3716 }
3717 }
3718}
3719
3720#[doc(hidden)]
3721impl FromGlib<ffi::GdkWindowTypeHint> for WindowTypeHint {
3722 unsafe fn from_glib(value: ffi::GdkWindowTypeHint) -> Self {
3723 skip_assert_initialized!();
3724
3725 match value {
3726 ffi::GDK_WINDOW_TYPE_HINT_NORMAL => Self::Normal,
3727 ffi::GDK_WINDOW_TYPE_HINT_DIALOG => Self::Dialog,
3728 ffi::GDK_WINDOW_TYPE_HINT_MENU => Self::Menu,
3729 ffi::GDK_WINDOW_TYPE_HINT_TOOLBAR => Self::Toolbar,
3730 ffi::GDK_WINDOW_TYPE_HINT_SPLASHSCREEN => Self::Splashscreen,
3731 ffi::GDK_WINDOW_TYPE_HINT_UTILITY => Self::Utility,
3732 ffi::GDK_WINDOW_TYPE_HINT_DOCK => Self::Dock,
3733 ffi::GDK_WINDOW_TYPE_HINT_DESKTOP => Self::Desktop,
3734 ffi::GDK_WINDOW_TYPE_HINT_DROPDOWN_MENU => Self::DropdownMenu,
3735 ffi::GDK_WINDOW_TYPE_HINT_POPUP_MENU => Self::PopupMenu,
3736 ffi::GDK_WINDOW_TYPE_HINT_TOOLTIP => Self::Tooltip,
3737 ffi::GDK_WINDOW_TYPE_HINT_NOTIFICATION => Self::Notification,
3738 ffi::GDK_WINDOW_TYPE_HINT_COMBO => Self::Combo,
3739 ffi::GDK_WINDOW_TYPE_HINT_DND => Self::Dnd,
3740 value => Self::__Unknown(value),
3741 }
3742 }
3743}
3744
3745impl StaticType for WindowTypeHint {
3746 #[inline]
3747 #[doc(alias = "gdk_window_type_hint_get_type")]
3748 fn static_type() -> glib::Type {
3749 unsafe { from_glib(ffi::gdk_window_type_hint_get_type()) }
3750 }
3751}
3752
3753impl glib::HasParamSpec for WindowTypeHint {
3754 type ParamSpec = glib::ParamSpecEnum;
3755 type SetValue = Self;
3756 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3757
3758 fn param_spec_builder() -> Self::BuilderFn {
3759 Self::ParamSpec::builder_with_default
3760 }
3761}
3762
3763impl glib::value::ValueType for WindowTypeHint {
3764 type Type = Self;
3765}
3766
3767unsafe impl<'a> glib::value::FromValue<'a> for WindowTypeHint {
3768 type Checker = glib::value::GenericValueTypeChecker<Self>;
3769
3770 #[inline]
3771 unsafe fn from_value(value: &'a glib::Value) -> Self {
3772 skip_assert_initialized!();
3773 unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
3774 }
3775}
3776
3777impl ToValue for WindowTypeHint {
3778 #[inline]
3779 fn to_value(&self) -> glib::Value {
3780 let mut value = glib::Value::for_value_type::<Self>();
3781 unsafe {
3782 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3783 }
3784 value
3785 }
3786
3787 #[inline]
3788 fn value_type(&self) -> glib::Type {
3789 Self::static_type()
3790 }
3791}
3792
3793impl From<WindowTypeHint> for glib::Value {
3794 #[inline]
3795 fn from(v: WindowTypeHint) -> Self {
3796 skip_assert_initialized!();
3797 ToValue::to_value(&v)
3798 }
3799}
3800
3801#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3802#[non_exhaustive]
3803#[doc(alias = "GdkWindowWindowClass")]
3804pub enum WindowWindowClass {
3805 #[doc(alias = "GDK_INPUT_OUTPUT")]
3806 InputOutput,
3807 #[doc(alias = "GDK_INPUT_ONLY")]
3808 InputOnly,
3809 #[doc(hidden)]
3810 __Unknown(i32),
3811}
3812
3813#[doc(hidden)]
3814impl IntoGlib for WindowWindowClass {
3815 type GlibType = ffi::GdkWindowWindowClass;
3816
3817 #[inline]
3818 fn into_glib(self) -> ffi::GdkWindowWindowClass {
3819 match self {
3820 Self::InputOutput => ffi::GDK_INPUT_OUTPUT,
3821 Self::InputOnly => ffi::GDK_INPUT_ONLY,
3822 Self::__Unknown(value) => value,
3823 }
3824 }
3825}
3826
3827#[doc(hidden)]
3828impl FromGlib<ffi::GdkWindowWindowClass> for WindowWindowClass {
3829 #[inline]
3830 unsafe fn from_glib(value: ffi::GdkWindowWindowClass) -> Self {
3831 skip_assert_initialized!();
3832
3833 match value {
3834 ffi::GDK_INPUT_OUTPUT => Self::InputOutput,
3835 ffi::GDK_INPUT_ONLY => Self::InputOnly,
3836 value => Self::__Unknown(value),
3837 }
3838 }
3839}
3840
3841impl StaticType for WindowWindowClass {
3842 #[inline]
3843 #[doc(alias = "gdk_window_window_class_get_type")]
3844 fn static_type() -> glib::Type {
3845 unsafe { from_glib(ffi::gdk_window_window_class_get_type()) }
3846 }
3847}
3848
3849impl glib::HasParamSpec for WindowWindowClass {
3850 type ParamSpec = glib::ParamSpecEnum;
3851 type SetValue = Self;
3852 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3853
3854 fn param_spec_builder() -> Self::BuilderFn {
3855 Self::ParamSpec::builder_with_default
3856 }
3857}
3858
3859impl glib::value::ValueType for WindowWindowClass {
3860 type Type = Self;
3861}
3862
3863unsafe impl<'a> glib::value::FromValue<'a> for WindowWindowClass {
3864 type Checker = glib::value::GenericValueTypeChecker<Self>;
3865
3866 #[inline]
3867 unsafe fn from_value(value: &'a glib::Value) -> Self {
3868 skip_assert_initialized!();
3869 unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
3870 }
3871}
3872
3873impl ToValue for WindowWindowClass {
3874 #[inline]
3875 fn to_value(&self) -> glib::Value {
3876 let mut value = glib::Value::for_value_type::<Self>();
3877 unsafe {
3878 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3879 }
3880 value
3881 }
3882
3883 #[inline]
3884 fn value_type(&self) -> glib::Type {
3885 Self::static_type()
3886 }
3887}
3888
3889impl From<WindowWindowClass> for glib::Value {
3890 #[inline]
3891 fn from(v: WindowWindowClass) -> Self {
3892 skip_assert_initialized!();
3893 ToValue::to_value(&v)
3894 }
3895}