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