1use glib::{bitflags::bitflags, prelude::*, translate::*};
6use std::fmt;
7
8bitflags! {
9 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
10 #[doc(alias = "GdkAnchorHints")]
11 pub struct AnchorHints: u32 {
12 #[doc(alias = "GDK_ANCHOR_FLIP_X")]
13 const FLIP_X = ffi::GDK_ANCHOR_FLIP_X as _;
14 #[doc(alias = "GDK_ANCHOR_FLIP_Y")]
15 const FLIP_Y = ffi::GDK_ANCHOR_FLIP_Y as _;
16 #[doc(alias = "GDK_ANCHOR_SLIDE_X")]
17 const SLIDE_X = ffi::GDK_ANCHOR_SLIDE_X as _;
18 #[doc(alias = "GDK_ANCHOR_SLIDE_Y")]
19 const SLIDE_Y = ffi::GDK_ANCHOR_SLIDE_Y as _;
20 #[doc(alias = "GDK_ANCHOR_RESIZE_X")]
21 const RESIZE_X = ffi::GDK_ANCHOR_RESIZE_X as _;
22 #[doc(alias = "GDK_ANCHOR_RESIZE_Y")]
23 const RESIZE_Y = ffi::GDK_ANCHOR_RESIZE_Y as _;
24 #[doc(alias = "GDK_ANCHOR_FLIP")]
25 const FLIP = ffi::GDK_ANCHOR_FLIP as _;
26 #[doc(alias = "GDK_ANCHOR_SLIDE")]
27 const SLIDE = ffi::GDK_ANCHOR_SLIDE as _;
28 #[doc(alias = "GDK_ANCHOR_RESIZE")]
29 const RESIZE = ffi::GDK_ANCHOR_RESIZE as _;
30 }
31}
32
33impl fmt::Display for AnchorHints {
34 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
35 <Self as fmt::Debug>::fmt(self, f)
36 }
37}
38
39#[doc(hidden)]
40impl IntoGlib for AnchorHints {
41 type GlibType = ffi::GdkAnchorHints;
42
43 #[inline]
44 fn into_glib(self) -> ffi::GdkAnchorHints {
45 self.bits()
46 }
47}
48
49#[doc(hidden)]
50impl FromGlib<ffi::GdkAnchorHints> for AnchorHints {
51 #[inline]
52 unsafe fn from_glib(value: ffi::GdkAnchorHints) -> Self {
53 skip_assert_initialized!();
54 Self::from_bits_truncate(value)
55 }
56}
57
58impl StaticType for AnchorHints {
59 #[inline]
60 fn static_type() -> glib::Type {
61 unsafe { from_glib(ffi::gdk_anchor_hints_get_type()) }
62 }
63}
64
65impl glib::HasParamSpec for AnchorHints {
66 type ParamSpec = glib::ParamSpecFlags;
67 type SetValue = Self;
68 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
69
70 fn param_spec_builder() -> Self::BuilderFn {
71 |name| Self::ParamSpec::builder(name)
72 }
73}
74
75impl glib::value::ValueType for AnchorHints {
76 type Type = Self;
77}
78
79unsafe impl<'a> glib::value::FromValue<'a> for AnchorHints {
80 type Checker = glib::value::GenericValueTypeChecker<Self>;
81
82 #[inline]
83 unsafe fn from_value(value: &'a glib::Value) -> Self {
84 skip_assert_initialized!();
85 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
86 }
87}
88
89impl ToValue for AnchorHints {
90 #[inline]
91 fn to_value(&self) -> glib::Value {
92 let mut value = glib::Value::for_value_type::<Self>();
93 unsafe {
94 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
95 }
96 value
97 }
98
99 #[inline]
100 fn value_type(&self) -> glib::Type {
101 Self::static_type()
102 }
103}
104
105impl From<AnchorHints> for glib::Value {
106 #[inline]
107 fn from(v: AnchorHints) -> Self {
108 skip_assert_initialized!();
109 ToValue::to_value(&v)
110 }
111}
112
113bitflags! {
114 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
115 #[doc(alias = "GdkAxisFlags")]
116 pub struct AxisFlags: u32 {
117 #[doc(alias = "GDK_AXIS_FLAG_X")]
118 const X = ffi::GDK_AXIS_FLAG_X as _;
119 #[doc(alias = "GDK_AXIS_FLAG_Y")]
120 const Y = ffi::GDK_AXIS_FLAG_Y as _;
121 #[doc(alias = "GDK_AXIS_FLAG_PRESSURE")]
122 const PRESSURE = ffi::GDK_AXIS_FLAG_PRESSURE as _;
123 #[doc(alias = "GDK_AXIS_FLAG_XTILT")]
124 const XTILT = ffi::GDK_AXIS_FLAG_XTILT as _;
125 #[doc(alias = "GDK_AXIS_FLAG_YTILT")]
126 const YTILT = ffi::GDK_AXIS_FLAG_YTILT as _;
127 #[doc(alias = "GDK_AXIS_FLAG_WHEEL")]
128 const WHEEL = ffi::GDK_AXIS_FLAG_WHEEL as _;
129 #[doc(alias = "GDK_AXIS_FLAG_DISTANCE")]
130 const DISTANCE = ffi::GDK_AXIS_FLAG_DISTANCE as _;
131 #[doc(alias = "GDK_AXIS_FLAG_ROTATION")]
132 const ROTATION = ffi::GDK_AXIS_FLAG_ROTATION as _;
133 #[doc(alias = "GDK_AXIS_FLAG_SLIDER")]
134 const SLIDER = ffi::GDK_AXIS_FLAG_SLIDER as _;
135 }
136}
137
138impl fmt::Display for AxisFlags {
139 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
140 <Self as fmt::Debug>::fmt(self, f)
141 }
142}
143
144#[doc(hidden)]
145impl IntoGlib for AxisFlags {
146 type GlibType = ffi::GdkAxisFlags;
147
148 #[inline]
149 fn into_glib(self) -> ffi::GdkAxisFlags {
150 self.bits()
151 }
152}
153
154#[doc(hidden)]
155impl FromGlib<ffi::GdkAxisFlags> for AxisFlags {
156 #[inline]
157 unsafe fn from_glib(value: ffi::GdkAxisFlags) -> Self {
158 skip_assert_initialized!();
159 Self::from_bits_truncate(value)
160 }
161}
162
163impl StaticType for AxisFlags {
164 #[inline]
165 fn static_type() -> glib::Type {
166 unsafe { from_glib(ffi::gdk_axis_flags_get_type()) }
167 }
168}
169
170impl glib::HasParamSpec for AxisFlags {
171 type ParamSpec = glib::ParamSpecFlags;
172 type SetValue = Self;
173 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
174
175 fn param_spec_builder() -> Self::BuilderFn {
176 |name| Self::ParamSpec::builder(name)
177 }
178}
179
180impl glib::value::ValueType for AxisFlags {
181 type Type = Self;
182}
183
184unsafe impl<'a> glib::value::FromValue<'a> for AxisFlags {
185 type Checker = glib::value::GenericValueTypeChecker<Self>;
186
187 #[inline]
188 unsafe fn from_value(value: &'a glib::Value) -> Self {
189 skip_assert_initialized!();
190 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
191 }
192}
193
194impl ToValue for AxisFlags {
195 #[inline]
196 fn to_value(&self) -> glib::Value {
197 let mut value = glib::Value::for_value_type::<Self>();
198 unsafe {
199 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
200 }
201 value
202 }
203
204 #[inline]
205 fn value_type(&self) -> glib::Type {
206 Self::static_type()
207 }
208}
209
210impl From<AxisFlags> for glib::Value {
211 #[inline]
212 fn from(v: AxisFlags) -> Self {
213 skip_assert_initialized!();
214 ToValue::to_value(&v)
215 }
216}
217
218bitflags! {
219 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
220 #[doc(alias = "GdkDragAction")]
221 pub struct DragAction: u32 {
222 #[doc(alias = "GDK_ACTION_DEFAULT")]
223 const DEFAULT = ffi::GDK_ACTION_DEFAULT as _;
224 #[doc(alias = "GDK_ACTION_COPY")]
225 const COPY = ffi::GDK_ACTION_COPY as _;
226 #[doc(alias = "GDK_ACTION_MOVE")]
227 const MOVE = ffi::GDK_ACTION_MOVE as _;
228 #[doc(alias = "GDK_ACTION_LINK")]
229 const LINK = ffi::GDK_ACTION_LINK as _;
230 #[doc(alias = "GDK_ACTION_PRIVATE")]
231 const PRIVATE = ffi::GDK_ACTION_PRIVATE as _;
232 #[doc(alias = "GDK_ACTION_ASK")]
233 const ASK = ffi::GDK_ACTION_ASK as _;
234 }
235}
236
237impl fmt::Display for DragAction {
238 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
239 <Self as fmt::Debug>::fmt(self, f)
240 }
241}
242
243#[doc(hidden)]
244impl IntoGlib for DragAction {
245 type GlibType = ffi::GdkDragAction;
246
247 #[inline]
248 fn into_glib(self) -> ffi::GdkDragAction {
249 self.bits()
250 }
251}
252
253#[doc(hidden)]
254impl FromGlib<ffi::GdkDragAction> for DragAction {
255 #[inline]
256 unsafe fn from_glib(value: ffi::GdkDragAction) -> Self {
257 skip_assert_initialized!();
258 Self::from_bits_truncate(value)
259 }
260}
261
262impl StaticType for DragAction {
263 #[inline]
264 fn static_type() -> glib::Type {
265 unsafe { from_glib(ffi::gdk_drag_action_get_type()) }
266 }
267}
268
269impl glib::HasParamSpec for DragAction {
270 type ParamSpec = glib::ParamSpecFlags;
271 type SetValue = Self;
272 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
273
274 fn param_spec_builder() -> Self::BuilderFn {
275 |name| Self::ParamSpec::builder(name)
276 }
277}
278
279impl glib::value::ValueType for DragAction {
280 type Type = Self;
281}
282
283unsafe impl<'a> glib::value::FromValue<'a> for DragAction {
284 type Checker = glib::value::GenericValueTypeChecker<Self>;
285
286 #[inline]
287 unsafe fn from_value(value: &'a glib::Value) -> Self {
288 skip_assert_initialized!();
289 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
290 }
291}
292
293impl ToValue for DragAction {
294 #[inline]
295 fn to_value(&self) -> glib::Value {
296 let mut value = glib::Value::for_value_type::<Self>();
297 unsafe {
298 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
299 }
300 value
301 }
302
303 #[inline]
304 fn value_type(&self) -> glib::Type {
305 Self::static_type()
306 }
307}
308
309impl From<DragAction> for glib::Value {
310 #[inline]
311 fn from(v: DragAction) -> Self {
312 skip_assert_initialized!();
313 ToValue::to_value(&v)
314 }
315}
316
317bitflags! {
318 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
319 #[doc(alias = "GdkEventMask")]
320 pub struct EventMask: u32 {
321 #[doc(alias = "GDK_EXPOSURE_MASK")]
322 const EXPOSURE_MASK = ffi::GDK_EXPOSURE_MASK as _;
323 #[doc(alias = "GDK_POINTER_MOTION_MASK")]
324 const POINTER_MOTION_MASK = ffi::GDK_POINTER_MOTION_MASK as _;
325 #[doc(alias = "GDK_POINTER_MOTION_HINT_MASK")]
326 const POINTER_MOTION_HINT_MASK = ffi::GDK_POINTER_MOTION_HINT_MASK as _;
327 #[doc(alias = "GDK_BUTTON_MOTION_MASK")]
328 const BUTTON_MOTION_MASK = ffi::GDK_BUTTON_MOTION_MASK as _;
329 #[doc(alias = "GDK_BUTTON1_MOTION_MASK")]
330 const BUTTON1_MOTION_MASK = ffi::GDK_BUTTON1_MOTION_MASK as _;
331 #[doc(alias = "GDK_BUTTON2_MOTION_MASK")]
332 const BUTTON2_MOTION_MASK = ffi::GDK_BUTTON2_MOTION_MASK as _;
333 #[doc(alias = "GDK_BUTTON3_MOTION_MASK")]
334 const BUTTON3_MOTION_MASK = ffi::GDK_BUTTON3_MOTION_MASK as _;
335 #[doc(alias = "GDK_BUTTON_PRESS_MASK")]
336 const BUTTON_PRESS_MASK = ffi::GDK_BUTTON_PRESS_MASK as _;
337 #[doc(alias = "GDK_BUTTON_RELEASE_MASK")]
338 const BUTTON_RELEASE_MASK = ffi::GDK_BUTTON_RELEASE_MASK as _;
339 #[doc(alias = "GDK_KEY_PRESS_MASK")]
340 const KEY_PRESS_MASK = ffi::GDK_KEY_PRESS_MASK as _;
341 #[doc(alias = "GDK_KEY_RELEASE_MASK")]
342 const KEY_RELEASE_MASK = ffi::GDK_KEY_RELEASE_MASK as _;
343 #[doc(alias = "GDK_ENTER_NOTIFY_MASK")]
344 const ENTER_NOTIFY_MASK = ffi::GDK_ENTER_NOTIFY_MASK as _;
345 #[doc(alias = "GDK_LEAVE_NOTIFY_MASK")]
346 const LEAVE_NOTIFY_MASK = ffi::GDK_LEAVE_NOTIFY_MASK as _;
347 #[doc(alias = "GDK_FOCUS_CHANGE_MASK")]
348 const FOCUS_CHANGE_MASK = ffi::GDK_FOCUS_CHANGE_MASK as _;
349 #[doc(alias = "GDK_STRUCTURE_MASK")]
350 const STRUCTURE_MASK = ffi::GDK_STRUCTURE_MASK as _;
351 #[doc(alias = "GDK_PROPERTY_CHANGE_MASK")]
352 const PROPERTY_CHANGE_MASK = ffi::GDK_PROPERTY_CHANGE_MASK as _;
353 #[doc(alias = "GDK_VISIBILITY_NOTIFY_MASK")]
354 const VISIBILITY_NOTIFY_MASK = ffi::GDK_VISIBILITY_NOTIFY_MASK as _;
355 #[doc(alias = "GDK_PROXIMITY_IN_MASK")]
356 const PROXIMITY_IN_MASK = ffi::GDK_PROXIMITY_IN_MASK as _;
357 #[doc(alias = "GDK_PROXIMITY_OUT_MASK")]
358 const PROXIMITY_OUT_MASK = ffi::GDK_PROXIMITY_OUT_MASK as _;
359 #[doc(alias = "GDK_SUBSTRUCTURE_MASK")]
360 const SUBSTRUCTURE_MASK = ffi::GDK_SUBSTRUCTURE_MASK as _;
361 #[doc(alias = "GDK_SCROLL_MASK")]
362 const SCROLL_MASK = ffi::GDK_SCROLL_MASK as _;
363 #[doc(alias = "GDK_TOUCH_MASK")]
364 const TOUCH_MASK = ffi::GDK_TOUCH_MASK as _;
365 #[doc(alias = "GDK_SMOOTH_SCROLL_MASK")]
366 const SMOOTH_SCROLL_MASK = ffi::GDK_SMOOTH_SCROLL_MASK as _;
367 #[doc(alias = "GDK_TOUCHPAD_GESTURE_MASK")]
368 const TOUCHPAD_GESTURE_MASK = ffi::GDK_TOUCHPAD_GESTURE_MASK as _;
369 #[doc(alias = "GDK_TABLET_PAD_MASK")]
370 const TABLET_PAD_MASK = ffi::GDK_TABLET_PAD_MASK as _;
371 #[doc(alias = "GDK_ALL_EVENTS_MASK")]
372 const ALL_EVENTS_MASK = ffi::GDK_ALL_EVENTS_MASK as _;
373 }
374}
375
376impl fmt::Display for EventMask {
377 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
378 <Self as fmt::Debug>::fmt(self, f)
379 }
380}
381
382#[doc(hidden)]
383impl IntoGlib for EventMask {
384 type GlibType = ffi::GdkEventMask;
385
386 #[inline]
387 fn into_glib(self) -> ffi::GdkEventMask {
388 self.bits()
389 }
390}
391
392#[doc(hidden)]
393impl FromGlib<ffi::GdkEventMask> for EventMask {
394 #[inline]
395 unsafe fn from_glib(value: ffi::GdkEventMask) -> Self {
396 skip_assert_initialized!();
397 Self::from_bits_truncate(value)
398 }
399}
400
401impl StaticType for EventMask {
402 #[inline]
403 fn static_type() -> glib::Type {
404 unsafe { from_glib(ffi::gdk_event_mask_get_type()) }
405 }
406}
407
408impl glib::HasParamSpec for EventMask {
409 type ParamSpec = glib::ParamSpecFlags;
410 type SetValue = Self;
411 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
412
413 fn param_spec_builder() -> Self::BuilderFn {
414 |name| Self::ParamSpec::builder(name)
415 }
416}
417
418impl glib::value::ValueType for EventMask {
419 type Type = Self;
420}
421
422unsafe impl<'a> glib::value::FromValue<'a> for EventMask {
423 type Checker = glib::value::GenericValueTypeChecker<Self>;
424
425 #[inline]
426 unsafe fn from_value(value: &'a glib::Value) -> Self {
427 skip_assert_initialized!();
428 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
429 }
430}
431
432impl ToValue for EventMask {
433 #[inline]
434 fn to_value(&self) -> glib::Value {
435 let mut value = glib::Value::for_value_type::<Self>();
436 unsafe {
437 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
438 }
439 value
440 }
441
442 #[inline]
443 fn value_type(&self) -> glib::Type {
444 Self::static_type()
445 }
446}
447
448impl From<EventMask> for glib::Value {
449 #[inline]
450 fn from(v: EventMask) -> Self {
451 skip_assert_initialized!();
452 ToValue::to_value(&v)
453 }
454}
455
456bitflags! {
457 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
458 #[doc(alias = "GdkFrameClockPhase")]
459 pub struct FrameClockPhase: u32 {
460 #[doc(alias = "GDK_FRAME_CLOCK_PHASE_NONE")]
461 const NONE = ffi::GDK_FRAME_CLOCK_PHASE_NONE as _;
462 #[doc(alias = "GDK_FRAME_CLOCK_PHASE_FLUSH_EVENTS")]
463 const FLUSH_EVENTS = ffi::GDK_FRAME_CLOCK_PHASE_FLUSH_EVENTS as _;
464 #[doc(alias = "GDK_FRAME_CLOCK_PHASE_BEFORE_PAINT")]
465 const BEFORE_PAINT = ffi::GDK_FRAME_CLOCK_PHASE_BEFORE_PAINT as _;
466 #[doc(alias = "GDK_FRAME_CLOCK_PHASE_UPDATE")]
467 const UPDATE = ffi::GDK_FRAME_CLOCK_PHASE_UPDATE as _;
468 #[doc(alias = "GDK_FRAME_CLOCK_PHASE_LAYOUT")]
469 const LAYOUT = ffi::GDK_FRAME_CLOCK_PHASE_LAYOUT as _;
470 #[doc(alias = "GDK_FRAME_CLOCK_PHASE_PAINT")]
471 const PAINT = ffi::GDK_FRAME_CLOCK_PHASE_PAINT as _;
472 #[doc(alias = "GDK_FRAME_CLOCK_PHASE_RESUME_EVENTS")]
473 const RESUME_EVENTS = ffi::GDK_FRAME_CLOCK_PHASE_RESUME_EVENTS as _;
474 #[doc(alias = "GDK_FRAME_CLOCK_PHASE_AFTER_PAINT")]
475 const AFTER_PAINT = ffi::GDK_FRAME_CLOCK_PHASE_AFTER_PAINT as _;
476 }
477}
478
479impl fmt::Display for FrameClockPhase {
480 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
481 <Self as fmt::Debug>::fmt(self, f)
482 }
483}
484
485#[doc(hidden)]
486impl IntoGlib for FrameClockPhase {
487 type GlibType = ffi::GdkFrameClockPhase;
488
489 #[inline]
490 fn into_glib(self) -> ffi::GdkFrameClockPhase {
491 self.bits()
492 }
493}
494
495#[doc(hidden)]
496impl FromGlib<ffi::GdkFrameClockPhase> for FrameClockPhase {
497 #[inline]
498 unsafe fn from_glib(value: ffi::GdkFrameClockPhase) -> Self {
499 skip_assert_initialized!();
500 Self::from_bits_truncate(value)
501 }
502}
503
504impl StaticType for FrameClockPhase {
505 #[inline]
506 fn static_type() -> glib::Type {
507 unsafe { from_glib(ffi::gdk_frame_clock_phase_get_type()) }
508 }
509}
510
511impl glib::HasParamSpec for FrameClockPhase {
512 type ParamSpec = glib::ParamSpecFlags;
513 type SetValue = Self;
514 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
515
516 fn param_spec_builder() -> Self::BuilderFn {
517 |name| Self::ParamSpec::builder(name)
518 }
519}
520
521impl glib::value::ValueType for FrameClockPhase {
522 type Type = Self;
523}
524
525unsafe impl<'a> glib::value::FromValue<'a> for FrameClockPhase {
526 type Checker = glib::value::GenericValueTypeChecker<Self>;
527
528 #[inline]
529 unsafe fn from_value(value: &'a glib::Value) -> Self {
530 skip_assert_initialized!();
531 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
532 }
533}
534
535impl ToValue for FrameClockPhase {
536 #[inline]
537 fn to_value(&self) -> glib::Value {
538 let mut value = glib::Value::for_value_type::<Self>();
539 unsafe {
540 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
541 }
542 value
543 }
544
545 #[inline]
546 fn value_type(&self) -> glib::Type {
547 Self::static_type()
548 }
549}
550
551impl From<FrameClockPhase> for glib::Value {
552 #[inline]
553 fn from(v: FrameClockPhase) -> Self {
554 skip_assert_initialized!();
555 ToValue::to_value(&v)
556 }
557}
558
559bitflags! {
560 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
561 #[doc(alias = "GdkModifierType")]
562 pub struct ModifierType: u32 {
563 #[doc(alias = "GDK_SHIFT_MASK")]
564 const SHIFT_MASK = ffi::GDK_SHIFT_MASK as _;
565 #[doc(alias = "GDK_LOCK_MASK")]
566 const LOCK_MASK = ffi::GDK_LOCK_MASK as _;
567 #[doc(alias = "GDK_CONTROL_MASK")]
568 const CONTROL_MASK = ffi::GDK_CONTROL_MASK as _;
569 #[doc(alias = "GDK_MOD1_MASK")]
570 const MOD1_MASK = ffi::GDK_MOD1_MASK as _;
571 #[doc(alias = "GDK_MOD2_MASK")]
572 const MOD2_MASK = ffi::GDK_MOD2_MASK as _;
573 #[doc(alias = "GDK_MOD3_MASK")]
574 const MOD3_MASK = ffi::GDK_MOD3_MASK as _;
575 #[doc(alias = "GDK_MOD4_MASK")]
576 const MOD4_MASK = ffi::GDK_MOD4_MASK as _;
577 #[doc(alias = "GDK_MOD5_MASK")]
578 const MOD5_MASK = ffi::GDK_MOD5_MASK as _;
579 #[doc(alias = "GDK_BUTTON1_MASK")]
580 const BUTTON1_MASK = ffi::GDK_BUTTON1_MASK as _;
581 #[doc(alias = "GDK_BUTTON2_MASK")]
582 const BUTTON2_MASK = ffi::GDK_BUTTON2_MASK as _;
583 #[doc(alias = "GDK_BUTTON3_MASK")]
584 const BUTTON3_MASK = ffi::GDK_BUTTON3_MASK as _;
585 #[doc(alias = "GDK_BUTTON4_MASK")]
586 const BUTTON4_MASK = ffi::GDK_BUTTON4_MASK as _;
587 #[doc(alias = "GDK_BUTTON5_MASK")]
588 const BUTTON5_MASK = ffi::GDK_BUTTON5_MASK as _;
589 #[doc(alias = "GDK_MODIFIER_RESERVED_13_MASK")]
590 const MODIFIER_RESERVED_13_MASK = ffi::GDK_MODIFIER_RESERVED_13_MASK as _;
591 #[doc(alias = "GDK_MODIFIER_RESERVED_14_MASK")]
592 const MODIFIER_RESERVED_14_MASK = ffi::GDK_MODIFIER_RESERVED_14_MASK as _;
593 #[doc(alias = "GDK_MODIFIER_RESERVED_15_MASK")]
594 const MODIFIER_RESERVED_15_MASK = ffi::GDK_MODIFIER_RESERVED_15_MASK as _;
595 #[doc(alias = "GDK_MODIFIER_RESERVED_16_MASK")]
596 const MODIFIER_RESERVED_16_MASK = ffi::GDK_MODIFIER_RESERVED_16_MASK as _;
597 #[doc(alias = "GDK_MODIFIER_RESERVED_17_MASK")]
598 const MODIFIER_RESERVED_17_MASK = ffi::GDK_MODIFIER_RESERVED_17_MASK as _;
599 #[doc(alias = "GDK_MODIFIER_RESERVED_18_MASK")]
600 const MODIFIER_RESERVED_18_MASK = ffi::GDK_MODIFIER_RESERVED_18_MASK as _;
601 #[doc(alias = "GDK_MODIFIER_RESERVED_19_MASK")]
602 const MODIFIER_RESERVED_19_MASK = ffi::GDK_MODIFIER_RESERVED_19_MASK as _;
603 #[doc(alias = "GDK_MODIFIER_RESERVED_20_MASK")]
604 const MODIFIER_RESERVED_20_MASK = ffi::GDK_MODIFIER_RESERVED_20_MASK as _;
605 #[doc(alias = "GDK_MODIFIER_RESERVED_21_MASK")]
606 const MODIFIER_RESERVED_21_MASK = ffi::GDK_MODIFIER_RESERVED_21_MASK as _;
607 #[doc(alias = "GDK_MODIFIER_RESERVED_22_MASK")]
608 const MODIFIER_RESERVED_22_MASK = ffi::GDK_MODIFIER_RESERVED_22_MASK as _;
609 #[doc(alias = "GDK_MODIFIER_RESERVED_23_MASK")]
610 const MODIFIER_RESERVED_23_MASK = ffi::GDK_MODIFIER_RESERVED_23_MASK as _;
611 #[doc(alias = "GDK_MODIFIER_RESERVED_24_MASK")]
612 const MODIFIER_RESERVED_24_MASK = ffi::GDK_MODIFIER_RESERVED_24_MASK as _;
613 #[doc(alias = "GDK_MODIFIER_RESERVED_25_MASK")]
614 const MODIFIER_RESERVED_25_MASK = ffi::GDK_MODIFIER_RESERVED_25_MASK as _;
615 #[doc(alias = "GDK_SUPER_MASK")]
616 const SUPER_MASK = ffi::GDK_SUPER_MASK as _;
617 #[doc(alias = "GDK_HYPER_MASK")]
618 const HYPER_MASK = ffi::GDK_HYPER_MASK as _;
619 #[doc(alias = "GDK_META_MASK")]
620 const META_MASK = ffi::GDK_META_MASK as _;
621 #[doc(alias = "GDK_MODIFIER_RESERVED_29_MASK")]
622 const MODIFIER_RESERVED_29_MASK = ffi::GDK_MODIFIER_RESERVED_29_MASK as _;
623 #[doc(alias = "GDK_RELEASE_MASK")]
624 const RELEASE_MASK = ffi::GDK_RELEASE_MASK as _;
625 #[doc(alias = "GDK_MODIFIER_MASK")]
626 const MODIFIER_MASK = ffi::GDK_MODIFIER_MASK as _;
627 }
628}
629
630impl fmt::Display for ModifierType {
631 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
632 <Self as fmt::Debug>::fmt(self, f)
633 }
634}
635
636#[doc(hidden)]
637impl IntoGlib for ModifierType {
638 type GlibType = ffi::GdkModifierType;
639
640 #[inline]
641 fn into_glib(self) -> ffi::GdkModifierType {
642 self.bits()
643 }
644}
645
646#[doc(hidden)]
647impl FromGlib<ffi::GdkModifierType> for ModifierType {
648 #[inline]
649 unsafe fn from_glib(value: ffi::GdkModifierType) -> Self {
650 skip_assert_initialized!();
651 Self::from_bits_truncate(value)
652 }
653}
654
655impl StaticType for ModifierType {
656 #[inline]
657 fn static_type() -> glib::Type {
658 unsafe { from_glib(ffi::gdk_modifier_type_get_type()) }
659 }
660}
661
662impl glib::HasParamSpec for ModifierType {
663 type ParamSpec = glib::ParamSpecFlags;
664 type SetValue = Self;
665 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
666
667 fn param_spec_builder() -> Self::BuilderFn {
668 |name| Self::ParamSpec::builder(name)
669 }
670}
671
672impl glib::value::ValueType for ModifierType {
673 type Type = Self;
674}
675
676unsafe impl<'a> glib::value::FromValue<'a> for ModifierType {
677 type Checker = glib::value::GenericValueTypeChecker<Self>;
678
679 #[inline]
680 unsafe fn from_value(value: &'a glib::Value) -> Self {
681 skip_assert_initialized!();
682 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
683 }
684}
685
686impl ToValue for ModifierType {
687 #[inline]
688 fn to_value(&self) -> glib::Value {
689 let mut value = glib::Value::for_value_type::<Self>();
690 unsafe {
691 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
692 }
693 value
694 }
695
696 #[inline]
697 fn value_type(&self) -> glib::Type {
698 Self::static_type()
699 }
700}
701
702impl From<ModifierType> for glib::Value {
703 #[inline]
704 fn from(v: ModifierType) -> Self {
705 skip_assert_initialized!();
706 ToValue::to_value(&v)
707 }
708}
709
710bitflags! {
711 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
712 #[doc(alias = "GdkSeatCapabilities")]
713 pub struct SeatCapabilities: u32 {
714 #[doc(alias = "GDK_SEAT_CAPABILITY_NONE")]
715 const NONE = ffi::GDK_SEAT_CAPABILITY_NONE as _;
716 #[doc(alias = "GDK_SEAT_CAPABILITY_POINTER")]
717 const POINTER = ffi::GDK_SEAT_CAPABILITY_POINTER as _;
718 #[doc(alias = "GDK_SEAT_CAPABILITY_TOUCH")]
719 const TOUCH = ffi::GDK_SEAT_CAPABILITY_TOUCH as _;
720 #[doc(alias = "GDK_SEAT_CAPABILITY_TABLET_STYLUS")]
721 const TABLET_STYLUS = ffi::GDK_SEAT_CAPABILITY_TABLET_STYLUS as _;
722 #[doc(alias = "GDK_SEAT_CAPABILITY_KEYBOARD")]
723 const KEYBOARD = ffi::GDK_SEAT_CAPABILITY_KEYBOARD as _;
724 #[doc(alias = "GDK_SEAT_CAPABILITY_ALL_POINTING")]
725 const ALL_POINTING = ffi::GDK_SEAT_CAPABILITY_ALL_POINTING as _;
726 #[doc(alias = "GDK_SEAT_CAPABILITY_ALL")]
727 const ALL = ffi::GDK_SEAT_CAPABILITY_ALL as _;
728 }
729}
730
731impl fmt::Display for SeatCapabilities {
732 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
733 <Self as fmt::Debug>::fmt(self, f)
734 }
735}
736
737#[doc(hidden)]
738impl IntoGlib for SeatCapabilities {
739 type GlibType = ffi::GdkSeatCapabilities;
740
741 #[inline]
742 fn into_glib(self) -> ffi::GdkSeatCapabilities {
743 self.bits()
744 }
745}
746
747#[doc(hidden)]
748impl FromGlib<ffi::GdkSeatCapabilities> for SeatCapabilities {
749 #[inline]
750 unsafe fn from_glib(value: ffi::GdkSeatCapabilities) -> Self {
751 skip_assert_initialized!();
752 Self::from_bits_truncate(value)
753 }
754}
755
756impl StaticType for SeatCapabilities {
757 #[inline]
758 fn static_type() -> glib::Type {
759 unsafe { from_glib(ffi::gdk_seat_capabilities_get_type()) }
760 }
761}
762
763impl glib::HasParamSpec for SeatCapabilities {
764 type ParamSpec = glib::ParamSpecFlags;
765 type SetValue = Self;
766 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
767
768 fn param_spec_builder() -> Self::BuilderFn {
769 |name| Self::ParamSpec::builder(name)
770 }
771}
772
773impl glib::value::ValueType for SeatCapabilities {
774 type Type = Self;
775}
776
777unsafe impl<'a> glib::value::FromValue<'a> for SeatCapabilities {
778 type Checker = glib::value::GenericValueTypeChecker<Self>;
779
780 #[inline]
781 unsafe fn from_value(value: &'a glib::Value) -> Self {
782 skip_assert_initialized!();
783 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
784 }
785}
786
787impl ToValue for SeatCapabilities {
788 #[inline]
789 fn to_value(&self) -> glib::Value {
790 let mut value = glib::Value::for_value_type::<Self>();
791 unsafe {
792 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
793 }
794 value
795 }
796
797 #[inline]
798 fn value_type(&self) -> glib::Type {
799 Self::static_type()
800 }
801}
802
803impl From<SeatCapabilities> for glib::Value {
804 #[inline]
805 fn from(v: SeatCapabilities) -> Self {
806 skip_assert_initialized!();
807 ToValue::to_value(&v)
808 }
809}
810
811bitflags! {
812 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
813 #[doc(alias = "GdkWMDecoration")]
814 pub struct WMDecoration: u32 {
815 #[doc(alias = "GDK_DECOR_ALL")]
816 const ALL = ffi::GDK_DECOR_ALL as _;
817 #[doc(alias = "GDK_DECOR_BORDER")]
818 const BORDER = ffi::GDK_DECOR_BORDER as _;
819 #[doc(alias = "GDK_DECOR_RESIZEH")]
820 const RESIZEH = ffi::GDK_DECOR_RESIZEH as _;
821 #[doc(alias = "GDK_DECOR_TITLE")]
822 const TITLE = ffi::GDK_DECOR_TITLE as _;
823 #[doc(alias = "GDK_DECOR_MENU")]
824 const MENU = ffi::GDK_DECOR_MENU as _;
825 #[doc(alias = "GDK_DECOR_MINIMIZE")]
826 const MINIMIZE = ffi::GDK_DECOR_MINIMIZE as _;
827 #[doc(alias = "GDK_DECOR_MAXIMIZE")]
828 const MAXIMIZE = ffi::GDK_DECOR_MAXIMIZE as _;
829 }
830}
831
832impl fmt::Display for WMDecoration {
833 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
834 <Self as fmt::Debug>::fmt(self, f)
835 }
836}
837
838#[doc(hidden)]
839impl IntoGlib for WMDecoration {
840 type GlibType = ffi::GdkWMDecoration;
841
842 #[inline]
843 fn into_glib(self) -> ffi::GdkWMDecoration {
844 self.bits()
845 }
846}
847
848#[doc(hidden)]
849impl FromGlib<ffi::GdkWMDecoration> for WMDecoration {
850 #[inline]
851 unsafe fn from_glib(value: ffi::GdkWMDecoration) -> Self {
852 skip_assert_initialized!();
853 Self::from_bits_truncate(value)
854 }
855}
856
857impl StaticType for WMDecoration {
858 #[inline]
859 fn static_type() -> glib::Type {
860 unsafe { from_glib(ffi::gdk_wm_decoration_get_type()) }
861 }
862}
863
864impl glib::HasParamSpec for WMDecoration {
865 type ParamSpec = glib::ParamSpecFlags;
866 type SetValue = Self;
867 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
868
869 fn param_spec_builder() -> Self::BuilderFn {
870 |name| Self::ParamSpec::builder(name)
871 }
872}
873
874impl glib::value::ValueType for WMDecoration {
875 type Type = Self;
876}
877
878unsafe impl<'a> glib::value::FromValue<'a> for WMDecoration {
879 type Checker = glib::value::GenericValueTypeChecker<Self>;
880
881 #[inline]
882 unsafe fn from_value(value: &'a glib::Value) -> Self {
883 skip_assert_initialized!();
884 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
885 }
886}
887
888impl ToValue for WMDecoration {
889 #[inline]
890 fn to_value(&self) -> glib::Value {
891 let mut value = glib::Value::for_value_type::<Self>();
892 unsafe {
893 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
894 }
895 value
896 }
897
898 #[inline]
899 fn value_type(&self) -> glib::Type {
900 Self::static_type()
901 }
902}
903
904impl From<WMDecoration> for glib::Value {
905 #[inline]
906 fn from(v: WMDecoration) -> Self {
907 skip_assert_initialized!();
908 ToValue::to_value(&v)
909 }
910}
911
912bitflags! {
913 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
914 #[doc(alias = "GdkWMFunction")]
915 pub struct WMFunction: u32 {
916 #[doc(alias = "GDK_FUNC_ALL")]
917 const ALL = ffi::GDK_FUNC_ALL as _;
918 #[doc(alias = "GDK_FUNC_RESIZE")]
919 const RESIZE = ffi::GDK_FUNC_RESIZE as _;
920 #[doc(alias = "GDK_FUNC_MOVE")]
921 const MOVE = ffi::GDK_FUNC_MOVE as _;
922 #[doc(alias = "GDK_FUNC_MINIMIZE")]
923 const MINIMIZE = ffi::GDK_FUNC_MINIMIZE as _;
924 #[doc(alias = "GDK_FUNC_MAXIMIZE")]
925 const MAXIMIZE = ffi::GDK_FUNC_MAXIMIZE as _;
926 #[doc(alias = "GDK_FUNC_CLOSE")]
927 const CLOSE = ffi::GDK_FUNC_CLOSE as _;
928 }
929}
930
931impl fmt::Display for WMFunction {
932 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
933 <Self as fmt::Debug>::fmt(self, f)
934 }
935}
936
937#[doc(hidden)]
938impl IntoGlib for WMFunction {
939 type GlibType = ffi::GdkWMFunction;
940
941 #[inline]
942 fn into_glib(self) -> ffi::GdkWMFunction {
943 self.bits()
944 }
945}
946
947#[doc(hidden)]
948impl FromGlib<ffi::GdkWMFunction> for WMFunction {
949 #[inline]
950 unsafe fn from_glib(value: ffi::GdkWMFunction) -> Self {
951 skip_assert_initialized!();
952 Self::from_bits_truncate(value)
953 }
954}
955
956impl StaticType for WMFunction {
957 #[inline]
958 fn static_type() -> glib::Type {
959 unsafe { from_glib(ffi::gdk_wm_function_get_type()) }
960 }
961}
962
963impl glib::HasParamSpec for WMFunction {
964 type ParamSpec = glib::ParamSpecFlags;
965 type SetValue = Self;
966 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
967
968 fn param_spec_builder() -> Self::BuilderFn {
969 |name| Self::ParamSpec::builder(name)
970 }
971}
972
973impl glib::value::ValueType for WMFunction {
974 type Type = Self;
975}
976
977unsafe impl<'a> glib::value::FromValue<'a> for WMFunction {
978 type Checker = glib::value::GenericValueTypeChecker<Self>;
979
980 #[inline]
981 unsafe fn from_value(value: &'a glib::Value) -> Self {
982 skip_assert_initialized!();
983 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
984 }
985}
986
987impl ToValue for WMFunction {
988 #[inline]
989 fn to_value(&self) -> glib::Value {
990 let mut value = glib::Value::for_value_type::<Self>();
991 unsafe {
992 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
993 }
994 value
995 }
996
997 #[inline]
998 fn value_type(&self) -> glib::Type {
999 Self::static_type()
1000 }
1001}
1002
1003impl From<WMFunction> for glib::Value {
1004 #[inline]
1005 fn from(v: WMFunction) -> Self {
1006 skip_assert_initialized!();
1007 ToValue::to_value(&v)
1008 }
1009}
1010
1011bitflags! {
1012 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1013 #[doc(alias = "GdkWindowHints")]
1014 pub struct WindowHints: u32 {
1015 #[doc(alias = "GDK_HINT_POS")]
1016 const POS = ffi::GDK_HINT_POS as _;
1017 #[doc(alias = "GDK_HINT_MIN_SIZE")]
1018 const MIN_SIZE = ffi::GDK_HINT_MIN_SIZE as _;
1019 #[doc(alias = "GDK_HINT_MAX_SIZE")]
1020 const MAX_SIZE = ffi::GDK_HINT_MAX_SIZE as _;
1021 #[doc(alias = "GDK_HINT_BASE_SIZE")]
1022 const BASE_SIZE = ffi::GDK_HINT_BASE_SIZE as _;
1023 #[doc(alias = "GDK_HINT_ASPECT")]
1024 const ASPECT = ffi::GDK_HINT_ASPECT as _;
1025 #[doc(alias = "GDK_HINT_RESIZE_INC")]
1026 const RESIZE_INC = ffi::GDK_HINT_RESIZE_INC as _;
1027 #[doc(alias = "GDK_HINT_WIN_GRAVITY")]
1028 const WIN_GRAVITY = ffi::GDK_HINT_WIN_GRAVITY as _;
1029 #[doc(alias = "GDK_HINT_USER_POS")]
1030 const USER_POS = ffi::GDK_HINT_USER_POS as _;
1031 #[doc(alias = "GDK_HINT_USER_SIZE")]
1032 const USER_SIZE = ffi::GDK_HINT_USER_SIZE as _;
1033 }
1034}
1035
1036impl fmt::Display for WindowHints {
1037 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1038 <Self as fmt::Debug>::fmt(self, f)
1039 }
1040}
1041
1042#[doc(hidden)]
1043impl IntoGlib for WindowHints {
1044 type GlibType = ffi::GdkWindowHints;
1045
1046 #[inline]
1047 fn into_glib(self) -> ffi::GdkWindowHints {
1048 self.bits()
1049 }
1050}
1051
1052#[doc(hidden)]
1053impl FromGlib<ffi::GdkWindowHints> for WindowHints {
1054 #[inline]
1055 unsafe fn from_glib(value: ffi::GdkWindowHints) -> Self {
1056 skip_assert_initialized!();
1057 Self::from_bits_truncate(value)
1058 }
1059}
1060
1061impl StaticType for WindowHints {
1062 #[inline]
1063 fn static_type() -> glib::Type {
1064 unsafe { from_glib(ffi::gdk_window_hints_get_type()) }
1065 }
1066}
1067
1068impl glib::HasParamSpec for WindowHints {
1069 type ParamSpec = glib::ParamSpecFlags;
1070 type SetValue = Self;
1071 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1072
1073 fn param_spec_builder() -> Self::BuilderFn {
1074 |name| Self::ParamSpec::builder(name)
1075 }
1076}
1077
1078impl glib::value::ValueType for WindowHints {
1079 type Type = Self;
1080}
1081
1082unsafe impl<'a> glib::value::FromValue<'a> for WindowHints {
1083 type Checker = glib::value::GenericValueTypeChecker<Self>;
1084
1085 #[inline]
1086 unsafe fn from_value(value: &'a glib::Value) -> Self {
1087 skip_assert_initialized!();
1088 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1089 }
1090}
1091
1092impl ToValue for WindowHints {
1093 #[inline]
1094 fn to_value(&self) -> glib::Value {
1095 let mut value = glib::Value::for_value_type::<Self>();
1096 unsafe {
1097 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1098 }
1099 value
1100 }
1101
1102 #[inline]
1103 fn value_type(&self) -> glib::Type {
1104 Self::static_type()
1105 }
1106}
1107
1108impl From<WindowHints> for glib::Value {
1109 #[inline]
1110 fn from(v: WindowHints) -> Self {
1111 skip_assert_initialized!();
1112 ToValue::to_value(&v)
1113 }
1114}
1115
1116bitflags! {
1117 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1118 #[doc(alias = "GdkWindowState")]
1119 pub struct WindowState: u32 {
1120 #[doc(alias = "GDK_WINDOW_STATE_WITHDRAWN")]
1121 const WITHDRAWN = ffi::GDK_WINDOW_STATE_WITHDRAWN as _;
1122 #[doc(alias = "GDK_WINDOW_STATE_ICONIFIED")]
1123 const ICONIFIED = ffi::GDK_WINDOW_STATE_ICONIFIED as _;
1124 #[doc(alias = "GDK_WINDOW_STATE_MAXIMIZED")]
1125 const MAXIMIZED = ffi::GDK_WINDOW_STATE_MAXIMIZED as _;
1126 #[doc(alias = "GDK_WINDOW_STATE_STICKY")]
1127 const STICKY = ffi::GDK_WINDOW_STATE_STICKY as _;
1128 #[doc(alias = "GDK_WINDOW_STATE_FULLSCREEN")]
1129 const FULLSCREEN = ffi::GDK_WINDOW_STATE_FULLSCREEN as _;
1130 #[doc(alias = "GDK_WINDOW_STATE_ABOVE")]
1131 const ABOVE = ffi::GDK_WINDOW_STATE_ABOVE as _;
1132 #[doc(alias = "GDK_WINDOW_STATE_BELOW")]
1133 const BELOW = ffi::GDK_WINDOW_STATE_BELOW as _;
1134 #[doc(alias = "GDK_WINDOW_STATE_FOCUSED")]
1135 const FOCUSED = ffi::GDK_WINDOW_STATE_FOCUSED as _;
1136 #[doc(alias = "GDK_WINDOW_STATE_TILED")]
1137 const TILED = ffi::GDK_WINDOW_STATE_TILED as _;
1138 #[doc(alias = "GDK_WINDOW_STATE_TOP_TILED")]
1139 const TOP_TILED = ffi::GDK_WINDOW_STATE_TOP_TILED as _;
1140 #[doc(alias = "GDK_WINDOW_STATE_TOP_RESIZABLE")]
1141 const TOP_RESIZABLE = ffi::GDK_WINDOW_STATE_TOP_RESIZABLE as _;
1142 #[doc(alias = "GDK_WINDOW_STATE_RIGHT_TILED")]
1143 const RIGHT_TILED = ffi::GDK_WINDOW_STATE_RIGHT_TILED as _;
1144 #[doc(alias = "GDK_WINDOW_STATE_RIGHT_RESIZABLE")]
1145 const RIGHT_RESIZABLE = ffi::GDK_WINDOW_STATE_RIGHT_RESIZABLE as _;
1146 #[doc(alias = "GDK_WINDOW_STATE_BOTTOM_TILED")]
1147 const BOTTOM_TILED = ffi::GDK_WINDOW_STATE_BOTTOM_TILED as _;
1148 #[doc(alias = "GDK_WINDOW_STATE_BOTTOM_RESIZABLE")]
1149 const BOTTOM_RESIZABLE = ffi::GDK_WINDOW_STATE_BOTTOM_RESIZABLE as _;
1150 #[doc(alias = "GDK_WINDOW_STATE_LEFT_TILED")]
1151 const LEFT_TILED = ffi::GDK_WINDOW_STATE_LEFT_TILED as _;
1152 #[doc(alias = "GDK_WINDOW_STATE_LEFT_RESIZABLE")]
1153 const LEFT_RESIZABLE = ffi::GDK_WINDOW_STATE_LEFT_RESIZABLE as _;
1154 }
1155}
1156
1157impl fmt::Display for WindowState {
1158 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1159 <Self as fmt::Debug>::fmt(self, f)
1160 }
1161}
1162
1163#[doc(hidden)]
1164impl IntoGlib for WindowState {
1165 type GlibType = ffi::GdkWindowState;
1166
1167 #[inline]
1168 fn into_glib(self) -> ffi::GdkWindowState {
1169 self.bits()
1170 }
1171}
1172
1173#[doc(hidden)]
1174impl FromGlib<ffi::GdkWindowState> for WindowState {
1175 #[inline]
1176 unsafe fn from_glib(value: ffi::GdkWindowState) -> Self {
1177 skip_assert_initialized!();
1178 Self::from_bits_truncate(value)
1179 }
1180}
1181
1182impl StaticType for WindowState {
1183 #[inline]
1184 fn static_type() -> glib::Type {
1185 unsafe { from_glib(ffi::gdk_window_state_get_type()) }
1186 }
1187}
1188
1189impl glib::HasParamSpec for WindowState {
1190 type ParamSpec = glib::ParamSpecFlags;
1191 type SetValue = Self;
1192 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1193
1194 fn param_spec_builder() -> Self::BuilderFn {
1195 |name| Self::ParamSpec::builder(name)
1196 }
1197}
1198
1199impl glib::value::ValueType for WindowState {
1200 type Type = Self;
1201}
1202
1203unsafe impl<'a> glib::value::FromValue<'a> for WindowState {
1204 type Checker = glib::value::GenericValueTypeChecker<Self>;
1205
1206 #[inline]
1207 unsafe fn from_value(value: &'a glib::Value) -> Self {
1208 skip_assert_initialized!();
1209 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1210 }
1211}
1212
1213impl ToValue for WindowState {
1214 #[inline]
1215 fn to_value(&self) -> glib::Value {
1216 let mut value = glib::Value::for_value_type::<Self>();
1217 unsafe {
1218 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1219 }
1220 value
1221 }
1222
1223 #[inline]
1224 fn value_type(&self) -> glib::Type {
1225 Self::static_type()
1226 }
1227}
1228
1229impl From<WindowState> for glib::Value {
1230 #[inline]
1231 fn from(v: WindowState) -> Self {
1232 skip_assert_initialized!();
1233 ToValue::to_value(&v)
1234 }
1235}