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 unsafe { 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 unsafe { 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 unsafe { 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 #[cfg(feature = "v4_22")]
346 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
347 #[doc(alias = "GTK_DEBUG_SESSION")]
348 const SESSION = ffi::GTK_DEBUG_SESSION as _;
349 }
350}
351
352#[doc(hidden)]
353impl IntoGlib for DebugFlags {
354 type GlibType = ffi::GtkDebugFlags;
355
356 #[inline]
357 fn into_glib(self) -> ffi::GtkDebugFlags {
358 self.bits()
359 }
360}
361
362#[doc(hidden)]
363impl FromGlib<ffi::GtkDebugFlags> for DebugFlags {
364 #[inline]
365 unsafe fn from_glib(value: ffi::GtkDebugFlags) -> Self {
366 skip_assert_initialized!();
367 Self::from_bits_truncate(value)
368 }
369}
370
371impl StaticType for DebugFlags {
372 #[inline]
373 #[doc(alias = "gtk_debug_flags_get_type")]
374 fn static_type() -> glib::Type {
375 unsafe { from_glib(ffi::gtk_debug_flags_get_type()) }
376 }
377}
378
379impl glib::HasParamSpec for DebugFlags {
380 type ParamSpec = glib::ParamSpecFlags;
381 type SetValue = Self;
382 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
383
384 fn param_spec_builder() -> Self::BuilderFn {
385 Self::ParamSpec::builder
386 }
387}
388
389impl glib::value::ValueType for DebugFlags {
390 type Type = Self;
391}
392
393unsafe impl<'a> glib::value::FromValue<'a> for DebugFlags {
394 type Checker = glib::value::GenericValueTypeChecker<Self>;
395
396 #[inline]
397 unsafe fn from_value(value: &'a glib::Value) -> Self {
398 skip_assert_initialized!();
399 unsafe { from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) }
400 }
401}
402
403impl ToValue for DebugFlags {
404 #[inline]
405 fn to_value(&self) -> glib::Value {
406 let mut value = glib::Value::for_value_type::<Self>();
407 unsafe {
408 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
409 }
410 value
411 }
412
413 #[inline]
414 fn value_type(&self) -> glib::Type {
415 Self::static_type()
416 }
417}
418
419impl From<DebugFlags> for glib::Value {
420 #[inline]
421 fn from(v: DebugFlags) -> Self {
422 skip_assert_initialized!();
423 ToValue::to_value(&v)
424 }
425}
426
427bitflags! {
428 #[cfg_attr(feature = "v4_20", deprecated = "Since 4.20")]
429 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
430 #[doc(alias = "GtkDialogFlags")]
431 pub struct DialogFlags: u32 {
432 #[doc(alias = "GTK_DIALOG_MODAL")]
433 const MODAL = ffi::GTK_DIALOG_MODAL as _;
434 #[doc(alias = "GTK_DIALOG_DESTROY_WITH_PARENT")]
435 const DESTROY_WITH_PARENT = ffi::GTK_DIALOG_DESTROY_WITH_PARENT as _;
436 #[doc(alias = "GTK_DIALOG_USE_HEADER_BAR")]
437 const USE_HEADER_BAR = ffi::GTK_DIALOG_USE_HEADER_BAR as _;
438 }
439}
440
441#[allow(deprecated)]
442#[doc(hidden)]
443impl IntoGlib for DialogFlags {
444 type GlibType = ffi::GtkDialogFlags;
445
446 #[inline]
447 fn into_glib(self) -> ffi::GtkDialogFlags {
448 self.bits()
449 }
450}
451
452#[allow(deprecated)]
453#[doc(hidden)]
454impl FromGlib<ffi::GtkDialogFlags> for DialogFlags {
455 #[inline]
456 unsafe fn from_glib(value: ffi::GtkDialogFlags) -> Self {
457 skip_assert_initialized!();
458 Self::from_bits_truncate(value)
459 }
460}
461
462#[allow(deprecated)]
463impl StaticType for DialogFlags {
464 #[inline]
465 #[doc(alias = "gtk_dialog_flags_get_type")]
466 fn static_type() -> glib::Type {
467 unsafe { from_glib(ffi::gtk_dialog_flags_get_type()) }
468 }
469}
470
471#[allow(deprecated)]
472impl glib::HasParamSpec for DialogFlags {
473 type ParamSpec = glib::ParamSpecFlags;
474 type SetValue = Self;
475 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
476
477 fn param_spec_builder() -> Self::BuilderFn {
478 Self::ParamSpec::builder
479 }
480}
481
482#[allow(deprecated)]
483impl glib::value::ValueType for DialogFlags {
484 type Type = Self;
485}
486
487#[allow(deprecated)]
488unsafe impl<'a> glib::value::FromValue<'a> for DialogFlags {
489 type Checker = glib::value::GenericValueTypeChecker<Self>;
490
491 #[inline]
492 unsafe fn from_value(value: &'a glib::Value) -> Self {
493 skip_assert_initialized!();
494 unsafe { from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) }
495 }
496}
497
498#[allow(deprecated)]
499impl ToValue for DialogFlags {
500 #[inline]
501 fn to_value(&self) -> glib::Value {
502 let mut value = glib::Value::for_value_type::<Self>();
503 unsafe {
504 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
505 }
506 value
507 }
508
509 #[inline]
510 fn value_type(&self) -> glib::Type {
511 Self::static_type()
512 }
513}
514
515#[allow(deprecated)]
516impl From<DialogFlags> for glib::Value {
517 #[inline]
518 fn from(v: DialogFlags) -> Self {
519 skip_assert_initialized!();
520 ToValue::to_value(&v)
521 }
522}
523
524bitflags! {
525 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
526 #[doc(alias = "GtkEventControllerScrollFlags")]
527 pub struct EventControllerScrollFlags: u32 {
528 #[doc(alias = "GTK_EVENT_CONTROLLER_SCROLL_NONE")]
529 const NONE = ffi::GTK_EVENT_CONTROLLER_SCROLL_NONE as _;
530 #[doc(alias = "GTK_EVENT_CONTROLLER_SCROLL_VERTICAL")]
531 const VERTICAL = ffi::GTK_EVENT_CONTROLLER_SCROLL_VERTICAL as _;
532 #[doc(alias = "GTK_EVENT_CONTROLLER_SCROLL_HORIZONTAL")]
533 const HORIZONTAL = ffi::GTK_EVENT_CONTROLLER_SCROLL_HORIZONTAL as _;
534 #[doc(alias = "GTK_EVENT_CONTROLLER_SCROLL_DISCRETE")]
535 const DISCRETE = ffi::GTK_EVENT_CONTROLLER_SCROLL_DISCRETE as _;
536 #[doc(alias = "GTK_EVENT_CONTROLLER_SCROLL_KINETIC")]
537 const KINETIC = ffi::GTK_EVENT_CONTROLLER_SCROLL_KINETIC as _;
538 #[cfg(feature = "v4_20")]
539 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
540 #[doc(alias = "GTK_EVENT_CONTROLLER_SCROLL_PHYSICAL_DIRECTION")]
541 const PHYSICAL_DIRECTION = ffi::GTK_EVENT_CONTROLLER_SCROLL_PHYSICAL_DIRECTION as _;
542 #[doc(alias = "GTK_EVENT_CONTROLLER_SCROLL_BOTH_AXES")]
543 const BOTH_AXES = ffi::GTK_EVENT_CONTROLLER_SCROLL_BOTH_AXES as _;
544 }
545}
546
547#[doc(hidden)]
548impl IntoGlib for EventControllerScrollFlags {
549 type GlibType = ffi::GtkEventControllerScrollFlags;
550
551 #[inline]
552 fn into_glib(self) -> ffi::GtkEventControllerScrollFlags {
553 self.bits()
554 }
555}
556
557#[doc(hidden)]
558impl FromGlib<ffi::GtkEventControllerScrollFlags> for EventControllerScrollFlags {
559 #[inline]
560 unsafe fn from_glib(value: ffi::GtkEventControllerScrollFlags) -> Self {
561 skip_assert_initialized!();
562 Self::from_bits_truncate(value)
563 }
564}
565
566impl StaticType for EventControllerScrollFlags {
567 #[inline]
568 #[doc(alias = "gtk_event_controller_scroll_flags_get_type")]
569 fn static_type() -> glib::Type {
570 unsafe { from_glib(ffi::gtk_event_controller_scroll_flags_get_type()) }
571 }
572}
573
574impl glib::HasParamSpec for EventControllerScrollFlags {
575 type ParamSpec = glib::ParamSpecFlags;
576 type SetValue = Self;
577 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
578
579 fn param_spec_builder() -> Self::BuilderFn {
580 Self::ParamSpec::builder
581 }
582}
583
584impl glib::value::ValueType for EventControllerScrollFlags {
585 type Type = Self;
586}
587
588unsafe impl<'a> glib::value::FromValue<'a> for EventControllerScrollFlags {
589 type Checker = glib::value::GenericValueTypeChecker<Self>;
590
591 #[inline]
592 unsafe fn from_value(value: &'a glib::Value) -> Self {
593 skip_assert_initialized!();
594 unsafe { from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) }
595 }
596}
597
598impl ToValue for EventControllerScrollFlags {
599 #[inline]
600 fn to_value(&self) -> glib::Value {
601 let mut value = glib::Value::for_value_type::<Self>();
602 unsafe {
603 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
604 }
605 value
606 }
607
608 #[inline]
609 fn value_type(&self) -> glib::Type {
610 Self::static_type()
611 }
612}
613
614impl From<EventControllerScrollFlags> for glib::Value {
615 #[inline]
616 fn from(v: EventControllerScrollFlags) -> Self {
617 skip_assert_initialized!();
618 ToValue::to_value(&v)
619 }
620}
621
622bitflags! {
623 #[cfg_attr(feature = "v4_20", deprecated = "Since 4.20")]
624 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
625 #[doc(alias = "GtkFontChooserLevel")]
626 pub struct FontChooserLevel: u32 {
627 #[doc(alias = "GTK_FONT_CHOOSER_LEVEL_FAMILY")]
628 const FAMILY = ffi::GTK_FONT_CHOOSER_LEVEL_FAMILY as _;
629 #[doc(alias = "GTK_FONT_CHOOSER_LEVEL_STYLE")]
630 const STYLE = ffi::GTK_FONT_CHOOSER_LEVEL_STYLE as _;
631 #[doc(alias = "GTK_FONT_CHOOSER_LEVEL_SIZE")]
632 const SIZE = ffi::GTK_FONT_CHOOSER_LEVEL_SIZE as _;
633 #[doc(alias = "GTK_FONT_CHOOSER_LEVEL_VARIATIONS")]
634 const VARIATIONS = ffi::GTK_FONT_CHOOSER_LEVEL_VARIATIONS as _;
635 #[doc(alias = "GTK_FONT_CHOOSER_LEVEL_FEATURES")]
636 const FEATURES = ffi::GTK_FONT_CHOOSER_LEVEL_FEATURES as _;
637 }
638}
639
640#[allow(deprecated)]
641#[doc(hidden)]
642impl IntoGlib for FontChooserLevel {
643 type GlibType = ffi::GtkFontChooserLevel;
644
645 #[inline]
646 fn into_glib(self) -> ffi::GtkFontChooserLevel {
647 self.bits()
648 }
649}
650
651#[allow(deprecated)]
652#[doc(hidden)]
653impl FromGlib<ffi::GtkFontChooserLevel> for FontChooserLevel {
654 #[inline]
655 unsafe fn from_glib(value: ffi::GtkFontChooserLevel) -> Self {
656 skip_assert_initialized!();
657 Self::from_bits_truncate(value)
658 }
659}
660
661#[allow(deprecated)]
662impl StaticType for FontChooserLevel {
663 #[inline]
664 #[doc(alias = "gtk_font_chooser_level_get_type")]
665 fn static_type() -> glib::Type {
666 unsafe { from_glib(ffi::gtk_font_chooser_level_get_type()) }
667 }
668}
669
670#[allow(deprecated)]
671impl glib::HasParamSpec for FontChooserLevel {
672 type ParamSpec = glib::ParamSpecFlags;
673 type SetValue = Self;
674 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
675
676 fn param_spec_builder() -> Self::BuilderFn {
677 Self::ParamSpec::builder
678 }
679}
680
681#[allow(deprecated)]
682impl glib::value::ValueType for FontChooserLevel {
683 type Type = Self;
684}
685
686#[allow(deprecated)]
687unsafe impl<'a> glib::value::FromValue<'a> for FontChooserLevel {
688 type Checker = glib::value::GenericValueTypeChecker<Self>;
689
690 #[inline]
691 unsafe fn from_value(value: &'a glib::Value) -> Self {
692 skip_assert_initialized!();
693 unsafe { from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) }
694 }
695}
696
697#[allow(deprecated)]
698impl ToValue for FontChooserLevel {
699 #[inline]
700 fn to_value(&self) -> glib::Value {
701 let mut value = glib::Value::for_value_type::<Self>();
702 unsafe {
703 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
704 }
705 value
706 }
707
708 #[inline]
709 fn value_type(&self) -> glib::Type {
710 Self::static_type()
711 }
712}
713
714#[allow(deprecated)]
715impl From<FontChooserLevel> for glib::Value {
716 #[inline]
717 fn from(v: FontChooserLevel) -> Self {
718 skip_assert_initialized!();
719 ToValue::to_value(&v)
720 }
721}
722
723bitflags! {
724 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
725 #[doc(alias = "GtkIconLookupFlags")]
726 pub struct IconLookupFlags: u32 {
727 #[cfg(feature = "v4_18")]
728 #[cfg_attr(docsrs, doc(cfg(feature = "v4_18")))]
729 #[doc(alias = "GTK_ICON_LOOKUP_NONE")]
730 const NONE = ffi::GTK_ICON_LOOKUP_NONE as _;
731 #[doc(alias = "GTK_ICON_LOOKUP_FORCE_REGULAR")]
732 const FORCE_REGULAR = ffi::GTK_ICON_LOOKUP_FORCE_REGULAR as _;
733 #[doc(alias = "GTK_ICON_LOOKUP_FORCE_SYMBOLIC")]
734 const FORCE_SYMBOLIC = ffi::GTK_ICON_LOOKUP_FORCE_SYMBOLIC as _;
735 #[doc(alias = "GTK_ICON_LOOKUP_PRELOAD")]
736 const PRELOAD = ffi::GTK_ICON_LOOKUP_PRELOAD as _;
737 }
738}
739
740#[doc(hidden)]
741impl IntoGlib for IconLookupFlags {
742 type GlibType = ffi::GtkIconLookupFlags;
743
744 #[inline]
745 fn into_glib(self) -> ffi::GtkIconLookupFlags {
746 self.bits()
747 }
748}
749
750#[doc(hidden)]
751impl FromGlib<ffi::GtkIconLookupFlags> for IconLookupFlags {
752 #[inline]
753 unsafe fn from_glib(value: ffi::GtkIconLookupFlags) -> Self {
754 skip_assert_initialized!();
755 Self::from_bits_truncate(value)
756 }
757}
758
759impl StaticType for IconLookupFlags {
760 #[inline]
761 #[doc(alias = "gtk_icon_lookup_flags_get_type")]
762 fn static_type() -> glib::Type {
763 unsafe { from_glib(ffi::gtk_icon_lookup_flags_get_type()) }
764 }
765}
766
767impl glib::HasParamSpec for IconLookupFlags {
768 type ParamSpec = glib::ParamSpecFlags;
769 type SetValue = Self;
770 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
771
772 fn param_spec_builder() -> Self::BuilderFn {
773 Self::ParamSpec::builder
774 }
775}
776
777impl glib::value::ValueType for IconLookupFlags {
778 type Type = Self;
779}
780
781unsafe impl<'a> glib::value::FromValue<'a> for IconLookupFlags {
782 type Checker = glib::value::GenericValueTypeChecker<Self>;
783
784 #[inline]
785 unsafe fn from_value(value: &'a glib::Value) -> Self {
786 skip_assert_initialized!();
787 unsafe { from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) }
788 }
789}
790
791impl ToValue for IconLookupFlags {
792 #[inline]
793 fn to_value(&self) -> glib::Value {
794 let mut value = glib::Value::for_value_type::<Self>();
795 unsafe {
796 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
797 }
798 value
799 }
800
801 #[inline]
802 fn value_type(&self) -> glib::Type {
803 Self::static_type()
804 }
805}
806
807impl From<IconLookupFlags> for glib::Value {
808 #[inline]
809 fn from(v: IconLookupFlags) -> Self {
810 skip_assert_initialized!();
811 ToValue::to_value(&v)
812 }
813}
814
815bitflags! {
816 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
817 #[doc(alias = "GtkInputHints")]
818 pub struct InputHints: u32 {
819 #[doc(alias = "GTK_INPUT_HINT_NONE")]
820 const NONE = ffi::GTK_INPUT_HINT_NONE as _;
821 #[doc(alias = "GTK_INPUT_HINT_SPELLCHECK")]
822 const SPELLCHECK = ffi::GTK_INPUT_HINT_SPELLCHECK as _;
823 #[doc(alias = "GTK_INPUT_HINT_NO_SPELLCHECK")]
824 const NO_SPELLCHECK = ffi::GTK_INPUT_HINT_NO_SPELLCHECK as _;
825 #[doc(alias = "GTK_INPUT_HINT_WORD_COMPLETION")]
826 const WORD_COMPLETION = ffi::GTK_INPUT_HINT_WORD_COMPLETION as _;
827 #[doc(alias = "GTK_INPUT_HINT_LOWERCASE")]
828 const LOWERCASE = ffi::GTK_INPUT_HINT_LOWERCASE as _;
829 #[doc(alias = "GTK_INPUT_HINT_UPPERCASE_CHARS")]
830 const UPPERCASE_CHARS = ffi::GTK_INPUT_HINT_UPPERCASE_CHARS as _;
831 #[doc(alias = "GTK_INPUT_HINT_UPPERCASE_WORDS")]
832 const UPPERCASE_WORDS = ffi::GTK_INPUT_HINT_UPPERCASE_WORDS as _;
833 #[doc(alias = "GTK_INPUT_HINT_UPPERCASE_SENTENCES")]
834 const UPPERCASE_SENTENCES = ffi::GTK_INPUT_HINT_UPPERCASE_SENTENCES as _;
835 #[doc(alias = "GTK_INPUT_HINT_INHIBIT_OSK")]
836 const INHIBIT_OSK = ffi::GTK_INPUT_HINT_INHIBIT_OSK as _;
837 #[doc(alias = "GTK_INPUT_HINT_VERTICAL_WRITING")]
838 const VERTICAL_WRITING = ffi::GTK_INPUT_HINT_VERTICAL_WRITING as _;
839 #[doc(alias = "GTK_INPUT_HINT_EMOJI")]
840 const EMOJI = ffi::GTK_INPUT_HINT_EMOJI as _;
841 #[doc(alias = "GTK_INPUT_HINT_NO_EMOJI")]
842 const NO_EMOJI = ffi::GTK_INPUT_HINT_NO_EMOJI as _;
843 #[doc(alias = "GTK_INPUT_HINT_PRIVATE")]
844 const PRIVATE = ffi::GTK_INPUT_HINT_PRIVATE as _;
845 }
846}
847
848#[doc(hidden)]
849impl IntoGlib for InputHints {
850 type GlibType = ffi::GtkInputHints;
851
852 #[inline]
853 fn into_glib(self) -> ffi::GtkInputHints {
854 self.bits()
855 }
856}
857
858#[doc(hidden)]
859impl FromGlib<ffi::GtkInputHints> for InputHints {
860 #[inline]
861 unsafe fn from_glib(value: ffi::GtkInputHints) -> Self {
862 skip_assert_initialized!();
863 Self::from_bits_truncate(value)
864 }
865}
866
867impl StaticType for InputHints {
868 #[inline]
869 #[doc(alias = "gtk_input_hints_get_type")]
870 fn static_type() -> glib::Type {
871 unsafe { from_glib(ffi::gtk_input_hints_get_type()) }
872 }
873}
874
875impl glib::HasParamSpec for InputHints {
876 type ParamSpec = glib::ParamSpecFlags;
877 type SetValue = Self;
878 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
879
880 fn param_spec_builder() -> Self::BuilderFn {
881 Self::ParamSpec::builder
882 }
883}
884
885impl glib::value::ValueType for InputHints {
886 type Type = Self;
887}
888
889unsafe impl<'a> glib::value::FromValue<'a> for InputHints {
890 type Checker = glib::value::GenericValueTypeChecker<Self>;
891
892 #[inline]
893 unsafe fn from_value(value: &'a glib::Value) -> Self {
894 skip_assert_initialized!();
895 unsafe { from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) }
896 }
897}
898
899impl ToValue for InputHints {
900 #[inline]
901 fn to_value(&self) -> glib::Value {
902 let mut value = glib::Value::for_value_type::<Self>();
903 unsafe {
904 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
905 }
906 value
907 }
908
909 #[inline]
910 fn value_type(&self) -> glib::Type {
911 Self::static_type()
912 }
913}
914
915impl From<InputHints> for glib::Value {
916 #[inline]
917 fn from(v: InputHints) -> Self {
918 skip_assert_initialized!();
919 ToValue::to_value(&v)
920 }
921}
922
923#[cfg(feature = "v4_12")]
924bitflags! {
925 #[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
926 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
927 #[doc(alias = "GtkListScrollFlags")]
928 pub struct ListScrollFlags: u32 {
929 #[doc(alias = "GTK_LIST_SCROLL_NONE")]
930 const NONE = ffi::GTK_LIST_SCROLL_NONE as _;
931 #[doc(alias = "GTK_LIST_SCROLL_FOCUS")]
932 const FOCUS = ffi::GTK_LIST_SCROLL_FOCUS as _;
933 #[doc(alias = "GTK_LIST_SCROLL_SELECT")]
934 const SELECT = ffi::GTK_LIST_SCROLL_SELECT as _;
935 }
936}
937
938#[cfg(feature = "v4_12")]
939#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
940#[doc(hidden)]
941impl IntoGlib for ListScrollFlags {
942 type GlibType = ffi::GtkListScrollFlags;
943
944 #[inline]
945 fn into_glib(self) -> ffi::GtkListScrollFlags {
946 self.bits()
947 }
948}
949
950#[cfg(feature = "v4_12")]
951#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
952#[doc(hidden)]
953impl FromGlib<ffi::GtkListScrollFlags> for ListScrollFlags {
954 #[inline]
955 unsafe fn from_glib(value: ffi::GtkListScrollFlags) -> Self {
956 skip_assert_initialized!();
957 Self::from_bits_truncate(value)
958 }
959}
960
961#[cfg(feature = "v4_12")]
962#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
963impl StaticType for ListScrollFlags {
964 #[inline]
965 #[doc(alias = "gtk_list_scroll_flags_get_type")]
966 fn static_type() -> glib::Type {
967 unsafe { from_glib(ffi::gtk_list_scroll_flags_get_type()) }
968 }
969}
970
971#[cfg(feature = "v4_12")]
972#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
973impl glib::HasParamSpec for ListScrollFlags {
974 type ParamSpec = glib::ParamSpecFlags;
975 type SetValue = Self;
976 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
977
978 fn param_spec_builder() -> Self::BuilderFn {
979 Self::ParamSpec::builder
980 }
981}
982
983#[cfg(feature = "v4_12")]
984#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
985impl glib::value::ValueType for ListScrollFlags {
986 type Type = Self;
987}
988
989#[cfg(feature = "v4_12")]
990#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
991unsafe impl<'a> glib::value::FromValue<'a> for ListScrollFlags {
992 type Checker = glib::value::GenericValueTypeChecker<Self>;
993
994 #[inline]
995 unsafe fn from_value(value: &'a glib::Value) -> Self {
996 skip_assert_initialized!();
997 unsafe { from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) }
998 }
999}
1000
1001#[cfg(feature = "v4_12")]
1002#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
1003impl ToValue for ListScrollFlags {
1004 #[inline]
1005 fn to_value(&self) -> glib::Value {
1006 let mut value = glib::Value::for_value_type::<Self>();
1007 unsafe {
1008 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1009 }
1010 value
1011 }
1012
1013 #[inline]
1014 fn value_type(&self) -> glib::Type {
1015 Self::static_type()
1016 }
1017}
1018
1019#[cfg(feature = "v4_12")]
1020#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
1021impl From<ListScrollFlags> for glib::Value {
1022 #[inline]
1023 fn from(v: ListScrollFlags) -> Self {
1024 skip_assert_initialized!();
1025 ToValue::to_value(&v)
1026 }
1027}
1028
1029bitflags! {
1030 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1031 #[doc(alias = "GtkPickFlags")]
1032 pub struct PickFlags: u32 {
1033 #[doc(alias = "GTK_PICK_DEFAULT")]
1034 const DEFAULT = ffi::GTK_PICK_DEFAULT as _;
1035 #[doc(alias = "GTK_PICK_INSENSITIVE")]
1036 const INSENSITIVE = ffi::GTK_PICK_INSENSITIVE as _;
1037 #[doc(alias = "GTK_PICK_NON_TARGETABLE")]
1038 const NON_TARGETABLE = ffi::GTK_PICK_NON_TARGETABLE as _;
1039 }
1040}
1041
1042#[doc(hidden)]
1043impl IntoGlib for PickFlags {
1044 type GlibType = ffi::GtkPickFlags;
1045
1046 #[inline]
1047 fn into_glib(self) -> ffi::GtkPickFlags {
1048 self.bits()
1049 }
1050}
1051
1052#[doc(hidden)]
1053impl FromGlib<ffi::GtkPickFlags> for PickFlags {
1054 #[inline]
1055 unsafe fn from_glib(value: ffi::GtkPickFlags) -> Self {
1056 skip_assert_initialized!();
1057 Self::from_bits_truncate(value)
1058 }
1059}
1060
1061impl StaticType for PickFlags {
1062 #[inline]
1063 #[doc(alias = "gtk_pick_flags_get_type")]
1064 fn static_type() -> glib::Type {
1065 unsafe { from_glib(ffi::gtk_pick_flags_get_type()) }
1066 }
1067}
1068
1069impl glib::HasParamSpec for PickFlags {
1070 type ParamSpec = glib::ParamSpecFlags;
1071 type SetValue = Self;
1072 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1073
1074 fn param_spec_builder() -> Self::BuilderFn {
1075 Self::ParamSpec::builder
1076 }
1077}
1078
1079impl glib::value::ValueType for PickFlags {
1080 type Type = Self;
1081}
1082
1083unsafe impl<'a> glib::value::FromValue<'a> for PickFlags {
1084 type Checker = glib::value::GenericValueTypeChecker<Self>;
1085
1086 #[inline]
1087 unsafe fn from_value(value: &'a glib::Value) -> Self {
1088 skip_assert_initialized!();
1089 unsafe { from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) }
1090 }
1091}
1092
1093impl ToValue for PickFlags {
1094 #[inline]
1095 fn to_value(&self) -> glib::Value {
1096 let mut value = glib::Value::for_value_type::<Self>();
1097 unsafe {
1098 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1099 }
1100 value
1101 }
1102
1103 #[inline]
1104 fn value_type(&self) -> glib::Type {
1105 Self::static_type()
1106 }
1107}
1108
1109impl From<PickFlags> for glib::Value {
1110 #[inline]
1111 fn from(v: PickFlags) -> Self {
1112 skip_assert_initialized!();
1113 ToValue::to_value(&v)
1114 }
1115}
1116
1117bitflags! {
1118 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1119 #[doc(alias = "GtkPopoverMenuFlags")]
1120 pub struct PopoverMenuFlags: u32 {
1121 #[cfg(feature = "v4_14")]
1122 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1123 #[doc(alias = "GTK_POPOVER_MENU_SLIDING")]
1124 const SLIDING = ffi::GTK_POPOVER_MENU_SLIDING as _;
1125 #[doc(alias = "GTK_POPOVER_MENU_NESTED")]
1126 const NESTED = ffi::GTK_POPOVER_MENU_NESTED as _;
1127 }
1128}
1129
1130#[doc(hidden)]
1131impl IntoGlib for PopoverMenuFlags {
1132 type GlibType = ffi::GtkPopoverMenuFlags;
1133
1134 #[inline]
1135 fn into_glib(self) -> ffi::GtkPopoverMenuFlags {
1136 self.bits()
1137 }
1138}
1139
1140#[doc(hidden)]
1141impl FromGlib<ffi::GtkPopoverMenuFlags> for PopoverMenuFlags {
1142 #[inline]
1143 unsafe fn from_glib(value: ffi::GtkPopoverMenuFlags) -> Self {
1144 skip_assert_initialized!();
1145 Self::from_bits_truncate(value)
1146 }
1147}
1148
1149impl StaticType for PopoverMenuFlags {
1150 #[inline]
1151 #[doc(alias = "gtk_popover_menu_flags_get_type")]
1152 fn static_type() -> glib::Type {
1153 unsafe { from_glib(ffi::gtk_popover_menu_flags_get_type()) }
1154 }
1155}
1156
1157impl glib::HasParamSpec for PopoverMenuFlags {
1158 type ParamSpec = glib::ParamSpecFlags;
1159 type SetValue = Self;
1160 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1161
1162 fn param_spec_builder() -> Self::BuilderFn {
1163 Self::ParamSpec::builder
1164 }
1165}
1166
1167impl glib::value::ValueType for PopoverMenuFlags {
1168 type Type = Self;
1169}
1170
1171unsafe impl<'a> glib::value::FromValue<'a> for PopoverMenuFlags {
1172 type Checker = glib::value::GenericValueTypeChecker<Self>;
1173
1174 #[inline]
1175 unsafe fn from_value(value: &'a glib::Value) -> Self {
1176 skip_assert_initialized!();
1177 unsafe { from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) }
1178 }
1179}
1180
1181impl ToValue for PopoverMenuFlags {
1182 #[inline]
1183 fn to_value(&self) -> glib::Value {
1184 let mut value = glib::Value::for_value_type::<Self>();
1185 unsafe {
1186 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1187 }
1188 value
1189 }
1190
1191 #[inline]
1192 fn value_type(&self) -> glib::Type {
1193 Self::static_type()
1194 }
1195}
1196
1197impl From<PopoverMenuFlags> for glib::Value {
1198 #[inline]
1199 fn from(v: PopoverMenuFlags) -> Self {
1200 skip_assert_initialized!();
1201 ToValue::to_value(&v)
1202 }
1203}
1204
1205#[cfg(target_os = "linux")]
1206bitflags! {
1207 #[cfg_attr(docsrs, doc(cfg(target_os = "linux")))]
1208 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1209 #[doc(alias = "GtkPrintCapabilities")]
1210 pub struct PrintCapabilities: u32 {
1211 #[doc(alias = "GTK_PRINT_CAPABILITY_PAGE_SET")]
1212 const PAGE_SET = ffi::GTK_PRINT_CAPABILITY_PAGE_SET as _;
1213 #[doc(alias = "GTK_PRINT_CAPABILITY_COPIES")]
1214 const COPIES = ffi::GTK_PRINT_CAPABILITY_COPIES as _;
1215 #[doc(alias = "GTK_PRINT_CAPABILITY_COLLATE")]
1216 const COLLATE = ffi::GTK_PRINT_CAPABILITY_COLLATE as _;
1217 #[doc(alias = "GTK_PRINT_CAPABILITY_REVERSE")]
1218 const REVERSE = ffi::GTK_PRINT_CAPABILITY_REVERSE as _;
1219 #[doc(alias = "GTK_PRINT_CAPABILITY_SCALE")]
1220 const SCALE = ffi::GTK_PRINT_CAPABILITY_SCALE as _;
1221 #[doc(alias = "GTK_PRINT_CAPABILITY_GENERATE_PDF")]
1222 const GENERATE_PDF = ffi::GTK_PRINT_CAPABILITY_GENERATE_PDF as _;
1223 #[doc(alias = "GTK_PRINT_CAPABILITY_GENERATE_PS")]
1224 const GENERATE_PS = ffi::GTK_PRINT_CAPABILITY_GENERATE_PS as _;
1225 #[doc(alias = "GTK_PRINT_CAPABILITY_PREVIEW")]
1226 const PREVIEW = ffi::GTK_PRINT_CAPABILITY_PREVIEW as _;
1227 #[doc(alias = "GTK_PRINT_CAPABILITY_NUMBER_UP")]
1228 const NUMBER_UP = ffi::GTK_PRINT_CAPABILITY_NUMBER_UP as _;
1229 #[doc(alias = "GTK_PRINT_CAPABILITY_NUMBER_UP_LAYOUT")]
1230 const NUMBER_UP_LAYOUT = ffi::GTK_PRINT_CAPABILITY_NUMBER_UP_LAYOUT as _;
1231 }
1232}
1233
1234#[cfg(target_os = "linux")]
1235#[doc(hidden)]
1236impl IntoGlib for PrintCapabilities {
1237 type GlibType = ffi::GtkPrintCapabilities;
1238
1239 #[inline]
1240 fn into_glib(self) -> ffi::GtkPrintCapabilities {
1241 self.bits()
1242 }
1243}
1244
1245#[cfg(target_os = "linux")]
1246#[doc(hidden)]
1247impl FromGlib<ffi::GtkPrintCapabilities> for PrintCapabilities {
1248 #[inline]
1249 unsafe fn from_glib(value: ffi::GtkPrintCapabilities) -> Self {
1250 skip_assert_initialized!();
1251 Self::from_bits_truncate(value)
1252 }
1253}
1254
1255#[cfg(target_os = "linux")]
1256impl StaticType for PrintCapabilities {
1257 #[inline]
1258 #[doc(alias = "gtk_print_capabilities_get_type")]
1259 fn static_type() -> glib::Type {
1260 unsafe { from_glib(ffi::gtk_print_capabilities_get_type()) }
1261 }
1262}
1263
1264#[cfg(target_os = "linux")]
1265impl glib::HasParamSpec for PrintCapabilities {
1266 type ParamSpec = glib::ParamSpecFlags;
1267 type SetValue = Self;
1268 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1269
1270 fn param_spec_builder() -> Self::BuilderFn {
1271 Self::ParamSpec::builder
1272 }
1273}
1274
1275#[cfg(target_os = "linux")]
1276impl glib::value::ValueType for PrintCapabilities {
1277 type Type = Self;
1278}
1279
1280#[cfg(target_os = "linux")]
1281unsafe impl<'a> glib::value::FromValue<'a> for PrintCapabilities {
1282 type Checker = glib::value::GenericValueTypeChecker<Self>;
1283
1284 #[inline]
1285 unsafe fn from_value(value: &'a glib::Value) -> Self {
1286 skip_assert_initialized!();
1287 unsafe { from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) }
1288 }
1289}
1290
1291#[cfg(target_os = "linux")]
1292impl ToValue for PrintCapabilities {
1293 #[inline]
1294 fn to_value(&self) -> glib::Value {
1295 let mut value = glib::Value::for_value_type::<Self>();
1296 unsafe {
1297 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1298 }
1299 value
1300 }
1301
1302 #[inline]
1303 fn value_type(&self) -> glib::Type {
1304 Self::static_type()
1305 }
1306}
1307
1308#[cfg(target_os = "linux")]
1309impl From<PrintCapabilities> for glib::Value {
1310 #[inline]
1311 fn from(v: PrintCapabilities) -> Self {
1312 skip_assert_initialized!();
1313 ToValue::to_value(&v)
1314 }
1315}
1316
1317bitflags! {
1318 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1319 #[doc(alias = "GtkShortcutActionFlags")]
1320 pub struct ShortcutActionFlags: u32 {
1321 #[doc(alias = "GTK_SHORTCUT_ACTION_EXCLUSIVE")]
1322 const EXCLUSIVE = ffi::GTK_SHORTCUT_ACTION_EXCLUSIVE as _;
1323 }
1324}
1325
1326#[doc(hidden)]
1327impl IntoGlib for ShortcutActionFlags {
1328 type GlibType = ffi::GtkShortcutActionFlags;
1329
1330 #[inline]
1331 fn into_glib(self) -> ffi::GtkShortcutActionFlags {
1332 self.bits()
1333 }
1334}
1335
1336#[doc(hidden)]
1337impl FromGlib<ffi::GtkShortcutActionFlags> for ShortcutActionFlags {
1338 #[inline]
1339 unsafe fn from_glib(value: ffi::GtkShortcutActionFlags) -> Self {
1340 skip_assert_initialized!();
1341 Self::from_bits_truncate(value)
1342 }
1343}
1344
1345impl StaticType for ShortcutActionFlags {
1346 #[inline]
1347 #[doc(alias = "gtk_shortcut_action_flags_get_type")]
1348 fn static_type() -> glib::Type {
1349 unsafe { from_glib(ffi::gtk_shortcut_action_flags_get_type()) }
1350 }
1351}
1352
1353impl glib::HasParamSpec for ShortcutActionFlags {
1354 type ParamSpec = glib::ParamSpecFlags;
1355 type SetValue = Self;
1356 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1357
1358 fn param_spec_builder() -> Self::BuilderFn {
1359 Self::ParamSpec::builder
1360 }
1361}
1362
1363impl glib::value::ValueType for ShortcutActionFlags {
1364 type Type = Self;
1365}
1366
1367unsafe impl<'a> glib::value::FromValue<'a> for ShortcutActionFlags {
1368 type Checker = glib::value::GenericValueTypeChecker<Self>;
1369
1370 #[inline]
1371 unsafe fn from_value(value: &'a glib::Value) -> Self {
1372 skip_assert_initialized!();
1373 unsafe { from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) }
1374 }
1375}
1376
1377impl ToValue for ShortcutActionFlags {
1378 #[inline]
1379 fn to_value(&self) -> glib::Value {
1380 let mut value = glib::Value::for_value_type::<Self>();
1381 unsafe {
1382 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1383 }
1384 value
1385 }
1386
1387 #[inline]
1388 fn value_type(&self) -> glib::Type {
1389 Self::static_type()
1390 }
1391}
1392
1393impl From<ShortcutActionFlags> for glib::Value {
1394 #[inline]
1395 fn from(v: ShortcutActionFlags) -> Self {
1396 skip_assert_initialized!();
1397 ToValue::to_value(&v)
1398 }
1399}
1400
1401bitflags! {
1402 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1403 #[doc(alias = "GtkStateFlags")]
1404 pub struct StateFlags: u32 {
1405 #[doc(alias = "GTK_STATE_FLAG_NORMAL")]
1406 const NORMAL = ffi::GTK_STATE_FLAG_NORMAL as _;
1407 #[doc(alias = "GTK_STATE_FLAG_ACTIVE")]
1408 const ACTIVE = ffi::GTK_STATE_FLAG_ACTIVE as _;
1409 #[doc(alias = "GTK_STATE_FLAG_PRELIGHT")]
1410 const PRELIGHT = ffi::GTK_STATE_FLAG_PRELIGHT as _;
1411 #[doc(alias = "GTK_STATE_FLAG_SELECTED")]
1412 const SELECTED = ffi::GTK_STATE_FLAG_SELECTED as _;
1413 #[doc(alias = "GTK_STATE_FLAG_INSENSITIVE")]
1414 const INSENSITIVE = ffi::GTK_STATE_FLAG_INSENSITIVE as _;
1415 #[doc(alias = "GTK_STATE_FLAG_INCONSISTENT")]
1416 const INCONSISTENT = ffi::GTK_STATE_FLAG_INCONSISTENT as _;
1417 #[doc(alias = "GTK_STATE_FLAG_FOCUSED")]
1418 const FOCUSED = ffi::GTK_STATE_FLAG_FOCUSED as _;
1419 #[doc(alias = "GTK_STATE_FLAG_BACKDROP")]
1420 const BACKDROP = ffi::GTK_STATE_FLAG_BACKDROP as _;
1421 #[doc(alias = "GTK_STATE_FLAG_DIR_LTR")]
1422 const DIR_LTR = ffi::GTK_STATE_FLAG_DIR_LTR as _;
1423 #[doc(alias = "GTK_STATE_FLAG_DIR_RTL")]
1424 const DIR_RTL = ffi::GTK_STATE_FLAG_DIR_RTL as _;
1425 #[doc(alias = "GTK_STATE_FLAG_LINK")]
1426 const LINK = ffi::GTK_STATE_FLAG_LINK as _;
1427 #[doc(alias = "GTK_STATE_FLAG_VISITED")]
1428 const VISITED = ffi::GTK_STATE_FLAG_VISITED as _;
1429 #[doc(alias = "GTK_STATE_FLAG_CHECKED")]
1430 const CHECKED = ffi::GTK_STATE_FLAG_CHECKED as _;
1431 #[doc(alias = "GTK_STATE_FLAG_DROP_ACTIVE")]
1432 const DROP_ACTIVE = ffi::GTK_STATE_FLAG_DROP_ACTIVE as _;
1433 #[doc(alias = "GTK_STATE_FLAG_FOCUS_VISIBLE")]
1434 const FOCUS_VISIBLE = ffi::GTK_STATE_FLAG_FOCUS_VISIBLE as _;
1435 #[doc(alias = "GTK_STATE_FLAG_FOCUS_WITHIN")]
1436 const FOCUS_WITHIN = ffi::GTK_STATE_FLAG_FOCUS_WITHIN as _;
1437 }
1438}
1439
1440#[doc(hidden)]
1441impl IntoGlib for StateFlags {
1442 type GlibType = ffi::GtkStateFlags;
1443
1444 #[inline]
1445 fn into_glib(self) -> ffi::GtkStateFlags {
1446 self.bits()
1447 }
1448}
1449
1450#[doc(hidden)]
1451impl FromGlib<ffi::GtkStateFlags> for StateFlags {
1452 #[inline]
1453 unsafe fn from_glib(value: ffi::GtkStateFlags) -> Self {
1454 skip_assert_initialized!();
1455 Self::from_bits_truncate(value)
1456 }
1457}
1458
1459impl StaticType for StateFlags {
1460 #[inline]
1461 #[doc(alias = "gtk_state_flags_get_type")]
1462 fn static_type() -> glib::Type {
1463 unsafe { from_glib(ffi::gtk_state_flags_get_type()) }
1464 }
1465}
1466
1467impl glib::HasParamSpec for StateFlags {
1468 type ParamSpec = glib::ParamSpecFlags;
1469 type SetValue = Self;
1470 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1471
1472 fn param_spec_builder() -> Self::BuilderFn {
1473 Self::ParamSpec::builder
1474 }
1475}
1476
1477impl glib::value::ValueType for StateFlags {
1478 type Type = Self;
1479}
1480
1481unsafe impl<'a> glib::value::FromValue<'a> for StateFlags {
1482 type Checker = glib::value::GenericValueTypeChecker<Self>;
1483
1484 #[inline]
1485 unsafe fn from_value(value: &'a glib::Value) -> Self {
1486 skip_assert_initialized!();
1487 unsafe { from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) }
1488 }
1489}
1490
1491impl ToValue for StateFlags {
1492 #[inline]
1493 fn to_value(&self) -> glib::Value {
1494 let mut value = glib::Value::for_value_type::<Self>();
1495 unsafe {
1496 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1497 }
1498 value
1499 }
1500
1501 #[inline]
1502 fn value_type(&self) -> glib::Type {
1503 Self::static_type()
1504 }
1505}
1506
1507impl From<StateFlags> for glib::Value {
1508 #[inline]
1509 fn from(v: StateFlags) -> Self {
1510 skip_assert_initialized!();
1511 ToValue::to_value(&v)
1512 }
1513}
1514
1515bitflags! {
1516 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1517 #[doc(alias = "GtkStyleContextPrintFlags")]
1518 pub struct StyleContextPrintFlags: u32 {
1519 #[doc(alias = "GTK_STYLE_CONTEXT_PRINT_NONE")]
1520 const NONE = ffi::GTK_STYLE_CONTEXT_PRINT_NONE as _;
1521 #[doc(alias = "GTK_STYLE_CONTEXT_PRINT_RECURSE")]
1522 const RECURSE = ffi::GTK_STYLE_CONTEXT_PRINT_RECURSE as _;
1523 #[doc(alias = "GTK_STYLE_CONTEXT_PRINT_SHOW_STYLE")]
1524 const SHOW_STYLE = ffi::GTK_STYLE_CONTEXT_PRINT_SHOW_STYLE as _;
1525 #[doc(alias = "GTK_STYLE_CONTEXT_PRINT_SHOW_CHANGE")]
1526 const SHOW_CHANGE = ffi::GTK_STYLE_CONTEXT_PRINT_SHOW_CHANGE as _;
1527 }
1528}
1529
1530#[doc(hidden)]
1531impl IntoGlib for StyleContextPrintFlags {
1532 type GlibType = ffi::GtkStyleContextPrintFlags;
1533
1534 #[inline]
1535 fn into_glib(self) -> ffi::GtkStyleContextPrintFlags {
1536 self.bits()
1537 }
1538}
1539
1540#[doc(hidden)]
1541impl FromGlib<ffi::GtkStyleContextPrintFlags> for StyleContextPrintFlags {
1542 #[inline]
1543 unsafe fn from_glib(value: ffi::GtkStyleContextPrintFlags) -> Self {
1544 skip_assert_initialized!();
1545 Self::from_bits_truncate(value)
1546 }
1547}
1548
1549impl StaticType for StyleContextPrintFlags {
1550 #[inline]
1551 #[doc(alias = "gtk_style_context_print_flags_get_type")]
1552 fn static_type() -> glib::Type {
1553 unsafe { from_glib(ffi::gtk_style_context_print_flags_get_type()) }
1554 }
1555}
1556
1557impl glib::HasParamSpec for StyleContextPrintFlags {
1558 type ParamSpec = glib::ParamSpecFlags;
1559 type SetValue = Self;
1560 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1561
1562 fn param_spec_builder() -> Self::BuilderFn {
1563 Self::ParamSpec::builder
1564 }
1565}
1566
1567impl glib::value::ValueType for StyleContextPrintFlags {
1568 type Type = Self;
1569}
1570
1571unsafe impl<'a> glib::value::FromValue<'a> for StyleContextPrintFlags {
1572 type Checker = glib::value::GenericValueTypeChecker<Self>;
1573
1574 #[inline]
1575 unsafe fn from_value(value: &'a glib::Value) -> Self {
1576 skip_assert_initialized!();
1577 unsafe { from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) }
1578 }
1579}
1580
1581impl ToValue for StyleContextPrintFlags {
1582 #[inline]
1583 fn to_value(&self) -> glib::Value {
1584 let mut value = glib::Value::for_value_type::<Self>();
1585 unsafe {
1586 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1587 }
1588 value
1589 }
1590
1591 #[inline]
1592 fn value_type(&self) -> glib::Type {
1593 Self::static_type()
1594 }
1595}
1596
1597impl From<StyleContextPrintFlags> for glib::Value {
1598 #[inline]
1599 fn from(v: StyleContextPrintFlags) -> Self {
1600 skip_assert_initialized!();
1601 ToValue::to_value(&v)
1602 }
1603}
1604
1605#[cfg(feature = "v4_22")]
1606bitflags! {
1607 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
1608 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1609 #[doc(alias = "GtkSvgFeatures")]
1610 pub struct SvgFeatures: u32 {
1611 #[doc(alias = "GTK_SVG_ANIMATIONS")]
1612 const ANIMATIONS = ffi::GTK_SVG_ANIMATIONS as _;
1613 #[doc(alias = "GTK_SVG_SYSTEM_RESOURCES")]
1614 const SYSTEM_RESOURCES = ffi::GTK_SVG_SYSTEM_RESOURCES as _;
1615 #[doc(alias = "GTK_SVG_EXTERNAL_RESOURCES")]
1616 const EXTERNAL_RESOURCES = ffi::GTK_SVG_EXTERNAL_RESOURCES as _;
1617 #[doc(alias = "GTK_SVG_EXTENSIONS")]
1618 const EXTENSIONS = ffi::GTK_SVG_EXTENSIONS as _;
1619 }
1620}
1621
1622#[cfg(feature = "v4_22")]
1623#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
1624#[doc(hidden)]
1625impl IntoGlib for SvgFeatures {
1626 type GlibType = ffi::GtkSvgFeatures;
1627
1628 #[inline]
1629 fn into_glib(self) -> ffi::GtkSvgFeatures {
1630 self.bits()
1631 }
1632}
1633
1634#[cfg(feature = "v4_22")]
1635#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
1636#[doc(hidden)]
1637impl FromGlib<ffi::GtkSvgFeatures> for SvgFeatures {
1638 #[inline]
1639 unsafe fn from_glib(value: ffi::GtkSvgFeatures) -> Self {
1640 skip_assert_initialized!();
1641 Self::from_bits_truncate(value)
1642 }
1643}
1644
1645#[cfg(feature = "v4_22")]
1646#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
1647impl StaticType for SvgFeatures {
1648 #[inline]
1649 #[doc(alias = "gtk_svg_features_get_type")]
1650 fn static_type() -> glib::Type {
1651 unsafe { from_glib(ffi::gtk_svg_features_get_type()) }
1652 }
1653}
1654
1655#[cfg(feature = "v4_22")]
1656#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
1657impl glib::HasParamSpec for SvgFeatures {
1658 type ParamSpec = glib::ParamSpecFlags;
1659 type SetValue = Self;
1660 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1661
1662 fn param_spec_builder() -> Self::BuilderFn {
1663 Self::ParamSpec::builder
1664 }
1665}
1666
1667#[cfg(feature = "v4_22")]
1668#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
1669impl glib::value::ValueType for SvgFeatures {
1670 type Type = Self;
1671}
1672
1673#[cfg(feature = "v4_22")]
1674#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
1675unsafe impl<'a> glib::value::FromValue<'a> for SvgFeatures {
1676 type Checker = glib::value::GenericValueTypeChecker<Self>;
1677
1678 #[inline]
1679 unsafe fn from_value(value: &'a glib::Value) -> Self {
1680 skip_assert_initialized!();
1681 unsafe { from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) }
1682 }
1683}
1684
1685#[cfg(feature = "v4_22")]
1686#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
1687impl ToValue for SvgFeatures {
1688 #[inline]
1689 fn to_value(&self) -> glib::Value {
1690 let mut value = glib::Value::for_value_type::<Self>();
1691 unsafe {
1692 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1693 }
1694 value
1695 }
1696
1697 #[inline]
1698 fn value_type(&self) -> glib::Type {
1699 Self::static_type()
1700 }
1701}
1702
1703#[cfg(feature = "v4_22")]
1704#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
1705impl From<SvgFeatures> for glib::Value {
1706 #[inline]
1707 fn from(v: SvgFeatures) -> Self {
1708 skip_assert_initialized!();
1709 ToValue::to_value(&v)
1710 }
1711}
1712
1713#[cfg(feature = "v4_16")]
1714bitflags! {
1715 #[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
1716 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1717 #[doc(alias = "GtkTextBufferNotifyFlags")]
1718 pub struct TextBufferNotifyFlags: u32 {
1719 #[doc(alias = "GTK_TEXT_BUFFER_NOTIFY_BEFORE_INSERT")]
1720 const BEFORE_INSERT = ffi::GTK_TEXT_BUFFER_NOTIFY_BEFORE_INSERT as _;
1721 #[doc(alias = "GTK_TEXT_BUFFER_NOTIFY_AFTER_INSERT")]
1722 const AFTER_INSERT = ffi::GTK_TEXT_BUFFER_NOTIFY_AFTER_INSERT as _;
1723 #[doc(alias = "GTK_TEXT_BUFFER_NOTIFY_BEFORE_DELETE")]
1724 const BEFORE_DELETE = ffi::GTK_TEXT_BUFFER_NOTIFY_BEFORE_DELETE as _;
1725 #[doc(alias = "GTK_TEXT_BUFFER_NOTIFY_AFTER_DELETE")]
1726 const AFTER_DELETE = ffi::GTK_TEXT_BUFFER_NOTIFY_AFTER_DELETE as _;
1727 }
1728}
1729
1730#[cfg(feature = "v4_16")]
1731#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
1732#[doc(hidden)]
1733impl IntoGlib for TextBufferNotifyFlags {
1734 type GlibType = ffi::GtkTextBufferNotifyFlags;
1735
1736 #[inline]
1737 fn into_glib(self) -> ffi::GtkTextBufferNotifyFlags {
1738 self.bits()
1739 }
1740}
1741
1742#[cfg(feature = "v4_16")]
1743#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
1744#[doc(hidden)]
1745impl FromGlib<ffi::GtkTextBufferNotifyFlags> for TextBufferNotifyFlags {
1746 #[inline]
1747 unsafe fn from_glib(value: ffi::GtkTextBufferNotifyFlags) -> Self {
1748 skip_assert_initialized!();
1749 Self::from_bits_truncate(value)
1750 }
1751}
1752
1753#[cfg(feature = "v4_16")]
1754#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
1755impl StaticType for TextBufferNotifyFlags {
1756 #[inline]
1757 #[doc(alias = "gtk_text_buffer_notify_flags_get_type")]
1758 fn static_type() -> glib::Type {
1759 unsafe { from_glib(ffi::gtk_text_buffer_notify_flags_get_type()) }
1760 }
1761}
1762
1763#[cfg(feature = "v4_16")]
1764#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
1765impl glib::HasParamSpec for TextBufferNotifyFlags {
1766 type ParamSpec = glib::ParamSpecFlags;
1767 type SetValue = Self;
1768 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1769
1770 fn param_spec_builder() -> Self::BuilderFn {
1771 Self::ParamSpec::builder
1772 }
1773}
1774
1775#[cfg(feature = "v4_16")]
1776#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
1777impl glib::value::ValueType for TextBufferNotifyFlags {
1778 type Type = Self;
1779}
1780
1781#[cfg(feature = "v4_16")]
1782#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
1783unsafe impl<'a> glib::value::FromValue<'a> for TextBufferNotifyFlags {
1784 type Checker = glib::value::GenericValueTypeChecker<Self>;
1785
1786 #[inline]
1787 unsafe fn from_value(value: &'a glib::Value) -> Self {
1788 skip_assert_initialized!();
1789 unsafe { from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) }
1790 }
1791}
1792
1793#[cfg(feature = "v4_16")]
1794#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
1795impl ToValue for TextBufferNotifyFlags {
1796 #[inline]
1797 fn to_value(&self) -> glib::Value {
1798 let mut value = glib::Value::for_value_type::<Self>();
1799 unsafe {
1800 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1801 }
1802 value
1803 }
1804
1805 #[inline]
1806 fn value_type(&self) -> glib::Type {
1807 Self::static_type()
1808 }
1809}
1810
1811#[cfg(feature = "v4_16")]
1812#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
1813impl From<TextBufferNotifyFlags> for glib::Value {
1814 #[inline]
1815 fn from(v: TextBufferNotifyFlags) -> Self {
1816 skip_assert_initialized!();
1817 ToValue::to_value(&v)
1818 }
1819}
1820
1821bitflags! {
1822 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1823 #[doc(alias = "GtkTextSearchFlags")]
1824 pub struct TextSearchFlags: u32 {
1825 #[doc(alias = "GTK_TEXT_SEARCH_VISIBLE_ONLY")]
1826 const VISIBLE_ONLY = ffi::GTK_TEXT_SEARCH_VISIBLE_ONLY as _;
1827 #[doc(alias = "GTK_TEXT_SEARCH_TEXT_ONLY")]
1828 const TEXT_ONLY = ffi::GTK_TEXT_SEARCH_TEXT_ONLY as _;
1829 #[doc(alias = "GTK_TEXT_SEARCH_CASE_INSENSITIVE")]
1830 const CASE_INSENSITIVE = ffi::GTK_TEXT_SEARCH_CASE_INSENSITIVE as _;
1831 }
1832}
1833
1834#[doc(hidden)]
1835impl IntoGlib for TextSearchFlags {
1836 type GlibType = ffi::GtkTextSearchFlags;
1837
1838 #[inline]
1839 fn into_glib(self) -> ffi::GtkTextSearchFlags {
1840 self.bits()
1841 }
1842}
1843
1844#[doc(hidden)]
1845impl FromGlib<ffi::GtkTextSearchFlags> for TextSearchFlags {
1846 #[inline]
1847 unsafe fn from_glib(value: ffi::GtkTextSearchFlags) -> Self {
1848 skip_assert_initialized!();
1849 Self::from_bits_truncate(value)
1850 }
1851}
1852
1853impl StaticType for TextSearchFlags {
1854 #[inline]
1855 #[doc(alias = "gtk_text_search_flags_get_type")]
1856 fn static_type() -> glib::Type {
1857 unsafe { from_glib(ffi::gtk_text_search_flags_get_type()) }
1858 }
1859}
1860
1861impl glib::HasParamSpec for TextSearchFlags {
1862 type ParamSpec = glib::ParamSpecFlags;
1863 type SetValue = Self;
1864 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1865
1866 fn param_spec_builder() -> Self::BuilderFn {
1867 Self::ParamSpec::builder
1868 }
1869}
1870
1871impl glib::value::ValueType for TextSearchFlags {
1872 type Type = Self;
1873}
1874
1875unsafe impl<'a> glib::value::FromValue<'a> for TextSearchFlags {
1876 type Checker = glib::value::GenericValueTypeChecker<Self>;
1877
1878 #[inline]
1879 unsafe fn from_value(value: &'a glib::Value) -> Self {
1880 skip_assert_initialized!();
1881 unsafe { from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) }
1882 }
1883}
1884
1885impl ToValue for TextSearchFlags {
1886 #[inline]
1887 fn to_value(&self) -> glib::Value {
1888 let mut value = glib::Value::for_value_type::<Self>();
1889 unsafe {
1890 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1891 }
1892 value
1893 }
1894
1895 #[inline]
1896 fn value_type(&self) -> glib::Type {
1897 Self::static_type()
1898 }
1899}
1900
1901impl From<TextSearchFlags> for glib::Value {
1902 #[inline]
1903 fn from(v: TextSearchFlags) -> Self {
1904 skip_assert_initialized!();
1905 ToValue::to_value(&v)
1906 }
1907}
1908
1909bitflags! {
1910 #[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
1911 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1912 #[doc(alias = "GtkTreeModelFlags")]
1913 pub struct TreeModelFlags: u32 {
1914 #[doc(alias = "GTK_TREE_MODEL_ITERS_PERSIST")]
1915 const ITERS_PERSIST = ffi::GTK_TREE_MODEL_ITERS_PERSIST as _;
1916 #[doc(alias = "GTK_TREE_MODEL_LIST_ONLY")]
1917 const LIST_ONLY = ffi::GTK_TREE_MODEL_LIST_ONLY as _;
1918 }
1919}
1920
1921#[allow(deprecated)]
1922#[doc(hidden)]
1923impl IntoGlib for TreeModelFlags {
1924 type GlibType = ffi::GtkTreeModelFlags;
1925
1926 #[inline]
1927 fn into_glib(self) -> ffi::GtkTreeModelFlags {
1928 self.bits()
1929 }
1930}
1931
1932#[allow(deprecated)]
1933#[doc(hidden)]
1934impl FromGlib<ffi::GtkTreeModelFlags> for TreeModelFlags {
1935 #[inline]
1936 unsafe fn from_glib(value: ffi::GtkTreeModelFlags) -> Self {
1937 skip_assert_initialized!();
1938 Self::from_bits_truncate(value)
1939 }
1940}
1941
1942#[allow(deprecated)]
1943impl StaticType for TreeModelFlags {
1944 #[inline]
1945 #[doc(alias = "gtk_tree_model_flags_get_type")]
1946 fn static_type() -> glib::Type {
1947 unsafe { from_glib(ffi::gtk_tree_model_flags_get_type()) }
1948 }
1949}
1950
1951#[allow(deprecated)]
1952impl glib::HasParamSpec for TreeModelFlags {
1953 type ParamSpec = glib::ParamSpecFlags;
1954 type SetValue = Self;
1955 type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>;
1956
1957 fn param_spec_builder() -> Self::BuilderFn {
1958 Self::ParamSpec::builder
1959 }
1960}
1961
1962#[allow(deprecated)]
1963impl glib::value::ValueType for TreeModelFlags {
1964 type Type = Self;
1965}
1966
1967#[allow(deprecated)]
1968unsafe impl<'a> glib::value::FromValue<'a> for TreeModelFlags {
1969 type Checker = glib::value::GenericValueTypeChecker<Self>;
1970
1971 #[inline]
1972 unsafe fn from_value(value: &'a glib::Value) -> Self {
1973 skip_assert_initialized!();
1974 unsafe { from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) }
1975 }
1976}
1977
1978#[allow(deprecated)]
1979impl ToValue for TreeModelFlags {
1980 #[inline]
1981 fn to_value(&self) -> glib::Value {
1982 let mut value = glib::Value::for_value_type::<Self>();
1983 unsafe {
1984 glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib());
1985 }
1986 value
1987 }
1988
1989 #[inline]
1990 fn value_type(&self) -> glib::Type {
1991 Self::static_type()
1992 }
1993}
1994
1995#[allow(deprecated)]
1996impl From<TreeModelFlags> for glib::Value {
1997 #[inline]
1998 fn from(v: TreeModelFlags) -> Self {
1999 skip_assert_initialized!();
2000 ToValue::to_value(&v)
2001 }
2002}