1use crate::ffi;
6use glib::{prelude::*, translate::*};
7
8#[cfg(feature = "v4_14")]
10#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
11#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
12#[non_exhaustive]
13#[doc(alias = "GtkAccessibleAnnouncementPriority")]
14pub enum AccessibleAnnouncementPriority {
15 #[doc(alias = "GTK_ACCESSIBLE_ANNOUNCEMENT_PRIORITY_LOW")]
18 Low,
19 #[doc(alias = "GTK_ACCESSIBLE_ANNOUNCEMENT_PRIORITY_MEDIUM")]
23 Medium,
24 #[doc(alias = "GTK_ACCESSIBLE_ANNOUNCEMENT_PRIORITY_HIGH")]
31 High,
32 #[doc(hidden)]
33 __Unknown(i32),
34}
35
36#[cfg(feature = "v4_14")]
37#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
38#[doc(hidden)]
39impl IntoGlib for AccessibleAnnouncementPriority {
40 type GlibType = ffi::GtkAccessibleAnnouncementPriority;
41
42 #[inline]
43 fn into_glib(self) -> ffi::GtkAccessibleAnnouncementPriority {
44 match self {
45 Self::Low => ffi::GTK_ACCESSIBLE_ANNOUNCEMENT_PRIORITY_LOW,
46 Self::Medium => ffi::GTK_ACCESSIBLE_ANNOUNCEMENT_PRIORITY_MEDIUM,
47 Self::High => ffi::GTK_ACCESSIBLE_ANNOUNCEMENT_PRIORITY_HIGH,
48 Self::__Unknown(value) => value,
49 }
50 }
51}
52
53#[cfg(feature = "v4_14")]
54#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
55#[doc(hidden)]
56impl FromGlib<ffi::GtkAccessibleAnnouncementPriority> for AccessibleAnnouncementPriority {
57 #[inline]
58 unsafe fn from_glib(value: ffi::GtkAccessibleAnnouncementPriority) -> Self {
59 skip_assert_initialized!();
60
61 match value {
62 ffi::GTK_ACCESSIBLE_ANNOUNCEMENT_PRIORITY_LOW => Self::Low,
63 ffi::GTK_ACCESSIBLE_ANNOUNCEMENT_PRIORITY_MEDIUM => Self::Medium,
64 ffi::GTK_ACCESSIBLE_ANNOUNCEMENT_PRIORITY_HIGH => Self::High,
65 value => Self::__Unknown(value),
66 }
67 }
68}
69
70#[cfg(feature = "v4_14")]
71#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
72impl StaticType for AccessibleAnnouncementPriority {
73 #[inline]
74 #[doc(alias = "gtk_accessible_announcement_priority_get_type")]
75 fn static_type() -> glib::Type {
76 unsafe { from_glib(ffi::gtk_accessible_announcement_priority_get_type()) }
77 }
78}
79
80#[cfg(feature = "v4_14")]
81#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
82impl glib::HasParamSpec for AccessibleAnnouncementPriority {
83 type ParamSpec = glib::ParamSpecEnum;
84 type SetValue = Self;
85 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
86
87 fn param_spec_builder() -> Self::BuilderFn {
88 Self::ParamSpec::builder_with_default
89 }
90}
91
92#[cfg(feature = "v4_14")]
93#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
94impl glib::value::ValueType for AccessibleAnnouncementPriority {
95 type Type = Self;
96}
97
98#[cfg(feature = "v4_14")]
99#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
100unsafe impl<'a> glib::value::FromValue<'a> for AccessibleAnnouncementPriority {
101 type Checker = glib::value::GenericValueTypeChecker<Self>;
102
103 #[inline]
104 unsafe fn from_value(value: &'a glib::Value) -> Self {
105 skip_assert_initialized!();
106 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
107 }
108}
109
110#[cfg(feature = "v4_14")]
111#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
112impl ToValue for AccessibleAnnouncementPriority {
113 #[inline]
114 fn to_value(&self) -> glib::Value {
115 let mut value = glib::Value::for_value_type::<Self>();
116 unsafe {
117 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
118 }
119 value
120 }
121
122 #[inline]
123 fn value_type(&self) -> glib::Type {
124 Self::static_type()
125 }
126}
127
128#[cfg(feature = "v4_14")]
129#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
130impl From<AccessibleAnnouncementPriority> for glib::Value {
131 #[inline]
132 fn from(v: AccessibleAnnouncementPriority) -> Self {
133 skip_assert_initialized!();
134 ToValue::to_value(&v)
135 }
136}
137
138#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
141#[non_exhaustive]
142#[doc(alias = "GtkAccessibleAutocomplete")]
143pub enum AccessibleAutocomplete {
144 #[doc(alias = "GTK_ACCESSIBLE_AUTOCOMPLETE_NONE")]
146 None,
147 #[doc(alias = "GTK_ACCESSIBLE_AUTOCOMPLETE_INLINE")]
151 Inline,
152 #[doc(alias = "GTK_ACCESSIBLE_AUTOCOMPLETE_LIST")]
156 List,
157 #[doc(alias = "GTK_ACCESSIBLE_AUTOCOMPLETE_BOTH")]
163 Both,
164 #[doc(hidden)]
165 __Unknown(i32),
166}
167
168#[doc(hidden)]
169impl IntoGlib for AccessibleAutocomplete {
170 type GlibType = ffi::GtkAccessibleAutocomplete;
171
172 #[inline]
173 fn into_glib(self) -> ffi::GtkAccessibleAutocomplete {
174 match self {
175 Self::None => ffi::GTK_ACCESSIBLE_AUTOCOMPLETE_NONE,
176 Self::Inline => ffi::GTK_ACCESSIBLE_AUTOCOMPLETE_INLINE,
177 Self::List => ffi::GTK_ACCESSIBLE_AUTOCOMPLETE_LIST,
178 Self::Both => ffi::GTK_ACCESSIBLE_AUTOCOMPLETE_BOTH,
179 Self::__Unknown(value) => value,
180 }
181 }
182}
183
184#[doc(hidden)]
185impl FromGlib<ffi::GtkAccessibleAutocomplete> for AccessibleAutocomplete {
186 #[inline]
187 unsafe fn from_glib(value: ffi::GtkAccessibleAutocomplete) -> Self {
188 skip_assert_initialized!();
189
190 match value {
191 ffi::GTK_ACCESSIBLE_AUTOCOMPLETE_NONE => Self::None,
192 ffi::GTK_ACCESSIBLE_AUTOCOMPLETE_INLINE => Self::Inline,
193 ffi::GTK_ACCESSIBLE_AUTOCOMPLETE_LIST => Self::List,
194 ffi::GTK_ACCESSIBLE_AUTOCOMPLETE_BOTH => Self::Both,
195 value => Self::__Unknown(value),
196 }
197 }
198}
199
200impl StaticType for AccessibleAutocomplete {
201 #[inline]
202 #[doc(alias = "gtk_accessible_autocomplete_get_type")]
203 fn static_type() -> glib::Type {
204 unsafe { from_glib(ffi::gtk_accessible_autocomplete_get_type()) }
205 }
206}
207
208impl glib::HasParamSpec for AccessibleAutocomplete {
209 type ParamSpec = glib::ParamSpecEnum;
210 type SetValue = Self;
211 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
212
213 fn param_spec_builder() -> Self::BuilderFn {
214 Self::ParamSpec::builder_with_default
215 }
216}
217
218impl glib::value::ValueType for AccessibleAutocomplete {
219 type Type = Self;
220}
221
222unsafe impl<'a> glib::value::FromValue<'a> for AccessibleAutocomplete {
223 type Checker = glib::value::GenericValueTypeChecker<Self>;
224
225 #[inline]
226 unsafe fn from_value(value: &'a glib::Value) -> Self {
227 skip_assert_initialized!();
228 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
229 }
230}
231
232impl ToValue for AccessibleAutocomplete {
233 #[inline]
234 fn to_value(&self) -> glib::Value {
235 let mut value = glib::Value::for_value_type::<Self>();
236 unsafe {
237 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
238 }
239 value
240 }
241
242 #[inline]
243 fn value_type(&self) -> glib::Type {
244 Self::static_type()
245 }
246}
247
248impl From<AccessibleAutocomplete> for glib::Value {
249 #[inline]
250 fn from(v: AccessibleAutocomplete) -> Self {
251 skip_assert_initialized!();
252 ToValue::to_value(&v)
253 }
254}
255
256#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
263#[non_exhaustive]
264#[doc(alias = "GtkAccessibleInvalidState")]
265pub enum AccessibleInvalidState {
266 #[doc(alias = "GTK_ACCESSIBLE_INVALID_FALSE")]
268 False,
269 #[doc(alias = "GTK_ACCESSIBLE_INVALID_TRUE")]
271 True,
272 #[doc(alias = "GTK_ACCESSIBLE_INVALID_GRAMMAR")]
274 Grammar,
275 #[doc(alias = "GTK_ACCESSIBLE_INVALID_SPELLING")]
277 Spelling,
278 #[doc(hidden)]
279 __Unknown(i32),
280}
281
282#[doc(hidden)]
283impl IntoGlib for AccessibleInvalidState {
284 type GlibType = ffi::GtkAccessibleInvalidState;
285
286 #[inline]
287 fn into_glib(self) -> ffi::GtkAccessibleInvalidState {
288 match self {
289 Self::False => ffi::GTK_ACCESSIBLE_INVALID_FALSE,
290 Self::True => ffi::GTK_ACCESSIBLE_INVALID_TRUE,
291 Self::Grammar => ffi::GTK_ACCESSIBLE_INVALID_GRAMMAR,
292 Self::Spelling => ffi::GTK_ACCESSIBLE_INVALID_SPELLING,
293 Self::__Unknown(value) => value,
294 }
295 }
296}
297
298#[doc(hidden)]
299impl FromGlib<ffi::GtkAccessibleInvalidState> for AccessibleInvalidState {
300 #[inline]
301 unsafe fn from_glib(value: ffi::GtkAccessibleInvalidState) -> Self {
302 skip_assert_initialized!();
303
304 match value {
305 ffi::GTK_ACCESSIBLE_INVALID_FALSE => Self::False,
306 ffi::GTK_ACCESSIBLE_INVALID_TRUE => Self::True,
307 ffi::GTK_ACCESSIBLE_INVALID_GRAMMAR => Self::Grammar,
308 ffi::GTK_ACCESSIBLE_INVALID_SPELLING => Self::Spelling,
309 value => Self::__Unknown(value),
310 }
311 }
312}
313
314impl StaticType for AccessibleInvalidState {
315 #[inline]
316 #[doc(alias = "gtk_accessible_invalid_state_get_type")]
317 fn static_type() -> glib::Type {
318 unsafe { from_glib(ffi::gtk_accessible_invalid_state_get_type()) }
319 }
320}
321
322impl glib::HasParamSpec for AccessibleInvalidState {
323 type ParamSpec = glib::ParamSpecEnum;
324 type SetValue = Self;
325 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
326
327 fn param_spec_builder() -> Self::BuilderFn {
328 Self::ParamSpec::builder_with_default
329 }
330}
331
332impl glib::value::ValueType for AccessibleInvalidState {
333 type Type = Self;
334}
335
336unsafe impl<'a> glib::value::FromValue<'a> for AccessibleInvalidState {
337 type Checker = glib::value::GenericValueTypeChecker<Self>;
338
339 #[inline]
340 unsafe fn from_value(value: &'a glib::Value) -> Self {
341 skip_assert_initialized!();
342 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
343 }
344}
345
346impl ToValue for AccessibleInvalidState {
347 #[inline]
348 fn to_value(&self) -> glib::Value {
349 let mut value = glib::Value::for_value_type::<Self>();
350 unsafe {
351 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
352 }
353 value
354 }
355
356 #[inline]
357 fn value_type(&self) -> glib::Type {
358 Self::static_type()
359 }
360}
361
362impl From<AccessibleInvalidState> for glib::Value {
363 #[inline]
364 fn from(v: AccessibleInvalidState) -> Self {
365 skip_assert_initialized!();
366 ToValue::to_value(&v)
367 }
368}
369
370#[cfg(feature = "v4_10")]
373#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
374#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
375#[non_exhaustive]
376#[doc(alias = "GtkAccessiblePlatformState")]
377pub enum AccessiblePlatformState {
378 #[doc(alias = "GTK_ACCESSIBLE_PLATFORM_STATE_FOCUSABLE")]
380 Focusable,
381 #[doc(alias = "GTK_ACCESSIBLE_PLATFORM_STATE_FOCUSED")]
383 Focused,
384 #[doc(alias = "GTK_ACCESSIBLE_PLATFORM_STATE_ACTIVE")]
386 Active,
387 #[doc(hidden)]
388 __Unknown(i32),
389}
390
391#[cfg(feature = "v4_10")]
392#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
393#[doc(hidden)]
394impl IntoGlib for AccessiblePlatformState {
395 type GlibType = ffi::GtkAccessiblePlatformState;
396
397 #[inline]
398 fn into_glib(self) -> ffi::GtkAccessiblePlatformState {
399 match self {
400 Self::Focusable => ffi::GTK_ACCESSIBLE_PLATFORM_STATE_FOCUSABLE,
401 Self::Focused => ffi::GTK_ACCESSIBLE_PLATFORM_STATE_FOCUSED,
402 Self::Active => ffi::GTK_ACCESSIBLE_PLATFORM_STATE_ACTIVE,
403 Self::__Unknown(value) => value,
404 }
405 }
406}
407
408#[cfg(feature = "v4_10")]
409#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
410#[doc(hidden)]
411impl FromGlib<ffi::GtkAccessiblePlatformState> for AccessiblePlatformState {
412 #[inline]
413 unsafe fn from_glib(value: ffi::GtkAccessiblePlatformState) -> Self {
414 skip_assert_initialized!();
415
416 match value {
417 ffi::GTK_ACCESSIBLE_PLATFORM_STATE_FOCUSABLE => Self::Focusable,
418 ffi::GTK_ACCESSIBLE_PLATFORM_STATE_FOCUSED => Self::Focused,
419 ffi::GTK_ACCESSIBLE_PLATFORM_STATE_ACTIVE => Self::Active,
420 value => Self::__Unknown(value),
421 }
422 }
423}
424
425#[cfg(feature = "v4_10")]
426#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
427impl StaticType for AccessiblePlatformState {
428 #[inline]
429 #[doc(alias = "gtk_accessible_platform_state_get_type")]
430 fn static_type() -> glib::Type {
431 unsafe { from_glib(ffi::gtk_accessible_platform_state_get_type()) }
432 }
433}
434
435#[cfg(feature = "v4_10")]
436#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
437impl glib::HasParamSpec for AccessiblePlatformState {
438 type ParamSpec = glib::ParamSpecEnum;
439 type SetValue = Self;
440 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
441
442 fn param_spec_builder() -> Self::BuilderFn {
443 Self::ParamSpec::builder_with_default
444 }
445}
446
447#[cfg(feature = "v4_10")]
448#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
449impl glib::value::ValueType for AccessiblePlatformState {
450 type Type = Self;
451}
452
453#[cfg(feature = "v4_10")]
454#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
455unsafe impl<'a> glib::value::FromValue<'a> for AccessiblePlatformState {
456 type Checker = glib::value::GenericValueTypeChecker<Self>;
457
458 #[inline]
459 unsafe fn from_value(value: &'a glib::Value) -> Self {
460 skip_assert_initialized!();
461 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
462 }
463}
464
465#[cfg(feature = "v4_10")]
466#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
467impl ToValue for AccessiblePlatformState {
468 #[inline]
469 fn to_value(&self) -> glib::Value {
470 let mut value = glib::Value::for_value_type::<Self>();
471 unsafe {
472 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
473 }
474 value
475 }
476
477 #[inline]
478 fn value_type(&self) -> glib::Type {
479 Self::static_type()
480 }
481}
482
483#[cfg(feature = "v4_10")]
484#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
485impl From<AccessiblePlatformState> for glib::Value {
486 #[inline]
487 fn from(v: AccessiblePlatformState) -> Self {
488 skip_assert_initialized!();
489 ToValue::to_value(&v)
490 }
491}
492
493#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
495#[non_exhaustive]
496#[doc(alias = "GtkAccessibleProperty")]
497pub enum AccessibleProperty {
498 #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_AUTOCOMPLETE")]
503 Autocomplete,
504 #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_DESCRIPTION")]
507 Description,
508 #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_HAS_POPUP")]
512 HasPopup,
513 #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_KEY_SHORTCUTS")]
520 KeyShortcuts,
521 #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_LABEL")]
524 Label,
525 #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_LEVEL")]
528 Level,
529 #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_MODAL")]
532 Modal,
533 #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_MULTI_LINE")]
536 MultiLine,
537 #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_MULTI_SELECTABLE")]
541 MultiSelectable,
542 #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_ORIENTATION")]
546 Orientation,
547 #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_PLACEHOLDER")]
552 Placeholder,
553 #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_READ_ONLY")]
556 ReadOnly,
557 #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_REQUIRED")]
560 Required,
561 #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_ROLE_DESCRIPTION")]
564 RoleDescription,
565 #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_SORT")]
568 Sort,
569 #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_VALUE_MAX")]
572 ValueMax,
573 #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_VALUE_MIN")]
576 ValueMin,
577 #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_VALUE_NOW")]
580 ValueNow,
581 #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_VALUE_TEXT")]
584 ValueText,
585 #[cfg(feature = "v4_16")]
588 #[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
589 #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_HELP_TEXT")]
590 HelpText,
591 #[doc(hidden)]
592 __Unknown(i32),
593}
594
595impl AccessibleProperty {
596 #[doc(alias = "gtk_accessible_property_init_value")]
597 pub fn init_value(self, value: &mut glib::Value) {
598 assert_initialized_main_thread!();
599 unsafe {
600 ffi::gtk_accessible_property_init_value(self.into_glib(), value.to_glib_none_mut().0);
601 }
602 }
603}
604
605#[doc(hidden)]
606impl IntoGlib for AccessibleProperty {
607 type GlibType = ffi::GtkAccessibleProperty;
608
609 fn into_glib(self) -> ffi::GtkAccessibleProperty {
610 match self {
611 Self::Autocomplete => ffi::GTK_ACCESSIBLE_PROPERTY_AUTOCOMPLETE,
612 Self::Description => ffi::GTK_ACCESSIBLE_PROPERTY_DESCRIPTION,
613 Self::HasPopup => ffi::GTK_ACCESSIBLE_PROPERTY_HAS_POPUP,
614 Self::KeyShortcuts => ffi::GTK_ACCESSIBLE_PROPERTY_KEY_SHORTCUTS,
615 Self::Label => ffi::GTK_ACCESSIBLE_PROPERTY_LABEL,
616 Self::Level => ffi::GTK_ACCESSIBLE_PROPERTY_LEVEL,
617 Self::Modal => ffi::GTK_ACCESSIBLE_PROPERTY_MODAL,
618 Self::MultiLine => ffi::GTK_ACCESSIBLE_PROPERTY_MULTI_LINE,
619 Self::MultiSelectable => ffi::GTK_ACCESSIBLE_PROPERTY_MULTI_SELECTABLE,
620 Self::Orientation => ffi::GTK_ACCESSIBLE_PROPERTY_ORIENTATION,
621 Self::Placeholder => ffi::GTK_ACCESSIBLE_PROPERTY_PLACEHOLDER,
622 Self::ReadOnly => ffi::GTK_ACCESSIBLE_PROPERTY_READ_ONLY,
623 Self::Required => ffi::GTK_ACCESSIBLE_PROPERTY_REQUIRED,
624 Self::RoleDescription => ffi::GTK_ACCESSIBLE_PROPERTY_ROLE_DESCRIPTION,
625 Self::Sort => ffi::GTK_ACCESSIBLE_PROPERTY_SORT,
626 Self::ValueMax => ffi::GTK_ACCESSIBLE_PROPERTY_VALUE_MAX,
627 Self::ValueMin => ffi::GTK_ACCESSIBLE_PROPERTY_VALUE_MIN,
628 Self::ValueNow => ffi::GTK_ACCESSIBLE_PROPERTY_VALUE_NOW,
629 Self::ValueText => ffi::GTK_ACCESSIBLE_PROPERTY_VALUE_TEXT,
630 #[cfg(feature = "v4_16")]
631 Self::HelpText => ffi::GTK_ACCESSIBLE_PROPERTY_HELP_TEXT,
632 Self::__Unknown(value) => value,
633 }
634 }
635}
636
637#[doc(hidden)]
638impl FromGlib<ffi::GtkAccessibleProperty> for AccessibleProperty {
639 unsafe fn from_glib(value: ffi::GtkAccessibleProperty) -> Self {
640 skip_assert_initialized!();
641
642 match value {
643 ffi::GTK_ACCESSIBLE_PROPERTY_AUTOCOMPLETE => Self::Autocomplete,
644 ffi::GTK_ACCESSIBLE_PROPERTY_DESCRIPTION => Self::Description,
645 ffi::GTK_ACCESSIBLE_PROPERTY_HAS_POPUP => Self::HasPopup,
646 ffi::GTK_ACCESSIBLE_PROPERTY_KEY_SHORTCUTS => Self::KeyShortcuts,
647 ffi::GTK_ACCESSIBLE_PROPERTY_LABEL => Self::Label,
648 ffi::GTK_ACCESSIBLE_PROPERTY_LEVEL => Self::Level,
649 ffi::GTK_ACCESSIBLE_PROPERTY_MODAL => Self::Modal,
650 ffi::GTK_ACCESSIBLE_PROPERTY_MULTI_LINE => Self::MultiLine,
651 ffi::GTK_ACCESSIBLE_PROPERTY_MULTI_SELECTABLE => Self::MultiSelectable,
652 ffi::GTK_ACCESSIBLE_PROPERTY_ORIENTATION => Self::Orientation,
653 ffi::GTK_ACCESSIBLE_PROPERTY_PLACEHOLDER => Self::Placeholder,
654 ffi::GTK_ACCESSIBLE_PROPERTY_READ_ONLY => Self::ReadOnly,
655 ffi::GTK_ACCESSIBLE_PROPERTY_REQUIRED => Self::Required,
656 ffi::GTK_ACCESSIBLE_PROPERTY_ROLE_DESCRIPTION => Self::RoleDescription,
657 ffi::GTK_ACCESSIBLE_PROPERTY_SORT => Self::Sort,
658 ffi::GTK_ACCESSIBLE_PROPERTY_VALUE_MAX => Self::ValueMax,
659 ffi::GTK_ACCESSIBLE_PROPERTY_VALUE_MIN => Self::ValueMin,
660 ffi::GTK_ACCESSIBLE_PROPERTY_VALUE_NOW => Self::ValueNow,
661 ffi::GTK_ACCESSIBLE_PROPERTY_VALUE_TEXT => Self::ValueText,
662 #[cfg(feature = "v4_16")]
663 ffi::GTK_ACCESSIBLE_PROPERTY_HELP_TEXT => Self::HelpText,
664 value => Self::__Unknown(value),
665 }
666 }
667}
668
669impl StaticType for AccessibleProperty {
670 #[inline]
671 #[doc(alias = "gtk_accessible_property_get_type")]
672 fn static_type() -> glib::Type {
673 unsafe { from_glib(ffi::gtk_accessible_property_get_type()) }
674 }
675}
676
677impl glib::HasParamSpec for AccessibleProperty {
678 type ParamSpec = glib::ParamSpecEnum;
679 type SetValue = Self;
680 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
681
682 fn param_spec_builder() -> Self::BuilderFn {
683 Self::ParamSpec::builder_with_default
684 }
685}
686
687impl glib::value::ValueType for AccessibleProperty {
688 type Type = Self;
689}
690
691unsafe impl<'a> glib::value::FromValue<'a> for AccessibleProperty {
692 type Checker = glib::value::GenericValueTypeChecker<Self>;
693
694 #[inline]
695 unsafe fn from_value(value: &'a glib::Value) -> Self {
696 skip_assert_initialized!();
697 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
698 }
699}
700
701impl ToValue for AccessibleProperty {
702 #[inline]
703 fn to_value(&self) -> glib::Value {
704 let mut value = glib::Value::for_value_type::<Self>();
705 unsafe {
706 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
707 }
708 value
709 }
710
711 #[inline]
712 fn value_type(&self) -> glib::Type {
713 Self::static_type()
714 }
715}
716
717impl From<AccessibleProperty> for glib::Value {
718 #[inline]
719 fn from(v: AccessibleProperty) -> Self {
720 skip_assert_initialized!();
721 ToValue::to_value(&v)
722 }
723}
724
725#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
730#[non_exhaustive]
731#[doc(alias = "GtkAccessibleRelation")]
732pub enum AccessibleRelation {
733 #[doc(alias = "GTK_ACCESSIBLE_RELATION_ACTIVE_DESCENDANT")]
737 ActiveDescendant,
738 #[doc(alias = "GTK_ACCESSIBLE_RELATION_COL_COUNT")]
741 ColCount,
742 #[doc(alias = "GTK_ACCESSIBLE_RELATION_COL_INDEX")]
746 ColIndex,
747 #[doc(alias = "GTK_ACCESSIBLE_RELATION_COL_INDEX_TEXT")]
750 ColIndexText,
751 #[doc(alias = "GTK_ACCESSIBLE_RELATION_COL_SPAN")]
754 ColSpan,
755 #[doc(alias = "GTK_ACCESSIBLE_RELATION_CONTROLS")]
758 Controls,
759 #[doc(alias = "GTK_ACCESSIBLE_RELATION_DESCRIBED_BY")]
762 DescribedBy,
763 #[doc(alias = "GTK_ACCESSIBLE_RELATION_DETAILS")]
766 Details,
767 #[doc(alias = "GTK_ACCESSIBLE_RELATION_ERROR_MESSAGE")]
770 ErrorMessage,
771 #[doc(alias = "GTK_ACCESSIBLE_RELATION_FLOW_TO")]
776 FlowTo,
777 #[doc(alias = "GTK_ACCESSIBLE_RELATION_LABELLED_BY")]
780 LabelledBy,
781 #[doc(alias = "GTK_ACCESSIBLE_RELATION_OWNS")]
786 Owns,
787 #[doc(alias = "GTK_ACCESSIBLE_RELATION_POS_IN_SET")]
790 PosInSet,
791 #[doc(alias = "GTK_ACCESSIBLE_RELATION_ROW_COUNT")]
794 RowCount,
795 #[doc(alias = "GTK_ACCESSIBLE_RELATION_ROW_INDEX")]
799 RowIndex,
800 #[doc(alias = "GTK_ACCESSIBLE_RELATION_ROW_INDEX_TEXT")]
803 RowIndexText,
804 #[doc(alias = "GTK_ACCESSIBLE_RELATION_ROW_SPAN")]
807 RowSpan,
808 #[doc(alias = "GTK_ACCESSIBLE_RELATION_SET_SIZE")]
811 SetSize,
812 #[cfg(feature = "v4_18")]
817 #[cfg_attr(docsrs, doc(cfg(feature = "v4_18")))]
818 #[doc(alias = "GTK_ACCESSIBLE_RELATION_LABEL_FOR")]
819 LabelFor,
820 #[cfg(feature = "v4_18")]
825 #[cfg_attr(docsrs, doc(cfg(feature = "v4_18")))]
826 #[doc(alias = "GTK_ACCESSIBLE_RELATION_DESCRIPTION_FOR")]
827 DescriptionFor,
828 #[cfg(feature = "v4_18")]
833 #[cfg_attr(docsrs, doc(cfg(feature = "v4_18")))]
834 #[doc(alias = "GTK_ACCESSIBLE_RELATION_CONTROLLED_BY")]
835 ControlledBy,
836 #[cfg(feature = "v4_18")]
841 #[cfg_attr(docsrs, doc(cfg(feature = "v4_18")))]
842 #[doc(alias = "GTK_ACCESSIBLE_RELATION_DETAILS_FOR")]
843 DetailsFor,
844 #[cfg(feature = "v4_18")]
849 #[cfg_attr(docsrs, doc(cfg(feature = "v4_18")))]
850 #[doc(alias = "GTK_ACCESSIBLE_RELATION_ERROR_MESSAGE_FOR")]
851 ErrorMessageFor,
852 #[cfg(feature = "v4_18")]
859 #[cfg_attr(docsrs, doc(cfg(feature = "v4_18")))]
860 #[doc(alias = "GTK_ACCESSIBLE_RELATION_FLOW_FROM")]
861 FlowFrom,
862 #[doc(hidden)]
863 __Unknown(i32),
864}
865
866impl AccessibleRelation {
867 #[doc(alias = "gtk_accessible_relation_init_value")]
868 pub fn init_value(self, value: &mut glib::Value) {
869 assert_initialized_main_thread!();
870 unsafe {
871 ffi::gtk_accessible_relation_init_value(self.into_glib(), value.to_glib_none_mut().0);
872 }
873 }
874}
875
876#[doc(hidden)]
877impl IntoGlib for AccessibleRelation {
878 type GlibType = ffi::GtkAccessibleRelation;
879
880 fn into_glib(self) -> ffi::GtkAccessibleRelation {
881 match self {
882 Self::ActiveDescendant => ffi::GTK_ACCESSIBLE_RELATION_ACTIVE_DESCENDANT,
883 Self::ColCount => ffi::GTK_ACCESSIBLE_RELATION_COL_COUNT,
884 Self::ColIndex => ffi::GTK_ACCESSIBLE_RELATION_COL_INDEX,
885 Self::ColIndexText => ffi::GTK_ACCESSIBLE_RELATION_COL_INDEX_TEXT,
886 Self::ColSpan => ffi::GTK_ACCESSIBLE_RELATION_COL_SPAN,
887 Self::Controls => ffi::GTK_ACCESSIBLE_RELATION_CONTROLS,
888 Self::DescribedBy => ffi::GTK_ACCESSIBLE_RELATION_DESCRIBED_BY,
889 Self::Details => ffi::GTK_ACCESSIBLE_RELATION_DETAILS,
890 Self::ErrorMessage => ffi::GTK_ACCESSIBLE_RELATION_ERROR_MESSAGE,
891 Self::FlowTo => ffi::GTK_ACCESSIBLE_RELATION_FLOW_TO,
892 Self::LabelledBy => ffi::GTK_ACCESSIBLE_RELATION_LABELLED_BY,
893 Self::Owns => ffi::GTK_ACCESSIBLE_RELATION_OWNS,
894 Self::PosInSet => ffi::GTK_ACCESSIBLE_RELATION_POS_IN_SET,
895 Self::RowCount => ffi::GTK_ACCESSIBLE_RELATION_ROW_COUNT,
896 Self::RowIndex => ffi::GTK_ACCESSIBLE_RELATION_ROW_INDEX,
897 Self::RowIndexText => ffi::GTK_ACCESSIBLE_RELATION_ROW_INDEX_TEXT,
898 Self::RowSpan => ffi::GTK_ACCESSIBLE_RELATION_ROW_SPAN,
899 Self::SetSize => ffi::GTK_ACCESSIBLE_RELATION_SET_SIZE,
900 #[cfg(feature = "v4_18")]
901 Self::LabelFor => ffi::GTK_ACCESSIBLE_RELATION_LABEL_FOR,
902 #[cfg(feature = "v4_18")]
903 Self::DescriptionFor => ffi::GTK_ACCESSIBLE_RELATION_DESCRIPTION_FOR,
904 #[cfg(feature = "v4_18")]
905 Self::ControlledBy => ffi::GTK_ACCESSIBLE_RELATION_CONTROLLED_BY,
906 #[cfg(feature = "v4_18")]
907 Self::DetailsFor => ffi::GTK_ACCESSIBLE_RELATION_DETAILS_FOR,
908 #[cfg(feature = "v4_18")]
909 Self::ErrorMessageFor => ffi::GTK_ACCESSIBLE_RELATION_ERROR_MESSAGE_FOR,
910 #[cfg(feature = "v4_18")]
911 Self::FlowFrom => ffi::GTK_ACCESSIBLE_RELATION_FLOW_FROM,
912 Self::__Unknown(value) => value,
913 }
914 }
915}
916
917#[doc(hidden)]
918impl FromGlib<ffi::GtkAccessibleRelation> for AccessibleRelation {
919 unsafe fn from_glib(value: ffi::GtkAccessibleRelation) -> Self {
920 skip_assert_initialized!();
921
922 match value {
923 ffi::GTK_ACCESSIBLE_RELATION_ACTIVE_DESCENDANT => Self::ActiveDescendant,
924 ffi::GTK_ACCESSIBLE_RELATION_COL_COUNT => Self::ColCount,
925 ffi::GTK_ACCESSIBLE_RELATION_COL_INDEX => Self::ColIndex,
926 ffi::GTK_ACCESSIBLE_RELATION_COL_INDEX_TEXT => Self::ColIndexText,
927 ffi::GTK_ACCESSIBLE_RELATION_COL_SPAN => Self::ColSpan,
928 ffi::GTK_ACCESSIBLE_RELATION_CONTROLS => Self::Controls,
929 ffi::GTK_ACCESSIBLE_RELATION_DESCRIBED_BY => Self::DescribedBy,
930 ffi::GTK_ACCESSIBLE_RELATION_DETAILS => Self::Details,
931 ffi::GTK_ACCESSIBLE_RELATION_ERROR_MESSAGE => Self::ErrorMessage,
932 ffi::GTK_ACCESSIBLE_RELATION_FLOW_TO => Self::FlowTo,
933 ffi::GTK_ACCESSIBLE_RELATION_LABELLED_BY => Self::LabelledBy,
934 ffi::GTK_ACCESSIBLE_RELATION_OWNS => Self::Owns,
935 ffi::GTK_ACCESSIBLE_RELATION_POS_IN_SET => Self::PosInSet,
936 ffi::GTK_ACCESSIBLE_RELATION_ROW_COUNT => Self::RowCount,
937 ffi::GTK_ACCESSIBLE_RELATION_ROW_INDEX => Self::RowIndex,
938 ffi::GTK_ACCESSIBLE_RELATION_ROW_INDEX_TEXT => Self::RowIndexText,
939 ffi::GTK_ACCESSIBLE_RELATION_ROW_SPAN => Self::RowSpan,
940 ffi::GTK_ACCESSIBLE_RELATION_SET_SIZE => Self::SetSize,
941 #[cfg(feature = "v4_18")]
942 ffi::GTK_ACCESSIBLE_RELATION_LABEL_FOR => Self::LabelFor,
943 #[cfg(feature = "v4_18")]
944 ffi::GTK_ACCESSIBLE_RELATION_DESCRIPTION_FOR => Self::DescriptionFor,
945 #[cfg(feature = "v4_18")]
946 ffi::GTK_ACCESSIBLE_RELATION_CONTROLLED_BY => Self::ControlledBy,
947 #[cfg(feature = "v4_18")]
948 ffi::GTK_ACCESSIBLE_RELATION_DETAILS_FOR => Self::DetailsFor,
949 #[cfg(feature = "v4_18")]
950 ffi::GTK_ACCESSIBLE_RELATION_ERROR_MESSAGE_FOR => Self::ErrorMessageFor,
951 #[cfg(feature = "v4_18")]
952 ffi::GTK_ACCESSIBLE_RELATION_FLOW_FROM => Self::FlowFrom,
953 value => Self::__Unknown(value),
954 }
955 }
956}
957
958impl StaticType for AccessibleRelation {
959 #[inline]
960 #[doc(alias = "gtk_accessible_relation_get_type")]
961 fn static_type() -> glib::Type {
962 unsafe { from_glib(ffi::gtk_accessible_relation_get_type()) }
963 }
964}
965
966impl glib::HasParamSpec for AccessibleRelation {
967 type ParamSpec = glib::ParamSpecEnum;
968 type SetValue = Self;
969 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
970
971 fn param_spec_builder() -> Self::BuilderFn {
972 Self::ParamSpec::builder_with_default
973 }
974}
975
976impl glib::value::ValueType for AccessibleRelation {
977 type Type = Self;
978}
979
980unsafe impl<'a> glib::value::FromValue<'a> for AccessibleRelation {
981 type Checker = glib::value::GenericValueTypeChecker<Self>;
982
983 #[inline]
984 unsafe fn from_value(value: &'a glib::Value) -> Self {
985 skip_assert_initialized!();
986 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
987 }
988}
989
990impl ToValue for AccessibleRelation {
991 #[inline]
992 fn to_value(&self) -> glib::Value {
993 let mut value = glib::Value::for_value_type::<Self>();
994 unsafe {
995 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
996 }
997 value
998 }
999
1000 #[inline]
1001 fn value_type(&self) -> glib::Type {
1002 Self::static_type()
1003 }
1004}
1005
1006impl From<AccessibleRelation> for glib::Value {
1007 #[inline]
1008 fn from(v: AccessibleRelation) -> Self {
1009 skip_assert_initialized!();
1010 ToValue::to_value(&v)
1011 }
1012}
1013
1014#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1019#[non_exhaustive]
1020#[doc(alias = "GtkAccessibleRole")]
1021pub enum AccessibleRole {
1022 #[doc(alias = "GTK_ACCESSIBLE_ROLE_ALERT")]
1025 Alert,
1026 #[doc(alias = "GTK_ACCESSIBLE_ROLE_ALERT_DIALOG")]
1029 AlertDialog,
1030 #[doc(alias = "GTK_ACCESSIBLE_ROLE_BANNER")]
1032 Banner,
1033 #[doc(alias = "GTK_ACCESSIBLE_ROLE_BUTTON")]
1036 Button,
1037 #[doc(alias = "GTK_ACCESSIBLE_ROLE_CAPTION")]
1039 Caption,
1040 #[doc(alias = "GTK_ACCESSIBLE_ROLE_CELL")]
1042 Cell,
1043 #[doc(alias = "GTK_ACCESSIBLE_ROLE_CHECKBOX")]
1046 Checkbox,
1047 #[doc(alias = "GTK_ACCESSIBLE_ROLE_COLUMN_HEADER")]
1049 ColumnHeader,
1050 #[doc(alias = "GTK_ACCESSIBLE_ROLE_COMBO_BOX")]
1054 ComboBox,
1055 #[doc(alias = "GTK_ACCESSIBLE_ROLE_COMMAND")]
1057 Command,
1058 #[doc(alias = "GTK_ACCESSIBLE_ROLE_COMPOSITE")]
1060 Composite,
1061 #[doc(alias = "GTK_ACCESSIBLE_ROLE_DIALOG")]
1065 Dialog,
1066 #[doc(alias = "GTK_ACCESSIBLE_ROLE_DOCUMENT")]
1069 Document,
1070 #[doc(alias = "GTK_ACCESSIBLE_ROLE_FEED")]
1072 Feed,
1073 #[doc(alias = "GTK_ACCESSIBLE_ROLE_FORM")]
1075 Form,
1076 #[doc(alias = "GTK_ACCESSIBLE_ROLE_GENERIC")]
1079 Generic,
1080 #[doc(alias = "GTK_ACCESSIBLE_ROLE_GRID")]
1082 Grid,
1083 #[doc(alias = "GTK_ACCESSIBLE_ROLE_GRID_CELL")]
1085 GridCell,
1086 #[doc(alias = "GTK_ACCESSIBLE_ROLE_GROUP")]
1089 Group,
1090 #[doc(alias = "GTK_ACCESSIBLE_ROLE_HEADING")]
1092 Heading,
1093 #[doc(alias = "GTK_ACCESSIBLE_ROLE_IMG")]
1095 Img,
1096 #[doc(alias = "GTK_ACCESSIBLE_ROLE_INPUT")]
1098 Input,
1099 #[doc(alias = "GTK_ACCESSIBLE_ROLE_LABEL")]
1101 Label,
1102 #[doc(alias = "GTK_ACCESSIBLE_ROLE_LANDMARK")]
1104 Landmark,
1105 #[doc(alias = "GTK_ACCESSIBLE_ROLE_LEGEND")]
1107 Legend,
1108 #[doc(alias = "GTK_ACCESSIBLE_ROLE_LINK")]
1110 Link,
1111 #[doc(alias = "GTK_ACCESSIBLE_ROLE_LIST")]
1113 List,
1114 #[doc(alias = "GTK_ACCESSIBLE_ROLE_LIST_BOX")]
1116 ListBox,
1117 #[doc(alias = "GTK_ACCESSIBLE_ROLE_LIST_ITEM")]
1119 ListItem,
1120 #[doc(alias = "GTK_ACCESSIBLE_ROLE_LOG")]
1122 Log,
1123 #[doc(alias = "GTK_ACCESSIBLE_ROLE_MAIN")]
1125 Main,
1126 #[doc(alias = "GTK_ACCESSIBLE_ROLE_MARQUEE")]
1128 Marquee,
1129 #[doc(alias = "GTK_ACCESSIBLE_ROLE_MATH")]
1131 Math,
1132 #[doc(alias = "GTK_ACCESSIBLE_ROLE_METER")]
1134 Meter,
1135 #[doc(alias = "GTK_ACCESSIBLE_ROLE_MENU")]
1137 Menu,
1138 #[doc(alias = "GTK_ACCESSIBLE_ROLE_MENU_BAR")]
1140 MenuBar,
1141 #[doc(alias = "GTK_ACCESSIBLE_ROLE_MENU_ITEM")]
1143 MenuItem,
1144 #[doc(alias = "GTK_ACCESSIBLE_ROLE_MENU_ITEM_CHECKBOX")]
1146 MenuItemCheckbox,
1147 #[doc(alias = "GTK_ACCESSIBLE_ROLE_MENU_ITEM_RADIO")]
1149 MenuItemRadio,
1150 #[doc(alias = "GTK_ACCESSIBLE_ROLE_NAVIGATION")]
1152 Navigation,
1153 #[doc(alias = "GTK_ACCESSIBLE_ROLE_NONE")]
1156 None,
1157 #[doc(alias = "GTK_ACCESSIBLE_ROLE_NOTE")]
1159 Note,
1160 #[doc(alias = "GTK_ACCESSIBLE_ROLE_OPTION")]
1162 Option,
1163 #[doc(alias = "GTK_ACCESSIBLE_ROLE_PRESENTATION")]
1166 Presentation,
1167 #[doc(alias = "GTK_ACCESSIBLE_ROLE_PROGRESS_BAR")]
1170 ProgressBar,
1171 #[doc(alias = "GTK_ACCESSIBLE_ROLE_RADIO")]
1174 Radio,
1175 #[doc(alias = "GTK_ACCESSIBLE_ROLE_RADIO_GROUP")]
1177 RadioGroup,
1178 #[doc(alias = "GTK_ACCESSIBLE_ROLE_RANGE")]
1180 Range,
1181 #[doc(alias = "GTK_ACCESSIBLE_ROLE_REGION")]
1183 Region,
1184 #[doc(alias = "GTK_ACCESSIBLE_ROLE_ROW")]
1186 Row,
1187 #[doc(alias = "GTK_ACCESSIBLE_ROLE_ROW_GROUP")]
1189 RowGroup,
1190 #[doc(alias = "GTK_ACCESSIBLE_ROLE_ROW_HEADER")]
1192 RowHeader,
1193 #[doc(alias = "GTK_ACCESSIBLE_ROLE_SCROLLBAR")]
1197 Scrollbar,
1198 #[doc(alias = "GTK_ACCESSIBLE_ROLE_SEARCH")]
1200 Search,
1201 #[doc(alias = "GTK_ACCESSIBLE_ROLE_SEARCH_BOX")]
1204 SearchBox,
1205 #[doc(alias = "GTK_ACCESSIBLE_ROLE_SECTION")]
1207 Section,
1208 #[doc(alias = "GTK_ACCESSIBLE_ROLE_SECTION_HEAD")]
1210 SectionHead,
1211 #[doc(alias = "GTK_ACCESSIBLE_ROLE_SELECT")]
1213 Select,
1214 #[doc(alias = "GTK_ACCESSIBLE_ROLE_SEPARATOR")]
1217 Separator,
1218 #[doc(alias = "GTK_ACCESSIBLE_ROLE_SLIDER")]
1221 Slider,
1222 #[doc(alias = "GTK_ACCESSIBLE_ROLE_SPIN_BUTTON")]
1225 SpinButton,
1226 #[doc(alias = "GTK_ACCESSIBLE_ROLE_STATUS")]
1228 Status,
1229 #[doc(alias = "GTK_ACCESSIBLE_ROLE_STRUCTURE")]
1231 Structure,
1232 #[doc(alias = "GTK_ACCESSIBLE_ROLE_SWITCH")]
1235 Switch,
1236 #[doc(alias = "GTK_ACCESSIBLE_ROLE_TAB")]
1238 Tab,
1239 #[doc(alias = "GTK_ACCESSIBLE_ROLE_TABLE")]
1241 Table,
1242 #[doc(alias = "GTK_ACCESSIBLE_ROLE_TAB_LIST")]
1244 TabList,
1245 #[doc(alias = "GTK_ACCESSIBLE_ROLE_TAB_PANEL")]
1247 TabPanel,
1248 #[doc(alias = "GTK_ACCESSIBLE_ROLE_TEXT_BOX")]
1251 TextBox,
1252 #[doc(alias = "GTK_ACCESSIBLE_ROLE_TIME")]
1254 Time,
1255 #[doc(alias = "GTK_ACCESSIBLE_ROLE_TIMER")]
1257 Timer,
1258 #[doc(alias = "GTK_ACCESSIBLE_ROLE_TOOLBAR")]
1260 Toolbar,
1261 #[doc(alias = "GTK_ACCESSIBLE_ROLE_TOOLTIP")]
1263 Tooltip,
1264 #[doc(alias = "GTK_ACCESSIBLE_ROLE_TREE")]
1266 Tree,
1267 #[doc(alias = "GTK_ACCESSIBLE_ROLE_TREE_GRID")]
1269 TreeGrid,
1270 #[doc(alias = "GTK_ACCESSIBLE_ROLE_TREE_ITEM")]
1272 TreeItem,
1273 #[doc(alias = "GTK_ACCESSIBLE_ROLE_WIDGET")]
1276 Widget,
1277 #[doc(alias = "GTK_ACCESSIBLE_ROLE_WINDOW")]
1279 Window,
1280 #[cfg(feature = "v4_10")]
1283 #[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
1284 #[doc(alias = "GTK_ACCESSIBLE_ROLE_TOGGLE_BUTTON")]
1285 ToggleButton,
1286 #[cfg(feature = "v4_12")]
1290 #[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
1291 #[doc(alias = "GTK_ACCESSIBLE_ROLE_APPLICATION")]
1292 Application,
1293 #[cfg(feature = "v4_14")]
1295 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1296 #[doc(alias = "GTK_ACCESSIBLE_ROLE_PARAGRAPH")]
1297 Paragraph,
1298 #[cfg(feature = "v4_14")]
1300 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1301 #[doc(alias = "GTK_ACCESSIBLE_ROLE_BLOCK_QUOTE")]
1302 BlockQuote,
1303 #[cfg(feature = "v4_14")]
1306 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1307 #[doc(alias = "GTK_ACCESSIBLE_ROLE_ARTICLE")]
1308 Article,
1309 #[cfg(feature = "v4_14")]
1311 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1312 #[doc(alias = "GTK_ACCESSIBLE_ROLE_COMMENT")]
1313 Comment,
1314 #[cfg(feature = "v4_14")]
1316 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1317 #[doc(alias = "GTK_ACCESSIBLE_ROLE_TERMINAL")]
1318 Terminal,
1319 #[doc(hidden)]
1320 __Unknown(i32),
1321}
1322
1323#[doc(hidden)]
1324impl IntoGlib for AccessibleRole {
1325 type GlibType = ffi::GtkAccessibleRole;
1326
1327 fn into_glib(self) -> ffi::GtkAccessibleRole {
1328 match self {
1329 Self::Alert => ffi::GTK_ACCESSIBLE_ROLE_ALERT,
1330 Self::AlertDialog => ffi::GTK_ACCESSIBLE_ROLE_ALERT_DIALOG,
1331 Self::Banner => ffi::GTK_ACCESSIBLE_ROLE_BANNER,
1332 Self::Button => ffi::GTK_ACCESSIBLE_ROLE_BUTTON,
1333 Self::Caption => ffi::GTK_ACCESSIBLE_ROLE_CAPTION,
1334 Self::Cell => ffi::GTK_ACCESSIBLE_ROLE_CELL,
1335 Self::Checkbox => ffi::GTK_ACCESSIBLE_ROLE_CHECKBOX,
1336 Self::ColumnHeader => ffi::GTK_ACCESSIBLE_ROLE_COLUMN_HEADER,
1337 Self::ComboBox => ffi::GTK_ACCESSIBLE_ROLE_COMBO_BOX,
1338 Self::Command => ffi::GTK_ACCESSIBLE_ROLE_COMMAND,
1339 Self::Composite => ffi::GTK_ACCESSIBLE_ROLE_COMPOSITE,
1340 Self::Dialog => ffi::GTK_ACCESSIBLE_ROLE_DIALOG,
1341 Self::Document => ffi::GTK_ACCESSIBLE_ROLE_DOCUMENT,
1342 Self::Feed => ffi::GTK_ACCESSIBLE_ROLE_FEED,
1343 Self::Form => ffi::GTK_ACCESSIBLE_ROLE_FORM,
1344 Self::Generic => ffi::GTK_ACCESSIBLE_ROLE_GENERIC,
1345 Self::Grid => ffi::GTK_ACCESSIBLE_ROLE_GRID,
1346 Self::GridCell => ffi::GTK_ACCESSIBLE_ROLE_GRID_CELL,
1347 Self::Group => ffi::GTK_ACCESSIBLE_ROLE_GROUP,
1348 Self::Heading => ffi::GTK_ACCESSIBLE_ROLE_HEADING,
1349 Self::Img => ffi::GTK_ACCESSIBLE_ROLE_IMG,
1350 Self::Input => ffi::GTK_ACCESSIBLE_ROLE_INPUT,
1351 Self::Label => ffi::GTK_ACCESSIBLE_ROLE_LABEL,
1352 Self::Landmark => ffi::GTK_ACCESSIBLE_ROLE_LANDMARK,
1353 Self::Legend => ffi::GTK_ACCESSIBLE_ROLE_LEGEND,
1354 Self::Link => ffi::GTK_ACCESSIBLE_ROLE_LINK,
1355 Self::List => ffi::GTK_ACCESSIBLE_ROLE_LIST,
1356 Self::ListBox => ffi::GTK_ACCESSIBLE_ROLE_LIST_BOX,
1357 Self::ListItem => ffi::GTK_ACCESSIBLE_ROLE_LIST_ITEM,
1358 Self::Log => ffi::GTK_ACCESSIBLE_ROLE_LOG,
1359 Self::Main => ffi::GTK_ACCESSIBLE_ROLE_MAIN,
1360 Self::Marquee => ffi::GTK_ACCESSIBLE_ROLE_MARQUEE,
1361 Self::Math => ffi::GTK_ACCESSIBLE_ROLE_MATH,
1362 Self::Meter => ffi::GTK_ACCESSIBLE_ROLE_METER,
1363 Self::Menu => ffi::GTK_ACCESSIBLE_ROLE_MENU,
1364 Self::MenuBar => ffi::GTK_ACCESSIBLE_ROLE_MENU_BAR,
1365 Self::MenuItem => ffi::GTK_ACCESSIBLE_ROLE_MENU_ITEM,
1366 Self::MenuItemCheckbox => ffi::GTK_ACCESSIBLE_ROLE_MENU_ITEM_CHECKBOX,
1367 Self::MenuItemRadio => ffi::GTK_ACCESSIBLE_ROLE_MENU_ITEM_RADIO,
1368 Self::Navigation => ffi::GTK_ACCESSIBLE_ROLE_NAVIGATION,
1369 Self::None => ffi::GTK_ACCESSIBLE_ROLE_NONE,
1370 Self::Note => ffi::GTK_ACCESSIBLE_ROLE_NOTE,
1371 Self::Option => ffi::GTK_ACCESSIBLE_ROLE_OPTION,
1372 Self::Presentation => ffi::GTK_ACCESSIBLE_ROLE_PRESENTATION,
1373 Self::ProgressBar => ffi::GTK_ACCESSIBLE_ROLE_PROGRESS_BAR,
1374 Self::Radio => ffi::GTK_ACCESSIBLE_ROLE_RADIO,
1375 Self::RadioGroup => ffi::GTK_ACCESSIBLE_ROLE_RADIO_GROUP,
1376 Self::Range => ffi::GTK_ACCESSIBLE_ROLE_RANGE,
1377 Self::Region => ffi::GTK_ACCESSIBLE_ROLE_REGION,
1378 Self::Row => ffi::GTK_ACCESSIBLE_ROLE_ROW,
1379 Self::RowGroup => ffi::GTK_ACCESSIBLE_ROLE_ROW_GROUP,
1380 Self::RowHeader => ffi::GTK_ACCESSIBLE_ROLE_ROW_HEADER,
1381 Self::Scrollbar => ffi::GTK_ACCESSIBLE_ROLE_SCROLLBAR,
1382 Self::Search => ffi::GTK_ACCESSIBLE_ROLE_SEARCH,
1383 Self::SearchBox => ffi::GTK_ACCESSIBLE_ROLE_SEARCH_BOX,
1384 Self::Section => ffi::GTK_ACCESSIBLE_ROLE_SECTION,
1385 Self::SectionHead => ffi::GTK_ACCESSIBLE_ROLE_SECTION_HEAD,
1386 Self::Select => ffi::GTK_ACCESSIBLE_ROLE_SELECT,
1387 Self::Separator => ffi::GTK_ACCESSIBLE_ROLE_SEPARATOR,
1388 Self::Slider => ffi::GTK_ACCESSIBLE_ROLE_SLIDER,
1389 Self::SpinButton => ffi::GTK_ACCESSIBLE_ROLE_SPIN_BUTTON,
1390 Self::Status => ffi::GTK_ACCESSIBLE_ROLE_STATUS,
1391 Self::Structure => ffi::GTK_ACCESSIBLE_ROLE_STRUCTURE,
1392 Self::Switch => ffi::GTK_ACCESSIBLE_ROLE_SWITCH,
1393 Self::Tab => ffi::GTK_ACCESSIBLE_ROLE_TAB,
1394 Self::Table => ffi::GTK_ACCESSIBLE_ROLE_TABLE,
1395 Self::TabList => ffi::GTK_ACCESSIBLE_ROLE_TAB_LIST,
1396 Self::TabPanel => ffi::GTK_ACCESSIBLE_ROLE_TAB_PANEL,
1397 Self::TextBox => ffi::GTK_ACCESSIBLE_ROLE_TEXT_BOX,
1398 Self::Time => ffi::GTK_ACCESSIBLE_ROLE_TIME,
1399 Self::Timer => ffi::GTK_ACCESSIBLE_ROLE_TIMER,
1400 Self::Toolbar => ffi::GTK_ACCESSIBLE_ROLE_TOOLBAR,
1401 Self::Tooltip => ffi::GTK_ACCESSIBLE_ROLE_TOOLTIP,
1402 Self::Tree => ffi::GTK_ACCESSIBLE_ROLE_TREE,
1403 Self::TreeGrid => ffi::GTK_ACCESSIBLE_ROLE_TREE_GRID,
1404 Self::TreeItem => ffi::GTK_ACCESSIBLE_ROLE_TREE_ITEM,
1405 Self::Widget => ffi::GTK_ACCESSIBLE_ROLE_WIDGET,
1406 Self::Window => ffi::GTK_ACCESSIBLE_ROLE_WINDOW,
1407 #[cfg(feature = "v4_10")]
1408 Self::ToggleButton => ffi::GTK_ACCESSIBLE_ROLE_TOGGLE_BUTTON,
1409 #[cfg(feature = "v4_12")]
1410 Self::Application => ffi::GTK_ACCESSIBLE_ROLE_APPLICATION,
1411 #[cfg(feature = "v4_14")]
1412 Self::Paragraph => ffi::GTK_ACCESSIBLE_ROLE_PARAGRAPH,
1413 #[cfg(feature = "v4_14")]
1414 Self::BlockQuote => ffi::GTK_ACCESSIBLE_ROLE_BLOCK_QUOTE,
1415 #[cfg(feature = "v4_14")]
1416 Self::Article => ffi::GTK_ACCESSIBLE_ROLE_ARTICLE,
1417 #[cfg(feature = "v4_14")]
1418 Self::Comment => ffi::GTK_ACCESSIBLE_ROLE_COMMENT,
1419 #[cfg(feature = "v4_14")]
1420 Self::Terminal => ffi::GTK_ACCESSIBLE_ROLE_TERMINAL,
1421 Self::__Unknown(value) => value,
1422 }
1423 }
1424}
1425
1426#[doc(hidden)]
1427impl FromGlib<ffi::GtkAccessibleRole> for AccessibleRole {
1428 unsafe fn from_glib(value: ffi::GtkAccessibleRole) -> Self {
1429 skip_assert_initialized!();
1430
1431 match value {
1432 ffi::GTK_ACCESSIBLE_ROLE_ALERT => Self::Alert,
1433 ffi::GTK_ACCESSIBLE_ROLE_ALERT_DIALOG => Self::AlertDialog,
1434 ffi::GTK_ACCESSIBLE_ROLE_BANNER => Self::Banner,
1435 ffi::GTK_ACCESSIBLE_ROLE_BUTTON => Self::Button,
1436 ffi::GTK_ACCESSIBLE_ROLE_CAPTION => Self::Caption,
1437 ffi::GTK_ACCESSIBLE_ROLE_CELL => Self::Cell,
1438 ffi::GTK_ACCESSIBLE_ROLE_CHECKBOX => Self::Checkbox,
1439 ffi::GTK_ACCESSIBLE_ROLE_COLUMN_HEADER => Self::ColumnHeader,
1440 ffi::GTK_ACCESSIBLE_ROLE_COMBO_BOX => Self::ComboBox,
1441 ffi::GTK_ACCESSIBLE_ROLE_COMMAND => Self::Command,
1442 ffi::GTK_ACCESSIBLE_ROLE_COMPOSITE => Self::Composite,
1443 ffi::GTK_ACCESSIBLE_ROLE_DIALOG => Self::Dialog,
1444 ffi::GTK_ACCESSIBLE_ROLE_DOCUMENT => Self::Document,
1445 ffi::GTK_ACCESSIBLE_ROLE_FEED => Self::Feed,
1446 ffi::GTK_ACCESSIBLE_ROLE_FORM => Self::Form,
1447 ffi::GTK_ACCESSIBLE_ROLE_GENERIC => Self::Generic,
1448 ffi::GTK_ACCESSIBLE_ROLE_GRID => Self::Grid,
1449 ffi::GTK_ACCESSIBLE_ROLE_GRID_CELL => Self::GridCell,
1450 ffi::GTK_ACCESSIBLE_ROLE_GROUP => Self::Group,
1451 ffi::GTK_ACCESSIBLE_ROLE_HEADING => Self::Heading,
1452 ffi::GTK_ACCESSIBLE_ROLE_IMG => Self::Img,
1453 ffi::GTK_ACCESSIBLE_ROLE_INPUT => Self::Input,
1454 ffi::GTK_ACCESSIBLE_ROLE_LABEL => Self::Label,
1455 ffi::GTK_ACCESSIBLE_ROLE_LANDMARK => Self::Landmark,
1456 ffi::GTK_ACCESSIBLE_ROLE_LEGEND => Self::Legend,
1457 ffi::GTK_ACCESSIBLE_ROLE_LINK => Self::Link,
1458 ffi::GTK_ACCESSIBLE_ROLE_LIST => Self::List,
1459 ffi::GTK_ACCESSIBLE_ROLE_LIST_BOX => Self::ListBox,
1460 ffi::GTK_ACCESSIBLE_ROLE_LIST_ITEM => Self::ListItem,
1461 ffi::GTK_ACCESSIBLE_ROLE_LOG => Self::Log,
1462 ffi::GTK_ACCESSIBLE_ROLE_MAIN => Self::Main,
1463 ffi::GTK_ACCESSIBLE_ROLE_MARQUEE => Self::Marquee,
1464 ffi::GTK_ACCESSIBLE_ROLE_MATH => Self::Math,
1465 ffi::GTK_ACCESSIBLE_ROLE_METER => Self::Meter,
1466 ffi::GTK_ACCESSIBLE_ROLE_MENU => Self::Menu,
1467 ffi::GTK_ACCESSIBLE_ROLE_MENU_BAR => Self::MenuBar,
1468 ffi::GTK_ACCESSIBLE_ROLE_MENU_ITEM => Self::MenuItem,
1469 ffi::GTK_ACCESSIBLE_ROLE_MENU_ITEM_CHECKBOX => Self::MenuItemCheckbox,
1470 ffi::GTK_ACCESSIBLE_ROLE_MENU_ITEM_RADIO => Self::MenuItemRadio,
1471 ffi::GTK_ACCESSIBLE_ROLE_NAVIGATION => Self::Navigation,
1472 ffi::GTK_ACCESSIBLE_ROLE_NONE => Self::None,
1473 ffi::GTK_ACCESSIBLE_ROLE_NOTE => Self::Note,
1474 ffi::GTK_ACCESSIBLE_ROLE_OPTION => Self::Option,
1475 ffi::GTK_ACCESSIBLE_ROLE_PRESENTATION => Self::Presentation,
1476 ffi::GTK_ACCESSIBLE_ROLE_PROGRESS_BAR => Self::ProgressBar,
1477 ffi::GTK_ACCESSIBLE_ROLE_RADIO => Self::Radio,
1478 ffi::GTK_ACCESSIBLE_ROLE_RADIO_GROUP => Self::RadioGroup,
1479 ffi::GTK_ACCESSIBLE_ROLE_RANGE => Self::Range,
1480 ffi::GTK_ACCESSIBLE_ROLE_REGION => Self::Region,
1481 ffi::GTK_ACCESSIBLE_ROLE_ROW => Self::Row,
1482 ffi::GTK_ACCESSIBLE_ROLE_ROW_GROUP => Self::RowGroup,
1483 ffi::GTK_ACCESSIBLE_ROLE_ROW_HEADER => Self::RowHeader,
1484 ffi::GTK_ACCESSIBLE_ROLE_SCROLLBAR => Self::Scrollbar,
1485 ffi::GTK_ACCESSIBLE_ROLE_SEARCH => Self::Search,
1486 ffi::GTK_ACCESSIBLE_ROLE_SEARCH_BOX => Self::SearchBox,
1487 ffi::GTK_ACCESSIBLE_ROLE_SECTION => Self::Section,
1488 ffi::GTK_ACCESSIBLE_ROLE_SECTION_HEAD => Self::SectionHead,
1489 ffi::GTK_ACCESSIBLE_ROLE_SELECT => Self::Select,
1490 ffi::GTK_ACCESSIBLE_ROLE_SEPARATOR => Self::Separator,
1491 ffi::GTK_ACCESSIBLE_ROLE_SLIDER => Self::Slider,
1492 ffi::GTK_ACCESSIBLE_ROLE_SPIN_BUTTON => Self::SpinButton,
1493 ffi::GTK_ACCESSIBLE_ROLE_STATUS => Self::Status,
1494 ffi::GTK_ACCESSIBLE_ROLE_STRUCTURE => Self::Structure,
1495 ffi::GTK_ACCESSIBLE_ROLE_SWITCH => Self::Switch,
1496 ffi::GTK_ACCESSIBLE_ROLE_TAB => Self::Tab,
1497 ffi::GTK_ACCESSIBLE_ROLE_TABLE => Self::Table,
1498 ffi::GTK_ACCESSIBLE_ROLE_TAB_LIST => Self::TabList,
1499 ffi::GTK_ACCESSIBLE_ROLE_TAB_PANEL => Self::TabPanel,
1500 ffi::GTK_ACCESSIBLE_ROLE_TEXT_BOX => Self::TextBox,
1501 ffi::GTK_ACCESSIBLE_ROLE_TIME => Self::Time,
1502 ffi::GTK_ACCESSIBLE_ROLE_TIMER => Self::Timer,
1503 ffi::GTK_ACCESSIBLE_ROLE_TOOLBAR => Self::Toolbar,
1504 ffi::GTK_ACCESSIBLE_ROLE_TOOLTIP => Self::Tooltip,
1505 ffi::GTK_ACCESSIBLE_ROLE_TREE => Self::Tree,
1506 ffi::GTK_ACCESSIBLE_ROLE_TREE_GRID => Self::TreeGrid,
1507 ffi::GTK_ACCESSIBLE_ROLE_TREE_ITEM => Self::TreeItem,
1508 ffi::GTK_ACCESSIBLE_ROLE_WIDGET => Self::Widget,
1509 ffi::GTK_ACCESSIBLE_ROLE_WINDOW => Self::Window,
1510 #[cfg(feature = "v4_10")]
1511 ffi::GTK_ACCESSIBLE_ROLE_TOGGLE_BUTTON => Self::ToggleButton,
1512 #[cfg(feature = "v4_12")]
1513 ffi::GTK_ACCESSIBLE_ROLE_APPLICATION => Self::Application,
1514 #[cfg(feature = "v4_14")]
1515 ffi::GTK_ACCESSIBLE_ROLE_PARAGRAPH => Self::Paragraph,
1516 #[cfg(feature = "v4_14")]
1517 ffi::GTK_ACCESSIBLE_ROLE_BLOCK_QUOTE => Self::BlockQuote,
1518 #[cfg(feature = "v4_14")]
1519 ffi::GTK_ACCESSIBLE_ROLE_ARTICLE => Self::Article,
1520 #[cfg(feature = "v4_14")]
1521 ffi::GTK_ACCESSIBLE_ROLE_COMMENT => Self::Comment,
1522 #[cfg(feature = "v4_14")]
1523 ffi::GTK_ACCESSIBLE_ROLE_TERMINAL => Self::Terminal,
1524 value => Self::__Unknown(value),
1525 }
1526 }
1527}
1528
1529impl StaticType for AccessibleRole {
1530 #[inline]
1531 #[doc(alias = "gtk_accessible_role_get_type")]
1532 fn static_type() -> glib::Type {
1533 unsafe { from_glib(ffi::gtk_accessible_role_get_type()) }
1534 }
1535}
1536
1537impl glib::HasParamSpec for AccessibleRole {
1538 type ParamSpec = glib::ParamSpecEnum;
1539 type SetValue = Self;
1540 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1541
1542 fn param_spec_builder() -> Self::BuilderFn {
1543 Self::ParamSpec::builder_with_default
1544 }
1545}
1546
1547impl glib::value::ValueType for AccessibleRole {
1548 type Type = Self;
1549}
1550
1551unsafe impl<'a> glib::value::FromValue<'a> for AccessibleRole {
1552 type Checker = glib::value::GenericValueTypeChecker<Self>;
1553
1554 #[inline]
1555 unsafe fn from_value(value: &'a glib::Value) -> Self {
1556 skip_assert_initialized!();
1557 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1558 }
1559}
1560
1561impl ToValue for AccessibleRole {
1562 #[inline]
1563 fn to_value(&self) -> glib::Value {
1564 let mut value = glib::Value::for_value_type::<Self>();
1565 unsafe {
1566 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1567 }
1568 value
1569 }
1570
1571 #[inline]
1572 fn value_type(&self) -> glib::Type {
1573 Self::static_type()
1574 }
1575}
1576
1577impl From<AccessibleRole> for glib::Value {
1578 #[inline]
1579 fn from(v: AccessibleRole) -> Self {
1580 skip_assert_initialized!();
1581 ToValue::to_value(&v)
1582 }
1583}
1584
1585#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1588#[non_exhaustive]
1589#[doc(alias = "GtkAccessibleSort")]
1590pub enum AccessibleSort {
1591 #[doc(alias = "GTK_ACCESSIBLE_SORT_NONE")]
1593 None,
1594 #[doc(alias = "GTK_ACCESSIBLE_SORT_ASCENDING")]
1596 Ascending,
1597 #[doc(alias = "GTK_ACCESSIBLE_SORT_DESCENDING")]
1599 Descending,
1600 #[doc(alias = "GTK_ACCESSIBLE_SORT_OTHER")]
1603 Other,
1604 #[doc(hidden)]
1605 __Unknown(i32),
1606}
1607
1608#[doc(hidden)]
1609impl IntoGlib for AccessibleSort {
1610 type GlibType = ffi::GtkAccessibleSort;
1611
1612 #[inline]
1613 fn into_glib(self) -> ffi::GtkAccessibleSort {
1614 match self {
1615 Self::None => ffi::GTK_ACCESSIBLE_SORT_NONE,
1616 Self::Ascending => ffi::GTK_ACCESSIBLE_SORT_ASCENDING,
1617 Self::Descending => ffi::GTK_ACCESSIBLE_SORT_DESCENDING,
1618 Self::Other => ffi::GTK_ACCESSIBLE_SORT_OTHER,
1619 Self::__Unknown(value) => value,
1620 }
1621 }
1622}
1623
1624#[doc(hidden)]
1625impl FromGlib<ffi::GtkAccessibleSort> for AccessibleSort {
1626 #[inline]
1627 unsafe fn from_glib(value: ffi::GtkAccessibleSort) -> Self {
1628 skip_assert_initialized!();
1629
1630 match value {
1631 ffi::GTK_ACCESSIBLE_SORT_NONE => Self::None,
1632 ffi::GTK_ACCESSIBLE_SORT_ASCENDING => Self::Ascending,
1633 ffi::GTK_ACCESSIBLE_SORT_DESCENDING => Self::Descending,
1634 ffi::GTK_ACCESSIBLE_SORT_OTHER => Self::Other,
1635 value => Self::__Unknown(value),
1636 }
1637 }
1638}
1639
1640impl StaticType for AccessibleSort {
1641 #[inline]
1642 #[doc(alias = "gtk_accessible_sort_get_type")]
1643 fn static_type() -> glib::Type {
1644 unsafe { from_glib(ffi::gtk_accessible_sort_get_type()) }
1645 }
1646}
1647
1648impl glib::HasParamSpec for AccessibleSort {
1649 type ParamSpec = glib::ParamSpecEnum;
1650 type SetValue = Self;
1651 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1652
1653 fn param_spec_builder() -> Self::BuilderFn {
1654 Self::ParamSpec::builder_with_default
1655 }
1656}
1657
1658impl glib::value::ValueType for AccessibleSort {
1659 type Type = Self;
1660}
1661
1662unsafe impl<'a> glib::value::FromValue<'a> for AccessibleSort {
1663 type Checker = glib::value::GenericValueTypeChecker<Self>;
1664
1665 #[inline]
1666 unsafe fn from_value(value: &'a glib::Value) -> Self {
1667 skip_assert_initialized!();
1668 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1669 }
1670}
1671
1672impl ToValue for AccessibleSort {
1673 #[inline]
1674 fn to_value(&self) -> glib::Value {
1675 let mut value = glib::Value::for_value_type::<Self>();
1676 unsafe {
1677 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1678 }
1679 value
1680 }
1681
1682 #[inline]
1683 fn value_type(&self) -> glib::Type {
1684 Self::static_type()
1685 }
1686}
1687
1688impl From<AccessibleSort> for glib::Value {
1689 #[inline]
1690 fn from(v: AccessibleSort) -> Self {
1691 skip_assert_initialized!();
1692 ToValue::to_value(&v)
1693 }
1694}
1695
1696#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1698#[non_exhaustive]
1699#[doc(alias = "GtkAccessibleState")]
1700pub enum AccessibleState {
1701 #[doc(alias = "GTK_ACCESSIBLE_STATE_BUSY")]
1703 Busy,
1704 #[doc(alias = "GTK_ACCESSIBLE_STATE_CHECKED")]
1707 Checked,
1708 #[doc(alias = "GTK_ACCESSIBLE_STATE_DISABLED")]
1712 Disabled,
1713 #[doc(alias = "GTK_ACCESSIBLE_STATE_EXPANDED")]
1717 Expanded,
1718 #[doc(alias = "GTK_ACCESSIBLE_STATE_HIDDEN")]
1724 Hidden,
1725 #[doc(alias = "GTK_ACCESSIBLE_STATE_INVALID")]
1728 Invalid,
1729 #[doc(alias = "GTK_ACCESSIBLE_STATE_PRESSED")]
1733 Pressed,
1734 #[doc(alias = "GTK_ACCESSIBLE_STATE_SELECTED")]
1737 Selected,
1738 #[cfg(feature = "v4_12")]
1741 #[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
1742 #[doc(alias = "GTK_ACCESSIBLE_STATE_VISITED")]
1743 Visited,
1744 #[doc(hidden)]
1745 __Unknown(i32),
1746}
1747
1748impl AccessibleState {
1749 #[doc(alias = "gtk_accessible_state_init_value")]
1750 pub fn init_value(self, value: &mut glib::Value) {
1751 assert_initialized_main_thread!();
1752 unsafe {
1753 ffi::gtk_accessible_state_init_value(self.into_glib(), value.to_glib_none_mut().0);
1754 }
1755 }
1756}
1757
1758#[doc(hidden)]
1759impl IntoGlib for AccessibleState {
1760 type GlibType = ffi::GtkAccessibleState;
1761
1762 #[inline]
1763 fn into_glib(self) -> ffi::GtkAccessibleState {
1764 match self {
1765 Self::Busy => ffi::GTK_ACCESSIBLE_STATE_BUSY,
1766 Self::Checked => ffi::GTK_ACCESSIBLE_STATE_CHECKED,
1767 Self::Disabled => ffi::GTK_ACCESSIBLE_STATE_DISABLED,
1768 Self::Expanded => ffi::GTK_ACCESSIBLE_STATE_EXPANDED,
1769 Self::Hidden => ffi::GTK_ACCESSIBLE_STATE_HIDDEN,
1770 Self::Invalid => ffi::GTK_ACCESSIBLE_STATE_INVALID,
1771 Self::Pressed => ffi::GTK_ACCESSIBLE_STATE_PRESSED,
1772 Self::Selected => ffi::GTK_ACCESSIBLE_STATE_SELECTED,
1773 #[cfg(feature = "v4_12")]
1774 Self::Visited => ffi::GTK_ACCESSIBLE_STATE_VISITED,
1775 Self::__Unknown(value) => value,
1776 }
1777 }
1778}
1779
1780#[doc(hidden)]
1781impl FromGlib<ffi::GtkAccessibleState> for AccessibleState {
1782 #[inline]
1783 unsafe fn from_glib(value: ffi::GtkAccessibleState) -> Self {
1784 skip_assert_initialized!();
1785
1786 match value {
1787 ffi::GTK_ACCESSIBLE_STATE_BUSY => Self::Busy,
1788 ffi::GTK_ACCESSIBLE_STATE_CHECKED => Self::Checked,
1789 ffi::GTK_ACCESSIBLE_STATE_DISABLED => Self::Disabled,
1790 ffi::GTK_ACCESSIBLE_STATE_EXPANDED => Self::Expanded,
1791 ffi::GTK_ACCESSIBLE_STATE_HIDDEN => Self::Hidden,
1792 ffi::GTK_ACCESSIBLE_STATE_INVALID => Self::Invalid,
1793 ffi::GTK_ACCESSIBLE_STATE_PRESSED => Self::Pressed,
1794 ffi::GTK_ACCESSIBLE_STATE_SELECTED => Self::Selected,
1795 #[cfg(feature = "v4_12")]
1796 ffi::GTK_ACCESSIBLE_STATE_VISITED => Self::Visited,
1797 value => Self::__Unknown(value),
1798 }
1799 }
1800}
1801
1802impl StaticType for AccessibleState {
1803 #[inline]
1804 #[doc(alias = "gtk_accessible_state_get_type")]
1805 fn static_type() -> glib::Type {
1806 unsafe { from_glib(ffi::gtk_accessible_state_get_type()) }
1807 }
1808}
1809
1810impl glib::HasParamSpec for AccessibleState {
1811 type ParamSpec = glib::ParamSpecEnum;
1812 type SetValue = Self;
1813 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1814
1815 fn param_spec_builder() -> Self::BuilderFn {
1816 Self::ParamSpec::builder_with_default
1817 }
1818}
1819
1820impl glib::value::ValueType for AccessibleState {
1821 type Type = Self;
1822}
1823
1824unsafe impl<'a> glib::value::FromValue<'a> for AccessibleState {
1825 type Checker = glib::value::GenericValueTypeChecker<Self>;
1826
1827 #[inline]
1828 unsafe fn from_value(value: &'a glib::Value) -> Self {
1829 skip_assert_initialized!();
1830 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1831 }
1832}
1833
1834impl ToValue for AccessibleState {
1835 #[inline]
1836 fn to_value(&self) -> glib::Value {
1837 let mut value = glib::Value::for_value_type::<Self>();
1838 unsafe {
1839 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1840 }
1841 value
1842 }
1843
1844 #[inline]
1845 fn value_type(&self) -> glib::Type {
1846 Self::static_type()
1847 }
1848}
1849
1850impl From<AccessibleState> for glib::Value {
1851 #[inline]
1852 fn from(v: AccessibleState) -> Self {
1853 skip_assert_initialized!();
1854 ToValue::to_value(&v)
1855 }
1856}
1857
1858#[cfg(feature = "v4_14")]
1860#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1861#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1862#[non_exhaustive]
1863#[doc(alias = "GtkAccessibleTextContentChange")]
1864pub enum AccessibleTextContentChange {
1865 #[doc(alias = "GTK_ACCESSIBLE_TEXT_CONTENT_CHANGE_INSERT")]
1868 Insert,
1869 #[doc(alias = "GTK_ACCESSIBLE_TEXT_CONTENT_CHANGE_REMOVE")]
1872 Remove,
1873 #[doc(hidden)]
1874 __Unknown(i32),
1875}
1876
1877#[cfg(feature = "v4_14")]
1878#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1879#[doc(hidden)]
1880impl IntoGlib for AccessibleTextContentChange {
1881 type GlibType = ffi::GtkAccessibleTextContentChange;
1882
1883 #[inline]
1884 fn into_glib(self) -> ffi::GtkAccessibleTextContentChange {
1885 match self {
1886 Self::Insert => ffi::GTK_ACCESSIBLE_TEXT_CONTENT_CHANGE_INSERT,
1887 Self::Remove => ffi::GTK_ACCESSIBLE_TEXT_CONTENT_CHANGE_REMOVE,
1888 Self::__Unknown(value) => value,
1889 }
1890 }
1891}
1892
1893#[cfg(feature = "v4_14")]
1894#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1895#[doc(hidden)]
1896impl FromGlib<ffi::GtkAccessibleTextContentChange> for AccessibleTextContentChange {
1897 #[inline]
1898 unsafe fn from_glib(value: ffi::GtkAccessibleTextContentChange) -> Self {
1899 skip_assert_initialized!();
1900
1901 match value {
1902 ffi::GTK_ACCESSIBLE_TEXT_CONTENT_CHANGE_INSERT => Self::Insert,
1903 ffi::GTK_ACCESSIBLE_TEXT_CONTENT_CHANGE_REMOVE => Self::Remove,
1904 value => Self::__Unknown(value),
1905 }
1906 }
1907}
1908
1909#[cfg(feature = "v4_14")]
1910#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1911impl StaticType for AccessibleTextContentChange {
1912 #[inline]
1913 #[doc(alias = "gtk_accessible_text_content_change_get_type")]
1914 fn static_type() -> glib::Type {
1915 unsafe { from_glib(ffi::gtk_accessible_text_content_change_get_type()) }
1916 }
1917}
1918
1919#[cfg(feature = "v4_14")]
1920#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1921impl glib::HasParamSpec for AccessibleTextContentChange {
1922 type ParamSpec = glib::ParamSpecEnum;
1923 type SetValue = Self;
1924 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1925
1926 fn param_spec_builder() -> Self::BuilderFn {
1927 Self::ParamSpec::builder_with_default
1928 }
1929}
1930
1931#[cfg(feature = "v4_14")]
1932#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1933impl glib::value::ValueType for AccessibleTextContentChange {
1934 type Type = Self;
1935}
1936
1937#[cfg(feature = "v4_14")]
1938#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1939unsafe impl<'a> glib::value::FromValue<'a> for AccessibleTextContentChange {
1940 type Checker = glib::value::GenericValueTypeChecker<Self>;
1941
1942 #[inline]
1943 unsafe fn from_value(value: &'a glib::Value) -> Self {
1944 skip_assert_initialized!();
1945 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1946 }
1947}
1948
1949#[cfg(feature = "v4_14")]
1950#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1951impl ToValue for AccessibleTextContentChange {
1952 #[inline]
1953 fn to_value(&self) -> glib::Value {
1954 let mut value = glib::Value::for_value_type::<Self>();
1955 unsafe {
1956 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1957 }
1958 value
1959 }
1960
1961 #[inline]
1962 fn value_type(&self) -> glib::Type {
1963 Self::static_type()
1964 }
1965}
1966
1967#[cfg(feature = "v4_14")]
1968#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1969impl From<AccessibleTextContentChange> for glib::Value {
1970 #[inline]
1971 fn from(v: AccessibleTextContentChange) -> Self {
1972 skip_assert_initialized!();
1973 ToValue::to_value(&v)
1974 }
1975}
1976
1977#[cfg(feature = "v4_14")]
1980#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1981#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1982#[non_exhaustive]
1983#[doc(alias = "GtkAccessibleTextGranularity")]
1984pub enum AccessibleTextGranularity {
1985 #[doc(alias = "GTK_ACCESSIBLE_TEXT_GRANULARITY_CHARACTER")]
1988 Character,
1989 #[doc(alias = "GTK_ACCESSIBLE_TEXT_GRANULARITY_WORD")]
1993 Word,
1994 #[doc(alias = "GTK_ACCESSIBLE_TEXT_GRANULARITY_SENTENCE")]
1998 Sentence,
1999 #[doc(alias = "GTK_ACCESSIBLE_TEXT_GRANULARITY_LINE")]
2003 Line,
2004 #[doc(alias = "GTK_ACCESSIBLE_TEXT_GRANULARITY_PARAGRAPH")]
2008 Paragraph,
2009 #[doc(hidden)]
2010 __Unknown(i32),
2011}
2012
2013#[cfg(feature = "v4_14")]
2014#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2015#[doc(hidden)]
2016impl IntoGlib for AccessibleTextGranularity {
2017 type GlibType = ffi::GtkAccessibleTextGranularity;
2018
2019 #[inline]
2020 fn into_glib(self) -> ffi::GtkAccessibleTextGranularity {
2021 match self {
2022 Self::Character => ffi::GTK_ACCESSIBLE_TEXT_GRANULARITY_CHARACTER,
2023 Self::Word => ffi::GTK_ACCESSIBLE_TEXT_GRANULARITY_WORD,
2024 Self::Sentence => ffi::GTK_ACCESSIBLE_TEXT_GRANULARITY_SENTENCE,
2025 Self::Line => ffi::GTK_ACCESSIBLE_TEXT_GRANULARITY_LINE,
2026 Self::Paragraph => ffi::GTK_ACCESSIBLE_TEXT_GRANULARITY_PARAGRAPH,
2027 Self::__Unknown(value) => value,
2028 }
2029 }
2030}
2031
2032#[cfg(feature = "v4_14")]
2033#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2034#[doc(hidden)]
2035impl FromGlib<ffi::GtkAccessibleTextGranularity> for AccessibleTextGranularity {
2036 #[inline]
2037 unsafe fn from_glib(value: ffi::GtkAccessibleTextGranularity) -> Self {
2038 skip_assert_initialized!();
2039
2040 match value {
2041 ffi::GTK_ACCESSIBLE_TEXT_GRANULARITY_CHARACTER => Self::Character,
2042 ffi::GTK_ACCESSIBLE_TEXT_GRANULARITY_WORD => Self::Word,
2043 ffi::GTK_ACCESSIBLE_TEXT_GRANULARITY_SENTENCE => Self::Sentence,
2044 ffi::GTK_ACCESSIBLE_TEXT_GRANULARITY_LINE => Self::Line,
2045 ffi::GTK_ACCESSIBLE_TEXT_GRANULARITY_PARAGRAPH => Self::Paragraph,
2046 value => Self::__Unknown(value),
2047 }
2048 }
2049}
2050
2051#[cfg(feature = "v4_14")]
2052#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2053impl StaticType for AccessibleTextGranularity {
2054 #[inline]
2055 #[doc(alias = "gtk_accessible_text_granularity_get_type")]
2056 fn static_type() -> glib::Type {
2057 unsafe { from_glib(ffi::gtk_accessible_text_granularity_get_type()) }
2058 }
2059}
2060
2061#[cfg(feature = "v4_14")]
2062#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2063impl glib::HasParamSpec for AccessibleTextGranularity {
2064 type ParamSpec = glib::ParamSpecEnum;
2065 type SetValue = Self;
2066 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2067
2068 fn param_spec_builder() -> Self::BuilderFn {
2069 Self::ParamSpec::builder_with_default
2070 }
2071}
2072
2073#[cfg(feature = "v4_14")]
2074#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2075impl glib::value::ValueType for AccessibleTextGranularity {
2076 type Type = Self;
2077}
2078
2079#[cfg(feature = "v4_14")]
2080#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2081unsafe impl<'a> glib::value::FromValue<'a> for AccessibleTextGranularity {
2082 type Checker = glib::value::GenericValueTypeChecker<Self>;
2083
2084 #[inline]
2085 unsafe fn from_value(value: &'a glib::Value) -> Self {
2086 skip_assert_initialized!();
2087 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2088 }
2089}
2090
2091#[cfg(feature = "v4_14")]
2092#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2093impl ToValue for AccessibleTextGranularity {
2094 #[inline]
2095 fn to_value(&self) -> glib::Value {
2096 let mut value = glib::Value::for_value_type::<Self>();
2097 unsafe {
2098 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2099 }
2100 value
2101 }
2102
2103 #[inline]
2104 fn value_type(&self) -> glib::Type {
2105 Self::static_type()
2106 }
2107}
2108
2109#[cfg(feature = "v4_14")]
2110#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2111impl From<AccessibleTextGranularity> for glib::Value {
2112 #[inline]
2113 fn from(v: AccessibleTextGranularity) -> Self {
2114 skip_assert_initialized!();
2115 ToValue::to_value(&v)
2116 }
2117}
2118
2119#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2126#[non_exhaustive]
2127#[doc(alias = "GtkAccessibleTristate")]
2128pub enum AccessibleTristate {
2129 #[doc(alias = "GTK_ACCESSIBLE_TRISTATE_FALSE")]
2131 False,
2132 #[doc(alias = "GTK_ACCESSIBLE_TRISTATE_TRUE")]
2134 True,
2135 #[doc(alias = "GTK_ACCESSIBLE_TRISTATE_MIXED")]
2137 Mixed,
2138 #[doc(hidden)]
2139 __Unknown(i32),
2140}
2141
2142#[doc(hidden)]
2143impl IntoGlib for AccessibleTristate {
2144 type GlibType = ffi::GtkAccessibleTristate;
2145
2146 #[inline]
2147 fn into_glib(self) -> ffi::GtkAccessibleTristate {
2148 match self {
2149 Self::False => ffi::GTK_ACCESSIBLE_TRISTATE_FALSE,
2150 Self::True => ffi::GTK_ACCESSIBLE_TRISTATE_TRUE,
2151 Self::Mixed => ffi::GTK_ACCESSIBLE_TRISTATE_MIXED,
2152 Self::__Unknown(value) => value,
2153 }
2154 }
2155}
2156
2157#[doc(hidden)]
2158impl FromGlib<ffi::GtkAccessibleTristate> for AccessibleTristate {
2159 #[inline]
2160 unsafe fn from_glib(value: ffi::GtkAccessibleTristate) -> Self {
2161 skip_assert_initialized!();
2162
2163 match value {
2164 ffi::GTK_ACCESSIBLE_TRISTATE_FALSE => Self::False,
2165 ffi::GTK_ACCESSIBLE_TRISTATE_TRUE => Self::True,
2166 ffi::GTK_ACCESSIBLE_TRISTATE_MIXED => Self::Mixed,
2167 value => Self::__Unknown(value),
2168 }
2169 }
2170}
2171
2172impl StaticType for AccessibleTristate {
2173 #[inline]
2174 #[doc(alias = "gtk_accessible_tristate_get_type")]
2175 fn static_type() -> glib::Type {
2176 unsafe { from_glib(ffi::gtk_accessible_tristate_get_type()) }
2177 }
2178}
2179
2180impl glib::HasParamSpec for AccessibleTristate {
2181 type ParamSpec = glib::ParamSpecEnum;
2182 type SetValue = Self;
2183 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2184
2185 fn param_spec_builder() -> Self::BuilderFn {
2186 Self::ParamSpec::builder_with_default
2187 }
2188}
2189
2190impl glib::value::ValueType for AccessibleTristate {
2191 type Type = Self;
2192}
2193
2194unsafe impl<'a> glib::value::FromValue<'a> for AccessibleTristate {
2195 type Checker = glib::value::GenericValueTypeChecker<Self>;
2196
2197 #[inline]
2198 unsafe fn from_value(value: &'a glib::Value) -> Self {
2199 skip_assert_initialized!();
2200 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2201 }
2202}
2203
2204impl ToValue for AccessibleTristate {
2205 #[inline]
2206 fn to_value(&self) -> glib::Value {
2207 let mut value = glib::Value::for_value_type::<Self>();
2208 unsafe {
2209 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2210 }
2211 value
2212 }
2213
2214 #[inline]
2215 fn value_type(&self) -> glib::Type {
2216 Self::static_type()
2217 }
2218}
2219
2220impl From<AccessibleTristate> for glib::Value {
2221 #[inline]
2222 fn from(v: AccessibleTristate) -> Self {
2223 skip_assert_initialized!();
2224 ToValue::to_value(&v)
2225 }
2226}
2227
2228#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2230#[non_exhaustive]
2231#[doc(alias = "GtkArrowType")]
2232pub enum ArrowType {
2233 #[doc(alias = "GTK_ARROW_UP")]
2235 Up,
2236 #[doc(alias = "GTK_ARROW_DOWN")]
2238 Down,
2239 #[doc(alias = "GTK_ARROW_LEFT")]
2241 Left,
2242 #[doc(alias = "GTK_ARROW_RIGHT")]
2244 Right,
2245 #[doc(alias = "GTK_ARROW_NONE")]
2247 None,
2248 #[doc(hidden)]
2249 __Unknown(i32),
2250}
2251
2252#[doc(hidden)]
2253impl IntoGlib for ArrowType {
2254 type GlibType = ffi::GtkArrowType;
2255
2256 #[inline]
2257 fn into_glib(self) -> ffi::GtkArrowType {
2258 match self {
2259 Self::Up => ffi::GTK_ARROW_UP,
2260 Self::Down => ffi::GTK_ARROW_DOWN,
2261 Self::Left => ffi::GTK_ARROW_LEFT,
2262 Self::Right => ffi::GTK_ARROW_RIGHT,
2263 Self::None => ffi::GTK_ARROW_NONE,
2264 Self::__Unknown(value) => value,
2265 }
2266 }
2267}
2268
2269#[doc(hidden)]
2270impl FromGlib<ffi::GtkArrowType> for ArrowType {
2271 #[inline]
2272 unsafe fn from_glib(value: ffi::GtkArrowType) -> Self {
2273 skip_assert_initialized!();
2274
2275 match value {
2276 ffi::GTK_ARROW_UP => Self::Up,
2277 ffi::GTK_ARROW_DOWN => Self::Down,
2278 ffi::GTK_ARROW_LEFT => Self::Left,
2279 ffi::GTK_ARROW_RIGHT => Self::Right,
2280 ffi::GTK_ARROW_NONE => Self::None,
2281 value => Self::__Unknown(value),
2282 }
2283 }
2284}
2285
2286impl StaticType for ArrowType {
2287 #[inline]
2288 #[doc(alias = "gtk_arrow_type_get_type")]
2289 fn static_type() -> glib::Type {
2290 unsafe { from_glib(ffi::gtk_arrow_type_get_type()) }
2291 }
2292}
2293
2294impl glib::HasParamSpec for ArrowType {
2295 type ParamSpec = glib::ParamSpecEnum;
2296 type SetValue = Self;
2297 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2298
2299 fn param_spec_builder() -> Self::BuilderFn {
2300 Self::ParamSpec::builder_with_default
2301 }
2302}
2303
2304impl glib::value::ValueType for ArrowType {
2305 type Type = Self;
2306}
2307
2308unsafe impl<'a> glib::value::FromValue<'a> for ArrowType {
2309 type Checker = glib::value::GenericValueTypeChecker<Self>;
2310
2311 #[inline]
2312 unsafe fn from_value(value: &'a glib::Value) -> Self {
2313 skip_assert_initialized!();
2314 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2315 }
2316}
2317
2318impl ToValue for ArrowType {
2319 #[inline]
2320 fn to_value(&self) -> glib::Value {
2321 let mut value = glib::Value::for_value_type::<Self>();
2322 unsafe {
2323 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2324 }
2325 value
2326 }
2327
2328 #[inline]
2329 fn value_type(&self) -> glib::Type {
2330 Self::static_type()
2331 }
2332}
2333
2334impl From<ArrowType> for glib::Value {
2335 #[inline]
2336 fn from(v: ArrowType) -> Self {
2337 skip_assert_initialized!();
2338 ToValue::to_value(&v)
2339 }
2340}
2341
2342#[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
2357#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2358#[non_exhaustive]
2359#[doc(alias = "GtkAssistantPageType")]
2360pub enum AssistantPageType {
2361 #[doc(alias = "GTK_ASSISTANT_PAGE_CONTENT")]
2364 Content,
2365 #[doc(alias = "GTK_ASSISTANT_PAGE_INTRO")]
2369 Intro,
2370 #[doc(alias = "GTK_ASSISTANT_PAGE_CONFIRM")]
2373 Confirm,
2374 #[doc(alias = "GTK_ASSISTANT_PAGE_SUMMARY")]
2377 Summary,
2378 #[doc(alias = "GTK_ASSISTANT_PAGE_PROGRESS")]
2382 Progress,
2383 #[doc(alias = "GTK_ASSISTANT_PAGE_CUSTOM")]
2387 Custom,
2388 #[doc(hidden)]
2389 __Unknown(i32),
2390}
2391
2392#[allow(deprecated)]
2393#[doc(hidden)]
2394impl IntoGlib for AssistantPageType {
2395 type GlibType = ffi::GtkAssistantPageType;
2396
2397 #[inline]
2398 fn into_glib(self) -> ffi::GtkAssistantPageType {
2399 match self {
2400 Self::Content => ffi::GTK_ASSISTANT_PAGE_CONTENT,
2401 Self::Intro => ffi::GTK_ASSISTANT_PAGE_INTRO,
2402 Self::Confirm => ffi::GTK_ASSISTANT_PAGE_CONFIRM,
2403 Self::Summary => ffi::GTK_ASSISTANT_PAGE_SUMMARY,
2404 Self::Progress => ffi::GTK_ASSISTANT_PAGE_PROGRESS,
2405 Self::Custom => ffi::GTK_ASSISTANT_PAGE_CUSTOM,
2406 Self::__Unknown(value) => value,
2407 }
2408 }
2409}
2410
2411#[allow(deprecated)]
2412#[doc(hidden)]
2413impl FromGlib<ffi::GtkAssistantPageType> for AssistantPageType {
2414 #[inline]
2415 unsafe fn from_glib(value: ffi::GtkAssistantPageType) -> Self {
2416 skip_assert_initialized!();
2417
2418 match value {
2419 ffi::GTK_ASSISTANT_PAGE_CONTENT => Self::Content,
2420 ffi::GTK_ASSISTANT_PAGE_INTRO => Self::Intro,
2421 ffi::GTK_ASSISTANT_PAGE_CONFIRM => Self::Confirm,
2422 ffi::GTK_ASSISTANT_PAGE_SUMMARY => Self::Summary,
2423 ffi::GTK_ASSISTANT_PAGE_PROGRESS => Self::Progress,
2424 ffi::GTK_ASSISTANT_PAGE_CUSTOM => Self::Custom,
2425 value => Self::__Unknown(value),
2426 }
2427 }
2428}
2429
2430#[allow(deprecated)]
2431impl StaticType for AssistantPageType {
2432 #[inline]
2433 #[doc(alias = "gtk_assistant_page_type_get_type")]
2434 fn static_type() -> glib::Type {
2435 unsafe { from_glib(ffi::gtk_assistant_page_type_get_type()) }
2436 }
2437}
2438
2439#[allow(deprecated)]
2440impl glib::HasParamSpec for AssistantPageType {
2441 type ParamSpec = glib::ParamSpecEnum;
2442 type SetValue = Self;
2443 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2444
2445 fn param_spec_builder() -> Self::BuilderFn {
2446 Self::ParamSpec::builder_with_default
2447 }
2448}
2449
2450#[allow(deprecated)]
2451impl glib::value::ValueType for AssistantPageType {
2452 type Type = Self;
2453}
2454
2455#[allow(deprecated)]
2456unsafe impl<'a> glib::value::FromValue<'a> for AssistantPageType {
2457 type Checker = glib::value::GenericValueTypeChecker<Self>;
2458
2459 #[inline]
2460 unsafe fn from_value(value: &'a glib::Value) -> Self {
2461 skip_assert_initialized!();
2462 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2463 }
2464}
2465
2466#[allow(deprecated)]
2467impl ToValue for AssistantPageType {
2468 #[inline]
2469 fn to_value(&self) -> glib::Value {
2470 let mut value = glib::Value::for_value_type::<Self>();
2471 unsafe {
2472 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2473 }
2474 value
2475 }
2476
2477 #[inline]
2478 fn value_type(&self) -> glib::Type {
2479 Self::static_type()
2480 }
2481}
2482
2483#[allow(deprecated)]
2484impl From<AssistantPageType> for glib::Value {
2485 #[inline]
2486 fn from(v: AssistantPageType) -> Self {
2487 skip_assert_initialized!();
2488 ToValue::to_value(&v)
2489 }
2490}
2491
2492#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2501#[non_exhaustive]
2502#[doc(alias = "GtkBaselinePosition")]
2503pub enum BaselinePosition {
2504 #[doc(alias = "GTK_BASELINE_POSITION_TOP")]
2506 Top,
2507 #[doc(alias = "GTK_BASELINE_POSITION_CENTER")]
2509 Center,
2510 #[doc(alias = "GTK_BASELINE_POSITION_BOTTOM")]
2512 Bottom,
2513 #[doc(hidden)]
2514 __Unknown(i32),
2515}
2516
2517#[doc(hidden)]
2518impl IntoGlib for BaselinePosition {
2519 type GlibType = ffi::GtkBaselinePosition;
2520
2521 #[inline]
2522 fn into_glib(self) -> ffi::GtkBaselinePosition {
2523 match self {
2524 Self::Top => ffi::GTK_BASELINE_POSITION_TOP,
2525 Self::Center => ffi::GTK_BASELINE_POSITION_CENTER,
2526 Self::Bottom => ffi::GTK_BASELINE_POSITION_BOTTOM,
2527 Self::__Unknown(value) => value,
2528 }
2529 }
2530}
2531
2532#[doc(hidden)]
2533impl FromGlib<ffi::GtkBaselinePosition> for BaselinePosition {
2534 #[inline]
2535 unsafe fn from_glib(value: ffi::GtkBaselinePosition) -> Self {
2536 skip_assert_initialized!();
2537
2538 match value {
2539 ffi::GTK_BASELINE_POSITION_TOP => Self::Top,
2540 ffi::GTK_BASELINE_POSITION_CENTER => Self::Center,
2541 ffi::GTK_BASELINE_POSITION_BOTTOM => Self::Bottom,
2542 value => Self::__Unknown(value),
2543 }
2544 }
2545}
2546
2547impl StaticType for BaselinePosition {
2548 #[inline]
2549 #[doc(alias = "gtk_baseline_position_get_type")]
2550 fn static_type() -> glib::Type {
2551 unsafe { from_glib(ffi::gtk_baseline_position_get_type()) }
2552 }
2553}
2554
2555impl glib::HasParamSpec for BaselinePosition {
2556 type ParamSpec = glib::ParamSpecEnum;
2557 type SetValue = Self;
2558 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2559
2560 fn param_spec_builder() -> Self::BuilderFn {
2561 Self::ParamSpec::builder_with_default
2562 }
2563}
2564
2565impl glib::value::ValueType for BaselinePosition {
2566 type Type = Self;
2567}
2568
2569unsafe impl<'a> glib::value::FromValue<'a> for BaselinePosition {
2570 type Checker = glib::value::GenericValueTypeChecker<Self>;
2571
2572 #[inline]
2573 unsafe fn from_value(value: &'a glib::Value) -> Self {
2574 skip_assert_initialized!();
2575 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2576 }
2577}
2578
2579impl ToValue for BaselinePosition {
2580 #[inline]
2581 fn to_value(&self) -> glib::Value {
2582 let mut value = glib::Value::for_value_type::<Self>();
2583 unsafe {
2584 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2585 }
2586 value
2587 }
2588
2589 #[inline]
2590 fn value_type(&self) -> glib::Type {
2591 Self::static_type()
2592 }
2593}
2594
2595impl From<BaselinePosition> for glib::Value {
2596 #[inline]
2597 fn from(v: BaselinePosition) -> Self {
2598 skip_assert_initialized!();
2599 ToValue::to_value(&v)
2600 }
2601}
2602
2603#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2605#[non_exhaustive]
2606#[doc(alias = "GtkBorderStyle")]
2607pub enum BorderStyle {
2608 #[doc(alias = "GTK_BORDER_STYLE_NONE")]
2610 None,
2611 #[doc(alias = "GTK_BORDER_STYLE_HIDDEN")]
2613 Hidden,
2614 #[doc(alias = "GTK_BORDER_STYLE_SOLID")]
2616 Solid,
2617 #[doc(alias = "GTK_BORDER_STYLE_INSET")]
2619 Inset,
2620 #[doc(alias = "GTK_BORDER_STYLE_OUTSET")]
2622 Outset,
2623 #[doc(alias = "GTK_BORDER_STYLE_DOTTED")]
2625 Dotted,
2626 #[doc(alias = "GTK_BORDER_STYLE_DASHED")]
2628 Dashed,
2629 #[doc(alias = "GTK_BORDER_STYLE_DOUBLE")]
2631 Double,
2632 #[doc(alias = "GTK_BORDER_STYLE_GROOVE")]
2634 Groove,
2635 #[doc(alias = "GTK_BORDER_STYLE_RIDGE")]
2637 Ridge,
2638 #[doc(hidden)]
2639 __Unknown(i32),
2640}
2641
2642#[doc(hidden)]
2643impl IntoGlib for BorderStyle {
2644 type GlibType = ffi::GtkBorderStyle;
2645
2646 #[inline]
2647 fn into_glib(self) -> ffi::GtkBorderStyle {
2648 match self {
2649 Self::None => ffi::GTK_BORDER_STYLE_NONE,
2650 Self::Hidden => ffi::GTK_BORDER_STYLE_HIDDEN,
2651 Self::Solid => ffi::GTK_BORDER_STYLE_SOLID,
2652 Self::Inset => ffi::GTK_BORDER_STYLE_INSET,
2653 Self::Outset => ffi::GTK_BORDER_STYLE_OUTSET,
2654 Self::Dotted => ffi::GTK_BORDER_STYLE_DOTTED,
2655 Self::Dashed => ffi::GTK_BORDER_STYLE_DASHED,
2656 Self::Double => ffi::GTK_BORDER_STYLE_DOUBLE,
2657 Self::Groove => ffi::GTK_BORDER_STYLE_GROOVE,
2658 Self::Ridge => ffi::GTK_BORDER_STYLE_RIDGE,
2659 Self::__Unknown(value) => value,
2660 }
2661 }
2662}
2663
2664#[doc(hidden)]
2665impl FromGlib<ffi::GtkBorderStyle> for BorderStyle {
2666 #[inline]
2667 unsafe fn from_glib(value: ffi::GtkBorderStyle) -> Self {
2668 skip_assert_initialized!();
2669
2670 match value {
2671 ffi::GTK_BORDER_STYLE_NONE => Self::None,
2672 ffi::GTK_BORDER_STYLE_HIDDEN => Self::Hidden,
2673 ffi::GTK_BORDER_STYLE_SOLID => Self::Solid,
2674 ffi::GTK_BORDER_STYLE_INSET => Self::Inset,
2675 ffi::GTK_BORDER_STYLE_OUTSET => Self::Outset,
2676 ffi::GTK_BORDER_STYLE_DOTTED => Self::Dotted,
2677 ffi::GTK_BORDER_STYLE_DASHED => Self::Dashed,
2678 ffi::GTK_BORDER_STYLE_DOUBLE => Self::Double,
2679 ffi::GTK_BORDER_STYLE_GROOVE => Self::Groove,
2680 ffi::GTK_BORDER_STYLE_RIDGE => Self::Ridge,
2681 value => Self::__Unknown(value),
2682 }
2683 }
2684}
2685
2686impl StaticType for BorderStyle {
2687 #[inline]
2688 #[doc(alias = "gtk_border_style_get_type")]
2689 fn static_type() -> glib::Type {
2690 unsafe { from_glib(ffi::gtk_border_style_get_type()) }
2691 }
2692}
2693
2694impl glib::HasParamSpec for BorderStyle {
2695 type ParamSpec = glib::ParamSpecEnum;
2696 type SetValue = Self;
2697 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2698
2699 fn param_spec_builder() -> Self::BuilderFn {
2700 Self::ParamSpec::builder_with_default
2701 }
2702}
2703
2704impl glib::value::ValueType for BorderStyle {
2705 type Type = Self;
2706}
2707
2708unsafe impl<'a> glib::value::FromValue<'a> for BorderStyle {
2709 type Checker = glib::value::GenericValueTypeChecker<Self>;
2710
2711 #[inline]
2712 unsafe fn from_value(value: &'a glib::Value) -> Self {
2713 skip_assert_initialized!();
2714 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2715 }
2716}
2717
2718impl ToValue for BorderStyle {
2719 #[inline]
2720 fn to_value(&self) -> glib::Value {
2721 let mut value = glib::Value::for_value_type::<Self>();
2722 unsafe {
2723 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2724 }
2725 value
2726 }
2727
2728 #[inline]
2729 fn value_type(&self) -> glib::Type {
2730 Self::static_type()
2731 }
2732}
2733
2734impl From<BorderStyle> for glib::Value {
2735 #[inline]
2736 fn from(v: BorderStyle) -> Self {
2737 skip_assert_initialized!();
2738 ToValue::to_value(&v)
2739 }
2740}
2741
2742#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2745#[non_exhaustive]
2746#[doc(alias = "GtkBuilderError")]
2747pub enum BuilderError {
2748 #[doc(alias = "GTK_BUILDER_ERROR_INVALID_TYPE_FUNCTION")]
2751 InvalidTypeFunction,
2752 #[doc(alias = "GTK_BUILDER_ERROR_UNHANDLED_TAG")]
2755 UnhandledTag,
2756 #[doc(alias = "GTK_BUILDER_ERROR_MISSING_ATTRIBUTE")]
2759 MissingAttribute,
2760 #[doc(alias = "GTK_BUILDER_ERROR_INVALID_ATTRIBUTE")]
2763 InvalidAttribute,
2764 #[doc(alias = "GTK_BUILDER_ERROR_INVALID_TAG")]
2767 InvalidTag,
2768 #[doc(alias = "GTK_BUILDER_ERROR_MISSING_PROPERTY_VALUE")]
2771 MissingPropertyValue,
2772 #[doc(alias = "GTK_BUILDER_ERROR_INVALID_VALUE")]
2775 InvalidValue,
2776 #[doc(alias = "GTK_BUILDER_ERROR_VERSION_MISMATCH")]
2779 VersionMismatch,
2780 #[doc(alias = "GTK_BUILDER_ERROR_DUPLICATE_ID")]
2782 DuplicateId,
2783 #[doc(alias = "GTK_BUILDER_ERROR_OBJECT_TYPE_REFUSED")]
2786 ObjectTypeRefused,
2787 #[doc(alias = "GTK_BUILDER_ERROR_TEMPLATE_MISMATCH")]
2789 TemplateMismatch,
2790 #[doc(alias = "GTK_BUILDER_ERROR_INVALID_PROPERTY")]
2792 InvalidProperty,
2793 #[doc(alias = "GTK_BUILDER_ERROR_INVALID_SIGNAL")]
2795 InvalidSignal,
2796 #[doc(alias = "GTK_BUILDER_ERROR_INVALID_ID")]
2798 InvalidId,
2799 #[doc(alias = "GTK_BUILDER_ERROR_INVALID_FUNCTION")]
2803 InvalidFunction,
2804 #[doc(hidden)]
2805 __Unknown(i32),
2806}
2807
2808#[doc(hidden)]
2809impl IntoGlib for BuilderError {
2810 type GlibType = ffi::GtkBuilderError;
2811
2812 fn into_glib(self) -> ffi::GtkBuilderError {
2813 match self {
2814 Self::InvalidTypeFunction => ffi::GTK_BUILDER_ERROR_INVALID_TYPE_FUNCTION,
2815 Self::UnhandledTag => ffi::GTK_BUILDER_ERROR_UNHANDLED_TAG,
2816 Self::MissingAttribute => ffi::GTK_BUILDER_ERROR_MISSING_ATTRIBUTE,
2817 Self::InvalidAttribute => ffi::GTK_BUILDER_ERROR_INVALID_ATTRIBUTE,
2818 Self::InvalidTag => ffi::GTK_BUILDER_ERROR_INVALID_TAG,
2819 Self::MissingPropertyValue => ffi::GTK_BUILDER_ERROR_MISSING_PROPERTY_VALUE,
2820 Self::InvalidValue => ffi::GTK_BUILDER_ERROR_INVALID_VALUE,
2821 Self::VersionMismatch => ffi::GTK_BUILDER_ERROR_VERSION_MISMATCH,
2822 Self::DuplicateId => ffi::GTK_BUILDER_ERROR_DUPLICATE_ID,
2823 Self::ObjectTypeRefused => ffi::GTK_BUILDER_ERROR_OBJECT_TYPE_REFUSED,
2824 Self::TemplateMismatch => ffi::GTK_BUILDER_ERROR_TEMPLATE_MISMATCH,
2825 Self::InvalidProperty => ffi::GTK_BUILDER_ERROR_INVALID_PROPERTY,
2826 Self::InvalidSignal => ffi::GTK_BUILDER_ERROR_INVALID_SIGNAL,
2827 Self::InvalidId => ffi::GTK_BUILDER_ERROR_INVALID_ID,
2828 Self::InvalidFunction => ffi::GTK_BUILDER_ERROR_INVALID_FUNCTION,
2829 Self::__Unknown(value) => value,
2830 }
2831 }
2832}
2833
2834#[doc(hidden)]
2835impl FromGlib<ffi::GtkBuilderError> for BuilderError {
2836 unsafe fn from_glib(value: ffi::GtkBuilderError) -> Self {
2837 skip_assert_initialized!();
2838
2839 match value {
2840 ffi::GTK_BUILDER_ERROR_INVALID_TYPE_FUNCTION => Self::InvalidTypeFunction,
2841 ffi::GTK_BUILDER_ERROR_UNHANDLED_TAG => Self::UnhandledTag,
2842 ffi::GTK_BUILDER_ERROR_MISSING_ATTRIBUTE => Self::MissingAttribute,
2843 ffi::GTK_BUILDER_ERROR_INVALID_ATTRIBUTE => Self::InvalidAttribute,
2844 ffi::GTK_BUILDER_ERROR_INVALID_TAG => Self::InvalidTag,
2845 ffi::GTK_BUILDER_ERROR_MISSING_PROPERTY_VALUE => Self::MissingPropertyValue,
2846 ffi::GTK_BUILDER_ERROR_INVALID_VALUE => Self::InvalidValue,
2847 ffi::GTK_BUILDER_ERROR_VERSION_MISMATCH => Self::VersionMismatch,
2848 ffi::GTK_BUILDER_ERROR_DUPLICATE_ID => Self::DuplicateId,
2849 ffi::GTK_BUILDER_ERROR_OBJECT_TYPE_REFUSED => Self::ObjectTypeRefused,
2850 ffi::GTK_BUILDER_ERROR_TEMPLATE_MISMATCH => Self::TemplateMismatch,
2851 ffi::GTK_BUILDER_ERROR_INVALID_PROPERTY => Self::InvalidProperty,
2852 ffi::GTK_BUILDER_ERROR_INVALID_SIGNAL => Self::InvalidSignal,
2853 ffi::GTK_BUILDER_ERROR_INVALID_ID => Self::InvalidId,
2854 ffi::GTK_BUILDER_ERROR_INVALID_FUNCTION => Self::InvalidFunction,
2855 value => Self::__Unknown(value),
2856 }
2857 }
2858}
2859
2860impl glib::error::ErrorDomain for BuilderError {
2861 #[inline]
2862 fn domain() -> glib::Quark {
2863 skip_assert_initialized!();
2864
2865 unsafe { from_glib(ffi::gtk_builder_error_quark()) }
2866 }
2867
2868 #[inline]
2869 fn code(self) -> i32 {
2870 self.into_glib()
2871 }
2872
2873 #[inline]
2874 #[allow(clippy::match_single_binding)]
2875 fn from(code: i32) -> Option<Self> {
2876 skip_assert_initialized!();
2877 match unsafe { from_glib(code) } {
2878 value => Some(value),
2879 }
2880 }
2881}
2882
2883impl StaticType for BuilderError {
2884 #[inline]
2885 #[doc(alias = "gtk_builder_error_get_type")]
2886 fn static_type() -> glib::Type {
2887 unsafe { from_glib(ffi::gtk_builder_error_get_type()) }
2888 }
2889}
2890
2891impl glib::HasParamSpec for BuilderError {
2892 type ParamSpec = glib::ParamSpecEnum;
2893 type SetValue = Self;
2894 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2895
2896 fn param_spec_builder() -> Self::BuilderFn {
2897 Self::ParamSpec::builder_with_default
2898 }
2899}
2900
2901impl glib::value::ValueType for BuilderError {
2902 type Type = Self;
2903}
2904
2905unsafe impl<'a> glib::value::FromValue<'a> for BuilderError {
2906 type Checker = glib::value::GenericValueTypeChecker<Self>;
2907
2908 #[inline]
2909 unsafe fn from_value(value: &'a glib::Value) -> Self {
2910 skip_assert_initialized!();
2911 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2912 }
2913}
2914
2915impl ToValue for BuilderError {
2916 #[inline]
2917 fn to_value(&self) -> glib::Value {
2918 let mut value = glib::Value::for_value_type::<Self>();
2919 unsafe {
2920 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2921 }
2922 value
2923 }
2924
2925 #[inline]
2926 fn value_type(&self) -> glib::Type {
2927 Self::static_type()
2928 }
2929}
2930
2931impl From<BuilderError> for glib::Value {
2932 #[inline]
2933 fn from(v: BuilderError) -> Self {
2934 skip_assert_initialized!();
2935 ToValue::to_value(&v)
2936 }
2937}
2938
2939#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2948#[non_exhaustive]
2949#[doc(alias = "GtkButtonsType")]
2950pub enum ButtonsType {
2951 #[doc(alias = "GTK_BUTTONS_NONE")]
2953 None,
2954 #[doc(alias = "GTK_BUTTONS_OK")]
2956 Ok,
2957 #[doc(alias = "GTK_BUTTONS_CLOSE")]
2959 Close,
2960 #[doc(alias = "GTK_BUTTONS_CANCEL")]
2962 Cancel,
2963 #[doc(alias = "GTK_BUTTONS_YES_NO")]
2965 YesNo,
2966 #[doc(alias = "GTK_BUTTONS_OK_CANCEL")]
2968 OkCancel,
2969 #[doc(hidden)]
2970 __Unknown(i32),
2971}
2972
2973#[doc(hidden)]
2974impl IntoGlib for ButtonsType {
2975 type GlibType = ffi::GtkButtonsType;
2976
2977 #[inline]
2978 fn into_glib(self) -> ffi::GtkButtonsType {
2979 match self {
2980 Self::None => ffi::GTK_BUTTONS_NONE,
2981 Self::Ok => ffi::GTK_BUTTONS_OK,
2982 Self::Close => ffi::GTK_BUTTONS_CLOSE,
2983 Self::Cancel => ffi::GTK_BUTTONS_CANCEL,
2984 Self::YesNo => ffi::GTK_BUTTONS_YES_NO,
2985 Self::OkCancel => ffi::GTK_BUTTONS_OK_CANCEL,
2986 Self::__Unknown(value) => value,
2987 }
2988 }
2989}
2990
2991#[doc(hidden)]
2992impl FromGlib<ffi::GtkButtonsType> for ButtonsType {
2993 #[inline]
2994 unsafe fn from_glib(value: ffi::GtkButtonsType) -> Self {
2995 skip_assert_initialized!();
2996
2997 match value {
2998 ffi::GTK_BUTTONS_NONE => Self::None,
2999 ffi::GTK_BUTTONS_OK => Self::Ok,
3000 ffi::GTK_BUTTONS_CLOSE => Self::Close,
3001 ffi::GTK_BUTTONS_CANCEL => Self::Cancel,
3002 ffi::GTK_BUTTONS_YES_NO => Self::YesNo,
3003 ffi::GTK_BUTTONS_OK_CANCEL => Self::OkCancel,
3004 value => Self::__Unknown(value),
3005 }
3006 }
3007}
3008
3009impl StaticType for ButtonsType {
3010 #[inline]
3011 #[doc(alias = "gtk_buttons_type_get_type")]
3012 fn static_type() -> glib::Type {
3013 unsafe { from_glib(ffi::gtk_buttons_type_get_type()) }
3014 }
3015}
3016
3017impl glib::HasParamSpec for ButtonsType {
3018 type ParamSpec = glib::ParamSpecEnum;
3019 type SetValue = Self;
3020 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3021
3022 fn param_spec_builder() -> Self::BuilderFn {
3023 Self::ParamSpec::builder_with_default
3024 }
3025}
3026
3027impl glib::value::ValueType for ButtonsType {
3028 type Type = Self;
3029}
3030
3031unsafe impl<'a> glib::value::FromValue<'a> for ButtonsType {
3032 type Checker = glib::value::GenericValueTypeChecker<Self>;
3033
3034 #[inline]
3035 unsafe fn from_value(value: &'a glib::Value) -> Self {
3036 skip_assert_initialized!();
3037 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3038 }
3039}
3040
3041impl ToValue for ButtonsType {
3042 #[inline]
3043 fn to_value(&self) -> glib::Value {
3044 let mut value = glib::Value::for_value_type::<Self>();
3045 unsafe {
3046 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3047 }
3048 value
3049 }
3050
3051 #[inline]
3052 fn value_type(&self) -> glib::Type {
3053 Self::static_type()
3054 }
3055}
3056
3057impl From<ButtonsType> for glib::Value {
3058 #[inline]
3059 fn from(v: ButtonsType) -> Self {
3060 skip_assert_initialized!();
3061 ToValue::to_value(&v)
3062 }
3063}
3064
3065#[cfg_attr(feature = "v4_20", deprecated = "Since 4.20")]
3071#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3072#[non_exhaustive]
3073#[doc(alias = "GtkCellRendererAccelMode")]
3074pub enum CellRendererAccelMode {
3075 #[doc(alias = "GTK_CELL_RENDERER_ACCEL_MODE_GTK")]
3077 Gtk,
3078 #[doc(alias = "GTK_CELL_RENDERER_ACCEL_MODE_OTHER")]
3080 Other,
3081 #[doc(hidden)]
3082 __Unknown(i32),
3083}
3084
3085#[allow(deprecated)]
3086#[doc(hidden)]
3087impl IntoGlib for CellRendererAccelMode {
3088 type GlibType = ffi::GtkCellRendererAccelMode;
3089
3090 #[inline]
3091 fn into_glib(self) -> ffi::GtkCellRendererAccelMode {
3092 match self {
3093 Self::Gtk => ffi::GTK_CELL_RENDERER_ACCEL_MODE_GTK,
3094 Self::Other => ffi::GTK_CELL_RENDERER_ACCEL_MODE_OTHER,
3095 Self::__Unknown(value) => value,
3096 }
3097 }
3098}
3099
3100#[allow(deprecated)]
3101#[doc(hidden)]
3102impl FromGlib<ffi::GtkCellRendererAccelMode> for CellRendererAccelMode {
3103 #[inline]
3104 unsafe fn from_glib(value: ffi::GtkCellRendererAccelMode) -> Self {
3105 skip_assert_initialized!();
3106
3107 match value {
3108 ffi::GTK_CELL_RENDERER_ACCEL_MODE_GTK => Self::Gtk,
3109 ffi::GTK_CELL_RENDERER_ACCEL_MODE_OTHER => Self::Other,
3110 value => Self::__Unknown(value),
3111 }
3112 }
3113}
3114
3115#[allow(deprecated)]
3116impl StaticType for CellRendererAccelMode {
3117 #[inline]
3118 #[doc(alias = "gtk_cell_renderer_accel_mode_get_type")]
3119 fn static_type() -> glib::Type {
3120 unsafe { from_glib(ffi::gtk_cell_renderer_accel_mode_get_type()) }
3121 }
3122}
3123
3124#[allow(deprecated)]
3125impl glib::HasParamSpec for CellRendererAccelMode {
3126 type ParamSpec = glib::ParamSpecEnum;
3127 type SetValue = Self;
3128 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3129
3130 fn param_spec_builder() -> Self::BuilderFn {
3131 Self::ParamSpec::builder_with_default
3132 }
3133}
3134
3135#[allow(deprecated)]
3136impl glib::value::ValueType for CellRendererAccelMode {
3137 type Type = Self;
3138}
3139
3140#[allow(deprecated)]
3141unsafe impl<'a> glib::value::FromValue<'a> for CellRendererAccelMode {
3142 type Checker = glib::value::GenericValueTypeChecker<Self>;
3143
3144 #[inline]
3145 unsafe fn from_value(value: &'a glib::Value) -> Self {
3146 skip_assert_initialized!();
3147 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3148 }
3149}
3150
3151#[allow(deprecated)]
3152impl ToValue for CellRendererAccelMode {
3153 #[inline]
3154 fn to_value(&self) -> glib::Value {
3155 let mut value = glib::Value::for_value_type::<Self>();
3156 unsafe {
3157 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3158 }
3159 value
3160 }
3161
3162 #[inline]
3163 fn value_type(&self) -> glib::Type {
3164 Self::static_type()
3165 }
3166}
3167
3168#[allow(deprecated)]
3169impl From<CellRendererAccelMode> for glib::Value {
3170 #[inline]
3171 fn from(v: CellRendererAccelMode) -> Self {
3172 skip_assert_initialized!();
3173 ToValue::to_value(&v)
3174 }
3175}
3176
3177#[cfg_attr(feature = "v4_20", deprecated = "Since 4.20")]
3183#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3184#[non_exhaustive]
3185#[doc(alias = "GtkCellRendererMode")]
3186pub enum CellRendererMode {
3187 #[doc(alias = "GTK_CELL_RENDERER_MODE_INERT")]
3192 Inert,
3193 #[doc(alias = "GTK_CELL_RENDERER_MODE_ACTIVATABLE")]
3195 Activatable,
3196 #[doc(alias = "GTK_CELL_RENDERER_MODE_EDITABLE")]
3198 Editable,
3199 #[doc(hidden)]
3200 __Unknown(i32),
3201}
3202
3203#[allow(deprecated)]
3204#[doc(hidden)]
3205impl IntoGlib for CellRendererMode {
3206 type GlibType = ffi::GtkCellRendererMode;
3207
3208 #[inline]
3209 fn into_glib(self) -> ffi::GtkCellRendererMode {
3210 match self {
3211 Self::Inert => ffi::GTK_CELL_RENDERER_MODE_INERT,
3212 Self::Activatable => ffi::GTK_CELL_RENDERER_MODE_ACTIVATABLE,
3213 Self::Editable => ffi::GTK_CELL_RENDERER_MODE_EDITABLE,
3214 Self::__Unknown(value) => value,
3215 }
3216 }
3217}
3218
3219#[allow(deprecated)]
3220#[doc(hidden)]
3221impl FromGlib<ffi::GtkCellRendererMode> for CellRendererMode {
3222 #[inline]
3223 unsafe fn from_glib(value: ffi::GtkCellRendererMode) -> Self {
3224 skip_assert_initialized!();
3225
3226 match value {
3227 ffi::GTK_CELL_RENDERER_MODE_INERT => Self::Inert,
3228 ffi::GTK_CELL_RENDERER_MODE_ACTIVATABLE => Self::Activatable,
3229 ffi::GTK_CELL_RENDERER_MODE_EDITABLE => Self::Editable,
3230 value => Self::__Unknown(value),
3231 }
3232 }
3233}
3234
3235#[allow(deprecated)]
3236impl StaticType for CellRendererMode {
3237 #[inline]
3238 #[doc(alias = "gtk_cell_renderer_mode_get_type")]
3239 fn static_type() -> glib::Type {
3240 unsafe { from_glib(ffi::gtk_cell_renderer_mode_get_type()) }
3241 }
3242}
3243
3244#[allow(deprecated)]
3245impl glib::HasParamSpec for CellRendererMode {
3246 type ParamSpec = glib::ParamSpecEnum;
3247 type SetValue = Self;
3248 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3249
3250 fn param_spec_builder() -> Self::BuilderFn {
3251 Self::ParamSpec::builder_with_default
3252 }
3253}
3254
3255#[allow(deprecated)]
3256impl glib::value::ValueType for CellRendererMode {
3257 type Type = Self;
3258}
3259
3260#[allow(deprecated)]
3261unsafe impl<'a> glib::value::FromValue<'a> for CellRendererMode {
3262 type Checker = glib::value::GenericValueTypeChecker<Self>;
3263
3264 #[inline]
3265 unsafe fn from_value(value: &'a glib::Value) -> Self {
3266 skip_assert_initialized!();
3267 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3268 }
3269}
3270
3271#[allow(deprecated)]
3272impl ToValue for CellRendererMode {
3273 #[inline]
3274 fn to_value(&self) -> glib::Value {
3275 let mut value = glib::Value::for_value_type::<Self>();
3276 unsafe {
3277 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3278 }
3279 value
3280 }
3281
3282 #[inline]
3283 fn value_type(&self) -> glib::Type {
3284 Self::static_type()
3285 }
3286}
3287
3288#[allow(deprecated)]
3289impl From<CellRendererMode> for glib::Value {
3290 #[inline]
3291 fn from(v: CellRendererMode) -> Self {
3292 skip_assert_initialized!();
3293 ToValue::to_value(&v)
3294 }
3295}
3296
3297#[cfg(feature = "v4_10")]
3303#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
3304#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3305#[non_exhaustive]
3306#[doc(alias = "GtkCollation")]
3307pub enum Collation {
3308 #[doc(alias = "GTK_COLLATION_NONE")]
3310 None,
3311 #[doc(alias = "GTK_COLLATION_UNICODE")]
3313 Unicode,
3314 #[doc(alias = "GTK_COLLATION_FILENAME")]
3316 Filename,
3317 #[doc(hidden)]
3318 __Unknown(i32),
3319}
3320
3321#[cfg(feature = "v4_10")]
3322#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
3323#[doc(hidden)]
3324impl IntoGlib for Collation {
3325 type GlibType = ffi::GtkCollation;
3326
3327 #[inline]
3328 fn into_glib(self) -> ffi::GtkCollation {
3329 match self {
3330 Self::None => ffi::GTK_COLLATION_NONE,
3331 Self::Unicode => ffi::GTK_COLLATION_UNICODE,
3332 Self::Filename => ffi::GTK_COLLATION_FILENAME,
3333 Self::__Unknown(value) => value,
3334 }
3335 }
3336}
3337
3338#[cfg(feature = "v4_10")]
3339#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
3340#[doc(hidden)]
3341impl FromGlib<ffi::GtkCollation> for Collation {
3342 #[inline]
3343 unsafe fn from_glib(value: ffi::GtkCollation) -> Self {
3344 skip_assert_initialized!();
3345
3346 match value {
3347 ffi::GTK_COLLATION_NONE => Self::None,
3348 ffi::GTK_COLLATION_UNICODE => Self::Unicode,
3349 ffi::GTK_COLLATION_FILENAME => Self::Filename,
3350 value => Self::__Unknown(value),
3351 }
3352 }
3353}
3354
3355#[cfg(feature = "v4_10")]
3356#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
3357impl StaticType for Collation {
3358 #[inline]
3359 #[doc(alias = "gtk_collation_get_type")]
3360 fn static_type() -> glib::Type {
3361 unsafe { from_glib(ffi::gtk_collation_get_type()) }
3362 }
3363}
3364
3365#[cfg(feature = "v4_10")]
3366#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
3367impl glib::HasParamSpec for Collation {
3368 type ParamSpec = glib::ParamSpecEnum;
3369 type SetValue = Self;
3370 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3371
3372 fn param_spec_builder() -> Self::BuilderFn {
3373 Self::ParamSpec::builder_with_default
3374 }
3375}
3376
3377#[cfg(feature = "v4_10")]
3378#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
3379impl glib::value::ValueType for Collation {
3380 type Type = Self;
3381}
3382
3383#[cfg(feature = "v4_10")]
3384#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
3385unsafe impl<'a> glib::value::FromValue<'a> for Collation {
3386 type Checker = glib::value::GenericValueTypeChecker<Self>;
3387
3388 #[inline]
3389 unsafe fn from_value(value: &'a glib::Value) -> Self {
3390 skip_assert_initialized!();
3391 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3392 }
3393}
3394
3395#[cfg(feature = "v4_10")]
3396#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
3397impl ToValue for Collation {
3398 #[inline]
3399 fn to_value(&self) -> glib::Value {
3400 let mut value = glib::Value::for_value_type::<Self>();
3401 unsafe {
3402 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3403 }
3404 value
3405 }
3406
3407 #[inline]
3408 fn value_type(&self) -> glib::Type {
3409 Self::static_type()
3410 }
3411}
3412
3413#[cfg(feature = "v4_10")]
3414#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
3415impl From<Collation> for glib::Value {
3416 #[inline]
3417 fn from(v: Collation) -> Self {
3418 skip_assert_initialized!();
3419 ToValue::to_value(&v)
3420 }
3421}
3422
3423#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3425#[non_exhaustive]
3426#[doc(alias = "GtkConstraintAttribute")]
3427pub enum ConstraintAttribute {
3428 #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_NONE")]
3431 None,
3432 #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_LEFT")]
3435 Left,
3436 #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_RIGHT")]
3439 Right,
3440 #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_TOP")]
3442 Top,
3443 #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_BOTTOM")]
3445 Bottom,
3446 #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_START")]
3450 Start,
3451 #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_END")]
3455 End,
3456 #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_WIDTH")]
3458 Width,
3459 #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_HEIGHT")]
3461 Height,
3462 #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_CENTER_X")]
3465 CenterX,
3466 #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_CENTER_Y")]
3469 CenterY,
3470 #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_BASELINE")]
3472 Baseline,
3473 #[doc(hidden)]
3474 __Unknown(i32),
3475}
3476
3477#[doc(hidden)]
3478impl IntoGlib for ConstraintAttribute {
3479 type GlibType = ffi::GtkConstraintAttribute;
3480
3481 #[inline]
3482 fn into_glib(self) -> ffi::GtkConstraintAttribute {
3483 match self {
3484 Self::None => ffi::GTK_CONSTRAINT_ATTRIBUTE_NONE,
3485 Self::Left => ffi::GTK_CONSTRAINT_ATTRIBUTE_LEFT,
3486 Self::Right => ffi::GTK_CONSTRAINT_ATTRIBUTE_RIGHT,
3487 Self::Top => ffi::GTK_CONSTRAINT_ATTRIBUTE_TOP,
3488 Self::Bottom => ffi::GTK_CONSTRAINT_ATTRIBUTE_BOTTOM,
3489 Self::Start => ffi::GTK_CONSTRAINT_ATTRIBUTE_START,
3490 Self::End => ffi::GTK_CONSTRAINT_ATTRIBUTE_END,
3491 Self::Width => ffi::GTK_CONSTRAINT_ATTRIBUTE_WIDTH,
3492 Self::Height => ffi::GTK_CONSTRAINT_ATTRIBUTE_HEIGHT,
3493 Self::CenterX => ffi::GTK_CONSTRAINT_ATTRIBUTE_CENTER_X,
3494 Self::CenterY => ffi::GTK_CONSTRAINT_ATTRIBUTE_CENTER_Y,
3495 Self::Baseline => ffi::GTK_CONSTRAINT_ATTRIBUTE_BASELINE,
3496 Self::__Unknown(value) => value,
3497 }
3498 }
3499}
3500
3501#[doc(hidden)]
3502impl FromGlib<ffi::GtkConstraintAttribute> for ConstraintAttribute {
3503 #[inline]
3504 unsafe fn from_glib(value: ffi::GtkConstraintAttribute) -> Self {
3505 skip_assert_initialized!();
3506
3507 match value {
3508 ffi::GTK_CONSTRAINT_ATTRIBUTE_NONE => Self::None,
3509 ffi::GTK_CONSTRAINT_ATTRIBUTE_LEFT => Self::Left,
3510 ffi::GTK_CONSTRAINT_ATTRIBUTE_RIGHT => Self::Right,
3511 ffi::GTK_CONSTRAINT_ATTRIBUTE_TOP => Self::Top,
3512 ffi::GTK_CONSTRAINT_ATTRIBUTE_BOTTOM => Self::Bottom,
3513 ffi::GTK_CONSTRAINT_ATTRIBUTE_START => Self::Start,
3514 ffi::GTK_CONSTRAINT_ATTRIBUTE_END => Self::End,
3515 ffi::GTK_CONSTRAINT_ATTRIBUTE_WIDTH => Self::Width,
3516 ffi::GTK_CONSTRAINT_ATTRIBUTE_HEIGHT => Self::Height,
3517 ffi::GTK_CONSTRAINT_ATTRIBUTE_CENTER_X => Self::CenterX,
3518 ffi::GTK_CONSTRAINT_ATTRIBUTE_CENTER_Y => Self::CenterY,
3519 ffi::GTK_CONSTRAINT_ATTRIBUTE_BASELINE => Self::Baseline,
3520 value => Self::__Unknown(value),
3521 }
3522 }
3523}
3524
3525impl StaticType for ConstraintAttribute {
3526 #[inline]
3527 #[doc(alias = "gtk_constraint_attribute_get_type")]
3528 fn static_type() -> glib::Type {
3529 unsafe { from_glib(ffi::gtk_constraint_attribute_get_type()) }
3530 }
3531}
3532
3533impl glib::HasParamSpec for ConstraintAttribute {
3534 type ParamSpec = glib::ParamSpecEnum;
3535 type SetValue = Self;
3536 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3537
3538 fn param_spec_builder() -> Self::BuilderFn {
3539 Self::ParamSpec::builder_with_default
3540 }
3541}
3542
3543impl glib::value::ValueType for ConstraintAttribute {
3544 type Type = Self;
3545}
3546
3547unsafe impl<'a> glib::value::FromValue<'a> for ConstraintAttribute {
3548 type Checker = glib::value::GenericValueTypeChecker<Self>;
3549
3550 #[inline]
3551 unsafe fn from_value(value: &'a glib::Value) -> Self {
3552 skip_assert_initialized!();
3553 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3554 }
3555}
3556
3557impl ToValue for ConstraintAttribute {
3558 #[inline]
3559 fn to_value(&self) -> glib::Value {
3560 let mut value = glib::Value::for_value_type::<Self>();
3561 unsafe {
3562 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3563 }
3564 value
3565 }
3566
3567 #[inline]
3568 fn value_type(&self) -> glib::Type {
3569 Self::static_type()
3570 }
3571}
3572
3573impl From<ConstraintAttribute> for glib::Value {
3574 #[inline]
3575 fn from(v: ConstraintAttribute) -> Self {
3576 skip_assert_initialized!();
3577 ToValue::to_value(&v)
3578 }
3579}
3580
3581#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3583#[non_exhaustive]
3584#[doc(alias = "GtkConstraintRelation")]
3585pub enum ConstraintRelation {
3586 #[doc(alias = "GTK_CONSTRAINT_RELATION_LE")]
3588 Le,
3589 #[doc(alias = "GTK_CONSTRAINT_RELATION_EQ")]
3591 Eq,
3592 #[doc(alias = "GTK_CONSTRAINT_RELATION_GE")]
3594 Ge,
3595 #[doc(hidden)]
3596 __Unknown(i32),
3597}
3598
3599#[doc(hidden)]
3600impl IntoGlib for ConstraintRelation {
3601 type GlibType = ffi::GtkConstraintRelation;
3602
3603 #[inline]
3604 fn into_glib(self) -> ffi::GtkConstraintRelation {
3605 match self {
3606 Self::Le => ffi::GTK_CONSTRAINT_RELATION_LE,
3607 Self::Eq => ffi::GTK_CONSTRAINT_RELATION_EQ,
3608 Self::Ge => ffi::GTK_CONSTRAINT_RELATION_GE,
3609 Self::__Unknown(value) => value,
3610 }
3611 }
3612}
3613
3614#[doc(hidden)]
3615impl FromGlib<ffi::GtkConstraintRelation> for ConstraintRelation {
3616 #[inline]
3617 unsafe fn from_glib(value: ffi::GtkConstraintRelation) -> Self {
3618 skip_assert_initialized!();
3619
3620 match value {
3621 ffi::GTK_CONSTRAINT_RELATION_LE => Self::Le,
3622 ffi::GTK_CONSTRAINT_RELATION_EQ => Self::Eq,
3623 ffi::GTK_CONSTRAINT_RELATION_GE => Self::Ge,
3624 value => Self::__Unknown(value),
3625 }
3626 }
3627}
3628
3629impl StaticType for ConstraintRelation {
3630 #[inline]
3631 #[doc(alias = "gtk_constraint_relation_get_type")]
3632 fn static_type() -> glib::Type {
3633 unsafe { from_glib(ffi::gtk_constraint_relation_get_type()) }
3634 }
3635}
3636
3637impl glib::HasParamSpec for ConstraintRelation {
3638 type ParamSpec = glib::ParamSpecEnum;
3639 type SetValue = Self;
3640 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3641
3642 fn param_spec_builder() -> Self::BuilderFn {
3643 Self::ParamSpec::builder_with_default
3644 }
3645}
3646
3647impl glib::value::ValueType for ConstraintRelation {
3648 type Type = Self;
3649}
3650
3651unsafe impl<'a> glib::value::FromValue<'a> for ConstraintRelation {
3652 type Checker = glib::value::GenericValueTypeChecker<Self>;
3653
3654 #[inline]
3655 unsafe fn from_value(value: &'a glib::Value) -> Self {
3656 skip_assert_initialized!();
3657 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3658 }
3659}
3660
3661impl ToValue for ConstraintRelation {
3662 #[inline]
3663 fn to_value(&self) -> glib::Value {
3664 let mut value = glib::Value::for_value_type::<Self>();
3665 unsafe {
3666 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3667 }
3668 value
3669 }
3670
3671 #[inline]
3672 fn value_type(&self) -> glib::Type {
3673 Self::static_type()
3674 }
3675}
3676
3677impl From<ConstraintRelation> for glib::Value {
3678 #[inline]
3679 fn from(v: ConstraintRelation) -> Self {
3680 skip_assert_initialized!();
3681 ToValue::to_value(&v)
3682 }
3683}
3684
3685#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3690#[non_exhaustive]
3691#[doc(alias = "GtkConstraintStrength")]
3692pub enum ConstraintStrength {
3693 #[doc(alias = "GTK_CONSTRAINT_STRENGTH_REQUIRED")]
3695 Required,
3696 #[doc(alias = "GTK_CONSTRAINT_STRENGTH_STRONG")]
3698 Strong,
3699 #[doc(alias = "GTK_CONSTRAINT_STRENGTH_MEDIUM")]
3701 Medium,
3702 #[doc(alias = "GTK_CONSTRAINT_STRENGTH_WEAK")]
3704 Weak,
3705 #[doc(hidden)]
3706 __Unknown(i32),
3707}
3708
3709#[doc(hidden)]
3710impl IntoGlib for ConstraintStrength {
3711 type GlibType = ffi::GtkConstraintStrength;
3712
3713 #[inline]
3714 fn into_glib(self) -> ffi::GtkConstraintStrength {
3715 match self {
3716 Self::Required => ffi::GTK_CONSTRAINT_STRENGTH_REQUIRED,
3717 Self::Strong => ffi::GTK_CONSTRAINT_STRENGTH_STRONG,
3718 Self::Medium => ffi::GTK_CONSTRAINT_STRENGTH_MEDIUM,
3719 Self::Weak => ffi::GTK_CONSTRAINT_STRENGTH_WEAK,
3720 Self::__Unknown(value) => value,
3721 }
3722 }
3723}
3724
3725#[doc(hidden)]
3726impl FromGlib<ffi::GtkConstraintStrength> for ConstraintStrength {
3727 #[inline]
3728 unsafe fn from_glib(value: ffi::GtkConstraintStrength) -> Self {
3729 skip_assert_initialized!();
3730
3731 match value {
3732 ffi::GTK_CONSTRAINT_STRENGTH_REQUIRED => Self::Required,
3733 ffi::GTK_CONSTRAINT_STRENGTH_STRONG => Self::Strong,
3734 ffi::GTK_CONSTRAINT_STRENGTH_MEDIUM => Self::Medium,
3735 ffi::GTK_CONSTRAINT_STRENGTH_WEAK => Self::Weak,
3736 value => Self::__Unknown(value),
3737 }
3738 }
3739}
3740
3741impl StaticType for ConstraintStrength {
3742 #[inline]
3743 #[doc(alias = "gtk_constraint_strength_get_type")]
3744 fn static_type() -> glib::Type {
3745 unsafe { from_glib(ffi::gtk_constraint_strength_get_type()) }
3746 }
3747}
3748
3749impl glib::HasParamSpec for ConstraintStrength {
3750 type ParamSpec = glib::ParamSpecEnum;
3751 type SetValue = Self;
3752 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3753
3754 fn param_spec_builder() -> Self::BuilderFn {
3755 Self::ParamSpec::builder_with_default
3756 }
3757}
3758
3759impl glib::value::ValueType for ConstraintStrength {
3760 type Type = Self;
3761}
3762
3763unsafe impl<'a> glib::value::FromValue<'a> for ConstraintStrength {
3764 type Checker = glib::value::GenericValueTypeChecker<Self>;
3765
3766 #[inline]
3767 unsafe fn from_value(value: &'a glib::Value) -> Self {
3768 skip_assert_initialized!();
3769 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3770 }
3771}
3772
3773impl ToValue for ConstraintStrength {
3774 #[inline]
3775 fn to_value(&self) -> glib::Value {
3776 let mut value = glib::Value::for_value_type::<Self>();
3777 unsafe {
3778 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3779 }
3780 value
3781 }
3782
3783 #[inline]
3784 fn value_type(&self) -> glib::Type {
3785 Self::static_type()
3786 }
3787}
3788
3789impl From<ConstraintStrength> for glib::Value {
3790 #[inline]
3791 fn from(v: ConstraintStrength) -> Self {
3792 skip_assert_initialized!();
3793 ToValue::to_value(&v)
3794 }
3795}
3796
3797#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3799#[non_exhaustive]
3800#[doc(alias = "GtkConstraintVflParserError")]
3801pub enum ConstraintVflParserError {
3802 #[doc(alias = "GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_SYMBOL")]
3804 Symbol,
3805 #[doc(alias = "GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_ATTRIBUTE")]
3807 Attribute,
3808 #[doc(alias = "GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_VIEW")]
3810 View,
3811 #[doc(alias = "GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_METRIC")]
3813 Metric,
3814 #[doc(alias = "GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_PRIORITY")]
3816 Priority,
3817 #[doc(alias = "GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_RELATION")]
3819 Relation,
3820 #[doc(hidden)]
3821 __Unknown(i32),
3822}
3823
3824#[doc(hidden)]
3825impl IntoGlib for ConstraintVflParserError {
3826 type GlibType = ffi::GtkConstraintVflParserError;
3827
3828 #[inline]
3829 fn into_glib(self) -> ffi::GtkConstraintVflParserError {
3830 match self {
3831 Self::Symbol => ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_SYMBOL,
3832 Self::Attribute => ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_ATTRIBUTE,
3833 Self::View => ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_VIEW,
3834 Self::Metric => ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_METRIC,
3835 Self::Priority => ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_PRIORITY,
3836 Self::Relation => ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_RELATION,
3837 Self::__Unknown(value) => value,
3838 }
3839 }
3840}
3841
3842#[doc(hidden)]
3843impl FromGlib<ffi::GtkConstraintVflParserError> for ConstraintVflParserError {
3844 #[inline]
3845 unsafe fn from_glib(value: ffi::GtkConstraintVflParserError) -> Self {
3846 skip_assert_initialized!();
3847
3848 match value {
3849 ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_SYMBOL => Self::Symbol,
3850 ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_ATTRIBUTE => Self::Attribute,
3851 ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_VIEW => Self::View,
3852 ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_METRIC => Self::Metric,
3853 ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_PRIORITY => Self::Priority,
3854 ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_RELATION => Self::Relation,
3855 value => Self::__Unknown(value),
3856 }
3857 }
3858}
3859
3860impl glib::error::ErrorDomain for ConstraintVflParserError {
3861 #[inline]
3862 fn domain() -> glib::Quark {
3863 skip_assert_initialized!();
3864
3865 unsafe { from_glib(ffi::gtk_constraint_vfl_parser_error_quark()) }
3866 }
3867
3868 #[inline]
3869 fn code(self) -> i32 {
3870 self.into_glib()
3871 }
3872
3873 #[inline]
3874 #[allow(clippy::match_single_binding)]
3875 fn from(code: i32) -> Option<Self> {
3876 skip_assert_initialized!();
3877 match unsafe { from_glib(code) } {
3878 value => Some(value),
3879 }
3880 }
3881}
3882
3883impl StaticType for ConstraintVflParserError {
3884 #[inline]
3885 #[doc(alias = "gtk_constraint_vfl_parser_error_get_type")]
3886 fn static_type() -> glib::Type {
3887 unsafe { from_glib(ffi::gtk_constraint_vfl_parser_error_get_type()) }
3888 }
3889}
3890
3891impl glib::HasParamSpec for ConstraintVflParserError {
3892 type ParamSpec = glib::ParamSpecEnum;
3893 type SetValue = Self;
3894 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3895
3896 fn param_spec_builder() -> Self::BuilderFn {
3897 Self::ParamSpec::builder_with_default
3898 }
3899}
3900
3901impl glib::value::ValueType for ConstraintVflParserError {
3902 type Type = Self;
3903}
3904
3905unsafe impl<'a> glib::value::FromValue<'a> for ConstraintVflParserError {
3906 type Checker = glib::value::GenericValueTypeChecker<Self>;
3907
3908 #[inline]
3909 unsafe fn from_value(value: &'a glib::Value) -> Self {
3910 skip_assert_initialized!();
3911 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3912 }
3913}
3914
3915impl ToValue for ConstraintVflParserError {
3916 #[inline]
3917 fn to_value(&self) -> glib::Value {
3918 let mut value = glib::Value::for_value_type::<Self>();
3919 unsafe {
3920 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3921 }
3922 value
3923 }
3924
3925 #[inline]
3926 fn value_type(&self) -> glib::Type {
3927 Self::static_type()
3928 }
3929}
3930
3931impl From<ConstraintVflParserError> for glib::Value {
3932 #[inline]
3933 fn from(v: ConstraintVflParserError) -> Self {
3934 skip_assert_initialized!();
3935 ToValue::to_value(&v)
3936 }
3937}
3938
3939#[cfg(feature = "v4_8")]
3941#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
3942#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3943#[non_exhaustive]
3944#[doc(alias = "GtkContentFit")]
3945pub enum ContentFit {
3946 #[doc(alias = "GTK_CONTENT_FIT_FILL")]
3951 Fill,
3952 #[doc(alias = "GTK_CONTENT_FIT_CONTAIN")]
3957 Contain,
3958 #[doc(alias = "GTK_CONTENT_FIT_COVER")]
3963 Cover,
3964 #[doc(alias = "GTK_CONTENT_FIT_SCALE_DOWN")]
3967 ScaleDown,
3968 #[doc(hidden)]
3969 __Unknown(i32),
3970}
3971
3972#[cfg(feature = "v4_8")]
3973#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
3974#[doc(hidden)]
3975impl IntoGlib for ContentFit {
3976 type GlibType = ffi::GtkContentFit;
3977
3978 #[inline]
3979 fn into_glib(self) -> ffi::GtkContentFit {
3980 match self {
3981 Self::Fill => ffi::GTK_CONTENT_FIT_FILL,
3982 Self::Contain => ffi::GTK_CONTENT_FIT_CONTAIN,
3983 Self::Cover => ffi::GTK_CONTENT_FIT_COVER,
3984 Self::ScaleDown => ffi::GTK_CONTENT_FIT_SCALE_DOWN,
3985 Self::__Unknown(value) => value,
3986 }
3987 }
3988}
3989
3990#[cfg(feature = "v4_8")]
3991#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
3992#[doc(hidden)]
3993impl FromGlib<ffi::GtkContentFit> for ContentFit {
3994 #[inline]
3995 unsafe fn from_glib(value: ffi::GtkContentFit) -> Self {
3996 skip_assert_initialized!();
3997
3998 match value {
3999 ffi::GTK_CONTENT_FIT_FILL => Self::Fill,
4000 ffi::GTK_CONTENT_FIT_CONTAIN => Self::Contain,
4001 ffi::GTK_CONTENT_FIT_COVER => Self::Cover,
4002 ffi::GTK_CONTENT_FIT_SCALE_DOWN => Self::ScaleDown,
4003 value => Self::__Unknown(value),
4004 }
4005 }
4006}
4007
4008#[cfg(feature = "v4_8")]
4009#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
4010impl StaticType for ContentFit {
4011 #[inline]
4012 #[doc(alias = "gtk_content_fit_get_type")]
4013 fn static_type() -> glib::Type {
4014 unsafe { from_glib(ffi::gtk_content_fit_get_type()) }
4015 }
4016}
4017
4018#[cfg(feature = "v4_8")]
4019#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
4020impl glib::HasParamSpec for ContentFit {
4021 type ParamSpec = glib::ParamSpecEnum;
4022 type SetValue = Self;
4023 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4024
4025 fn param_spec_builder() -> Self::BuilderFn {
4026 Self::ParamSpec::builder_with_default
4027 }
4028}
4029
4030#[cfg(feature = "v4_8")]
4031#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
4032impl glib::value::ValueType for ContentFit {
4033 type Type = Self;
4034}
4035
4036#[cfg(feature = "v4_8")]
4037#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
4038unsafe impl<'a> glib::value::FromValue<'a> for ContentFit {
4039 type Checker = glib::value::GenericValueTypeChecker<Self>;
4040
4041 #[inline]
4042 unsafe fn from_value(value: &'a glib::Value) -> Self {
4043 skip_assert_initialized!();
4044 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4045 }
4046}
4047
4048#[cfg(feature = "v4_8")]
4049#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
4050impl ToValue for ContentFit {
4051 #[inline]
4052 fn to_value(&self) -> glib::Value {
4053 let mut value = glib::Value::for_value_type::<Self>();
4054 unsafe {
4055 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4056 }
4057 value
4058 }
4059
4060 #[inline]
4061 fn value_type(&self) -> glib::Type {
4062 Self::static_type()
4063 }
4064}
4065
4066#[cfg(feature = "v4_8")]
4067#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
4068impl From<ContentFit> for glib::Value {
4069 #[inline]
4070 fn from(v: ContentFit) -> Self {
4071 skip_assert_initialized!();
4072 ToValue::to_value(&v)
4073 }
4074}
4075
4076#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4081#[non_exhaustive]
4082#[doc(alias = "GtkCornerType")]
4083pub enum CornerType {
4084 #[doc(alias = "GTK_CORNER_TOP_LEFT")]
4087 TopLeft,
4088 #[doc(alias = "GTK_CORNER_BOTTOM_LEFT")]
4091 BottomLeft,
4092 #[doc(alias = "GTK_CORNER_TOP_RIGHT")]
4095 TopRight,
4096 #[doc(alias = "GTK_CORNER_BOTTOM_RIGHT")]
4099 BottomRight,
4100 #[doc(hidden)]
4101 __Unknown(i32),
4102}
4103
4104#[doc(hidden)]
4105impl IntoGlib for CornerType {
4106 type GlibType = ffi::GtkCornerType;
4107
4108 #[inline]
4109 fn into_glib(self) -> ffi::GtkCornerType {
4110 match self {
4111 Self::TopLeft => ffi::GTK_CORNER_TOP_LEFT,
4112 Self::BottomLeft => ffi::GTK_CORNER_BOTTOM_LEFT,
4113 Self::TopRight => ffi::GTK_CORNER_TOP_RIGHT,
4114 Self::BottomRight => ffi::GTK_CORNER_BOTTOM_RIGHT,
4115 Self::__Unknown(value) => value,
4116 }
4117 }
4118}
4119
4120#[doc(hidden)]
4121impl FromGlib<ffi::GtkCornerType> for CornerType {
4122 #[inline]
4123 unsafe fn from_glib(value: ffi::GtkCornerType) -> Self {
4124 skip_assert_initialized!();
4125
4126 match value {
4127 ffi::GTK_CORNER_TOP_LEFT => Self::TopLeft,
4128 ffi::GTK_CORNER_BOTTOM_LEFT => Self::BottomLeft,
4129 ffi::GTK_CORNER_TOP_RIGHT => Self::TopRight,
4130 ffi::GTK_CORNER_BOTTOM_RIGHT => Self::BottomRight,
4131 value => Self::__Unknown(value),
4132 }
4133 }
4134}
4135
4136impl StaticType for CornerType {
4137 #[inline]
4138 #[doc(alias = "gtk_corner_type_get_type")]
4139 fn static_type() -> glib::Type {
4140 unsafe { from_glib(ffi::gtk_corner_type_get_type()) }
4141 }
4142}
4143
4144impl glib::HasParamSpec for CornerType {
4145 type ParamSpec = glib::ParamSpecEnum;
4146 type SetValue = Self;
4147 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4148
4149 fn param_spec_builder() -> Self::BuilderFn {
4150 Self::ParamSpec::builder_with_default
4151 }
4152}
4153
4154impl glib::value::ValueType for CornerType {
4155 type Type = Self;
4156}
4157
4158unsafe impl<'a> glib::value::FromValue<'a> for CornerType {
4159 type Checker = glib::value::GenericValueTypeChecker<Self>;
4160
4161 #[inline]
4162 unsafe fn from_value(value: &'a glib::Value) -> Self {
4163 skip_assert_initialized!();
4164 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4165 }
4166}
4167
4168impl ToValue for CornerType {
4169 #[inline]
4170 fn to_value(&self) -> glib::Value {
4171 let mut value = glib::Value::for_value_type::<Self>();
4172 unsafe {
4173 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4174 }
4175 value
4176 }
4177
4178 #[inline]
4179 fn value_type(&self) -> glib::Type {
4180 Self::static_type()
4181 }
4182}
4183
4184impl From<CornerType> for glib::Value {
4185 #[inline]
4186 fn from(v: CornerType) -> Self {
4187 skip_assert_initialized!();
4188 ToValue::to_value(&v)
4189 }
4190}
4191
4192#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4197#[non_exhaustive]
4198#[doc(alias = "GtkCssParserError")]
4199pub enum CssParserError {
4200 #[doc(alias = "GTK_CSS_PARSER_ERROR_FAILED")]
4202 Failed,
4203 #[doc(alias = "GTK_CSS_PARSER_ERROR_SYNTAX")]
4205 Syntax,
4206 #[doc(alias = "GTK_CSS_PARSER_ERROR_IMPORT")]
4208 Import,
4209 #[doc(alias = "GTK_CSS_PARSER_ERROR_NAME")]
4211 Name,
4212 #[doc(alias = "GTK_CSS_PARSER_ERROR_UNKNOWN_VALUE")]
4214 UnknownValue,
4215 #[doc(hidden)]
4216 __Unknown(i32),
4217}
4218
4219#[doc(hidden)]
4220impl IntoGlib for CssParserError {
4221 type GlibType = ffi::GtkCssParserError;
4222
4223 #[inline]
4224 fn into_glib(self) -> ffi::GtkCssParserError {
4225 match self {
4226 Self::Failed => ffi::GTK_CSS_PARSER_ERROR_FAILED,
4227 Self::Syntax => ffi::GTK_CSS_PARSER_ERROR_SYNTAX,
4228 Self::Import => ffi::GTK_CSS_PARSER_ERROR_IMPORT,
4229 Self::Name => ffi::GTK_CSS_PARSER_ERROR_NAME,
4230 Self::UnknownValue => ffi::GTK_CSS_PARSER_ERROR_UNKNOWN_VALUE,
4231 Self::__Unknown(value) => value,
4232 }
4233 }
4234}
4235
4236#[doc(hidden)]
4237impl FromGlib<ffi::GtkCssParserError> for CssParserError {
4238 #[inline]
4239 unsafe fn from_glib(value: ffi::GtkCssParserError) -> Self {
4240 skip_assert_initialized!();
4241
4242 match value {
4243 ffi::GTK_CSS_PARSER_ERROR_FAILED => Self::Failed,
4244 ffi::GTK_CSS_PARSER_ERROR_SYNTAX => Self::Syntax,
4245 ffi::GTK_CSS_PARSER_ERROR_IMPORT => Self::Import,
4246 ffi::GTK_CSS_PARSER_ERROR_NAME => Self::Name,
4247 ffi::GTK_CSS_PARSER_ERROR_UNKNOWN_VALUE => Self::UnknownValue,
4248 value => Self::__Unknown(value),
4249 }
4250 }
4251}
4252
4253impl glib::error::ErrorDomain for CssParserError {
4254 #[inline]
4255 fn domain() -> glib::Quark {
4256 skip_assert_initialized!();
4257
4258 unsafe { from_glib(ffi::gtk_css_parser_error_quark()) }
4259 }
4260
4261 #[inline]
4262 fn code(self) -> i32 {
4263 self.into_glib()
4264 }
4265
4266 #[inline]
4267 #[allow(clippy::match_single_binding)]
4268 fn from(code: i32) -> Option<Self> {
4269 skip_assert_initialized!();
4270 match unsafe { from_glib(code) } {
4271 Self::__Unknown(_) => Some(Self::Failed),
4272 value => Some(value),
4273 }
4274 }
4275}
4276
4277#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4282#[non_exhaustive]
4283#[doc(alias = "GtkCssParserWarning")]
4284pub enum CssParserWarning {
4285 #[doc(alias = "GTK_CSS_PARSER_WARNING_DEPRECATED")]
4288 Deprecated,
4289 #[doc(alias = "GTK_CSS_PARSER_WARNING_SYNTAX")]
4292 Syntax,
4293 #[doc(alias = "GTK_CSS_PARSER_WARNING_UNIMPLEMENTED")]
4295 Unimplemented,
4296 #[doc(hidden)]
4297 __Unknown(i32),
4298}
4299
4300#[doc(hidden)]
4301impl IntoGlib for CssParserWarning {
4302 type GlibType = ffi::GtkCssParserWarning;
4303
4304 #[inline]
4305 fn into_glib(self) -> ffi::GtkCssParserWarning {
4306 match self {
4307 Self::Deprecated => ffi::GTK_CSS_PARSER_WARNING_DEPRECATED,
4308 Self::Syntax => ffi::GTK_CSS_PARSER_WARNING_SYNTAX,
4309 Self::Unimplemented => ffi::GTK_CSS_PARSER_WARNING_UNIMPLEMENTED,
4310 Self::__Unknown(value) => value,
4311 }
4312 }
4313}
4314
4315#[doc(hidden)]
4316impl FromGlib<ffi::GtkCssParserWarning> for CssParserWarning {
4317 #[inline]
4318 unsafe fn from_glib(value: ffi::GtkCssParserWarning) -> Self {
4319 skip_assert_initialized!();
4320
4321 match value {
4322 ffi::GTK_CSS_PARSER_WARNING_DEPRECATED => Self::Deprecated,
4323 ffi::GTK_CSS_PARSER_WARNING_SYNTAX => Self::Syntax,
4324 ffi::GTK_CSS_PARSER_WARNING_UNIMPLEMENTED => Self::Unimplemented,
4325 value => Self::__Unknown(value),
4326 }
4327 }
4328}
4329
4330#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4332#[non_exhaustive]
4333#[doc(alias = "GtkDeleteType")]
4334pub enum DeleteType {
4335 #[doc(alias = "GTK_DELETE_CHARS")]
4337 Chars,
4338 #[doc(alias = "GTK_DELETE_WORD_ENDS")]
4341 WordEnds,
4342 #[doc(alias = "GTK_DELETE_WORDS")]
4344 Words,
4345 #[doc(alias = "GTK_DELETE_DISPLAY_LINES")]
4350 DisplayLines,
4351 #[doc(alias = "GTK_DELETE_DISPLAY_LINE_ENDS")]
4354 DisplayLineEnds,
4355 #[doc(alias = "GTK_DELETE_PARAGRAPH_ENDS")]
4358 ParagraphEnds,
4359 #[doc(alias = "GTK_DELETE_PARAGRAPHS")]
4361 Paragraphs,
4362 #[doc(alias = "GTK_DELETE_WHITESPACE")]
4364 Whitespace,
4365 #[doc(hidden)]
4366 __Unknown(i32),
4367}
4368
4369#[doc(hidden)]
4370impl IntoGlib for DeleteType {
4371 type GlibType = ffi::GtkDeleteType;
4372
4373 #[inline]
4374 fn into_glib(self) -> ffi::GtkDeleteType {
4375 match self {
4376 Self::Chars => ffi::GTK_DELETE_CHARS,
4377 Self::WordEnds => ffi::GTK_DELETE_WORD_ENDS,
4378 Self::Words => ffi::GTK_DELETE_WORDS,
4379 Self::DisplayLines => ffi::GTK_DELETE_DISPLAY_LINES,
4380 Self::DisplayLineEnds => ffi::GTK_DELETE_DISPLAY_LINE_ENDS,
4381 Self::ParagraphEnds => ffi::GTK_DELETE_PARAGRAPH_ENDS,
4382 Self::Paragraphs => ffi::GTK_DELETE_PARAGRAPHS,
4383 Self::Whitespace => ffi::GTK_DELETE_WHITESPACE,
4384 Self::__Unknown(value) => value,
4385 }
4386 }
4387}
4388
4389#[doc(hidden)]
4390impl FromGlib<ffi::GtkDeleteType> for DeleteType {
4391 #[inline]
4392 unsafe fn from_glib(value: ffi::GtkDeleteType) -> Self {
4393 skip_assert_initialized!();
4394
4395 match value {
4396 ffi::GTK_DELETE_CHARS => Self::Chars,
4397 ffi::GTK_DELETE_WORD_ENDS => Self::WordEnds,
4398 ffi::GTK_DELETE_WORDS => Self::Words,
4399 ffi::GTK_DELETE_DISPLAY_LINES => Self::DisplayLines,
4400 ffi::GTK_DELETE_DISPLAY_LINE_ENDS => Self::DisplayLineEnds,
4401 ffi::GTK_DELETE_PARAGRAPH_ENDS => Self::ParagraphEnds,
4402 ffi::GTK_DELETE_PARAGRAPHS => Self::Paragraphs,
4403 ffi::GTK_DELETE_WHITESPACE => Self::Whitespace,
4404 value => Self::__Unknown(value),
4405 }
4406 }
4407}
4408
4409impl StaticType for DeleteType {
4410 #[inline]
4411 #[doc(alias = "gtk_delete_type_get_type")]
4412 fn static_type() -> glib::Type {
4413 unsafe { from_glib(ffi::gtk_delete_type_get_type()) }
4414 }
4415}
4416
4417impl glib::HasParamSpec for DeleteType {
4418 type ParamSpec = glib::ParamSpecEnum;
4419 type SetValue = Self;
4420 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4421
4422 fn param_spec_builder() -> Self::BuilderFn {
4423 Self::ParamSpec::builder_with_default
4424 }
4425}
4426
4427impl glib::value::ValueType for DeleteType {
4428 type Type = Self;
4429}
4430
4431unsafe impl<'a> glib::value::FromValue<'a> for DeleteType {
4432 type Checker = glib::value::GenericValueTypeChecker<Self>;
4433
4434 #[inline]
4435 unsafe fn from_value(value: &'a glib::Value) -> Self {
4436 skip_assert_initialized!();
4437 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4438 }
4439}
4440
4441impl ToValue for DeleteType {
4442 #[inline]
4443 fn to_value(&self) -> glib::Value {
4444 let mut value = glib::Value::for_value_type::<Self>();
4445 unsafe {
4446 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4447 }
4448 value
4449 }
4450
4451 #[inline]
4452 fn value_type(&self) -> glib::Type {
4453 Self::static_type()
4454 }
4455}
4456
4457impl From<DeleteType> for glib::Value {
4458 #[inline]
4459 fn from(v: DeleteType) -> Self {
4460 skip_assert_initialized!();
4461 ToValue::to_value(&v)
4462 }
4463}
4464
4465#[cfg(feature = "v4_10")]
4468#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
4469#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4470#[non_exhaustive]
4471#[doc(alias = "GtkDialogError")]
4472pub enum DialogError {
4473 #[doc(alias = "GTK_DIALOG_ERROR_FAILED")]
4476 Failed,
4477 #[doc(alias = "GTK_DIALOG_ERROR_CANCELLED")]
4480 Cancelled,
4481 #[doc(alias = "GTK_DIALOG_ERROR_DISMISSED")]
4484 Dismissed,
4485 #[doc(hidden)]
4486 __Unknown(i32),
4487}
4488
4489#[cfg(feature = "v4_10")]
4490#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
4491#[doc(hidden)]
4492impl IntoGlib for DialogError {
4493 type GlibType = ffi::GtkDialogError;
4494
4495 #[inline]
4496 fn into_glib(self) -> ffi::GtkDialogError {
4497 match self {
4498 Self::Failed => ffi::GTK_DIALOG_ERROR_FAILED,
4499 Self::Cancelled => ffi::GTK_DIALOG_ERROR_CANCELLED,
4500 Self::Dismissed => ffi::GTK_DIALOG_ERROR_DISMISSED,
4501 Self::__Unknown(value) => value,
4502 }
4503 }
4504}
4505
4506#[cfg(feature = "v4_10")]
4507#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
4508#[doc(hidden)]
4509impl FromGlib<ffi::GtkDialogError> for DialogError {
4510 #[inline]
4511 unsafe fn from_glib(value: ffi::GtkDialogError) -> Self {
4512 skip_assert_initialized!();
4513
4514 match value {
4515 ffi::GTK_DIALOG_ERROR_FAILED => Self::Failed,
4516 ffi::GTK_DIALOG_ERROR_CANCELLED => Self::Cancelled,
4517 ffi::GTK_DIALOG_ERROR_DISMISSED => Self::Dismissed,
4518 value => Self::__Unknown(value),
4519 }
4520 }
4521}
4522
4523#[cfg(feature = "v4_10")]
4524#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
4525impl glib::error::ErrorDomain for DialogError {
4526 #[inline]
4527 fn domain() -> glib::Quark {
4528 skip_assert_initialized!();
4529
4530 unsafe { from_glib(ffi::gtk_dialog_error_quark()) }
4531 }
4532
4533 #[inline]
4534 fn code(self) -> i32 {
4535 self.into_glib()
4536 }
4537
4538 #[inline]
4539 #[allow(clippy::match_single_binding)]
4540 fn from(code: i32) -> Option<Self> {
4541 skip_assert_initialized!();
4542 match unsafe { from_glib(code) } {
4543 Self::__Unknown(_) => Some(Self::Failed),
4544 value => Some(value),
4545 }
4546 }
4547}
4548
4549#[cfg(feature = "v4_10")]
4550#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
4551impl StaticType for DialogError {
4552 #[inline]
4553 #[doc(alias = "gtk_dialog_error_get_type")]
4554 fn static_type() -> glib::Type {
4555 unsafe { from_glib(ffi::gtk_dialog_error_get_type()) }
4556 }
4557}
4558
4559#[cfg(feature = "v4_10")]
4560#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
4561impl glib::HasParamSpec for DialogError {
4562 type ParamSpec = glib::ParamSpecEnum;
4563 type SetValue = Self;
4564 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4565
4566 fn param_spec_builder() -> Self::BuilderFn {
4567 Self::ParamSpec::builder_with_default
4568 }
4569}
4570
4571#[cfg(feature = "v4_10")]
4572#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
4573impl glib::value::ValueType for DialogError {
4574 type Type = Self;
4575}
4576
4577#[cfg(feature = "v4_10")]
4578#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
4579unsafe impl<'a> glib::value::FromValue<'a> for DialogError {
4580 type Checker = glib::value::GenericValueTypeChecker<Self>;
4581
4582 #[inline]
4583 unsafe fn from_value(value: &'a glib::Value) -> Self {
4584 skip_assert_initialized!();
4585 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4586 }
4587}
4588
4589#[cfg(feature = "v4_10")]
4590#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
4591impl ToValue for DialogError {
4592 #[inline]
4593 fn to_value(&self) -> glib::Value {
4594 let mut value = glib::Value::for_value_type::<Self>();
4595 unsafe {
4596 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4597 }
4598 value
4599 }
4600
4601 #[inline]
4602 fn value_type(&self) -> glib::Type {
4603 Self::static_type()
4604 }
4605}
4606
4607#[cfg(feature = "v4_10")]
4608#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
4609impl From<DialogError> for glib::Value {
4610 #[inline]
4611 fn from(v: DialogError) -> Self {
4612 skip_assert_initialized!();
4613 ToValue::to_value(&v)
4614 }
4615}
4616
4617#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4619#[non_exhaustive]
4620#[doc(alias = "GtkDirectionType")]
4621pub enum DirectionType {
4622 #[doc(alias = "GTK_DIR_TAB_FORWARD")]
4624 TabForward,
4625 #[doc(alias = "GTK_DIR_TAB_BACKWARD")]
4627 TabBackward,
4628 #[doc(alias = "GTK_DIR_UP")]
4630 Up,
4631 #[doc(alias = "GTK_DIR_DOWN")]
4633 Down,
4634 #[doc(alias = "GTK_DIR_LEFT")]
4636 Left,
4637 #[doc(alias = "GTK_DIR_RIGHT")]
4639 Right,
4640 #[doc(hidden)]
4641 __Unknown(i32),
4642}
4643
4644#[doc(hidden)]
4645impl IntoGlib for DirectionType {
4646 type GlibType = ffi::GtkDirectionType;
4647
4648 #[inline]
4649 fn into_glib(self) -> ffi::GtkDirectionType {
4650 match self {
4651 Self::TabForward => ffi::GTK_DIR_TAB_FORWARD,
4652 Self::TabBackward => ffi::GTK_DIR_TAB_BACKWARD,
4653 Self::Up => ffi::GTK_DIR_UP,
4654 Self::Down => ffi::GTK_DIR_DOWN,
4655 Self::Left => ffi::GTK_DIR_LEFT,
4656 Self::Right => ffi::GTK_DIR_RIGHT,
4657 Self::__Unknown(value) => value,
4658 }
4659 }
4660}
4661
4662#[doc(hidden)]
4663impl FromGlib<ffi::GtkDirectionType> for DirectionType {
4664 #[inline]
4665 unsafe fn from_glib(value: ffi::GtkDirectionType) -> Self {
4666 skip_assert_initialized!();
4667
4668 match value {
4669 ffi::GTK_DIR_TAB_FORWARD => Self::TabForward,
4670 ffi::GTK_DIR_TAB_BACKWARD => Self::TabBackward,
4671 ffi::GTK_DIR_UP => Self::Up,
4672 ffi::GTK_DIR_DOWN => Self::Down,
4673 ffi::GTK_DIR_LEFT => Self::Left,
4674 ffi::GTK_DIR_RIGHT => Self::Right,
4675 value => Self::__Unknown(value),
4676 }
4677 }
4678}
4679
4680impl StaticType for DirectionType {
4681 #[inline]
4682 #[doc(alias = "gtk_direction_type_get_type")]
4683 fn static_type() -> glib::Type {
4684 unsafe { from_glib(ffi::gtk_direction_type_get_type()) }
4685 }
4686}
4687
4688impl glib::HasParamSpec for DirectionType {
4689 type ParamSpec = glib::ParamSpecEnum;
4690 type SetValue = Self;
4691 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4692
4693 fn param_spec_builder() -> Self::BuilderFn {
4694 Self::ParamSpec::builder_with_default
4695 }
4696}
4697
4698impl glib::value::ValueType for DirectionType {
4699 type Type = Self;
4700}
4701
4702unsafe impl<'a> glib::value::FromValue<'a> for DirectionType {
4703 type Checker = glib::value::GenericValueTypeChecker<Self>;
4704
4705 #[inline]
4706 unsafe fn from_value(value: &'a glib::Value) -> Self {
4707 skip_assert_initialized!();
4708 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4709 }
4710}
4711
4712impl ToValue for DirectionType {
4713 #[inline]
4714 fn to_value(&self) -> glib::Value {
4715 let mut value = glib::Value::for_value_type::<Self>();
4716 unsafe {
4717 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4718 }
4719 value
4720 }
4721
4722 #[inline]
4723 fn value_type(&self) -> glib::Type {
4724 Self::static_type()
4725 }
4726}
4727
4728impl From<DirectionType> for glib::Value {
4729 #[inline]
4730 fn from(v: DirectionType) -> Self {
4731 skip_assert_initialized!();
4732 ToValue::to_value(&v)
4733 }
4734}
4735
4736#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4741#[non_exhaustive]
4742#[doc(alias = "GtkEditableProperties")]
4743pub enum EditableProperties {
4744 #[doc(alias = "GTK_EDITABLE_PROP_TEXT")]
4746 PropText,
4747 #[doc(alias = "GTK_EDITABLE_PROP_CURSOR_POSITION")]
4749 PropCursorPosition,
4750 #[doc(alias = "GTK_EDITABLE_PROP_SELECTION_BOUND")]
4752 PropSelectionBound,
4753 #[doc(alias = "GTK_EDITABLE_PROP_EDITABLE")]
4755 PropEditable,
4756 #[doc(alias = "GTK_EDITABLE_PROP_WIDTH_CHARS")]
4758 PropWidthChars,
4759 #[doc(alias = "GTK_EDITABLE_PROP_MAX_WIDTH_CHARS")]
4761 PropMaxWidthChars,
4762 #[doc(alias = "GTK_EDITABLE_PROP_XALIGN")]
4764 PropXalign,
4765 #[doc(alias = "GTK_EDITABLE_PROP_ENABLE_UNDO")]
4767 PropEnableUndo,
4768 #[doc(alias = "GTK_EDITABLE_NUM_PROPERTIES")]
4770 NumProperties,
4771 #[doc(hidden)]
4772 __Unknown(i32),
4773}
4774
4775#[doc(hidden)]
4776impl IntoGlib for EditableProperties {
4777 type GlibType = ffi::GtkEditableProperties;
4778
4779 #[inline]
4780 fn into_glib(self) -> ffi::GtkEditableProperties {
4781 match self {
4782 Self::PropText => ffi::GTK_EDITABLE_PROP_TEXT,
4783 Self::PropCursorPosition => ffi::GTK_EDITABLE_PROP_CURSOR_POSITION,
4784 Self::PropSelectionBound => ffi::GTK_EDITABLE_PROP_SELECTION_BOUND,
4785 Self::PropEditable => ffi::GTK_EDITABLE_PROP_EDITABLE,
4786 Self::PropWidthChars => ffi::GTK_EDITABLE_PROP_WIDTH_CHARS,
4787 Self::PropMaxWidthChars => ffi::GTK_EDITABLE_PROP_MAX_WIDTH_CHARS,
4788 Self::PropXalign => ffi::GTK_EDITABLE_PROP_XALIGN,
4789 Self::PropEnableUndo => ffi::GTK_EDITABLE_PROP_ENABLE_UNDO,
4790 Self::NumProperties => ffi::GTK_EDITABLE_NUM_PROPERTIES,
4791 Self::__Unknown(value) => value,
4792 }
4793 }
4794}
4795
4796#[doc(hidden)]
4797impl FromGlib<ffi::GtkEditableProperties> for EditableProperties {
4798 #[inline]
4799 unsafe fn from_glib(value: ffi::GtkEditableProperties) -> Self {
4800 skip_assert_initialized!();
4801
4802 match value {
4803 ffi::GTK_EDITABLE_PROP_TEXT => Self::PropText,
4804 ffi::GTK_EDITABLE_PROP_CURSOR_POSITION => Self::PropCursorPosition,
4805 ffi::GTK_EDITABLE_PROP_SELECTION_BOUND => Self::PropSelectionBound,
4806 ffi::GTK_EDITABLE_PROP_EDITABLE => Self::PropEditable,
4807 ffi::GTK_EDITABLE_PROP_WIDTH_CHARS => Self::PropWidthChars,
4808 ffi::GTK_EDITABLE_PROP_MAX_WIDTH_CHARS => Self::PropMaxWidthChars,
4809 ffi::GTK_EDITABLE_PROP_XALIGN => Self::PropXalign,
4810 ffi::GTK_EDITABLE_PROP_ENABLE_UNDO => Self::PropEnableUndo,
4811 ffi::GTK_EDITABLE_NUM_PROPERTIES => Self::NumProperties,
4812 value => Self::__Unknown(value),
4813 }
4814 }
4815}
4816
4817impl StaticType for EditableProperties {
4818 #[inline]
4819 #[doc(alias = "gtk_editable_properties_get_type")]
4820 fn static_type() -> glib::Type {
4821 unsafe { from_glib(ffi::gtk_editable_properties_get_type()) }
4822 }
4823}
4824
4825impl glib::HasParamSpec for EditableProperties {
4826 type ParamSpec = glib::ParamSpecEnum;
4827 type SetValue = Self;
4828 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4829
4830 fn param_spec_builder() -> Self::BuilderFn {
4831 Self::ParamSpec::builder_with_default
4832 }
4833}
4834
4835impl glib::value::ValueType for EditableProperties {
4836 type Type = Self;
4837}
4838
4839unsafe impl<'a> glib::value::FromValue<'a> for EditableProperties {
4840 type Checker = glib::value::GenericValueTypeChecker<Self>;
4841
4842 #[inline]
4843 unsafe fn from_value(value: &'a glib::Value) -> Self {
4844 skip_assert_initialized!();
4845 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4846 }
4847}
4848
4849impl ToValue for EditableProperties {
4850 #[inline]
4851 fn to_value(&self) -> glib::Value {
4852 let mut value = glib::Value::for_value_type::<Self>();
4853 unsafe {
4854 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4855 }
4856 value
4857 }
4858
4859 #[inline]
4860 fn value_type(&self) -> glib::Type {
4861 Self::static_type()
4862 }
4863}
4864
4865impl From<EditableProperties> for glib::Value {
4866 #[inline]
4867 fn from(v: EditableProperties) -> Self {
4868 skip_assert_initialized!();
4869 ToValue::to_value(&v)
4870 }
4871}
4872
4873#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4875#[non_exhaustive]
4876#[doc(alias = "GtkEntryIconPosition")]
4877pub enum EntryIconPosition {
4878 #[doc(alias = "GTK_ENTRY_ICON_PRIMARY")]
4880 Primary,
4881 #[doc(alias = "GTK_ENTRY_ICON_SECONDARY")]
4883 Secondary,
4884 #[doc(hidden)]
4885 __Unknown(i32),
4886}
4887
4888#[doc(hidden)]
4889impl IntoGlib for EntryIconPosition {
4890 type GlibType = ffi::GtkEntryIconPosition;
4891
4892 #[inline]
4893 fn into_glib(self) -> ffi::GtkEntryIconPosition {
4894 match self {
4895 Self::Primary => ffi::GTK_ENTRY_ICON_PRIMARY,
4896 Self::Secondary => ffi::GTK_ENTRY_ICON_SECONDARY,
4897 Self::__Unknown(value) => value,
4898 }
4899 }
4900}
4901
4902#[doc(hidden)]
4903impl FromGlib<ffi::GtkEntryIconPosition> for EntryIconPosition {
4904 #[inline]
4905 unsafe fn from_glib(value: ffi::GtkEntryIconPosition) -> Self {
4906 skip_assert_initialized!();
4907
4908 match value {
4909 ffi::GTK_ENTRY_ICON_PRIMARY => Self::Primary,
4910 ffi::GTK_ENTRY_ICON_SECONDARY => Self::Secondary,
4911 value => Self::__Unknown(value),
4912 }
4913 }
4914}
4915
4916impl StaticType for EntryIconPosition {
4917 #[inline]
4918 #[doc(alias = "gtk_entry_icon_position_get_type")]
4919 fn static_type() -> glib::Type {
4920 unsafe { from_glib(ffi::gtk_entry_icon_position_get_type()) }
4921 }
4922}
4923
4924impl glib::HasParamSpec for EntryIconPosition {
4925 type ParamSpec = glib::ParamSpecEnum;
4926 type SetValue = Self;
4927 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4928
4929 fn param_spec_builder() -> Self::BuilderFn {
4930 Self::ParamSpec::builder_with_default
4931 }
4932}
4933
4934impl glib::value::ValueType for EntryIconPosition {
4935 type Type = Self;
4936}
4937
4938unsafe impl<'a> glib::value::FromValue<'a> for EntryIconPosition {
4939 type Checker = glib::value::GenericValueTypeChecker<Self>;
4940
4941 #[inline]
4942 unsafe fn from_value(value: &'a glib::Value) -> Self {
4943 skip_assert_initialized!();
4944 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4945 }
4946}
4947
4948impl ToValue for EntryIconPosition {
4949 #[inline]
4950 fn to_value(&self) -> glib::Value {
4951 let mut value = glib::Value::for_value_type::<Self>();
4952 unsafe {
4953 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4954 }
4955 value
4956 }
4957
4958 #[inline]
4959 fn value_type(&self) -> glib::Type {
4960 Self::static_type()
4961 }
4962}
4963
4964impl From<EntryIconPosition> for glib::Value {
4965 #[inline]
4966 fn from(v: EntryIconPosition) -> Self {
4967 skip_assert_initialized!();
4968 ToValue::to_value(&v)
4969 }
4970}
4971
4972#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4974#[non_exhaustive]
4975#[doc(alias = "GtkEventSequenceState")]
4976pub enum EventSequenceState {
4977 #[doc(alias = "GTK_EVENT_SEQUENCE_NONE")]
4979 None,
4980 #[doc(alias = "GTK_EVENT_SEQUENCE_CLAIMED")]
4982 Claimed,
4983 #[doc(alias = "GTK_EVENT_SEQUENCE_DENIED")]
4985 Denied,
4986 #[doc(hidden)]
4987 __Unknown(i32),
4988}
4989
4990#[doc(hidden)]
4991impl IntoGlib for EventSequenceState {
4992 type GlibType = ffi::GtkEventSequenceState;
4993
4994 #[inline]
4995 fn into_glib(self) -> ffi::GtkEventSequenceState {
4996 match self {
4997 Self::None => ffi::GTK_EVENT_SEQUENCE_NONE,
4998 Self::Claimed => ffi::GTK_EVENT_SEQUENCE_CLAIMED,
4999 Self::Denied => ffi::GTK_EVENT_SEQUENCE_DENIED,
5000 Self::__Unknown(value) => value,
5001 }
5002 }
5003}
5004
5005#[doc(hidden)]
5006impl FromGlib<ffi::GtkEventSequenceState> for EventSequenceState {
5007 #[inline]
5008 unsafe fn from_glib(value: ffi::GtkEventSequenceState) -> Self {
5009 skip_assert_initialized!();
5010
5011 match value {
5012 ffi::GTK_EVENT_SEQUENCE_NONE => Self::None,
5013 ffi::GTK_EVENT_SEQUENCE_CLAIMED => Self::Claimed,
5014 ffi::GTK_EVENT_SEQUENCE_DENIED => Self::Denied,
5015 value => Self::__Unknown(value),
5016 }
5017 }
5018}
5019
5020impl StaticType for EventSequenceState {
5021 #[inline]
5022 #[doc(alias = "gtk_event_sequence_state_get_type")]
5023 fn static_type() -> glib::Type {
5024 unsafe { from_glib(ffi::gtk_event_sequence_state_get_type()) }
5025 }
5026}
5027
5028impl glib::HasParamSpec for EventSequenceState {
5029 type ParamSpec = glib::ParamSpecEnum;
5030 type SetValue = Self;
5031 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5032
5033 fn param_spec_builder() -> Self::BuilderFn {
5034 Self::ParamSpec::builder_with_default
5035 }
5036}
5037
5038impl glib::value::ValueType for EventSequenceState {
5039 type Type = Self;
5040}
5041
5042unsafe impl<'a> glib::value::FromValue<'a> for EventSequenceState {
5043 type Checker = glib::value::GenericValueTypeChecker<Self>;
5044
5045 #[inline]
5046 unsafe fn from_value(value: &'a glib::Value) -> Self {
5047 skip_assert_initialized!();
5048 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5049 }
5050}
5051
5052impl ToValue for EventSequenceState {
5053 #[inline]
5054 fn to_value(&self) -> glib::Value {
5055 let mut value = glib::Value::for_value_type::<Self>();
5056 unsafe {
5057 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5058 }
5059 value
5060 }
5061
5062 #[inline]
5063 fn value_type(&self) -> glib::Type {
5064 Self::static_type()
5065 }
5066}
5067
5068impl From<EventSequenceState> for glib::Value {
5069 #[inline]
5070 fn from(v: EventSequenceState) -> Self {
5071 skip_assert_initialized!();
5072 ToValue::to_value(&v)
5073 }
5074}
5075
5076#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5079#[non_exhaustive]
5080#[doc(alias = "GtkFileChooserAction")]
5081pub enum FileChooserAction {
5082 #[doc(alias = "GTK_FILE_CHOOSER_ACTION_OPEN")]
5085 Open,
5086 #[doc(alias = "GTK_FILE_CHOOSER_ACTION_SAVE")]
5090 Save,
5091 #[doc(alias = "GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER")]
5095 SelectFolder,
5096 #[doc(hidden)]
5097 __Unknown(i32),
5098}
5099
5100#[doc(hidden)]
5101impl IntoGlib for FileChooserAction {
5102 type GlibType = ffi::GtkFileChooserAction;
5103
5104 #[inline]
5105 fn into_glib(self) -> ffi::GtkFileChooserAction {
5106 match self {
5107 Self::Open => ffi::GTK_FILE_CHOOSER_ACTION_OPEN,
5108 Self::Save => ffi::GTK_FILE_CHOOSER_ACTION_SAVE,
5109 Self::SelectFolder => ffi::GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
5110 Self::__Unknown(value) => value,
5111 }
5112 }
5113}
5114
5115#[doc(hidden)]
5116impl FromGlib<ffi::GtkFileChooserAction> for FileChooserAction {
5117 #[inline]
5118 unsafe fn from_glib(value: ffi::GtkFileChooserAction) -> Self {
5119 skip_assert_initialized!();
5120
5121 match value {
5122 ffi::GTK_FILE_CHOOSER_ACTION_OPEN => Self::Open,
5123 ffi::GTK_FILE_CHOOSER_ACTION_SAVE => Self::Save,
5124 ffi::GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER => Self::SelectFolder,
5125 value => Self::__Unknown(value),
5126 }
5127 }
5128}
5129
5130impl StaticType for FileChooserAction {
5131 #[inline]
5132 #[doc(alias = "gtk_file_chooser_action_get_type")]
5133 fn static_type() -> glib::Type {
5134 unsafe { from_glib(ffi::gtk_file_chooser_action_get_type()) }
5135 }
5136}
5137
5138impl glib::HasParamSpec for FileChooserAction {
5139 type ParamSpec = glib::ParamSpecEnum;
5140 type SetValue = Self;
5141 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5142
5143 fn param_spec_builder() -> Self::BuilderFn {
5144 Self::ParamSpec::builder_with_default
5145 }
5146}
5147
5148impl glib::value::ValueType for FileChooserAction {
5149 type Type = Self;
5150}
5151
5152unsafe impl<'a> glib::value::FromValue<'a> for FileChooserAction {
5153 type Checker = glib::value::GenericValueTypeChecker<Self>;
5154
5155 #[inline]
5156 unsafe fn from_value(value: &'a glib::Value) -> Self {
5157 skip_assert_initialized!();
5158 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5159 }
5160}
5161
5162impl ToValue for FileChooserAction {
5163 #[inline]
5164 fn to_value(&self) -> glib::Value {
5165 let mut value = glib::Value::for_value_type::<Self>();
5166 unsafe {
5167 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5168 }
5169 value
5170 }
5171
5172 #[inline]
5173 fn value_type(&self) -> glib::Type {
5174 Self::static_type()
5175 }
5176}
5177
5178impl From<FileChooserAction> for glib::Value {
5179 #[inline]
5180 fn from(v: FileChooserAction) -> Self {
5181 skip_assert_initialized!();
5182 ToValue::to_value(&v)
5183 }
5184}
5185
5186#[cfg_attr(feature = "v4_20", deprecated = "Since 4.20")]
5193#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5194#[non_exhaustive]
5195#[doc(alias = "GtkFileChooserError")]
5196pub enum FileChooserError {
5197 #[doc(alias = "GTK_FILE_CHOOSER_ERROR_NONEXISTENT")]
5199 Nonexistent,
5200 #[doc(alias = "GTK_FILE_CHOOSER_ERROR_BAD_FILENAME")]
5202 BadFilename,
5203 #[doc(alias = "GTK_FILE_CHOOSER_ERROR_ALREADY_EXISTS")]
5206 AlreadyExists,
5207 #[doc(alias = "GTK_FILE_CHOOSER_ERROR_INCOMPLETE_HOSTNAME")]
5210 IncompleteHostname,
5211 #[doc(hidden)]
5212 __Unknown(i32),
5213}
5214
5215#[allow(deprecated)]
5216#[doc(hidden)]
5217impl IntoGlib for FileChooserError {
5218 type GlibType = ffi::GtkFileChooserError;
5219
5220 #[inline]
5221 fn into_glib(self) -> ffi::GtkFileChooserError {
5222 match self {
5223 Self::Nonexistent => ffi::GTK_FILE_CHOOSER_ERROR_NONEXISTENT,
5224 Self::BadFilename => ffi::GTK_FILE_CHOOSER_ERROR_BAD_FILENAME,
5225 Self::AlreadyExists => ffi::GTK_FILE_CHOOSER_ERROR_ALREADY_EXISTS,
5226 Self::IncompleteHostname => ffi::GTK_FILE_CHOOSER_ERROR_INCOMPLETE_HOSTNAME,
5227 Self::__Unknown(value) => value,
5228 }
5229 }
5230}
5231
5232#[allow(deprecated)]
5233#[doc(hidden)]
5234impl FromGlib<ffi::GtkFileChooserError> for FileChooserError {
5235 #[inline]
5236 unsafe fn from_glib(value: ffi::GtkFileChooserError) -> Self {
5237 skip_assert_initialized!();
5238
5239 match value {
5240 ffi::GTK_FILE_CHOOSER_ERROR_NONEXISTENT => Self::Nonexistent,
5241 ffi::GTK_FILE_CHOOSER_ERROR_BAD_FILENAME => Self::BadFilename,
5242 ffi::GTK_FILE_CHOOSER_ERROR_ALREADY_EXISTS => Self::AlreadyExists,
5243 ffi::GTK_FILE_CHOOSER_ERROR_INCOMPLETE_HOSTNAME => Self::IncompleteHostname,
5244 value => Self::__Unknown(value),
5245 }
5246 }
5247}
5248
5249#[allow(deprecated)]
5250impl glib::error::ErrorDomain for FileChooserError {
5251 #[inline]
5252 fn domain() -> glib::Quark {
5253 skip_assert_initialized!();
5254
5255 unsafe { from_glib(ffi::gtk_file_chooser_error_quark()) }
5256 }
5257
5258 #[inline]
5259 fn code(self) -> i32 {
5260 self.into_glib()
5261 }
5262
5263 #[inline]
5264 #[allow(clippy::match_single_binding)]
5265 fn from(code: i32) -> Option<Self> {
5266 skip_assert_initialized!();
5267 match unsafe { from_glib(code) } {
5268 value => Some(value),
5269 }
5270 }
5271}
5272
5273#[allow(deprecated)]
5274impl StaticType for FileChooserError {
5275 #[inline]
5276 #[doc(alias = "gtk_file_chooser_error_get_type")]
5277 fn static_type() -> glib::Type {
5278 unsafe { from_glib(ffi::gtk_file_chooser_error_get_type()) }
5279 }
5280}
5281
5282#[allow(deprecated)]
5283impl glib::HasParamSpec for FileChooserError {
5284 type ParamSpec = glib::ParamSpecEnum;
5285 type SetValue = Self;
5286 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5287
5288 fn param_spec_builder() -> Self::BuilderFn {
5289 Self::ParamSpec::builder_with_default
5290 }
5291}
5292
5293#[allow(deprecated)]
5294impl glib::value::ValueType for FileChooserError {
5295 type Type = Self;
5296}
5297
5298#[allow(deprecated)]
5299unsafe impl<'a> glib::value::FromValue<'a> for FileChooserError {
5300 type Checker = glib::value::GenericValueTypeChecker<Self>;
5301
5302 #[inline]
5303 unsafe fn from_value(value: &'a glib::Value) -> Self {
5304 skip_assert_initialized!();
5305 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5306 }
5307}
5308
5309#[allow(deprecated)]
5310impl ToValue for FileChooserError {
5311 #[inline]
5312 fn to_value(&self) -> glib::Value {
5313 let mut value = glib::Value::for_value_type::<Self>();
5314 unsafe {
5315 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5316 }
5317 value
5318 }
5319
5320 #[inline]
5321 fn value_type(&self) -> glib::Type {
5322 Self::static_type()
5323 }
5324}
5325
5326#[allow(deprecated)]
5327impl From<FileChooserError> for glib::Value {
5328 #[inline]
5329 fn from(v: FileChooserError) -> Self {
5330 skip_assert_initialized!();
5331 ToValue::to_value(&v)
5332 }
5333}
5334
5335#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5342#[non_exhaustive]
5343#[doc(alias = "GtkFilterChange")]
5344pub enum FilterChange {
5345 #[doc(alias = "GTK_FILTER_CHANGE_DIFFERENT")]
5348 Different,
5349 #[doc(alias = "GTK_FILTER_CHANGE_LESS_STRICT")]
5353 LessStrict,
5354 #[doc(alias = "GTK_FILTER_CHANGE_MORE_STRICT")]
5358 MoreStrict,
5359 #[doc(hidden)]
5360 __Unknown(i32),
5361}
5362
5363#[doc(hidden)]
5364impl IntoGlib for FilterChange {
5365 type GlibType = ffi::GtkFilterChange;
5366
5367 #[inline]
5368 fn into_glib(self) -> ffi::GtkFilterChange {
5369 match self {
5370 Self::Different => ffi::GTK_FILTER_CHANGE_DIFFERENT,
5371 Self::LessStrict => ffi::GTK_FILTER_CHANGE_LESS_STRICT,
5372 Self::MoreStrict => ffi::GTK_FILTER_CHANGE_MORE_STRICT,
5373 Self::__Unknown(value) => value,
5374 }
5375 }
5376}
5377
5378#[doc(hidden)]
5379impl FromGlib<ffi::GtkFilterChange> for FilterChange {
5380 #[inline]
5381 unsafe fn from_glib(value: ffi::GtkFilterChange) -> Self {
5382 skip_assert_initialized!();
5383
5384 match value {
5385 ffi::GTK_FILTER_CHANGE_DIFFERENT => Self::Different,
5386 ffi::GTK_FILTER_CHANGE_LESS_STRICT => Self::LessStrict,
5387 ffi::GTK_FILTER_CHANGE_MORE_STRICT => Self::MoreStrict,
5388 value => Self::__Unknown(value),
5389 }
5390 }
5391}
5392
5393impl StaticType for FilterChange {
5394 #[inline]
5395 #[doc(alias = "gtk_filter_change_get_type")]
5396 fn static_type() -> glib::Type {
5397 unsafe { from_glib(ffi::gtk_filter_change_get_type()) }
5398 }
5399}
5400
5401impl glib::HasParamSpec for FilterChange {
5402 type ParamSpec = glib::ParamSpecEnum;
5403 type SetValue = Self;
5404 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5405
5406 fn param_spec_builder() -> Self::BuilderFn {
5407 Self::ParamSpec::builder_with_default
5408 }
5409}
5410
5411impl glib::value::ValueType for FilterChange {
5412 type Type = Self;
5413}
5414
5415unsafe impl<'a> glib::value::FromValue<'a> for FilterChange {
5416 type Checker = glib::value::GenericValueTypeChecker<Self>;
5417
5418 #[inline]
5419 unsafe fn from_value(value: &'a glib::Value) -> Self {
5420 skip_assert_initialized!();
5421 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5422 }
5423}
5424
5425impl ToValue for FilterChange {
5426 #[inline]
5427 fn to_value(&self) -> glib::Value {
5428 let mut value = glib::Value::for_value_type::<Self>();
5429 unsafe {
5430 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5431 }
5432 value
5433 }
5434
5435 #[inline]
5436 fn value_type(&self) -> glib::Type {
5437 Self::static_type()
5438 }
5439}
5440
5441impl From<FilterChange> for glib::Value {
5442 #[inline]
5443 fn from(v: FilterChange) -> Self {
5444 skip_assert_initialized!();
5445 ToValue::to_value(&v)
5446 }
5447}
5448
5449#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5455#[non_exhaustive]
5456#[doc(alias = "GtkFilterMatch")]
5457pub enum FilterMatch {
5458 #[doc(alias = "GTK_FILTER_MATCH_SOME")]
5461 Some,
5462 #[doc(alias = "GTK_FILTER_MATCH_NONE")]
5465 None,
5466 #[doc(alias = "GTK_FILTER_MATCH_ALL")]
5469 All,
5470 #[doc(hidden)]
5471 __Unknown(i32),
5472}
5473
5474#[doc(hidden)]
5475impl IntoGlib for FilterMatch {
5476 type GlibType = ffi::GtkFilterMatch;
5477
5478 #[inline]
5479 fn into_glib(self) -> ffi::GtkFilterMatch {
5480 match self {
5481 Self::Some => ffi::GTK_FILTER_MATCH_SOME,
5482 Self::None => ffi::GTK_FILTER_MATCH_NONE,
5483 Self::All => ffi::GTK_FILTER_MATCH_ALL,
5484 Self::__Unknown(value) => value,
5485 }
5486 }
5487}
5488
5489#[doc(hidden)]
5490impl FromGlib<ffi::GtkFilterMatch> for FilterMatch {
5491 #[inline]
5492 unsafe fn from_glib(value: ffi::GtkFilterMatch) -> Self {
5493 skip_assert_initialized!();
5494
5495 match value {
5496 ffi::GTK_FILTER_MATCH_SOME => Self::Some,
5497 ffi::GTK_FILTER_MATCH_NONE => Self::None,
5498 ffi::GTK_FILTER_MATCH_ALL => Self::All,
5499 value => Self::__Unknown(value),
5500 }
5501 }
5502}
5503
5504impl StaticType for FilterMatch {
5505 #[inline]
5506 #[doc(alias = "gtk_filter_match_get_type")]
5507 fn static_type() -> glib::Type {
5508 unsafe { from_glib(ffi::gtk_filter_match_get_type()) }
5509 }
5510}
5511
5512impl glib::HasParamSpec for FilterMatch {
5513 type ParamSpec = glib::ParamSpecEnum;
5514 type SetValue = Self;
5515 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5516
5517 fn param_spec_builder() -> Self::BuilderFn {
5518 Self::ParamSpec::builder_with_default
5519 }
5520}
5521
5522impl glib::value::ValueType for FilterMatch {
5523 type Type = Self;
5524}
5525
5526unsafe impl<'a> glib::value::FromValue<'a> for FilterMatch {
5527 type Checker = glib::value::GenericValueTypeChecker<Self>;
5528
5529 #[inline]
5530 unsafe fn from_value(value: &'a glib::Value) -> Self {
5531 skip_assert_initialized!();
5532 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5533 }
5534}
5535
5536impl ToValue for FilterMatch {
5537 #[inline]
5538 fn to_value(&self) -> glib::Value {
5539 let mut value = glib::Value::for_value_type::<Self>();
5540 unsafe {
5541 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5542 }
5543 value
5544 }
5545
5546 #[inline]
5547 fn value_type(&self) -> glib::Type {
5548 Self::static_type()
5549 }
5550}
5551
5552impl From<FilterMatch> for glib::Value {
5553 #[inline]
5554 fn from(v: FilterMatch) -> Self {
5555 skip_assert_initialized!();
5556 ToValue::to_value(&v)
5557 }
5558}
5559
5560#[cfg(feature = "v4_10")]
5566#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
5567#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5568#[non_exhaustive]
5569#[doc(alias = "GtkFontLevel")]
5570pub enum FontLevel {
5571 #[doc(alias = "GTK_FONT_LEVEL_FAMILY")]
5573 Family,
5574 #[doc(alias = "GTK_FONT_LEVEL_FACE")]
5576 Face,
5577 #[doc(alias = "GTK_FONT_LEVEL_FONT")]
5579 Font,
5580 #[doc(alias = "GTK_FONT_LEVEL_FEATURES")]
5582 Features,
5583 #[doc(hidden)]
5584 __Unknown(i32),
5585}
5586
5587#[cfg(feature = "v4_10")]
5588#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
5589#[doc(hidden)]
5590impl IntoGlib for FontLevel {
5591 type GlibType = ffi::GtkFontLevel;
5592
5593 #[inline]
5594 fn into_glib(self) -> ffi::GtkFontLevel {
5595 match self {
5596 Self::Family => ffi::GTK_FONT_LEVEL_FAMILY,
5597 Self::Face => ffi::GTK_FONT_LEVEL_FACE,
5598 Self::Font => ffi::GTK_FONT_LEVEL_FONT,
5599 Self::Features => ffi::GTK_FONT_LEVEL_FEATURES,
5600 Self::__Unknown(value) => value,
5601 }
5602 }
5603}
5604
5605#[cfg(feature = "v4_10")]
5606#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
5607#[doc(hidden)]
5608impl FromGlib<ffi::GtkFontLevel> for FontLevel {
5609 #[inline]
5610 unsafe fn from_glib(value: ffi::GtkFontLevel) -> Self {
5611 skip_assert_initialized!();
5612
5613 match value {
5614 ffi::GTK_FONT_LEVEL_FAMILY => Self::Family,
5615 ffi::GTK_FONT_LEVEL_FACE => Self::Face,
5616 ffi::GTK_FONT_LEVEL_FONT => Self::Font,
5617 ffi::GTK_FONT_LEVEL_FEATURES => Self::Features,
5618 value => Self::__Unknown(value),
5619 }
5620 }
5621}
5622
5623#[cfg(feature = "v4_10")]
5624#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
5625impl StaticType for FontLevel {
5626 #[inline]
5627 #[doc(alias = "gtk_font_level_get_type")]
5628 fn static_type() -> glib::Type {
5629 unsafe { from_glib(ffi::gtk_font_level_get_type()) }
5630 }
5631}
5632
5633#[cfg(feature = "v4_10")]
5634#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
5635impl glib::HasParamSpec for FontLevel {
5636 type ParamSpec = glib::ParamSpecEnum;
5637 type SetValue = Self;
5638 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5639
5640 fn param_spec_builder() -> Self::BuilderFn {
5641 Self::ParamSpec::builder_with_default
5642 }
5643}
5644
5645#[cfg(feature = "v4_10")]
5646#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
5647impl glib::value::ValueType for FontLevel {
5648 type Type = Self;
5649}
5650
5651#[cfg(feature = "v4_10")]
5652#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
5653unsafe impl<'a> glib::value::FromValue<'a> for FontLevel {
5654 type Checker = glib::value::GenericValueTypeChecker<Self>;
5655
5656 #[inline]
5657 unsafe fn from_value(value: &'a glib::Value) -> Self {
5658 skip_assert_initialized!();
5659 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5660 }
5661}
5662
5663#[cfg(feature = "v4_10")]
5664#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
5665impl ToValue for FontLevel {
5666 #[inline]
5667 fn to_value(&self) -> glib::Value {
5668 let mut value = glib::Value::for_value_type::<Self>();
5669 unsafe {
5670 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5671 }
5672 value
5673 }
5674
5675 #[inline]
5676 fn value_type(&self) -> glib::Type {
5677 Self::static_type()
5678 }
5679}
5680
5681#[cfg(feature = "v4_10")]
5682#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
5683impl From<FontLevel> for glib::Value {
5684 #[inline]
5685 fn from(v: FontLevel) -> Self {
5686 skip_assert_initialized!();
5687 ToValue::to_value(&v)
5688 }
5689}
5690
5691#[cfg(feature = "v4_16")]
5694#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
5695#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5696#[non_exhaustive]
5697#[doc(alias = "GtkFontRendering")]
5698pub enum FontRendering {
5699 #[doc(alias = "GTK_FONT_RENDERING_AUTOMATIC")]
5702 Automatic,
5703 #[doc(alias = "GTK_FONT_RENDERING_MANUAL")]
5706 Manual,
5707 #[doc(hidden)]
5708 __Unknown(i32),
5709}
5710
5711#[cfg(feature = "v4_16")]
5712#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
5713#[doc(hidden)]
5714impl IntoGlib for FontRendering {
5715 type GlibType = ffi::GtkFontRendering;
5716
5717 #[inline]
5718 fn into_glib(self) -> ffi::GtkFontRendering {
5719 match self {
5720 Self::Automatic => ffi::GTK_FONT_RENDERING_AUTOMATIC,
5721 Self::Manual => ffi::GTK_FONT_RENDERING_MANUAL,
5722 Self::__Unknown(value) => value,
5723 }
5724 }
5725}
5726
5727#[cfg(feature = "v4_16")]
5728#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
5729#[doc(hidden)]
5730impl FromGlib<ffi::GtkFontRendering> for FontRendering {
5731 #[inline]
5732 unsafe fn from_glib(value: ffi::GtkFontRendering) -> Self {
5733 skip_assert_initialized!();
5734
5735 match value {
5736 ffi::GTK_FONT_RENDERING_AUTOMATIC => Self::Automatic,
5737 ffi::GTK_FONT_RENDERING_MANUAL => Self::Manual,
5738 value => Self::__Unknown(value),
5739 }
5740 }
5741}
5742
5743#[cfg(feature = "v4_16")]
5744#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
5745impl StaticType for FontRendering {
5746 #[inline]
5747 #[doc(alias = "gtk_font_rendering_get_type")]
5748 fn static_type() -> glib::Type {
5749 unsafe { from_glib(ffi::gtk_font_rendering_get_type()) }
5750 }
5751}
5752
5753#[cfg(feature = "v4_16")]
5754#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
5755impl glib::HasParamSpec for FontRendering {
5756 type ParamSpec = glib::ParamSpecEnum;
5757 type SetValue = Self;
5758 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5759
5760 fn param_spec_builder() -> Self::BuilderFn {
5761 Self::ParamSpec::builder_with_default
5762 }
5763}
5764
5765#[cfg(feature = "v4_16")]
5766#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
5767impl glib::value::ValueType for FontRendering {
5768 type Type = Self;
5769}
5770
5771#[cfg(feature = "v4_16")]
5772#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
5773unsafe impl<'a> glib::value::FromValue<'a> for FontRendering {
5774 type Checker = glib::value::GenericValueTypeChecker<Self>;
5775
5776 #[inline]
5777 unsafe fn from_value(value: &'a glib::Value) -> Self {
5778 skip_assert_initialized!();
5779 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5780 }
5781}
5782
5783#[cfg(feature = "v4_16")]
5784#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
5785impl ToValue for FontRendering {
5786 #[inline]
5787 fn to_value(&self) -> glib::Value {
5788 let mut value = glib::Value::for_value_type::<Self>();
5789 unsafe {
5790 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5791 }
5792 value
5793 }
5794
5795 #[inline]
5796 fn value_type(&self) -> glib::Type {
5797 Self::static_type()
5798 }
5799}
5800
5801#[cfg(feature = "v4_16")]
5802#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
5803impl From<FontRendering> for glib::Value {
5804 #[inline]
5805 fn from(v: FontRendering) -> Self {
5806 skip_assert_initialized!();
5807 ToValue::to_value(&v)
5808 }
5809}
5810
5811#[cfg(feature = "v4_14")]
5813#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
5814#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5815#[non_exhaustive]
5816#[doc(alias = "GtkGraphicsOffloadEnabled")]
5817pub enum GraphicsOffloadEnabled {
5818 #[doc(alias = "GTK_GRAPHICS_OFFLOAD_ENABLED")]
5820 Enabled,
5821 #[doc(alias = "GTK_GRAPHICS_OFFLOAD_DISABLED")]
5823 Disabled,
5824 #[doc(hidden)]
5825 __Unknown(i32),
5826}
5827
5828#[cfg(feature = "v4_14")]
5829#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
5830#[doc(hidden)]
5831impl IntoGlib for GraphicsOffloadEnabled {
5832 type GlibType = ffi::GtkGraphicsOffloadEnabled;
5833
5834 #[inline]
5835 fn into_glib(self) -> ffi::GtkGraphicsOffloadEnabled {
5836 match self {
5837 Self::Enabled => ffi::GTK_GRAPHICS_OFFLOAD_ENABLED,
5838 Self::Disabled => ffi::GTK_GRAPHICS_OFFLOAD_DISABLED,
5839 Self::__Unknown(value) => value,
5840 }
5841 }
5842}
5843
5844#[cfg(feature = "v4_14")]
5845#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
5846#[doc(hidden)]
5847impl FromGlib<ffi::GtkGraphicsOffloadEnabled> for GraphicsOffloadEnabled {
5848 #[inline]
5849 unsafe fn from_glib(value: ffi::GtkGraphicsOffloadEnabled) -> Self {
5850 skip_assert_initialized!();
5851
5852 match value {
5853 ffi::GTK_GRAPHICS_OFFLOAD_ENABLED => Self::Enabled,
5854 ffi::GTK_GRAPHICS_OFFLOAD_DISABLED => Self::Disabled,
5855 value => Self::__Unknown(value),
5856 }
5857 }
5858}
5859
5860#[cfg(feature = "v4_14")]
5861#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
5862impl StaticType for GraphicsOffloadEnabled {
5863 #[inline]
5864 #[doc(alias = "gtk_graphics_offload_enabled_get_type")]
5865 fn static_type() -> glib::Type {
5866 unsafe { from_glib(ffi::gtk_graphics_offload_enabled_get_type()) }
5867 }
5868}
5869
5870#[cfg(feature = "v4_14")]
5871#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
5872impl glib::HasParamSpec for GraphicsOffloadEnabled {
5873 type ParamSpec = glib::ParamSpecEnum;
5874 type SetValue = Self;
5875 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5876
5877 fn param_spec_builder() -> Self::BuilderFn {
5878 Self::ParamSpec::builder_with_default
5879 }
5880}
5881
5882#[cfg(feature = "v4_14")]
5883#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
5884impl glib::value::ValueType for GraphicsOffloadEnabled {
5885 type Type = Self;
5886}
5887
5888#[cfg(feature = "v4_14")]
5889#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
5890unsafe impl<'a> glib::value::FromValue<'a> for GraphicsOffloadEnabled {
5891 type Checker = glib::value::GenericValueTypeChecker<Self>;
5892
5893 #[inline]
5894 unsafe fn from_value(value: &'a glib::Value) -> Self {
5895 skip_assert_initialized!();
5896 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5897 }
5898}
5899
5900#[cfg(feature = "v4_14")]
5901#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
5902impl ToValue for GraphicsOffloadEnabled {
5903 #[inline]
5904 fn to_value(&self) -> glib::Value {
5905 let mut value = glib::Value::for_value_type::<Self>();
5906 unsafe {
5907 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5908 }
5909 value
5910 }
5911
5912 #[inline]
5913 fn value_type(&self) -> glib::Type {
5914 Self::static_type()
5915 }
5916}
5917
5918#[cfg(feature = "v4_14")]
5919#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
5920impl From<GraphicsOffloadEnabled> for glib::Value {
5921 #[inline]
5922 fn from(v: GraphicsOffloadEnabled) -> Self {
5923 skip_assert_initialized!();
5924 ToValue::to_value(&v)
5925 }
5926}
5927
5928#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5938#[non_exhaustive]
5939#[doc(alias = "GtkIconSize")]
5940pub enum IconSize {
5941 #[doc(alias = "GTK_ICON_SIZE_INHERIT")]
5943 Inherit,
5944 #[doc(alias = "GTK_ICON_SIZE_NORMAL")]
5946 Normal,
5947 #[doc(alias = "GTK_ICON_SIZE_LARGE")]
5949 Large,
5950 #[doc(hidden)]
5951 __Unknown(i32),
5952}
5953
5954#[doc(hidden)]
5955impl IntoGlib for IconSize {
5956 type GlibType = ffi::GtkIconSize;
5957
5958 #[inline]
5959 fn into_glib(self) -> ffi::GtkIconSize {
5960 match self {
5961 Self::Inherit => ffi::GTK_ICON_SIZE_INHERIT,
5962 Self::Normal => ffi::GTK_ICON_SIZE_NORMAL,
5963 Self::Large => ffi::GTK_ICON_SIZE_LARGE,
5964 Self::__Unknown(value) => value,
5965 }
5966 }
5967}
5968
5969#[doc(hidden)]
5970impl FromGlib<ffi::GtkIconSize> for IconSize {
5971 #[inline]
5972 unsafe fn from_glib(value: ffi::GtkIconSize) -> Self {
5973 skip_assert_initialized!();
5974
5975 match value {
5976 ffi::GTK_ICON_SIZE_INHERIT => Self::Inherit,
5977 ffi::GTK_ICON_SIZE_NORMAL => Self::Normal,
5978 ffi::GTK_ICON_SIZE_LARGE => Self::Large,
5979 value => Self::__Unknown(value),
5980 }
5981 }
5982}
5983
5984impl StaticType for IconSize {
5985 #[inline]
5986 #[doc(alias = "gtk_icon_size_get_type")]
5987 fn static_type() -> glib::Type {
5988 unsafe { from_glib(ffi::gtk_icon_size_get_type()) }
5989 }
5990}
5991
5992impl glib::HasParamSpec for IconSize {
5993 type ParamSpec = glib::ParamSpecEnum;
5994 type SetValue = Self;
5995 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5996
5997 fn param_spec_builder() -> Self::BuilderFn {
5998 Self::ParamSpec::builder_with_default
5999 }
6000}
6001
6002impl glib::value::ValueType for IconSize {
6003 type Type = Self;
6004}
6005
6006unsafe impl<'a> glib::value::FromValue<'a> for IconSize {
6007 type Checker = glib::value::GenericValueTypeChecker<Self>;
6008
6009 #[inline]
6010 unsafe fn from_value(value: &'a glib::Value) -> Self {
6011 skip_assert_initialized!();
6012 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
6013 }
6014}
6015
6016impl ToValue for IconSize {
6017 #[inline]
6018 fn to_value(&self) -> glib::Value {
6019 let mut value = glib::Value::for_value_type::<Self>();
6020 unsafe {
6021 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
6022 }
6023 value
6024 }
6025
6026 #[inline]
6027 fn value_type(&self) -> glib::Type {
6028 Self::static_type()
6029 }
6030}
6031
6032impl From<IconSize> for glib::Value {
6033 #[inline]
6034 fn from(v: IconSize) -> Self {
6035 skip_assert_initialized!();
6036 ToValue::to_value(&v)
6037 }
6038}
6039
6040#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6042#[non_exhaustive]
6043#[doc(alias = "GtkIconThemeError")]
6044pub enum IconThemeError {
6045 #[doc(alias = "GTK_ICON_THEME_NOT_FOUND")]
6047 NotFound,
6048 #[doc(alias = "GTK_ICON_THEME_FAILED")]
6050 Failed,
6051 #[doc(hidden)]
6052 __Unknown(i32),
6053}
6054
6055#[doc(hidden)]
6056impl IntoGlib for IconThemeError {
6057 type GlibType = ffi::GtkIconThemeError;
6058
6059 #[inline]
6060 fn into_glib(self) -> ffi::GtkIconThemeError {
6061 match self {
6062 Self::NotFound => ffi::GTK_ICON_THEME_NOT_FOUND,
6063 Self::Failed => ffi::GTK_ICON_THEME_FAILED,
6064 Self::__Unknown(value) => value,
6065 }
6066 }
6067}
6068
6069#[doc(hidden)]
6070impl FromGlib<ffi::GtkIconThemeError> for IconThemeError {
6071 #[inline]
6072 unsafe fn from_glib(value: ffi::GtkIconThemeError) -> Self {
6073 skip_assert_initialized!();
6074
6075 match value {
6076 ffi::GTK_ICON_THEME_NOT_FOUND => Self::NotFound,
6077 ffi::GTK_ICON_THEME_FAILED => Self::Failed,
6078 value => Self::__Unknown(value),
6079 }
6080 }
6081}
6082
6083impl glib::error::ErrorDomain for IconThemeError {
6084 #[inline]
6085 fn domain() -> glib::Quark {
6086 skip_assert_initialized!();
6087
6088 unsafe { from_glib(ffi::gtk_icon_theme_error_quark()) }
6089 }
6090
6091 #[inline]
6092 fn code(self) -> i32 {
6093 self.into_glib()
6094 }
6095
6096 #[inline]
6097 #[allow(clippy::match_single_binding)]
6098 fn from(code: i32) -> Option<Self> {
6099 skip_assert_initialized!();
6100 match unsafe { from_glib(code) } {
6101 Self::__Unknown(_) => Some(Self::Failed),
6102 value => Some(value),
6103 }
6104 }
6105}
6106
6107impl StaticType for IconThemeError {
6108 #[inline]
6109 #[doc(alias = "gtk_icon_theme_error_get_type")]
6110 fn static_type() -> glib::Type {
6111 unsafe { from_glib(ffi::gtk_icon_theme_error_get_type()) }
6112 }
6113}
6114
6115impl glib::HasParamSpec for IconThemeError {
6116 type ParamSpec = glib::ParamSpecEnum;
6117 type SetValue = Self;
6118 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
6119
6120 fn param_spec_builder() -> Self::BuilderFn {
6121 Self::ParamSpec::builder_with_default
6122 }
6123}
6124
6125impl glib::value::ValueType for IconThemeError {
6126 type Type = Self;
6127}
6128
6129unsafe impl<'a> glib::value::FromValue<'a> for IconThemeError {
6130 type Checker = glib::value::GenericValueTypeChecker<Self>;
6131
6132 #[inline]
6133 unsafe fn from_value(value: &'a glib::Value) -> Self {
6134 skip_assert_initialized!();
6135 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
6136 }
6137}
6138
6139impl ToValue for IconThemeError {
6140 #[inline]
6141 fn to_value(&self) -> glib::Value {
6142 let mut value = glib::Value::for_value_type::<Self>();
6143 unsafe {
6144 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
6145 }
6146 value
6147 }
6148
6149 #[inline]
6150 fn value_type(&self) -> glib::Type {
6151 Self::static_type()
6152 }
6153}
6154
6155impl From<IconThemeError> for glib::Value {
6156 #[inline]
6157 fn from(v: IconThemeError) -> Self {
6158 skip_assert_initialized!();
6159 ToValue::to_value(&v)
6160 }
6161}
6162
6163#[cfg_attr(feature = "v4_20", deprecated = "Since 4.20")]
6169#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6170#[non_exhaustive]
6171#[doc(alias = "GtkIconViewDropPosition")]
6172pub enum IconViewDropPosition {
6173 #[doc(alias = "GTK_ICON_VIEW_NO_DROP")]
6175 NoDrop,
6176 #[doc(alias = "GTK_ICON_VIEW_DROP_INTO")]
6178 DropInto,
6179 #[doc(alias = "GTK_ICON_VIEW_DROP_LEFT")]
6181 DropLeft,
6182 #[doc(alias = "GTK_ICON_VIEW_DROP_RIGHT")]
6184 DropRight,
6185 #[doc(alias = "GTK_ICON_VIEW_DROP_ABOVE")]
6187 DropAbove,
6188 #[doc(alias = "GTK_ICON_VIEW_DROP_BELOW")]
6190 DropBelow,
6191 #[doc(hidden)]
6192 __Unknown(i32),
6193}
6194
6195#[allow(deprecated)]
6196#[doc(hidden)]
6197impl IntoGlib for IconViewDropPosition {
6198 type GlibType = ffi::GtkIconViewDropPosition;
6199
6200 #[inline]
6201 fn into_glib(self) -> ffi::GtkIconViewDropPosition {
6202 match self {
6203 Self::NoDrop => ffi::GTK_ICON_VIEW_NO_DROP,
6204 Self::DropInto => ffi::GTK_ICON_VIEW_DROP_INTO,
6205 Self::DropLeft => ffi::GTK_ICON_VIEW_DROP_LEFT,
6206 Self::DropRight => ffi::GTK_ICON_VIEW_DROP_RIGHT,
6207 Self::DropAbove => ffi::GTK_ICON_VIEW_DROP_ABOVE,
6208 Self::DropBelow => ffi::GTK_ICON_VIEW_DROP_BELOW,
6209 Self::__Unknown(value) => value,
6210 }
6211 }
6212}
6213
6214#[allow(deprecated)]
6215#[doc(hidden)]
6216impl FromGlib<ffi::GtkIconViewDropPosition> for IconViewDropPosition {
6217 #[inline]
6218 unsafe fn from_glib(value: ffi::GtkIconViewDropPosition) -> Self {
6219 skip_assert_initialized!();
6220
6221 match value {
6222 ffi::GTK_ICON_VIEW_NO_DROP => Self::NoDrop,
6223 ffi::GTK_ICON_VIEW_DROP_INTO => Self::DropInto,
6224 ffi::GTK_ICON_VIEW_DROP_LEFT => Self::DropLeft,
6225 ffi::GTK_ICON_VIEW_DROP_RIGHT => Self::DropRight,
6226 ffi::GTK_ICON_VIEW_DROP_ABOVE => Self::DropAbove,
6227 ffi::GTK_ICON_VIEW_DROP_BELOW => Self::DropBelow,
6228 value => Self::__Unknown(value),
6229 }
6230 }
6231}
6232
6233#[allow(deprecated)]
6234impl StaticType for IconViewDropPosition {
6235 #[inline]
6236 #[doc(alias = "gtk_icon_view_drop_position_get_type")]
6237 fn static_type() -> glib::Type {
6238 unsafe { from_glib(ffi::gtk_icon_view_drop_position_get_type()) }
6239 }
6240}
6241
6242#[allow(deprecated)]
6243impl glib::HasParamSpec for IconViewDropPosition {
6244 type ParamSpec = glib::ParamSpecEnum;
6245 type SetValue = Self;
6246 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
6247
6248 fn param_spec_builder() -> Self::BuilderFn {
6249 Self::ParamSpec::builder_with_default
6250 }
6251}
6252
6253#[allow(deprecated)]
6254impl glib::value::ValueType for IconViewDropPosition {
6255 type Type = Self;
6256}
6257
6258#[allow(deprecated)]
6259unsafe impl<'a> glib::value::FromValue<'a> for IconViewDropPosition {
6260 type Checker = glib::value::GenericValueTypeChecker<Self>;
6261
6262 #[inline]
6263 unsafe fn from_value(value: &'a glib::Value) -> Self {
6264 skip_assert_initialized!();
6265 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
6266 }
6267}
6268
6269#[allow(deprecated)]
6270impl ToValue for IconViewDropPosition {
6271 #[inline]
6272 fn to_value(&self) -> glib::Value {
6273 let mut value = glib::Value::for_value_type::<Self>();
6274 unsafe {
6275 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
6276 }
6277 value
6278 }
6279
6280 #[inline]
6281 fn value_type(&self) -> glib::Type {
6282 Self::static_type()
6283 }
6284}
6285
6286#[allow(deprecated)]
6287impl From<IconViewDropPosition> for glib::Value {
6288 #[inline]
6289 fn from(v: IconViewDropPosition) -> Self {
6290 skip_assert_initialized!();
6291 ToValue::to_value(&v)
6292 }
6293}
6294
6295#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6304#[non_exhaustive]
6305#[doc(alias = "GtkImageType")]
6306pub enum ImageType {
6307 #[doc(alias = "GTK_IMAGE_EMPTY")]
6309 Empty,
6310 #[doc(alias = "GTK_IMAGE_ICON_NAME")]
6312 IconName,
6313 #[doc(alias = "GTK_IMAGE_GICON")]
6315 Gicon,
6316 #[doc(alias = "GTK_IMAGE_PAINTABLE")]
6318 Paintable,
6319 #[doc(hidden)]
6320 __Unknown(i32),
6321}
6322
6323#[doc(hidden)]
6324impl IntoGlib for ImageType {
6325 type GlibType = ffi::GtkImageType;
6326
6327 #[inline]
6328 fn into_glib(self) -> ffi::GtkImageType {
6329 match self {
6330 Self::Empty => ffi::GTK_IMAGE_EMPTY,
6331 Self::IconName => ffi::GTK_IMAGE_ICON_NAME,
6332 Self::Gicon => ffi::GTK_IMAGE_GICON,
6333 Self::Paintable => ffi::GTK_IMAGE_PAINTABLE,
6334 Self::__Unknown(value) => value,
6335 }
6336 }
6337}
6338
6339#[doc(hidden)]
6340impl FromGlib<ffi::GtkImageType> for ImageType {
6341 #[inline]
6342 unsafe fn from_glib(value: ffi::GtkImageType) -> Self {
6343 skip_assert_initialized!();
6344
6345 match value {
6346 ffi::GTK_IMAGE_EMPTY => Self::Empty,
6347 ffi::GTK_IMAGE_ICON_NAME => Self::IconName,
6348 ffi::GTK_IMAGE_GICON => Self::Gicon,
6349 ffi::GTK_IMAGE_PAINTABLE => Self::Paintable,
6350 value => Self::__Unknown(value),
6351 }
6352 }
6353}
6354
6355impl StaticType for ImageType {
6356 #[inline]
6357 #[doc(alias = "gtk_image_type_get_type")]
6358 fn static_type() -> glib::Type {
6359 unsafe { from_glib(ffi::gtk_image_type_get_type()) }
6360 }
6361}
6362
6363impl glib::HasParamSpec for ImageType {
6364 type ParamSpec = glib::ParamSpecEnum;
6365 type SetValue = Self;
6366 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
6367
6368 fn param_spec_builder() -> Self::BuilderFn {
6369 Self::ParamSpec::builder_with_default
6370 }
6371}
6372
6373impl glib::value::ValueType for ImageType {
6374 type Type = Self;
6375}
6376
6377unsafe impl<'a> glib::value::FromValue<'a> for ImageType {
6378 type Checker = glib::value::GenericValueTypeChecker<Self>;
6379
6380 #[inline]
6381 unsafe fn from_value(value: &'a glib::Value) -> Self {
6382 skip_assert_initialized!();
6383 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
6384 }
6385}
6386
6387impl ToValue for ImageType {
6388 #[inline]
6389 fn to_value(&self) -> glib::Value {
6390 let mut value = glib::Value::for_value_type::<Self>();
6391 unsafe {
6392 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
6393 }
6394 value
6395 }
6396
6397 #[inline]
6398 fn value_type(&self) -> glib::Type {
6399 Self::static_type()
6400 }
6401}
6402
6403impl From<ImageType> for glib::Value {
6404 #[inline]
6405 fn from(v: ImageType) -> Self {
6406 skip_assert_initialized!();
6407 ToValue::to_value(&v)
6408 }
6409}
6410
6411#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6431#[non_exhaustive]
6432#[doc(alias = "GtkInputPurpose")]
6433pub enum InputPurpose {
6434 #[doc(alias = "GTK_INPUT_PURPOSE_FREE_FORM")]
6436 FreeForm,
6437 #[doc(alias = "GTK_INPUT_PURPOSE_ALPHA")]
6439 Alpha,
6440 #[doc(alias = "GTK_INPUT_PURPOSE_DIGITS")]
6442 Digits,
6443 #[doc(alias = "GTK_INPUT_PURPOSE_NUMBER")]
6445 Number,
6446 #[doc(alias = "GTK_INPUT_PURPOSE_PHONE")]
6448 Phone,
6449 #[doc(alias = "GTK_INPUT_PURPOSE_URL")]
6451 Url,
6452 #[doc(alias = "GTK_INPUT_PURPOSE_EMAIL")]
6454 Email,
6455 #[doc(alias = "GTK_INPUT_PURPOSE_NAME")]
6457 Name,
6458 #[doc(alias = "GTK_INPUT_PURPOSE_PASSWORD")]
6460 Password,
6461 #[doc(alias = "GTK_INPUT_PURPOSE_PIN")]
6463 Pin,
6464 #[doc(alias = "GTK_INPUT_PURPOSE_TERMINAL")]
6466 Terminal,
6467 #[doc(hidden)]
6468 __Unknown(i32),
6469}
6470
6471#[doc(hidden)]
6472impl IntoGlib for InputPurpose {
6473 type GlibType = ffi::GtkInputPurpose;
6474
6475 #[inline]
6476 fn into_glib(self) -> ffi::GtkInputPurpose {
6477 match self {
6478 Self::FreeForm => ffi::GTK_INPUT_PURPOSE_FREE_FORM,
6479 Self::Alpha => ffi::GTK_INPUT_PURPOSE_ALPHA,
6480 Self::Digits => ffi::GTK_INPUT_PURPOSE_DIGITS,
6481 Self::Number => ffi::GTK_INPUT_PURPOSE_NUMBER,
6482 Self::Phone => ffi::GTK_INPUT_PURPOSE_PHONE,
6483 Self::Url => ffi::GTK_INPUT_PURPOSE_URL,
6484 Self::Email => ffi::GTK_INPUT_PURPOSE_EMAIL,
6485 Self::Name => ffi::GTK_INPUT_PURPOSE_NAME,
6486 Self::Password => ffi::GTK_INPUT_PURPOSE_PASSWORD,
6487 Self::Pin => ffi::GTK_INPUT_PURPOSE_PIN,
6488 Self::Terminal => ffi::GTK_INPUT_PURPOSE_TERMINAL,
6489 Self::__Unknown(value) => value,
6490 }
6491 }
6492}
6493
6494#[doc(hidden)]
6495impl FromGlib<ffi::GtkInputPurpose> for InputPurpose {
6496 #[inline]
6497 unsafe fn from_glib(value: ffi::GtkInputPurpose) -> Self {
6498 skip_assert_initialized!();
6499
6500 match value {
6501 ffi::GTK_INPUT_PURPOSE_FREE_FORM => Self::FreeForm,
6502 ffi::GTK_INPUT_PURPOSE_ALPHA => Self::Alpha,
6503 ffi::GTK_INPUT_PURPOSE_DIGITS => Self::Digits,
6504 ffi::GTK_INPUT_PURPOSE_NUMBER => Self::Number,
6505 ffi::GTK_INPUT_PURPOSE_PHONE => Self::Phone,
6506 ffi::GTK_INPUT_PURPOSE_URL => Self::Url,
6507 ffi::GTK_INPUT_PURPOSE_EMAIL => Self::Email,
6508 ffi::GTK_INPUT_PURPOSE_NAME => Self::Name,
6509 ffi::GTK_INPUT_PURPOSE_PASSWORD => Self::Password,
6510 ffi::GTK_INPUT_PURPOSE_PIN => Self::Pin,
6511 ffi::GTK_INPUT_PURPOSE_TERMINAL => Self::Terminal,
6512 value => Self::__Unknown(value),
6513 }
6514 }
6515}
6516
6517impl StaticType for InputPurpose {
6518 #[inline]
6519 #[doc(alias = "gtk_input_purpose_get_type")]
6520 fn static_type() -> glib::Type {
6521 unsafe { from_glib(ffi::gtk_input_purpose_get_type()) }
6522 }
6523}
6524
6525impl glib::HasParamSpec for InputPurpose {
6526 type ParamSpec = glib::ParamSpecEnum;
6527 type SetValue = Self;
6528 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
6529
6530 fn param_spec_builder() -> Self::BuilderFn {
6531 Self::ParamSpec::builder_with_default
6532 }
6533}
6534
6535impl glib::value::ValueType for InputPurpose {
6536 type Type = Self;
6537}
6538
6539unsafe impl<'a> glib::value::FromValue<'a> for InputPurpose {
6540 type Checker = glib::value::GenericValueTypeChecker<Self>;
6541
6542 #[inline]
6543 unsafe fn from_value(value: &'a glib::Value) -> Self {
6544 skip_assert_initialized!();
6545 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
6546 }
6547}
6548
6549impl ToValue for InputPurpose {
6550 #[inline]
6551 fn to_value(&self) -> glib::Value {
6552 let mut value = glib::Value::for_value_type::<Self>();
6553 unsafe {
6554 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
6555 }
6556 value
6557 }
6558
6559 #[inline]
6560 fn value_type(&self) -> glib::Type {
6561 Self::static_type()
6562 }
6563}
6564
6565impl From<InputPurpose> for glib::Value {
6566 #[inline]
6567 fn from(v: InputPurpose) -> Self {
6568 skip_assert_initialized!();
6569 ToValue::to_value(&v)
6570 }
6571}
6572
6573#[cfg(feature = "v4_8")]
6576#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
6577#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6578#[non_exhaustive]
6579#[doc(alias = "GtkInscriptionOverflow")]
6580pub enum InscriptionOverflow {
6581 #[doc(alias = "GTK_INSCRIPTION_OVERFLOW_CLIP")]
6583 Clip,
6584 #[doc(alias = "GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_START")]
6586 EllipsizeStart,
6587 #[doc(alias = "GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_MIDDLE")]
6589 EllipsizeMiddle,
6590 #[doc(alias = "GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_END")]
6592 EllipsizeEnd,
6593 #[doc(hidden)]
6594 __Unknown(i32),
6595}
6596
6597#[cfg(feature = "v4_8")]
6598#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
6599#[doc(hidden)]
6600impl IntoGlib for InscriptionOverflow {
6601 type GlibType = ffi::GtkInscriptionOverflow;
6602
6603 #[inline]
6604 fn into_glib(self) -> ffi::GtkInscriptionOverflow {
6605 match self {
6606 Self::Clip => ffi::GTK_INSCRIPTION_OVERFLOW_CLIP,
6607 Self::EllipsizeStart => ffi::GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_START,
6608 Self::EllipsizeMiddle => ffi::GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_MIDDLE,
6609 Self::EllipsizeEnd => ffi::GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_END,
6610 Self::__Unknown(value) => value,
6611 }
6612 }
6613}
6614
6615#[cfg(feature = "v4_8")]
6616#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
6617#[doc(hidden)]
6618impl FromGlib<ffi::GtkInscriptionOverflow> for InscriptionOverflow {
6619 #[inline]
6620 unsafe fn from_glib(value: ffi::GtkInscriptionOverflow) -> Self {
6621 skip_assert_initialized!();
6622
6623 match value {
6624 ffi::GTK_INSCRIPTION_OVERFLOW_CLIP => Self::Clip,
6625 ffi::GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_START => Self::EllipsizeStart,
6626 ffi::GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_MIDDLE => Self::EllipsizeMiddle,
6627 ffi::GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_END => Self::EllipsizeEnd,
6628 value => Self::__Unknown(value),
6629 }
6630 }
6631}
6632
6633#[cfg(feature = "v4_8")]
6634#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
6635impl StaticType for InscriptionOverflow {
6636 #[inline]
6637 #[doc(alias = "gtk_inscription_overflow_get_type")]
6638 fn static_type() -> glib::Type {
6639 unsafe { from_glib(ffi::gtk_inscription_overflow_get_type()) }
6640 }
6641}
6642
6643#[cfg(feature = "v4_8")]
6644#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
6645impl glib::HasParamSpec for InscriptionOverflow {
6646 type ParamSpec = glib::ParamSpecEnum;
6647 type SetValue = Self;
6648 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
6649
6650 fn param_spec_builder() -> Self::BuilderFn {
6651 Self::ParamSpec::builder_with_default
6652 }
6653}
6654
6655#[cfg(feature = "v4_8")]
6656#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
6657impl glib::value::ValueType for InscriptionOverflow {
6658 type Type = Self;
6659}
6660
6661#[cfg(feature = "v4_8")]
6662#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
6663unsafe impl<'a> glib::value::FromValue<'a> for InscriptionOverflow {
6664 type Checker = glib::value::GenericValueTypeChecker<Self>;
6665
6666 #[inline]
6667 unsafe fn from_value(value: &'a glib::Value) -> Self {
6668 skip_assert_initialized!();
6669 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
6670 }
6671}
6672
6673#[cfg(feature = "v4_8")]
6674#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
6675impl ToValue for InscriptionOverflow {
6676 #[inline]
6677 fn to_value(&self) -> glib::Value {
6678 let mut value = glib::Value::for_value_type::<Self>();
6679 unsafe {
6680 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
6681 }
6682 value
6683 }
6684
6685 #[inline]
6686 fn value_type(&self) -> glib::Type {
6687 Self::static_type()
6688 }
6689}
6690
6691#[cfg(feature = "v4_8")]
6692#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
6693impl From<InscriptionOverflow> for glib::Value {
6694 #[inline]
6695 fn from(v: InscriptionOverflow) -> Self {
6696 skip_assert_initialized!();
6697 ToValue::to_value(&v)
6698 }
6699}
6700
6701#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6703#[non_exhaustive]
6704#[doc(alias = "GtkJustification")]
6705pub enum Justification {
6706 #[doc(alias = "GTK_JUSTIFY_LEFT")]
6708 Left,
6709 #[doc(alias = "GTK_JUSTIFY_RIGHT")]
6711 Right,
6712 #[doc(alias = "GTK_JUSTIFY_CENTER")]
6714 Center,
6715 #[doc(alias = "GTK_JUSTIFY_FILL")]
6717 Fill,
6718 #[doc(hidden)]
6719 __Unknown(i32),
6720}
6721
6722#[doc(hidden)]
6723impl IntoGlib for Justification {
6724 type GlibType = ffi::GtkJustification;
6725
6726 #[inline]
6727 fn into_glib(self) -> ffi::GtkJustification {
6728 match self {
6729 Self::Left => ffi::GTK_JUSTIFY_LEFT,
6730 Self::Right => ffi::GTK_JUSTIFY_RIGHT,
6731 Self::Center => ffi::GTK_JUSTIFY_CENTER,
6732 Self::Fill => ffi::GTK_JUSTIFY_FILL,
6733 Self::__Unknown(value) => value,
6734 }
6735 }
6736}
6737
6738#[doc(hidden)]
6739impl FromGlib<ffi::GtkJustification> for Justification {
6740 #[inline]
6741 unsafe fn from_glib(value: ffi::GtkJustification) -> Self {
6742 skip_assert_initialized!();
6743
6744 match value {
6745 ffi::GTK_JUSTIFY_LEFT => Self::Left,
6746 ffi::GTK_JUSTIFY_RIGHT => Self::Right,
6747 ffi::GTK_JUSTIFY_CENTER => Self::Center,
6748 ffi::GTK_JUSTIFY_FILL => Self::Fill,
6749 value => Self::__Unknown(value),
6750 }
6751 }
6752}
6753
6754impl StaticType for Justification {
6755 #[inline]
6756 #[doc(alias = "gtk_justification_get_type")]
6757 fn static_type() -> glib::Type {
6758 unsafe { from_glib(ffi::gtk_justification_get_type()) }
6759 }
6760}
6761
6762impl glib::HasParamSpec for Justification {
6763 type ParamSpec = glib::ParamSpecEnum;
6764 type SetValue = Self;
6765 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
6766
6767 fn param_spec_builder() -> Self::BuilderFn {
6768 Self::ParamSpec::builder_with_default
6769 }
6770}
6771
6772impl glib::value::ValueType for Justification {
6773 type Type = Self;
6774}
6775
6776unsafe impl<'a> glib::value::FromValue<'a> for Justification {
6777 type Checker = glib::value::GenericValueTypeChecker<Self>;
6778
6779 #[inline]
6780 unsafe fn from_value(value: &'a glib::Value) -> Self {
6781 skip_assert_initialized!();
6782 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
6783 }
6784}
6785
6786impl ToValue for Justification {
6787 #[inline]
6788 fn to_value(&self) -> glib::Value {
6789 let mut value = glib::Value::for_value_type::<Self>();
6790 unsafe {
6791 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
6792 }
6793 value
6794 }
6795
6796 #[inline]
6797 fn value_type(&self) -> glib::Type {
6798 Self::static_type()
6799 }
6800}
6801
6802impl From<Justification> for glib::Value {
6803 #[inline]
6804 fn from(v: Justification) -> Self {
6805 skip_assert_initialized!();
6806 ToValue::to_value(&v)
6807 }
6808}
6809
6810#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6815#[non_exhaustive]
6816#[doc(alias = "GtkLevelBarMode")]
6817pub enum LevelBarMode {
6818 #[doc(alias = "GTK_LEVEL_BAR_MODE_CONTINUOUS")]
6820 Continuous,
6821 #[doc(alias = "GTK_LEVEL_BAR_MODE_DISCRETE")]
6823 Discrete,
6824 #[doc(hidden)]
6825 __Unknown(i32),
6826}
6827
6828#[doc(hidden)]
6829impl IntoGlib for LevelBarMode {
6830 type GlibType = ffi::GtkLevelBarMode;
6831
6832 #[inline]
6833 fn into_glib(self) -> ffi::GtkLevelBarMode {
6834 match self {
6835 Self::Continuous => ffi::GTK_LEVEL_BAR_MODE_CONTINUOUS,
6836 Self::Discrete => ffi::GTK_LEVEL_BAR_MODE_DISCRETE,
6837 Self::__Unknown(value) => value,
6838 }
6839 }
6840}
6841
6842#[doc(hidden)]
6843impl FromGlib<ffi::GtkLevelBarMode> for LevelBarMode {
6844 #[inline]
6845 unsafe fn from_glib(value: ffi::GtkLevelBarMode) -> Self {
6846 skip_assert_initialized!();
6847
6848 match value {
6849 ffi::GTK_LEVEL_BAR_MODE_CONTINUOUS => Self::Continuous,
6850 ffi::GTK_LEVEL_BAR_MODE_DISCRETE => Self::Discrete,
6851 value => Self::__Unknown(value),
6852 }
6853 }
6854}
6855
6856impl StaticType for LevelBarMode {
6857 #[inline]
6858 #[doc(alias = "gtk_level_bar_mode_get_type")]
6859 fn static_type() -> glib::Type {
6860 unsafe { from_glib(ffi::gtk_level_bar_mode_get_type()) }
6861 }
6862}
6863
6864impl glib::HasParamSpec for LevelBarMode {
6865 type ParamSpec = glib::ParamSpecEnum;
6866 type SetValue = Self;
6867 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
6868
6869 fn param_spec_builder() -> Self::BuilderFn {
6870 Self::ParamSpec::builder_with_default
6871 }
6872}
6873
6874impl glib::value::ValueType for LevelBarMode {
6875 type Type = Self;
6876}
6877
6878unsafe impl<'a> glib::value::FromValue<'a> for LevelBarMode {
6879 type Checker = glib::value::GenericValueTypeChecker<Self>;
6880
6881 #[inline]
6882 unsafe fn from_value(value: &'a glib::Value) -> Self {
6883 skip_assert_initialized!();
6884 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
6885 }
6886}
6887
6888impl ToValue for LevelBarMode {
6889 #[inline]
6890 fn to_value(&self) -> glib::Value {
6891 let mut value = glib::Value::for_value_type::<Self>();
6892 unsafe {
6893 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
6894 }
6895 value
6896 }
6897
6898 #[inline]
6899 fn value_type(&self) -> glib::Type {
6900 Self::static_type()
6901 }
6902}
6903
6904impl From<LevelBarMode> for glib::Value {
6905 #[inline]
6906 fn from(v: LevelBarMode) -> Self {
6907 skip_assert_initialized!();
6908 ToValue::to_value(&v)
6909 }
6910}
6911
6912#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6916#[non_exhaustive]
6917#[doc(alias = "GtkLicense")]
6918pub enum License {
6919 #[doc(alias = "GTK_LICENSE_UNKNOWN")]
6921 Unknown,
6922 #[doc(alias = "GTK_LICENSE_CUSTOM")]
6925 Custom,
6926 #[doc(alias = "GTK_LICENSE_GPL_2_0")]
6928 Gpl20,
6929 #[doc(alias = "GTK_LICENSE_GPL_3_0")]
6931 Gpl30,
6932 #[doc(alias = "GTK_LICENSE_LGPL_2_1")]
6934 Lgpl21,
6935 #[doc(alias = "GTK_LICENSE_LGPL_3_0")]
6937 Lgpl30,
6938 #[doc(alias = "GTK_LICENSE_BSD")]
6940 Bsd,
6941 #[doc(alias = "GTK_LICENSE_MIT_X11")]
6943 MitX11,
6944 #[doc(alias = "GTK_LICENSE_ARTISTIC")]
6946 Artistic,
6947 #[doc(alias = "GTK_LICENSE_GPL_2_0_ONLY")]
6949 Gpl20Only,
6950 #[doc(alias = "GTK_LICENSE_GPL_3_0_ONLY")]
6952 Gpl30Only,
6953 #[doc(alias = "GTK_LICENSE_LGPL_2_1_ONLY")]
6955 Lgpl21Only,
6956 #[doc(alias = "GTK_LICENSE_LGPL_3_0_ONLY")]
6958 Lgpl30Only,
6959 #[doc(alias = "GTK_LICENSE_AGPL_3_0")]
6961 Agpl30,
6962 #[doc(alias = "GTK_LICENSE_AGPL_3_0_ONLY")]
6964 Agpl30Only,
6965 #[doc(alias = "GTK_LICENSE_BSD_3")]
6967 Bsd3,
6968 #[doc(alias = "GTK_LICENSE_APACHE_2_0")]
6970 Apache20,
6971 #[doc(alias = "GTK_LICENSE_MPL_2_0")]
6973 Mpl20,
6974 #[cfg(feature = "v4_14")]
6976 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
6977 #[doc(alias = "GTK_LICENSE_0BSD")]
6978 _0bsd,
6979 #[doc(hidden)]
6980 __Unknown(i32),
6981}
6982
6983#[doc(hidden)]
6984impl IntoGlib for License {
6985 type GlibType = ffi::GtkLicense;
6986
6987 fn into_glib(self) -> ffi::GtkLicense {
6988 match self {
6989 Self::Unknown => ffi::GTK_LICENSE_UNKNOWN,
6990 Self::Custom => ffi::GTK_LICENSE_CUSTOM,
6991 Self::Gpl20 => ffi::GTK_LICENSE_GPL_2_0,
6992 Self::Gpl30 => ffi::GTK_LICENSE_GPL_3_0,
6993 Self::Lgpl21 => ffi::GTK_LICENSE_LGPL_2_1,
6994 Self::Lgpl30 => ffi::GTK_LICENSE_LGPL_3_0,
6995 Self::Bsd => ffi::GTK_LICENSE_BSD,
6996 Self::MitX11 => ffi::GTK_LICENSE_MIT_X11,
6997 Self::Artistic => ffi::GTK_LICENSE_ARTISTIC,
6998 Self::Gpl20Only => ffi::GTK_LICENSE_GPL_2_0_ONLY,
6999 Self::Gpl30Only => ffi::GTK_LICENSE_GPL_3_0_ONLY,
7000 Self::Lgpl21Only => ffi::GTK_LICENSE_LGPL_2_1_ONLY,
7001 Self::Lgpl30Only => ffi::GTK_LICENSE_LGPL_3_0_ONLY,
7002 Self::Agpl30 => ffi::GTK_LICENSE_AGPL_3_0,
7003 Self::Agpl30Only => ffi::GTK_LICENSE_AGPL_3_0_ONLY,
7004 Self::Bsd3 => ffi::GTK_LICENSE_BSD_3,
7005 Self::Apache20 => ffi::GTK_LICENSE_APACHE_2_0,
7006 Self::Mpl20 => ffi::GTK_LICENSE_MPL_2_0,
7007 #[cfg(feature = "v4_14")]
7008 Self::_0bsd => ffi::GTK_LICENSE_0BSD,
7009 Self::__Unknown(value) => value,
7010 }
7011 }
7012}
7013
7014#[doc(hidden)]
7015impl FromGlib<ffi::GtkLicense> for License {
7016 unsafe fn from_glib(value: ffi::GtkLicense) -> Self {
7017 skip_assert_initialized!();
7018
7019 match value {
7020 ffi::GTK_LICENSE_UNKNOWN => Self::Unknown,
7021 ffi::GTK_LICENSE_CUSTOM => Self::Custom,
7022 ffi::GTK_LICENSE_GPL_2_0 => Self::Gpl20,
7023 ffi::GTK_LICENSE_GPL_3_0 => Self::Gpl30,
7024 ffi::GTK_LICENSE_LGPL_2_1 => Self::Lgpl21,
7025 ffi::GTK_LICENSE_LGPL_3_0 => Self::Lgpl30,
7026 ffi::GTK_LICENSE_BSD => Self::Bsd,
7027 ffi::GTK_LICENSE_MIT_X11 => Self::MitX11,
7028 ffi::GTK_LICENSE_ARTISTIC => Self::Artistic,
7029 ffi::GTK_LICENSE_GPL_2_0_ONLY => Self::Gpl20Only,
7030 ffi::GTK_LICENSE_GPL_3_0_ONLY => Self::Gpl30Only,
7031 ffi::GTK_LICENSE_LGPL_2_1_ONLY => Self::Lgpl21Only,
7032 ffi::GTK_LICENSE_LGPL_3_0_ONLY => Self::Lgpl30Only,
7033 ffi::GTK_LICENSE_AGPL_3_0 => Self::Agpl30,
7034 ffi::GTK_LICENSE_AGPL_3_0_ONLY => Self::Agpl30Only,
7035 ffi::GTK_LICENSE_BSD_3 => Self::Bsd3,
7036 ffi::GTK_LICENSE_APACHE_2_0 => Self::Apache20,
7037 ffi::GTK_LICENSE_MPL_2_0 => Self::Mpl20,
7038 #[cfg(feature = "v4_14")]
7039 ffi::GTK_LICENSE_0BSD => Self::_0bsd,
7040 value => Self::__Unknown(value),
7041 }
7042 }
7043}
7044
7045impl StaticType for License {
7046 #[inline]
7047 #[doc(alias = "gtk_license_get_type")]
7048 fn static_type() -> glib::Type {
7049 unsafe { from_glib(ffi::gtk_license_get_type()) }
7050 }
7051}
7052
7053impl glib::HasParamSpec for License {
7054 type ParamSpec = glib::ParamSpecEnum;
7055 type SetValue = Self;
7056 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
7057
7058 fn param_spec_builder() -> Self::BuilderFn {
7059 Self::ParamSpec::builder_with_default
7060 }
7061}
7062
7063impl glib::value::ValueType for License {
7064 type Type = Self;
7065}
7066
7067unsafe impl<'a> glib::value::FromValue<'a> for License {
7068 type Checker = glib::value::GenericValueTypeChecker<Self>;
7069
7070 #[inline]
7071 unsafe fn from_value(value: &'a glib::Value) -> Self {
7072 skip_assert_initialized!();
7073 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
7074 }
7075}
7076
7077impl ToValue for License {
7078 #[inline]
7079 fn to_value(&self) -> glib::Value {
7080 let mut value = glib::Value::for_value_type::<Self>();
7081 unsafe {
7082 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
7083 }
7084 value
7085 }
7086
7087 #[inline]
7088 fn value_type(&self) -> glib::Type {
7089 Self::static_type()
7090 }
7091}
7092
7093impl From<License> for glib::Value {
7094 #[inline]
7095 fn from(v: License) -> Self {
7096 skip_assert_initialized!();
7097 ToValue::to_value(&v)
7098 }
7099}
7100
7101#[cfg(feature = "v4_12")]
7105#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
7106#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7107#[non_exhaustive]
7108#[doc(alias = "GtkListTabBehavior")]
7109pub enum ListTabBehavior {
7110 #[doc(alias = "GTK_LIST_TAB_ALL")]
7112 All,
7113 #[doc(alias = "GTK_LIST_TAB_ITEM")]
7117 Item,
7118 #[doc(alias = "GTK_LIST_TAB_CELL")]
7124 Cell,
7125 #[doc(hidden)]
7126 __Unknown(i32),
7127}
7128
7129#[cfg(feature = "v4_12")]
7130#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
7131#[doc(hidden)]
7132impl IntoGlib for ListTabBehavior {
7133 type GlibType = ffi::GtkListTabBehavior;
7134
7135 #[inline]
7136 fn into_glib(self) -> ffi::GtkListTabBehavior {
7137 match self {
7138 Self::All => ffi::GTK_LIST_TAB_ALL,
7139 Self::Item => ffi::GTK_LIST_TAB_ITEM,
7140 Self::Cell => ffi::GTK_LIST_TAB_CELL,
7141 Self::__Unknown(value) => value,
7142 }
7143 }
7144}
7145
7146#[cfg(feature = "v4_12")]
7147#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
7148#[doc(hidden)]
7149impl FromGlib<ffi::GtkListTabBehavior> for ListTabBehavior {
7150 #[inline]
7151 unsafe fn from_glib(value: ffi::GtkListTabBehavior) -> Self {
7152 skip_assert_initialized!();
7153
7154 match value {
7155 ffi::GTK_LIST_TAB_ALL => Self::All,
7156 ffi::GTK_LIST_TAB_ITEM => Self::Item,
7157 ffi::GTK_LIST_TAB_CELL => Self::Cell,
7158 value => Self::__Unknown(value),
7159 }
7160 }
7161}
7162
7163#[cfg(feature = "v4_12")]
7164#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
7165impl StaticType for ListTabBehavior {
7166 #[inline]
7167 #[doc(alias = "gtk_list_tab_behavior_get_type")]
7168 fn static_type() -> glib::Type {
7169 unsafe { from_glib(ffi::gtk_list_tab_behavior_get_type()) }
7170 }
7171}
7172
7173#[cfg(feature = "v4_12")]
7174#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
7175impl glib::HasParamSpec for ListTabBehavior {
7176 type ParamSpec = glib::ParamSpecEnum;
7177 type SetValue = Self;
7178 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
7179
7180 fn param_spec_builder() -> Self::BuilderFn {
7181 Self::ParamSpec::builder_with_default
7182 }
7183}
7184
7185#[cfg(feature = "v4_12")]
7186#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
7187impl glib::value::ValueType for ListTabBehavior {
7188 type Type = Self;
7189}
7190
7191#[cfg(feature = "v4_12")]
7192#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
7193unsafe impl<'a> glib::value::FromValue<'a> for ListTabBehavior {
7194 type Checker = glib::value::GenericValueTypeChecker<Self>;
7195
7196 #[inline]
7197 unsafe fn from_value(value: &'a glib::Value) -> Self {
7198 skip_assert_initialized!();
7199 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
7200 }
7201}
7202
7203#[cfg(feature = "v4_12")]
7204#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
7205impl ToValue for ListTabBehavior {
7206 #[inline]
7207 fn to_value(&self) -> glib::Value {
7208 let mut value = glib::Value::for_value_type::<Self>();
7209 unsafe {
7210 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
7211 }
7212 value
7213 }
7214
7215 #[inline]
7216 fn value_type(&self) -> glib::Type {
7217 Self::static_type()
7218 }
7219}
7220
7221#[cfg(feature = "v4_12")]
7222#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
7223impl From<ListTabBehavior> for glib::Value {
7224 #[inline]
7225 fn from(v: ListTabBehavior) -> Self {
7226 skip_assert_initialized!();
7227 ToValue::to_value(&v)
7228 }
7229}
7230
7231#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7233#[non_exhaustive]
7234#[doc(alias = "GtkMessageType")]
7235pub enum MessageType {
7236 #[doc(alias = "GTK_MESSAGE_INFO")]
7238 Info,
7239 #[doc(alias = "GTK_MESSAGE_WARNING")]
7241 Warning,
7242 #[doc(alias = "GTK_MESSAGE_QUESTION")]
7244 Question,
7245 #[doc(alias = "GTK_MESSAGE_ERROR")]
7247 Error,
7248 #[doc(alias = "GTK_MESSAGE_OTHER")]
7250 Other,
7251 #[doc(hidden)]
7252 __Unknown(i32),
7253}
7254
7255#[doc(hidden)]
7256impl IntoGlib for MessageType {
7257 type GlibType = ffi::GtkMessageType;
7258
7259 #[inline]
7260 fn into_glib(self) -> ffi::GtkMessageType {
7261 match self {
7262 Self::Info => ffi::GTK_MESSAGE_INFO,
7263 Self::Warning => ffi::GTK_MESSAGE_WARNING,
7264 Self::Question => ffi::GTK_MESSAGE_QUESTION,
7265 Self::Error => ffi::GTK_MESSAGE_ERROR,
7266 Self::Other => ffi::GTK_MESSAGE_OTHER,
7267 Self::__Unknown(value) => value,
7268 }
7269 }
7270}
7271
7272#[doc(hidden)]
7273impl FromGlib<ffi::GtkMessageType> for MessageType {
7274 #[inline]
7275 unsafe fn from_glib(value: ffi::GtkMessageType) -> Self {
7276 skip_assert_initialized!();
7277
7278 match value {
7279 ffi::GTK_MESSAGE_INFO => Self::Info,
7280 ffi::GTK_MESSAGE_WARNING => Self::Warning,
7281 ffi::GTK_MESSAGE_QUESTION => Self::Question,
7282 ffi::GTK_MESSAGE_ERROR => Self::Error,
7283 ffi::GTK_MESSAGE_OTHER => Self::Other,
7284 value => Self::__Unknown(value),
7285 }
7286 }
7287}
7288
7289impl StaticType for MessageType {
7290 #[inline]
7291 #[doc(alias = "gtk_message_type_get_type")]
7292 fn static_type() -> glib::Type {
7293 unsafe { from_glib(ffi::gtk_message_type_get_type()) }
7294 }
7295}
7296
7297impl glib::HasParamSpec for MessageType {
7298 type ParamSpec = glib::ParamSpecEnum;
7299 type SetValue = Self;
7300 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
7301
7302 fn param_spec_builder() -> Self::BuilderFn {
7303 Self::ParamSpec::builder_with_default
7304 }
7305}
7306
7307impl glib::value::ValueType for MessageType {
7308 type Type = Self;
7309}
7310
7311unsafe impl<'a> glib::value::FromValue<'a> for MessageType {
7312 type Checker = glib::value::GenericValueTypeChecker<Self>;
7313
7314 #[inline]
7315 unsafe fn from_value(value: &'a glib::Value) -> Self {
7316 skip_assert_initialized!();
7317 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
7318 }
7319}
7320
7321impl ToValue for MessageType {
7322 #[inline]
7323 fn to_value(&self) -> glib::Value {
7324 let mut value = glib::Value::for_value_type::<Self>();
7325 unsafe {
7326 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
7327 }
7328 value
7329 }
7330
7331 #[inline]
7332 fn value_type(&self) -> glib::Type {
7333 Self::static_type()
7334 }
7335}
7336
7337impl From<MessageType> for glib::Value {
7338 #[inline]
7339 fn from(v: MessageType) -> Self {
7340 skip_assert_initialized!();
7341 ToValue::to_value(&v)
7342 }
7343}
7344
7345#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7348#[non_exhaustive]
7349#[doc(alias = "GtkMovementStep")]
7350pub enum MovementStep {
7351 #[doc(alias = "GTK_MOVEMENT_LOGICAL_POSITIONS")]
7353 LogicalPositions,
7354 #[doc(alias = "GTK_MOVEMENT_VISUAL_POSITIONS")]
7356 VisualPositions,
7357 #[doc(alias = "GTK_MOVEMENT_WORDS")]
7359 Words,
7360 #[doc(alias = "GTK_MOVEMENT_DISPLAY_LINES")]
7362 DisplayLines,
7363 #[doc(alias = "GTK_MOVEMENT_DISPLAY_LINE_ENDS")]
7365 DisplayLineEnds,
7366 #[doc(alias = "GTK_MOVEMENT_PARAGRAPHS")]
7368 Paragraphs,
7369 #[doc(alias = "GTK_MOVEMENT_PARAGRAPH_ENDS")]
7371 ParagraphEnds,
7372 #[doc(alias = "GTK_MOVEMENT_PAGES")]
7374 Pages,
7375 #[doc(alias = "GTK_MOVEMENT_BUFFER_ENDS")]
7377 BufferEnds,
7378 #[doc(alias = "GTK_MOVEMENT_HORIZONTAL_PAGES")]
7380 HorizontalPages,
7381 #[doc(hidden)]
7382 __Unknown(i32),
7383}
7384
7385#[doc(hidden)]
7386impl IntoGlib for MovementStep {
7387 type GlibType = ffi::GtkMovementStep;
7388
7389 #[inline]
7390 fn into_glib(self) -> ffi::GtkMovementStep {
7391 match self {
7392 Self::LogicalPositions => ffi::GTK_MOVEMENT_LOGICAL_POSITIONS,
7393 Self::VisualPositions => ffi::GTK_MOVEMENT_VISUAL_POSITIONS,
7394 Self::Words => ffi::GTK_MOVEMENT_WORDS,
7395 Self::DisplayLines => ffi::GTK_MOVEMENT_DISPLAY_LINES,
7396 Self::DisplayLineEnds => ffi::GTK_MOVEMENT_DISPLAY_LINE_ENDS,
7397 Self::Paragraphs => ffi::GTK_MOVEMENT_PARAGRAPHS,
7398 Self::ParagraphEnds => ffi::GTK_MOVEMENT_PARAGRAPH_ENDS,
7399 Self::Pages => ffi::GTK_MOVEMENT_PAGES,
7400 Self::BufferEnds => ffi::GTK_MOVEMENT_BUFFER_ENDS,
7401 Self::HorizontalPages => ffi::GTK_MOVEMENT_HORIZONTAL_PAGES,
7402 Self::__Unknown(value) => value,
7403 }
7404 }
7405}
7406
7407#[doc(hidden)]
7408impl FromGlib<ffi::GtkMovementStep> for MovementStep {
7409 #[inline]
7410 unsafe fn from_glib(value: ffi::GtkMovementStep) -> Self {
7411 skip_assert_initialized!();
7412
7413 match value {
7414 ffi::GTK_MOVEMENT_LOGICAL_POSITIONS => Self::LogicalPositions,
7415 ffi::GTK_MOVEMENT_VISUAL_POSITIONS => Self::VisualPositions,
7416 ffi::GTK_MOVEMENT_WORDS => Self::Words,
7417 ffi::GTK_MOVEMENT_DISPLAY_LINES => Self::DisplayLines,
7418 ffi::GTK_MOVEMENT_DISPLAY_LINE_ENDS => Self::DisplayLineEnds,
7419 ffi::GTK_MOVEMENT_PARAGRAPHS => Self::Paragraphs,
7420 ffi::GTK_MOVEMENT_PARAGRAPH_ENDS => Self::ParagraphEnds,
7421 ffi::GTK_MOVEMENT_PAGES => Self::Pages,
7422 ffi::GTK_MOVEMENT_BUFFER_ENDS => Self::BufferEnds,
7423 ffi::GTK_MOVEMENT_HORIZONTAL_PAGES => Self::HorizontalPages,
7424 value => Self::__Unknown(value),
7425 }
7426 }
7427}
7428
7429impl StaticType for MovementStep {
7430 #[inline]
7431 #[doc(alias = "gtk_movement_step_get_type")]
7432 fn static_type() -> glib::Type {
7433 unsafe { from_glib(ffi::gtk_movement_step_get_type()) }
7434 }
7435}
7436
7437impl glib::HasParamSpec for MovementStep {
7438 type ParamSpec = glib::ParamSpecEnum;
7439 type SetValue = Self;
7440 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
7441
7442 fn param_spec_builder() -> Self::BuilderFn {
7443 Self::ParamSpec::builder_with_default
7444 }
7445}
7446
7447impl glib::value::ValueType for MovementStep {
7448 type Type = Self;
7449}
7450
7451unsafe impl<'a> glib::value::FromValue<'a> for MovementStep {
7452 type Checker = glib::value::GenericValueTypeChecker<Self>;
7453
7454 #[inline]
7455 unsafe fn from_value(value: &'a glib::Value) -> Self {
7456 skip_assert_initialized!();
7457 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
7458 }
7459}
7460
7461impl ToValue for MovementStep {
7462 #[inline]
7463 fn to_value(&self) -> glib::Value {
7464 let mut value = glib::Value::for_value_type::<Self>();
7465 unsafe {
7466 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
7467 }
7468 value
7469 }
7470
7471 #[inline]
7472 fn value_type(&self) -> glib::Type {
7473 Self::static_type()
7474 }
7475}
7476
7477impl From<MovementStep> for glib::Value {
7478 #[inline]
7479 fn from(v: MovementStep) -> Self {
7480 skip_assert_initialized!();
7481 ToValue::to_value(&v)
7482 }
7483}
7484
7485#[cfg(feature = "v4_6")]
7490#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
7491#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7492#[non_exhaustive]
7493#[doc(alias = "GtkNaturalWrapMode")]
7494pub enum NaturalWrapMode {
7495 #[doc(alias = "GTK_NATURAL_WRAP_INHERIT")]
7498 Inherit,
7499 #[doc(alias = "GTK_NATURAL_WRAP_NONE")]
7503 None,
7504 #[doc(alias = "GTK_NATURAL_WRAP_WORD")]
7508 Word,
7509 #[doc(hidden)]
7510 __Unknown(i32),
7511}
7512
7513#[cfg(feature = "v4_6")]
7514#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
7515#[doc(hidden)]
7516impl IntoGlib for NaturalWrapMode {
7517 type GlibType = ffi::GtkNaturalWrapMode;
7518
7519 #[inline]
7520 fn into_glib(self) -> ffi::GtkNaturalWrapMode {
7521 match self {
7522 Self::Inherit => ffi::GTK_NATURAL_WRAP_INHERIT,
7523 Self::None => ffi::GTK_NATURAL_WRAP_NONE,
7524 Self::Word => ffi::GTK_NATURAL_WRAP_WORD,
7525 Self::__Unknown(value) => value,
7526 }
7527 }
7528}
7529
7530#[cfg(feature = "v4_6")]
7531#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
7532#[doc(hidden)]
7533impl FromGlib<ffi::GtkNaturalWrapMode> for NaturalWrapMode {
7534 #[inline]
7535 unsafe fn from_glib(value: ffi::GtkNaturalWrapMode) -> Self {
7536 skip_assert_initialized!();
7537
7538 match value {
7539 ffi::GTK_NATURAL_WRAP_INHERIT => Self::Inherit,
7540 ffi::GTK_NATURAL_WRAP_NONE => Self::None,
7541 ffi::GTK_NATURAL_WRAP_WORD => Self::Word,
7542 value => Self::__Unknown(value),
7543 }
7544 }
7545}
7546
7547#[cfg(feature = "v4_6")]
7548#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
7549impl StaticType for NaturalWrapMode {
7550 #[inline]
7551 #[doc(alias = "gtk_natural_wrap_mode_get_type")]
7552 fn static_type() -> glib::Type {
7553 unsafe { from_glib(ffi::gtk_natural_wrap_mode_get_type()) }
7554 }
7555}
7556
7557#[cfg(feature = "v4_6")]
7558#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
7559impl glib::HasParamSpec for NaturalWrapMode {
7560 type ParamSpec = glib::ParamSpecEnum;
7561 type SetValue = Self;
7562 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
7563
7564 fn param_spec_builder() -> Self::BuilderFn {
7565 Self::ParamSpec::builder_with_default
7566 }
7567}
7568
7569#[cfg(feature = "v4_6")]
7570#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
7571impl glib::value::ValueType for NaturalWrapMode {
7572 type Type = Self;
7573}
7574
7575#[cfg(feature = "v4_6")]
7576#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
7577unsafe impl<'a> glib::value::FromValue<'a> for NaturalWrapMode {
7578 type Checker = glib::value::GenericValueTypeChecker<Self>;
7579
7580 #[inline]
7581 unsafe fn from_value(value: &'a glib::Value) -> Self {
7582 skip_assert_initialized!();
7583 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
7584 }
7585}
7586
7587#[cfg(feature = "v4_6")]
7588#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
7589impl ToValue for NaturalWrapMode {
7590 #[inline]
7591 fn to_value(&self) -> glib::Value {
7592 let mut value = glib::Value::for_value_type::<Self>();
7593 unsafe {
7594 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
7595 }
7596 value
7597 }
7598
7599 #[inline]
7600 fn value_type(&self) -> glib::Type {
7601 Self::static_type()
7602 }
7603}
7604
7605#[cfg(feature = "v4_6")]
7606#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
7607impl From<NaturalWrapMode> for glib::Value {
7608 #[inline]
7609 fn from(v: NaturalWrapMode) -> Self {
7610 skip_assert_initialized!();
7611 ToValue::to_value(&v)
7612 }
7613}
7614
7615#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7617#[non_exhaustive]
7618#[doc(alias = "GtkNotebookTab")]
7619pub enum NotebookTab {
7620 #[doc(alias = "GTK_NOTEBOOK_TAB_FIRST")]
7622 First,
7623 #[doc(alias = "GTK_NOTEBOOK_TAB_LAST")]
7625 Last,
7626 #[doc(hidden)]
7627 __Unknown(i32),
7628}
7629
7630#[doc(hidden)]
7631impl IntoGlib for NotebookTab {
7632 type GlibType = ffi::GtkNotebookTab;
7633
7634 #[inline]
7635 fn into_glib(self) -> ffi::GtkNotebookTab {
7636 match self {
7637 Self::First => ffi::GTK_NOTEBOOK_TAB_FIRST,
7638 Self::Last => ffi::GTK_NOTEBOOK_TAB_LAST,
7639 Self::__Unknown(value) => value,
7640 }
7641 }
7642}
7643
7644#[doc(hidden)]
7645impl FromGlib<ffi::GtkNotebookTab> for NotebookTab {
7646 #[inline]
7647 unsafe fn from_glib(value: ffi::GtkNotebookTab) -> Self {
7648 skip_assert_initialized!();
7649
7650 match value {
7651 ffi::GTK_NOTEBOOK_TAB_FIRST => Self::First,
7652 ffi::GTK_NOTEBOOK_TAB_LAST => Self::Last,
7653 value => Self::__Unknown(value),
7654 }
7655 }
7656}
7657
7658impl StaticType for NotebookTab {
7659 #[inline]
7660 #[doc(alias = "gtk_notebook_tab_get_type")]
7661 fn static_type() -> glib::Type {
7662 unsafe { from_glib(ffi::gtk_notebook_tab_get_type()) }
7663 }
7664}
7665
7666impl glib::HasParamSpec for NotebookTab {
7667 type ParamSpec = glib::ParamSpecEnum;
7668 type SetValue = Self;
7669 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
7670
7671 fn param_spec_builder() -> Self::BuilderFn {
7672 Self::ParamSpec::builder_with_default
7673 }
7674}
7675
7676impl glib::value::ValueType for NotebookTab {
7677 type Type = Self;
7678}
7679
7680unsafe impl<'a> glib::value::FromValue<'a> for NotebookTab {
7681 type Checker = glib::value::GenericValueTypeChecker<Self>;
7682
7683 #[inline]
7684 unsafe fn from_value(value: &'a glib::Value) -> Self {
7685 skip_assert_initialized!();
7686 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
7687 }
7688}
7689
7690impl ToValue for NotebookTab {
7691 #[inline]
7692 fn to_value(&self) -> glib::Value {
7693 let mut value = glib::Value::for_value_type::<Self>();
7694 unsafe {
7695 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
7696 }
7697 value
7698 }
7699
7700 #[inline]
7701 fn value_type(&self) -> glib::Type {
7702 Self::static_type()
7703 }
7704}
7705
7706impl From<NotebookTab> for glib::Value {
7707 #[inline]
7708 fn from(v: NotebookTab) -> Self {
7709 skip_assert_initialized!();
7710 ToValue::to_value(&v)
7711 }
7712}
7713
7714#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7717#[non_exhaustive]
7718#[doc(alias = "GtkNumberUpLayout")]
7719pub enum NumberUpLayout {
7720 #[doc(alias = "GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM")]
7722 Lrtb,
7723 #[doc(alias = "GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_BOTTOM_TO_TOP")]
7725 Lrbt,
7726 #[doc(alias = "GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM")]
7728 Rltb,
7729 #[doc(alias = "GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_BOTTOM_TO_TOP")]
7731 Rlbt,
7732 #[doc(alias = "GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_LEFT_TO_RIGHT")]
7734 Tblr,
7735 #[doc(alias = "GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_RIGHT_TO_LEFT")]
7737 Tbrl,
7738 #[doc(alias = "GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_LEFT_TO_RIGHT")]
7740 Btlr,
7741 #[doc(alias = "GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_RIGHT_TO_LEFT")]
7743 Btrl,
7744 #[doc(hidden)]
7745 __Unknown(i32),
7746}
7747
7748#[doc(hidden)]
7749impl IntoGlib for NumberUpLayout {
7750 type GlibType = ffi::GtkNumberUpLayout;
7751
7752 #[inline]
7753 fn into_glib(self) -> ffi::GtkNumberUpLayout {
7754 match self {
7755 Self::Lrtb => ffi::GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM,
7756 Self::Lrbt => ffi::GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_BOTTOM_TO_TOP,
7757 Self::Rltb => ffi::GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM,
7758 Self::Rlbt => ffi::GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_BOTTOM_TO_TOP,
7759 Self::Tblr => ffi::GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_LEFT_TO_RIGHT,
7760 Self::Tbrl => ffi::GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_RIGHT_TO_LEFT,
7761 Self::Btlr => ffi::GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_LEFT_TO_RIGHT,
7762 Self::Btrl => ffi::GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_RIGHT_TO_LEFT,
7763 Self::__Unknown(value) => value,
7764 }
7765 }
7766}
7767
7768#[doc(hidden)]
7769impl FromGlib<ffi::GtkNumberUpLayout> for NumberUpLayout {
7770 #[inline]
7771 unsafe fn from_glib(value: ffi::GtkNumberUpLayout) -> Self {
7772 skip_assert_initialized!();
7773
7774 match value {
7775 ffi::GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM => Self::Lrtb,
7776 ffi::GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_BOTTOM_TO_TOP => Self::Lrbt,
7777 ffi::GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM => Self::Rltb,
7778 ffi::GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_BOTTOM_TO_TOP => Self::Rlbt,
7779 ffi::GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_LEFT_TO_RIGHT => Self::Tblr,
7780 ffi::GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_RIGHT_TO_LEFT => Self::Tbrl,
7781 ffi::GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_LEFT_TO_RIGHT => Self::Btlr,
7782 ffi::GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_RIGHT_TO_LEFT => Self::Btrl,
7783 value => Self::__Unknown(value),
7784 }
7785 }
7786}
7787
7788impl StaticType for NumberUpLayout {
7789 #[inline]
7790 #[doc(alias = "gtk_number_up_layout_get_type")]
7791 fn static_type() -> glib::Type {
7792 unsafe { from_glib(ffi::gtk_number_up_layout_get_type()) }
7793 }
7794}
7795
7796impl glib::HasParamSpec for NumberUpLayout {
7797 type ParamSpec = glib::ParamSpecEnum;
7798 type SetValue = Self;
7799 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
7800
7801 fn param_spec_builder() -> Self::BuilderFn {
7802 Self::ParamSpec::builder_with_default
7803 }
7804}
7805
7806impl glib::value::ValueType for NumberUpLayout {
7807 type Type = Self;
7808}
7809
7810unsafe impl<'a> glib::value::FromValue<'a> for NumberUpLayout {
7811 type Checker = glib::value::GenericValueTypeChecker<Self>;
7812
7813 #[inline]
7814 unsafe fn from_value(value: &'a glib::Value) -> Self {
7815 skip_assert_initialized!();
7816 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
7817 }
7818}
7819
7820impl ToValue for NumberUpLayout {
7821 #[inline]
7822 fn to_value(&self) -> glib::Value {
7823 let mut value = glib::Value::for_value_type::<Self>();
7824 unsafe {
7825 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
7826 }
7827 value
7828 }
7829
7830 #[inline]
7831 fn value_type(&self) -> glib::Type {
7832 Self::static_type()
7833 }
7834}
7835
7836impl From<NumberUpLayout> for glib::Value {
7837 #[inline]
7838 fn from(v: NumberUpLayout) -> Self {
7839 skip_assert_initialized!();
7840 ToValue::to_value(&v)
7841 }
7842}
7843
7844#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7851#[non_exhaustive]
7852#[doc(alias = "GtkOrdering")]
7853pub enum Ordering {
7854 #[doc(alias = "GTK_ORDERING_SMALLER")]
7856 Smaller,
7857 #[doc(alias = "GTK_ORDERING_EQUAL")]
7859 Equal,
7860 #[doc(alias = "GTK_ORDERING_LARGER")]
7862 Larger,
7863 #[doc(hidden)]
7864 __Unknown(i32),
7865}
7866
7867#[doc(hidden)]
7868impl IntoGlib for Ordering {
7869 type GlibType = ffi::GtkOrdering;
7870
7871 #[inline]
7872 fn into_glib(self) -> ffi::GtkOrdering {
7873 match self {
7874 Self::Smaller => ffi::GTK_ORDERING_SMALLER,
7875 Self::Equal => ffi::GTK_ORDERING_EQUAL,
7876 Self::Larger => ffi::GTK_ORDERING_LARGER,
7877 Self::__Unknown(value) => value,
7878 }
7879 }
7880}
7881
7882#[doc(hidden)]
7883impl FromGlib<ffi::GtkOrdering> for Ordering {
7884 #[inline]
7885 unsafe fn from_glib(value: ffi::GtkOrdering) -> Self {
7886 skip_assert_initialized!();
7887
7888 match value {
7889 ffi::GTK_ORDERING_SMALLER => Self::Smaller,
7890 ffi::GTK_ORDERING_EQUAL => Self::Equal,
7891 ffi::GTK_ORDERING_LARGER => Self::Larger,
7892 value => Self::__Unknown(value),
7893 }
7894 }
7895}
7896
7897impl StaticType for Ordering {
7898 #[inline]
7899 #[doc(alias = "gtk_ordering_get_type")]
7900 fn static_type() -> glib::Type {
7901 unsafe { from_glib(ffi::gtk_ordering_get_type()) }
7902 }
7903}
7904
7905impl glib::HasParamSpec for Ordering {
7906 type ParamSpec = glib::ParamSpecEnum;
7907 type SetValue = Self;
7908 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
7909
7910 fn param_spec_builder() -> Self::BuilderFn {
7911 Self::ParamSpec::builder_with_default
7912 }
7913}
7914
7915impl glib::value::ValueType for Ordering {
7916 type Type = Self;
7917}
7918
7919unsafe impl<'a> glib::value::FromValue<'a> for Ordering {
7920 type Checker = glib::value::GenericValueTypeChecker<Self>;
7921
7922 #[inline]
7923 unsafe fn from_value(value: &'a glib::Value) -> Self {
7924 skip_assert_initialized!();
7925 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
7926 }
7927}
7928
7929impl ToValue for Ordering {
7930 #[inline]
7931 fn to_value(&self) -> glib::Value {
7932 let mut value = glib::Value::for_value_type::<Self>();
7933 unsafe {
7934 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
7935 }
7936 value
7937 }
7938
7939 #[inline]
7940 fn value_type(&self) -> glib::Type {
7941 Self::static_type()
7942 }
7943}
7944
7945impl From<Ordering> for glib::Value {
7946 #[inline]
7947 fn from(v: Ordering) -> Self {
7948 skip_assert_initialized!();
7949 ToValue::to_value(&v)
7950 }
7951}
7952
7953#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7957#[non_exhaustive]
7958#[doc(alias = "GtkOrientation")]
7959pub enum Orientation {
7960 #[doc(alias = "GTK_ORIENTATION_HORIZONTAL")]
7962 Horizontal,
7963 #[doc(alias = "GTK_ORIENTATION_VERTICAL")]
7965 Vertical,
7966 #[doc(hidden)]
7967 __Unknown(i32),
7968}
7969
7970#[doc(hidden)]
7971impl IntoGlib for Orientation {
7972 type GlibType = ffi::GtkOrientation;
7973
7974 #[inline]
7975 fn into_glib(self) -> ffi::GtkOrientation {
7976 match self {
7977 Self::Horizontal => ffi::GTK_ORIENTATION_HORIZONTAL,
7978 Self::Vertical => ffi::GTK_ORIENTATION_VERTICAL,
7979 Self::__Unknown(value) => value,
7980 }
7981 }
7982}
7983
7984#[doc(hidden)]
7985impl FromGlib<ffi::GtkOrientation> for Orientation {
7986 #[inline]
7987 unsafe fn from_glib(value: ffi::GtkOrientation) -> Self {
7988 skip_assert_initialized!();
7989
7990 match value {
7991 ffi::GTK_ORIENTATION_HORIZONTAL => Self::Horizontal,
7992 ffi::GTK_ORIENTATION_VERTICAL => Self::Vertical,
7993 value => Self::__Unknown(value),
7994 }
7995 }
7996}
7997
7998impl StaticType for Orientation {
7999 #[inline]
8000 #[doc(alias = "gtk_orientation_get_type")]
8001 fn static_type() -> glib::Type {
8002 unsafe { from_glib(ffi::gtk_orientation_get_type()) }
8003 }
8004}
8005
8006impl glib::HasParamSpec for Orientation {
8007 type ParamSpec = glib::ParamSpecEnum;
8008 type SetValue = Self;
8009 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
8010
8011 fn param_spec_builder() -> Self::BuilderFn {
8012 Self::ParamSpec::builder_with_default
8013 }
8014}
8015
8016impl glib::value::ValueType for Orientation {
8017 type Type = Self;
8018}
8019
8020unsafe impl<'a> glib::value::FromValue<'a> for Orientation {
8021 type Checker = glib::value::GenericValueTypeChecker<Self>;
8022
8023 #[inline]
8024 unsafe fn from_value(value: &'a glib::Value) -> Self {
8025 skip_assert_initialized!();
8026 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
8027 }
8028}
8029
8030impl ToValue for Orientation {
8031 #[inline]
8032 fn to_value(&self) -> glib::Value {
8033 let mut value = glib::Value::for_value_type::<Self>();
8034 unsafe {
8035 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
8036 }
8037 value
8038 }
8039
8040 #[inline]
8041 fn value_type(&self) -> glib::Type {
8042 Self::static_type()
8043 }
8044}
8045
8046impl From<Orientation> for glib::Value {
8047 #[inline]
8048 fn from(v: Orientation) -> Self {
8049 skip_assert_initialized!();
8050 ToValue::to_value(&v)
8051 }
8052}
8053
8054#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
8060#[non_exhaustive]
8061#[doc(alias = "GtkOverflow")]
8062pub enum Overflow {
8063 #[doc(alias = "GTK_OVERFLOW_VISIBLE")]
8066 Visible,
8067 #[doc(alias = "GTK_OVERFLOW_HIDDEN")]
8070 Hidden,
8071 #[doc(hidden)]
8072 __Unknown(i32),
8073}
8074
8075#[doc(hidden)]
8076impl IntoGlib for Overflow {
8077 type GlibType = ffi::GtkOverflow;
8078
8079 #[inline]
8080 fn into_glib(self) -> ffi::GtkOverflow {
8081 match self {
8082 Self::Visible => ffi::GTK_OVERFLOW_VISIBLE,
8083 Self::Hidden => ffi::GTK_OVERFLOW_HIDDEN,
8084 Self::__Unknown(value) => value,
8085 }
8086 }
8087}
8088
8089#[doc(hidden)]
8090impl FromGlib<ffi::GtkOverflow> for Overflow {
8091 #[inline]
8092 unsafe fn from_glib(value: ffi::GtkOverflow) -> Self {
8093 skip_assert_initialized!();
8094
8095 match value {
8096 ffi::GTK_OVERFLOW_VISIBLE => Self::Visible,
8097 ffi::GTK_OVERFLOW_HIDDEN => Self::Hidden,
8098 value => Self::__Unknown(value),
8099 }
8100 }
8101}
8102
8103impl StaticType for Overflow {
8104 #[inline]
8105 #[doc(alias = "gtk_overflow_get_type")]
8106 fn static_type() -> glib::Type {
8107 unsafe { from_glib(ffi::gtk_overflow_get_type()) }
8108 }
8109}
8110
8111impl glib::HasParamSpec for Overflow {
8112 type ParamSpec = glib::ParamSpecEnum;
8113 type SetValue = Self;
8114 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
8115
8116 fn param_spec_builder() -> Self::BuilderFn {
8117 Self::ParamSpec::builder_with_default
8118 }
8119}
8120
8121impl glib::value::ValueType for Overflow {
8122 type Type = Self;
8123}
8124
8125unsafe impl<'a> glib::value::FromValue<'a> for Overflow {
8126 type Checker = glib::value::GenericValueTypeChecker<Self>;
8127
8128 #[inline]
8129 unsafe fn from_value(value: &'a glib::Value) -> Self {
8130 skip_assert_initialized!();
8131 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
8132 }
8133}
8134
8135impl ToValue for Overflow {
8136 #[inline]
8137 fn to_value(&self) -> glib::Value {
8138 let mut value = glib::Value::for_value_type::<Self>();
8139 unsafe {
8140 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
8141 }
8142 value
8143 }
8144
8145 #[inline]
8146 fn value_type(&self) -> glib::Type {
8147 Self::static_type()
8148 }
8149}
8150
8151impl From<Overflow> for glib::Value {
8152 #[inline]
8153 fn from(v: Overflow) -> Self {
8154 skip_assert_initialized!();
8155 ToValue::to_value(&v)
8156 }
8157}
8158
8159#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
8163#[non_exhaustive]
8164#[doc(alias = "GtkPackType")]
8165pub enum PackType {
8166 #[doc(alias = "GTK_PACK_START")]
8168 Start,
8169 #[doc(alias = "GTK_PACK_END")]
8171 End,
8172 #[doc(hidden)]
8173 __Unknown(i32),
8174}
8175
8176#[doc(hidden)]
8177impl IntoGlib for PackType {
8178 type GlibType = ffi::GtkPackType;
8179
8180 #[inline]
8181 fn into_glib(self) -> ffi::GtkPackType {
8182 match self {
8183 Self::Start => ffi::GTK_PACK_START,
8184 Self::End => ffi::GTK_PACK_END,
8185 Self::__Unknown(value) => value,
8186 }
8187 }
8188}
8189
8190#[doc(hidden)]
8191impl FromGlib<ffi::GtkPackType> for PackType {
8192 #[inline]
8193 unsafe fn from_glib(value: ffi::GtkPackType) -> Self {
8194 skip_assert_initialized!();
8195
8196 match value {
8197 ffi::GTK_PACK_START => Self::Start,
8198 ffi::GTK_PACK_END => Self::End,
8199 value => Self::__Unknown(value),
8200 }
8201 }
8202}
8203
8204impl StaticType for PackType {
8205 #[inline]
8206 #[doc(alias = "gtk_pack_type_get_type")]
8207 fn static_type() -> glib::Type {
8208 unsafe { from_glib(ffi::gtk_pack_type_get_type()) }
8209 }
8210}
8211
8212impl glib::HasParamSpec for PackType {
8213 type ParamSpec = glib::ParamSpecEnum;
8214 type SetValue = Self;
8215 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
8216
8217 fn param_spec_builder() -> Self::BuilderFn {
8218 Self::ParamSpec::builder_with_default
8219 }
8220}
8221
8222impl glib::value::ValueType for PackType {
8223 type Type = Self;
8224}
8225
8226unsafe impl<'a> glib::value::FromValue<'a> for PackType {
8227 type Checker = glib::value::GenericValueTypeChecker<Self>;
8228
8229 #[inline]
8230 unsafe fn from_value(value: &'a glib::Value) -> Self {
8231 skip_assert_initialized!();
8232 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
8233 }
8234}
8235
8236impl ToValue for PackType {
8237 #[inline]
8238 fn to_value(&self) -> glib::Value {
8239 let mut value = glib::Value::for_value_type::<Self>();
8240 unsafe {
8241 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
8242 }
8243 value
8244 }
8245
8246 #[inline]
8247 fn value_type(&self) -> glib::Type {
8248 Self::static_type()
8249 }
8250}
8251
8252impl From<PackType> for glib::Value {
8253 #[inline]
8254 fn from(v: PackType) -> Self {
8255 skip_assert_initialized!();
8256 ToValue::to_value(&v)
8257 }
8258}
8259
8260#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
8262#[non_exhaustive]
8263#[doc(alias = "GtkPadActionType")]
8264pub enum PadActionType {
8265 #[doc(alias = "GTK_PAD_ACTION_BUTTON")]
8267 Button,
8268 #[doc(alias = "GTK_PAD_ACTION_RING")]
8270 Ring,
8271 #[doc(alias = "GTK_PAD_ACTION_STRIP")]
8273 Strip,
8274 #[doc(alias = "GTK_PAD_ACTION_DIAL")]
8276 Dial,
8277 #[doc(hidden)]
8278 __Unknown(i32),
8279}
8280
8281#[doc(hidden)]
8282impl IntoGlib for PadActionType {
8283 type GlibType = ffi::GtkPadActionType;
8284
8285 #[inline]
8286 fn into_glib(self) -> ffi::GtkPadActionType {
8287 match self {
8288 Self::Button => ffi::GTK_PAD_ACTION_BUTTON,
8289 Self::Ring => ffi::GTK_PAD_ACTION_RING,
8290 Self::Strip => ffi::GTK_PAD_ACTION_STRIP,
8291 Self::Dial => ffi::GTK_PAD_ACTION_DIAL,
8292 Self::__Unknown(value) => value,
8293 }
8294 }
8295}
8296
8297#[doc(hidden)]
8298impl FromGlib<ffi::GtkPadActionType> for PadActionType {
8299 #[inline]
8300 unsafe fn from_glib(value: ffi::GtkPadActionType) -> Self {
8301 skip_assert_initialized!();
8302
8303 match value {
8304 ffi::GTK_PAD_ACTION_BUTTON => Self::Button,
8305 ffi::GTK_PAD_ACTION_RING => Self::Ring,
8306 ffi::GTK_PAD_ACTION_STRIP => Self::Strip,
8307 ffi::GTK_PAD_ACTION_DIAL => Self::Dial,
8308 value => Self::__Unknown(value),
8309 }
8310 }
8311}
8312
8313impl StaticType for PadActionType {
8314 #[inline]
8315 #[doc(alias = "gtk_pad_action_type_get_type")]
8316 fn static_type() -> glib::Type {
8317 unsafe { from_glib(ffi::gtk_pad_action_type_get_type()) }
8318 }
8319}
8320
8321impl glib::HasParamSpec for PadActionType {
8322 type ParamSpec = glib::ParamSpecEnum;
8323 type SetValue = Self;
8324 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
8325
8326 fn param_spec_builder() -> Self::BuilderFn {
8327 Self::ParamSpec::builder_with_default
8328 }
8329}
8330
8331impl glib::value::ValueType for PadActionType {
8332 type Type = Self;
8333}
8334
8335unsafe impl<'a> glib::value::FromValue<'a> for PadActionType {
8336 type Checker = glib::value::GenericValueTypeChecker<Self>;
8337
8338 #[inline]
8339 unsafe fn from_value(value: &'a glib::Value) -> Self {
8340 skip_assert_initialized!();
8341 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
8342 }
8343}
8344
8345impl ToValue for PadActionType {
8346 #[inline]
8347 fn to_value(&self) -> glib::Value {
8348 let mut value = glib::Value::for_value_type::<Self>();
8349 unsafe {
8350 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
8351 }
8352 value
8353 }
8354
8355 #[inline]
8356 fn value_type(&self) -> glib::Type {
8357 Self::static_type()
8358 }
8359}
8360
8361impl From<PadActionType> for glib::Value {
8362 #[inline]
8363 fn from(v: PadActionType) -> Self {
8364 skip_assert_initialized!();
8365 ToValue::to_value(&v)
8366 }
8367}
8368
8369#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
8371#[non_exhaustive]
8372#[doc(alias = "GtkPageOrientation")]
8373pub enum PageOrientation {
8374 #[doc(alias = "GTK_PAGE_ORIENTATION_PORTRAIT")]
8376 Portrait,
8377 #[doc(alias = "GTK_PAGE_ORIENTATION_LANDSCAPE")]
8379 Landscape,
8380 #[doc(alias = "GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT")]
8382 ReversePortrait,
8383 #[doc(alias = "GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE")]
8385 ReverseLandscape,
8386 #[doc(hidden)]
8387 __Unknown(i32),
8388}
8389
8390#[doc(hidden)]
8391impl IntoGlib for PageOrientation {
8392 type GlibType = ffi::GtkPageOrientation;
8393
8394 #[inline]
8395 fn into_glib(self) -> ffi::GtkPageOrientation {
8396 match self {
8397 Self::Portrait => ffi::GTK_PAGE_ORIENTATION_PORTRAIT,
8398 Self::Landscape => ffi::GTK_PAGE_ORIENTATION_LANDSCAPE,
8399 Self::ReversePortrait => ffi::GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT,
8400 Self::ReverseLandscape => ffi::GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE,
8401 Self::__Unknown(value) => value,
8402 }
8403 }
8404}
8405
8406#[doc(hidden)]
8407impl FromGlib<ffi::GtkPageOrientation> for PageOrientation {
8408 #[inline]
8409 unsafe fn from_glib(value: ffi::GtkPageOrientation) -> Self {
8410 skip_assert_initialized!();
8411
8412 match value {
8413 ffi::GTK_PAGE_ORIENTATION_PORTRAIT => Self::Portrait,
8414 ffi::GTK_PAGE_ORIENTATION_LANDSCAPE => Self::Landscape,
8415 ffi::GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT => Self::ReversePortrait,
8416 ffi::GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE => Self::ReverseLandscape,
8417 value => Self::__Unknown(value),
8418 }
8419 }
8420}
8421
8422impl StaticType for PageOrientation {
8423 #[inline]
8424 #[doc(alias = "gtk_page_orientation_get_type")]
8425 fn static_type() -> glib::Type {
8426 unsafe { from_glib(ffi::gtk_page_orientation_get_type()) }
8427 }
8428}
8429
8430impl glib::HasParamSpec for PageOrientation {
8431 type ParamSpec = glib::ParamSpecEnum;
8432 type SetValue = Self;
8433 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
8434
8435 fn param_spec_builder() -> Self::BuilderFn {
8436 Self::ParamSpec::builder_with_default
8437 }
8438}
8439
8440impl glib::value::ValueType for PageOrientation {
8441 type Type = Self;
8442}
8443
8444unsafe impl<'a> glib::value::FromValue<'a> for PageOrientation {
8445 type Checker = glib::value::GenericValueTypeChecker<Self>;
8446
8447 #[inline]
8448 unsafe fn from_value(value: &'a glib::Value) -> Self {
8449 skip_assert_initialized!();
8450 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
8451 }
8452}
8453
8454impl ToValue for PageOrientation {
8455 #[inline]
8456 fn to_value(&self) -> glib::Value {
8457 let mut value = glib::Value::for_value_type::<Self>();
8458 unsafe {
8459 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
8460 }
8461 value
8462 }
8463
8464 #[inline]
8465 fn value_type(&self) -> glib::Type {
8466 Self::static_type()
8467 }
8468}
8469
8470impl From<PageOrientation> for glib::Value {
8471 #[inline]
8472 fn from(v: PageOrientation) -> Self {
8473 skip_assert_initialized!();
8474 ToValue::to_value(&v)
8475 }
8476}
8477
8478#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
8480#[non_exhaustive]
8481#[doc(alias = "GtkPageSet")]
8482pub enum PageSet {
8483 #[doc(alias = "GTK_PAGE_SET_ALL")]
8485 All,
8486 #[doc(alias = "GTK_PAGE_SET_EVEN")]
8488 Even,
8489 #[doc(alias = "GTK_PAGE_SET_ODD")]
8491 Odd,
8492 #[doc(hidden)]
8493 __Unknown(i32),
8494}
8495
8496#[doc(hidden)]
8497impl IntoGlib for PageSet {
8498 type GlibType = ffi::GtkPageSet;
8499
8500 #[inline]
8501 fn into_glib(self) -> ffi::GtkPageSet {
8502 match self {
8503 Self::All => ffi::GTK_PAGE_SET_ALL,
8504 Self::Even => ffi::GTK_PAGE_SET_EVEN,
8505 Self::Odd => ffi::GTK_PAGE_SET_ODD,
8506 Self::__Unknown(value) => value,
8507 }
8508 }
8509}
8510
8511#[doc(hidden)]
8512impl FromGlib<ffi::GtkPageSet> for PageSet {
8513 #[inline]
8514 unsafe fn from_glib(value: ffi::GtkPageSet) -> Self {
8515 skip_assert_initialized!();
8516
8517 match value {
8518 ffi::GTK_PAGE_SET_ALL => Self::All,
8519 ffi::GTK_PAGE_SET_EVEN => Self::Even,
8520 ffi::GTK_PAGE_SET_ODD => Self::Odd,
8521 value => Self::__Unknown(value),
8522 }
8523 }
8524}
8525
8526impl StaticType for PageSet {
8527 #[inline]
8528 #[doc(alias = "gtk_page_set_get_type")]
8529 fn static_type() -> glib::Type {
8530 unsafe { from_glib(ffi::gtk_page_set_get_type()) }
8531 }
8532}
8533
8534impl glib::HasParamSpec for PageSet {
8535 type ParamSpec = glib::ParamSpecEnum;
8536 type SetValue = Self;
8537 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
8538
8539 fn param_spec_builder() -> Self::BuilderFn {
8540 Self::ParamSpec::builder_with_default
8541 }
8542}
8543
8544impl glib::value::ValueType for PageSet {
8545 type Type = Self;
8546}
8547
8548unsafe impl<'a> glib::value::FromValue<'a> for PageSet {
8549 type Checker = glib::value::GenericValueTypeChecker<Self>;
8550
8551 #[inline]
8552 unsafe fn from_value(value: &'a glib::Value) -> Self {
8553 skip_assert_initialized!();
8554 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
8555 }
8556}
8557
8558impl ToValue for PageSet {
8559 #[inline]
8560 fn to_value(&self) -> glib::Value {
8561 let mut value = glib::Value::for_value_type::<Self>();
8562 unsafe {
8563 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
8564 }
8565 value
8566 }
8567
8568 #[inline]
8569 fn value_type(&self) -> glib::Type {
8570 Self::static_type()
8571 }
8572}
8573
8574impl From<PageSet> for glib::Value {
8575 #[inline]
8576 fn from(v: PageSet) -> Self {
8577 skip_assert_initialized!();
8578 ToValue::to_value(&v)
8579 }
8580}
8581
8582#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
8584#[non_exhaustive]
8585#[doc(alias = "GtkPanDirection")]
8586pub enum PanDirection {
8587 #[doc(alias = "GTK_PAN_DIRECTION_LEFT")]
8589 Left,
8590 #[doc(alias = "GTK_PAN_DIRECTION_RIGHT")]
8592 Right,
8593 #[doc(alias = "GTK_PAN_DIRECTION_UP")]
8595 Up,
8596 #[doc(alias = "GTK_PAN_DIRECTION_DOWN")]
8598 Down,
8599 #[doc(hidden)]
8600 __Unknown(i32),
8601}
8602
8603#[doc(hidden)]
8604impl IntoGlib for PanDirection {
8605 type GlibType = ffi::GtkPanDirection;
8606
8607 #[inline]
8608 fn into_glib(self) -> ffi::GtkPanDirection {
8609 match self {
8610 Self::Left => ffi::GTK_PAN_DIRECTION_LEFT,
8611 Self::Right => ffi::GTK_PAN_DIRECTION_RIGHT,
8612 Self::Up => ffi::GTK_PAN_DIRECTION_UP,
8613 Self::Down => ffi::GTK_PAN_DIRECTION_DOWN,
8614 Self::__Unknown(value) => value,
8615 }
8616 }
8617}
8618
8619#[doc(hidden)]
8620impl FromGlib<ffi::GtkPanDirection> for PanDirection {
8621 #[inline]
8622 unsafe fn from_glib(value: ffi::GtkPanDirection) -> Self {
8623 skip_assert_initialized!();
8624
8625 match value {
8626 ffi::GTK_PAN_DIRECTION_LEFT => Self::Left,
8627 ffi::GTK_PAN_DIRECTION_RIGHT => Self::Right,
8628 ffi::GTK_PAN_DIRECTION_UP => Self::Up,
8629 ffi::GTK_PAN_DIRECTION_DOWN => Self::Down,
8630 value => Self::__Unknown(value),
8631 }
8632 }
8633}
8634
8635impl StaticType for PanDirection {
8636 #[inline]
8637 #[doc(alias = "gtk_pan_direction_get_type")]
8638 fn static_type() -> glib::Type {
8639 unsafe { from_glib(ffi::gtk_pan_direction_get_type()) }
8640 }
8641}
8642
8643impl glib::HasParamSpec for PanDirection {
8644 type ParamSpec = glib::ParamSpecEnum;
8645 type SetValue = Self;
8646 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
8647
8648 fn param_spec_builder() -> Self::BuilderFn {
8649 Self::ParamSpec::builder_with_default
8650 }
8651}
8652
8653impl glib::value::ValueType for PanDirection {
8654 type Type = Self;
8655}
8656
8657unsafe impl<'a> glib::value::FromValue<'a> for PanDirection {
8658 type Checker = glib::value::GenericValueTypeChecker<Self>;
8659
8660 #[inline]
8661 unsafe fn from_value(value: &'a glib::Value) -> Self {
8662 skip_assert_initialized!();
8663 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
8664 }
8665}
8666
8667impl ToValue for PanDirection {
8668 #[inline]
8669 fn to_value(&self) -> glib::Value {
8670 let mut value = glib::Value::for_value_type::<Self>();
8671 unsafe {
8672 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
8673 }
8674 value
8675 }
8676
8677 #[inline]
8678 fn value_type(&self) -> glib::Type {
8679 Self::static_type()
8680 }
8681}
8682
8683impl From<PanDirection> for glib::Value {
8684 #[inline]
8685 fn from(v: PanDirection) -> Self {
8686 skip_assert_initialized!();
8687 ToValue::to_value(&v)
8688 }
8689}
8690
8691#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
8694#[non_exhaustive]
8695#[doc(alias = "GtkPolicyType")]
8696pub enum PolicyType {
8697 #[doc(alias = "GTK_POLICY_ALWAYS")]
8700 Always,
8701 #[doc(alias = "GTK_POLICY_AUTOMATIC")]
8704 Automatic,
8705 #[doc(alias = "GTK_POLICY_NEVER")]
8708 Never,
8709 #[doc(alias = "GTK_POLICY_EXTERNAL")]
8713 External,
8714 #[doc(hidden)]
8715 __Unknown(i32),
8716}
8717
8718#[doc(hidden)]
8719impl IntoGlib for PolicyType {
8720 type GlibType = ffi::GtkPolicyType;
8721
8722 #[inline]
8723 fn into_glib(self) -> ffi::GtkPolicyType {
8724 match self {
8725 Self::Always => ffi::GTK_POLICY_ALWAYS,
8726 Self::Automatic => ffi::GTK_POLICY_AUTOMATIC,
8727 Self::Never => ffi::GTK_POLICY_NEVER,
8728 Self::External => ffi::GTK_POLICY_EXTERNAL,
8729 Self::__Unknown(value) => value,
8730 }
8731 }
8732}
8733
8734#[doc(hidden)]
8735impl FromGlib<ffi::GtkPolicyType> for PolicyType {
8736 #[inline]
8737 unsafe fn from_glib(value: ffi::GtkPolicyType) -> Self {
8738 skip_assert_initialized!();
8739
8740 match value {
8741 ffi::GTK_POLICY_ALWAYS => Self::Always,
8742 ffi::GTK_POLICY_AUTOMATIC => Self::Automatic,
8743 ffi::GTK_POLICY_NEVER => Self::Never,
8744 ffi::GTK_POLICY_EXTERNAL => Self::External,
8745 value => Self::__Unknown(value),
8746 }
8747 }
8748}
8749
8750impl StaticType for PolicyType {
8751 #[inline]
8752 #[doc(alias = "gtk_policy_type_get_type")]
8753 fn static_type() -> glib::Type {
8754 unsafe { from_glib(ffi::gtk_policy_type_get_type()) }
8755 }
8756}
8757
8758impl glib::HasParamSpec for PolicyType {
8759 type ParamSpec = glib::ParamSpecEnum;
8760 type SetValue = Self;
8761 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
8762
8763 fn param_spec_builder() -> Self::BuilderFn {
8764 Self::ParamSpec::builder_with_default
8765 }
8766}
8767
8768impl glib::value::ValueType for PolicyType {
8769 type Type = Self;
8770}
8771
8772unsafe impl<'a> glib::value::FromValue<'a> for PolicyType {
8773 type Checker = glib::value::GenericValueTypeChecker<Self>;
8774
8775 #[inline]
8776 unsafe fn from_value(value: &'a glib::Value) -> Self {
8777 skip_assert_initialized!();
8778 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
8779 }
8780}
8781
8782impl ToValue for PolicyType {
8783 #[inline]
8784 fn to_value(&self) -> glib::Value {
8785 let mut value = glib::Value::for_value_type::<Self>();
8786 unsafe {
8787 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
8788 }
8789 value
8790 }
8791
8792 #[inline]
8793 fn value_type(&self) -> glib::Type {
8794 Self::static_type()
8795 }
8796}
8797
8798impl From<PolicyType> for glib::Value {
8799 #[inline]
8800 fn from(v: PolicyType) -> Self {
8801 skip_assert_initialized!();
8802 ToValue::to_value(&v)
8803 }
8804}
8805
8806#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
8811#[non_exhaustive]
8812#[doc(alias = "GtkPositionType")]
8813pub enum PositionType {
8814 #[doc(alias = "GTK_POS_LEFT")]
8816 Left,
8817 #[doc(alias = "GTK_POS_RIGHT")]
8819 Right,
8820 #[doc(alias = "GTK_POS_TOP")]
8822 Top,
8823 #[doc(alias = "GTK_POS_BOTTOM")]
8825 Bottom,
8826 #[doc(hidden)]
8827 __Unknown(i32),
8828}
8829
8830#[doc(hidden)]
8831impl IntoGlib for PositionType {
8832 type GlibType = ffi::GtkPositionType;
8833
8834 #[inline]
8835 fn into_glib(self) -> ffi::GtkPositionType {
8836 match self {
8837 Self::Left => ffi::GTK_POS_LEFT,
8838 Self::Right => ffi::GTK_POS_RIGHT,
8839 Self::Top => ffi::GTK_POS_TOP,
8840 Self::Bottom => ffi::GTK_POS_BOTTOM,
8841 Self::__Unknown(value) => value,
8842 }
8843 }
8844}
8845
8846#[doc(hidden)]
8847impl FromGlib<ffi::GtkPositionType> for PositionType {
8848 #[inline]
8849 unsafe fn from_glib(value: ffi::GtkPositionType) -> Self {
8850 skip_assert_initialized!();
8851
8852 match value {
8853 ffi::GTK_POS_LEFT => Self::Left,
8854 ffi::GTK_POS_RIGHT => Self::Right,
8855 ffi::GTK_POS_TOP => Self::Top,
8856 ffi::GTK_POS_BOTTOM => Self::Bottom,
8857 value => Self::__Unknown(value),
8858 }
8859 }
8860}
8861
8862impl StaticType for PositionType {
8863 #[inline]
8864 #[doc(alias = "gtk_position_type_get_type")]
8865 fn static_type() -> glib::Type {
8866 unsafe { from_glib(ffi::gtk_position_type_get_type()) }
8867 }
8868}
8869
8870impl glib::HasParamSpec for PositionType {
8871 type ParamSpec = glib::ParamSpecEnum;
8872 type SetValue = Self;
8873 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
8874
8875 fn param_spec_builder() -> Self::BuilderFn {
8876 Self::ParamSpec::builder_with_default
8877 }
8878}
8879
8880impl glib::value::ValueType for PositionType {
8881 type Type = Self;
8882}
8883
8884unsafe impl<'a> glib::value::FromValue<'a> for PositionType {
8885 type Checker = glib::value::GenericValueTypeChecker<Self>;
8886
8887 #[inline]
8888 unsafe fn from_value(value: &'a glib::Value) -> Self {
8889 skip_assert_initialized!();
8890 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
8891 }
8892}
8893
8894impl ToValue for PositionType {
8895 #[inline]
8896 fn to_value(&self) -> glib::Value {
8897 let mut value = glib::Value::for_value_type::<Self>();
8898 unsafe {
8899 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
8900 }
8901 value
8902 }
8903
8904 #[inline]
8905 fn value_type(&self) -> glib::Type {
8906 Self::static_type()
8907 }
8908}
8909
8910impl From<PositionType> for glib::Value {
8911 #[inline]
8912 fn from(v: PositionType) -> Self {
8913 skip_assert_initialized!();
8914 ToValue::to_value(&v)
8915 }
8916}
8917
8918#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
8920#[non_exhaustive]
8921#[doc(alias = "GtkPrintDuplex")]
8922pub enum PrintDuplex {
8923 #[doc(alias = "GTK_PRINT_DUPLEX_SIMPLEX")]
8925 Simplex,
8926 #[doc(alias = "GTK_PRINT_DUPLEX_HORIZONTAL")]
8928 Horizontal,
8929 #[doc(alias = "GTK_PRINT_DUPLEX_VERTICAL")]
8931 Vertical,
8932 #[doc(hidden)]
8933 __Unknown(i32),
8934}
8935
8936#[doc(hidden)]
8937impl IntoGlib for PrintDuplex {
8938 type GlibType = ffi::GtkPrintDuplex;
8939
8940 #[inline]
8941 fn into_glib(self) -> ffi::GtkPrintDuplex {
8942 match self {
8943 Self::Simplex => ffi::GTK_PRINT_DUPLEX_SIMPLEX,
8944 Self::Horizontal => ffi::GTK_PRINT_DUPLEX_HORIZONTAL,
8945 Self::Vertical => ffi::GTK_PRINT_DUPLEX_VERTICAL,
8946 Self::__Unknown(value) => value,
8947 }
8948 }
8949}
8950
8951#[doc(hidden)]
8952impl FromGlib<ffi::GtkPrintDuplex> for PrintDuplex {
8953 #[inline]
8954 unsafe fn from_glib(value: ffi::GtkPrintDuplex) -> Self {
8955 skip_assert_initialized!();
8956
8957 match value {
8958 ffi::GTK_PRINT_DUPLEX_SIMPLEX => Self::Simplex,
8959 ffi::GTK_PRINT_DUPLEX_HORIZONTAL => Self::Horizontal,
8960 ffi::GTK_PRINT_DUPLEX_VERTICAL => Self::Vertical,
8961 value => Self::__Unknown(value),
8962 }
8963 }
8964}
8965
8966impl StaticType for PrintDuplex {
8967 #[inline]
8968 #[doc(alias = "gtk_print_duplex_get_type")]
8969 fn static_type() -> glib::Type {
8970 unsafe { from_glib(ffi::gtk_print_duplex_get_type()) }
8971 }
8972}
8973
8974impl glib::HasParamSpec for PrintDuplex {
8975 type ParamSpec = glib::ParamSpecEnum;
8976 type SetValue = Self;
8977 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
8978
8979 fn param_spec_builder() -> Self::BuilderFn {
8980 Self::ParamSpec::builder_with_default
8981 }
8982}
8983
8984impl glib::value::ValueType for PrintDuplex {
8985 type Type = Self;
8986}
8987
8988unsafe impl<'a> glib::value::FromValue<'a> for PrintDuplex {
8989 type Checker = glib::value::GenericValueTypeChecker<Self>;
8990
8991 #[inline]
8992 unsafe fn from_value(value: &'a glib::Value) -> Self {
8993 skip_assert_initialized!();
8994 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
8995 }
8996}
8997
8998impl ToValue for PrintDuplex {
8999 #[inline]
9000 fn to_value(&self) -> glib::Value {
9001 let mut value = glib::Value::for_value_type::<Self>();
9002 unsafe {
9003 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
9004 }
9005 value
9006 }
9007
9008 #[inline]
9009 fn value_type(&self) -> glib::Type {
9010 Self::static_type()
9011 }
9012}
9013
9014impl From<PrintDuplex> for glib::Value {
9015 #[inline]
9016 fn from(v: PrintDuplex) -> Self {
9017 skip_assert_initialized!();
9018 ToValue::to_value(&v)
9019 }
9020}
9021
9022#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
9025#[non_exhaustive]
9026#[doc(alias = "GtkPrintError")]
9027pub enum PrintError {
9028 #[doc(alias = "GTK_PRINT_ERROR_GENERAL")]
9030 General,
9031 #[doc(alias = "GTK_PRINT_ERROR_INTERNAL_ERROR")]
9033 InternalError,
9034 #[doc(alias = "GTK_PRINT_ERROR_NOMEM")]
9036 Nomem,
9037 #[doc(alias = "GTK_PRINT_ERROR_INVALID_FILE")]
9040 InvalidFile,
9041 #[doc(hidden)]
9042 __Unknown(i32),
9043}
9044
9045#[doc(hidden)]
9046impl IntoGlib for PrintError {
9047 type GlibType = ffi::GtkPrintError;
9048
9049 #[inline]
9050 fn into_glib(self) -> ffi::GtkPrintError {
9051 match self {
9052 Self::General => ffi::GTK_PRINT_ERROR_GENERAL,
9053 Self::InternalError => ffi::GTK_PRINT_ERROR_INTERNAL_ERROR,
9054 Self::Nomem => ffi::GTK_PRINT_ERROR_NOMEM,
9055 Self::InvalidFile => ffi::GTK_PRINT_ERROR_INVALID_FILE,
9056 Self::__Unknown(value) => value,
9057 }
9058 }
9059}
9060
9061#[doc(hidden)]
9062impl FromGlib<ffi::GtkPrintError> for PrintError {
9063 #[inline]
9064 unsafe fn from_glib(value: ffi::GtkPrintError) -> Self {
9065 skip_assert_initialized!();
9066
9067 match value {
9068 ffi::GTK_PRINT_ERROR_GENERAL => Self::General,
9069 ffi::GTK_PRINT_ERROR_INTERNAL_ERROR => Self::InternalError,
9070 ffi::GTK_PRINT_ERROR_NOMEM => Self::Nomem,
9071 ffi::GTK_PRINT_ERROR_INVALID_FILE => Self::InvalidFile,
9072 value => Self::__Unknown(value),
9073 }
9074 }
9075}
9076
9077impl glib::error::ErrorDomain for PrintError {
9078 #[inline]
9079 fn domain() -> glib::Quark {
9080 skip_assert_initialized!();
9081
9082 unsafe { from_glib(ffi::gtk_print_error_quark()) }
9083 }
9084
9085 #[inline]
9086 fn code(self) -> i32 {
9087 self.into_glib()
9088 }
9089
9090 #[inline]
9091 #[allow(clippy::match_single_binding)]
9092 fn from(code: i32) -> Option<Self> {
9093 skip_assert_initialized!();
9094 match unsafe { from_glib(code) } {
9095 value => Some(value),
9096 }
9097 }
9098}
9099
9100impl StaticType for PrintError {
9101 #[inline]
9102 #[doc(alias = "gtk_print_error_get_type")]
9103 fn static_type() -> glib::Type {
9104 unsafe { from_glib(ffi::gtk_print_error_get_type()) }
9105 }
9106}
9107
9108impl glib::HasParamSpec for PrintError {
9109 type ParamSpec = glib::ParamSpecEnum;
9110 type SetValue = Self;
9111 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
9112
9113 fn param_spec_builder() -> Self::BuilderFn {
9114 Self::ParamSpec::builder_with_default
9115 }
9116}
9117
9118impl glib::value::ValueType for PrintError {
9119 type Type = Self;
9120}
9121
9122unsafe impl<'a> glib::value::FromValue<'a> for PrintError {
9123 type Checker = glib::value::GenericValueTypeChecker<Self>;
9124
9125 #[inline]
9126 unsafe fn from_value(value: &'a glib::Value) -> Self {
9127 skip_assert_initialized!();
9128 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
9129 }
9130}
9131
9132impl ToValue for PrintError {
9133 #[inline]
9134 fn to_value(&self) -> glib::Value {
9135 let mut value = glib::Value::for_value_type::<Self>();
9136 unsafe {
9137 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
9138 }
9139 value
9140 }
9141
9142 #[inline]
9143 fn value_type(&self) -> glib::Type {
9144 Self::static_type()
9145 }
9146}
9147
9148impl From<PrintError> for glib::Value {
9149 #[inline]
9150 fn from(v: PrintError) -> Self {
9151 skip_assert_initialized!();
9152 ToValue::to_value(&v)
9153 }
9154}
9155
9156#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
9160#[non_exhaustive]
9161#[doc(alias = "GtkPrintOperationAction")]
9162pub enum PrintOperationAction {
9163 #[doc(alias = "GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG")]
9165 PrintDialog,
9166 #[doc(alias = "GTK_PRINT_OPERATION_ACTION_PRINT")]
9170 Print,
9171 #[doc(alias = "GTK_PRINT_OPERATION_ACTION_PREVIEW")]
9173 Preview,
9174 #[doc(alias = "GTK_PRINT_OPERATION_ACTION_EXPORT")]
9177 Export,
9178 #[doc(hidden)]
9179 __Unknown(i32),
9180}
9181
9182#[doc(hidden)]
9183impl IntoGlib for PrintOperationAction {
9184 type GlibType = ffi::GtkPrintOperationAction;
9185
9186 #[inline]
9187 fn into_glib(self) -> ffi::GtkPrintOperationAction {
9188 match self {
9189 Self::PrintDialog => ffi::GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG,
9190 Self::Print => ffi::GTK_PRINT_OPERATION_ACTION_PRINT,
9191 Self::Preview => ffi::GTK_PRINT_OPERATION_ACTION_PREVIEW,
9192 Self::Export => ffi::GTK_PRINT_OPERATION_ACTION_EXPORT,
9193 Self::__Unknown(value) => value,
9194 }
9195 }
9196}
9197
9198#[doc(hidden)]
9199impl FromGlib<ffi::GtkPrintOperationAction> for PrintOperationAction {
9200 #[inline]
9201 unsafe fn from_glib(value: ffi::GtkPrintOperationAction) -> Self {
9202 skip_assert_initialized!();
9203
9204 match value {
9205 ffi::GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG => Self::PrintDialog,
9206 ffi::GTK_PRINT_OPERATION_ACTION_PRINT => Self::Print,
9207 ffi::GTK_PRINT_OPERATION_ACTION_PREVIEW => Self::Preview,
9208 ffi::GTK_PRINT_OPERATION_ACTION_EXPORT => Self::Export,
9209 value => Self::__Unknown(value),
9210 }
9211 }
9212}
9213
9214impl StaticType for PrintOperationAction {
9215 #[inline]
9216 #[doc(alias = "gtk_print_operation_action_get_type")]
9217 fn static_type() -> glib::Type {
9218 unsafe { from_glib(ffi::gtk_print_operation_action_get_type()) }
9219 }
9220}
9221
9222impl glib::HasParamSpec for PrintOperationAction {
9223 type ParamSpec = glib::ParamSpecEnum;
9224 type SetValue = Self;
9225 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
9226
9227 fn param_spec_builder() -> Self::BuilderFn {
9228 Self::ParamSpec::builder_with_default
9229 }
9230}
9231
9232impl glib::value::ValueType for PrintOperationAction {
9233 type Type = Self;
9234}
9235
9236unsafe impl<'a> glib::value::FromValue<'a> for PrintOperationAction {
9237 type Checker = glib::value::GenericValueTypeChecker<Self>;
9238
9239 #[inline]
9240 unsafe fn from_value(value: &'a glib::Value) -> Self {
9241 skip_assert_initialized!();
9242 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
9243 }
9244}
9245
9246impl ToValue for PrintOperationAction {
9247 #[inline]
9248 fn to_value(&self) -> glib::Value {
9249 let mut value = glib::Value::for_value_type::<Self>();
9250 unsafe {
9251 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
9252 }
9253 value
9254 }
9255
9256 #[inline]
9257 fn value_type(&self) -> glib::Type {
9258 Self::static_type()
9259 }
9260}
9261
9262impl From<PrintOperationAction> for glib::Value {
9263 #[inline]
9264 fn from(v: PrintOperationAction) -> Self {
9265 skip_assert_initialized!();
9266 ToValue::to_value(&v)
9267 }
9268}
9269
9270#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
9274#[non_exhaustive]
9275#[doc(alias = "GtkPrintOperationResult")]
9276pub enum PrintOperationResult {
9277 #[doc(alias = "GTK_PRINT_OPERATION_RESULT_ERROR")]
9279 Error,
9280 #[doc(alias = "GTK_PRINT_OPERATION_RESULT_APPLY")]
9282 Apply,
9283 #[doc(alias = "GTK_PRINT_OPERATION_RESULT_CANCEL")]
9286 Cancel,
9287 #[doc(alias = "GTK_PRINT_OPERATION_RESULT_IN_PROGRESS")]
9290 InProgress,
9291 #[doc(hidden)]
9292 __Unknown(i32),
9293}
9294
9295#[doc(hidden)]
9296impl IntoGlib for PrintOperationResult {
9297 type GlibType = ffi::GtkPrintOperationResult;
9298
9299 #[inline]
9300 fn into_glib(self) -> ffi::GtkPrintOperationResult {
9301 match self {
9302 Self::Error => ffi::GTK_PRINT_OPERATION_RESULT_ERROR,
9303 Self::Apply => ffi::GTK_PRINT_OPERATION_RESULT_APPLY,
9304 Self::Cancel => ffi::GTK_PRINT_OPERATION_RESULT_CANCEL,
9305 Self::InProgress => ffi::GTK_PRINT_OPERATION_RESULT_IN_PROGRESS,
9306 Self::__Unknown(value) => value,
9307 }
9308 }
9309}
9310
9311#[doc(hidden)]
9312impl FromGlib<ffi::GtkPrintOperationResult> for PrintOperationResult {
9313 #[inline]
9314 unsafe fn from_glib(value: ffi::GtkPrintOperationResult) -> Self {
9315 skip_assert_initialized!();
9316
9317 match value {
9318 ffi::GTK_PRINT_OPERATION_RESULT_ERROR => Self::Error,
9319 ffi::GTK_PRINT_OPERATION_RESULT_APPLY => Self::Apply,
9320 ffi::GTK_PRINT_OPERATION_RESULT_CANCEL => Self::Cancel,
9321 ffi::GTK_PRINT_OPERATION_RESULT_IN_PROGRESS => Self::InProgress,
9322 value => Self::__Unknown(value),
9323 }
9324 }
9325}
9326
9327impl StaticType for PrintOperationResult {
9328 #[inline]
9329 #[doc(alias = "gtk_print_operation_result_get_type")]
9330 fn static_type() -> glib::Type {
9331 unsafe { from_glib(ffi::gtk_print_operation_result_get_type()) }
9332 }
9333}
9334
9335impl glib::HasParamSpec for PrintOperationResult {
9336 type ParamSpec = glib::ParamSpecEnum;
9337 type SetValue = Self;
9338 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
9339
9340 fn param_spec_builder() -> Self::BuilderFn {
9341 Self::ParamSpec::builder_with_default
9342 }
9343}
9344
9345impl glib::value::ValueType for PrintOperationResult {
9346 type Type = Self;
9347}
9348
9349unsafe impl<'a> glib::value::FromValue<'a> for PrintOperationResult {
9350 type Checker = glib::value::GenericValueTypeChecker<Self>;
9351
9352 #[inline]
9353 unsafe fn from_value(value: &'a glib::Value) -> Self {
9354 skip_assert_initialized!();
9355 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
9356 }
9357}
9358
9359impl ToValue for PrintOperationResult {
9360 #[inline]
9361 fn to_value(&self) -> glib::Value {
9362 let mut value = glib::Value::for_value_type::<Self>();
9363 unsafe {
9364 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
9365 }
9366 value
9367 }
9368
9369 #[inline]
9370 fn value_type(&self) -> glib::Type {
9371 Self::static_type()
9372 }
9373}
9374
9375impl From<PrintOperationResult> for glib::Value {
9376 #[inline]
9377 fn from(v: PrintOperationResult) -> Self {
9378 skip_assert_initialized!();
9379 ToValue::to_value(&v)
9380 }
9381}
9382
9383#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
9385#[non_exhaustive]
9386#[doc(alias = "GtkPrintPages")]
9387pub enum PrintPages {
9388 #[doc(alias = "GTK_PRINT_PAGES_ALL")]
9390 All,
9391 #[doc(alias = "GTK_PRINT_PAGES_CURRENT")]
9393 Current,
9394 #[doc(alias = "GTK_PRINT_PAGES_RANGES")]
9396 Ranges,
9397 #[doc(alias = "GTK_PRINT_PAGES_SELECTION")]
9399 Selection,
9400 #[doc(hidden)]
9401 __Unknown(i32),
9402}
9403
9404#[doc(hidden)]
9405impl IntoGlib for PrintPages {
9406 type GlibType = ffi::GtkPrintPages;
9407
9408 #[inline]
9409 fn into_glib(self) -> ffi::GtkPrintPages {
9410 match self {
9411 Self::All => ffi::GTK_PRINT_PAGES_ALL,
9412 Self::Current => ffi::GTK_PRINT_PAGES_CURRENT,
9413 Self::Ranges => ffi::GTK_PRINT_PAGES_RANGES,
9414 Self::Selection => ffi::GTK_PRINT_PAGES_SELECTION,
9415 Self::__Unknown(value) => value,
9416 }
9417 }
9418}
9419
9420#[doc(hidden)]
9421impl FromGlib<ffi::GtkPrintPages> for PrintPages {
9422 #[inline]
9423 unsafe fn from_glib(value: ffi::GtkPrintPages) -> Self {
9424 skip_assert_initialized!();
9425
9426 match value {
9427 ffi::GTK_PRINT_PAGES_ALL => Self::All,
9428 ffi::GTK_PRINT_PAGES_CURRENT => Self::Current,
9429 ffi::GTK_PRINT_PAGES_RANGES => Self::Ranges,
9430 ffi::GTK_PRINT_PAGES_SELECTION => Self::Selection,
9431 value => Self::__Unknown(value),
9432 }
9433 }
9434}
9435
9436impl StaticType for PrintPages {
9437 #[inline]
9438 #[doc(alias = "gtk_print_pages_get_type")]
9439 fn static_type() -> glib::Type {
9440 unsafe { from_glib(ffi::gtk_print_pages_get_type()) }
9441 }
9442}
9443
9444impl glib::HasParamSpec for PrintPages {
9445 type ParamSpec = glib::ParamSpecEnum;
9446 type SetValue = Self;
9447 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
9448
9449 fn param_spec_builder() -> Self::BuilderFn {
9450 Self::ParamSpec::builder_with_default
9451 }
9452}
9453
9454impl glib::value::ValueType for PrintPages {
9455 type Type = Self;
9456}
9457
9458unsafe impl<'a> glib::value::FromValue<'a> for PrintPages {
9459 type Checker = glib::value::GenericValueTypeChecker<Self>;
9460
9461 #[inline]
9462 unsafe fn from_value(value: &'a glib::Value) -> Self {
9463 skip_assert_initialized!();
9464 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
9465 }
9466}
9467
9468impl ToValue for PrintPages {
9469 #[inline]
9470 fn to_value(&self) -> glib::Value {
9471 let mut value = glib::Value::for_value_type::<Self>();
9472 unsafe {
9473 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
9474 }
9475 value
9476 }
9477
9478 #[inline]
9479 fn value_type(&self) -> glib::Type {
9480 Self::static_type()
9481 }
9482}
9483
9484impl From<PrintPages> for glib::Value {
9485 #[inline]
9486 fn from(v: PrintPages) -> Self {
9487 skip_assert_initialized!();
9488 ToValue::to_value(&v)
9489 }
9490}
9491
9492#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
9494#[non_exhaustive]
9495#[doc(alias = "GtkPrintQuality")]
9496pub enum PrintQuality {
9497 #[doc(alias = "GTK_PRINT_QUALITY_LOW")]
9499 Low,
9500 #[doc(alias = "GTK_PRINT_QUALITY_NORMAL")]
9502 Normal,
9503 #[doc(alias = "GTK_PRINT_QUALITY_HIGH")]
9505 High,
9506 #[doc(alias = "GTK_PRINT_QUALITY_DRAFT")]
9508 Draft,
9509 #[doc(hidden)]
9510 __Unknown(i32),
9511}
9512
9513#[doc(hidden)]
9514impl IntoGlib for PrintQuality {
9515 type GlibType = ffi::GtkPrintQuality;
9516
9517 #[inline]
9518 fn into_glib(self) -> ffi::GtkPrintQuality {
9519 match self {
9520 Self::Low => ffi::GTK_PRINT_QUALITY_LOW,
9521 Self::Normal => ffi::GTK_PRINT_QUALITY_NORMAL,
9522 Self::High => ffi::GTK_PRINT_QUALITY_HIGH,
9523 Self::Draft => ffi::GTK_PRINT_QUALITY_DRAFT,
9524 Self::__Unknown(value) => value,
9525 }
9526 }
9527}
9528
9529#[doc(hidden)]
9530impl FromGlib<ffi::GtkPrintQuality> for PrintQuality {
9531 #[inline]
9532 unsafe fn from_glib(value: ffi::GtkPrintQuality) -> Self {
9533 skip_assert_initialized!();
9534
9535 match value {
9536 ffi::GTK_PRINT_QUALITY_LOW => Self::Low,
9537 ffi::GTK_PRINT_QUALITY_NORMAL => Self::Normal,
9538 ffi::GTK_PRINT_QUALITY_HIGH => Self::High,
9539 ffi::GTK_PRINT_QUALITY_DRAFT => Self::Draft,
9540 value => Self::__Unknown(value),
9541 }
9542 }
9543}
9544
9545impl StaticType for PrintQuality {
9546 #[inline]
9547 #[doc(alias = "gtk_print_quality_get_type")]
9548 fn static_type() -> glib::Type {
9549 unsafe { from_glib(ffi::gtk_print_quality_get_type()) }
9550 }
9551}
9552
9553impl glib::HasParamSpec for PrintQuality {
9554 type ParamSpec = glib::ParamSpecEnum;
9555 type SetValue = Self;
9556 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
9557
9558 fn param_spec_builder() -> Self::BuilderFn {
9559 Self::ParamSpec::builder_with_default
9560 }
9561}
9562
9563impl glib::value::ValueType for PrintQuality {
9564 type Type = Self;
9565}
9566
9567unsafe impl<'a> glib::value::FromValue<'a> for PrintQuality {
9568 type Checker = glib::value::GenericValueTypeChecker<Self>;
9569
9570 #[inline]
9571 unsafe fn from_value(value: &'a glib::Value) -> Self {
9572 skip_assert_initialized!();
9573 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
9574 }
9575}
9576
9577impl ToValue for PrintQuality {
9578 #[inline]
9579 fn to_value(&self) -> glib::Value {
9580 let mut value = glib::Value::for_value_type::<Self>();
9581 unsafe {
9582 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
9583 }
9584 value
9585 }
9586
9587 #[inline]
9588 fn value_type(&self) -> glib::Type {
9589 Self::static_type()
9590 }
9591}
9592
9593impl From<PrintQuality> for glib::Value {
9594 #[inline]
9595 fn from(v: PrintQuality) -> Self {
9596 skip_assert_initialized!();
9597 ToValue::to_value(&v)
9598 }
9599}
9600
9601#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
9604#[non_exhaustive]
9605#[doc(alias = "GtkPrintStatus")]
9606pub enum PrintStatus {
9607 #[doc(alias = "GTK_PRINT_STATUS_INITIAL")]
9610 Initial,
9611 #[doc(alias = "GTK_PRINT_STATUS_PREPARING")]
9614 Preparing,
9615 #[doc(alias = "GTK_PRINT_STATUS_GENERATING_DATA")]
9618 GeneratingData,
9619 #[doc(alias = "GTK_PRINT_STATUS_SENDING_DATA")]
9622 SendingData,
9623 #[doc(alias = "GTK_PRINT_STATUS_PENDING")]
9626 Pending,
9627 #[doc(alias = "GTK_PRINT_STATUS_PENDING_ISSUE")]
9630 PendingIssue,
9631 #[doc(alias = "GTK_PRINT_STATUS_PRINTING")]
9633 Printing,
9634 #[doc(alias = "GTK_PRINT_STATUS_FINISHED")]
9636 Finished,
9637 #[doc(alias = "GTK_PRINT_STATUS_FINISHED_ABORTED")]
9639 FinishedAborted,
9640 #[doc(hidden)]
9641 __Unknown(i32),
9642}
9643
9644#[doc(hidden)]
9645impl IntoGlib for PrintStatus {
9646 type GlibType = ffi::GtkPrintStatus;
9647
9648 #[inline]
9649 fn into_glib(self) -> ffi::GtkPrintStatus {
9650 match self {
9651 Self::Initial => ffi::GTK_PRINT_STATUS_INITIAL,
9652 Self::Preparing => ffi::GTK_PRINT_STATUS_PREPARING,
9653 Self::GeneratingData => ffi::GTK_PRINT_STATUS_GENERATING_DATA,
9654 Self::SendingData => ffi::GTK_PRINT_STATUS_SENDING_DATA,
9655 Self::Pending => ffi::GTK_PRINT_STATUS_PENDING,
9656 Self::PendingIssue => ffi::GTK_PRINT_STATUS_PENDING_ISSUE,
9657 Self::Printing => ffi::GTK_PRINT_STATUS_PRINTING,
9658 Self::Finished => ffi::GTK_PRINT_STATUS_FINISHED,
9659 Self::FinishedAborted => ffi::GTK_PRINT_STATUS_FINISHED_ABORTED,
9660 Self::__Unknown(value) => value,
9661 }
9662 }
9663}
9664
9665#[doc(hidden)]
9666impl FromGlib<ffi::GtkPrintStatus> for PrintStatus {
9667 #[inline]
9668 unsafe fn from_glib(value: ffi::GtkPrintStatus) -> Self {
9669 skip_assert_initialized!();
9670
9671 match value {
9672 ffi::GTK_PRINT_STATUS_INITIAL => Self::Initial,
9673 ffi::GTK_PRINT_STATUS_PREPARING => Self::Preparing,
9674 ffi::GTK_PRINT_STATUS_GENERATING_DATA => Self::GeneratingData,
9675 ffi::GTK_PRINT_STATUS_SENDING_DATA => Self::SendingData,
9676 ffi::GTK_PRINT_STATUS_PENDING => Self::Pending,
9677 ffi::GTK_PRINT_STATUS_PENDING_ISSUE => Self::PendingIssue,
9678 ffi::GTK_PRINT_STATUS_PRINTING => Self::Printing,
9679 ffi::GTK_PRINT_STATUS_FINISHED => Self::Finished,
9680 ffi::GTK_PRINT_STATUS_FINISHED_ABORTED => Self::FinishedAborted,
9681 value => Self::__Unknown(value),
9682 }
9683 }
9684}
9685
9686impl StaticType for PrintStatus {
9687 #[inline]
9688 #[doc(alias = "gtk_print_status_get_type")]
9689 fn static_type() -> glib::Type {
9690 unsafe { from_glib(ffi::gtk_print_status_get_type()) }
9691 }
9692}
9693
9694impl glib::HasParamSpec for PrintStatus {
9695 type ParamSpec = glib::ParamSpecEnum;
9696 type SetValue = Self;
9697 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
9698
9699 fn param_spec_builder() -> Self::BuilderFn {
9700 Self::ParamSpec::builder_with_default
9701 }
9702}
9703
9704impl glib::value::ValueType for PrintStatus {
9705 type Type = Self;
9706}
9707
9708unsafe impl<'a> glib::value::FromValue<'a> for PrintStatus {
9709 type Checker = glib::value::GenericValueTypeChecker<Self>;
9710
9711 #[inline]
9712 unsafe fn from_value(value: &'a glib::Value) -> Self {
9713 skip_assert_initialized!();
9714 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
9715 }
9716}
9717
9718impl ToValue for PrintStatus {
9719 #[inline]
9720 fn to_value(&self) -> glib::Value {
9721 let mut value = glib::Value::for_value_type::<Self>();
9722 unsafe {
9723 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
9724 }
9725 value
9726 }
9727
9728 #[inline]
9729 fn value_type(&self) -> glib::Type {
9730 Self::static_type()
9731 }
9732}
9733
9734impl From<PrintStatus> for glib::Value {
9735 #[inline]
9736 fn from(v: PrintStatus) -> Self {
9737 skip_assert_initialized!();
9738 ToValue::to_value(&v)
9739 }
9740}
9741
9742#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
9745#[non_exhaustive]
9746#[doc(alias = "GtkPropagationLimit")]
9747pub enum PropagationLimit {
9748 #[doc(alias = "GTK_LIMIT_NONE")]
9751 None,
9752 #[doc(alias = "GTK_LIMIT_SAME_NATIVE")]
9757 SameNative,
9758 #[doc(hidden)]
9759 __Unknown(i32),
9760}
9761
9762#[doc(hidden)]
9763impl IntoGlib for PropagationLimit {
9764 type GlibType = ffi::GtkPropagationLimit;
9765
9766 #[inline]
9767 fn into_glib(self) -> ffi::GtkPropagationLimit {
9768 match self {
9769 Self::None => ffi::GTK_LIMIT_NONE,
9770 Self::SameNative => ffi::GTK_LIMIT_SAME_NATIVE,
9771 Self::__Unknown(value) => value,
9772 }
9773 }
9774}
9775
9776#[doc(hidden)]
9777impl FromGlib<ffi::GtkPropagationLimit> for PropagationLimit {
9778 #[inline]
9779 unsafe fn from_glib(value: ffi::GtkPropagationLimit) -> Self {
9780 skip_assert_initialized!();
9781
9782 match value {
9783 ffi::GTK_LIMIT_NONE => Self::None,
9784 ffi::GTK_LIMIT_SAME_NATIVE => Self::SameNative,
9785 value => Self::__Unknown(value),
9786 }
9787 }
9788}
9789
9790impl StaticType for PropagationLimit {
9791 #[inline]
9792 #[doc(alias = "gtk_propagation_limit_get_type")]
9793 fn static_type() -> glib::Type {
9794 unsafe { from_glib(ffi::gtk_propagation_limit_get_type()) }
9795 }
9796}
9797
9798impl glib::HasParamSpec for PropagationLimit {
9799 type ParamSpec = glib::ParamSpecEnum;
9800 type SetValue = Self;
9801 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
9802
9803 fn param_spec_builder() -> Self::BuilderFn {
9804 Self::ParamSpec::builder_with_default
9805 }
9806}
9807
9808impl glib::value::ValueType for PropagationLimit {
9809 type Type = Self;
9810}
9811
9812unsafe impl<'a> glib::value::FromValue<'a> for PropagationLimit {
9813 type Checker = glib::value::GenericValueTypeChecker<Self>;
9814
9815 #[inline]
9816 unsafe fn from_value(value: &'a glib::Value) -> Self {
9817 skip_assert_initialized!();
9818 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
9819 }
9820}
9821
9822impl ToValue for PropagationLimit {
9823 #[inline]
9824 fn to_value(&self) -> glib::Value {
9825 let mut value = glib::Value::for_value_type::<Self>();
9826 unsafe {
9827 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
9828 }
9829 value
9830 }
9831
9832 #[inline]
9833 fn value_type(&self) -> glib::Type {
9834 Self::static_type()
9835 }
9836}
9837
9838impl From<PropagationLimit> for glib::Value {
9839 #[inline]
9840 fn from(v: PropagationLimit) -> Self {
9841 skip_assert_initialized!();
9842 ToValue::to_value(&v)
9843 }
9844}
9845
9846#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
9848#[non_exhaustive]
9849#[doc(alias = "GtkPropagationPhase")]
9850pub enum PropagationPhase {
9851 #[doc(alias = "GTK_PHASE_NONE")]
9853 None,
9854 #[doc(alias = "GTK_PHASE_CAPTURE")]
9859 Capture,
9860 #[doc(alias = "GTK_PHASE_BUBBLE")]
9864 Bubble,
9865 #[doc(alias = "GTK_PHASE_TARGET")]
9869 Target,
9870 #[doc(hidden)]
9871 __Unknown(i32),
9872}
9873
9874#[doc(hidden)]
9875impl IntoGlib for PropagationPhase {
9876 type GlibType = ffi::GtkPropagationPhase;
9877
9878 #[inline]
9879 fn into_glib(self) -> ffi::GtkPropagationPhase {
9880 match self {
9881 Self::None => ffi::GTK_PHASE_NONE,
9882 Self::Capture => ffi::GTK_PHASE_CAPTURE,
9883 Self::Bubble => ffi::GTK_PHASE_BUBBLE,
9884 Self::Target => ffi::GTK_PHASE_TARGET,
9885 Self::__Unknown(value) => value,
9886 }
9887 }
9888}
9889
9890#[doc(hidden)]
9891impl FromGlib<ffi::GtkPropagationPhase> for PropagationPhase {
9892 #[inline]
9893 unsafe fn from_glib(value: ffi::GtkPropagationPhase) -> Self {
9894 skip_assert_initialized!();
9895
9896 match value {
9897 ffi::GTK_PHASE_NONE => Self::None,
9898 ffi::GTK_PHASE_CAPTURE => Self::Capture,
9899 ffi::GTK_PHASE_BUBBLE => Self::Bubble,
9900 ffi::GTK_PHASE_TARGET => Self::Target,
9901 value => Self::__Unknown(value),
9902 }
9903 }
9904}
9905
9906impl StaticType for PropagationPhase {
9907 #[inline]
9908 #[doc(alias = "gtk_propagation_phase_get_type")]
9909 fn static_type() -> glib::Type {
9910 unsafe { from_glib(ffi::gtk_propagation_phase_get_type()) }
9911 }
9912}
9913
9914impl glib::HasParamSpec for PropagationPhase {
9915 type ParamSpec = glib::ParamSpecEnum;
9916 type SetValue = Self;
9917 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
9918
9919 fn param_spec_builder() -> Self::BuilderFn {
9920 Self::ParamSpec::builder_with_default
9921 }
9922}
9923
9924impl glib::value::ValueType for PropagationPhase {
9925 type Type = Self;
9926}
9927
9928unsafe impl<'a> glib::value::FromValue<'a> for PropagationPhase {
9929 type Checker = glib::value::GenericValueTypeChecker<Self>;
9930
9931 #[inline]
9932 unsafe fn from_value(value: &'a glib::Value) -> Self {
9933 skip_assert_initialized!();
9934 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
9935 }
9936}
9937
9938impl ToValue for PropagationPhase {
9939 #[inline]
9940 fn to_value(&self) -> glib::Value {
9941 let mut value = glib::Value::for_value_type::<Self>();
9942 unsafe {
9943 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
9944 }
9945 value
9946 }
9947
9948 #[inline]
9949 fn value_type(&self) -> glib::Type {
9950 Self::static_type()
9951 }
9952}
9953
9954impl From<PropagationPhase> for glib::Value {
9955 #[inline]
9956 fn from(v: PropagationPhase) -> Self {
9957 skip_assert_initialized!();
9958 ToValue::to_value(&v)
9959 }
9960}
9961
9962#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
9964#[non_exhaustive]
9965#[doc(alias = "GtkRecentManagerError")]
9966pub enum RecentManagerError {
9967 #[doc(alias = "GTK_RECENT_MANAGER_ERROR_NOT_FOUND")]
9970 NotFound,
9971 #[doc(alias = "GTK_RECENT_MANAGER_ERROR_INVALID_URI")]
9973 InvalidUri,
9974 #[doc(alias = "GTK_RECENT_MANAGER_ERROR_INVALID_ENCODING")]
9977 InvalidEncoding,
9978 #[doc(alias = "GTK_RECENT_MANAGER_ERROR_NOT_REGISTERED")]
9981 NotRegistered,
9982 #[doc(alias = "GTK_RECENT_MANAGER_ERROR_READ")]
9985 Read,
9986 #[doc(alias = "GTK_RECENT_MANAGER_ERROR_WRITE")]
9989 Write,
9990 #[doc(alias = "GTK_RECENT_MANAGER_ERROR_UNKNOWN")]
9992 Unknown,
9993 #[doc(hidden)]
9994 __Unknown(i32),
9995}
9996
9997#[doc(hidden)]
9998impl IntoGlib for RecentManagerError {
9999 type GlibType = ffi::GtkRecentManagerError;
10000
10001 #[inline]
10002 fn into_glib(self) -> ffi::GtkRecentManagerError {
10003 match self {
10004 Self::NotFound => ffi::GTK_RECENT_MANAGER_ERROR_NOT_FOUND,
10005 Self::InvalidUri => ffi::GTK_RECENT_MANAGER_ERROR_INVALID_URI,
10006 Self::InvalidEncoding => ffi::GTK_RECENT_MANAGER_ERROR_INVALID_ENCODING,
10007 Self::NotRegistered => ffi::GTK_RECENT_MANAGER_ERROR_NOT_REGISTERED,
10008 Self::Read => ffi::GTK_RECENT_MANAGER_ERROR_READ,
10009 Self::Write => ffi::GTK_RECENT_MANAGER_ERROR_WRITE,
10010 Self::Unknown => ffi::GTK_RECENT_MANAGER_ERROR_UNKNOWN,
10011 Self::__Unknown(value) => value,
10012 }
10013 }
10014}
10015
10016#[doc(hidden)]
10017impl FromGlib<ffi::GtkRecentManagerError> for RecentManagerError {
10018 #[inline]
10019 unsafe fn from_glib(value: ffi::GtkRecentManagerError) -> Self {
10020 skip_assert_initialized!();
10021
10022 match value {
10023 ffi::GTK_RECENT_MANAGER_ERROR_NOT_FOUND => Self::NotFound,
10024 ffi::GTK_RECENT_MANAGER_ERROR_INVALID_URI => Self::InvalidUri,
10025 ffi::GTK_RECENT_MANAGER_ERROR_INVALID_ENCODING => Self::InvalidEncoding,
10026 ffi::GTK_RECENT_MANAGER_ERROR_NOT_REGISTERED => Self::NotRegistered,
10027 ffi::GTK_RECENT_MANAGER_ERROR_READ => Self::Read,
10028 ffi::GTK_RECENT_MANAGER_ERROR_WRITE => Self::Write,
10029 ffi::GTK_RECENT_MANAGER_ERROR_UNKNOWN => Self::Unknown,
10030 value => Self::__Unknown(value),
10031 }
10032 }
10033}
10034
10035impl glib::error::ErrorDomain for RecentManagerError {
10036 #[inline]
10037 fn domain() -> glib::Quark {
10038 skip_assert_initialized!();
10039
10040 unsafe { from_glib(ffi::gtk_recent_manager_error_quark()) }
10041 }
10042
10043 #[inline]
10044 fn code(self) -> i32 {
10045 self.into_glib()
10046 }
10047
10048 #[inline]
10049 #[allow(clippy::match_single_binding)]
10050 fn from(code: i32) -> Option<Self> {
10051 skip_assert_initialized!();
10052 match unsafe { from_glib(code) } {
10053 value => Some(value),
10054 }
10055 }
10056}
10057
10058impl StaticType for RecentManagerError {
10059 #[inline]
10060 #[doc(alias = "gtk_recent_manager_error_get_type")]
10061 fn static_type() -> glib::Type {
10062 unsafe { from_glib(ffi::gtk_recent_manager_error_get_type()) }
10063 }
10064}
10065
10066impl glib::HasParamSpec for RecentManagerError {
10067 type ParamSpec = glib::ParamSpecEnum;
10068 type SetValue = Self;
10069 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
10070
10071 fn param_spec_builder() -> Self::BuilderFn {
10072 Self::ParamSpec::builder_with_default
10073 }
10074}
10075
10076impl glib::value::ValueType for RecentManagerError {
10077 type Type = Self;
10078}
10079
10080unsafe impl<'a> glib::value::FromValue<'a> for RecentManagerError {
10081 type Checker = glib::value::GenericValueTypeChecker<Self>;
10082
10083 #[inline]
10084 unsafe fn from_value(value: &'a glib::Value) -> Self {
10085 skip_assert_initialized!();
10086 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
10087 }
10088}
10089
10090impl ToValue for RecentManagerError {
10091 #[inline]
10092 fn to_value(&self) -> glib::Value {
10093 let mut value = glib::Value::for_value_type::<Self>();
10094 unsafe {
10095 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
10096 }
10097 value
10098 }
10099
10100 #[inline]
10101 fn value_type(&self) -> glib::Type {
10102 Self::static_type()
10103 }
10104}
10105
10106impl From<RecentManagerError> for glib::Value {
10107 #[inline]
10108 fn from(v: RecentManagerError) -> Self {
10109 skip_assert_initialized!();
10110 ToValue::to_value(&v)
10111 }
10112}
10113
10114#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
10117#[non_exhaustive]
10118#[doc(alias = "GtkRevealerTransitionType")]
10119pub enum RevealerTransitionType {
10120 #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_NONE")]
10122 None,
10123 #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_CROSSFADE")]
10125 Crossfade,
10126 #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT")]
10128 SlideRight,
10129 #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_SLIDE_LEFT")]
10131 SlideLeft,
10132 #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_SLIDE_UP")]
10134 SlideUp,
10135 #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN")]
10137 SlideDown,
10138 #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_SWING_RIGHT")]
10140 SwingRight,
10141 #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_SWING_LEFT")]
10143 SwingLeft,
10144 #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_SWING_UP")]
10146 SwingUp,
10147 #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_SWING_DOWN")]
10149 SwingDown,
10150 #[doc(hidden)]
10151 __Unknown(i32),
10152}
10153
10154#[doc(hidden)]
10155impl IntoGlib for RevealerTransitionType {
10156 type GlibType = ffi::GtkRevealerTransitionType;
10157
10158 #[inline]
10159 fn into_glib(self) -> ffi::GtkRevealerTransitionType {
10160 match self {
10161 Self::None => ffi::GTK_REVEALER_TRANSITION_TYPE_NONE,
10162 Self::Crossfade => ffi::GTK_REVEALER_TRANSITION_TYPE_CROSSFADE,
10163 Self::SlideRight => ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT,
10164 Self::SlideLeft => ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_LEFT,
10165 Self::SlideUp => ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_UP,
10166 Self::SlideDown => ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN,
10167 Self::SwingRight => ffi::GTK_REVEALER_TRANSITION_TYPE_SWING_RIGHT,
10168 Self::SwingLeft => ffi::GTK_REVEALER_TRANSITION_TYPE_SWING_LEFT,
10169 Self::SwingUp => ffi::GTK_REVEALER_TRANSITION_TYPE_SWING_UP,
10170 Self::SwingDown => ffi::GTK_REVEALER_TRANSITION_TYPE_SWING_DOWN,
10171 Self::__Unknown(value) => value,
10172 }
10173 }
10174}
10175
10176#[doc(hidden)]
10177impl FromGlib<ffi::GtkRevealerTransitionType> for RevealerTransitionType {
10178 #[inline]
10179 unsafe fn from_glib(value: ffi::GtkRevealerTransitionType) -> Self {
10180 skip_assert_initialized!();
10181
10182 match value {
10183 ffi::GTK_REVEALER_TRANSITION_TYPE_NONE => Self::None,
10184 ffi::GTK_REVEALER_TRANSITION_TYPE_CROSSFADE => Self::Crossfade,
10185 ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT => Self::SlideRight,
10186 ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_LEFT => Self::SlideLeft,
10187 ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_UP => Self::SlideUp,
10188 ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN => Self::SlideDown,
10189 ffi::GTK_REVEALER_TRANSITION_TYPE_SWING_RIGHT => Self::SwingRight,
10190 ffi::GTK_REVEALER_TRANSITION_TYPE_SWING_LEFT => Self::SwingLeft,
10191 ffi::GTK_REVEALER_TRANSITION_TYPE_SWING_UP => Self::SwingUp,
10192 ffi::GTK_REVEALER_TRANSITION_TYPE_SWING_DOWN => Self::SwingDown,
10193 value => Self::__Unknown(value),
10194 }
10195 }
10196}
10197
10198impl StaticType for RevealerTransitionType {
10199 #[inline]
10200 #[doc(alias = "gtk_revealer_transition_type_get_type")]
10201 fn static_type() -> glib::Type {
10202 unsafe { from_glib(ffi::gtk_revealer_transition_type_get_type()) }
10203 }
10204}
10205
10206impl glib::HasParamSpec for RevealerTransitionType {
10207 type ParamSpec = glib::ParamSpecEnum;
10208 type SetValue = Self;
10209 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
10210
10211 fn param_spec_builder() -> Self::BuilderFn {
10212 Self::ParamSpec::builder_with_default
10213 }
10214}
10215
10216impl glib::value::ValueType for RevealerTransitionType {
10217 type Type = Self;
10218}
10219
10220unsafe impl<'a> glib::value::FromValue<'a> for RevealerTransitionType {
10221 type Checker = glib::value::GenericValueTypeChecker<Self>;
10222
10223 #[inline]
10224 unsafe fn from_value(value: &'a glib::Value) -> Self {
10225 skip_assert_initialized!();
10226 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
10227 }
10228}
10229
10230impl ToValue for RevealerTransitionType {
10231 #[inline]
10232 fn to_value(&self) -> glib::Value {
10233 let mut value = glib::Value::for_value_type::<Self>();
10234 unsafe {
10235 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
10236 }
10237 value
10238 }
10239
10240 #[inline]
10241 fn value_type(&self) -> glib::Type {
10242 Self::static_type()
10243 }
10244}
10245
10246impl From<RevealerTransitionType> for glib::Value {
10247 #[inline]
10248 fn from(v: RevealerTransitionType) -> Self {
10249 skip_assert_initialized!();
10250 ToValue::to_value(&v)
10251 }
10252}
10253
10254#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
10256#[non_exhaustive]
10257#[doc(alias = "GtkScrollStep")]
10258pub enum ScrollStep {
10259 #[doc(alias = "GTK_SCROLL_STEPS")]
10261 Steps,
10262 #[doc(alias = "GTK_SCROLL_PAGES")]
10264 Pages,
10265 #[doc(alias = "GTK_SCROLL_ENDS")]
10267 Ends,
10268 #[doc(alias = "GTK_SCROLL_HORIZONTAL_STEPS")]
10270 HorizontalSteps,
10271 #[doc(alias = "GTK_SCROLL_HORIZONTAL_PAGES")]
10273 HorizontalPages,
10274 #[doc(alias = "GTK_SCROLL_HORIZONTAL_ENDS")]
10276 HorizontalEnds,
10277 #[doc(hidden)]
10278 __Unknown(i32),
10279}
10280
10281#[doc(hidden)]
10282impl IntoGlib for ScrollStep {
10283 type GlibType = ffi::GtkScrollStep;
10284
10285 #[inline]
10286 fn into_glib(self) -> ffi::GtkScrollStep {
10287 match self {
10288 Self::Steps => ffi::GTK_SCROLL_STEPS,
10289 Self::Pages => ffi::GTK_SCROLL_PAGES,
10290 Self::Ends => ffi::GTK_SCROLL_ENDS,
10291 Self::HorizontalSteps => ffi::GTK_SCROLL_HORIZONTAL_STEPS,
10292 Self::HorizontalPages => ffi::GTK_SCROLL_HORIZONTAL_PAGES,
10293 Self::HorizontalEnds => ffi::GTK_SCROLL_HORIZONTAL_ENDS,
10294 Self::__Unknown(value) => value,
10295 }
10296 }
10297}
10298
10299#[doc(hidden)]
10300impl FromGlib<ffi::GtkScrollStep> for ScrollStep {
10301 #[inline]
10302 unsafe fn from_glib(value: ffi::GtkScrollStep) -> Self {
10303 skip_assert_initialized!();
10304
10305 match value {
10306 ffi::GTK_SCROLL_STEPS => Self::Steps,
10307 ffi::GTK_SCROLL_PAGES => Self::Pages,
10308 ffi::GTK_SCROLL_ENDS => Self::Ends,
10309 ffi::GTK_SCROLL_HORIZONTAL_STEPS => Self::HorizontalSteps,
10310 ffi::GTK_SCROLL_HORIZONTAL_PAGES => Self::HorizontalPages,
10311 ffi::GTK_SCROLL_HORIZONTAL_ENDS => Self::HorizontalEnds,
10312 value => Self::__Unknown(value),
10313 }
10314 }
10315}
10316
10317impl StaticType for ScrollStep {
10318 #[inline]
10319 #[doc(alias = "gtk_scroll_step_get_type")]
10320 fn static_type() -> glib::Type {
10321 unsafe { from_glib(ffi::gtk_scroll_step_get_type()) }
10322 }
10323}
10324
10325impl glib::HasParamSpec for ScrollStep {
10326 type ParamSpec = glib::ParamSpecEnum;
10327 type SetValue = Self;
10328 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
10329
10330 fn param_spec_builder() -> Self::BuilderFn {
10331 Self::ParamSpec::builder_with_default
10332 }
10333}
10334
10335impl glib::value::ValueType for ScrollStep {
10336 type Type = Self;
10337}
10338
10339unsafe impl<'a> glib::value::FromValue<'a> for ScrollStep {
10340 type Checker = glib::value::GenericValueTypeChecker<Self>;
10341
10342 #[inline]
10343 unsafe fn from_value(value: &'a glib::Value) -> Self {
10344 skip_assert_initialized!();
10345 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
10346 }
10347}
10348
10349impl ToValue for ScrollStep {
10350 #[inline]
10351 fn to_value(&self) -> glib::Value {
10352 let mut value = glib::Value::for_value_type::<Self>();
10353 unsafe {
10354 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
10355 }
10356 value
10357 }
10358
10359 #[inline]
10360 fn value_type(&self) -> glib::Type {
10361 Self::static_type()
10362 }
10363}
10364
10365impl From<ScrollStep> for glib::Value {
10366 #[inline]
10367 fn from(v: ScrollStep) -> Self {
10368 skip_assert_initialized!();
10369 ToValue::to_value(&v)
10370 }
10371}
10372
10373#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
10375#[non_exhaustive]
10376#[doc(alias = "GtkScrollType")]
10377pub enum ScrollType {
10378 #[doc(alias = "GTK_SCROLL_NONE")]
10380 None,
10381 #[doc(alias = "GTK_SCROLL_JUMP")]
10383 Jump,
10384 #[doc(alias = "GTK_SCROLL_STEP_BACKWARD")]
10386 StepBackward,
10387 #[doc(alias = "GTK_SCROLL_STEP_FORWARD")]
10389 StepForward,
10390 #[doc(alias = "GTK_SCROLL_PAGE_BACKWARD")]
10392 PageBackward,
10393 #[doc(alias = "GTK_SCROLL_PAGE_FORWARD")]
10395 PageForward,
10396 #[doc(alias = "GTK_SCROLL_STEP_UP")]
10398 StepUp,
10399 #[doc(alias = "GTK_SCROLL_STEP_DOWN")]
10401 StepDown,
10402 #[doc(alias = "GTK_SCROLL_PAGE_UP")]
10404 PageUp,
10405 #[doc(alias = "GTK_SCROLL_PAGE_DOWN")]
10407 PageDown,
10408 #[doc(alias = "GTK_SCROLL_STEP_LEFT")]
10410 StepLeft,
10411 #[doc(alias = "GTK_SCROLL_STEP_RIGHT")]
10413 StepRight,
10414 #[doc(alias = "GTK_SCROLL_PAGE_LEFT")]
10416 PageLeft,
10417 #[doc(alias = "GTK_SCROLL_PAGE_RIGHT")]
10419 PageRight,
10420 #[doc(alias = "GTK_SCROLL_START")]
10422 Start,
10423 #[doc(alias = "GTK_SCROLL_END")]
10425 End,
10426 #[doc(hidden)]
10427 __Unknown(i32),
10428}
10429
10430#[doc(hidden)]
10431impl IntoGlib for ScrollType {
10432 type GlibType = ffi::GtkScrollType;
10433
10434 fn into_glib(self) -> ffi::GtkScrollType {
10435 match self {
10436 Self::None => ffi::GTK_SCROLL_NONE,
10437 Self::Jump => ffi::GTK_SCROLL_JUMP,
10438 Self::StepBackward => ffi::GTK_SCROLL_STEP_BACKWARD,
10439 Self::StepForward => ffi::GTK_SCROLL_STEP_FORWARD,
10440 Self::PageBackward => ffi::GTK_SCROLL_PAGE_BACKWARD,
10441 Self::PageForward => ffi::GTK_SCROLL_PAGE_FORWARD,
10442 Self::StepUp => ffi::GTK_SCROLL_STEP_UP,
10443 Self::StepDown => ffi::GTK_SCROLL_STEP_DOWN,
10444 Self::PageUp => ffi::GTK_SCROLL_PAGE_UP,
10445 Self::PageDown => ffi::GTK_SCROLL_PAGE_DOWN,
10446 Self::StepLeft => ffi::GTK_SCROLL_STEP_LEFT,
10447 Self::StepRight => ffi::GTK_SCROLL_STEP_RIGHT,
10448 Self::PageLeft => ffi::GTK_SCROLL_PAGE_LEFT,
10449 Self::PageRight => ffi::GTK_SCROLL_PAGE_RIGHT,
10450 Self::Start => ffi::GTK_SCROLL_START,
10451 Self::End => ffi::GTK_SCROLL_END,
10452 Self::__Unknown(value) => value,
10453 }
10454 }
10455}
10456
10457#[doc(hidden)]
10458impl FromGlib<ffi::GtkScrollType> for ScrollType {
10459 unsafe fn from_glib(value: ffi::GtkScrollType) -> Self {
10460 skip_assert_initialized!();
10461
10462 match value {
10463 ffi::GTK_SCROLL_NONE => Self::None,
10464 ffi::GTK_SCROLL_JUMP => Self::Jump,
10465 ffi::GTK_SCROLL_STEP_BACKWARD => Self::StepBackward,
10466 ffi::GTK_SCROLL_STEP_FORWARD => Self::StepForward,
10467 ffi::GTK_SCROLL_PAGE_BACKWARD => Self::PageBackward,
10468 ffi::GTK_SCROLL_PAGE_FORWARD => Self::PageForward,
10469 ffi::GTK_SCROLL_STEP_UP => Self::StepUp,
10470 ffi::GTK_SCROLL_STEP_DOWN => Self::StepDown,
10471 ffi::GTK_SCROLL_PAGE_UP => Self::PageUp,
10472 ffi::GTK_SCROLL_PAGE_DOWN => Self::PageDown,
10473 ffi::GTK_SCROLL_STEP_LEFT => Self::StepLeft,
10474 ffi::GTK_SCROLL_STEP_RIGHT => Self::StepRight,
10475 ffi::GTK_SCROLL_PAGE_LEFT => Self::PageLeft,
10476 ffi::GTK_SCROLL_PAGE_RIGHT => Self::PageRight,
10477 ffi::GTK_SCROLL_START => Self::Start,
10478 ffi::GTK_SCROLL_END => Self::End,
10479 value => Self::__Unknown(value),
10480 }
10481 }
10482}
10483
10484impl StaticType for ScrollType {
10485 #[inline]
10486 #[doc(alias = "gtk_scroll_type_get_type")]
10487 fn static_type() -> glib::Type {
10488 unsafe { from_glib(ffi::gtk_scroll_type_get_type()) }
10489 }
10490}
10491
10492impl glib::HasParamSpec for ScrollType {
10493 type ParamSpec = glib::ParamSpecEnum;
10494 type SetValue = Self;
10495 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
10496
10497 fn param_spec_builder() -> Self::BuilderFn {
10498 Self::ParamSpec::builder_with_default
10499 }
10500}
10501
10502impl glib::value::ValueType for ScrollType {
10503 type Type = Self;
10504}
10505
10506unsafe impl<'a> glib::value::FromValue<'a> for ScrollType {
10507 type Checker = glib::value::GenericValueTypeChecker<Self>;
10508
10509 #[inline]
10510 unsafe fn from_value(value: &'a glib::Value) -> Self {
10511 skip_assert_initialized!();
10512 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
10513 }
10514}
10515
10516impl ToValue for ScrollType {
10517 #[inline]
10518 fn to_value(&self) -> glib::Value {
10519 let mut value = glib::Value::for_value_type::<Self>();
10520 unsafe {
10521 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
10522 }
10523 value
10524 }
10525
10526 #[inline]
10527 fn value_type(&self) -> glib::Type {
10528 Self::static_type()
10529 }
10530}
10531
10532impl From<ScrollType> for glib::Value {
10533 #[inline]
10534 fn from(v: ScrollType) -> Self {
10535 skip_assert_initialized!();
10536 ToValue::to_value(&v)
10537 }
10538}
10539
10540#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
10543#[non_exhaustive]
10544#[doc(alias = "GtkScrollablePolicy")]
10545pub enum ScrollablePolicy {
10546 #[doc(alias = "GTK_SCROLL_MINIMUM")]
10548 Minimum,
10549 #[doc(alias = "GTK_SCROLL_NATURAL")]
10551 Natural,
10552 #[doc(hidden)]
10553 __Unknown(i32),
10554}
10555
10556#[doc(hidden)]
10557impl IntoGlib for ScrollablePolicy {
10558 type GlibType = ffi::GtkScrollablePolicy;
10559
10560 #[inline]
10561 fn into_glib(self) -> ffi::GtkScrollablePolicy {
10562 match self {
10563 Self::Minimum => ffi::GTK_SCROLL_MINIMUM,
10564 Self::Natural => ffi::GTK_SCROLL_NATURAL,
10565 Self::__Unknown(value) => value,
10566 }
10567 }
10568}
10569
10570#[doc(hidden)]
10571impl FromGlib<ffi::GtkScrollablePolicy> for ScrollablePolicy {
10572 #[inline]
10573 unsafe fn from_glib(value: ffi::GtkScrollablePolicy) -> Self {
10574 skip_assert_initialized!();
10575
10576 match value {
10577 ffi::GTK_SCROLL_MINIMUM => Self::Minimum,
10578 ffi::GTK_SCROLL_NATURAL => Self::Natural,
10579 value => Self::__Unknown(value),
10580 }
10581 }
10582}
10583
10584impl StaticType for ScrollablePolicy {
10585 #[inline]
10586 #[doc(alias = "gtk_scrollable_policy_get_type")]
10587 fn static_type() -> glib::Type {
10588 unsafe { from_glib(ffi::gtk_scrollable_policy_get_type()) }
10589 }
10590}
10591
10592impl glib::HasParamSpec for ScrollablePolicy {
10593 type ParamSpec = glib::ParamSpecEnum;
10594 type SetValue = Self;
10595 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
10596
10597 fn param_spec_builder() -> Self::BuilderFn {
10598 Self::ParamSpec::builder_with_default
10599 }
10600}
10601
10602impl glib::value::ValueType for ScrollablePolicy {
10603 type Type = Self;
10604}
10605
10606unsafe impl<'a> glib::value::FromValue<'a> for ScrollablePolicy {
10607 type Checker = glib::value::GenericValueTypeChecker<Self>;
10608
10609 #[inline]
10610 unsafe fn from_value(value: &'a glib::Value) -> Self {
10611 skip_assert_initialized!();
10612 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
10613 }
10614}
10615
10616impl ToValue for ScrollablePolicy {
10617 #[inline]
10618 fn to_value(&self) -> glib::Value {
10619 let mut value = glib::Value::for_value_type::<Self>();
10620 unsafe {
10621 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
10622 }
10623 value
10624 }
10625
10626 #[inline]
10627 fn value_type(&self) -> glib::Type {
10628 Self::static_type()
10629 }
10630}
10631
10632impl From<ScrollablePolicy> for glib::Value {
10633 #[inline]
10634 fn from(v: ScrollablePolicy) -> Self {
10635 skip_assert_initialized!();
10636 ToValue::to_value(&v)
10637 }
10638}
10639
10640#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
10642#[non_exhaustive]
10643#[doc(alias = "GtkSelectionMode")]
10644pub enum SelectionMode {
10645 #[doc(alias = "GTK_SELECTION_NONE")]
10647 None,
10648 #[doc(alias = "GTK_SELECTION_SINGLE")]
10650 Single,
10651 #[doc(alias = "GTK_SELECTION_BROWSE")]
10658 Browse,
10659 #[doc(alias = "GTK_SELECTION_MULTIPLE")]
10664 Multiple,
10665 #[doc(hidden)]
10666 __Unknown(i32),
10667}
10668
10669#[doc(hidden)]
10670impl IntoGlib for SelectionMode {
10671 type GlibType = ffi::GtkSelectionMode;
10672
10673 #[inline]
10674 fn into_glib(self) -> ffi::GtkSelectionMode {
10675 match self {
10676 Self::None => ffi::GTK_SELECTION_NONE,
10677 Self::Single => ffi::GTK_SELECTION_SINGLE,
10678 Self::Browse => ffi::GTK_SELECTION_BROWSE,
10679 Self::Multiple => ffi::GTK_SELECTION_MULTIPLE,
10680 Self::__Unknown(value) => value,
10681 }
10682 }
10683}
10684
10685#[doc(hidden)]
10686impl FromGlib<ffi::GtkSelectionMode> for SelectionMode {
10687 #[inline]
10688 unsafe fn from_glib(value: ffi::GtkSelectionMode) -> Self {
10689 skip_assert_initialized!();
10690
10691 match value {
10692 ffi::GTK_SELECTION_NONE => Self::None,
10693 ffi::GTK_SELECTION_SINGLE => Self::Single,
10694 ffi::GTK_SELECTION_BROWSE => Self::Browse,
10695 ffi::GTK_SELECTION_MULTIPLE => Self::Multiple,
10696 value => Self::__Unknown(value),
10697 }
10698 }
10699}
10700
10701impl StaticType for SelectionMode {
10702 #[inline]
10703 #[doc(alias = "gtk_selection_mode_get_type")]
10704 fn static_type() -> glib::Type {
10705 unsafe { from_glib(ffi::gtk_selection_mode_get_type()) }
10706 }
10707}
10708
10709impl glib::HasParamSpec for SelectionMode {
10710 type ParamSpec = glib::ParamSpecEnum;
10711 type SetValue = Self;
10712 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
10713
10714 fn param_spec_builder() -> Self::BuilderFn {
10715 Self::ParamSpec::builder_with_default
10716 }
10717}
10718
10719impl glib::value::ValueType for SelectionMode {
10720 type Type = Self;
10721}
10722
10723unsafe impl<'a> glib::value::FromValue<'a> for SelectionMode {
10724 type Checker = glib::value::GenericValueTypeChecker<Self>;
10725
10726 #[inline]
10727 unsafe fn from_value(value: &'a glib::Value) -> Self {
10728 skip_assert_initialized!();
10729 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
10730 }
10731}
10732
10733impl ToValue for SelectionMode {
10734 #[inline]
10735 fn to_value(&self) -> glib::Value {
10736 let mut value = glib::Value::for_value_type::<Self>();
10737 unsafe {
10738 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
10739 }
10740 value
10741 }
10742
10743 #[inline]
10744 fn value_type(&self) -> glib::Type {
10745 Self::static_type()
10746 }
10747}
10748
10749impl From<SelectionMode> for glib::Value {
10750 #[inline]
10751 fn from(v: SelectionMode) -> Self {
10752 skip_assert_initialized!();
10753 ToValue::to_value(&v)
10754 }
10755}
10756
10757#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
10760#[non_exhaustive]
10761#[doc(alias = "GtkSensitivityType")]
10762pub enum SensitivityType {
10763 #[doc(alias = "GTK_SENSITIVITY_AUTO")]
10766 Auto,
10767 #[doc(alias = "GTK_SENSITIVITY_ON")]
10769 On,
10770 #[doc(alias = "GTK_SENSITIVITY_OFF")]
10772 Off,
10773 #[doc(hidden)]
10774 __Unknown(i32),
10775}
10776
10777#[doc(hidden)]
10778impl IntoGlib for SensitivityType {
10779 type GlibType = ffi::GtkSensitivityType;
10780
10781 #[inline]
10782 fn into_glib(self) -> ffi::GtkSensitivityType {
10783 match self {
10784 Self::Auto => ffi::GTK_SENSITIVITY_AUTO,
10785 Self::On => ffi::GTK_SENSITIVITY_ON,
10786 Self::Off => ffi::GTK_SENSITIVITY_OFF,
10787 Self::__Unknown(value) => value,
10788 }
10789 }
10790}
10791
10792#[doc(hidden)]
10793impl FromGlib<ffi::GtkSensitivityType> for SensitivityType {
10794 #[inline]
10795 unsafe fn from_glib(value: ffi::GtkSensitivityType) -> Self {
10796 skip_assert_initialized!();
10797
10798 match value {
10799 ffi::GTK_SENSITIVITY_AUTO => Self::Auto,
10800 ffi::GTK_SENSITIVITY_ON => Self::On,
10801 ffi::GTK_SENSITIVITY_OFF => Self::Off,
10802 value => Self::__Unknown(value),
10803 }
10804 }
10805}
10806
10807impl StaticType for SensitivityType {
10808 #[inline]
10809 #[doc(alias = "gtk_sensitivity_type_get_type")]
10810 fn static_type() -> glib::Type {
10811 unsafe { from_glib(ffi::gtk_sensitivity_type_get_type()) }
10812 }
10813}
10814
10815impl glib::HasParamSpec for SensitivityType {
10816 type ParamSpec = glib::ParamSpecEnum;
10817 type SetValue = Self;
10818 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
10819
10820 fn param_spec_builder() -> Self::BuilderFn {
10821 Self::ParamSpec::builder_with_default
10822 }
10823}
10824
10825impl glib::value::ValueType for SensitivityType {
10826 type Type = Self;
10827}
10828
10829unsafe impl<'a> glib::value::FromValue<'a> for SensitivityType {
10830 type Checker = glib::value::GenericValueTypeChecker<Self>;
10831
10832 #[inline]
10833 unsafe fn from_value(value: &'a glib::Value) -> Self {
10834 skip_assert_initialized!();
10835 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
10836 }
10837}
10838
10839impl ToValue for SensitivityType {
10840 #[inline]
10841 fn to_value(&self) -> glib::Value {
10842 let mut value = glib::Value::for_value_type::<Self>();
10843 unsafe {
10844 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
10845 }
10846 value
10847 }
10848
10849 #[inline]
10850 fn value_type(&self) -> glib::Type {
10851 Self::static_type()
10852 }
10853}
10854
10855impl From<SensitivityType> for glib::Value {
10856 #[inline]
10857 fn from(v: SensitivityType) -> Self {
10858 skip_assert_initialized!();
10859 ToValue::to_value(&v)
10860 }
10861}
10862
10863#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
10866#[non_exhaustive]
10867#[doc(alias = "GtkShortcutScope")]
10868pub enum ShortcutScope {
10869 #[doc(alias = "GTK_SHORTCUT_SCOPE_LOCAL")]
10872 Local,
10873 #[doc(alias = "GTK_SHORTCUT_SCOPE_MANAGED")]
10876 Managed,
10877 #[doc(alias = "GTK_SHORTCUT_SCOPE_GLOBAL")]
10880 Global,
10881 #[doc(hidden)]
10882 __Unknown(i32),
10883}
10884
10885#[doc(hidden)]
10886impl IntoGlib for ShortcutScope {
10887 type GlibType = ffi::GtkShortcutScope;
10888
10889 #[inline]
10890 fn into_glib(self) -> ffi::GtkShortcutScope {
10891 match self {
10892 Self::Local => ffi::GTK_SHORTCUT_SCOPE_LOCAL,
10893 Self::Managed => ffi::GTK_SHORTCUT_SCOPE_MANAGED,
10894 Self::Global => ffi::GTK_SHORTCUT_SCOPE_GLOBAL,
10895 Self::__Unknown(value) => value,
10896 }
10897 }
10898}
10899
10900#[doc(hidden)]
10901impl FromGlib<ffi::GtkShortcutScope> for ShortcutScope {
10902 #[inline]
10903 unsafe fn from_glib(value: ffi::GtkShortcutScope) -> Self {
10904 skip_assert_initialized!();
10905
10906 match value {
10907 ffi::GTK_SHORTCUT_SCOPE_LOCAL => Self::Local,
10908 ffi::GTK_SHORTCUT_SCOPE_MANAGED => Self::Managed,
10909 ffi::GTK_SHORTCUT_SCOPE_GLOBAL => Self::Global,
10910 value => Self::__Unknown(value),
10911 }
10912 }
10913}
10914
10915impl StaticType for ShortcutScope {
10916 #[inline]
10917 #[doc(alias = "gtk_shortcut_scope_get_type")]
10918 fn static_type() -> glib::Type {
10919 unsafe { from_glib(ffi::gtk_shortcut_scope_get_type()) }
10920 }
10921}
10922
10923impl glib::HasParamSpec for ShortcutScope {
10924 type ParamSpec = glib::ParamSpecEnum;
10925 type SetValue = Self;
10926 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
10927
10928 fn param_spec_builder() -> Self::BuilderFn {
10929 Self::ParamSpec::builder_with_default
10930 }
10931}
10932
10933impl glib::value::ValueType for ShortcutScope {
10934 type Type = Self;
10935}
10936
10937unsafe impl<'a> glib::value::FromValue<'a> for ShortcutScope {
10938 type Checker = glib::value::GenericValueTypeChecker<Self>;
10939
10940 #[inline]
10941 unsafe fn from_value(value: &'a glib::Value) -> Self {
10942 skip_assert_initialized!();
10943 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
10944 }
10945}
10946
10947impl ToValue for ShortcutScope {
10948 #[inline]
10949 fn to_value(&self) -> glib::Value {
10950 let mut value = glib::Value::for_value_type::<Self>();
10951 unsafe {
10952 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
10953 }
10954 value
10955 }
10956
10957 #[inline]
10958 fn value_type(&self) -> glib::Type {
10959 Self::static_type()
10960 }
10961}
10962
10963impl From<ShortcutScope> for glib::Value {
10964 #[inline]
10965 fn from(v: ShortcutScope) -> Self {
10966 skip_assert_initialized!();
10967 ToValue::to_value(&v)
10968 }
10969}
10970
10971#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
10975#[non_exhaustive]
10976#[doc(alias = "GtkShortcutType")]
10977pub enum ShortcutType {
10978 #[doc(alias = "GTK_SHORTCUT_ACCELERATOR")]
10981 Accelerator,
10982 #[doc(alias = "GTK_SHORTCUT_GESTURE_PINCH")]
10984 GesturePinch,
10985 #[doc(alias = "GTK_SHORTCUT_GESTURE_STRETCH")]
10987 GestureStretch,
10988 #[doc(alias = "GTK_SHORTCUT_GESTURE_ROTATE_CLOCKWISE")]
10990 GestureRotateClockwise,
10991 #[doc(alias = "GTK_SHORTCUT_GESTURE_ROTATE_COUNTERCLOCKWISE")]
10993 GestureRotateCounterclockwise,
10994 #[doc(alias = "GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_LEFT")]
10996 GestureTwoFingerSwipeLeft,
10997 #[doc(alias = "GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_RIGHT")]
10999 GestureTwoFingerSwipeRight,
11000 #[doc(alias = "GTK_SHORTCUT_GESTURE")]
11003 Gesture,
11004 #[doc(alias = "GTK_SHORTCUT_GESTURE_SWIPE_LEFT")]
11006 GestureSwipeLeft,
11007 #[doc(alias = "GTK_SHORTCUT_GESTURE_SWIPE_RIGHT")]
11009 GestureSwipeRight,
11010 #[doc(hidden)]
11011 __Unknown(i32),
11012}
11013
11014#[doc(hidden)]
11015impl IntoGlib for ShortcutType {
11016 type GlibType = ffi::GtkShortcutType;
11017
11018 #[inline]
11019 fn into_glib(self) -> ffi::GtkShortcutType {
11020 match self {
11021 Self::Accelerator => ffi::GTK_SHORTCUT_ACCELERATOR,
11022 Self::GesturePinch => ffi::GTK_SHORTCUT_GESTURE_PINCH,
11023 Self::GestureStretch => ffi::GTK_SHORTCUT_GESTURE_STRETCH,
11024 Self::GestureRotateClockwise => ffi::GTK_SHORTCUT_GESTURE_ROTATE_CLOCKWISE,
11025 Self::GestureRotateCounterclockwise => {
11026 ffi::GTK_SHORTCUT_GESTURE_ROTATE_COUNTERCLOCKWISE
11027 }
11028 Self::GestureTwoFingerSwipeLeft => ffi::GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_LEFT,
11029 Self::GestureTwoFingerSwipeRight => ffi::GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_RIGHT,
11030 Self::Gesture => ffi::GTK_SHORTCUT_GESTURE,
11031 Self::GestureSwipeLeft => ffi::GTK_SHORTCUT_GESTURE_SWIPE_LEFT,
11032 Self::GestureSwipeRight => ffi::GTK_SHORTCUT_GESTURE_SWIPE_RIGHT,
11033 Self::__Unknown(value) => value,
11034 }
11035 }
11036}
11037
11038#[doc(hidden)]
11039impl FromGlib<ffi::GtkShortcutType> for ShortcutType {
11040 #[inline]
11041 unsafe fn from_glib(value: ffi::GtkShortcutType) -> Self {
11042 skip_assert_initialized!();
11043
11044 match value {
11045 ffi::GTK_SHORTCUT_ACCELERATOR => Self::Accelerator,
11046 ffi::GTK_SHORTCUT_GESTURE_PINCH => Self::GesturePinch,
11047 ffi::GTK_SHORTCUT_GESTURE_STRETCH => Self::GestureStretch,
11048 ffi::GTK_SHORTCUT_GESTURE_ROTATE_CLOCKWISE => Self::GestureRotateClockwise,
11049 ffi::GTK_SHORTCUT_GESTURE_ROTATE_COUNTERCLOCKWISE => {
11050 Self::GestureRotateCounterclockwise
11051 }
11052 ffi::GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_LEFT => Self::GestureTwoFingerSwipeLeft,
11053 ffi::GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_RIGHT => Self::GestureTwoFingerSwipeRight,
11054 ffi::GTK_SHORTCUT_GESTURE => Self::Gesture,
11055 ffi::GTK_SHORTCUT_GESTURE_SWIPE_LEFT => Self::GestureSwipeLeft,
11056 ffi::GTK_SHORTCUT_GESTURE_SWIPE_RIGHT => Self::GestureSwipeRight,
11057 value => Self::__Unknown(value),
11058 }
11059 }
11060}
11061
11062impl StaticType for ShortcutType {
11063 #[inline]
11064 #[doc(alias = "gtk_shortcut_type_get_type")]
11065 fn static_type() -> glib::Type {
11066 unsafe { from_glib(ffi::gtk_shortcut_type_get_type()) }
11067 }
11068}
11069
11070impl glib::HasParamSpec for ShortcutType {
11071 type ParamSpec = glib::ParamSpecEnum;
11072 type SetValue = Self;
11073 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
11074
11075 fn param_spec_builder() -> Self::BuilderFn {
11076 Self::ParamSpec::builder_with_default
11077 }
11078}
11079
11080impl glib::value::ValueType for ShortcutType {
11081 type Type = Self;
11082}
11083
11084unsafe impl<'a> glib::value::FromValue<'a> for ShortcutType {
11085 type Checker = glib::value::GenericValueTypeChecker<Self>;
11086
11087 #[inline]
11088 unsafe fn from_value(value: &'a glib::Value) -> Self {
11089 skip_assert_initialized!();
11090 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
11091 }
11092}
11093
11094impl ToValue for ShortcutType {
11095 #[inline]
11096 fn to_value(&self) -> glib::Value {
11097 let mut value = glib::Value::for_value_type::<Self>();
11098 unsafe {
11099 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
11100 }
11101 value
11102 }
11103
11104 #[inline]
11105 fn value_type(&self) -> glib::Type {
11106 Self::static_type()
11107 }
11108}
11109
11110impl From<ShortcutType> for glib::Value {
11111 #[inline]
11112 fn from(v: ShortcutType) -> Self {
11113 skip_assert_initialized!();
11114 ToValue::to_value(&v)
11115 }
11116}
11117
11118#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
11121#[non_exhaustive]
11122#[doc(alias = "GtkSizeGroupMode")]
11123pub enum SizeGroupMode {
11124 #[doc(alias = "GTK_SIZE_GROUP_NONE")]
11126 None,
11127 #[doc(alias = "GTK_SIZE_GROUP_HORIZONTAL")]
11129 Horizontal,
11130 #[doc(alias = "GTK_SIZE_GROUP_VERTICAL")]
11132 Vertical,
11133 #[doc(alias = "GTK_SIZE_GROUP_BOTH")]
11135 Both,
11136 #[doc(hidden)]
11137 __Unknown(i32),
11138}
11139
11140#[doc(hidden)]
11141impl IntoGlib for SizeGroupMode {
11142 type GlibType = ffi::GtkSizeGroupMode;
11143
11144 #[inline]
11145 fn into_glib(self) -> ffi::GtkSizeGroupMode {
11146 match self {
11147 Self::None => ffi::GTK_SIZE_GROUP_NONE,
11148 Self::Horizontal => ffi::GTK_SIZE_GROUP_HORIZONTAL,
11149 Self::Vertical => ffi::GTK_SIZE_GROUP_VERTICAL,
11150 Self::Both => ffi::GTK_SIZE_GROUP_BOTH,
11151 Self::__Unknown(value) => value,
11152 }
11153 }
11154}
11155
11156#[doc(hidden)]
11157impl FromGlib<ffi::GtkSizeGroupMode> for SizeGroupMode {
11158 #[inline]
11159 unsafe fn from_glib(value: ffi::GtkSizeGroupMode) -> Self {
11160 skip_assert_initialized!();
11161
11162 match value {
11163 ffi::GTK_SIZE_GROUP_NONE => Self::None,
11164 ffi::GTK_SIZE_GROUP_HORIZONTAL => Self::Horizontal,
11165 ffi::GTK_SIZE_GROUP_VERTICAL => Self::Vertical,
11166 ffi::GTK_SIZE_GROUP_BOTH => Self::Both,
11167 value => Self::__Unknown(value),
11168 }
11169 }
11170}
11171
11172impl StaticType for SizeGroupMode {
11173 #[inline]
11174 #[doc(alias = "gtk_size_group_mode_get_type")]
11175 fn static_type() -> glib::Type {
11176 unsafe { from_glib(ffi::gtk_size_group_mode_get_type()) }
11177 }
11178}
11179
11180impl glib::HasParamSpec for SizeGroupMode {
11181 type ParamSpec = glib::ParamSpecEnum;
11182 type SetValue = Self;
11183 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
11184
11185 fn param_spec_builder() -> Self::BuilderFn {
11186 Self::ParamSpec::builder_with_default
11187 }
11188}
11189
11190impl glib::value::ValueType for SizeGroupMode {
11191 type Type = Self;
11192}
11193
11194unsafe impl<'a> glib::value::FromValue<'a> for SizeGroupMode {
11195 type Checker = glib::value::GenericValueTypeChecker<Self>;
11196
11197 #[inline]
11198 unsafe fn from_value(value: &'a glib::Value) -> Self {
11199 skip_assert_initialized!();
11200 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
11201 }
11202}
11203
11204impl ToValue for SizeGroupMode {
11205 #[inline]
11206 fn to_value(&self) -> glib::Value {
11207 let mut value = glib::Value::for_value_type::<Self>();
11208 unsafe {
11209 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
11210 }
11211 value
11212 }
11213
11214 #[inline]
11215 fn value_type(&self) -> glib::Type {
11216 Self::static_type()
11217 }
11218}
11219
11220impl From<SizeGroupMode> for glib::Value {
11221 #[inline]
11222 fn from(v: SizeGroupMode) -> Self {
11223 skip_assert_initialized!();
11224 ToValue::to_value(&v)
11225 }
11226}
11227
11228#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
11231#[non_exhaustive]
11232#[doc(alias = "GtkSizeRequestMode")]
11233pub enum SizeRequestMode {
11234 #[doc(alias = "GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH")]
11236 HeightForWidth,
11237 #[doc(alias = "GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT")]
11239 WidthForHeight,
11240 #[doc(alias = "GTK_SIZE_REQUEST_CONSTANT_SIZE")]
11242 ConstantSize,
11243 #[doc(hidden)]
11244 __Unknown(i32),
11245}
11246
11247#[doc(hidden)]
11248impl IntoGlib for SizeRequestMode {
11249 type GlibType = ffi::GtkSizeRequestMode;
11250
11251 #[inline]
11252 fn into_glib(self) -> ffi::GtkSizeRequestMode {
11253 match self {
11254 Self::HeightForWidth => ffi::GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH,
11255 Self::WidthForHeight => ffi::GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT,
11256 Self::ConstantSize => ffi::GTK_SIZE_REQUEST_CONSTANT_SIZE,
11257 Self::__Unknown(value) => value,
11258 }
11259 }
11260}
11261
11262#[doc(hidden)]
11263impl FromGlib<ffi::GtkSizeRequestMode> for SizeRequestMode {
11264 #[inline]
11265 unsafe fn from_glib(value: ffi::GtkSizeRequestMode) -> Self {
11266 skip_assert_initialized!();
11267
11268 match value {
11269 ffi::GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH => Self::HeightForWidth,
11270 ffi::GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT => Self::WidthForHeight,
11271 ffi::GTK_SIZE_REQUEST_CONSTANT_SIZE => Self::ConstantSize,
11272 value => Self::__Unknown(value),
11273 }
11274 }
11275}
11276
11277impl StaticType for SizeRequestMode {
11278 #[inline]
11279 #[doc(alias = "gtk_size_request_mode_get_type")]
11280 fn static_type() -> glib::Type {
11281 unsafe { from_glib(ffi::gtk_size_request_mode_get_type()) }
11282 }
11283}
11284
11285impl glib::HasParamSpec for SizeRequestMode {
11286 type ParamSpec = glib::ParamSpecEnum;
11287 type SetValue = Self;
11288 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
11289
11290 fn param_spec_builder() -> Self::BuilderFn {
11291 Self::ParamSpec::builder_with_default
11292 }
11293}
11294
11295impl glib::value::ValueType for SizeRequestMode {
11296 type Type = Self;
11297}
11298
11299unsafe impl<'a> glib::value::FromValue<'a> for SizeRequestMode {
11300 type Checker = glib::value::GenericValueTypeChecker<Self>;
11301
11302 #[inline]
11303 unsafe fn from_value(value: &'a glib::Value) -> Self {
11304 skip_assert_initialized!();
11305 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
11306 }
11307}
11308
11309impl ToValue for SizeRequestMode {
11310 #[inline]
11311 fn to_value(&self) -> glib::Value {
11312 let mut value = glib::Value::for_value_type::<Self>();
11313 unsafe {
11314 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
11315 }
11316 value
11317 }
11318
11319 #[inline]
11320 fn value_type(&self) -> glib::Type {
11321 Self::static_type()
11322 }
11323}
11324
11325impl From<SizeRequestMode> for glib::Value {
11326 #[inline]
11327 fn from(v: SizeRequestMode) -> Self {
11328 skip_assert_initialized!();
11329 ToValue::to_value(&v)
11330 }
11331}
11332
11333#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
11335#[non_exhaustive]
11336#[doc(alias = "GtkSortType")]
11337pub enum SortType {
11338 #[doc(alias = "GTK_SORT_ASCENDING")]
11340 Ascending,
11341 #[doc(alias = "GTK_SORT_DESCENDING")]
11343 Descending,
11344 #[doc(hidden)]
11345 __Unknown(i32),
11346}
11347
11348#[doc(hidden)]
11349impl IntoGlib for SortType {
11350 type GlibType = ffi::GtkSortType;
11351
11352 #[inline]
11353 fn into_glib(self) -> ffi::GtkSortType {
11354 match self {
11355 Self::Ascending => ffi::GTK_SORT_ASCENDING,
11356 Self::Descending => ffi::GTK_SORT_DESCENDING,
11357 Self::__Unknown(value) => value,
11358 }
11359 }
11360}
11361
11362#[doc(hidden)]
11363impl FromGlib<ffi::GtkSortType> for SortType {
11364 #[inline]
11365 unsafe fn from_glib(value: ffi::GtkSortType) -> Self {
11366 skip_assert_initialized!();
11367
11368 match value {
11369 ffi::GTK_SORT_ASCENDING => Self::Ascending,
11370 ffi::GTK_SORT_DESCENDING => Self::Descending,
11371 value => Self::__Unknown(value),
11372 }
11373 }
11374}
11375
11376impl StaticType for SortType {
11377 #[inline]
11378 #[doc(alias = "gtk_sort_type_get_type")]
11379 fn static_type() -> glib::Type {
11380 unsafe { from_glib(ffi::gtk_sort_type_get_type()) }
11381 }
11382}
11383
11384impl glib::HasParamSpec for SortType {
11385 type ParamSpec = glib::ParamSpecEnum;
11386 type SetValue = Self;
11387 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
11388
11389 fn param_spec_builder() -> Self::BuilderFn {
11390 Self::ParamSpec::builder_with_default
11391 }
11392}
11393
11394impl glib::value::ValueType for SortType {
11395 type Type = Self;
11396}
11397
11398unsafe impl<'a> glib::value::FromValue<'a> for SortType {
11399 type Checker = glib::value::GenericValueTypeChecker<Self>;
11400
11401 #[inline]
11402 unsafe fn from_value(value: &'a glib::Value) -> Self {
11403 skip_assert_initialized!();
11404 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
11405 }
11406}
11407
11408impl ToValue for SortType {
11409 #[inline]
11410 fn to_value(&self) -> glib::Value {
11411 let mut value = glib::Value::for_value_type::<Self>();
11412 unsafe {
11413 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
11414 }
11415 value
11416 }
11417
11418 #[inline]
11419 fn value_type(&self) -> glib::Type {
11420 Self::static_type()
11421 }
11422}
11423
11424impl From<SortType> for glib::Value {
11425 #[inline]
11426 fn from(v: SortType) -> Self {
11427 skip_assert_initialized!();
11428 ToValue::to_value(&v)
11429 }
11430}
11431
11432#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
11435#[non_exhaustive]
11436#[doc(alias = "GtkSorterChange")]
11437pub enum SorterChange {
11438 #[doc(alias = "GTK_SORTER_CHANGE_DIFFERENT")]
11441 Different,
11442 #[doc(alias = "GTK_SORTER_CHANGE_INVERTED")]
11446 Inverted,
11447 #[doc(alias = "GTK_SORTER_CHANGE_LESS_STRICT")]
11450 LessStrict,
11451 #[doc(alias = "GTK_SORTER_CHANGE_MORE_STRICT")]
11454 MoreStrict,
11455 #[doc(hidden)]
11456 __Unknown(i32),
11457}
11458
11459#[doc(hidden)]
11460impl IntoGlib for SorterChange {
11461 type GlibType = ffi::GtkSorterChange;
11462
11463 #[inline]
11464 fn into_glib(self) -> ffi::GtkSorterChange {
11465 match self {
11466 Self::Different => ffi::GTK_SORTER_CHANGE_DIFFERENT,
11467 Self::Inverted => ffi::GTK_SORTER_CHANGE_INVERTED,
11468 Self::LessStrict => ffi::GTK_SORTER_CHANGE_LESS_STRICT,
11469 Self::MoreStrict => ffi::GTK_SORTER_CHANGE_MORE_STRICT,
11470 Self::__Unknown(value) => value,
11471 }
11472 }
11473}
11474
11475#[doc(hidden)]
11476impl FromGlib<ffi::GtkSorterChange> for SorterChange {
11477 #[inline]
11478 unsafe fn from_glib(value: ffi::GtkSorterChange) -> Self {
11479 skip_assert_initialized!();
11480
11481 match value {
11482 ffi::GTK_SORTER_CHANGE_DIFFERENT => Self::Different,
11483 ffi::GTK_SORTER_CHANGE_INVERTED => Self::Inverted,
11484 ffi::GTK_SORTER_CHANGE_LESS_STRICT => Self::LessStrict,
11485 ffi::GTK_SORTER_CHANGE_MORE_STRICT => Self::MoreStrict,
11486 value => Self::__Unknown(value),
11487 }
11488 }
11489}
11490
11491impl StaticType for SorterChange {
11492 #[inline]
11493 #[doc(alias = "gtk_sorter_change_get_type")]
11494 fn static_type() -> glib::Type {
11495 unsafe { from_glib(ffi::gtk_sorter_change_get_type()) }
11496 }
11497}
11498
11499impl glib::HasParamSpec for SorterChange {
11500 type ParamSpec = glib::ParamSpecEnum;
11501 type SetValue = Self;
11502 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
11503
11504 fn param_spec_builder() -> Self::BuilderFn {
11505 Self::ParamSpec::builder_with_default
11506 }
11507}
11508
11509impl glib::value::ValueType for SorterChange {
11510 type Type = Self;
11511}
11512
11513unsafe impl<'a> glib::value::FromValue<'a> for SorterChange {
11514 type Checker = glib::value::GenericValueTypeChecker<Self>;
11515
11516 #[inline]
11517 unsafe fn from_value(value: &'a glib::Value) -> Self {
11518 skip_assert_initialized!();
11519 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
11520 }
11521}
11522
11523impl ToValue for SorterChange {
11524 #[inline]
11525 fn to_value(&self) -> glib::Value {
11526 let mut value = glib::Value::for_value_type::<Self>();
11527 unsafe {
11528 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
11529 }
11530 value
11531 }
11532
11533 #[inline]
11534 fn value_type(&self) -> glib::Type {
11535 Self::static_type()
11536 }
11537}
11538
11539impl From<SorterChange> for glib::Value {
11540 #[inline]
11541 fn from(v: SorterChange) -> Self {
11542 skip_assert_initialized!();
11543 ToValue::to_value(&v)
11544 }
11545}
11546
11547#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
11549#[non_exhaustive]
11550#[doc(alias = "GtkSorterOrder")]
11551pub enum SorterOrder {
11552 #[doc(alias = "GTK_SORTER_ORDER_PARTIAL")]
11554 Partial,
11555 #[doc(alias = "GTK_SORTER_ORDER_NONE")]
11558 None,
11559 #[doc(alias = "GTK_SORTER_ORDER_TOTAL")]
11563 Total,
11564 #[doc(hidden)]
11565 __Unknown(i32),
11566}
11567
11568#[doc(hidden)]
11569impl IntoGlib for SorterOrder {
11570 type GlibType = ffi::GtkSorterOrder;
11571
11572 #[inline]
11573 fn into_glib(self) -> ffi::GtkSorterOrder {
11574 match self {
11575 Self::Partial => ffi::GTK_SORTER_ORDER_PARTIAL,
11576 Self::None => ffi::GTK_SORTER_ORDER_NONE,
11577 Self::Total => ffi::GTK_SORTER_ORDER_TOTAL,
11578 Self::__Unknown(value) => value,
11579 }
11580 }
11581}
11582
11583#[doc(hidden)]
11584impl FromGlib<ffi::GtkSorterOrder> for SorterOrder {
11585 #[inline]
11586 unsafe fn from_glib(value: ffi::GtkSorterOrder) -> Self {
11587 skip_assert_initialized!();
11588
11589 match value {
11590 ffi::GTK_SORTER_ORDER_PARTIAL => Self::Partial,
11591 ffi::GTK_SORTER_ORDER_NONE => Self::None,
11592 ffi::GTK_SORTER_ORDER_TOTAL => Self::Total,
11593 value => Self::__Unknown(value),
11594 }
11595 }
11596}
11597
11598impl StaticType for SorterOrder {
11599 #[inline]
11600 #[doc(alias = "gtk_sorter_order_get_type")]
11601 fn static_type() -> glib::Type {
11602 unsafe { from_glib(ffi::gtk_sorter_order_get_type()) }
11603 }
11604}
11605
11606impl glib::HasParamSpec for SorterOrder {
11607 type ParamSpec = glib::ParamSpecEnum;
11608 type SetValue = Self;
11609 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
11610
11611 fn param_spec_builder() -> Self::BuilderFn {
11612 Self::ParamSpec::builder_with_default
11613 }
11614}
11615
11616impl glib::value::ValueType for SorterOrder {
11617 type Type = Self;
11618}
11619
11620unsafe impl<'a> glib::value::FromValue<'a> for SorterOrder {
11621 type Checker = glib::value::GenericValueTypeChecker<Self>;
11622
11623 #[inline]
11624 unsafe fn from_value(value: &'a glib::Value) -> Self {
11625 skip_assert_initialized!();
11626 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
11627 }
11628}
11629
11630impl ToValue for SorterOrder {
11631 #[inline]
11632 fn to_value(&self) -> glib::Value {
11633 let mut value = glib::Value::for_value_type::<Self>();
11634 unsafe {
11635 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
11636 }
11637 value
11638 }
11639
11640 #[inline]
11641 fn value_type(&self) -> glib::Type {
11642 Self::static_type()
11643 }
11644}
11645
11646impl From<SorterOrder> for glib::Value {
11647 #[inline]
11648 fn from(v: SorterOrder) -> Self {
11649 skip_assert_initialized!();
11650 ToValue::to_value(&v)
11651 }
11652}
11653
11654#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
11659#[non_exhaustive]
11660#[doc(alias = "GtkSpinButtonUpdatePolicy")]
11661pub enum SpinButtonUpdatePolicy {
11662 #[doc(alias = "GTK_UPDATE_ALWAYS")]
11665 Always,
11666 #[doc(alias = "GTK_UPDATE_IF_VALID")]
11670 IfValid,
11671 #[doc(hidden)]
11672 __Unknown(i32),
11673}
11674
11675#[doc(hidden)]
11676impl IntoGlib for SpinButtonUpdatePolicy {
11677 type GlibType = ffi::GtkSpinButtonUpdatePolicy;
11678
11679 #[inline]
11680 fn into_glib(self) -> ffi::GtkSpinButtonUpdatePolicy {
11681 match self {
11682 Self::Always => ffi::GTK_UPDATE_ALWAYS,
11683 Self::IfValid => ffi::GTK_UPDATE_IF_VALID,
11684 Self::__Unknown(value) => value,
11685 }
11686 }
11687}
11688
11689#[doc(hidden)]
11690impl FromGlib<ffi::GtkSpinButtonUpdatePolicy> for SpinButtonUpdatePolicy {
11691 #[inline]
11692 unsafe fn from_glib(value: ffi::GtkSpinButtonUpdatePolicy) -> Self {
11693 skip_assert_initialized!();
11694
11695 match value {
11696 ffi::GTK_UPDATE_ALWAYS => Self::Always,
11697 ffi::GTK_UPDATE_IF_VALID => Self::IfValid,
11698 value => Self::__Unknown(value),
11699 }
11700 }
11701}
11702
11703impl StaticType for SpinButtonUpdatePolicy {
11704 #[inline]
11705 #[doc(alias = "gtk_spin_button_update_policy_get_type")]
11706 fn static_type() -> glib::Type {
11707 unsafe { from_glib(ffi::gtk_spin_button_update_policy_get_type()) }
11708 }
11709}
11710
11711impl glib::HasParamSpec for SpinButtonUpdatePolicy {
11712 type ParamSpec = glib::ParamSpecEnum;
11713 type SetValue = Self;
11714 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
11715
11716 fn param_spec_builder() -> Self::BuilderFn {
11717 Self::ParamSpec::builder_with_default
11718 }
11719}
11720
11721impl glib::value::ValueType for SpinButtonUpdatePolicy {
11722 type Type = Self;
11723}
11724
11725unsafe impl<'a> glib::value::FromValue<'a> for SpinButtonUpdatePolicy {
11726 type Checker = glib::value::GenericValueTypeChecker<Self>;
11727
11728 #[inline]
11729 unsafe fn from_value(value: &'a glib::Value) -> Self {
11730 skip_assert_initialized!();
11731 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
11732 }
11733}
11734
11735impl ToValue for SpinButtonUpdatePolicy {
11736 #[inline]
11737 fn to_value(&self) -> glib::Value {
11738 let mut value = glib::Value::for_value_type::<Self>();
11739 unsafe {
11740 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
11741 }
11742 value
11743 }
11744
11745 #[inline]
11746 fn value_type(&self) -> glib::Type {
11747 Self::static_type()
11748 }
11749}
11750
11751impl From<SpinButtonUpdatePolicy> for glib::Value {
11752 #[inline]
11753 fn from(v: SpinButtonUpdatePolicy) -> Self {
11754 skip_assert_initialized!();
11755 ToValue::to_value(&v)
11756 }
11757}
11758
11759#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
11762#[non_exhaustive]
11763#[doc(alias = "GtkSpinType")]
11764pub enum SpinType {
11765 #[doc(alias = "GTK_SPIN_STEP_FORWARD")]
11767 StepForward,
11768 #[doc(alias = "GTK_SPIN_STEP_BACKWARD")]
11770 StepBackward,
11771 #[doc(alias = "GTK_SPIN_PAGE_FORWARD")]
11773 PageForward,
11774 #[doc(alias = "GTK_SPIN_PAGE_BACKWARD")]
11776 PageBackward,
11777 #[doc(alias = "GTK_SPIN_HOME")]
11779 Home,
11780 #[doc(alias = "GTK_SPIN_END")]
11782 End,
11783 #[doc(alias = "GTK_SPIN_USER_DEFINED")]
11785 UserDefined,
11786 #[doc(hidden)]
11787 __Unknown(i32),
11788}
11789
11790#[doc(hidden)]
11791impl IntoGlib for SpinType {
11792 type GlibType = ffi::GtkSpinType;
11793
11794 #[inline]
11795 fn into_glib(self) -> ffi::GtkSpinType {
11796 match self {
11797 Self::StepForward => ffi::GTK_SPIN_STEP_FORWARD,
11798 Self::StepBackward => ffi::GTK_SPIN_STEP_BACKWARD,
11799 Self::PageForward => ffi::GTK_SPIN_PAGE_FORWARD,
11800 Self::PageBackward => ffi::GTK_SPIN_PAGE_BACKWARD,
11801 Self::Home => ffi::GTK_SPIN_HOME,
11802 Self::End => ffi::GTK_SPIN_END,
11803 Self::UserDefined => ffi::GTK_SPIN_USER_DEFINED,
11804 Self::__Unknown(value) => value,
11805 }
11806 }
11807}
11808
11809#[doc(hidden)]
11810impl FromGlib<ffi::GtkSpinType> for SpinType {
11811 #[inline]
11812 unsafe fn from_glib(value: ffi::GtkSpinType) -> Self {
11813 skip_assert_initialized!();
11814
11815 match value {
11816 ffi::GTK_SPIN_STEP_FORWARD => Self::StepForward,
11817 ffi::GTK_SPIN_STEP_BACKWARD => Self::StepBackward,
11818 ffi::GTK_SPIN_PAGE_FORWARD => Self::PageForward,
11819 ffi::GTK_SPIN_PAGE_BACKWARD => Self::PageBackward,
11820 ffi::GTK_SPIN_HOME => Self::Home,
11821 ffi::GTK_SPIN_END => Self::End,
11822 ffi::GTK_SPIN_USER_DEFINED => Self::UserDefined,
11823 value => Self::__Unknown(value),
11824 }
11825 }
11826}
11827
11828impl StaticType for SpinType {
11829 #[inline]
11830 #[doc(alias = "gtk_spin_type_get_type")]
11831 fn static_type() -> glib::Type {
11832 unsafe { from_glib(ffi::gtk_spin_type_get_type()) }
11833 }
11834}
11835
11836impl glib::HasParamSpec for SpinType {
11837 type ParamSpec = glib::ParamSpecEnum;
11838 type SetValue = Self;
11839 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
11840
11841 fn param_spec_builder() -> Self::BuilderFn {
11842 Self::ParamSpec::builder_with_default
11843 }
11844}
11845
11846impl glib::value::ValueType for SpinType {
11847 type Type = Self;
11848}
11849
11850unsafe impl<'a> glib::value::FromValue<'a> for SpinType {
11851 type Checker = glib::value::GenericValueTypeChecker<Self>;
11852
11853 #[inline]
11854 unsafe fn from_value(value: &'a glib::Value) -> Self {
11855 skip_assert_initialized!();
11856 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
11857 }
11858}
11859
11860impl ToValue for SpinType {
11861 #[inline]
11862 fn to_value(&self) -> glib::Value {
11863 let mut value = glib::Value::for_value_type::<Self>();
11864 unsafe {
11865 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
11866 }
11867 value
11868 }
11869
11870 #[inline]
11871 fn value_type(&self) -> glib::Type {
11872 Self::static_type()
11873 }
11874}
11875
11876impl From<SpinType> for glib::Value {
11877 #[inline]
11878 fn from(v: SpinType) -> Self {
11879 skip_assert_initialized!();
11880 ToValue::to_value(&v)
11881 }
11882}
11883
11884#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
11888#[non_exhaustive]
11889#[doc(alias = "GtkStackTransitionType")]
11890pub enum StackTransitionType {
11891 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_NONE")]
11893 None,
11894 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_CROSSFADE")]
11896 Crossfade,
11897 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_SLIDE_RIGHT")]
11899 SlideRight,
11900 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT")]
11902 SlideLeft,
11903 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_SLIDE_UP")]
11905 SlideUp,
11906 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_SLIDE_DOWN")]
11908 SlideDown,
11909 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT")]
11911 SlideLeftRight,
11912 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN")]
11914 SlideUpDown,
11915 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_UP")]
11917 OverUp,
11918 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_DOWN")]
11920 OverDown,
11921 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_LEFT")]
11923 OverLeft,
11924 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_RIGHT")]
11926 OverRight,
11927 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_UNDER_UP")]
11929 UnderUp,
11930 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_UNDER_DOWN")]
11932 UnderDown,
11933 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_UNDER_LEFT")]
11935 UnderLeft,
11936 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_UNDER_RIGHT")]
11938 UnderRight,
11939 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_UP_DOWN")]
11941 OverUpDown,
11942 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_DOWN_UP")]
11944 OverDownUp,
11945 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_LEFT_RIGHT")]
11947 OverLeftRight,
11948 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_RIGHT_LEFT")]
11950 OverRightLeft,
11951 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT")]
11953 RotateLeft,
11954 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_ROTATE_RIGHT")]
11956 RotateRight,
11957 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT_RIGHT")]
11959 RotateLeftRight,
11960 #[doc(hidden)]
11961 __Unknown(i32),
11962}
11963
11964#[doc(hidden)]
11965impl IntoGlib for StackTransitionType {
11966 type GlibType = ffi::GtkStackTransitionType;
11967
11968 fn into_glib(self) -> ffi::GtkStackTransitionType {
11969 match self {
11970 Self::None => ffi::GTK_STACK_TRANSITION_TYPE_NONE,
11971 Self::Crossfade => ffi::GTK_STACK_TRANSITION_TYPE_CROSSFADE,
11972 Self::SlideRight => ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_RIGHT,
11973 Self::SlideLeft => ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT,
11974 Self::SlideUp => ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_UP,
11975 Self::SlideDown => ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_DOWN,
11976 Self::SlideLeftRight => ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT,
11977 Self::SlideUpDown => ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN,
11978 Self::OverUp => ffi::GTK_STACK_TRANSITION_TYPE_OVER_UP,
11979 Self::OverDown => ffi::GTK_STACK_TRANSITION_TYPE_OVER_DOWN,
11980 Self::OverLeft => ffi::GTK_STACK_TRANSITION_TYPE_OVER_LEFT,
11981 Self::OverRight => ffi::GTK_STACK_TRANSITION_TYPE_OVER_RIGHT,
11982 Self::UnderUp => ffi::GTK_STACK_TRANSITION_TYPE_UNDER_UP,
11983 Self::UnderDown => ffi::GTK_STACK_TRANSITION_TYPE_UNDER_DOWN,
11984 Self::UnderLeft => ffi::GTK_STACK_TRANSITION_TYPE_UNDER_LEFT,
11985 Self::UnderRight => ffi::GTK_STACK_TRANSITION_TYPE_UNDER_RIGHT,
11986 Self::OverUpDown => ffi::GTK_STACK_TRANSITION_TYPE_OVER_UP_DOWN,
11987 Self::OverDownUp => ffi::GTK_STACK_TRANSITION_TYPE_OVER_DOWN_UP,
11988 Self::OverLeftRight => ffi::GTK_STACK_TRANSITION_TYPE_OVER_LEFT_RIGHT,
11989 Self::OverRightLeft => ffi::GTK_STACK_TRANSITION_TYPE_OVER_RIGHT_LEFT,
11990 Self::RotateLeft => ffi::GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT,
11991 Self::RotateRight => ffi::GTK_STACK_TRANSITION_TYPE_ROTATE_RIGHT,
11992 Self::RotateLeftRight => ffi::GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT_RIGHT,
11993 Self::__Unknown(value) => value,
11994 }
11995 }
11996}
11997
11998#[doc(hidden)]
11999impl FromGlib<ffi::GtkStackTransitionType> for StackTransitionType {
12000 unsafe fn from_glib(value: ffi::GtkStackTransitionType) -> Self {
12001 skip_assert_initialized!();
12002
12003 match value {
12004 ffi::GTK_STACK_TRANSITION_TYPE_NONE => Self::None,
12005 ffi::GTK_STACK_TRANSITION_TYPE_CROSSFADE => Self::Crossfade,
12006 ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_RIGHT => Self::SlideRight,
12007 ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT => Self::SlideLeft,
12008 ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_UP => Self::SlideUp,
12009 ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_DOWN => Self::SlideDown,
12010 ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT => Self::SlideLeftRight,
12011 ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN => Self::SlideUpDown,
12012 ffi::GTK_STACK_TRANSITION_TYPE_OVER_UP => Self::OverUp,
12013 ffi::GTK_STACK_TRANSITION_TYPE_OVER_DOWN => Self::OverDown,
12014 ffi::GTK_STACK_TRANSITION_TYPE_OVER_LEFT => Self::OverLeft,
12015 ffi::GTK_STACK_TRANSITION_TYPE_OVER_RIGHT => Self::OverRight,
12016 ffi::GTK_STACK_TRANSITION_TYPE_UNDER_UP => Self::UnderUp,
12017 ffi::GTK_STACK_TRANSITION_TYPE_UNDER_DOWN => Self::UnderDown,
12018 ffi::GTK_STACK_TRANSITION_TYPE_UNDER_LEFT => Self::UnderLeft,
12019 ffi::GTK_STACK_TRANSITION_TYPE_UNDER_RIGHT => Self::UnderRight,
12020 ffi::GTK_STACK_TRANSITION_TYPE_OVER_UP_DOWN => Self::OverUpDown,
12021 ffi::GTK_STACK_TRANSITION_TYPE_OVER_DOWN_UP => Self::OverDownUp,
12022 ffi::GTK_STACK_TRANSITION_TYPE_OVER_LEFT_RIGHT => Self::OverLeftRight,
12023 ffi::GTK_STACK_TRANSITION_TYPE_OVER_RIGHT_LEFT => Self::OverRightLeft,
12024 ffi::GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT => Self::RotateLeft,
12025 ffi::GTK_STACK_TRANSITION_TYPE_ROTATE_RIGHT => Self::RotateRight,
12026 ffi::GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT_RIGHT => Self::RotateLeftRight,
12027 value => Self::__Unknown(value),
12028 }
12029 }
12030}
12031
12032impl StaticType for StackTransitionType {
12033 #[inline]
12034 #[doc(alias = "gtk_stack_transition_type_get_type")]
12035 fn static_type() -> glib::Type {
12036 unsafe { from_glib(ffi::gtk_stack_transition_type_get_type()) }
12037 }
12038}
12039
12040impl glib::HasParamSpec for StackTransitionType {
12041 type ParamSpec = glib::ParamSpecEnum;
12042 type SetValue = Self;
12043 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
12044
12045 fn param_spec_builder() -> Self::BuilderFn {
12046 Self::ParamSpec::builder_with_default
12047 }
12048}
12049
12050impl glib::value::ValueType for StackTransitionType {
12051 type Type = Self;
12052}
12053
12054unsafe impl<'a> glib::value::FromValue<'a> for StackTransitionType {
12055 type Checker = glib::value::GenericValueTypeChecker<Self>;
12056
12057 #[inline]
12058 unsafe fn from_value(value: &'a glib::Value) -> Self {
12059 skip_assert_initialized!();
12060 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
12061 }
12062}
12063
12064impl ToValue for StackTransitionType {
12065 #[inline]
12066 fn to_value(&self) -> glib::Value {
12067 let mut value = glib::Value::for_value_type::<Self>();
12068 unsafe {
12069 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
12070 }
12071 value
12072 }
12073
12074 #[inline]
12075 fn value_type(&self) -> glib::Type {
12076 Self::static_type()
12077 }
12078}
12079
12080impl From<StackTransitionType> for glib::Value {
12081 #[inline]
12082 fn from(v: StackTransitionType) -> Self {
12083 skip_assert_initialized!();
12084 ToValue::to_value(&v)
12085 }
12086}
12087
12088#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
12090#[non_exhaustive]
12091#[doc(alias = "GtkStringFilterMatchMode")]
12092pub enum StringFilterMatchMode {
12093 #[doc(alias = "GTK_STRING_FILTER_MATCH_MODE_EXACT")]
12096 Exact,
12097 #[doc(alias = "GTK_STRING_FILTER_MATCH_MODE_SUBSTRING")]
12100 Substring,
12101 #[doc(alias = "GTK_STRING_FILTER_MATCH_MODE_PREFIX")]
12104 Prefix,
12105 #[doc(hidden)]
12106 __Unknown(i32),
12107}
12108
12109#[doc(hidden)]
12110impl IntoGlib for StringFilterMatchMode {
12111 type GlibType = ffi::GtkStringFilterMatchMode;
12112
12113 #[inline]
12114 fn into_glib(self) -> ffi::GtkStringFilterMatchMode {
12115 match self {
12116 Self::Exact => ffi::GTK_STRING_FILTER_MATCH_MODE_EXACT,
12117 Self::Substring => ffi::GTK_STRING_FILTER_MATCH_MODE_SUBSTRING,
12118 Self::Prefix => ffi::GTK_STRING_FILTER_MATCH_MODE_PREFIX,
12119 Self::__Unknown(value) => value,
12120 }
12121 }
12122}
12123
12124#[doc(hidden)]
12125impl FromGlib<ffi::GtkStringFilterMatchMode> for StringFilterMatchMode {
12126 #[inline]
12127 unsafe fn from_glib(value: ffi::GtkStringFilterMatchMode) -> Self {
12128 skip_assert_initialized!();
12129
12130 match value {
12131 ffi::GTK_STRING_FILTER_MATCH_MODE_EXACT => Self::Exact,
12132 ffi::GTK_STRING_FILTER_MATCH_MODE_SUBSTRING => Self::Substring,
12133 ffi::GTK_STRING_FILTER_MATCH_MODE_PREFIX => Self::Prefix,
12134 value => Self::__Unknown(value),
12135 }
12136 }
12137}
12138
12139impl StaticType for StringFilterMatchMode {
12140 #[inline]
12141 #[doc(alias = "gtk_string_filter_match_mode_get_type")]
12142 fn static_type() -> glib::Type {
12143 unsafe { from_glib(ffi::gtk_string_filter_match_mode_get_type()) }
12144 }
12145}
12146
12147impl glib::HasParamSpec for StringFilterMatchMode {
12148 type ParamSpec = glib::ParamSpecEnum;
12149 type SetValue = Self;
12150 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
12151
12152 fn param_spec_builder() -> Self::BuilderFn {
12153 Self::ParamSpec::builder_with_default
12154 }
12155}
12156
12157impl glib::value::ValueType for StringFilterMatchMode {
12158 type Type = Self;
12159}
12160
12161unsafe impl<'a> glib::value::FromValue<'a> for StringFilterMatchMode {
12162 type Checker = glib::value::GenericValueTypeChecker<Self>;
12163
12164 #[inline]
12165 unsafe fn from_value(value: &'a glib::Value) -> Self {
12166 skip_assert_initialized!();
12167 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
12168 }
12169}
12170
12171impl ToValue for StringFilterMatchMode {
12172 #[inline]
12173 fn to_value(&self) -> glib::Value {
12174 let mut value = glib::Value::for_value_type::<Self>();
12175 unsafe {
12176 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
12177 }
12178 value
12179 }
12180
12181 #[inline]
12182 fn value_type(&self) -> glib::Type {
12183 Self::static_type()
12184 }
12185}
12186
12187impl From<StringFilterMatchMode> for glib::Value {
12188 #[inline]
12189 fn from(v: StringFilterMatchMode) -> Self {
12190 skip_assert_initialized!();
12191 ToValue::to_value(&v)
12192 }
12193}
12194
12195#[cfg(feature = "v4_6")]
12200#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
12201#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
12202#[non_exhaustive]
12203#[doc(alias = "GtkSymbolicColor")]
12204pub enum SymbolicColor {
12205 #[doc(alias = "GTK_SYMBOLIC_COLOR_FOREGROUND")]
12207 Foreground,
12208 #[doc(alias = "GTK_SYMBOLIC_COLOR_ERROR")]
12210 Error,
12211 #[doc(alias = "GTK_SYMBOLIC_COLOR_WARNING")]
12213 Warning,
12214 #[doc(alias = "GTK_SYMBOLIC_COLOR_SUCCESS")]
12216 Success,
12217 #[doc(hidden)]
12218 __Unknown(i32),
12219}
12220
12221#[cfg(feature = "v4_6")]
12222#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
12223#[doc(hidden)]
12224impl IntoGlib for SymbolicColor {
12225 type GlibType = ffi::GtkSymbolicColor;
12226
12227 #[inline]
12228 fn into_glib(self) -> ffi::GtkSymbolicColor {
12229 match self {
12230 Self::Foreground => ffi::GTK_SYMBOLIC_COLOR_FOREGROUND,
12231 Self::Error => ffi::GTK_SYMBOLIC_COLOR_ERROR,
12232 Self::Warning => ffi::GTK_SYMBOLIC_COLOR_WARNING,
12233 Self::Success => ffi::GTK_SYMBOLIC_COLOR_SUCCESS,
12234 Self::__Unknown(value) => value,
12235 }
12236 }
12237}
12238
12239#[cfg(feature = "v4_6")]
12240#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
12241#[doc(hidden)]
12242impl FromGlib<ffi::GtkSymbolicColor> for SymbolicColor {
12243 #[inline]
12244 unsafe fn from_glib(value: ffi::GtkSymbolicColor) -> Self {
12245 skip_assert_initialized!();
12246
12247 match value {
12248 ffi::GTK_SYMBOLIC_COLOR_FOREGROUND => Self::Foreground,
12249 ffi::GTK_SYMBOLIC_COLOR_ERROR => Self::Error,
12250 ffi::GTK_SYMBOLIC_COLOR_WARNING => Self::Warning,
12251 ffi::GTK_SYMBOLIC_COLOR_SUCCESS => Self::Success,
12252 value => Self::__Unknown(value),
12253 }
12254 }
12255}
12256
12257#[cfg(feature = "v4_6")]
12258#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
12259impl StaticType for SymbolicColor {
12260 #[inline]
12261 #[doc(alias = "gtk_symbolic_color_get_type")]
12262 fn static_type() -> glib::Type {
12263 unsafe { from_glib(ffi::gtk_symbolic_color_get_type()) }
12264 }
12265}
12266
12267#[cfg(feature = "v4_6")]
12268#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
12269impl glib::HasParamSpec for SymbolicColor {
12270 type ParamSpec = glib::ParamSpecEnum;
12271 type SetValue = Self;
12272 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
12273
12274 fn param_spec_builder() -> Self::BuilderFn {
12275 Self::ParamSpec::builder_with_default
12276 }
12277}
12278
12279#[cfg(feature = "v4_6")]
12280#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
12281impl glib::value::ValueType for SymbolicColor {
12282 type Type = Self;
12283}
12284
12285#[cfg(feature = "v4_6")]
12286#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
12287unsafe impl<'a> glib::value::FromValue<'a> for SymbolicColor {
12288 type Checker = glib::value::GenericValueTypeChecker<Self>;
12289
12290 #[inline]
12291 unsafe fn from_value(value: &'a glib::Value) -> Self {
12292 skip_assert_initialized!();
12293 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
12294 }
12295}
12296
12297#[cfg(feature = "v4_6")]
12298#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
12299impl ToValue for SymbolicColor {
12300 #[inline]
12301 fn to_value(&self) -> glib::Value {
12302 let mut value = glib::Value::for_value_type::<Self>();
12303 unsafe {
12304 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
12305 }
12306 value
12307 }
12308
12309 #[inline]
12310 fn value_type(&self) -> glib::Type {
12311 Self::static_type()
12312 }
12313}
12314
12315#[cfg(feature = "v4_6")]
12316#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
12317impl From<SymbolicColor> for glib::Value {
12318 #[inline]
12319 fn from(v: SymbolicColor) -> Self {
12320 skip_assert_initialized!();
12321 ToValue::to_value(&v)
12322 }
12323}
12324
12325#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
12335#[non_exhaustive]
12336#[doc(alias = "GtkSystemSetting")]
12337pub enum SystemSetting {
12338 #[doc(alias = "GTK_SYSTEM_SETTING_DPI")]
12340 Dpi,
12341 #[doc(alias = "GTK_SYSTEM_SETTING_FONT_NAME")]
12343 FontName,
12344 #[doc(alias = "GTK_SYSTEM_SETTING_FONT_CONFIG")]
12352 FontConfig,
12353 #[doc(alias = "GTK_SYSTEM_SETTING_DISPLAY")]
12355 Display,
12356 #[doc(alias = "GTK_SYSTEM_SETTING_ICON_THEME")]
12359 IconTheme,
12360 #[doc(hidden)]
12361 __Unknown(i32),
12362}
12363
12364#[doc(hidden)]
12365impl IntoGlib for SystemSetting {
12366 type GlibType = ffi::GtkSystemSetting;
12367
12368 #[inline]
12369 fn into_glib(self) -> ffi::GtkSystemSetting {
12370 match self {
12371 Self::Dpi => ffi::GTK_SYSTEM_SETTING_DPI,
12372 Self::FontName => ffi::GTK_SYSTEM_SETTING_FONT_NAME,
12373 Self::FontConfig => ffi::GTK_SYSTEM_SETTING_FONT_CONFIG,
12374 Self::Display => ffi::GTK_SYSTEM_SETTING_DISPLAY,
12375 Self::IconTheme => ffi::GTK_SYSTEM_SETTING_ICON_THEME,
12376 Self::__Unknown(value) => value,
12377 }
12378 }
12379}
12380
12381#[doc(hidden)]
12382impl FromGlib<ffi::GtkSystemSetting> for SystemSetting {
12383 #[inline]
12384 unsafe fn from_glib(value: ffi::GtkSystemSetting) -> Self {
12385 skip_assert_initialized!();
12386
12387 match value {
12388 ffi::GTK_SYSTEM_SETTING_DPI => Self::Dpi,
12389 ffi::GTK_SYSTEM_SETTING_FONT_NAME => Self::FontName,
12390 ffi::GTK_SYSTEM_SETTING_FONT_CONFIG => Self::FontConfig,
12391 ffi::GTK_SYSTEM_SETTING_DISPLAY => Self::Display,
12392 ffi::GTK_SYSTEM_SETTING_ICON_THEME => Self::IconTheme,
12393 value => Self::__Unknown(value),
12394 }
12395 }
12396}
12397
12398impl StaticType for SystemSetting {
12399 #[inline]
12400 #[doc(alias = "gtk_system_setting_get_type")]
12401 fn static_type() -> glib::Type {
12402 unsafe { from_glib(ffi::gtk_system_setting_get_type()) }
12403 }
12404}
12405
12406impl glib::HasParamSpec for SystemSetting {
12407 type ParamSpec = glib::ParamSpecEnum;
12408 type SetValue = Self;
12409 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
12410
12411 fn param_spec_builder() -> Self::BuilderFn {
12412 Self::ParamSpec::builder_with_default
12413 }
12414}
12415
12416impl glib::value::ValueType for SystemSetting {
12417 type Type = Self;
12418}
12419
12420unsafe impl<'a> glib::value::FromValue<'a> for SystemSetting {
12421 type Checker = glib::value::GenericValueTypeChecker<Self>;
12422
12423 #[inline]
12424 unsafe fn from_value(value: &'a glib::Value) -> Self {
12425 skip_assert_initialized!();
12426 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
12427 }
12428}
12429
12430impl ToValue for SystemSetting {
12431 #[inline]
12432 fn to_value(&self) -> glib::Value {
12433 let mut value = glib::Value::for_value_type::<Self>();
12434 unsafe {
12435 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
12436 }
12437 value
12438 }
12439
12440 #[inline]
12441 fn value_type(&self) -> glib::Type {
12442 Self::static_type()
12443 }
12444}
12445
12446impl From<SystemSetting> for glib::Value {
12447 #[inline]
12448 fn from(v: SystemSetting) -> Self {
12449 skip_assert_initialized!();
12450 ToValue::to_value(&v)
12451 }
12452}
12453
12454#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
12456#[non_exhaustive]
12457#[doc(alias = "GtkTextDirection")]
12458pub enum TextDirection {
12459 #[doc(alias = "GTK_TEXT_DIR_NONE")]
12461 None,
12462 #[doc(alias = "GTK_TEXT_DIR_LTR")]
12464 Ltr,
12465 #[doc(alias = "GTK_TEXT_DIR_RTL")]
12467 Rtl,
12468 #[doc(hidden)]
12469 __Unknown(i32),
12470}
12471
12472#[doc(hidden)]
12473impl IntoGlib for TextDirection {
12474 type GlibType = ffi::GtkTextDirection;
12475
12476 #[inline]
12477 fn into_glib(self) -> ffi::GtkTextDirection {
12478 match self {
12479 Self::None => ffi::GTK_TEXT_DIR_NONE,
12480 Self::Ltr => ffi::GTK_TEXT_DIR_LTR,
12481 Self::Rtl => ffi::GTK_TEXT_DIR_RTL,
12482 Self::__Unknown(value) => value,
12483 }
12484 }
12485}
12486
12487#[doc(hidden)]
12488impl FromGlib<ffi::GtkTextDirection> for TextDirection {
12489 #[inline]
12490 unsafe fn from_glib(value: ffi::GtkTextDirection) -> Self {
12491 skip_assert_initialized!();
12492
12493 match value {
12494 ffi::GTK_TEXT_DIR_NONE => Self::None,
12495 ffi::GTK_TEXT_DIR_LTR => Self::Ltr,
12496 ffi::GTK_TEXT_DIR_RTL => Self::Rtl,
12497 value => Self::__Unknown(value),
12498 }
12499 }
12500}
12501
12502impl StaticType for TextDirection {
12503 #[inline]
12504 #[doc(alias = "gtk_text_direction_get_type")]
12505 fn static_type() -> glib::Type {
12506 unsafe { from_glib(ffi::gtk_text_direction_get_type()) }
12507 }
12508}
12509
12510impl glib::HasParamSpec for TextDirection {
12511 type ParamSpec = glib::ParamSpecEnum;
12512 type SetValue = Self;
12513 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
12514
12515 fn param_spec_builder() -> Self::BuilderFn {
12516 Self::ParamSpec::builder_with_default
12517 }
12518}
12519
12520impl glib::value::ValueType for TextDirection {
12521 type Type = Self;
12522}
12523
12524unsafe impl<'a> glib::value::FromValue<'a> for TextDirection {
12525 type Checker = glib::value::GenericValueTypeChecker<Self>;
12526
12527 #[inline]
12528 unsafe fn from_value(value: &'a glib::Value) -> Self {
12529 skip_assert_initialized!();
12530 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
12531 }
12532}
12533
12534impl ToValue for TextDirection {
12535 #[inline]
12536 fn to_value(&self) -> glib::Value {
12537 let mut value = glib::Value::for_value_type::<Self>();
12538 unsafe {
12539 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
12540 }
12541 value
12542 }
12543
12544 #[inline]
12545 fn value_type(&self) -> glib::Type {
12546 Self::static_type()
12547 }
12548}
12549
12550impl From<TextDirection> for glib::Value {
12551 #[inline]
12552 fn from(v: TextDirection) -> Self {
12553 skip_assert_initialized!();
12554 ToValue::to_value(&v)
12555 }
12556}
12557
12558#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
12561#[non_exhaustive]
12562#[doc(alias = "GtkTextExtendSelection")]
12563pub enum TextExtendSelection {
12564 #[doc(alias = "GTK_TEXT_EXTEND_SELECTION_WORD")]
12567 Word,
12568 #[doc(alias = "GTK_TEXT_EXTEND_SELECTION_LINE")]
12571 Line,
12572 #[doc(hidden)]
12573 __Unknown(i32),
12574}
12575
12576#[doc(hidden)]
12577impl IntoGlib for TextExtendSelection {
12578 type GlibType = ffi::GtkTextExtendSelection;
12579
12580 #[inline]
12581 fn into_glib(self) -> ffi::GtkTextExtendSelection {
12582 match self {
12583 Self::Word => ffi::GTK_TEXT_EXTEND_SELECTION_WORD,
12584 Self::Line => ffi::GTK_TEXT_EXTEND_SELECTION_LINE,
12585 Self::__Unknown(value) => value,
12586 }
12587 }
12588}
12589
12590#[doc(hidden)]
12591impl FromGlib<ffi::GtkTextExtendSelection> for TextExtendSelection {
12592 #[inline]
12593 unsafe fn from_glib(value: ffi::GtkTextExtendSelection) -> Self {
12594 skip_assert_initialized!();
12595
12596 match value {
12597 ffi::GTK_TEXT_EXTEND_SELECTION_WORD => Self::Word,
12598 ffi::GTK_TEXT_EXTEND_SELECTION_LINE => Self::Line,
12599 value => Self::__Unknown(value),
12600 }
12601 }
12602}
12603
12604impl StaticType for TextExtendSelection {
12605 #[inline]
12606 #[doc(alias = "gtk_text_extend_selection_get_type")]
12607 fn static_type() -> glib::Type {
12608 unsafe { from_glib(ffi::gtk_text_extend_selection_get_type()) }
12609 }
12610}
12611
12612impl glib::HasParamSpec for TextExtendSelection {
12613 type ParamSpec = glib::ParamSpecEnum;
12614 type SetValue = Self;
12615 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
12616
12617 fn param_spec_builder() -> Self::BuilderFn {
12618 Self::ParamSpec::builder_with_default
12619 }
12620}
12621
12622impl glib::value::ValueType for TextExtendSelection {
12623 type Type = Self;
12624}
12625
12626unsafe impl<'a> glib::value::FromValue<'a> for TextExtendSelection {
12627 type Checker = glib::value::GenericValueTypeChecker<Self>;
12628
12629 #[inline]
12630 unsafe fn from_value(value: &'a glib::Value) -> Self {
12631 skip_assert_initialized!();
12632 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
12633 }
12634}
12635
12636impl ToValue for TextExtendSelection {
12637 #[inline]
12638 fn to_value(&self) -> glib::Value {
12639 let mut value = glib::Value::for_value_type::<Self>();
12640 unsafe {
12641 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
12642 }
12643 value
12644 }
12645
12646 #[inline]
12647 fn value_type(&self) -> glib::Type {
12648 Self::static_type()
12649 }
12650}
12651
12652impl From<TextExtendSelection> for glib::Value {
12653 #[inline]
12654 fn from(v: TextExtendSelection) -> Self {
12655 skip_assert_initialized!();
12656 ToValue::to_value(&v)
12657 }
12658}
12659
12660#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
12663#[non_exhaustive]
12664#[doc(alias = "GtkTextViewLayer")]
12665pub enum TextViewLayer {
12666 #[doc(alias = "GTK_TEXT_VIEW_LAYER_BELOW_TEXT")]
12668 BelowText,
12669 #[doc(alias = "GTK_TEXT_VIEW_LAYER_ABOVE_TEXT")]
12671 AboveText,
12672 #[doc(hidden)]
12673 __Unknown(i32),
12674}
12675
12676#[doc(hidden)]
12677impl IntoGlib for TextViewLayer {
12678 type GlibType = ffi::GtkTextViewLayer;
12679
12680 #[inline]
12681 fn into_glib(self) -> ffi::GtkTextViewLayer {
12682 match self {
12683 Self::BelowText => ffi::GTK_TEXT_VIEW_LAYER_BELOW_TEXT,
12684 Self::AboveText => ffi::GTK_TEXT_VIEW_LAYER_ABOVE_TEXT,
12685 Self::__Unknown(value) => value,
12686 }
12687 }
12688}
12689
12690#[doc(hidden)]
12691impl FromGlib<ffi::GtkTextViewLayer> for TextViewLayer {
12692 #[inline]
12693 unsafe fn from_glib(value: ffi::GtkTextViewLayer) -> Self {
12694 skip_assert_initialized!();
12695
12696 match value {
12697 ffi::GTK_TEXT_VIEW_LAYER_BELOW_TEXT => Self::BelowText,
12698 ffi::GTK_TEXT_VIEW_LAYER_ABOVE_TEXT => Self::AboveText,
12699 value => Self::__Unknown(value),
12700 }
12701 }
12702}
12703
12704impl StaticType for TextViewLayer {
12705 #[inline]
12706 #[doc(alias = "gtk_text_view_layer_get_type")]
12707 fn static_type() -> glib::Type {
12708 unsafe { from_glib(ffi::gtk_text_view_layer_get_type()) }
12709 }
12710}
12711
12712impl glib::HasParamSpec for TextViewLayer {
12713 type ParamSpec = glib::ParamSpecEnum;
12714 type SetValue = Self;
12715 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
12716
12717 fn param_spec_builder() -> Self::BuilderFn {
12718 Self::ParamSpec::builder_with_default
12719 }
12720}
12721
12722impl glib::value::ValueType for TextViewLayer {
12723 type Type = Self;
12724}
12725
12726unsafe impl<'a> glib::value::FromValue<'a> for TextViewLayer {
12727 type Checker = glib::value::GenericValueTypeChecker<Self>;
12728
12729 #[inline]
12730 unsafe fn from_value(value: &'a glib::Value) -> Self {
12731 skip_assert_initialized!();
12732 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
12733 }
12734}
12735
12736impl ToValue for TextViewLayer {
12737 #[inline]
12738 fn to_value(&self) -> glib::Value {
12739 let mut value = glib::Value::for_value_type::<Self>();
12740 unsafe {
12741 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
12742 }
12743 value
12744 }
12745
12746 #[inline]
12747 fn value_type(&self) -> glib::Type {
12748 Self::static_type()
12749 }
12750}
12751
12752impl From<TextViewLayer> for glib::Value {
12753 #[inline]
12754 fn from(v: TextViewLayer) -> Self {
12755 skip_assert_initialized!();
12756 ToValue::to_value(&v)
12757 }
12758}
12759
12760#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
12762#[non_exhaustive]
12763#[doc(alias = "GtkTextWindowType")]
12764pub enum TextWindowType {
12765 #[doc(alias = "GTK_TEXT_WINDOW_WIDGET")]
12767 Widget,
12768 #[doc(alias = "GTK_TEXT_WINDOW_TEXT")]
12770 Text,
12771 #[doc(alias = "GTK_TEXT_WINDOW_LEFT")]
12773 Left,
12774 #[doc(alias = "GTK_TEXT_WINDOW_RIGHT")]
12776 Right,
12777 #[doc(alias = "GTK_TEXT_WINDOW_TOP")]
12779 Top,
12780 #[doc(alias = "GTK_TEXT_WINDOW_BOTTOM")]
12782 Bottom,
12783 #[doc(hidden)]
12784 __Unknown(i32),
12785}
12786
12787#[doc(hidden)]
12788impl IntoGlib for TextWindowType {
12789 type GlibType = ffi::GtkTextWindowType;
12790
12791 #[inline]
12792 fn into_glib(self) -> ffi::GtkTextWindowType {
12793 match self {
12794 Self::Widget => ffi::GTK_TEXT_WINDOW_WIDGET,
12795 Self::Text => ffi::GTK_TEXT_WINDOW_TEXT,
12796 Self::Left => ffi::GTK_TEXT_WINDOW_LEFT,
12797 Self::Right => ffi::GTK_TEXT_WINDOW_RIGHT,
12798 Self::Top => ffi::GTK_TEXT_WINDOW_TOP,
12799 Self::Bottom => ffi::GTK_TEXT_WINDOW_BOTTOM,
12800 Self::__Unknown(value) => value,
12801 }
12802 }
12803}
12804
12805#[doc(hidden)]
12806impl FromGlib<ffi::GtkTextWindowType> for TextWindowType {
12807 #[inline]
12808 unsafe fn from_glib(value: ffi::GtkTextWindowType) -> Self {
12809 skip_assert_initialized!();
12810
12811 match value {
12812 ffi::GTK_TEXT_WINDOW_WIDGET => Self::Widget,
12813 ffi::GTK_TEXT_WINDOW_TEXT => Self::Text,
12814 ffi::GTK_TEXT_WINDOW_LEFT => Self::Left,
12815 ffi::GTK_TEXT_WINDOW_RIGHT => Self::Right,
12816 ffi::GTK_TEXT_WINDOW_TOP => Self::Top,
12817 ffi::GTK_TEXT_WINDOW_BOTTOM => Self::Bottom,
12818 value => Self::__Unknown(value),
12819 }
12820 }
12821}
12822
12823impl StaticType for TextWindowType {
12824 #[inline]
12825 #[doc(alias = "gtk_text_window_type_get_type")]
12826 fn static_type() -> glib::Type {
12827 unsafe { from_glib(ffi::gtk_text_window_type_get_type()) }
12828 }
12829}
12830
12831impl glib::HasParamSpec for TextWindowType {
12832 type ParamSpec = glib::ParamSpecEnum;
12833 type SetValue = Self;
12834 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
12835
12836 fn param_spec_builder() -> Self::BuilderFn {
12837 Self::ParamSpec::builder_with_default
12838 }
12839}
12840
12841impl glib::value::ValueType for TextWindowType {
12842 type Type = Self;
12843}
12844
12845unsafe impl<'a> glib::value::FromValue<'a> for TextWindowType {
12846 type Checker = glib::value::GenericValueTypeChecker<Self>;
12847
12848 #[inline]
12849 unsafe fn from_value(value: &'a glib::Value) -> Self {
12850 skip_assert_initialized!();
12851 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
12852 }
12853}
12854
12855impl ToValue for TextWindowType {
12856 #[inline]
12857 fn to_value(&self) -> glib::Value {
12858 let mut value = glib::Value::for_value_type::<Self>();
12859 unsafe {
12860 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
12861 }
12862 value
12863 }
12864
12865 #[inline]
12866 fn value_type(&self) -> glib::Type {
12867 Self::static_type()
12868 }
12869}
12870
12871impl From<TextWindowType> for glib::Value {
12872 #[inline]
12873 fn from(v: TextWindowType) -> Self {
12874 skip_assert_initialized!();
12875 ToValue::to_value(&v)
12876 }
12877}
12878
12879#[cfg_attr(feature = "v4_20", deprecated = "Since 4.20")]
12887#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
12888#[non_exhaustive]
12889#[doc(alias = "GtkTreeViewColumnSizing")]
12890pub enum TreeViewColumnSizing {
12891 #[doc(alias = "GTK_TREE_VIEW_COLUMN_GROW_ONLY")]
12893 GrowOnly,
12894 #[doc(alias = "GTK_TREE_VIEW_COLUMN_AUTOSIZE")]
12896 Autosize,
12897 #[doc(alias = "GTK_TREE_VIEW_COLUMN_FIXED")]
12899 Fixed,
12900 #[doc(hidden)]
12901 __Unknown(i32),
12902}
12903
12904#[allow(deprecated)]
12905#[doc(hidden)]
12906impl IntoGlib for TreeViewColumnSizing {
12907 type GlibType = ffi::GtkTreeViewColumnSizing;
12908
12909 #[inline]
12910 fn into_glib(self) -> ffi::GtkTreeViewColumnSizing {
12911 match self {
12912 Self::GrowOnly => ffi::GTK_TREE_VIEW_COLUMN_GROW_ONLY,
12913 Self::Autosize => ffi::GTK_TREE_VIEW_COLUMN_AUTOSIZE,
12914 Self::Fixed => ffi::GTK_TREE_VIEW_COLUMN_FIXED,
12915 Self::__Unknown(value) => value,
12916 }
12917 }
12918}
12919
12920#[allow(deprecated)]
12921#[doc(hidden)]
12922impl FromGlib<ffi::GtkTreeViewColumnSizing> for TreeViewColumnSizing {
12923 #[inline]
12924 unsafe fn from_glib(value: ffi::GtkTreeViewColumnSizing) -> Self {
12925 skip_assert_initialized!();
12926
12927 match value {
12928 ffi::GTK_TREE_VIEW_COLUMN_GROW_ONLY => Self::GrowOnly,
12929 ffi::GTK_TREE_VIEW_COLUMN_AUTOSIZE => Self::Autosize,
12930 ffi::GTK_TREE_VIEW_COLUMN_FIXED => Self::Fixed,
12931 value => Self::__Unknown(value),
12932 }
12933 }
12934}
12935
12936#[allow(deprecated)]
12937impl StaticType for TreeViewColumnSizing {
12938 #[inline]
12939 #[doc(alias = "gtk_tree_view_column_sizing_get_type")]
12940 fn static_type() -> glib::Type {
12941 unsafe { from_glib(ffi::gtk_tree_view_column_sizing_get_type()) }
12942 }
12943}
12944
12945#[allow(deprecated)]
12946impl glib::HasParamSpec for TreeViewColumnSizing {
12947 type ParamSpec = glib::ParamSpecEnum;
12948 type SetValue = Self;
12949 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
12950
12951 fn param_spec_builder() -> Self::BuilderFn {
12952 Self::ParamSpec::builder_with_default
12953 }
12954}
12955
12956#[allow(deprecated)]
12957impl glib::value::ValueType for TreeViewColumnSizing {
12958 type Type = Self;
12959}
12960
12961#[allow(deprecated)]
12962unsafe impl<'a> glib::value::FromValue<'a> for TreeViewColumnSizing {
12963 type Checker = glib::value::GenericValueTypeChecker<Self>;
12964
12965 #[inline]
12966 unsafe fn from_value(value: &'a glib::Value) -> Self {
12967 skip_assert_initialized!();
12968 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
12969 }
12970}
12971
12972#[allow(deprecated)]
12973impl ToValue for TreeViewColumnSizing {
12974 #[inline]
12975 fn to_value(&self) -> glib::Value {
12976 let mut value = glib::Value::for_value_type::<Self>();
12977 unsafe {
12978 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
12979 }
12980 value
12981 }
12982
12983 #[inline]
12984 fn value_type(&self) -> glib::Type {
12985 Self::static_type()
12986 }
12987}
12988
12989#[allow(deprecated)]
12990impl From<TreeViewColumnSizing> for glib::Value {
12991 #[inline]
12992 fn from(v: TreeViewColumnSizing) -> Self {
12993 skip_assert_initialized!();
12994 ToValue::to_value(&v)
12995 }
12996}
12997
12998#[cfg_attr(feature = "v4_20", deprecated = "Since 4.20")]
13004#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
13005#[non_exhaustive]
13006#[doc(alias = "GtkTreeViewDropPosition")]
13007pub enum TreeViewDropPosition {
13008 #[doc(alias = "GTK_TREE_VIEW_DROP_BEFORE")]
13010 Before,
13011 #[doc(alias = "GTK_TREE_VIEW_DROP_AFTER")]
13013 After,
13014 #[doc(alias = "GTK_TREE_VIEW_DROP_INTO_OR_BEFORE")]
13016 IntoOrBefore,
13017 #[doc(alias = "GTK_TREE_VIEW_DROP_INTO_OR_AFTER")]
13019 IntoOrAfter,
13020 #[doc(hidden)]
13021 __Unknown(i32),
13022}
13023
13024#[allow(deprecated)]
13025#[doc(hidden)]
13026impl IntoGlib for TreeViewDropPosition {
13027 type GlibType = ffi::GtkTreeViewDropPosition;
13028
13029 #[inline]
13030 fn into_glib(self) -> ffi::GtkTreeViewDropPosition {
13031 match self {
13032 Self::Before => ffi::GTK_TREE_VIEW_DROP_BEFORE,
13033 Self::After => ffi::GTK_TREE_VIEW_DROP_AFTER,
13034 Self::IntoOrBefore => ffi::GTK_TREE_VIEW_DROP_INTO_OR_BEFORE,
13035 Self::IntoOrAfter => ffi::GTK_TREE_VIEW_DROP_INTO_OR_AFTER,
13036 Self::__Unknown(value) => value,
13037 }
13038 }
13039}
13040
13041#[allow(deprecated)]
13042#[doc(hidden)]
13043impl FromGlib<ffi::GtkTreeViewDropPosition> for TreeViewDropPosition {
13044 #[inline]
13045 unsafe fn from_glib(value: ffi::GtkTreeViewDropPosition) -> Self {
13046 skip_assert_initialized!();
13047
13048 match value {
13049 ffi::GTK_TREE_VIEW_DROP_BEFORE => Self::Before,
13050 ffi::GTK_TREE_VIEW_DROP_AFTER => Self::After,
13051 ffi::GTK_TREE_VIEW_DROP_INTO_OR_BEFORE => Self::IntoOrBefore,
13052 ffi::GTK_TREE_VIEW_DROP_INTO_OR_AFTER => Self::IntoOrAfter,
13053 value => Self::__Unknown(value),
13054 }
13055 }
13056}
13057
13058#[allow(deprecated)]
13059impl StaticType for TreeViewDropPosition {
13060 #[inline]
13061 #[doc(alias = "gtk_tree_view_drop_position_get_type")]
13062 fn static_type() -> glib::Type {
13063 unsafe { from_glib(ffi::gtk_tree_view_drop_position_get_type()) }
13064 }
13065}
13066
13067#[allow(deprecated)]
13068impl glib::HasParamSpec for TreeViewDropPosition {
13069 type ParamSpec = glib::ParamSpecEnum;
13070 type SetValue = Self;
13071 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
13072
13073 fn param_spec_builder() -> Self::BuilderFn {
13074 Self::ParamSpec::builder_with_default
13075 }
13076}
13077
13078#[allow(deprecated)]
13079impl glib::value::ValueType for TreeViewDropPosition {
13080 type Type = Self;
13081}
13082
13083#[allow(deprecated)]
13084unsafe impl<'a> glib::value::FromValue<'a> for TreeViewDropPosition {
13085 type Checker = glib::value::GenericValueTypeChecker<Self>;
13086
13087 #[inline]
13088 unsafe fn from_value(value: &'a glib::Value) -> Self {
13089 skip_assert_initialized!();
13090 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
13091 }
13092}
13093
13094#[allow(deprecated)]
13095impl ToValue for TreeViewDropPosition {
13096 #[inline]
13097 fn to_value(&self) -> glib::Value {
13098 let mut value = glib::Value::for_value_type::<Self>();
13099 unsafe {
13100 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
13101 }
13102 value
13103 }
13104
13105 #[inline]
13106 fn value_type(&self) -> glib::Type {
13107 Self::static_type()
13108 }
13109}
13110
13111#[allow(deprecated)]
13112impl From<TreeViewDropPosition> for glib::Value {
13113 #[inline]
13114 fn from(v: TreeViewDropPosition) -> Self {
13115 skip_assert_initialized!();
13116 ToValue::to_value(&v)
13117 }
13118}
13119
13120#[cfg_attr(feature = "v4_20", deprecated = "Since 4.20")]
13126#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
13127#[non_exhaustive]
13128#[doc(alias = "GtkTreeViewGridLines")]
13129pub enum TreeViewGridLines {
13130 #[doc(alias = "GTK_TREE_VIEW_GRID_LINES_NONE")]
13132 None,
13133 #[doc(alias = "GTK_TREE_VIEW_GRID_LINES_HORIZONTAL")]
13135 Horizontal,
13136 #[doc(alias = "GTK_TREE_VIEW_GRID_LINES_VERTICAL")]
13138 Vertical,
13139 #[doc(alias = "GTK_TREE_VIEW_GRID_LINES_BOTH")]
13141 Both,
13142 #[doc(hidden)]
13143 __Unknown(i32),
13144}
13145
13146#[allow(deprecated)]
13147#[doc(hidden)]
13148impl IntoGlib for TreeViewGridLines {
13149 type GlibType = ffi::GtkTreeViewGridLines;
13150
13151 #[inline]
13152 fn into_glib(self) -> ffi::GtkTreeViewGridLines {
13153 match self {
13154 Self::None => ffi::GTK_TREE_VIEW_GRID_LINES_NONE,
13155 Self::Horizontal => ffi::GTK_TREE_VIEW_GRID_LINES_HORIZONTAL,
13156 Self::Vertical => ffi::GTK_TREE_VIEW_GRID_LINES_VERTICAL,
13157 Self::Both => ffi::GTK_TREE_VIEW_GRID_LINES_BOTH,
13158 Self::__Unknown(value) => value,
13159 }
13160 }
13161}
13162
13163#[allow(deprecated)]
13164#[doc(hidden)]
13165impl FromGlib<ffi::GtkTreeViewGridLines> for TreeViewGridLines {
13166 #[inline]
13167 unsafe fn from_glib(value: ffi::GtkTreeViewGridLines) -> Self {
13168 skip_assert_initialized!();
13169
13170 match value {
13171 ffi::GTK_TREE_VIEW_GRID_LINES_NONE => Self::None,
13172 ffi::GTK_TREE_VIEW_GRID_LINES_HORIZONTAL => Self::Horizontal,
13173 ffi::GTK_TREE_VIEW_GRID_LINES_VERTICAL => Self::Vertical,
13174 ffi::GTK_TREE_VIEW_GRID_LINES_BOTH => Self::Both,
13175 value => Self::__Unknown(value),
13176 }
13177 }
13178}
13179
13180#[allow(deprecated)]
13181impl StaticType for TreeViewGridLines {
13182 #[inline]
13183 #[doc(alias = "gtk_tree_view_grid_lines_get_type")]
13184 fn static_type() -> glib::Type {
13185 unsafe { from_glib(ffi::gtk_tree_view_grid_lines_get_type()) }
13186 }
13187}
13188
13189#[allow(deprecated)]
13190impl glib::HasParamSpec for TreeViewGridLines {
13191 type ParamSpec = glib::ParamSpecEnum;
13192 type SetValue = Self;
13193 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
13194
13195 fn param_spec_builder() -> Self::BuilderFn {
13196 Self::ParamSpec::builder_with_default
13197 }
13198}
13199
13200#[allow(deprecated)]
13201impl glib::value::ValueType for TreeViewGridLines {
13202 type Type = Self;
13203}
13204
13205#[allow(deprecated)]
13206unsafe impl<'a> glib::value::FromValue<'a> for TreeViewGridLines {
13207 type Checker = glib::value::GenericValueTypeChecker<Self>;
13208
13209 #[inline]
13210 unsafe fn from_value(value: &'a glib::Value) -> Self {
13211 skip_assert_initialized!();
13212 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
13213 }
13214}
13215
13216#[allow(deprecated)]
13217impl ToValue for TreeViewGridLines {
13218 #[inline]
13219 fn to_value(&self) -> glib::Value {
13220 let mut value = glib::Value::for_value_type::<Self>();
13221 unsafe {
13222 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
13223 }
13224 value
13225 }
13226
13227 #[inline]
13228 fn value_type(&self) -> glib::Type {
13229 Self::static_type()
13230 }
13231}
13232
13233#[allow(deprecated)]
13234impl From<TreeViewGridLines> for glib::Value {
13235 #[inline]
13236 fn from(v: TreeViewGridLines) -> Self {
13237 skip_assert_initialized!();
13238 ToValue::to_value(&v)
13239 }
13240}
13241
13242#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
13244#[non_exhaustive]
13245#[doc(alias = "GtkUnit")]
13246pub enum Unit {
13247 #[doc(alias = "GTK_UNIT_NONE")]
13249 None,
13250 #[doc(alias = "GTK_UNIT_POINTS")]
13252 Points,
13253 #[doc(alias = "GTK_UNIT_INCH")]
13255 Inch,
13256 #[doc(alias = "GTK_UNIT_MM")]
13258 Mm,
13259 #[doc(hidden)]
13260 __Unknown(i32),
13261}
13262
13263#[doc(hidden)]
13264impl IntoGlib for Unit {
13265 type GlibType = ffi::GtkUnit;
13266
13267 #[inline]
13268 fn into_glib(self) -> ffi::GtkUnit {
13269 match self {
13270 Self::None => ffi::GTK_UNIT_NONE,
13271 Self::Points => ffi::GTK_UNIT_POINTS,
13272 Self::Inch => ffi::GTK_UNIT_INCH,
13273 Self::Mm => ffi::GTK_UNIT_MM,
13274 Self::__Unknown(value) => value,
13275 }
13276 }
13277}
13278
13279#[doc(hidden)]
13280impl FromGlib<ffi::GtkUnit> for Unit {
13281 #[inline]
13282 unsafe fn from_glib(value: ffi::GtkUnit) -> Self {
13283 skip_assert_initialized!();
13284
13285 match value {
13286 ffi::GTK_UNIT_NONE => Self::None,
13287 ffi::GTK_UNIT_POINTS => Self::Points,
13288 ffi::GTK_UNIT_INCH => Self::Inch,
13289 ffi::GTK_UNIT_MM => Self::Mm,
13290 value => Self::__Unknown(value),
13291 }
13292 }
13293}
13294
13295impl StaticType for Unit {
13296 #[inline]
13297 #[doc(alias = "gtk_unit_get_type")]
13298 fn static_type() -> glib::Type {
13299 unsafe { from_glib(ffi::gtk_unit_get_type()) }
13300 }
13301}
13302
13303impl glib::HasParamSpec for Unit {
13304 type ParamSpec = glib::ParamSpecEnum;
13305 type SetValue = Self;
13306 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
13307
13308 fn param_spec_builder() -> Self::BuilderFn {
13309 Self::ParamSpec::builder_with_default
13310 }
13311}
13312
13313impl glib::value::ValueType for Unit {
13314 type Type = Self;
13315}
13316
13317unsafe impl<'a> glib::value::FromValue<'a> for Unit {
13318 type Checker = glib::value::GenericValueTypeChecker<Self>;
13319
13320 #[inline]
13321 unsafe fn from_value(value: &'a glib::Value) -> Self {
13322 skip_assert_initialized!();
13323 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
13324 }
13325}
13326
13327impl ToValue for Unit {
13328 #[inline]
13329 fn to_value(&self) -> glib::Value {
13330 let mut value = glib::Value::for_value_type::<Self>();
13331 unsafe {
13332 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
13333 }
13334 value
13335 }
13336
13337 #[inline]
13338 fn value_type(&self) -> glib::Type {
13339 Self::static_type()
13340 }
13341}
13342
13343impl From<Unit> for glib::Value {
13344 #[inline]
13345 fn from(v: Unit) -> Self {
13346 skip_assert_initialized!();
13347 ToValue::to_value(&v)
13348 }
13349}
13350
13351#[cfg(feature = "v4_20")]
13354#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
13355#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
13356#[non_exhaustive]
13357#[doc(alias = "GtkWindowGravity")]
13358pub enum WindowGravity {
13359 #[doc(alias = "GTK_WINDOW_GRAVITY_TOP_LEFT")]
13361 TopLeft,
13362 #[doc(alias = "GTK_WINDOW_GRAVITY_TOP")]
13364 Top,
13365 #[doc(alias = "GTK_WINDOW_GRAVITY_TOP_RIGHT")]
13367 TopRight,
13368 #[doc(alias = "GTK_WINDOW_GRAVITY_LEFT")]
13370 Left,
13371 #[doc(alias = "GTK_WINDOW_GRAVITY_CENTER")]
13373 Center,
13374 #[doc(alias = "GTK_WINDOW_GRAVITY_RIGHT")]
13376 Right,
13377 #[doc(alias = "GTK_WINDOW_GRAVITY_BOTTOM_LEFT")]
13379 BottomLeft,
13380 #[doc(alias = "GTK_WINDOW_GRAVITY_BOTTOM")]
13382 Bottom,
13383 #[doc(alias = "GTK_WINDOW_GRAVITY_BOTTOM_RIGHT")]
13385 BottomRight,
13386 #[doc(alias = "GTK_WINDOW_GRAVITY_TOP_START")]
13389 TopStart,
13390 #[doc(alias = "GTK_WINDOW_GRAVITY_TOP_END")]
13393 TopEnd,
13394 #[doc(alias = "GTK_WINDOW_GRAVITY_START")]
13397 Start,
13398 #[doc(alias = "GTK_WINDOW_GRAVITY_END")]
13401 End,
13402 #[doc(alias = "GTK_WINDOW_GRAVITY_BOTTOM_START")]
13405 BottomStart,
13406 #[doc(alias = "GTK_WINDOW_GRAVITY_BOTTOM_END")]
13409 BottomEnd,
13410 #[doc(hidden)]
13411 __Unknown(i32),
13412}
13413
13414#[cfg(feature = "v4_20")]
13415#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
13416#[doc(hidden)]
13417impl IntoGlib for WindowGravity {
13418 type GlibType = ffi::GtkWindowGravity;
13419
13420 fn into_glib(self) -> ffi::GtkWindowGravity {
13421 match self {
13422 Self::TopLeft => ffi::GTK_WINDOW_GRAVITY_TOP_LEFT,
13423 Self::Top => ffi::GTK_WINDOW_GRAVITY_TOP,
13424 Self::TopRight => ffi::GTK_WINDOW_GRAVITY_TOP_RIGHT,
13425 Self::Left => ffi::GTK_WINDOW_GRAVITY_LEFT,
13426 Self::Center => ffi::GTK_WINDOW_GRAVITY_CENTER,
13427 Self::Right => ffi::GTK_WINDOW_GRAVITY_RIGHT,
13428 Self::BottomLeft => ffi::GTK_WINDOW_GRAVITY_BOTTOM_LEFT,
13429 Self::Bottom => ffi::GTK_WINDOW_GRAVITY_BOTTOM,
13430 Self::BottomRight => ffi::GTK_WINDOW_GRAVITY_BOTTOM_RIGHT,
13431 Self::TopStart => ffi::GTK_WINDOW_GRAVITY_TOP_START,
13432 Self::TopEnd => ffi::GTK_WINDOW_GRAVITY_TOP_END,
13433 Self::Start => ffi::GTK_WINDOW_GRAVITY_START,
13434 Self::End => ffi::GTK_WINDOW_GRAVITY_END,
13435 Self::BottomStart => ffi::GTK_WINDOW_GRAVITY_BOTTOM_START,
13436 Self::BottomEnd => ffi::GTK_WINDOW_GRAVITY_BOTTOM_END,
13437 Self::__Unknown(value) => value,
13438 }
13439 }
13440}
13441
13442#[cfg(feature = "v4_20")]
13443#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
13444#[doc(hidden)]
13445impl FromGlib<ffi::GtkWindowGravity> for WindowGravity {
13446 unsafe fn from_glib(value: ffi::GtkWindowGravity) -> Self {
13447 skip_assert_initialized!();
13448
13449 match value {
13450 ffi::GTK_WINDOW_GRAVITY_TOP_LEFT => Self::TopLeft,
13451 ffi::GTK_WINDOW_GRAVITY_TOP => Self::Top,
13452 ffi::GTK_WINDOW_GRAVITY_TOP_RIGHT => Self::TopRight,
13453 ffi::GTK_WINDOW_GRAVITY_LEFT => Self::Left,
13454 ffi::GTK_WINDOW_GRAVITY_CENTER => Self::Center,
13455 ffi::GTK_WINDOW_GRAVITY_RIGHT => Self::Right,
13456 ffi::GTK_WINDOW_GRAVITY_BOTTOM_LEFT => Self::BottomLeft,
13457 ffi::GTK_WINDOW_GRAVITY_BOTTOM => Self::Bottom,
13458 ffi::GTK_WINDOW_GRAVITY_BOTTOM_RIGHT => Self::BottomRight,
13459 ffi::GTK_WINDOW_GRAVITY_TOP_START => Self::TopStart,
13460 ffi::GTK_WINDOW_GRAVITY_TOP_END => Self::TopEnd,
13461 ffi::GTK_WINDOW_GRAVITY_START => Self::Start,
13462 ffi::GTK_WINDOW_GRAVITY_END => Self::End,
13463 ffi::GTK_WINDOW_GRAVITY_BOTTOM_START => Self::BottomStart,
13464 ffi::GTK_WINDOW_GRAVITY_BOTTOM_END => Self::BottomEnd,
13465 value => Self::__Unknown(value),
13466 }
13467 }
13468}
13469
13470#[cfg(feature = "v4_20")]
13471#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
13472impl StaticType for WindowGravity {
13473 #[inline]
13474 #[doc(alias = "gtk_window_gravity_get_type")]
13475 fn static_type() -> glib::Type {
13476 unsafe { from_glib(ffi::gtk_window_gravity_get_type()) }
13477 }
13478}
13479
13480#[cfg(feature = "v4_20")]
13481#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
13482impl glib::HasParamSpec for WindowGravity {
13483 type ParamSpec = glib::ParamSpecEnum;
13484 type SetValue = Self;
13485 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
13486
13487 fn param_spec_builder() -> Self::BuilderFn {
13488 Self::ParamSpec::builder_with_default
13489 }
13490}
13491
13492#[cfg(feature = "v4_20")]
13493#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
13494impl glib::value::ValueType for WindowGravity {
13495 type Type = Self;
13496}
13497
13498#[cfg(feature = "v4_20")]
13499#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
13500unsafe impl<'a> glib::value::FromValue<'a> for WindowGravity {
13501 type Checker = glib::value::GenericValueTypeChecker<Self>;
13502
13503 #[inline]
13504 unsafe fn from_value(value: &'a glib::Value) -> Self {
13505 skip_assert_initialized!();
13506 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
13507 }
13508}
13509
13510#[cfg(feature = "v4_20")]
13511#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
13512impl ToValue for WindowGravity {
13513 #[inline]
13514 fn to_value(&self) -> glib::Value {
13515 let mut value = glib::Value::for_value_type::<Self>();
13516 unsafe {
13517 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
13518 }
13519 value
13520 }
13521
13522 #[inline]
13523 fn value_type(&self) -> glib::Type {
13524 Self::static_type()
13525 }
13526}
13527
13528#[cfg(feature = "v4_20")]
13529#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
13530impl From<WindowGravity> for glib::Value {
13531 #[inline]
13532 fn from(v: WindowGravity) -> Self {
13533 skip_assert_initialized!();
13534 ToValue::to_value(&v)
13535 }
13536}
13537
13538#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
13540#[non_exhaustive]
13541#[doc(alias = "GtkWrapMode")]
13542pub enum WrapMode {
13543 #[doc(alias = "GTK_WRAP_NONE")]
13545 None,
13546 #[doc(alias = "GTK_WRAP_CHAR")]
13550 Char,
13551 #[doc(alias = "GTK_WRAP_WORD")]
13553 Word,
13554 #[doc(alias = "GTK_WRAP_WORD_CHAR")]
13557 WordChar,
13558 #[doc(hidden)]
13559 __Unknown(i32),
13560}
13561
13562#[doc(hidden)]
13563impl IntoGlib for WrapMode {
13564 type GlibType = ffi::GtkWrapMode;
13565
13566 #[inline]
13567 fn into_glib(self) -> ffi::GtkWrapMode {
13568 match self {
13569 Self::None => ffi::GTK_WRAP_NONE,
13570 Self::Char => ffi::GTK_WRAP_CHAR,
13571 Self::Word => ffi::GTK_WRAP_WORD,
13572 Self::WordChar => ffi::GTK_WRAP_WORD_CHAR,
13573 Self::__Unknown(value) => value,
13574 }
13575 }
13576}
13577
13578#[doc(hidden)]
13579impl FromGlib<ffi::GtkWrapMode> for WrapMode {
13580 #[inline]
13581 unsafe fn from_glib(value: ffi::GtkWrapMode) -> Self {
13582 skip_assert_initialized!();
13583
13584 match value {
13585 ffi::GTK_WRAP_NONE => Self::None,
13586 ffi::GTK_WRAP_CHAR => Self::Char,
13587 ffi::GTK_WRAP_WORD => Self::Word,
13588 ffi::GTK_WRAP_WORD_CHAR => Self::WordChar,
13589 value => Self::__Unknown(value),
13590 }
13591 }
13592}
13593
13594impl StaticType for WrapMode {
13595 #[inline]
13596 #[doc(alias = "gtk_wrap_mode_get_type")]
13597 fn static_type() -> glib::Type {
13598 unsafe { from_glib(ffi::gtk_wrap_mode_get_type()) }
13599 }
13600}
13601
13602impl glib::HasParamSpec for WrapMode {
13603 type ParamSpec = glib::ParamSpecEnum;
13604 type SetValue = Self;
13605 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
13606
13607 fn param_spec_builder() -> Self::BuilderFn {
13608 Self::ParamSpec::builder_with_default
13609 }
13610}
13611
13612impl glib::value::ValueType for WrapMode {
13613 type Type = Self;
13614}
13615
13616unsafe impl<'a> glib::value::FromValue<'a> for WrapMode {
13617 type Checker = glib::value::GenericValueTypeChecker<Self>;
13618
13619 #[inline]
13620 unsafe fn from_value(value: &'a glib::Value) -> Self {
13621 skip_assert_initialized!();
13622 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
13623 }
13624}
13625
13626impl ToValue for WrapMode {
13627 #[inline]
13628 fn to_value(&self) -> glib::Value {
13629 let mut value = glib::Value::for_value_type::<Self>();
13630 unsafe {
13631 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
13632 }
13633 value
13634 }
13635
13636 #[inline]
13637 fn value_type(&self) -> glib::Type {
13638 Self::static_type()
13639 }
13640}
13641
13642impl From<WrapMode> for glib::Value {
13643 #[inline]
13644 fn from(v: WrapMode) -> Self {
13645 skip_assert_initialized!();
13646 ToValue::to_value(&v)
13647 }
13648}