1use crate::ffi;
6use glib::{bitflags::bitflags, prelude::*, translate::*};
7
8bitflags! {
9 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
10 #[doc(alias = "GtkApplicationInhibitFlags")]
11 pub struct ApplicationInhibitFlags: u32 {
12 #[doc(alias = "GTK_APPLICATION_INHIBIT_LOGOUT")]
13 const LOGOUT = ffi::GTK_APPLICATION_INHIBIT_LOGOUT as _;
14 #[doc(alias = "GTK_APPLICATION_INHIBIT_SWITCH")]
15 const SWITCH = ffi::GTK_APPLICATION_INHIBIT_SWITCH as _;
16 #[doc(alias = "GTK_APPLICATION_INHIBIT_SUSPEND")]
17 const SUSPEND = ffi::GTK_APPLICATION_INHIBIT_SUSPEND as _;
18 #[doc(alias = "GTK_APPLICATION_INHIBIT_IDLE")]
19 const IDLE = ffi::GTK_APPLICATION_INHIBIT_IDLE as _;
20 }
21}
22
23#[doc(hidden)]
24impl IntoGlib for ApplicationInhibitFlags {
25 type GlibType = ffi::GtkApplicationInhibitFlags;
26
27 #[inline]
28 fn into_glib(self) -> ffi::GtkApplicationInhibitFlags {
29 self.bits()
30 }
31}
32
33#[doc(hidden)]
34impl FromGlib<ffi::GtkApplicationInhibitFlags> for ApplicationInhibitFlags {
35 #[inline]
36 unsafe fn from_glib(value: ffi::GtkApplicationInhibitFlags) -> Self {
37 skip_assert_initialized!();
38 Self::from_bits_truncate(value)
39 }
40}
41
42impl StaticType for ApplicationInhibitFlags {
43 #[inline]
44 #[doc(alias = "gtk_application_inhibit_flags_get_type")]
45 fn static_type() -> glib::Type {
46 unsafe { from_glib(ffi::gtk_application_inhibit_flags_get_type()) }
47 }
48}
49
50impl glib::HasParamSpec for ApplicationInhibitFlags {
51 type ParamSpec = glib::ParamSpecFlags;
52 type SetValue = Self;
53 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
54
55 fn param_spec_builder() -> Self::BuilderFn {
56 Self::ParamSpec::builder
57 }
58}
59
60impl glib::value::ValueType for ApplicationInhibitFlags {
61 type Type = Self;
62}
63
64unsafe impl<'a> glib::value::FromValue<'a> for ApplicationInhibitFlags {
65 type Checker = glib::value::GenericValueTypeChecker<Self>;
66
67 #[inline]
68 unsafe fn from_value(value: &'a glib::Value) -> Self {
69 skip_assert_initialized!();
70 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
71 }
72}
73
74impl ToValue for ApplicationInhibitFlags {
75 #[inline]
76 fn to_value(&self) -> glib::Value {
77 let mut value = glib::Value::for_value_type::<Self>();
78 unsafe {
79 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
80 }
81 value
82 }
83
84 #[inline]
85 fn value_type(&self) -> glib::Type {
86 Self::static_type()
87 }
88}
89
90impl From<ApplicationInhibitFlags> for glib::Value {
91 #[inline]
92 fn from(v: ApplicationInhibitFlags) -> Self {
93 skip_assert_initialized!();
94 ToValue::to_value(&v)
95 }
96}
97
98bitflags! {
99 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
100 #[doc(alias = "GtkBuilderClosureFlags")]
101 pub struct BuilderClosureFlags: u32 {
102 #[doc(alias = "GTK_BUILDER_CLOSURE_SWAPPED")]
103 const SWAPPED = ffi::GTK_BUILDER_CLOSURE_SWAPPED as _;
104 }
105}
106
107#[doc(hidden)]
108impl IntoGlib for BuilderClosureFlags {
109 type GlibType = ffi::GtkBuilderClosureFlags;
110
111 #[inline]
112 fn into_glib(self) -> ffi::GtkBuilderClosureFlags {
113 self.bits()
114 }
115}
116
117#[doc(hidden)]
118impl FromGlib<ffi::GtkBuilderClosureFlags> for BuilderClosureFlags {
119 #[inline]
120 unsafe fn from_glib(value: ffi::GtkBuilderClosureFlags) -> Self {
121 skip_assert_initialized!();
122 Self::from_bits_truncate(value)
123 }
124}
125
126impl StaticType for BuilderClosureFlags {
127 #[inline]
128 #[doc(alias = "gtk_builder_closure_flags_get_type")]
129 fn static_type() -> glib::Type {
130 unsafe { from_glib(ffi::gtk_builder_closure_flags_get_type()) }
131 }
132}
133
134impl glib::HasParamSpec for BuilderClosureFlags {
135 type ParamSpec = glib::ParamSpecFlags;
136 type SetValue = Self;
137 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
138
139 fn param_spec_builder() -> Self::BuilderFn {
140 Self::ParamSpec::builder
141 }
142}
143
144impl glib::value::ValueType for BuilderClosureFlags {
145 type Type = Self;
146}
147
148unsafe impl<'a> glib::value::FromValue<'a> for BuilderClosureFlags {
149 type Checker = glib::value::GenericValueTypeChecker<Self>;
150
151 #[inline]
152 unsafe fn from_value(value: &'a glib::Value) -> Self {
153 skip_assert_initialized!();
154 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
155 }
156}
157
158impl ToValue for BuilderClosureFlags {
159 #[inline]
160 fn to_value(&self) -> glib::Value {
161 let mut value = glib::Value::for_value_type::<Self>();
162 unsafe {
163 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
164 }
165 value
166 }
167
168 #[inline]
169 fn value_type(&self) -> glib::Type {
170 Self::static_type()
171 }
172}
173
174impl From<BuilderClosureFlags> for glib::Value {
175 #[inline]
176 fn from(v: BuilderClosureFlags) -> Self {
177 skip_assert_initialized!();
178 ToValue::to_value(&v)
179 }
180}
181
182bitflags! {
183 #[cfg_attr(feature = "v4_20", deprecated = "Since 4.20")]
184 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
185 #[doc(alias = "GtkCellRendererState")]
186 pub struct CellRendererState: u32 {
187 #[doc(alias = "GTK_CELL_RENDERER_SELECTED")]
188 const SELECTED = ffi::GTK_CELL_RENDERER_SELECTED as _;
189 #[doc(alias = "GTK_CELL_RENDERER_PRELIT")]
190 const PRELIT = ffi::GTK_CELL_RENDERER_PRELIT as _;
191 #[doc(alias = "GTK_CELL_RENDERER_INSENSITIVE")]
192 const INSENSITIVE = ffi::GTK_CELL_RENDERER_INSENSITIVE as _;
193 #[doc(alias = "GTK_CELL_RENDERER_SORTED")]
194 const SORTED = ffi::GTK_CELL_RENDERER_SORTED as _;
195 #[doc(alias = "GTK_CELL_RENDERER_FOCUSED")]
196 const FOCUSED = ffi::GTK_CELL_RENDERER_FOCUSED as _;
197 #[doc(alias = "GTK_CELL_RENDERER_EXPANDABLE")]
198 const EXPANDABLE = ffi::GTK_CELL_RENDERER_EXPANDABLE as _;
199 #[doc(alias = "GTK_CELL_RENDERER_EXPANDED")]
200 const EXPANDED = ffi::GTK_CELL_RENDERER_EXPANDED as _;
201 }
202}
203
204#[allow(deprecated)]
205#[doc(hidden)]
206impl IntoGlib for CellRendererState {
207 type GlibType = ffi::GtkCellRendererState;
208
209 #[inline]
210 fn into_glib(self) -> ffi::GtkCellRendererState {
211 self.bits()
212 }
213}
214
215#[allow(deprecated)]
216#[doc(hidden)]
217impl FromGlib<ffi::GtkCellRendererState> for CellRendererState {
218 #[inline]
219 unsafe fn from_glib(value: ffi::GtkCellRendererState) -> Self {
220 skip_assert_initialized!();
221 Self::from_bits_truncate(value)
222 }
223}
224
225#[allow(deprecated)]
226impl StaticType for CellRendererState {
227 #[inline]
228 #[doc(alias = "gtk_cell_renderer_state_get_type")]
229 fn static_type() -> glib::Type {
230 unsafe { from_glib(ffi::gtk_cell_renderer_state_get_type()) }
231 }
232}
233
234#[allow(deprecated)]
235impl glib::HasParamSpec for CellRendererState {
236 type ParamSpec = glib::ParamSpecFlags;
237 type SetValue = Self;
238 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
239
240 fn param_spec_builder() -> Self::BuilderFn {
241 Self::ParamSpec::builder
242 }
243}
244
245#[allow(deprecated)]
246impl glib::value::ValueType for CellRendererState {
247 type Type = Self;
248}
249
250#[allow(deprecated)]
251unsafe impl<'a> glib::value::FromValue<'a> for CellRendererState {
252 type Checker = glib::value::GenericValueTypeChecker<Self>;
253
254 #[inline]
255 unsafe fn from_value(value: &'a glib::Value) -> Self {
256 skip_assert_initialized!();
257 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
258 }
259}
260
261#[allow(deprecated)]
262impl ToValue for CellRendererState {
263 #[inline]
264 fn to_value(&self) -> glib::Value {
265 let mut value = glib::Value::for_value_type::<Self>();
266 unsafe {
267 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
268 }
269 value
270 }
271
272 #[inline]
273 fn value_type(&self) -> glib::Type {
274 Self::static_type()
275 }
276}
277
278#[allow(deprecated)]
279impl From<CellRendererState> for glib::Value {
280 #[inline]
281 fn from(v: CellRendererState) -> Self {
282 skip_assert_initialized!();
283 ToValue::to_value(&v)
284 }
285}
286
287bitflags! {
288 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
289 #[doc(alias = "GtkDebugFlags")]
290 pub struct DebugFlags: u32 {
291 #[doc(alias = "GTK_DEBUG_TEXT")]
292 const TEXT = ffi::GTK_DEBUG_TEXT as _;
293 #[doc(alias = "GTK_DEBUG_TREE")]
294 const TREE = ffi::GTK_DEBUG_TREE as _;
295 #[doc(alias = "GTK_DEBUG_KEYBINDINGS")]
296 const KEYBINDINGS = ffi::GTK_DEBUG_KEYBINDINGS as _;
297 #[doc(alias = "GTK_DEBUG_MODULES")]
298 const MODULES = ffi::GTK_DEBUG_MODULES as _;
299 #[doc(alias = "GTK_DEBUG_GEOMETRY")]
300 const GEOMETRY = ffi::GTK_DEBUG_GEOMETRY as _;
301 #[doc(alias = "GTK_DEBUG_ICONTHEME")]
302 const ICONTHEME = ffi::GTK_DEBUG_ICONTHEME as _;
303 #[doc(alias = "GTK_DEBUG_PRINTING")]
304 const PRINTING = ffi::GTK_DEBUG_PRINTING as _;
305 #[doc(alias = "GTK_DEBUG_BUILDER_TRACE")]
306 const BUILDER_TRACE = ffi::GTK_DEBUG_BUILDER_TRACE as _;
307 #[doc(alias = "GTK_DEBUG_SIZE_REQUEST")]
308 const SIZE_REQUEST = ffi::GTK_DEBUG_SIZE_REQUEST as _;
309 #[doc(alias = "GTK_DEBUG_NO_CSS_CACHE")]
310 const NO_CSS_CACHE = ffi::GTK_DEBUG_NO_CSS_CACHE as _;
311 #[doc(alias = "GTK_DEBUG_INTERACTIVE")]
312 const INTERACTIVE = ffi::GTK_DEBUG_INTERACTIVE as _;
313 #[cfg(feature = "v4_20")]
314 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
315 #[doc(alias = "GTK_DEBUG_TOUCHSCREEN")]
316 const TOUCHSCREEN = ffi::GTK_DEBUG_TOUCHSCREEN as _;
317 #[doc(alias = "GTK_DEBUG_ACTIONS")]
318 const ACTIONS = ffi::GTK_DEBUG_ACTIONS as _;
319 #[doc(alias = "GTK_DEBUG_LAYOUT")]
320 const LAYOUT = ffi::GTK_DEBUG_LAYOUT as _;
321 #[doc(alias = "GTK_DEBUG_SNAPSHOT")]
322 const SNAPSHOT = ffi::GTK_DEBUG_SNAPSHOT as _;
323 #[doc(alias = "GTK_DEBUG_CONSTRAINTS")]
324 const CONSTRAINTS = ffi::GTK_DEBUG_CONSTRAINTS as _;
325 #[doc(alias = "GTK_DEBUG_BUILDER_OBJECTS")]
326 const BUILDER_OBJECTS = ffi::GTK_DEBUG_BUILDER_OBJECTS as _;
327 #[doc(alias = "GTK_DEBUG_A11Y")]
328 const A11Y = ffi::GTK_DEBUG_A11Y as _;
329 #[cfg(feature = "v4_2")]
330 #[cfg_attr(docsrs, doc(cfg(feature = "v4_2")))]
331 #[doc(alias = "GTK_DEBUG_ICONFALLBACK")]
332 const ICONFALLBACK = ffi::GTK_DEBUG_ICONFALLBACK as _;
333 #[cfg(feature = "v4_8")]
334 #[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
335 #[doc(alias = "GTK_DEBUG_INVERT_TEXT_DIR")]
336 const INVERT_TEXT_DIR = ffi::GTK_DEBUG_INVERT_TEXT_DIR as _;
337 #[cfg(feature = "v4_16")]
338 #[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
339 #[doc(alias = "GTK_DEBUG_CSS")]
340 const CSS = ffi::GTK_DEBUG_CSS as _;
341 #[cfg(feature = "v4_18")]
342 #[cfg_attr(docsrs, doc(cfg(feature = "v4_18")))]
343 #[doc(alias = "GTK_DEBUG_BUILDER")]
344 const BUILDER = ffi::GTK_DEBUG_BUILDER as _;
345 }
346}
347
348#[doc(hidden)]
349impl IntoGlib for DebugFlags {
350 type GlibType = ffi::GtkDebugFlags;
351
352 #[inline]
353 fn into_glib(self) -> ffi::GtkDebugFlags {
354 self.bits()
355 }
356}
357
358#[doc(hidden)]
359impl FromGlib<ffi::GtkDebugFlags> for DebugFlags {
360 #[inline]
361 unsafe fn from_glib(value: ffi::GtkDebugFlags) -> Self {
362 skip_assert_initialized!();
363 Self::from_bits_truncate(value)
364 }
365}
366
367impl StaticType for DebugFlags {
368 #[inline]
369 #[doc(alias = "gtk_debug_flags_get_type")]
370 fn static_type() -> glib::Type {
371 unsafe { from_glib(ffi::gtk_debug_flags_get_type()) }
372 }
373}
374
375impl glib::HasParamSpec for DebugFlags {
376 type ParamSpec = glib::ParamSpecFlags;
377 type SetValue = Self;
378 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
379
380 fn param_spec_builder() -> Self::BuilderFn {
381 Self::ParamSpec::builder
382 }
383}
384
385impl glib::value::ValueType for DebugFlags {
386 type Type = Self;
387}
388
389unsafe impl<'a> glib::value::FromValue<'a> for DebugFlags {
390 type Checker = glib::value::GenericValueTypeChecker<Self>;
391
392 #[inline]
393 unsafe fn from_value(value: &'a glib::Value) -> Self {
394 skip_assert_initialized!();
395 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
396 }
397}
398
399impl ToValue for DebugFlags {
400 #[inline]
401 fn to_value(&self) -> glib::Value {
402 let mut value = glib::Value::for_value_type::<Self>();
403 unsafe {
404 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
405 }
406 value
407 }
408
409 #[inline]
410 fn value_type(&self) -> glib::Type {
411 Self::static_type()
412 }
413}
414
415impl From<DebugFlags> for glib::Value {
416 #[inline]
417 fn from(v: DebugFlags) -> Self {
418 skip_assert_initialized!();
419 ToValue::to_value(&v)
420 }
421}
422
423bitflags! {
424 #[cfg_attr(feature = "v4_20", deprecated = "Since 4.20")]
425 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
426 #[doc(alias = "GtkDialogFlags")]
427 pub struct DialogFlags: u32 {
428 #[doc(alias = "GTK_DIALOG_MODAL")]
429 const MODAL = ffi::GTK_DIALOG_MODAL as _;
430 #[doc(alias = "GTK_DIALOG_DESTROY_WITH_PARENT")]
431 const DESTROY_WITH_PARENT = ffi::GTK_DIALOG_DESTROY_WITH_PARENT as _;
432 #[doc(alias = "GTK_DIALOG_USE_HEADER_BAR")]
433 const USE_HEADER_BAR = ffi::GTK_DIALOG_USE_HEADER_BAR as _;
434 }
435}
436
437#[allow(deprecated)]
438#[doc(hidden)]
439impl IntoGlib for DialogFlags {
440 type GlibType = ffi::GtkDialogFlags;
441
442 #[inline]
443 fn into_glib(self) -> ffi::GtkDialogFlags {
444 self.bits()
445 }
446}
447
448#[allow(deprecated)]
449#[doc(hidden)]
450impl FromGlib<ffi::GtkDialogFlags> for DialogFlags {
451 #[inline]
452 unsafe fn from_glib(value: ffi::GtkDialogFlags) -> Self {
453 skip_assert_initialized!();
454 Self::from_bits_truncate(value)
455 }
456}
457
458#[allow(deprecated)]
459impl StaticType for DialogFlags {
460 #[inline]
461 #[doc(alias = "gtk_dialog_flags_get_type")]
462 fn static_type() -> glib::Type {
463 unsafe { from_glib(ffi::gtk_dialog_flags_get_type()) }
464 }
465}
466
467#[allow(deprecated)]
468impl glib::HasParamSpec for DialogFlags {
469 type ParamSpec = glib::ParamSpecFlags;
470 type SetValue = Self;
471 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
472
473 fn param_spec_builder() -> Self::BuilderFn {
474 Self::ParamSpec::builder
475 }
476}
477
478#[allow(deprecated)]
479impl glib::value::ValueType for DialogFlags {
480 type Type = Self;
481}
482
483#[allow(deprecated)]
484unsafe impl<'a> glib::value::FromValue<'a> for DialogFlags {
485 type Checker = glib::value::GenericValueTypeChecker<Self>;
486
487 #[inline]
488 unsafe fn from_value(value: &'a glib::Value) -> Self {
489 skip_assert_initialized!();
490 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
491 }
492}
493
494#[allow(deprecated)]
495impl ToValue for DialogFlags {
496 #[inline]
497 fn to_value(&self) -> glib::Value {
498 let mut value = glib::Value::for_value_type::<Self>();
499 unsafe {
500 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
501 }
502 value
503 }
504
505 #[inline]
506 fn value_type(&self) -> glib::Type {
507 Self::static_type()
508 }
509}
510
511#[allow(deprecated)]
512impl From<DialogFlags> for glib::Value {
513 #[inline]
514 fn from(v: DialogFlags) -> Self {
515 skip_assert_initialized!();
516 ToValue::to_value(&v)
517 }
518}
519
520bitflags! {
521 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
522 #[doc(alias = "GtkEventControllerScrollFlags")]
523 pub struct EventControllerScrollFlags: u32 {
524 #[doc(alias = "GTK_EVENT_CONTROLLER_SCROLL_NONE")]
525 const NONE = ffi::GTK_EVENT_CONTROLLER_SCROLL_NONE as _;
526 #[doc(alias = "GTK_EVENT_CONTROLLER_SCROLL_VERTICAL")]
527 const VERTICAL = ffi::GTK_EVENT_CONTROLLER_SCROLL_VERTICAL as _;
528 #[doc(alias = "GTK_EVENT_CONTROLLER_SCROLL_HORIZONTAL")]
529 const HORIZONTAL = ffi::GTK_EVENT_CONTROLLER_SCROLL_HORIZONTAL as _;
530 #[doc(alias = "GTK_EVENT_CONTROLLER_SCROLL_DISCRETE")]
531 const DISCRETE = ffi::GTK_EVENT_CONTROLLER_SCROLL_DISCRETE as _;
532 #[doc(alias = "GTK_EVENT_CONTROLLER_SCROLL_KINETIC")]
533 const KINETIC = ffi::GTK_EVENT_CONTROLLER_SCROLL_KINETIC as _;
534 #[cfg(feature = "v4_20")]
535 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
536 #[doc(alias = "GTK_EVENT_CONTROLLER_SCROLL_PHYSICAL_DIRECTION")]
537 const PHYSICAL_DIRECTION = ffi::GTK_EVENT_CONTROLLER_SCROLL_PHYSICAL_DIRECTION as _;
538 #[doc(alias = "GTK_EVENT_CONTROLLER_SCROLL_BOTH_AXES")]
539 const BOTH_AXES = ffi::GTK_EVENT_CONTROLLER_SCROLL_BOTH_AXES as _;
540 }
541}
542
543#[doc(hidden)]
544impl IntoGlib for EventControllerScrollFlags {
545 type GlibType = ffi::GtkEventControllerScrollFlags;
546
547 #[inline]
548 fn into_glib(self) -> ffi::GtkEventControllerScrollFlags {
549 self.bits()
550 }
551}
552
553#[doc(hidden)]
554impl FromGlib<ffi::GtkEventControllerScrollFlags> for EventControllerScrollFlags {
555 #[inline]
556 unsafe fn from_glib(value: ffi::GtkEventControllerScrollFlags) -> Self {
557 skip_assert_initialized!();
558 Self::from_bits_truncate(value)
559 }
560}
561
562impl StaticType for EventControllerScrollFlags {
563 #[inline]
564 #[doc(alias = "gtk_event_controller_scroll_flags_get_type")]
565 fn static_type() -> glib::Type {
566 unsafe { from_glib(ffi::gtk_event_controller_scroll_flags_get_type()) }
567 }
568}
569
570impl glib::HasParamSpec for EventControllerScrollFlags {
571 type ParamSpec = glib::ParamSpecFlags;
572 type SetValue = Self;
573 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
574
575 fn param_spec_builder() -> Self::BuilderFn {
576 Self::ParamSpec::builder
577 }
578}
579
580impl glib::value::ValueType for EventControllerScrollFlags {
581 type Type = Self;
582}
583
584unsafe impl<'a> glib::value::FromValue<'a> for EventControllerScrollFlags {
585 type Checker = glib::value::GenericValueTypeChecker<Self>;
586
587 #[inline]
588 unsafe fn from_value(value: &'a glib::Value) -> Self {
589 skip_assert_initialized!();
590 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
591 }
592}
593
594impl ToValue for EventControllerScrollFlags {
595 #[inline]
596 fn to_value(&self) -> glib::Value {
597 let mut value = glib::Value::for_value_type::<Self>();
598 unsafe {
599 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
600 }
601 value
602 }
603
604 #[inline]
605 fn value_type(&self) -> glib::Type {
606 Self::static_type()
607 }
608}
609
610impl From<EventControllerScrollFlags> for glib::Value {
611 #[inline]
612 fn from(v: EventControllerScrollFlags) -> Self {
613 skip_assert_initialized!();
614 ToValue::to_value(&v)
615 }
616}
617
618bitflags! {
619 #[cfg_attr(feature = "v4_20", deprecated = "Since 4.20")]
620 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
621 #[doc(alias = "GtkFontChooserLevel")]
622 pub struct FontChooserLevel: u32 {
623 #[doc(alias = "GTK_FONT_CHOOSER_LEVEL_FAMILY")]
624 const FAMILY = ffi::GTK_FONT_CHOOSER_LEVEL_FAMILY as _;
625 #[doc(alias = "GTK_FONT_CHOOSER_LEVEL_STYLE")]
626 const STYLE = ffi::GTK_FONT_CHOOSER_LEVEL_STYLE as _;
627 #[doc(alias = "GTK_FONT_CHOOSER_LEVEL_SIZE")]
628 const SIZE = ffi::GTK_FONT_CHOOSER_LEVEL_SIZE as _;
629 #[doc(alias = "GTK_FONT_CHOOSER_LEVEL_VARIATIONS")]
630 const VARIATIONS = ffi::GTK_FONT_CHOOSER_LEVEL_VARIATIONS as _;
631 #[doc(alias = "GTK_FONT_CHOOSER_LEVEL_FEATURES")]
632 const FEATURES = ffi::GTK_FONT_CHOOSER_LEVEL_FEATURES as _;
633 }
634}
635
636#[allow(deprecated)]
637#[doc(hidden)]
638impl IntoGlib for FontChooserLevel {
639 type GlibType = ffi::GtkFontChooserLevel;
640
641 #[inline]
642 fn into_glib(self) -> ffi::GtkFontChooserLevel {
643 self.bits()
644 }
645}
646
647#[allow(deprecated)]
648#[doc(hidden)]
649impl FromGlib<ffi::GtkFontChooserLevel> for FontChooserLevel {
650 #[inline]
651 unsafe fn from_glib(value: ffi::GtkFontChooserLevel) -> Self {
652 skip_assert_initialized!();
653 Self::from_bits_truncate(value)
654 }
655}
656
657#[allow(deprecated)]
658impl StaticType for FontChooserLevel {
659 #[inline]
660 #[doc(alias = "gtk_font_chooser_level_get_type")]
661 fn static_type() -> glib::Type {
662 unsafe { from_glib(ffi::gtk_font_chooser_level_get_type()) }
663 }
664}
665
666#[allow(deprecated)]
667impl glib::HasParamSpec for FontChooserLevel {
668 type ParamSpec = glib::ParamSpecFlags;
669 type SetValue = Self;
670 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
671
672 fn param_spec_builder() -> Self::BuilderFn {
673 Self::ParamSpec::builder
674 }
675}
676
677#[allow(deprecated)]
678impl glib::value::ValueType for FontChooserLevel {
679 type Type = Self;
680}
681
682#[allow(deprecated)]
683unsafe impl<'a> glib::value::FromValue<'a> for FontChooserLevel {
684 type Checker = glib::value::GenericValueTypeChecker<Self>;
685
686 #[inline]
687 unsafe fn from_value(value: &'a glib::Value) -> Self {
688 skip_assert_initialized!();
689 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
690 }
691}
692
693#[allow(deprecated)]
694impl ToValue for FontChooserLevel {
695 #[inline]
696 fn to_value(&self) -> glib::Value {
697 let mut value = glib::Value::for_value_type::<Self>();
698 unsafe {
699 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
700 }
701 value
702 }
703
704 #[inline]
705 fn value_type(&self) -> glib::Type {
706 Self::static_type()
707 }
708}
709
710#[allow(deprecated)]
711impl From<FontChooserLevel> for glib::Value {
712 #[inline]
713 fn from(v: FontChooserLevel) -> Self {
714 skip_assert_initialized!();
715 ToValue::to_value(&v)
716 }
717}
718
719bitflags! {
720 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
721 #[doc(alias = "GtkIconLookupFlags")]
722 pub struct IconLookupFlags: u32 {
723 #[cfg(feature = "v4_18")]
724 #[cfg_attr(docsrs, doc(cfg(feature = "v4_18")))]
725 #[doc(alias = "GTK_ICON_LOOKUP_NONE")]
726 const NONE = ffi::GTK_ICON_LOOKUP_NONE as _;
727 #[doc(alias = "GTK_ICON_LOOKUP_FORCE_REGULAR")]
728 const FORCE_REGULAR = ffi::GTK_ICON_LOOKUP_FORCE_REGULAR as _;
729 #[doc(alias = "GTK_ICON_LOOKUP_FORCE_SYMBOLIC")]
730 const FORCE_SYMBOLIC = ffi::GTK_ICON_LOOKUP_FORCE_SYMBOLIC as _;
731 #[doc(alias = "GTK_ICON_LOOKUP_PRELOAD")]
732 const PRELOAD = ffi::GTK_ICON_LOOKUP_PRELOAD as _;
733 }
734}
735
736#[doc(hidden)]
737impl IntoGlib for IconLookupFlags {
738 type GlibType = ffi::GtkIconLookupFlags;
739
740 #[inline]
741 fn into_glib(self) -> ffi::GtkIconLookupFlags {
742 self.bits()
743 }
744}
745
746#[doc(hidden)]
747impl FromGlib<ffi::GtkIconLookupFlags> for IconLookupFlags {
748 #[inline]
749 unsafe fn from_glib(value: ffi::GtkIconLookupFlags) -> Self {
750 skip_assert_initialized!();
751 Self::from_bits_truncate(value)
752 }
753}
754
755impl StaticType for IconLookupFlags {
756 #[inline]
757 #[doc(alias = "gtk_icon_lookup_flags_get_type")]
758 fn static_type() -> glib::Type {
759 unsafe { from_glib(ffi::gtk_icon_lookup_flags_get_type()) }
760 }
761}
762
763impl glib::HasParamSpec for IconLookupFlags {
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 Self::ParamSpec::builder
770 }
771}
772
773impl glib::value::ValueType for IconLookupFlags {
774 type Type = Self;
775}
776
777unsafe impl<'a> glib::value::FromValue<'a> for IconLookupFlags {
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 IconLookupFlags {
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<IconLookupFlags> for glib::Value {
804 #[inline]
805 fn from(v: IconLookupFlags) -> 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 = "GtkInputHints")]
814 pub struct InputHints: u32 {
815 #[doc(alias = "GTK_INPUT_HINT_NONE")]
816 const NONE = ffi::GTK_INPUT_HINT_NONE as _;
817 #[doc(alias = "GTK_INPUT_HINT_SPELLCHECK")]
818 const SPELLCHECK = ffi::GTK_INPUT_HINT_SPELLCHECK as _;
819 #[doc(alias = "GTK_INPUT_HINT_NO_SPELLCHECK")]
820 const NO_SPELLCHECK = ffi::GTK_INPUT_HINT_NO_SPELLCHECK as _;
821 #[doc(alias = "GTK_INPUT_HINT_WORD_COMPLETION")]
822 const WORD_COMPLETION = ffi::GTK_INPUT_HINT_WORD_COMPLETION as _;
823 #[doc(alias = "GTK_INPUT_HINT_LOWERCASE")]
824 const LOWERCASE = ffi::GTK_INPUT_HINT_LOWERCASE as _;
825 #[doc(alias = "GTK_INPUT_HINT_UPPERCASE_CHARS")]
826 const UPPERCASE_CHARS = ffi::GTK_INPUT_HINT_UPPERCASE_CHARS as _;
827 #[doc(alias = "GTK_INPUT_HINT_UPPERCASE_WORDS")]
828 const UPPERCASE_WORDS = ffi::GTK_INPUT_HINT_UPPERCASE_WORDS as _;
829 #[doc(alias = "GTK_INPUT_HINT_UPPERCASE_SENTENCES")]
830 const UPPERCASE_SENTENCES = ffi::GTK_INPUT_HINT_UPPERCASE_SENTENCES as _;
831 #[doc(alias = "GTK_INPUT_HINT_INHIBIT_OSK")]
832 const INHIBIT_OSK = ffi::GTK_INPUT_HINT_INHIBIT_OSK as _;
833 #[doc(alias = "GTK_INPUT_HINT_VERTICAL_WRITING")]
834 const VERTICAL_WRITING = ffi::GTK_INPUT_HINT_VERTICAL_WRITING as _;
835 #[doc(alias = "GTK_INPUT_HINT_EMOJI")]
836 const EMOJI = ffi::GTK_INPUT_HINT_EMOJI as _;
837 #[doc(alias = "GTK_INPUT_HINT_NO_EMOJI")]
838 const NO_EMOJI = ffi::GTK_INPUT_HINT_NO_EMOJI as _;
839 #[doc(alias = "GTK_INPUT_HINT_PRIVATE")]
840 const PRIVATE = ffi::GTK_INPUT_HINT_PRIVATE as _;
841 }
842}
843
844#[doc(hidden)]
845impl IntoGlib for InputHints {
846 type GlibType = ffi::GtkInputHints;
847
848 #[inline]
849 fn into_glib(self) -> ffi::GtkInputHints {
850 self.bits()
851 }
852}
853
854#[doc(hidden)]
855impl FromGlib<ffi::GtkInputHints> for InputHints {
856 #[inline]
857 unsafe fn from_glib(value: ffi::GtkInputHints) -> Self {
858 skip_assert_initialized!();
859 Self::from_bits_truncate(value)
860 }
861}
862
863impl StaticType for InputHints {
864 #[inline]
865 #[doc(alias = "gtk_input_hints_get_type")]
866 fn static_type() -> glib::Type {
867 unsafe { from_glib(ffi::gtk_input_hints_get_type()) }
868 }
869}
870
871impl glib::HasParamSpec for InputHints {
872 type ParamSpec = glib::ParamSpecFlags;
873 type SetValue = Self;
874 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
875
876 fn param_spec_builder() -> Self::BuilderFn {
877 Self::ParamSpec::builder
878 }
879}
880
881impl glib::value::ValueType for InputHints {
882 type Type = Self;
883}
884
885unsafe impl<'a> glib::value::FromValue<'a> for InputHints {
886 type Checker = glib::value::GenericValueTypeChecker<Self>;
887
888 #[inline]
889 unsafe fn from_value(value: &'a glib::Value) -> Self {
890 skip_assert_initialized!();
891 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
892 }
893}
894
895impl ToValue for InputHints {
896 #[inline]
897 fn to_value(&self) -> glib::Value {
898 let mut value = glib::Value::for_value_type::<Self>();
899 unsafe {
900 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
901 }
902 value
903 }
904
905 #[inline]
906 fn value_type(&self) -> glib::Type {
907 Self::static_type()
908 }
909}
910
911impl From<InputHints> for glib::Value {
912 #[inline]
913 fn from(v: InputHints) -> Self {
914 skip_assert_initialized!();
915 ToValue::to_value(&v)
916 }
917}
918
919#[cfg(feature = "v4_12")]
920bitflags! {
921 #[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
922 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
923 #[doc(alias = "GtkListScrollFlags")]
924 pub struct ListScrollFlags: u32 {
925 #[doc(alias = "GTK_LIST_SCROLL_NONE")]
926 const NONE = ffi::GTK_LIST_SCROLL_NONE as _;
927 #[doc(alias = "GTK_LIST_SCROLL_FOCUS")]
928 const FOCUS = ffi::GTK_LIST_SCROLL_FOCUS as _;
929 #[doc(alias = "GTK_LIST_SCROLL_SELECT")]
930 const SELECT = ffi::GTK_LIST_SCROLL_SELECT as _;
931 }
932}
933
934#[cfg(feature = "v4_12")]
935#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
936#[doc(hidden)]
937impl IntoGlib for ListScrollFlags {
938 type GlibType = ffi::GtkListScrollFlags;
939
940 #[inline]
941 fn into_glib(self) -> ffi::GtkListScrollFlags {
942 self.bits()
943 }
944}
945
946#[cfg(feature = "v4_12")]
947#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
948#[doc(hidden)]
949impl FromGlib<ffi::GtkListScrollFlags> for ListScrollFlags {
950 #[inline]
951 unsafe fn from_glib(value: ffi::GtkListScrollFlags) -> Self {
952 skip_assert_initialized!();
953 Self::from_bits_truncate(value)
954 }
955}
956
957#[cfg(feature = "v4_12")]
958#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
959impl StaticType for ListScrollFlags {
960 #[inline]
961 #[doc(alias = "gtk_list_scroll_flags_get_type")]
962 fn static_type() -> glib::Type {
963 unsafe { from_glib(ffi::gtk_list_scroll_flags_get_type()) }
964 }
965}
966
967#[cfg(feature = "v4_12")]
968#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
969impl glib::HasParamSpec for ListScrollFlags {
970 type ParamSpec = glib::ParamSpecFlags;
971 type SetValue = Self;
972 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
973
974 fn param_spec_builder() -> Self::BuilderFn {
975 Self::ParamSpec::builder
976 }
977}
978
979#[cfg(feature = "v4_12")]
980#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
981impl glib::value::ValueType for ListScrollFlags {
982 type Type = Self;
983}
984
985#[cfg(feature = "v4_12")]
986#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
987unsafe impl<'a> glib::value::FromValue<'a> for ListScrollFlags {
988 type Checker = glib::value::GenericValueTypeChecker<Self>;
989
990 #[inline]
991 unsafe fn from_value(value: &'a glib::Value) -> Self {
992 skip_assert_initialized!();
993 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
994 }
995}
996
997#[cfg(feature = "v4_12")]
998#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
999impl ToValue for ListScrollFlags {
1000 #[inline]
1001 fn to_value(&self) -> glib::Value {
1002 let mut value = glib::Value::for_value_type::<Self>();
1003 unsafe {
1004 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1005 }
1006 value
1007 }
1008
1009 #[inline]
1010 fn value_type(&self) -> glib::Type {
1011 Self::static_type()
1012 }
1013}
1014
1015#[cfg(feature = "v4_12")]
1016#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
1017impl From<ListScrollFlags> for glib::Value {
1018 #[inline]
1019 fn from(v: ListScrollFlags) -> Self {
1020 skip_assert_initialized!();
1021 ToValue::to_value(&v)
1022 }
1023}
1024
1025bitflags! {
1026 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1027 #[doc(alias = "GtkPickFlags")]
1028 pub struct PickFlags: u32 {
1029 #[doc(alias = "GTK_PICK_DEFAULT")]
1030 const DEFAULT = ffi::GTK_PICK_DEFAULT as _;
1031 #[doc(alias = "GTK_PICK_INSENSITIVE")]
1032 const INSENSITIVE = ffi::GTK_PICK_INSENSITIVE as _;
1033 #[doc(alias = "GTK_PICK_NON_TARGETABLE")]
1034 const NON_TARGETABLE = ffi::GTK_PICK_NON_TARGETABLE as _;
1035 }
1036}
1037
1038#[doc(hidden)]
1039impl IntoGlib for PickFlags {
1040 type GlibType = ffi::GtkPickFlags;
1041
1042 #[inline]
1043 fn into_glib(self) -> ffi::GtkPickFlags {
1044 self.bits()
1045 }
1046}
1047
1048#[doc(hidden)]
1049impl FromGlib<ffi::GtkPickFlags> for PickFlags {
1050 #[inline]
1051 unsafe fn from_glib(value: ffi::GtkPickFlags) -> Self {
1052 skip_assert_initialized!();
1053 Self::from_bits_truncate(value)
1054 }
1055}
1056
1057impl StaticType for PickFlags {
1058 #[inline]
1059 #[doc(alias = "gtk_pick_flags_get_type")]
1060 fn static_type() -> glib::Type {
1061 unsafe { from_glib(ffi::gtk_pick_flags_get_type()) }
1062 }
1063}
1064
1065impl glib::HasParamSpec for PickFlags {
1066 type ParamSpec = glib::ParamSpecFlags;
1067 type SetValue = Self;
1068 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1069
1070 fn param_spec_builder() -> Self::BuilderFn {
1071 Self::ParamSpec::builder
1072 }
1073}
1074
1075impl glib::value::ValueType for PickFlags {
1076 type Type = Self;
1077}
1078
1079unsafe impl<'a> glib::value::FromValue<'a> for PickFlags {
1080 type Checker = glib::value::GenericValueTypeChecker<Self>;
1081
1082 #[inline]
1083 unsafe fn from_value(value: &'a glib::Value) -> Self {
1084 skip_assert_initialized!();
1085 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1086 }
1087}
1088
1089impl ToValue for PickFlags {
1090 #[inline]
1091 fn to_value(&self) -> glib::Value {
1092 let mut value = glib::Value::for_value_type::<Self>();
1093 unsafe {
1094 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1095 }
1096 value
1097 }
1098
1099 #[inline]
1100 fn value_type(&self) -> glib::Type {
1101 Self::static_type()
1102 }
1103}
1104
1105impl From<PickFlags> for glib::Value {
1106 #[inline]
1107 fn from(v: PickFlags) -> Self {
1108 skip_assert_initialized!();
1109 ToValue::to_value(&v)
1110 }
1111}
1112
1113bitflags! {
1114 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1115 #[doc(alias = "GtkPopoverMenuFlags")]
1116 pub struct PopoverMenuFlags: u32 {
1117 #[cfg(feature = "v4_14")]
1118 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1119 #[doc(alias = "GTK_POPOVER_MENU_SLIDING")]
1120 const SLIDING = ffi::GTK_POPOVER_MENU_SLIDING as _;
1121 #[doc(alias = "GTK_POPOVER_MENU_NESTED")]
1122 const NESTED = ffi::GTK_POPOVER_MENU_NESTED as _;
1123 }
1124}
1125
1126#[doc(hidden)]
1127impl IntoGlib for PopoverMenuFlags {
1128 type GlibType = ffi::GtkPopoverMenuFlags;
1129
1130 #[inline]
1131 fn into_glib(self) -> ffi::GtkPopoverMenuFlags {
1132 self.bits()
1133 }
1134}
1135
1136#[doc(hidden)]
1137impl FromGlib<ffi::GtkPopoverMenuFlags> for PopoverMenuFlags {
1138 #[inline]
1139 unsafe fn from_glib(value: ffi::GtkPopoverMenuFlags) -> Self {
1140 skip_assert_initialized!();
1141 Self::from_bits_truncate(value)
1142 }
1143}
1144
1145impl StaticType for PopoverMenuFlags {
1146 #[inline]
1147 #[doc(alias = "gtk_popover_menu_flags_get_type")]
1148 fn static_type() -> glib::Type {
1149 unsafe { from_glib(ffi::gtk_popover_menu_flags_get_type()) }
1150 }
1151}
1152
1153impl glib::HasParamSpec for PopoverMenuFlags {
1154 type ParamSpec = glib::ParamSpecFlags;
1155 type SetValue = Self;
1156 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1157
1158 fn param_spec_builder() -> Self::BuilderFn {
1159 Self::ParamSpec::builder
1160 }
1161}
1162
1163impl glib::value::ValueType for PopoverMenuFlags {
1164 type Type = Self;
1165}
1166
1167unsafe impl<'a> glib::value::FromValue<'a> for PopoverMenuFlags {
1168 type Checker = glib::value::GenericValueTypeChecker<Self>;
1169
1170 #[inline]
1171 unsafe fn from_value(value: &'a glib::Value) -> Self {
1172 skip_assert_initialized!();
1173 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1174 }
1175}
1176
1177impl ToValue for PopoverMenuFlags {
1178 #[inline]
1179 fn to_value(&self) -> glib::Value {
1180 let mut value = glib::Value::for_value_type::<Self>();
1181 unsafe {
1182 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1183 }
1184 value
1185 }
1186
1187 #[inline]
1188 fn value_type(&self) -> glib::Type {
1189 Self::static_type()
1190 }
1191}
1192
1193impl From<PopoverMenuFlags> for glib::Value {
1194 #[inline]
1195 fn from(v: PopoverMenuFlags) -> Self {
1196 skip_assert_initialized!();
1197 ToValue::to_value(&v)
1198 }
1199}
1200
1201#[cfg(target_os = "linux")]
1202bitflags! {
1203 #[cfg_attr(docsrs, doc(cfg(target_os = "linux")))]
1204 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1205 #[doc(alias = "GtkPrintCapabilities")]
1206 pub struct PrintCapabilities: u32 {
1207 #[doc(alias = "GTK_PRINT_CAPABILITY_PAGE_SET")]
1208 const PAGE_SET = ffi::GTK_PRINT_CAPABILITY_PAGE_SET as _;
1209 #[doc(alias = "GTK_PRINT_CAPABILITY_COPIES")]
1210 const COPIES = ffi::GTK_PRINT_CAPABILITY_COPIES as _;
1211 #[doc(alias = "GTK_PRINT_CAPABILITY_COLLATE")]
1212 const COLLATE = ffi::GTK_PRINT_CAPABILITY_COLLATE as _;
1213 #[doc(alias = "GTK_PRINT_CAPABILITY_REVERSE")]
1214 const REVERSE = ffi::GTK_PRINT_CAPABILITY_REVERSE as _;
1215 #[doc(alias = "GTK_PRINT_CAPABILITY_SCALE")]
1216 const SCALE = ffi::GTK_PRINT_CAPABILITY_SCALE as _;
1217 #[doc(alias = "GTK_PRINT_CAPABILITY_GENERATE_PDF")]
1218 const GENERATE_PDF = ffi::GTK_PRINT_CAPABILITY_GENERATE_PDF as _;
1219 #[doc(alias = "GTK_PRINT_CAPABILITY_GENERATE_PS")]
1220 const GENERATE_PS = ffi::GTK_PRINT_CAPABILITY_GENERATE_PS as _;
1221 #[doc(alias = "GTK_PRINT_CAPABILITY_PREVIEW")]
1222 const PREVIEW = ffi::GTK_PRINT_CAPABILITY_PREVIEW as _;
1223 #[doc(alias = "GTK_PRINT_CAPABILITY_NUMBER_UP")]
1224 const NUMBER_UP = ffi::GTK_PRINT_CAPABILITY_NUMBER_UP as _;
1225 #[doc(alias = "GTK_PRINT_CAPABILITY_NUMBER_UP_LAYOUT")]
1226 const NUMBER_UP_LAYOUT = ffi::GTK_PRINT_CAPABILITY_NUMBER_UP_LAYOUT as _;
1227 }
1228}
1229
1230#[cfg(target_os = "linux")]
1231#[doc(hidden)]
1232impl IntoGlib for PrintCapabilities {
1233 type GlibType = ffi::GtkPrintCapabilities;
1234
1235 #[inline]
1236 fn into_glib(self) -> ffi::GtkPrintCapabilities {
1237 self.bits()
1238 }
1239}
1240
1241#[cfg(target_os = "linux")]
1242#[doc(hidden)]
1243impl FromGlib<ffi::GtkPrintCapabilities> for PrintCapabilities {
1244 #[inline]
1245 unsafe fn from_glib(value: ffi::GtkPrintCapabilities) -> Self {
1246 skip_assert_initialized!();
1247 Self::from_bits_truncate(value)
1248 }
1249}
1250
1251#[cfg(target_os = "linux")]
1252impl StaticType for PrintCapabilities {
1253 #[inline]
1254 #[doc(alias = "gtk_print_capabilities_get_type")]
1255 fn static_type() -> glib::Type {
1256 unsafe { from_glib(ffi::gtk_print_capabilities_get_type()) }
1257 }
1258}
1259
1260#[cfg(target_os = "linux")]
1261impl glib::HasParamSpec for PrintCapabilities {
1262 type ParamSpec = glib::ParamSpecFlags;
1263 type SetValue = Self;
1264 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1265
1266 fn param_spec_builder() -> Self::BuilderFn {
1267 Self::ParamSpec::builder
1268 }
1269}
1270
1271#[cfg(target_os = "linux")]
1272impl glib::value::ValueType for PrintCapabilities {
1273 type Type = Self;
1274}
1275
1276#[cfg(target_os = "linux")]
1277unsafe impl<'a> glib::value::FromValue<'a> for PrintCapabilities {
1278 type Checker = glib::value::GenericValueTypeChecker<Self>;
1279
1280 #[inline]
1281 unsafe fn from_value(value: &'a glib::Value) -> Self {
1282 skip_assert_initialized!();
1283 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1284 }
1285}
1286
1287#[cfg(target_os = "linux")]
1288impl ToValue for PrintCapabilities {
1289 #[inline]
1290 fn to_value(&self) -> glib::Value {
1291 let mut value = glib::Value::for_value_type::<Self>();
1292 unsafe {
1293 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1294 }
1295 value
1296 }
1297
1298 #[inline]
1299 fn value_type(&self) -> glib::Type {
1300 Self::static_type()
1301 }
1302}
1303
1304#[cfg(target_os = "linux")]
1305impl From<PrintCapabilities> for glib::Value {
1306 #[inline]
1307 fn from(v: PrintCapabilities) -> Self {
1308 skip_assert_initialized!();
1309 ToValue::to_value(&v)
1310 }
1311}
1312
1313bitflags! {
1314 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1315 #[doc(alias = "GtkShortcutActionFlags")]
1316 pub struct ShortcutActionFlags: u32 {
1317 #[doc(alias = "GTK_SHORTCUT_ACTION_EXCLUSIVE")]
1318 const EXCLUSIVE = ffi::GTK_SHORTCUT_ACTION_EXCLUSIVE as _;
1319 }
1320}
1321
1322#[doc(hidden)]
1323impl IntoGlib for ShortcutActionFlags {
1324 type GlibType = ffi::GtkShortcutActionFlags;
1325
1326 #[inline]
1327 fn into_glib(self) -> ffi::GtkShortcutActionFlags {
1328 self.bits()
1329 }
1330}
1331
1332#[doc(hidden)]
1333impl FromGlib<ffi::GtkShortcutActionFlags> for ShortcutActionFlags {
1334 #[inline]
1335 unsafe fn from_glib(value: ffi::GtkShortcutActionFlags) -> Self {
1336 skip_assert_initialized!();
1337 Self::from_bits_truncate(value)
1338 }
1339}
1340
1341impl StaticType for ShortcutActionFlags {
1342 #[inline]
1343 #[doc(alias = "gtk_shortcut_action_flags_get_type")]
1344 fn static_type() -> glib::Type {
1345 unsafe { from_glib(ffi::gtk_shortcut_action_flags_get_type()) }
1346 }
1347}
1348
1349impl glib::HasParamSpec for ShortcutActionFlags {
1350 type ParamSpec = glib::ParamSpecFlags;
1351 type SetValue = Self;
1352 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1353
1354 fn param_spec_builder() -> Self::BuilderFn {
1355 Self::ParamSpec::builder
1356 }
1357}
1358
1359impl glib::value::ValueType for ShortcutActionFlags {
1360 type Type = Self;
1361}
1362
1363unsafe impl<'a> glib::value::FromValue<'a> for ShortcutActionFlags {
1364 type Checker = glib::value::GenericValueTypeChecker<Self>;
1365
1366 #[inline]
1367 unsafe fn from_value(value: &'a glib::Value) -> Self {
1368 skip_assert_initialized!();
1369 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1370 }
1371}
1372
1373impl ToValue for ShortcutActionFlags {
1374 #[inline]
1375 fn to_value(&self) -> glib::Value {
1376 let mut value = glib::Value::for_value_type::<Self>();
1377 unsafe {
1378 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1379 }
1380 value
1381 }
1382
1383 #[inline]
1384 fn value_type(&self) -> glib::Type {
1385 Self::static_type()
1386 }
1387}
1388
1389impl From<ShortcutActionFlags> for glib::Value {
1390 #[inline]
1391 fn from(v: ShortcutActionFlags) -> Self {
1392 skip_assert_initialized!();
1393 ToValue::to_value(&v)
1394 }
1395}
1396
1397bitflags! {
1398 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1399 #[doc(alias = "GtkStateFlags")]
1400 pub struct StateFlags: u32 {
1401 #[doc(alias = "GTK_STATE_FLAG_NORMAL")]
1402 const NORMAL = ffi::GTK_STATE_FLAG_NORMAL as _;
1403 #[doc(alias = "GTK_STATE_FLAG_ACTIVE")]
1404 const ACTIVE = ffi::GTK_STATE_FLAG_ACTIVE as _;
1405 #[doc(alias = "GTK_STATE_FLAG_PRELIGHT")]
1406 const PRELIGHT = ffi::GTK_STATE_FLAG_PRELIGHT as _;
1407 #[doc(alias = "GTK_STATE_FLAG_SELECTED")]
1408 const SELECTED = ffi::GTK_STATE_FLAG_SELECTED as _;
1409 #[doc(alias = "GTK_STATE_FLAG_INSENSITIVE")]
1410 const INSENSITIVE = ffi::GTK_STATE_FLAG_INSENSITIVE as _;
1411 #[doc(alias = "GTK_STATE_FLAG_INCONSISTENT")]
1412 const INCONSISTENT = ffi::GTK_STATE_FLAG_INCONSISTENT as _;
1413 #[doc(alias = "GTK_STATE_FLAG_FOCUSED")]
1414 const FOCUSED = ffi::GTK_STATE_FLAG_FOCUSED as _;
1415 #[doc(alias = "GTK_STATE_FLAG_BACKDROP")]
1416 const BACKDROP = ffi::GTK_STATE_FLAG_BACKDROP as _;
1417 #[doc(alias = "GTK_STATE_FLAG_DIR_LTR")]
1418 const DIR_LTR = ffi::GTK_STATE_FLAG_DIR_LTR as _;
1419 #[doc(alias = "GTK_STATE_FLAG_DIR_RTL")]
1420 const DIR_RTL = ffi::GTK_STATE_FLAG_DIR_RTL as _;
1421 #[doc(alias = "GTK_STATE_FLAG_LINK")]
1422 const LINK = ffi::GTK_STATE_FLAG_LINK as _;
1423 #[doc(alias = "GTK_STATE_FLAG_VISITED")]
1424 const VISITED = ffi::GTK_STATE_FLAG_VISITED as _;
1425 #[doc(alias = "GTK_STATE_FLAG_CHECKED")]
1426 const CHECKED = ffi::GTK_STATE_FLAG_CHECKED as _;
1427 #[doc(alias = "GTK_STATE_FLAG_DROP_ACTIVE")]
1428 const DROP_ACTIVE = ffi::GTK_STATE_FLAG_DROP_ACTIVE as _;
1429 #[doc(alias = "GTK_STATE_FLAG_FOCUS_VISIBLE")]
1430 const FOCUS_VISIBLE = ffi::GTK_STATE_FLAG_FOCUS_VISIBLE as _;
1431 #[doc(alias = "GTK_STATE_FLAG_FOCUS_WITHIN")]
1432 const FOCUS_WITHIN = ffi::GTK_STATE_FLAG_FOCUS_WITHIN as _;
1433 }
1434}
1435
1436#[doc(hidden)]
1437impl IntoGlib for StateFlags {
1438 type GlibType = ffi::GtkStateFlags;
1439
1440 #[inline]
1441 fn into_glib(self) -> ffi::GtkStateFlags {
1442 self.bits()
1443 }
1444}
1445
1446#[doc(hidden)]
1447impl FromGlib<ffi::GtkStateFlags> for StateFlags {
1448 #[inline]
1449 unsafe fn from_glib(value: ffi::GtkStateFlags) -> Self {
1450 skip_assert_initialized!();
1451 Self::from_bits_truncate(value)
1452 }
1453}
1454
1455impl StaticType for StateFlags {
1456 #[inline]
1457 #[doc(alias = "gtk_state_flags_get_type")]
1458 fn static_type() -> glib::Type {
1459 unsafe { from_glib(ffi::gtk_state_flags_get_type()) }
1460 }
1461}
1462
1463impl glib::HasParamSpec for StateFlags {
1464 type ParamSpec = glib::ParamSpecFlags;
1465 type SetValue = Self;
1466 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1467
1468 fn param_spec_builder() -> Self::BuilderFn {
1469 Self::ParamSpec::builder
1470 }
1471}
1472
1473impl glib::value::ValueType for StateFlags {
1474 type Type = Self;
1475}
1476
1477unsafe impl<'a> glib::value::FromValue<'a> for StateFlags {
1478 type Checker = glib::value::GenericValueTypeChecker<Self>;
1479
1480 #[inline]
1481 unsafe fn from_value(value: &'a glib::Value) -> Self {
1482 skip_assert_initialized!();
1483 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1484 }
1485}
1486
1487impl ToValue for StateFlags {
1488 #[inline]
1489 fn to_value(&self) -> glib::Value {
1490 let mut value = glib::Value::for_value_type::<Self>();
1491 unsafe {
1492 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1493 }
1494 value
1495 }
1496
1497 #[inline]
1498 fn value_type(&self) -> glib::Type {
1499 Self::static_type()
1500 }
1501}
1502
1503impl From<StateFlags> for glib::Value {
1504 #[inline]
1505 fn from(v: StateFlags) -> Self {
1506 skip_assert_initialized!();
1507 ToValue::to_value(&v)
1508 }
1509}
1510
1511bitflags! {
1512 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1513 #[doc(alias = "GtkStyleContextPrintFlags")]
1514 pub struct StyleContextPrintFlags: u32 {
1515 #[doc(alias = "GTK_STYLE_CONTEXT_PRINT_NONE")]
1516 const NONE = ffi::GTK_STYLE_CONTEXT_PRINT_NONE as _;
1517 #[doc(alias = "GTK_STYLE_CONTEXT_PRINT_RECURSE")]
1518 const RECURSE = ffi::GTK_STYLE_CONTEXT_PRINT_RECURSE as _;
1519 #[doc(alias = "GTK_STYLE_CONTEXT_PRINT_SHOW_STYLE")]
1520 const SHOW_STYLE = ffi::GTK_STYLE_CONTEXT_PRINT_SHOW_STYLE as _;
1521 #[doc(alias = "GTK_STYLE_CONTEXT_PRINT_SHOW_CHANGE")]
1522 const SHOW_CHANGE = ffi::GTK_STYLE_CONTEXT_PRINT_SHOW_CHANGE as _;
1523 }
1524}
1525
1526#[doc(hidden)]
1527impl IntoGlib for StyleContextPrintFlags {
1528 type GlibType = ffi::GtkStyleContextPrintFlags;
1529
1530 #[inline]
1531 fn into_glib(self) -> ffi::GtkStyleContextPrintFlags {
1532 self.bits()
1533 }
1534}
1535
1536#[doc(hidden)]
1537impl FromGlib<ffi::GtkStyleContextPrintFlags> for StyleContextPrintFlags {
1538 #[inline]
1539 unsafe fn from_glib(value: ffi::GtkStyleContextPrintFlags) -> Self {
1540 skip_assert_initialized!();
1541 Self::from_bits_truncate(value)
1542 }
1543}
1544
1545impl StaticType for StyleContextPrintFlags {
1546 #[inline]
1547 #[doc(alias = "gtk_style_context_print_flags_get_type")]
1548 fn static_type() -> glib::Type {
1549 unsafe { from_glib(ffi::gtk_style_context_print_flags_get_type()) }
1550 }
1551}
1552
1553impl glib::HasParamSpec for StyleContextPrintFlags {
1554 type ParamSpec = glib::ParamSpecFlags;
1555 type SetValue = Self;
1556 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1557
1558 fn param_spec_builder() -> Self::BuilderFn {
1559 Self::ParamSpec::builder
1560 }
1561}
1562
1563impl glib::value::ValueType for StyleContextPrintFlags {
1564 type Type = Self;
1565}
1566
1567unsafe impl<'a> glib::value::FromValue<'a> for StyleContextPrintFlags {
1568 type Checker = glib::value::GenericValueTypeChecker<Self>;
1569
1570 #[inline]
1571 unsafe fn from_value(value: &'a glib::Value) -> Self {
1572 skip_assert_initialized!();
1573 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1574 }
1575}
1576
1577impl ToValue for StyleContextPrintFlags {
1578 #[inline]
1579 fn to_value(&self) -> glib::Value {
1580 let mut value = glib::Value::for_value_type::<Self>();
1581 unsafe {
1582 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1583 }
1584 value
1585 }
1586
1587 #[inline]
1588 fn value_type(&self) -> glib::Type {
1589 Self::static_type()
1590 }
1591}
1592
1593impl From<StyleContextPrintFlags> for glib::Value {
1594 #[inline]
1595 fn from(v: StyleContextPrintFlags) -> Self {
1596 skip_assert_initialized!();
1597 ToValue::to_value(&v)
1598 }
1599}
1600
1601#[cfg(feature = "v4_16")]
1602bitflags! {
1603 #[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
1604 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1605 #[doc(alias = "GtkTextBufferNotifyFlags")]
1606 pub struct TextBufferNotifyFlags: u32 {
1607 #[doc(alias = "GTK_TEXT_BUFFER_NOTIFY_BEFORE_INSERT")]
1608 const BEFORE_INSERT = ffi::GTK_TEXT_BUFFER_NOTIFY_BEFORE_INSERT as _;
1609 #[doc(alias = "GTK_TEXT_BUFFER_NOTIFY_AFTER_INSERT")]
1610 const AFTER_INSERT = ffi::GTK_TEXT_BUFFER_NOTIFY_AFTER_INSERT as _;
1611 #[doc(alias = "GTK_TEXT_BUFFER_NOTIFY_BEFORE_DELETE")]
1612 const BEFORE_DELETE = ffi::GTK_TEXT_BUFFER_NOTIFY_BEFORE_DELETE as _;
1613 #[doc(alias = "GTK_TEXT_BUFFER_NOTIFY_AFTER_DELETE")]
1614 const AFTER_DELETE = ffi::GTK_TEXT_BUFFER_NOTIFY_AFTER_DELETE as _;
1615 }
1616}
1617
1618#[cfg(feature = "v4_16")]
1619#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
1620#[doc(hidden)]
1621impl IntoGlib for TextBufferNotifyFlags {
1622 type GlibType = ffi::GtkTextBufferNotifyFlags;
1623
1624 #[inline]
1625 fn into_glib(self) -> ffi::GtkTextBufferNotifyFlags {
1626 self.bits()
1627 }
1628}
1629
1630#[cfg(feature = "v4_16")]
1631#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
1632#[doc(hidden)]
1633impl FromGlib<ffi::GtkTextBufferNotifyFlags> for TextBufferNotifyFlags {
1634 #[inline]
1635 unsafe fn from_glib(value: ffi::GtkTextBufferNotifyFlags) -> Self {
1636 skip_assert_initialized!();
1637 Self::from_bits_truncate(value)
1638 }
1639}
1640
1641#[cfg(feature = "v4_16")]
1642#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
1643impl StaticType for TextBufferNotifyFlags {
1644 #[inline]
1645 #[doc(alias = "gtk_text_buffer_notify_flags_get_type")]
1646 fn static_type() -> glib::Type {
1647 unsafe { from_glib(ffi::gtk_text_buffer_notify_flags_get_type()) }
1648 }
1649}
1650
1651#[cfg(feature = "v4_16")]
1652#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
1653impl glib::HasParamSpec for TextBufferNotifyFlags {
1654 type ParamSpec = glib::ParamSpecFlags;
1655 type SetValue = Self;
1656 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1657
1658 fn param_spec_builder() -> Self::BuilderFn {
1659 Self::ParamSpec::builder
1660 }
1661}
1662
1663#[cfg(feature = "v4_16")]
1664#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
1665impl glib::value::ValueType for TextBufferNotifyFlags {
1666 type Type = Self;
1667}
1668
1669#[cfg(feature = "v4_16")]
1670#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
1671unsafe impl<'a> glib::value::FromValue<'a> for TextBufferNotifyFlags {
1672 type Checker = glib::value::GenericValueTypeChecker<Self>;
1673
1674 #[inline]
1675 unsafe fn from_value(value: &'a glib::Value) -> Self {
1676 skip_assert_initialized!();
1677 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1678 }
1679}
1680
1681#[cfg(feature = "v4_16")]
1682#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
1683impl ToValue for TextBufferNotifyFlags {
1684 #[inline]
1685 fn to_value(&self) -> glib::Value {
1686 let mut value = glib::Value::for_value_type::<Self>();
1687 unsafe {
1688 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1689 }
1690 value
1691 }
1692
1693 #[inline]
1694 fn value_type(&self) -> glib::Type {
1695 Self::static_type()
1696 }
1697}
1698
1699#[cfg(feature = "v4_16")]
1700#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
1701impl From<TextBufferNotifyFlags> for glib::Value {
1702 #[inline]
1703 fn from(v: TextBufferNotifyFlags) -> Self {
1704 skip_assert_initialized!();
1705 ToValue::to_value(&v)
1706 }
1707}
1708
1709bitflags! {
1710 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1711 #[doc(alias = "GtkTextSearchFlags")]
1712 pub struct TextSearchFlags: u32 {
1713 #[doc(alias = "GTK_TEXT_SEARCH_VISIBLE_ONLY")]
1714 const VISIBLE_ONLY = ffi::GTK_TEXT_SEARCH_VISIBLE_ONLY as _;
1715 #[doc(alias = "GTK_TEXT_SEARCH_TEXT_ONLY")]
1716 const TEXT_ONLY = ffi::GTK_TEXT_SEARCH_TEXT_ONLY as _;
1717 #[doc(alias = "GTK_TEXT_SEARCH_CASE_INSENSITIVE")]
1718 const CASE_INSENSITIVE = ffi::GTK_TEXT_SEARCH_CASE_INSENSITIVE as _;
1719 }
1720}
1721
1722#[doc(hidden)]
1723impl IntoGlib for TextSearchFlags {
1724 type GlibType = ffi::GtkTextSearchFlags;
1725
1726 #[inline]
1727 fn into_glib(self) -> ffi::GtkTextSearchFlags {
1728 self.bits()
1729 }
1730}
1731
1732#[doc(hidden)]
1733impl FromGlib<ffi::GtkTextSearchFlags> for TextSearchFlags {
1734 #[inline]
1735 unsafe fn from_glib(value: ffi::GtkTextSearchFlags) -> Self {
1736 skip_assert_initialized!();
1737 Self::from_bits_truncate(value)
1738 }
1739}
1740
1741impl StaticType for TextSearchFlags {
1742 #[inline]
1743 #[doc(alias = "gtk_text_search_flags_get_type")]
1744 fn static_type() -> glib::Type {
1745 unsafe { from_glib(ffi::gtk_text_search_flags_get_type()) }
1746 }
1747}
1748
1749impl glib::HasParamSpec for TextSearchFlags {
1750 type ParamSpec = glib::ParamSpecFlags;
1751 type SetValue = Self;
1752 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1753
1754 fn param_spec_builder() -> Self::BuilderFn {
1755 Self::ParamSpec::builder
1756 }
1757}
1758
1759impl glib::value::ValueType for TextSearchFlags {
1760 type Type = Self;
1761}
1762
1763unsafe impl<'a> glib::value::FromValue<'a> for TextSearchFlags {
1764 type Checker = glib::value::GenericValueTypeChecker<Self>;
1765
1766 #[inline]
1767 unsafe fn from_value(value: &'a glib::Value) -> Self {
1768 skip_assert_initialized!();
1769 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1770 }
1771}
1772
1773impl ToValue for TextSearchFlags {
1774 #[inline]
1775 fn to_value(&self) -> glib::Value {
1776 let mut value = glib::Value::for_value_type::<Self>();
1777 unsafe {
1778 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1779 }
1780 value
1781 }
1782
1783 #[inline]
1784 fn value_type(&self) -> glib::Type {
1785 Self::static_type()
1786 }
1787}
1788
1789impl From<TextSearchFlags> for glib::Value {
1790 #[inline]
1791 fn from(v: TextSearchFlags) -> Self {
1792 skip_assert_initialized!();
1793 ToValue::to_value(&v)
1794 }
1795}
1796
1797bitflags! {
1798 #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
1799 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1800 #[doc(alias = "GtkTreeModelFlags")]
1801 pub struct TreeModelFlags: u32 {
1802 #[doc(alias = "GTK_TREE_MODEL_ITERS_PERSIST")]
1803 const ITERS_PERSIST = ffi::GTK_TREE_MODEL_ITERS_PERSIST as _;
1804 #[doc(alias = "GTK_TREE_MODEL_LIST_ONLY")]
1805 const LIST_ONLY = ffi::GTK_TREE_MODEL_LIST_ONLY as _;
1806 }
1807}
1808
1809#[allow(deprecated)]
1810#[doc(hidden)]
1811impl IntoGlib for TreeModelFlags {
1812 type GlibType = ffi::GtkTreeModelFlags;
1813
1814 #[inline]
1815 fn into_glib(self) -> ffi::GtkTreeModelFlags {
1816 self.bits()
1817 }
1818}
1819
1820#[allow(deprecated)]
1821#[doc(hidden)]
1822impl FromGlib<ffi::GtkTreeModelFlags> for TreeModelFlags {
1823 #[inline]
1824 unsafe fn from_glib(value: ffi::GtkTreeModelFlags) -> Self {
1825 skip_assert_initialized!();
1826 Self::from_bits_truncate(value)
1827 }
1828}
1829
1830#[allow(deprecated)]
1831impl StaticType for TreeModelFlags {
1832 #[inline]
1833 #[doc(alias = "gtk_tree_model_flags_get_type")]
1834 fn static_type() -> glib::Type {
1835 unsafe { from_glib(ffi::gtk_tree_model_flags_get_type()) }
1836 }
1837}
1838
1839#[allow(deprecated)]
1840impl glib::HasParamSpec for TreeModelFlags {
1841 type ParamSpec = glib::ParamSpecFlags;
1842 type SetValue = Self;
1843 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1844
1845 fn param_spec_builder() -> Self::BuilderFn {
1846 Self::ParamSpec::builder
1847 }
1848}
1849
1850#[allow(deprecated)]
1851impl glib::value::ValueType for TreeModelFlags {
1852 type Type = Self;
1853}
1854
1855#[allow(deprecated)]
1856unsafe impl<'a> glib::value::FromValue<'a> for TreeModelFlags {
1857 type Checker = glib::value::GenericValueTypeChecker<Self>;
1858
1859 #[inline]
1860 unsafe fn from_value(value: &'a glib::Value) -> Self {
1861 skip_assert_initialized!();
1862 from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1863 }
1864}
1865
1866#[allow(deprecated)]
1867impl ToValue for TreeModelFlags {
1868 #[inline]
1869 fn to_value(&self) -> glib::Value {
1870 let mut value = glib::Value::for_value_type::<Self>();
1871 unsafe {
1872 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1873 }
1874 value
1875 }
1876
1877 #[inline]
1878 fn value_type(&self) -> glib::Type {
1879 Self::static_type()
1880 }
1881}
1882
1883#[allow(deprecated)]
1884impl From<TreeModelFlags> for glib::Value {
1885 #[inline]
1886 fn from(v: TreeModelFlags) -> Self {
1887 skip_assert_initialized!();
1888 ToValue::to_value(&v)
1889 }
1890}