1use crate::ffi;
6use glib::{bitflags::bitflags, prelude::*, translate::*};
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
33#[doc(hidden)]
34impl IntoGlib for AnchorHints {
35 type GlibType = ffi::GdkAnchorHints;
36
37 #[inline]
38 fn into_glib(self) -> ffi::GdkAnchorHints {
39 self.bits()
40 }
41}
42
43#[doc(hidden)]
44impl FromGlib<ffi::GdkAnchorHints> for AnchorHints {
45 #[inline]
46 unsafe fn from_glib(value: ffi::GdkAnchorHints) -> Self {
47 skip_assert_initialized!();
48 Self::from_bits_truncate(value)
49 }
50}
51
52impl StaticType for AnchorHints {
53 #[inline]
54 #[doc(alias = "gdk_anchor_hints_get_type")]
55 fn static_type() -> glib::Type {
56 unsafe { from_glib(ffi::gdk_anchor_hints_get_type()) }
57 }
58}
59
60impl glib::HasParamSpec for AnchorHints {
61 type ParamSpec = glib::ParamSpecFlags;
62 type SetValue = Self;
63 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
64
65 fn param_spec_builder() -> Self::BuilderFn {
66 Self::ParamSpec::builder
67 }
68}
69
70impl glib::value::ValueType for AnchorHints {
71 type Type = Self;
72}
73
74unsafe impl<'a> glib::value::FromValue<'a> for AnchorHints {
75 type Checker = glib::value::GenericValueTypeChecker<Self>;
76
77 #[inline]
78 unsafe fn from_value(value: &'a glib::Value) -> Self {
79 skip_assert_initialized!();
80 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
81 }
82}
83
84impl ToValue for AnchorHints {
85 #[inline]
86 fn to_value(&self) -> glib::Value {
87 let mut value = glib::Value::for_value_type::<Self>();
88 unsafe {
89 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
90 }
91 value
92 }
93
94 #[inline]
95 fn value_type(&self) -> glib::Type {
96 Self::static_type()
97 }
98}
99
100impl From<AnchorHints> for glib::Value {
101 #[inline]
102 fn from(v: AnchorHints) -> Self {
103 skip_assert_initialized!();
104 ToValue::to_value(&v)
105 }
106}
107
108bitflags! {
109 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
110 #[doc(alias = "GdkAxisFlags")]
111 pub struct AxisFlags: u32 {
112 #[doc(alias = "GDK_AXIS_FLAG_X")]
113 const X = ffi::GDK_AXIS_FLAG_X as _;
114 #[doc(alias = "GDK_AXIS_FLAG_Y")]
115 const Y = ffi::GDK_AXIS_FLAG_Y as _;
116 #[doc(alias = "GDK_AXIS_FLAG_DELTA_X")]
117 const DELTA_X = ffi::GDK_AXIS_FLAG_DELTA_X as _;
118 #[doc(alias = "GDK_AXIS_FLAG_DELTA_Y")]
119 const DELTA_Y = ffi::GDK_AXIS_FLAG_DELTA_Y as _;
120 #[doc(alias = "GDK_AXIS_FLAG_PRESSURE")]
121 const PRESSURE = ffi::GDK_AXIS_FLAG_PRESSURE as _;
122 #[doc(alias = "GDK_AXIS_FLAG_XTILT")]
123 const XTILT = ffi::GDK_AXIS_FLAG_XTILT as _;
124 #[doc(alias = "GDK_AXIS_FLAG_YTILT")]
125 const YTILT = ffi::GDK_AXIS_FLAG_YTILT as _;
126 #[doc(alias = "GDK_AXIS_FLAG_WHEEL")]
127 const WHEEL = ffi::GDK_AXIS_FLAG_WHEEL as _;
128 #[doc(alias = "GDK_AXIS_FLAG_DISTANCE")]
129 const DISTANCE = ffi::GDK_AXIS_FLAG_DISTANCE as _;
130 #[doc(alias = "GDK_AXIS_FLAG_ROTATION")]
131 const ROTATION = ffi::GDK_AXIS_FLAG_ROTATION as _;
132 #[doc(alias = "GDK_AXIS_FLAG_SLIDER")]
133 const SLIDER = ffi::GDK_AXIS_FLAG_SLIDER as _;
134 }
135}
136
137#[doc(hidden)]
138impl IntoGlib for AxisFlags {
139 type GlibType = ffi::GdkAxisFlags;
140
141 #[inline]
142 fn into_glib(self) -> ffi::GdkAxisFlags {
143 self.bits()
144 }
145}
146
147#[doc(hidden)]
148impl FromGlib<ffi::GdkAxisFlags> for AxisFlags {
149 #[inline]
150 unsafe fn from_glib(value: ffi::GdkAxisFlags) -> Self {
151 skip_assert_initialized!();
152 Self::from_bits_truncate(value)
153 }
154}
155
156impl StaticType for AxisFlags {
157 #[inline]
158 #[doc(alias = "gdk_axis_flags_get_type")]
159 fn static_type() -> glib::Type {
160 unsafe { from_glib(ffi::gdk_axis_flags_get_type()) }
161 }
162}
163
164impl glib::HasParamSpec for AxisFlags {
165 type ParamSpec = glib::ParamSpecFlags;
166 type SetValue = Self;
167 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
168
169 fn param_spec_builder() -> Self::BuilderFn {
170 Self::ParamSpec::builder
171 }
172}
173
174impl glib::value::ValueType for AxisFlags {
175 type Type = Self;
176}
177
178unsafe impl<'a> glib::value::FromValue<'a> for AxisFlags {
179 type Checker = glib::value::GenericValueTypeChecker<Self>;
180
181 #[inline]
182 unsafe fn from_value(value: &'a glib::Value) -> Self {
183 skip_assert_initialized!();
184 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
185 }
186}
187
188impl ToValue for AxisFlags {
189 #[inline]
190 fn to_value(&self) -> glib::Value {
191 let mut value = glib::Value::for_value_type::<Self>();
192 unsafe {
193 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
194 }
195 value
196 }
197
198 #[inline]
199 fn value_type(&self) -> glib::Type {
200 Self::static_type()
201 }
202}
203
204impl From<AxisFlags> for glib::Value {
205 #[inline]
206 fn from(v: AxisFlags) -> Self {
207 skip_assert_initialized!();
208 ToValue::to_value(&v)
209 }
210}
211
212bitflags! {
213 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
214 #[doc(alias = "GdkDragAction")]
215 pub struct DragAction: u32 {
216 #[cfg(feature = "v4_20")]
217 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
218 #[doc(alias = "GDK_ACTION_NONE")]
219 const NONE = ffi::GDK_ACTION_NONE as _;
220 #[doc(alias = "GDK_ACTION_COPY")]
221 const COPY = ffi::GDK_ACTION_COPY as _;
222 #[doc(alias = "GDK_ACTION_MOVE")]
223 const MOVE = ffi::GDK_ACTION_MOVE as _;
224 #[doc(alias = "GDK_ACTION_LINK")]
225 const LINK = ffi::GDK_ACTION_LINK as _;
226 #[doc(alias = "GDK_ACTION_ASK")]
227 const ASK = ffi::GDK_ACTION_ASK as _;
228 }
229}
230
231impl DragAction {
232 #[doc(alias = "gdk_drag_action_is_unique")]
233 pub fn is_unique(self) -> bool {
234 assert_initialized_main_thread!();
235 unsafe { from_glib(ffi::gdk_drag_action_is_unique(self.into_glib())) }
236 }
237}
238
239#[doc(hidden)]
240impl IntoGlib for DragAction {
241 type GlibType = ffi::GdkDragAction;
242
243 #[inline]
244 fn into_glib(self) -> ffi::GdkDragAction {
245 self.bits()
246 }
247}
248
249#[doc(hidden)]
250impl FromGlib<ffi::GdkDragAction> for DragAction {
251 #[inline]
252 unsafe fn from_glib(value: ffi::GdkDragAction) -> Self {
253 skip_assert_initialized!();
254 Self::from_bits_truncate(value)
255 }
256}
257
258impl StaticType for DragAction {
259 #[inline]
260 #[doc(alias = "gdk_drag_action_get_type")]
261 fn static_type() -> glib::Type {
262 unsafe { from_glib(ffi::gdk_drag_action_get_type()) }
263 }
264}
265
266impl glib::HasParamSpec for DragAction {
267 type ParamSpec = glib::ParamSpecFlags;
268 type SetValue = Self;
269 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
270
271 fn param_spec_builder() -> Self::BuilderFn {
272 Self::ParamSpec::builder
273 }
274}
275
276impl glib::value::ValueType for DragAction {
277 type Type = Self;
278}
279
280unsafe impl<'a> glib::value::FromValue<'a> for DragAction {
281 type Checker = glib::value::GenericValueTypeChecker<Self>;
282
283 #[inline]
284 unsafe fn from_value(value: &'a glib::Value) -> Self {
285 skip_assert_initialized!();
286 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
287 }
288}
289
290impl ToValue for DragAction {
291 #[inline]
292 fn to_value(&self) -> glib::Value {
293 let mut value = glib::Value::for_value_type::<Self>();
294 unsafe {
295 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
296 }
297 value
298 }
299
300 #[inline]
301 fn value_type(&self) -> glib::Type {
302 Self::static_type()
303 }
304}
305
306impl From<DragAction> for glib::Value {
307 #[inline]
308 fn from(v: DragAction) -> Self {
309 skip_assert_initialized!();
310 ToValue::to_value(&v)
311 }
312}
313
314bitflags! {
315 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
316 #[doc(alias = "GdkFrameClockPhase")]
317 pub struct FrameClockPhase: u32 {
318 #[doc(alias = "GDK_FRAME_CLOCK_PHASE_NONE")]
319 const NONE = ffi::GDK_FRAME_CLOCK_PHASE_NONE as _;
320 #[doc(alias = "GDK_FRAME_CLOCK_PHASE_FLUSH_EVENTS")]
321 const FLUSH_EVENTS = ffi::GDK_FRAME_CLOCK_PHASE_FLUSH_EVENTS as _;
322 #[doc(alias = "GDK_FRAME_CLOCK_PHASE_BEFORE_PAINT")]
323 const BEFORE_PAINT = ffi::GDK_FRAME_CLOCK_PHASE_BEFORE_PAINT as _;
324 #[doc(alias = "GDK_FRAME_CLOCK_PHASE_UPDATE")]
325 const UPDATE = ffi::GDK_FRAME_CLOCK_PHASE_UPDATE as _;
326 #[doc(alias = "GDK_FRAME_CLOCK_PHASE_LAYOUT")]
327 const LAYOUT = ffi::GDK_FRAME_CLOCK_PHASE_LAYOUT as _;
328 #[doc(alias = "GDK_FRAME_CLOCK_PHASE_PAINT")]
329 const PAINT = ffi::GDK_FRAME_CLOCK_PHASE_PAINT as _;
330 #[doc(alias = "GDK_FRAME_CLOCK_PHASE_RESUME_EVENTS")]
331 const RESUME_EVENTS = ffi::GDK_FRAME_CLOCK_PHASE_RESUME_EVENTS as _;
332 #[doc(alias = "GDK_FRAME_CLOCK_PHASE_AFTER_PAINT")]
333 const AFTER_PAINT = ffi::GDK_FRAME_CLOCK_PHASE_AFTER_PAINT as _;
334 }
335}
336
337#[doc(hidden)]
338impl IntoGlib for FrameClockPhase {
339 type GlibType = ffi::GdkFrameClockPhase;
340
341 #[inline]
342 fn into_glib(self) -> ffi::GdkFrameClockPhase {
343 self.bits()
344 }
345}
346
347#[doc(hidden)]
348impl FromGlib<ffi::GdkFrameClockPhase> for FrameClockPhase {
349 #[inline]
350 unsafe fn from_glib(value: ffi::GdkFrameClockPhase) -> Self {
351 skip_assert_initialized!();
352 Self::from_bits_truncate(value)
353 }
354}
355
356impl StaticType for FrameClockPhase {
357 #[inline]
358 #[doc(alias = "gdk_frame_clock_phase_get_type")]
359 fn static_type() -> glib::Type {
360 unsafe { from_glib(ffi::gdk_frame_clock_phase_get_type()) }
361 }
362}
363
364impl glib::HasParamSpec for FrameClockPhase {
365 type ParamSpec = glib::ParamSpecFlags;
366 type SetValue = Self;
367 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
368
369 fn param_spec_builder() -> Self::BuilderFn {
370 Self::ParamSpec::builder
371 }
372}
373
374impl glib::value::ValueType for FrameClockPhase {
375 type Type = Self;
376}
377
378unsafe impl<'a> glib::value::FromValue<'a> for FrameClockPhase {
379 type Checker = glib::value::GenericValueTypeChecker<Self>;
380
381 #[inline]
382 unsafe fn from_value(value: &'a glib::Value) -> Self {
383 skip_assert_initialized!();
384 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
385 }
386}
387
388impl ToValue for FrameClockPhase {
389 #[inline]
390 fn to_value(&self) -> glib::Value {
391 let mut value = glib::Value::for_value_type::<Self>();
392 unsafe {
393 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
394 }
395 value
396 }
397
398 #[inline]
399 fn value_type(&self) -> glib::Type {
400 Self::static_type()
401 }
402}
403
404impl From<FrameClockPhase> for glib::Value {
405 #[inline]
406 fn from(v: FrameClockPhase) -> Self {
407 skip_assert_initialized!();
408 ToValue::to_value(&v)
409 }
410}
411
412#[cfg(feature = "v4_6")]
413bitflags! {
414 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
415 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
416 #[doc(alias = "GdkGLAPI")]
417 pub struct GLAPI: u32 {
418 #[doc(alias = "GDK_GL_API_GL")]
419 const GL = ffi::GDK_GL_API_GL as _;
420 #[doc(alias = "GDK_GL_API_GLES")]
421 const GLES = ffi::GDK_GL_API_GLES as _;
422 }
423}
424
425#[cfg(feature = "v4_6")]
426#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
427#[doc(hidden)]
428impl IntoGlib for GLAPI {
429 type GlibType = ffi::GdkGLAPI;
430
431 #[inline]
432 fn into_glib(self) -> ffi::GdkGLAPI {
433 self.bits()
434 }
435}
436
437#[cfg(feature = "v4_6")]
438#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
439#[doc(hidden)]
440impl FromGlib<ffi::GdkGLAPI> for GLAPI {
441 #[inline]
442 unsafe fn from_glib(value: ffi::GdkGLAPI) -> Self {
443 skip_assert_initialized!();
444 Self::from_bits_truncate(value)
445 }
446}
447
448#[cfg(feature = "v4_6")]
449#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
450impl StaticType for GLAPI {
451 #[inline]
452 #[doc(alias = "gdk_gl_api_get_type")]
453 fn static_type() -> glib::Type {
454 unsafe { from_glib(ffi::gdk_gl_api_get_type()) }
455 }
456}
457
458#[cfg(feature = "v4_6")]
459#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
460impl glib::HasParamSpec for GLAPI {
461 type ParamSpec = glib::ParamSpecFlags;
462 type SetValue = Self;
463 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
464
465 fn param_spec_builder() -> Self::BuilderFn {
466 Self::ParamSpec::builder
467 }
468}
469
470#[cfg(feature = "v4_6")]
471#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
472impl glib::value::ValueType for GLAPI {
473 type Type = Self;
474}
475
476#[cfg(feature = "v4_6")]
477#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
478unsafe impl<'a> glib::value::FromValue<'a> for GLAPI {
479 type Checker = glib::value::GenericValueTypeChecker<Self>;
480
481 #[inline]
482 unsafe fn from_value(value: &'a glib::Value) -> Self {
483 skip_assert_initialized!();
484 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
485 }
486}
487
488#[cfg(feature = "v4_6")]
489#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
490impl ToValue for GLAPI {
491 #[inline]
492 fn to_value(&self) -> glib::Value {
493 let mut value = glib::Value::for_value_type::<Self>();
494 unsafe {
495 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
496 }
497 value
498 }
499
500 #[inline]
501 fn value_type(&self) -> glib::Type {
502 Self::static_type()
503 }
504}
505
506#[cfg(feature = "v4_6")]
507#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
508impl From<GLAPI> for glib::Value {
509 #[inline]
510 fn from(v: GLAPI) -> Self {
511 skip_assert_initialized!();
512 ToValue::to_value(&v)
513 }
514}
515
516bitflags! {
517 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
518 #[doc(alias = "GdkModifierType")]
519 pub struct ModifierType: u32 {
520 #[cfg(feature = "v4_14")]
521 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
522 #[doc(alias = "GDK_NO_MODIFIER_MASK")]
523 const NO_MODIFIER_MASK = ffi::GDK_NO_MODIFIER_MASK as _;
524 #[doc(alias = "GDK_SHIFT_MASK")]
525 const SHIFT_MASK = ffi::GDK_SHIFT_MASK as _;
526 #[doc(alias = "GDK_LOCK_MASK")]
527 const LOCK_MASK = ffi::GDK_LOCK_MASK as _;
528 #[doc(alias = "GDK_CONTROL_MASK")]
529 const CONTROL_MASK = ffi::GDK_CONTROL_MASK as _;
530 #[doc(alias = "GDK_ALT_MASK")]
531 const ALT_MASK = ffi::GDK_ALT_MASK as _;
532 #[doc(alias = "GDK_BUTTON1_MASK")]
533 const BUTTON1_MASK = ffi::GDK_BUTTON1_MASK as _;
534 #[doc(alias = "GDK_BUTTON2_MASK")]
535 const BUTTON2_MASK = ffi::GDK_BUTTON2_MASK as _;
536 #[doc(alias = "GDK_BUTTON3_MASK")]
537 const BUTTON3_MASK = ffi::GDK_BUTTON3_MASK as _;
538 #[doc(alias = "GDK_BUTTON4_MASK")]
539 const BUTTON4_MASK = ffi::GDK_BUTTON4_MASK as _;
540 #[doc(alias = "GDK_BUTTON5_MASK")]
541 const BUTTON5_MASK = ffi::GDK_BUTTON5_MASK as _;
542 #[doc(alias = "GDK_SUPER_MASK")]
543 const SUPER_MASK = ffi::GDK_SUPER_MASK as _;
544 #[doc(alias = "GDK_HYPER_MASK")]
545 const HYPER_MASK = ffi::GDK_HYPER_MASK as _;
546 #[doc(alias = "GDK_META_MASK")]
547 const META_MASK = ffi::GDK_META_MASK as _;
548 }
549}
550
551#[doc(hidden)]
552impl IntoGlib for ModifierType {
553 type GlibType = ffi::GdkModifierType;
554
555 #[inline]
556 fn into_glib(self) -> ffi::GdkModifierType {
557 self.bits()
558 }
559}
560
561#[doc(hidden)]
562impl FromGlib<ffi::GdkModifierType> for ModifierType {
563 #[inline]
564 unsafe fn from_glib(value: ffi::GdkModifierType) -> Self {
565 skip_assert_initialized!();
566 Self::from_bits_truncate(value)
567 }
568}
569
570impl StaticType for ModifierType {
571 #[inline]
572 #[doc(alias = "gdk_modifier_type_get_type")]
573 fn static_type() -> glib::Type {
574 unsafe { from_glib(ffi::gdk_modifier_type_get_type()) }
575 }
576}
577
578impl glib::HasParamSpec for ModifierType {
579 type ParamSpec = glib::ParamSpecFlags;
580 type SetValue = Self;
581 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
582
583 fn param_spec_builder() -> Self::BuilderFn {
584 Self::ParamSpec::builder
585 }
586}
587
588impl glib::value::ValueType for ModifierType {
589 type Type = Self;
590}
591
592unsafe impl<'a> glib::value::FromValue<'a> for ModifierType {
593 type Checker = glib::value::GenericValueTypeChecker<Self>;
594
595 #[inline]
596 unsafe fn from_value(value: &'a glib::Value) -> Self {
597 skip_assert_initialized!();
598 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
599 }
600}
601
602impl ToValue for ModifierType {
603 #[inline]
604 fn to_value(&self) -> glib::Value {
605 let mut value = glib::Value::for_value_type::<Self>();
606 unsafe {
607 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
608 }
609 value
610 }
611
612 #[inline]
613 fn value_type(&self) -> glib::Type {
614 Self::static_type()
615 }
616}
617
618impl From<ModifierType> for glib::Value {
619 #[inline]
620 fn from(v: ModifierType) -> Self {
621 skip_assert_initialized!();
622 ToValue::to_value(&v)
623 }
624}
625
626bitflags! {
627 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
628 #[doc(alias = "GdkPaintableFlags")]
629 pub struct PaintableFlags: u32 {
630 #[doc(alias = "GDK_PAINTABLE_STATIC_SIZE")]
631 const SIZE = ffi::GDK_PAINTABLE_STATIC_SIZE as _;
632 #[doc(alias = "GDK_PAINTABLE_STATIC_CONTENTS")]
633 const CONTENTS = ffi::GDK_PAINTABLE_STATIC_CONTENTS as _;
634 }
635}
636
637#[doc(hidden)]
638impl IntoGlib for PaintableFlags {
639 type GlibType = ffi::GdkPaintableFlags;
640
641 #[inline]
642 fn into_glib(self) -> ffi::GdkPaintableFlags {
643 self.bits()
644 }
645}
646
647#[doc(hidden)]
648impl FromGlib<ffi::GdkPaintableFlags> for PaintableFlags {
649 #[inline]
650 unsafe fn from_glib(value: ffi::GdkPaintableFlags) -> Self {
651 skip_assert_initialized!();
652 Self::from_bits_truncate(value)
653 }
654}
655
656impl StaticType for PaintableFlags {
657 #[inline]
658 #[doc(alias = "gdk_paintable_flags_get_type")]
659 fn static_type() -> glib::Type {
660 unsafe { from_glib(ffi::gdk_paintable_flags_get_type()) }
661 }
662}
663
664impl glib::HasParamSpec for PaintableFlags {
665 type ParamSpec = glib::ParamSpecFlags;
666 type SetValue = Self;
667 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
668
669 fn param_spec_builder() -> Self::BuilderFn {
670 Self::ParamSpec::builder
671 }
672}
673
674impl glib::value::ValueType for PaintableFlags {
675 type Type = Self;
676}
677
678unsafe impl<'a> glib::value::FromValue<'a> for PaintableFlags {
679 type Checker = glib::value::GenericValueTypeChecker<Self>;
680
681 #[inline]
682 unsafe fn from_value(value: &'a glib::Value) -> Self {
683 skip_assert_initialized!();
684 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
685 }
686}
687
688impl ToValue for PaintableFlags {
689 #[inline]
690 fn to_value(&self) -> glib::Value {
691 let mut value = glib::Value::for_value_type::<Self>();
692 unsafe {
693 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
694 }
695 value
696 }
697
698 #[inline]
699 fn value_type(&self) -> glib::Type {
700 Self::static_type()
701 }
702}
703
704impl From<PaintableFlags> for glib::Value {
705 #[inline]
706 fn from(v: PaintableFlags) -> Self {
707 skip_assert_initialized!();
708 ToValue::to_value(&v)
709 }
710}
711
712bitflags! {
713 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
714 #[doc(alias = "GdkSeatCapabilities")]
715 pub struct SeatCapabilities: u32 {
716 #[doc(alias = "GDK_SEAT_CAPABILITY_NONE")]
717 const NONE = ffi::GDK_SEAT_CAPABILITY_NONE as _;
718 #[doc(alias = "GDK_SEAT_CAPABILITY_POINTER")]
719 const POINTER = ffi::GDK_SEAT_CAPABILITY_POINTER as _;
720 #[doc(alias = "GDK_SEAT_CAPABILITY_TOUCH")]
721 const TOUCH = ffi::GDK_SEAT_CAPABILITY_TOUCH as _;
722 #[doc(alias = "GDK_SEAT_CAPABILITY_TABLET_STYLUS")]
723 const TABLET_STYLUS = ffi::GDK_SEAT_CAPABILITY_TABLET_STYLUS as _;
724 #[doc(alias = "GDK_SEAT_CAPABILITY_KEYBOARD")]
725 const KEYBOARD = ffi::GDK_SEAT_CAPABILITY_KEYBOARD as _;
726 #[doc(alias = "GDK_SEAT_CAPABILITY_TABLET_PAD")]
727 const TABLET_PAD = ffi::GDK_SEAT_CAPABILITY_TABLET_PAD as _;
728 #[doc(alias = "GDK_SEAT_CAPABILITY_ALL_POINTING")]
729 const ALL_POINTING = ffi::GDK_SEAT_CAPABILITY_ALL_POINTING as _;
730 #[doc(alias = "GDK_SEAT_CAPABILITY_ALL")]
731 const ALL = ffi::GDK_SEAT_CAPABILITY_ALL as _;
732 }
733}
734
735#[doc(hidden)]
736impl IntoGlib for SeatCapabilities {
737 type GlibType = ffi::GdkSeatCapabilities;
738
739 #[inline]
740 fn into_glib(self) -> ffi::GdkSeatCapabilities {
741 self.bits()
742 }
743}
744
745#[doc(hidden)]
746impl FromGlib<ffi::GdkSeatCapabilities> for SeatCapabilities {
747 #[inline]
748 unsafe fn from_glib(value: ffi::GdkSeatCapabilities) -> Self {
749 skip_assert_initialized!();
750 Self::from_bits_truncate(value)
751 }
752}
753
754impl StaticType for SeatCapabilities {
755 #[inline]
756 #[doc(alias = "gdk_seat_capabilities_get_type")]
757 fn static_type() -> glib::Type {
758 unsafe { from_glib(ffi::gdk_seat_capabilities_get_type()) }
759 }
760}
761
762impl glib::HasParamSpec for SeatCapabilities {
763 type ParamSpec = glib::ParamSpecFlags;
764 type SetValue = Self;
765 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
766
767 fn param_spec_builder() -> Self::BuilderFn {
768 Self::ParamSpec::builder
769 }
770}
771
772impl glib::value::ValueType for SeatCapabilities {
773 type Type = Self;
774}
775
776unsafe impl<'a> glib::value::FromValue<'a> for SeatCapabilities {
777 type Checker = glib::value::GenericValueTypeChecker<Self>;
778
779 #[inline]
780 unsafe fn from_value(value: &'a glib::Value) -> Self {
781 skip_assert_initialized!();
782 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
783 }
784}
785
786impl ToValue for SeatCapabilities {
787 #[inline]
788 fn to_value(&self) -> glib::Value {
789 let mut value = glib::Value::for_value_type::<Self>();
790 unsafe {
791 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
792 }
793 value
794 }
795
796 #[inline]
797 fn value_type(&self) -> glib::Type {
798 Self::static_type()
799 }
800}
801
802impl From<SeatCapabilities> for glib::Value {
803 #[inline]
804 fn from(v: SeatCapabilities) -> Self {
805 skip_assert_initialized!();
806 ToValue::to_value(&v)
807 }
808}
809
810#[cfg(feature = "v4_20")]
811bitflags! {
812 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
813 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
814 #[doc(alias = "GdkToplevelCapabilities")]
815 pub struct ToplevelCapabilities: u32 {
816 #[cfg(feature = "v4_20")]
817 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
818 #[doc(alias = "GDK_TOPLEVEL_CAPABILITIES_EDGE_CONSTRAINTS")]
819 const EDGE_CONSTRAINTS = ffi::GDK_TOPLEVEL_CAPABILITIES_EDGE_CONSTRAINTS as _;
820 #[cfg(feature = "v4_20")]
821 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
822 #[doc(alias = "GDK_TOPLEVEL_CAPABILITIES_INHIBIT_SHORTCUTS")]
823 const INHIBIT_SHORTCUTS = ffi::GDK_TOPLEVEL_CAPABILITIES_INHIBIT_SHORTCUTS as _;
824 #[cfg(feature = "v4_20")]
825 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
826 #[doc(alias = "GDK_TOPLEVEL_CAPABILITIES_TITLEBAR_GESTURES")]
827 const TITLEBAR_GESTURES = ffi::GDK_TOPLEVEL_CAPABILITIES_TITLEBAR_GESTURES as _;
828 #[cfg(feature = "v4_20")]
829 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
830 #[doc(alias = "GDK_TOPLEVEL_CAPABILITIES_WINDOW_MENU")]
831 const WINDOW_MENU = ffi::GDK_TOPLEVEL_CAPABILITIES_WINDOW_MENU as _;
832 #[cfg(feature = "v4_20")]
833 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
834 #[doc(alias = "GDK_TOPLEVEL_CAPABILITIES_MAXIMIZE")]
835 const MAXIMIZE = ffi::GDK_TOPLEVEL_CAPABILITIES_MAXIMIZE as _;
836 #[cfg(feature = "v4_20")]
837 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
838 #[doc(alias = "GDK_TOPLEVEL_CAPABILITIES_FULLSCREEN")]
839 const FULLSCREEN = ffi::GDK_TOPLEVEL_CAPABILITIES_FULLSCREEN as _;
840 #[cfg(feature = "v4_20")]
841 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
842 #[doc(alias = "GDK_TOPLEVEL_CAPABILITIES_MINIMIZE")]
843 const MINIMIZE = ffi::GDK_TOPLEVEL_CAPABILITIES_MINIMIZE as _;
844 #[cfg(feature = "v4_20")]
845 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
846 #[doc(alias = "GDK_TOPLEVEL_CAPABILITIES_LOWER")]
847 const LOWER = ffi::GDK_TOPLEVEL_CAPABILITIES_LOWER as _;
848 }
849}
850
851#[cfg(feature = "v4_20")]
852#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
853#[doc(hidden)]
854impl IntoGlib for ToplevelCapabilities {
855 type GlibType = ffi::GdkToplevelCapabilities;
856
857 #[inline]
858 fn into_glib(self) -> ffi::GdkToplevelCapabilities {
859 self.bits()
860 }
861}
862
863#[cfg(feature = "v4_20")]
864#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
865#[doc(hidden)]
866impl FromGlib<ffi::GdkToplevelCapabilities> for ToplevelCapabilities {
867 #[inline]
868 unsafe fn from_glib(value: ffi::GdkToplevelCapabilities) -> Self {
869 skip_assert_initialized!();
870 Self::from_bits_truncate(value)
871 }
872}
873
874#[cfg(feature = "v4_20")]
875#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
876impl StaticType for ToplevelCapabilities {
877 #[inline]
878 #[doc(alias = "gdk_toplevel_capabilities_get_type")]
879 fn static_type() -> glib::Type {
880 unsafe { from_glib(ffi::gdk_toplevel_capabilities_get_type()) }
881 }
882}
883
884#[cfg(feature = "v4_20")]
885#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
886impl glib::HasParamSpec for ToplevelCapabilities {
887 type ParamSpec = glib::ParamSpecFlags;
888 type SetValue = Self;
889 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
890
891 fn param_spec_builder() -> Self::BuilderFn {
892 Self::ParamSpec::builder
893 }
894}
895
896#[cfg(feature = "v4_20")]
897#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
898impl glib::value::ValueType for ToplevelCapabilities {
899 type Type = Self;
900}
901
902#[cfg(feature = "v4_20")]
903#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
904unsafe impl<'a> glib::value::FromValue<'a> for ToplevelCapabilities {
905 type Checker = glib::value::GenericValueTypeChecker<Self>;
906
907 #[inline]
908 unsafe fn from_value(value: &'a glib::Value) -> Self {
909 skip_assert_initialized!();
910 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
911 }
912}
913
914#[cfg(feature = "v4_20")]
915#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
916impl ToValue for ToplevelCapabilities {
917 #[inline]
918 fn to_value(&self) -> glib::Value {
919 let mut value = glib::Value::for_value_type::<Self>();
920 unsafe {
921 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
922 }
923 value
924 }
925
926 #[inline]
927 fn value_type(&self) -> glib::Type {
928 Self::static_type()
929 }
930}
931
932#[cfg(feature = "v4_20")]
933#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
934impl From<ToplevelCapabilities> for glib::Value {
935 #[inline]
936 fn from(v: ToplevelCapabilities) -> Self {
937 skip_assert_initialized!();
938 ToValue::to_value(&v)
939 }
940}
941
942bitflags! {
943 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
944 #[doc(alias = "GdkToplevelState")]
945 pub struct ToplevelState: u32 {
946 #[doc(alias = "GDK_TOPLEVEL_STATE_MINIMIZED")]
947 const MINIMIZED = ffi::GDK_TOPLEVEL_STATE_MINIMIZED as _;
948 #[doc(alias = "GDK_TOPLEVEL_STATE_MAXIMIZED")]
949 const MAXIMIZED = ffi::GDK_TOPLEVEL_STATE_MAXIMIZED as _;
950 #[doc(alias = "GDK_TOPLEVEL_STATE_STICKY")]
951 const STICKY = ffi::GDK_TOPLEVEL_STATE_STICKY as _;
952 #[doc(alias = "GDK_TOPLEVEL_STATE_FULLSCREEN")]
953 const FULLSCREEN = ffi::GDK_TOPLEVEL_STATE_FULLSCREEN as _;
954 #[doc(alias = "GDK_TOPLEVEL_STATE_ABOVE")]
955 const ABOVE = ffi::GDK_TOPLEVEL_STATE_ABOVE as _;
956 #[doc(alias = "GDK_TOPLEVEL_STATE_BELOW")]
957 const BELOW = ffi::GDK_TOPLEVEL_STATE_BELOW as _;
958 #[doc(alias = "GDK_TOPLEVEL_STATE_FOCUSED")]
959 const FOCUSED = ffi::GDK_TOPLEVEL_STATE_FOCUSED as _;
960 #[doc(alias = "GDK_TOPLEVEL_STATE_TILED")]
961 const TILED = ffi::GDK_TOPLEVEL_STATE_TILED as _;
962 #[doc(alias = "GDK_TOPLEVEL_STATE_TOP_TILED")]
963 const TOP_TILED = ffi::GDK_TOPLEVEL_STATE_TOP_TILED as _;
964 #[doc(alias = "GDK_TOPLEVEL_STATE_TOP_RESIZABLE")]
965 const TOP_RESIZABLE = ffi::GDK_TOPLEVEL_STATE_TOP_RESIZABLE as _;
966 #[doc(alias = "GDK_TOPLEVEL_STATE_RIGHT_TILED")]
967 const RIGHT_TILED = ffi::GDK_TOPLEVEL_STATE_RIGHT_TILED as _;
968 #[doc(alias = "GDK_TOPLEVEL_STATE_RIGHT_RESIZABLE")]
969 const RIGHT_RESIZABLE = ffi::GDK_TOPLEVEL_STATE_RIGHT_RESIZABLE as _;
970 #[doc(alias = "GDK_TOPLEVEL_STATE_BOTTOM_TILED")]
971 const BOTTOM_TILED = ffi::GDK_TOPLEVEL_STATE_BOTTOM_TILED as _;
972 #[doc(alias = "GDK_TOPLEVEL_STATE_BOTTOM_RESIZABLE")]
973 const BOTTOM_RESIZABLE = ffi::GDK_TOPLEVEL_STATE_BOTTOM_RESIZABLE as _;
974 #[doc(alias = "GDK_TOPLEVEL_STATE_LEFT_TILED")]
975 const LEFT_TILED = ffi::GDK_TOPLEVEL_STATE_LEFT_TILED as _;
976 #[doc(alias = "GDK_TOPLEVEL_STATE_LEFT_RESIZABLE")]
977 const LEFT_RESIZABLE = ffi::GDK_TOPLEVEL_STATE_LEFT_RESIZABLE as _;
978 #[cfg(feature = "v4_12")]
979 #[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
980 #[doc(alias = "GDK_TOPLEVEL_STATE_SUSPENDED")]
981 const SUSPENDED = ffi::GDK_TOPLEVEL_STATE_SUSPENDED as _;
982 }
983}
984
985#[doc(hidden)]
986impl IntoGlib for ToplevelState {
987 type GlibType = ffi::GdkToplevelState;
988
989 #[inline]
990 fn into_glib(self) -> ffi::GdkToplevelState {
991 self.bits()
992 }
993}
994
995#[doc(hidden)]
996impl FromGlib<ffi::GdkToplevelState> for ToplevelState {
997 #[inline]
998 unsafe fn from_glib(value: ffi::GdkToplevelState) -> Self {
999 skip_assert_initialized!();
1000 Self::from_bits_truncate(value)
1001 }
1002}
1003
1004impl StaticType for ToplevelState {
1005 #[inline]
1006 #[doc(alias = "gdk_toplevel_state_get_type")]
1007 fn static_type() -> glib::Type {
1008 unsafe { from_glib(ffi::gdk_toplevel_state_get_type()) }
1009 }
1010}
1011
1012impl glib::HasParamSpec for ToplevelState {
1013 type ParamSpec = glib::ParamSpecFlags;
1014 type SetValue = Self;
1015 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1016
1017 fn param_spec_builder() -> Self::BuilderFn {
1018 Self::ParamSpec::builder
1019 }
1020}
1021
1022impl glib::value::ValueType for ToplevelState {
1023 type Type = Self;
1024}
1025
1026unsafe impl<'a> glib::value::FromValue<'a> for ToplevelState {
1027 type Checker = glib::value::GenericValueTypeChecker<Self>;
1028
1029 #[inline]
1030 unsafe fn from_value(value: &'a glib::Value) -> Self {
1031 skip_assert_initialized!();
1032 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1033 }
1034}
1035
1036impl ToValue for ToplevelState {
1037 #[inline]
1038 fn to_value(&self) -> glib::Value {
1039 let mut value = glib::Value::for_value_type::<Self>();
1040 unsafe {
1041 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1042 }
1043 value
1044 }
1045
1046 #[inline]
1047 fn value_type(&self) -> glib::Type {
1048 Self::static_type()
1049 }
1050}
1051
1052impl From<ToplevelState> for glib::Value {
1053 #[inline]
1054 fn from(v: ToplevelState) -> Self {
1055 skip_assert_initialized!();
1056 ToValue::to_value(&v)
1057 }
1058}