1 // This file was generated by gir (https://github.com/gtk-rs/gir)
2 // from gir-files (https://github.com/gtk-rs/gir-files)
3 // DO NOT EDIT
4 
5 use bitflags::bitflags;
6 use glib::translate::*;
7 use glib::value::FromValue;
8 use glib::value::ToValue;
9 use glib::StaticType;
10 use glib::Type;
11 use std::fmt;
12 
13 bitflags! {
14     #[doc(alias = "GtkAccelFlags")]
15     pub struct AccelFlags: u32 {
16         #[doc(alias = "GTK_ACCEL_VISIBLE")]
17         const VISIBLE = ffi::GTK_ACCEL_VISIBLE as u32;
18         #[doc(alias = "GTK_ACCEL_LOCKED")]
19         const LOCKED = ffi::GTK_ACCEL_LOCKED as u32;
20         #[doc(alias = "GTK_ACCEL_MASK")]
21         const MASK = ffi::GTK_ACCEL_MASK as u32;
22     }
23 }
24 
25 impl fmt::Display for AccelFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result26     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
27         <Self as fmt::Debug>::fmt(self, f)
28     }
29 }
30 
31 #[doc(hidden)]
32 impl IntoGlib for AccelFlags {
33     type GlibType = ffi::GtkAccelFlags;
34 
into_glib(self) -> ffi::GtkAccelFlags35     fn into_glib(self) -> ffi::GtkAccelFlags {
36         self.bits()
37     }
38 }
39 
40 #[doc(hidden)]
41 impl FromGlib<ffi::GtkAccelFlags> for AccelFlags {
from_glib(value: ffi::GtkAccelFlags) -> Self42     unsafe fn from_glib(value: ffi::GtkAccelFlags) -> Self {
43         skip_assert_initialized!();
44         Self::from_bits_truncate(value)
45     }
46 }
47 
48 impl StaticType for AccelFlags {
static_type() -> Type49     fn static_type() -> Type {
50         unsafe { from_glib(ffi::gtk_accel_flags_get_type()) }
51     }
52 }
53 
54 impl glib::value::ValueType for AccelFlags {
55     type Type = Self;
56 }
57 
58 unsafe impl<'a> FromValue<'a> for AccelFlags {
59     type Checker = glib::value::GenericValueTypeChecker<Self>;
60 
from_value(value: &'a glib::Value) -> Self61     unsafe fn from_value(value: &'a glib::Value) -> Self {
62         skip_assert_initialized!();
63         from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
64     }
65 }
66 
67 impl ToValue for AccelFlags {
to_value(&self) -> glib::Value68     fn to_value(&self) -> glib::Value {
69         let mut value = glib::Value::for_value_type::<Self>();
70         unsafe {
71             glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
72         }
73         value
74     }
75 
value_type(&self) -> glib::Type76     fn value_type(&self) -> glib::Type {
77         Self::static_type()
78     }
79 }
80 
81 bitflags! {
82     #[doc(alias = "GtkApplicationInhibitFlags")]
83     pub struct ApplicationInhibitFlags: u32 {
84         #[doc(alias = "GTK_APPLICATION_INHIBIT_LOGOUT")]
85         const LOGOUT = ffi::GTK_APPLICATION_INHIBIT_LOGOUT as u32;
86         #[doc(alias = "GTK_APPLICATION_INHIBIT_SWITCH")]
87         const SWITCH = ffi::GTK_APPLICATION_INHIBIT_SWITCH as u32;
88         #[doc(alias = "GTK_APPLICATION_INHIBIT_SUSPEND")]
89         const SUSPEND = ffi::GTK_APPLICATION_INHIBIT_SUSPEND as u32;
90         #[doc(alias = "GTK_APPLICATION_INHIBIT_IDLE")]
91         const IDLE = ffi::GTK_APPLICATION_INHIBIT_IDLE as u32;
92     }
93 }
94 
95 impl fmt::Display for ApplicationInhibitFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result96     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
97         <Self as fmt::Debug>::fmt(self, f)
98     }
99 }
100 
101 #[doc(hidden)]
102 impl IntoGlib for ApplicationInhibitFlags {
103     type GlibType = ffi::GtkApplicationInhibitFlags;
104 
into_glib(self) -> ffi::GtkApplicationInhibitFlags105     fn into_glib(self) -> ffi::GtkApplicationInhibitFlags {
106         self.bits()
107     }
108 }
109 
110 #[doc(hidden)]
111 impl FromGlib<ffi::GtkApplicationInhibitFlags> for ApplicationInhibitFlags {
from_glib(value: ffi::GtkApplicationInhibitFlags) -> Self112     unsafe fn from_glib(value: ffi::GtkApplicationInhibitFlags) -> Self {
113         skip_assert_initialized!();
114         Self::from_bits_truncate(value)
115     }
116 }
117 
118 impl StaticType for ApplicationInhibitFlags {
static_type() -> Type119     fn static_type() -> Type {
120         unsafe { from_glib(ffi::gtk_application_inhibit_flags_get_type()) }
121     }
122 }
123 
124 impl glib::value::ValueType for ApplicationInhibitFlags {
125     type Type = Self;
126 }
127 
128 unsafe impl<'a> FromValue<'a> for ApplicationInhibitFlags {
129     type Checker = glib::value::GenericValueTypeChecker<Self>;
130 
from_value(value: &'a glib::Value) -> Self131     unsafe fn from_value(value: &'a glib::Value) -> Self {
132         skip_assert_initialized!();
133         from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
134     }
135 }
136 
137 impl ToValue for ApplicationInhibitFlags {
to_value(&self) -> glib::Value138     fn to_value(&self) -> glib::Value {
139         let mut value = glib::Value::for_value_type::<Self>();
140         unsafe {
141             glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
142         }
143         value
144     }
145 
value_type(&self) -> glib::Type146     fn value_type(&self) -> glib::Type {
147         Self::static_type()
148     }
149 }
150 
151 bitflags! {
152     #[doc(alias = "GtkCalendarDisplayOptions")]
153     pub struct CalendarDisplayOptions: u32 {
154         #[doc(alias = "GTK_CALENDAR_SHOW_HEADING")]
155         const SHOW_HEADING = ffi::GTK_CALENDAR_SHOW_HEADING as u32;
156         #[doc(alias = "GTK_CALENDAR_SHOW_DAY_NAMES")]
157         const SHOW_DAY_NAMES = ffi::GTK_CALENDAR_SHOW_DAY_NAMES as u32;
158         #[doc(alias = "GTK_CALENDAR_NO_MONTH_CHANGE")]
159         const NO_MONTH_CHANGE = ffi::GTK_CALENDAR_NO_MONTH_CHANGE as u32;
160         #[doc(alias = "GTK_CALENDAR_SHOW_WEEK_NUMBERS")]
161         const SHOW_WEEK_NUMBERS = ffi::GTK_CALENDAR_SHOW_WEEK_NUMBERS as u32;
162         #[doc(alias = "GTK_CALENDAR_SHOW_DETAILS")]
163         const SHOW_DETAILS = ffi::GTK_CALENDAR_SHOW_DETAILS as u32;
164     }
165 }
166 
167 impl fmt::Display for CalendarDisplayOptions {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result168     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
169         <Self as fmt::Debug>::fmt(self, f)
170     }
171 }
172 
173 #[doc(hidden)]
174 impl IntoGlib for CalendarDisplayOptions {
175     type GlibType = ffi::GtkCalendarDisplayOptions;
176 
into_glib(self) -> ffi::GtkCalendarDisplayOptions177     fn into_glib(self) -> ffi::GtkCalendarDisplayOptions {
178         self.bits()
179     }
180 }
181 
182 #[doc(hidden)]
183 impl FromGlib<ffi::GtkCalendarDisplayOptions> for CalendarDisplayOptions {
from_glib(value: ffi::GtkCalendarDisplayOptions) -> Self184     unsafe fn from_glib(value: ffi::GtkCalendarDisplayOptions) -> Self {
185         skip_assert_initialized!();
186         Self::from_bits_truncate(value)
187     }
188 }
189 
190 impl StaticType for CalendarDisplayOptions {
static_type() -> Type191     fn static_type() -> Type {
192         unsafe { from_glib(ffi::gtk_calendar_display_options_get_type()) }
193     }
194 }
195 
196 impl glib::value::ValueType for CalendarDisplayOptions {
197     type Type = Self;
198 }
199 
200 unsafe impl<'a> FromValue<'a> for CalendarDisplayOptions {
201     type Checker = glib::value::GenericValueTypeChecker<Self>;
202 
from_value(value: &'a glib::Value) -> Self203     unsafe fn from_value(value: &'a glib::Value) -> Self {
204         skip_assert_initialized!();
205         from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
206     }
207 }
208 
209 impl ToValue for CalendarDisplayOptions {
to_value(&self) -> glib::Value210     fn to_value(&self) -> glib::Value {
211         let mut value = glib::Value::for_value_type::<Self>();
212         unsafe {
213             glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
214         }
215         value
216     }
217 
value_type(&self) -> glib::Type218     fn value_type(&self) -> glib::Type {
219         Self::static_type()
220     }
221 }
222 
223 bitflags! {
224     #[doc(alias = "GtkCellRendererState")]
225     pub struct CellRendererState: u32 {
226         #[doc(alias = "GTK_CELL_RENDERER_SELECTED")]
227         const SELECTED = ffi::GTK_CELL_RENDERER_SELECTED as u32;
228         #[doc(alias = "GTK_CELL_RENDERER_PRELIT")]
229         const PRELIT = ffi::GTK_CELL_RENDERER_PRELIT as u32;
230         #[doc(alias = "GTK_CELL_RENDERER_INSENSITIVE")]
231         const INSENSITIVE = ffi::GTK_CELL_RENDERER_INSENSITIVE as u32;
232         #[doc(alias = "GTK_CELL_RENDERER_SORTED")]
233         const SORTED = ffi::GTK_CELL_RENDERER_SORTED as u32;
234         #[doc(alias = "GTK_CELL_RENDERER_FOCUSED")]
235         const FOCUSED = ffi::GTK_CELL_RENDERER_FOCUSED as u32;
236         #[doc(alias = "GTK_CELL_RENDERER_EXPANDABLE")]
237         const EXPANDABLE = ffi::GTK_CELL_RENDERER_EXPANDABLE as u32;
238         #[doc(alias = "GTK_CELL_RENDERER_EXPANDED")]
239         const EXPANDED = ffi::GTK_CELL_RENDERER_EXPANDED as u32;
240     }
241 }
242 
243 impl fmt::Display for CellRendererState {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result244     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
245         <Self as fmt::Debug>::fmt(self, f)
246     }
247 }
248 
249 #[doc(hidden)]
250 impl IntoGlib for CellRendererState {
251     type GlibType = ffi::GtkCellRendererState;
252 
into_glib(self) -> ffi::GtkCellRendererState253     fn into_glib(self) -> ffi::GtkCellRendererState {
254         self.bits()
255     }
256 }
257 
258 #[doc(hidden)]
259 impl FromGlib<ffi::GtkCellRendererState> for CellRendererState {
from_glib(value: ffi::GtkCellRendererState) -> Self260     unsafe fn from_glib(value: ffi::GtkCellRendererState) -> Self {
261         skip_assert_initialized!();
262         Self::from_bits_truncate(value)
263     }
264 }
265 
266 impl StaticType for CellRendererState {
static_type() -> Type267     fn static_type() -> Type {
268         unsafe { from_glib(ffi::gtk_cell_renderer_state_get_type()) }
269     }
270 }
271 
272 impl glib::value::ValueType for CellRendererState {
273     type Type = Self;
274 }
275 
276 unsafe impl<'a> FromValue<'a> for CellRendererState {
277     type Checker = glib::value::GenericValueTypeChecker<Self>;
278 
from_value(value: &'a glib::Value) -> Self279     unsafe fn from_value(value: &'a glib::Value) -> Self {
280         skip_assert_initialized!();
281         from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
282     }
283 }
284 
285 impl ToValue for CellRendererState {
to_value(&self) -> glib::Value286     fn to_value(&self) -> glib::Value {
287         let mut value = glib::Value::for_value_type::<Self>();
288         unsafe {
289             glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
290         }
291         value
292     }
293 
value_type(&self) -> glib::Type294     fn value_type(&self) -> glib::Type {
295         Self::static_type()
296     }
297 }
298 
299 bitflags! {
300     #[doc(alias = "GtkDestDefaults")]
301     pub struct DestDefaults: u32 {
302         #[doc(alias = "GTK_DEST_DEFAULT_MOTION")]
303         const MOTION = ffi::GTK_DEST_DEFAULT_MOTION as u32;
304         #[doc(alias = "GTK_DEST_DEFAULT_HIGHLIGHT")]
305         const HIGHLIGHT = ffi::GTK_DEST_DEFAULT_HIGHLIGHT as u32;
306         #[doc(alias = "GTK_DEST_DEFAULT_DROP")]
307         const DROP = ffi::GTK_DEST_DEFAULT_DROP as u32;
308         #[doc(alias = "GTK_DEST_DEFAULT_ALL")]
309         const ALL = ffi::GTK_DEST_DEFAULT_ALL as u32;
310     }
311 }
312 
313 impl fmt::Display for DestDefaults {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result314     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
315         <Self as fmt::Debug>::fmt(self, f)
316     }
317 }
318 
319 #[doc(hidden)]
320 impl IntoGlib for DestDefaults {
321     type GlibType = ffi::GtkDestDefaults;
322 
into_glib(self) -> ffi::GtkDestDefaults323     fn into_glib(self) -> ffi::GtkDestDefaults {
324         self.bits()
325     }
326 }
327 
328 #[doc(hidden)]
329 impl FromGlib<ffi::GtkDestDefaults> for DestDefaults {
from_glib(value: ffi::GtkDestDefaults) -> Self330     unsafe fn from_glib(value: ffi::GtkDestDefaults) -> Self {
331         skip_assert_initialized!();
332         Self::from_bits_truncate(value)
333     }
334 }
335 
336 impl StaticType for DestDefaults {
static_type() -> Type337     fn static_type() -> Type {
338         unsafe { from_glib(ffi::gtk_dest_defaults_get_type()) }
339     }
340 }
341 
342 impl glib::value::ValueType for DestDefaults {
343     type Type = Self;
344 }
345 
346 unsafe impl<'a> FromValue<'a> for DestDefaults {
347     type Checker = glib::value::GenericValueTypeChecker<Self>;
348 
from_value(value: &'a glib::Value) -> Self349     unsafe fn from_value(value: &'a glib::Value) -> Self {
350         skip_assert_initialized!();
351         from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
352     }
353 }
354 
355 impl ToValue for DestDefaults {
to_value(&self) -> glib::Value356     fn to_value(&self) -> glib::Value {
357         let mut value = glib::Value::for_value_type::<Self>();
358         unsafe {
359             glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
360         }
361         value
362     }
363 
value_type(&self) -> glib::Type364     fn value_type(&self) -> glib::Type {
365         Self::static_type()
366     }
367 }
368 
369 bitflags! {
370     #[doc(alias = "GtkDialogFlags")]
371     pub struct DialogFlags: u32 {
372         #[doc(alias = "GTK_DIALOG_MODAL")]
373         const MODAL = ffi::GTK_DIALOG_MODAL as u32;
374         #[doc(alias = "GTK_DIALOG_DESTROY_WITH_PARENT")]
375         const DESTROY_WITH_PARENT = ffi::GTK_DIALOG_DESTROY_WITH_PARENT as u32;
376         #[doc(alias = "GTK_DIALOG_USE_HEADER_BAR")]
377         const USE_HEADER_BAR = ffi::GTK_DIALOG_USE_HEADER_BAR as u32;
378     }
379 }
380 
381 impl fmt::Display for DialogFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result382     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
383         <Self as fmt::Debug>::fmt(self, f)
384     }
385 }
386 
387 #[doc(hidden)]
388 impl IntoGlib for DialogFlags {
389     type GlibType = ffi::GtkDialogFlags;
390 
into_glib(self) -> ffi::GtkDialogFlags391     fn into_glib(self) -> ffi::GtkDialogFlags {
392         self.bits()
393     }
394 }
395 
396 #[doc(hidden)]
397 impl FromGlib<ffi::GtkDialogFlags> for DialogFlags {
from_glib(value: ffi::GtkDialogFlags) -> Self398     unsafe fn from_glib(value: ffi::GtkDialogFlags) -> Self {
399         skip_assert_initialized!();
400         Self::from_bits_truncate(value)
401     }
402 }
403 
404 impl StaticType for DialogFlags {
static_type() -> Type405     fn static_type() -> Type {
406         unsafe { from_glib(ffi::gtk_dialog_flags_get_type()) }
407     }
408 }
409 
410 impl glib::value::ValueType for DialogFlags {
411     type Type = Self;
412 }
413 
414 unsafe impl<'a> FromValue<'a> for DialogFlags {
415     type Checker = glib::value::GenericValueTypeChecker<Self>;
416 
from_value(value: &'a glib::Value) -> Self417     unsafe fn from_value(value: &'a glib::Value) -> Self {
418         skip_assert_initialized!();
419         from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
420     }
421 }
422 
423 impl ToValue for DialogFlags {
to_value(&self) -> glib::Value424     fn to_value(&self) -> glib::Value {
425         let mut value = glib::Value::for_value_type::<Self>();
426         unsafe {
427             glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
428         }
429         value
430     }
431 
value_type(&self) -> glib::Type432     fn value_type(&self) -> glib::Type {
433         Self::static_type()
434     }
435 }
436 
437 #[cfg(any(feature = "v3_24", feature = "dox"))]
438 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_24")))]
439 bitflags! {
440     #[doc(alias = "GtkEventControllerScrollFlags")]
441     pub struct EventControllerScrollFlags: u32 {
442         #[doc(alias = "GTK_EVENT_CONTROLLER_SCROLL_NONE")]
443         const NONE = ffi::GTK_EVENT_CONTROLLER_SCROLL_NONE as u32;
444         #[doc(alias = "GTK_EVENT_CONTROLLER_SCROLL_VERTICAL")]
445         const VERTICAL = ffi::GTK_EVENT_CONTROLLER_SCROLL_VERTICAL as u32;
446         #[doc(alias = "GTK_EVENT_CONTROLLER_SCROLL_HORIZONTAL")]
447         const HORIZONTAL = ffi::GTK_EVENT_CONTROLLER_SCROLL_HORIZONTAL as u32;
448         #[doc(alias = "GTK_EVENT_CONTROLLER_SCROLL_DISCRETE")]
449         const DISCRETE = ffi::GTK_EVENT_CONTROLLER_SCROLL_DISCRETE as u32;
450         #[doc(alias = "GTK_EVENT_CONTROLLER_SCROLL_KINETIC")]
451         const KINETIC = ffi::GTK_EVENT_CONTROLLER_SCROLL_KINETIC as u32;
452         #[doc(alias = "GTK_EVENT_CONTROLLER_SCROLL_BOTH_AXES")]
453         const BOTH_AXES = ffi::GTK_EVENT_CONTROLLER_SCROLL_BOTH_AXES as u32;
454     }
455 }
456 
457 #[cfg(any(feature = "v3_24", feature = "dox"))]
458 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_24")))]
459 impl fmt::Display for EventControllerScrollFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result460     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
461         <Self as fmt::Debug>::fmt(self, f)
462     }
463 }
464 
465 #[cfg(any(feature = "v3_24", feature = "dox"))]
466 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_24")))]
467 #[doc(hidden)]
468 impl IntoGlib for EventControllerScrollFlags {
469     type GlibType = ffi::GtkEventControllerScrollFlags;
470 
into_glib(self) -> ffi::GtkEventControllerScrollFlags471     fn into_glib(self) -> ffi::GtkEventControllerScrollFlags {
472         self.bits()
473     }
474 }
475 
476 #[cfg(any(feature = "v3_24", feature = "dox"))]
477 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_24")))]
478 #[doc(hidden)]
479 impl FromGlib<ffi::GtkEventControllerScrollFlags> for EventControllerScrollFlags {
from_glib(value: ffi::GtkEventControllerScrollFlags) -> Self480     unsafe fn from_glib(value: ffi::GtkEventControllerScrollFlags) -> Self {
481         skip_assert_initialized!();
482         Self::from_bits_truncate(value)
483     }
484 }
485 
486 #[cfg(any(feature = "v3_24", feature = "dox"))]
487 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_24")))]
488 impl StaticType for EventControllerScrollFlags {
static_type() -> Type489     fn static_type() -> Type {
490         unsafe { from_glib(ffi::gtk_event_controller_scroll_flags_get_type()) }
491     }
492 }
493 
494 #[cfg(any(feature = "v3_24", feature = "dox"))]
495 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_24")))]
496 impl glib::value::ValueType for EventControllerScrollFlags {
497     type Type = Self;
498 }
499 
500 #[cfg(any(feature = "v3_24", feature = "dox"))]
501 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_24")))]
502 unsafe impl<'a> FromValue<'a> for EventControllerScrollFlags {
503     type Checker = glib::value::GenericValueTypeChecker<Self>;
504 
from_value(value: &'a glib::Value) -> Self505     unsafe fn from_value(value: &'a glib::Value) -> Self {
506         skip_assert_initialized!();
507         from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
508     }
509 }
510 
511 #[cfg(any(feature = "v3_24", feature = "dox"))]
512 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_24")))]
513 impl ToValue for EventControllerScrollFlags {
to_value(&self) -> glib::Value514     fn to_value(&self) -> glib::Value {
515         let mut value = glib::Value::for_value_type::<Self>();
516         unsafe {
517             glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
518         }
519         value
520     }
521 
value_type(&self) -> glib::Type522     fn value_type(&self) -> glib::Type {
523         Self::static_type()
524     }
525 }
526 
527 bitflags! {
528     #[doc(alias = "GtkFileFilterFlags")]
529     pub struct FileFilterFlags: u32 {
530         #[doc(alias = "GTK_FILE_FILTER_FILENAME")]
531         const FILENAME = ffi::GTK_FILE_FILTER_FILENAME as u32;
532         #[doc(alias = "GTK_FILE_FILTER_URI")]
533         const URI = ffi::GTK_FILE_FILTER_URI as u32;
534         #[doc(alias = "GTK_FILE_FILTER_DISPLAY_NAME")]
535         const DISPLAY_NAME = ffi::GTK_FILE_FILTER_DISPLAY_NAME as u32;
536         #[doc(alias = "GTK_FILE_FILTER_MIME_TYPE")]
537         const MIME_TYPE = ffi::GTK_FILE_FILTER_MIME_TYPE as u32;
538     }
539 }
540 
541 impl fmt::Display for FileFilterFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result542     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
543         <Self as fmt::Debug>::fmt(self, f)
544     }
545 }
546 
547 #[doc(hidden)]
548 impl IntoGlib for FileFilterFlags {
549     type GlibType = ffi::GtkFileFilterFlags;
550 
into_glib(self) -> ffi::GtkFileFilterFlags551     fn into_glib(self) -> ffi::GtkFileFilterFlags {
552         self.bits()
553     }
554 }
555 
556 #[doc(hidden)]
557 impl FromGlib<ffi::GtkFileFilterFlags> for FileFilterFlags {
from_glib(value: ffi::GtkFileFilterFlags) -> Self558     unsafe fn from_glib(value: ffi::GtkFileFilterFlags) -> Self {
559         skip_assert_initialized!();
560         Self::from_bits_truncate(value)
561     }
562 }
563 
564 impl StaticType for FileFilterFlags {
static_type() -> Type565     fn static_type() -> Type {
566         unsafe { from_glib(ffi::gtk_file_filter_flags_get_type()) }
567     }
568 }
569 
570 impl glib::value::ValueType for FileFilterFlags {
571     type Type = Self;
572 }
573 
574 unsafe impl<'a> FromValue<'a> for FileFilterFlags {
575     type Checker = glib::value::GenericValueTypeChecker<Self>;
576 
from_value(value: &'a glib::Value) -> Self577     unsafe fn from_value(value: &'a glib::Value) -> Self {
578         skip_assert_initialized!();
579         from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
580     }
581 }
582 
583 impl ToValue for FileFilterFlags {
to_value(&self) -> glib::Value584     fn to_value(&self) -> glib::Value {
585         let mut value = glib::Value::for_value_type::<Self>();
586         unsafe {
587             glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
588         }
589         value
590     }
591 
value_type(&self) -> glib::Type592     fn value_type(&self) -> glib::Type {
593         Self::static_type()
594     }
595 }
596 
597 #[cfg(any(feature = "v3_24", feature = "dox"))]
598 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_24")))]
599 bitflags! {
600     #[doc(alias = "GtkFontChooserLevel")]
601     pub struct FontChooserLevel: u32 {
602         #[doc(alias = "GTK_FONT_CHOOSER_LEVEL_FAMILY")]
603         const FAMILY = ffi::GTK_FONT_CHOOSER_LEVEL_FAMILY as u32;
604         #[doc(alias = "GTK_FONT_CHOOSER_LEVEL_STYLE")]
605         const STYLE = ffi::GTK_FONT_CHOOSER_LEVEL_STYLE as u32;
606         #[doc(alias = "GTK_FONT_CHOOSER_LEVEL_SIZE")]
607         const SIZE = ffi::GTK_FONT_CHOOSER_LEVEL_SIZE as u32;
608         #[doc(alias = "GTK_FONT_CHOOSER_LEVEL_VARIATIONS")]
609         const VARIATIONS = ffi::GTK_FONT_CHOOSER_LEVEL_VARIATIONS as u32;
610         #[doc(alias = "GTK_FONT_CHOOSER_LEVEL_FEATURES")]
611         const FEATURES = ffi::GTK_FONT_CHOOSER_LEVEL_FEATURES as u32;
612     }
613 }
614 
615 #[cfg(any(feature = "v3_24", feature = "dox"))]
616 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_24")))]
617 impl fmt::Display for FontChooserLevel {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result618     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
619         <Self as fmt::Debug>::fmt(self, f)
620     }
621 }
622 
623 #[cfg(any(feature = "v3_24", feature = "dox"))]
624 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_24")))]
625 #[doc(hidden)]
626 impl IntoGlib for FontChooserLevel {
627     type GlibType = ffi::GtkFontChooserLevel;
628 
into_glib(self) -> ffi::GtkFontChooserLevel629     fn into_glib(self) -> ffi::GtkFontChooserLevel {
630         self.bits()
631     }
632 }
633 
634 #[cfg(any(feature = "v3_24", feature = "dox"))]
635 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_24")))]
636 #[doc(hidden)]
637 impl FromGlib<ffi::GtkFontChooserLevel> for FontChooserLevel {
from_glib(value: ffi::GtkFontChooserLevel) -> Self638     unsafe fn from_glib(value: ffi::GtkFontChooserLevel) -> Self {
639         skip_assert_initialized!();
640         Self::from_bits_truncate(value)
641     }
642 }
643 
644 #[cfg(any(feature = "v3_24", feature = "dox"))]
645 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_24")))]
646 impl StaticType for FontChooserLevel {
static_type() -> Type647     fn static_type() -> Type {
648         unsafe { from_glib(ffi::gtk_font_chooser_level_get_type()) }
649     }
650 }
651 
652 #[cfg(any(feature = "v3_24", feature = "dox"))]
653 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_24")))]
654 impl glib::value::ValueType for FontChooserLevel {
655     type Type = Self;
656 }
657 
658 #[cfg(any(feature = "v3_24", feature = "dox"))]
659 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_24")))]
660 unsafe impl<'a> FromValue<'a> for FontChooserLevel {
661     type Checker = glib::value::GenericValueTypeChecker<Self>;
662 
from_value(value: &'a glib::Value) -> Self663     unsafe fn from_value(value: &'a glib::Value) -> Self {
664         skip_assert_initialized!();
665         from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
666     }
667 }
668 
669 #[cfg(any(feature = "v3_24", feature = "dox"))]
670 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_24")))]
671 impl ToValue for FontChooserLevel {
to_value(&self) -> glib::Value672     fn to_value(&self) -> glib::Value {
673         let mut value = glib::Value::for_value_type::<Self>();
674         unsafe {
675             glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
676         }
677         value
678     }
679 
value_type(&self) -> glib::Type680     fn value_type(&self) -> glib::Type {
681         Self::static_type()
682     }
683 }
684 
685 bitflags! {
686     #[doc(alias = "GtkIconLookupFlags")]
687     pub struct IconLookupFlags: u32 {
688         #[doc(alias = "GTK_ICON_LOOKUP_NO_SVG")]
689         const NO_SVG = ffi::GTK_ICON_LOOKUP_NO_SVG as u32;
690         #[doc(alias = "GTK_ICON_LOOKUP_FORCE_SVG")]
691         const FORCE_SVG = ffi::GTK_ICON_LOOKUP_FORCE_SVG as u32;
692         #[doc(alias = "GTK_ICON_LOOKUP_USE_BUILTIN")]
693         const USE_BUILTIN = ffi::GTK_ICON_LOOKUP_USE_BUILTIN as u32;
694         #[doc(alias = "GTK_ICON_LOOKUP_GENERIC_FALLBACK")]
695         const GENERIC_FALLBACK = ffi::GTK_ICON_LOOKUP_GENERIC_FALLBACK as u32;
696         #[doc(alias = "GTK_ICON_LOOKUP_FORCE_SIZE")]
697         const FORCE_SIZE = ffi::GTK_ICON_LOOKUP_FORCE_SIZE as u32;
698         #[doc(alias = "GTK_ICON_LOOKUP_FORCE_REGULAR")]
699         const FORCE_REGULAR = ffi::GTK_ICON_LOOKUP_FORCE_REGULAR as u32;
700         #[doc(alias = "GTK_ICON_LOOKUP_FORCE_SYMBOLIC")]
701         const FORCE_SYMBOLIC = ffi::GTK_ICON_LOOKUP_FORCE_SYMBOLIC as u32;
702         #[doc(alias = "GTK_ICON_LOOKUP_DIR_LTR")]
703         const DIR_LTR = ffi::GTK_ICON_LOOKUP_DIR_LTR as u32;
704         #[doc(alias = "GTK_ICON_LOOKUP_DIR_RTL")]
705         const DIR_RTL = ffi::GTK_ICON_LOOKUP_DIR_RTL as u32;
706     }
707 }
708 
709 impl fmt::Display for IconLookupFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result710     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
711         <Self as fmt::Debug>::fmt(self, f)
712     }
713 }
714 
715 #[doc(hidden)]
716 impl IntoGlib for IconLookupFlags {
717     type GlibType = ffi::GtkIconLookupFlags;
718 
into_glib(self) -> ffi::GtkIconLookupFlags719     fn into_glib(self) -> ffi::GtkIconLookupFlags {
720         self.bits()
721     }
722 }
723 
724 #[doc(hidden)]
725 impl FromGlib<ffi::GtkIconLookupFlags> for IconLookupFlags {
from_glib(value: ffi::GtkIconLookupFlags) -> Self726     unsafe fn from_glib(value: ffi::GtkIconLookupFlags) -> Self {
727         skip_assert_initialized!();
728         Self::from_bits_truncate(value)
729     }
730 }
731 
732 impl StaticType for IconLookupFlags {
static_type() -> Type733     fn static_type() -> Type {
734         unsafe { from_glib(ffi::gtk_icon_lookup_flags_get_type()) }
735     }
736 }
737 
738 impl glib::value::ValueType for IconLookupFlags {
739     type Type = Self;
740 }
741 
742 unsafe impl<'a> FromValue<'a> for IconLookupFlags {
743     type Checker = glib::value::GenericValueTypeChecker<Self>;
744 
from_value(value: &'a glib::Value) -> Self745     unsafe fn from_value(value: &'a glib::Value) -> Self {
746         skip_assert_initialized!();
747         from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
748     }
749 }
750 
751 impl ToValue for IconLookupFlags {
to_value(&self) -> glib::Value752     fn to_value(&self) -> glib::Value {
753         let mut value = glib::Value::for_value_type::<Self>();
754         unsafe {
755             glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
756         }
757         value
758     }
759 
value_type(&self) -> glib::Type760     fn value_type(&self) -> glib::Type {
761         Self::static_type()
762     }
763 }
764 
765 bitflags! {
766     #[doc(alias = "GtkInputHints")]
767     pub struct InputHints: u32 {
768         #[doc(alias = "GTK_INPUT_HINT_NONE")]
769         const NONE = ffi::GTK_INPUT_HINT_NONE as u32;
770         #[doc(alias = "GTK_INPUT_HINT_SPELLCHECK")]
771         const SPELLCHECK = ffi::GTK_INPUT_HINT_SPELLCHECK as u32;
772         #[doc(alias = "GTK_INPUT_HINT_NO_SPELLCHECK")]
773         const NO_SPELLCHECK = ffi::GTK_INPUT_HINT_NO_SPELLCHECK as u32;
774         #[doc(alias = "GTK_INPUT_HINT_WORD_COMPLETION")]
775         const WORD_COMPLETION = ffi::GTK_INPUT_HINT_WORD_COMPLETION as u32;
776         #[doc(alias = "GTK_INPUT_HINT_LOWERCASE")]
777         const LOWERCASE = ffi::GTK_INPUT_HINT_LOWERCASE as u32;
778         #[doc(alias = "GTK_INPUT_HINT_UPPERCASE_CHARS")]
779         const UPPERCASE_CHARS = ffi::GTK_INPUT_HINT_UPPERCASE_CHARS as u32;
780         #[doc(alias = "GTK_INPUT_HINT_UPPERCASE_WORDS")]
781         const UPPERCASE_WORDS = ffi::GTK_INPUT_HINT_UPPERCASE_WORDS as u32;
782         #[doc(alias = "GTK_INPUT_HINT_UPPERCASE_SENTENCES")]
783         const UPPERCASE_SENTENCES = ffi::GTK_INPUT_HINT_UPPERCASE_SENTENCES as u32;
784         #[doc(alias = "GTK_INPUT_HINT_INHIBIT_OSK")]
785         const INHIBIT_OSK = ffi::GTK_INPUT_HINT_INHIBIT_OSK as u32;
786         #[doc(alias = "GTK_INPUT_HINT_VERTICAL_WRITING")]
787         const VERTICAL_WRITING = ffi::GTK_INPUT_HINT_VERTICAL_WRITING as u32;
788         #[cfg(any(feature = "v3_22_20", feature = "dox"))]
789         #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22_20")))]
790         #[doc(alias = "GTK_INPUT_HINT_EMOJI")]
791         const EMOJI = ffi::GTK_INPUT_HINT_EMOJI as u32;
792         #[cfg(any(feature = "v3_22_20", feature = "dox"))]
793         #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22_20")))]
794         #[doc(alias = "GTK_INPUT_HINT_NO_EMOJI")]
795         const NO_EMOJI = ffi::GTK_INPUT_HINT_NO_EMOJI as u32;
796     }
797 }
798 
799 impl fmt::Display for InputHints {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result800     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
801         <Self as fmt::Debug>::fmt(self, f)
802     }
803 }
804 
805 #[doc(hidden)]
806 impl IntoGlib for InputHints {
807     type GlibType = ffi::GtkInputHints;
808 
into_glib(self) -> ffi::GtkInputHints809     fn into_glib(self) -> ffi::GtkInputHints {
810         self.bits()
811     }
812 }
813 
814 #[doc(hidden)]
815 impl FromGlib<ffi::GtkInputHints> for InputHints {
from_glib(value: ffi::GtkInputHints) -> Self816     unsafe fn from_glib(value: ffi::GtkInputHints) -> Self {
817         skip_assert_initialized!();
818         Self::from_bits_truncate(value)
819     }
820 }
821 
822 impl StaticType for InputHints {
static_type() -> Type823     fn static_type() -> Type {
824         unsafe { from_glib(ffi::gtk_input_hints_get_type()) }
825     }
826 }
827 
828 impl glib::value::ValueType for InputHints {
829     type Type = Self;
830 }
831 
832 unsafe impl<'a> FromValue<'a> for InputHints {
833     type Checker = glib::value::GenericValueTypeChecker<Self>;
834 
from_value(value: &'a glib::Value) -> Self835     unsafe fn from_value(value: &'a glib::Value) -> Self {
836         skip_assert_initialized!();
837         from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
838     }
839 }
840 
841 impl ToValue for InputHints {
to_value(&self) -> glib::Value842     fn to_value(&self) -> glib::Value {
843         let mut value = glib::Value::for_value_type::<Self>();
844         unsafe {
845             glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
846         }
847         value
848     }
849 
value_type(&self) -> glib::Type850     fn value_type(&self) -> glib::Type {
851         Self::static_type()
852     }
853 }
854 
855 bitflags! {
856     #[doc(alias = "GtkJunctionSides")]
857     pub struct JunctionSides: u32 {
858         #[doc(alias = "GTK_JUNCTION_NONE")]
859         const NONE = ffi::GTK_JUNCTION_NONE as u32;
860         #[doc(alias = "GTK_JUNCTION_CORNER_TOPLEFT")]
861         const CORNER_TOPLEFT = ffi::GTK_JUNCTION_CORNER_TOPLEFT as u32;
862         #[doc(alias = "GTK_JUNCTION_CORNER_TOPRIGHT")]
863         const CORNER_TOPRIGHT = ffi::GTK_JUNCTION_CORNER_TOPRIGHT as u32;
864         #[doc(alias = "GTK_JUNCTION_CORNER_BOTTOMLEFT")]
865         const CORNER_BOTTOMLEFT = ffi::GTK_JUNCTION_CORNER_BOTTOMLEFT as u32;
866         #[doc(alias = "GTK_JUNCTION_CORNER_BOTTOMRIGHT")]
867         const CORNER_BOTTOMRIGHT = ffi::GTK_JUNCTION_CORNER_BOTTOMRIGHT as u32;
868         #[doc(alias = "GTK_JUNCTION_TOP")]
869         const TOP = ffi::GTK_JUNCTION_TOP as u32;
870         #[doc(alias = "GTK_JUNCTION_BOTTOM")]
871         const BOTTOM = ffi::GTK_JUNCTION_BOTTOM as u32;
872         #[doc(alias = "GTK_JUNCTION_LEFT")]
873         const LEFT = ffi::GTK_JUNCTION_LEFT as u32;
874         #[doc(alias = "GTK_JUNCTION_RIGHT")]
875         const RIGHT = ffi::GTK_JUNCTION_RIGHT as u32;
876     }
877 }
878 
879 impl fmt::Display for JunctionSides {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result880     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
881         <Self as fmt::Debug>::fmt(self, f)
882     }
883 }
884 
885 #[doc(hidden)]
886 impl IntoGlib for JunctionSides {
887     type GlibType = ffi::GtkJunctionSides;
888 
into_glib(self) -> ffi::GtkJunctionSides889     fn into_glib(self) -> ffi::GtkJunctionSides {
890         self.bits()
891     }
892 }
893 
894 #[doc(hidden)]
895 impl FromGlib<ffi::GtkJunctionSides> for JunctionSides {
from_glib(value: ffi::GtkJunctionSides) -> Self896     unsafe fn from_glib(value: ffi::GtkJunctionSides) -> Self {
897         skip_assert_initialized!();
898         Self::from_bits_truncate(value)
899     }
900 }
901 
902 impl StaticType for JunctionSides {
static_type() -> Type903     fn static_type() -> Type {
904         unsafe { from_glib(ffi::gtk_junction_sides_get_type()) }
905     }
906 }
907 
908 impl glib::value::ValueType for JunctionSides {
909     type Type = Self;
910 }
911 
912 unsafe impl<'a> FromValue<'a> for JunctionSides {
913     type Checker = glib::value::GenericValueTypeChecker<Self>;
914 
from_value(value: &'a glib::Value) -> Self915     unsafe fn from_value(value: &'a glib::Value) -> Self {
916         skip_assert_initialized!();
917         from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
918     }
919 }
920 
921 impl ToValue for JunctionSides {
to_value(&self) -> glib::Value922     fn to_value(&self) -> glib::Value {
923         let mut value = glib::Value::for_value_type::<Self>();
924         unsafe {
925             glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
926         }
927         value
928     }
929 
value_type(&self) -> glib::Type930     fn value_type(&self) -> glib::Type {
931         Self::static_type()
932     }
933 }
934 
935 bitflags! {
936     #[doc(alias = "GtkPlacesOpenFlags")]
937     pub struct PlacesOpenFlags: u32 {
938         #[doc(alias = "GTK_PLACES_OPEN_NORMAL")]
939         const NORMAL = ffi::GTK_PLACES_OPEN_NORMAL as u32;
940         #[doc(alias = "GTK_PLACES_OPEN_NEW_TAB")]
941         const NEW_TAB = ffi::GTK_PLACES_OPEN_NEW_TAB as u32;
942         #[doc(alias = "GTK_PLACES_OPEN_NEW_WINDOW")]
943         const NEW_WINDOW = ffi::GTK_PLACES_OPEN_NEW_WINDOW as u32;
944     }
945 }
946 
947 impl fmt::Display for PlacesOpenFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result948     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
949         <Self as fmt::Debug>::fmt(self, f)
950     }
951 }
952 
953 #[doc(hidden)]
954 impl IntoGlib for PlacesOpenFlags {
955     type GlibType = ffi::GtkPlacesOpenFlags;
956 
into_glib(self) -> ffi::GtkPlacesOpenFlags957     fn into_glib(self) -> ffi::GtkPlacesOpenFlags {
958         self.bits()
959     }
960 }
961 
962 #[doc(hidden)]
963 impl FromGlib<ffi::GtkPlacesOpenFlags> for PlacesOpenFlags {
from_glib(value: ffi::GtkPlacesOpenFlags) -> Self964     unsafe fn from_glib(value: ffi::GtkPlacesOpenFlags) -> Self {
965         skip_assert_initialized!();
966         Self::from_bits_truncate(value)
967     }
968 }
969 
970 impl StaticType for PlacesOpenFlags {
static_type() -> Type971     fn static_type() -> Type {
972         unsafe { from_glib(ffi::gtk_places_open_flags_get_type()) }
973     }
974 }
975 
976 impl glib::value::ValueType for PlacesOpenFlags {
977     type Type = Self;
978 }
979 
980 unsafe impl<'a> FromValue<'a> for PlacesOpenFlags {
981     type Checker = glib::value::GenericValueTypeChecker<Self>;
982 
from_value(value: &'a glib::Value) -> Self983     unsafe fn from_value(value: &'a glib::Value) -> Self {
984         skip_assert_initialized!();
985         from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
986     }
987 }
988 
989 impl ToValue for PlacesOpenFlags {
to_value(&self) -> glib::Value990     fn to_value(&self) -> glib::Value {
991         let mut value = glib::Value::for_value_type::<Self>();
992         unsafe {
993             glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
994         }
995         value
996     }
997 
value_type(&self) -> glib::Type998     fn value_type(&self) -> glib::Type {
999         Self::static_type()
1000     }
1001 }
1002 
1003 bitflags! {
1004     #[doc(alias = "GtkRecentFilterFlags")]
1005     pub struct RecentFilterFlags: u32 {
1006         #[doc(alias = "GTK_RECENT_FILTER_URI")]
1007         const URI = ffi::GTK_RECENT_FILTER_URI as u32;
1008         #[doc(alias = "GTK_RECENT_FILTER_DISPLAY_NAME")]
1009         const DISPLAY_NAME = ffi::GTK_RECENT_FILTER_DISPLAY_NAME as u32;
1010         #[doc(alias = "GTK_RECENT_FILTER_MIME_TYPE")]
1011         const MIME_TYPE = ffi::GTK_RECENT_FILTER_MIME_TYPE as u32;
1012         #[doc(alias = "GTK_RECENT_FILTER_APPLICATION")]
1013         const APPLICATION = ffi::GTK_RECENT_FILTER_APPLICATION as u32;
1014         #[doc(alias = "GTK_RECENT_FILTER_GROUP")]
1015         const GROUP = ffi::GTK_RECENT_FILTER_GROUP as u32;
1016         #[doc(alias = "GTK_RECENT_FILTER_AGE")]
1017         const AGE = ffi::GTK_RECENT_FILTER_AGE as u32;
1018     }
1019 }
1020 
1021 impl fmt::Display for RecentFilterFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1022     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1023         <Self as fmt::Debug>::fmt(self, f)
1024     }
1025 }
1026 
1027 #[doc(hidden)]
1028 impl IntoGlib for RecentFilterFlags {
1029     type GlibType = ffi::GtkRecentFilterFlags;
1030 
into_glib(self) -> ffi::GtkRecentFilterFlags1031     fn into_glib(self) -> ffi::GtkRecentFilterFlags {
1032         self.bits()
1033     }
1034 }
1035 
1036 #[doc(hidden)]
1037 impl FromGlib<ffi::GtkRecentFilterFlags> for RecentFilterFlags {
from_glib(value: ffi::GtkRecentFilterFlags) -> Self1038     unsafe fn from_glib(value: ffi::GtkRecentFilterFlags) -> Self {
1039         skip_assert_initialized!();
1040         Self::from_bits_truncate(value)
1041     }
1042 }
1043 
1044 impl StaticType for RecentFilterFlags {
static_type() -> Type1045     fn static_type() -> Type {
1046         unsafe { from_glib(ffi::gtk_recent_filter_flags_get_type()) }
1047     }
1048 }
1049 
1050 impl glib::value::ValueType for RecentFilterFlags {
1051     type Type = Self;
1052 }
1053 
1054 unsafe impl<'a> FromValue<'a> for RecentFilterFlags {
1055     type Checker = glib::value::GenericValueTypeChecker<Self>;
1056 
from_value(value: &'a glib::Value) -> Self1057     unsafe fn from_value(value: &'a glib::Value) -> Self {
1058         skip_assert_initialized!();
1059         from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1060     }
1061 }
1062 
1063 impl ToValue for RecentFilterFlags {
to_value(&self) -> glib::Value1064     fn to_value(&self) -> glib::Value {
1065         let mut value = glib::Value::for_value_type::<Self>();
1066         unsafe {
1067             glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1068         }
1069         value
1070     }
1071 
value_type(&self) -> glib::Type1072     fn value_type(&self) -> glib::Type {
1073         Self::static_type()
1074     }
1075 }
1076 
1077 bitflags! {
1078     #[doc(alias = "GtkRegionFlags")]
1079     pub struct RegionFlags: u32 {
1080         #[doc(alias = "GTK_REGION_EVEN")]
1081         const EVEN = ffi::GTK_REGION_EVEN as u32;
1082         #[doc(alias = "GTK_REGION_ODD")]
1083         const ODD = ffi::GTK_REGION_ODD as u32;
1084         #[doc(alias = "GTK_REGION_FIRST")]
1085         const FIRST = ffi::GTK_REGION_FIRST as u32;
1086         #[doc(alias = "GTK_REGION_LAST")]
1087         const LAST = ffi::GTK_REGION_LAST as u32;
1088         #[doc(alias = "GTK_REGION_ONLY")]
1089         const ONLY = ffi::GTK_REGION_ONLY as u32;
1090         #[doc(alias = "GTK_REGION_SORTED")]
1091         const SORTED = ffi::GTK_REGION_SORTED as u32;
1092     }
1093 }
1094 
1095 impl fmt::Display for RegionFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1096     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1097         <Self as fmt::Debug>::fmt(self, f)
1098     }
1099 }
1100 
1101 #[doc(hidden)]
1102 impl IntoGlib for RegionFlags {
1103     type GlibType = ffi::GtkRegionFlags;
1104 
into_glib(self) -> ffi::GtkRegionFlags1105     fn into_glib(self) -> ffi::GtkRegionFlags {
1106         self.bits()
1107     }
1108 }
1109 
1110 #[doc(hidden)]
1111 impl FromGlib<ffi::GtkRegionFlags> for RegionFlags {
from_glib(value: ffi::GtkRegionFlags) -> Self1112     unsafe fn from_glib(value: ffi::GtkRegionFlags) -> Self {
1113         skip_assert_initialized!();
1114         Self::from_bits_truncate(value)
1115     }
1116 }
1117 
1118 impl StaticType for RegionFlags {
static_type() -> Type1119     fn static_type() -> Type {
1120         unsafe { from_glib(ffi::gtk_region_flags_get_type()) }
1121     }
1122 }
1123 
1124 impl glib::value::ValueType for RegionFlags {
1125     type Type = Self;
1126 }
1127 
1128 unsafe impl<'a> FromValue<'a> for RegionFlags {
1129     type Checker = glib::value::GenericValueTypeChecker<Self>;
1130 
from_value(value: &'a glib::Value) -> Self1131     unsafe fn from_value(value: &'a glib::Value) -> Self {
1132         skip_assert_initialized!();
1133         from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1134     }
1135 }
1136 
1137 impl ToValue for RegionFlags {
to_value(&self) -> glib::Value1138     fn to_value(&self) -> glib::Value {
1139         let mut value = glib::Value::for_value_type::<Self>();
1140         unsafe {
1141             glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1142         }
1143         value
1144     }
1145 
value_type(&self) -> glib::Type1146     fn value_type(&self) -> glib::Type {
1147         Self::static_type()
1148     }
1149 }
1150 
1151 bitflags! {
1152     #[doc(alias = "GtkStateFlags")]
1153     pub struct StateFlags: u32 {
1154         #[doc(alias = "GTK_STATE_FLAG_NORMAL")]
1155         const NORMAL = ffi::GTK_STATE_FLAG_NORMAL as u32;
1156         #[doc(alias = "GTK_STATE_FLAG_ACTIVE")]
1157         const ACTIVE = ffi::GTK_STATE_FLAG_ACTIVE as u32;
1158         #[doc(alias = "GTK_STATE_FLAG_PRELIGHT")]
1159         const PRELIGHT = ffi::GTK_STATE_FLAG_PRELIGHT as u32;
1160         #[doc(alias = "GTK_STATE_FLAG_SELECTED")]
1161         const SELECTED = ffi::GTK_STATE_FLAG_SELECTED as u32;
1162         #[doc(alias = "GTK_STATE_FLAG_INSENSITIVE")]
1163         const INSENSITIVE = ffi::GTK_STATE_FLAG_INSENSITIVE as u32;
1164         #[doc(alias = "GTK_STATE_FLAG_INCONSISTENT")]
1165         const INCONSISTENT = ffi::GTK_STATE_FLAG_INCONSISTENT as u32;
1166         #[doc(alias = "GTK_STATE_FLAG_FOCUSED")]
1167         const FOCUSED = ffi::GTK_STATE_FLAG_FOCUSED as u32;
1168         #[doc(alias = "GTK_STATE_FLAG_BACKDROP")]
1169         const BACKDROP = ffi::GTK_STATE_FLAG_BACKDROP as u32;
1170         #[doc(alias = "GTK_STATE_FLAG_DIR_LTR")]
1171         const DIR_LTR = ffi::GTK_STATE_FLAG_DIR_LTR as u32;
1172         #[doc(alias = "GTK_STATE_FLAG_DIR_RTL")]
1173         const DIR_RTL = ffi::GTK_STATE_FLAG_DIR_RTL as u32;
1174         #[doc(alias = "GTK_STATE_FLAG_LINK")]
1175         const LINK = ffi::GTK_STATE_FLAG_LINK as u32;
1176         #[doc(alias = "GTK_STATE_FLAG_VISITED")]
1177         const VISITED = ffi::GTK_STATE_FLAG_VISITED as u32;
1178         #[doc(alias = "GTK_STATE_FLAG_CHECKED")]
1179         const CHECKED = ffi::GTK_STATE_FLAG_CHECKED as u32;
1180         #[doc(alias = "GTK_STATE_FLAG_DROP_ACTIVE")]
1181         const DROP_ACTIVE = ffi::GTK_STATE_FLAG_DROP_ACTIVE as u32;
1182     }
1183 }
1184 
1185 impl fmt::Display for StateFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1186     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1187         <Self as fmt::Debug>::fmt(self, f)
1188     }
1189 }
1190 
1191 #[doc(hidden)]
1192 impl IntoGlib for StateFlags {
1193     type GlibType = ffi::GtkStateFlags;
1194 
into_glib(self) -> ffi::GtkStateFlags1195     fn into_glib(self) -> ffi::GtkStateFlags {
1196         self.bits()
1197     }
1198 }
1199 
1200 #[doc(hidden)]
1201 impl FromGlib<ffi::GtkStateFlags> for StateFlags {
from_glib(value: ffi::GtkStateFlags) -> Self1202     unsafe fn from_glib(value: ffi::GtkStateFlags) -> Self {
1203         skip_assert_initialized!();
1204         Self::from_bits_truncate(value)
1205     }
1206 }
1207 
1208 impl StaticType for StateFlags {
static_type() -> Type1209     fn static_type() -> Type {
1210         unsafe { from_glib(ffi::gtk_state_flags_get_type()) }
1211     }
1212 }
1213 
1214 impl glib::value::ValueType for StateFlags {
1215     type Type = Self;
1216 }
1217 
1218 unsafe impl<'a> FromValue<'a> for StateFlags {
1219     type Checker = glib::value::GenericValueTypeChecker<Self>;
1220 
from_value(value: &'a glib::Value) -> Self1221     unsafe fn from_value(value: &'a glib::Value) -> Self {
1222         skip_assert_initialized!();
1223         from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1224     }
1225 }
1226 
1227 impl ToValue for StateFlags {
to_value(&self) -> glib::Value1228     fn to_value(&self) -> glib::Value {
1229         let mut value = glib::Value::for_value_type::<Self>();
1230         unsafe {
1231             glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1232         }
1233         value
1234     }
1235 
value_type(&self) -> glib::Type1236     fn value_type(&self) -> glib::Type {
1237         Self::static_type()
1238     }
1239 }
1240 
1241 #[cfg(any(feature = "v3_20", feature = "dox"))]
1242 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))]
1243 bitflags! {
1244     #[doc(alias = "GtkStyleContextPrintFlags")]
1245     pub struct StyleContextPrintFlags: u32 {
1246         #[doc(alias = "GTK_STYLE_CONTEXT_PRINT_NONE")]
1247         const NONE = ffi::GTK_STYLE_CONTEXT_PRINT_NONE as u32;
1248         #[doc(alias = "GTK_STYLE_CONTEXT_PRINT_RECURSE")]
1249         const RECURSE = ffi::GTK_STYLE_CONTEXT_PRINT_RECURSE as u32;
1250         #[doc(alias = "GTK_STYLE_CONTEXT_PRINT_SHOW_STYLE")]
1251         const SHOW_STYLE = ffi::GTK_STYLE_CONTEXT_PRINT_SHOW_STYLE as u32;
1252     }
1253 }
1254 
1255 #[cfg(any(feature = "v3_20", feature = "dox"))]
1256 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))]
1257 impl fmt::Display for StyleContextPrintFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1258     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1259         <Self as fmt::Debug>::fmt(self, f)
1260     }
1261 }
1262 
1263 #[cfg(any(feature = "v3_20", feature = "dox"))]
1264 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))]
1265 #[doc(hidden)]
1266 impl IntoGlib for StyleContextPrintFlags {
1267     type GlibType = ffi::GtkStyleContextPrintFlags;
1268 
into_glib(self) -> ffi::GtkStyleContextPrintFlags1269     fn into_glib(self) -> ffi::GtkStyleContextPrintFlags {
1270         self.bits()
1271     }
1272 }
1273 
1274 #[cfg(any(feature = "v3_20", feature = "dox"))]
1275 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))]
1276 #[doc(hidden)]
1277 impl FromGlib<ffi::GtkStyleContextPrintFlags> for StyleContextPrintFlags {
from_glib(value: ffi::GtkStyleContextPrintFlags) -> Self1278     unsafe fn from_glib(value: ffi::GtkStyleContextPrintFlags) -> Self {
1279         skip_assert_initialized!();
1280         Self::from_bits_truncate(value)
1281     }
1282 }
1283 
1284 #[cfg(any(feature = "v3_20", feature = "dox"))]
1285 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))]
1286 impl StaticType for StyleContextPrintFlags {
static_type() -> Type1287     fn static_type() -> Type {
1288         unsafe { from_glib(ffi::gtk_style_context_print_flags_get_type()) }
1289     }
1290 }
1291 
1292 #[cfg(any(feature = "v3_20", feature = "dox"))]
1293 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))]
1294 impl glib::value::ValueType for StyleContextPrintFlags {
1295     type Type = Self;
1296 }
1297 
1298 #[cfg(any(feature = "v3_20", feature = "dox"))]
1299 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))]
1300 unsafe impl<'a> FromValue<'a> for StyleContextPrintFlags {
1301     type Checker = glib::value::GenericValueTypeChecker<Self>;
1302 
from_value(value: &'a glib::Value) -> Self1303     unsafe fn from_value(value: &'a glib::Value) -> Self {
1304         skip_assert_initialized!();
1305         from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1306     }
1307 }
1308 
1309 #[cfg(any(feature = "v3_20", feature = "dox"))]
1310 #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))]
1311 impl ToValue for StyleContextPrintFlags {
to_value(&self) -> glib::Value1312     fn to_value(&self) -> glib::Value {
1313         let mut value = glib::Value::for_value_type::<Self>();
1314         unsafe {
1315             glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1316         }
1317         value
1318     }
1319 
value_type(&self) -> glib::Type1320     fn value_type(&self) -> glib::Type {
1321         Self::static_type()
1322     }
1323 }
1324 
1325 bitflags! {
1326     #[doc(alias = "GtkTargetFlags")]
1327     pub struct TargetFlags: u32 {
1328         #[doc(alias = "GTK_TARGET_SAME_APP")]
1329         const SAME_APP = ffi::GTK_TARGET_SAME_APP as u32;
1330         #[doc(alias = "GTK_TARGET_SAME_WIDGET")]
1331         const SAME_WIDGET = ffi::GTK_TARGET_SAME_WIDGET as u32;
1332         #[doc(alias = "GTK_TARGET_OTHER_APP")]
1333         const OTHER_APP = ffi::GTK_TARGET_OTHER_APP as u32;
1334         #[doc(alias = "GTK_TARGET_OTHER_WIDGET")]
1335         const OTHER_WIDGET = ffi::GTK_TARGET_OTHER_WIDGET as u32;
1336     }
1337 }
1338 
1339 impl fmt::Display for TargetFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1340     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1341         <Self as fmt::Debug>::fmt(self, f)
1342     }
1343 }
1344 
1345 #[doc(hidden)]
1346 impl IntoGlib for TargetFlags {
1347     type GlibType = ffi::GtkTargetFlags;
1348 
into_glib(self) -> ffi::GtkTargetFlags1349     fn into_glib(self) -> ffi::GtkTargetFlags {
1350         self.bits()
1351     }
1352 }
1353 
1354 #[doc(hidden)]
1355 impl FromGlib<ffi::GtkTargetFlags> for TargetFlags {
from_glib(value: ffi::GtkTargetFlags) -> Self1356     unsafe fn from_glib(value: ffi::GtkTargetFlags) -> Self {
1357         skip_assert_initialized!();
1358         Self::from_bits_truncate(value)
1359     }
1360 }
1361 
1362 impl StaticType for TargetFlags {
static_type() -> Type1363     fn static_type() -> Type {
1364         unsafe { from_glib(ffi::gtk_target_flags_get_type()) }
1365     }
1366 }
1367 
1368 impl glib::value::ValueType for TargetFlags {
1369     type Type = Self;
1370 }
1371 
1372 unsafe impl<'a> FromValue<'a> for TargetFlags {
1373     type Checker = glib::value::GenericValueTypeChecker<Self>;
1374 
from_value(value: &'a glib::Value) -> Self1375     unsafe fn from_value(value: &'a glib::Value) -> Self {
1376         skip_assert_initialized!();
1377         from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1378     }
1379 }
1380 
1381 impl ToValue for TargetFlags {
to_value(&self) -> glib::Value1382     fn to_value(&self) -> glib::Value {
1383         let mut value = glib::Value::for_value_type::<Self>();
1384         unsafe {
1385             glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1386         }
1387         value
1388     }
1389 
value_type(&self) -> glib::Type1390     fn value_type(&self) -> glib::Type {
1391         Self::static_type()
1392     }
1393 }
1394 
1395 bitflags! {
1396     #[doc(alias = "GtkTextSearchFlags")]
1397     pub struct TextSearchFlags: u32 {
1398         #[doc(alias = "GTK_TEXT_SEARCH_VISIBLE_ONLY")]
1399         const VISIBLE_ONLY = ffi::GTK_TEXT_SEARCH_VISIBLE_ONLY as u32;
1400         #[doc(alias = "GTK_TEXT_SEARCH_TEXT_ONLY")]
1401         const TEXT_ONLY = ffi::GTK_TEXT_SEARCH_TEXT_ONLY as u32;
1402         #[doc(alias = "GTK_TEXT_SEARCH_CASE_INSENSITIVE")]
1403         const CASE_INSENSITIVE = ffi::GTK_TEXT_SEARCH_CASE_INSENSITIVE as u32;
1404     }
1405 }
1406 
1407 impl fmt::Display for TextSearchFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1408     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1409         <Self as fmt::Debug>::fmt(self, f)
1410     }
1411 }
1412 
1413 #[doc(hidden)]
1414 impl IntoGlib for TextSearchFlags {
1415     type GlibType = ffi::GtkTextSearchFlags;
1416 
into_glib(self) -> ffi::GtkTextSearchFlags1417     fn into_glib(self) -> ffi::GtkTextSearchFlags {
1418         self.bits()
1419     }
1420 }
1421 
1422 #[doc(hidden)]
1423 impl FromGlib<ffi::GtkTextSearchFlags> for TextSearchFlags {
from_glib(value: ffi::GtkTextSearchFlags) -> Self1424     unsafe fn from_glib(value: ffi::GtkTextSearchFlags) -> Self {
1425         skip_assert_initialized!();
1426         Self::from_bits_truncate(value)
1427     }
1428 }
1429 
1430 impl StaticType for TextSearchFlags {
static_type() -> Type1431     fn static_type() -> Type {
1432         unsafe { from_glib(ffi::gtk_text_search_flags_get_type()) }
1433     }
1434 }
1435 
1436 impl glib::value::ValueType for TextSearchFlags {
1437     type Type = Self;
1438 }
1439 
1440 unsafe impl<'a> FromValue<'a> for TextSearchFlags {
1441     type Checker = glib::value::GenericValueTypeChecker<Self>;
1442 
from_value(value: &'a glib::Value) -> Self1443     unsafe fn from_value(value: &'a glib::Value) -> Self {
1444         skip_assert_initialized!();
1445         from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1446     }
1447 }
1448 
1449 impl ToValue for TextSearchFlags {
to_value(&self) -> glib::Value1450     fn to_value(&self) -> glib::Value {
1451         let mut value = glib::Value::for_value_type::<Self>();
1452         unsafe {
1453             glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1454         }
1455         value
1456     }
1457 
value_type(&self) -> glib::Type1458     fn value_type(&self) -> glib::Type {
1459         Self::static_type()
1460     }
1461 }
1462 
1463 bitflags! {
1464     #[doc(alias = "GtkToolPaletteDragTargets")]
1465     pub struct ToolPaletteDragTargets: u32 {
1466         #[doc(alias = "GTK_TOOL_PALETTE_DRAG_ITEMS")]
1467         const ITEMS = ffi::GTK_TOOL_PALETTE_DRAG_ITEMS as u32;
1468         #[doc(alias = "GTK_TOOL_PALETTE_DRAG_GROUPS")]
1469         const GROUPS = ffi::GTK_TOOL_PALETTE_DRAG_GROUPS as u32;
1470     }
1471 }
1472 
1473 impl fmt::Display for ToolPaletteDragTargets {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1474     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1475         <Self as fmt::Debug>::fmt(self, f)
1476     }
1477 }
1478 
1479 #[doc(hidden)]
1480 impl IntoGlib for ToolPaletteDragTargets {
1481     type GlibType = ffi::GtkToolPaletteDragTargets;
1482 
into_glib(self) -> ffi::GtkToolPaletteDragTargets1483     fn into_glib(self) -> ffi::GtkToolPaletteDragTargets {
1484         self.bits()
1485     }
1486 }
1487 
1488 #[doc(hidden)]
1489 impl FromGlib<ffi::GtkToolPaletteDragTargets> for ToolPaletteDragTargets {
from_glib(value: ffi::GtkToolPaletteDragTargets) -> Self1490     unsafe fn from_glib(value: ffi::GtkToolPaletteDragTargets) -> Self {
1491         skip_assert_initialized!();
1492         Self::from_bits_truncate(value)
1493     }
1494 }
1495 
1496 impl StaticType for ToolPaletteDragTargets {
static_type() -> Type1497     fn static_type() -> Type {
1498         unsafe { from_glib(ffi::gtk_tool_palette_drag_targets_get_type()) }
1499     }
1500 }
1501 
1502 impl glib::value::ValueType for ToolPaletteDragTargets {
1503     type Type = Self;
1504 }
1505 
1506 unsafe impl<'a> FromValue<'a> for ToolPaletteDragTargets {
1507     type Checker = glib::value::GenericValueTypeChecker<Self>;
1508 
from_value(value: &'a glib::Value) -> Self1509     unsafe fn from_value(value: &'a glib::Value) -> Self {
1510         skip_assert_initialized!();
1511         from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1512     }
1513 }
1514 
1515 impl ToValue for ToolPaletteDragTargets {
to_value(&self) -> glib::Value1516     fn to_value(&self) -> glib::Value {
1517         let mut value = glib::Value::for_value_type::<Self>();
1518         unsafe {
1519             glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1520         }
1521         value
1522     }
1523 
value_type(&self) -> glib::Type1524     fn value_type(&self) -> glib::Type {
1525         Self::static_type()
1526     }
1527 }
1528 
1529 bitflags! {
1530     #[doc(alias = "GtkTreeModelFlags")]
1531     pub struct TreeModelFlags: u32 {
1532         #[doc(alias = "GTK_TREE_MODEL_ITERS_PERSIST")]
1533         const ITERS_PERSIST = ffi::GTK_TREE_MODEL_ITERS_PERSIST as u32;
1534         #[doc(alias = "GTK_TREE_MODEL_LIST_ONLY")]
1535         const LIST_ONLY = ffi::GTK_TREE_MODEL_LIST_ONLY as u32;
1536     }
1537 }
1538 
1539 impl fmt::Display for TreeModelFlags {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result1540     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1541         <Self as fmt::Debug>::fmt(self, f)
1542     }
1543 }
1544 
1545 #[doc(hidden)]
1546 impl IntoGlib for TreeModelFlags {
1547     type GlibType = ffi::GtkTreeModelFlags;
1548 
into_glib(self) -> ffi::GtkTreeModelFlags1549     fn into_glib(self) -> ffi::GtkTreeModelFlags {
1550         self.bits()
1551     }
1552 }
1553 
1554 #[doc(hidden)]
1555 impl FromGlib<ffi::GtkTreeModelFlags> for TreeModelFlags {
from_glib(value: ffi::GtkTreeModelFlags) -> Self1556     unsafe fn from_glib(value: ffi::GtkTreeModelFlags) -> Self {
1557         skip_assert_initialized!();
1558         Self::from_bits_truncate(value)
1559     }
1560 }
1561 
1562 impl StaticType for TreeModelFlags {
static_type() -> Type1563     fn static_type() -> Type {
1564         unsafe { from_glib(ffi::gtk_tree_model_flags_get_type()) }
1565     }
1566 }
1567 
1568 impl glib::value::ValueType for TreeModelFlags {
1569     type Type = Self;
1570 }
1571 
1572 unsafe impl<'a> FromValue<'a> for TreeModelFlags {
1573     type Checker = glib::value::GenericValueTypeChecker<Self>;
1574 
from_value(value: &'a glib::Value) -> Self1575     unsafe fn from_value(value: &'a glib::Value) -> Self {
1576         skip_assert_initialized!();
1577         from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0))
1578     }
1579 }
1580 
1581 impl ToValue for TreeModelFlags {
to_value(&self) -> glib::Value1582     fn to_value(&self) -> glib::Value {
1583         let mut value = glib::Value::for_value_type::<Self>();
1584         unsafe {
1585             glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1586         }
1587         value
1588     }
1589 
value_type(&self) -> glib::Type1590     fn value_type(&self) -> glib::Type {
1591         Self::static_type()
1592     }
1593 }
1594