gtk4/auto/
enums.rs

Help
1// This file was generated by gir (https://github.com/gtk-rs/gir)
2// from gir-files (https://github.com/gtk-rs/gir-files)
3// DO NOT EDIT
4
5use crate::ffi;
6use glib::{prelude::*, translate::*};
7
8/// The priority of an accessibility announcement.
9#[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    /// The announcement is low priority,
16    ///   and might be read only on the user's request.
17    #[doc(alias = "GTK_ACCESSIBLE_ANNOUNCEMENT_PRIORITY_LOW")]
18    Low,
19    /// The announcement is of medium
20    ///   priority, and is usually spoken at the next opportunity, such as at the
21    ///   end of speaking the current sentence or when the user pauses typing.
22    #[doc(alias = "GTK_ACCESSIBLE_ANNOUNCEMENT_PRIORITY_MEDIUM")]
23    Medium,
24    /// The announcement is of high
25    ///   priority, and is usually spoken immediately. Because an interruption
26    ///   might disorient users or cause them to not complete their current task,
27    ///   authors SHOULD NOT use high priority announcements unless the
28    ///   interruption is imperative. An example would be a notification about a
29    ///   critical battery power level.
30    #[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/// The possible values for the [`AccessibleProperty::Autocomplete`][crate::AccessibleProperty::Autocomplete]
139/// accessible property.
140#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
141#[non_exhaustive]
142#[doc(alias = "GtkAccessibleAutocomplete")]
143pub enum AccessibleAutocomplete {
144    /// Automatic suggestions are not displayed.
145    #[doc(alias = "GTK_ACCESSIBLE_AUTOCOMPLETE_NONE")]
146    None,
147    /// When a user is providing input, text
148    ///    suggesting one way to complete the provided input may be dynamically
149    ///    inserted after the caret.
150    #[doc(alias = "GTK_ACCESSIBLE_AUTOCOMPLETE_INLINE")]
151    Inline,
152    /// When a user is providing input, an element
153    ///    containing a collection of values that could complete the provided input
154    ///    may be displayed.
155    #[doc(alias = "GTK_ACCESSIBLE_AUTOCOMPLETE_LIST")]
156    List,
157    /// When a user is providing input, an element
158    ///    containing a collection of values that could complete the provided input
159    ///    may be displayed. If displayed, one value in the collection is automatically
160    ///    selected, and the text needed to complete the automatically selected value
161    ///    appears after the caret in the input.
162    #[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/// The possible values for the [`AccessibleState::Invalid`][crate::AccessibleState::Invalid]
257/// accessible state.
258///
259/// Note that the [`False`][Self::False] and
260/// [`True`][Self::True] have the same values
261/// as [`false`] and [`true`].
262#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
263#[non_exhaustive]
264#[doc(alias = "GtkAccessibleInvalidState")]
265pub enum AccessibleInvalidState {
266    /// There are no detected errors in the value
267    #[doc(alias = "GTK_ACCESSIBLE_INVALID_FALSE")]
268    False,
269    /// The value entered by the user has failed validation
270    #[doc(alias = "GTK_ACCESSIBLE_INVALID_TRUE")]
271    True,
272    /// A grammatical error was detected
273    #[doc(alias = "GTK_ACCESSIBLE_INVALID_GRAMMAR")]
274    Grammar,
275    /// A spelling error was detected
276    #[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/// The various platform states which can be queried
371/// using [`AccessibleExt::platform_state()`][crate::prelude::AccessibleExt::platform_state()].
372#[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    /// whether the accessible can be focused
379    #[doc(alias = "GTK_ACCESSIBLE_PLATFORM_STATE_FOCUSABLE")]
380    Focusable,
381    /// whether the accessible has focus
382    #[doc(alias = "GTK_ACCESSIBLE_PLATFORM_STATE_FOCUSED")]
383    Focused,
384    /// whether the accessible is active
385    #[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/// The possible accessible properties of a [`Accessible`][crate::Accessible].
494#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
495#[non_exhaustive]
496#[doc(alias = "GtkAccessibleProperty")]
497pub enum AccessibleProperty {
498    /// Indicates whether inputting text
499    ///    could trigger display of one or more predictions of the user's intended
500    ///    value for a combobox, searchbox, or textbox and specifies how predictions
501    ///    would be presented if they were made. Value type: [`AccessibleAutocomplete`][crate::AccessibleAutocomplete]
502    #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_AUTOCOMPLETE")]
503    Autocomplete,
504    /// Defines a string value that describes
505    ///    or annotates the current element. Value type: string
506    #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_DESCRIPTION")]
507    Description,
508    /// Indicates the availability and type of
509    ///    interactive popup element, such as menu or dialog, that can be triggered
510    ///    by an element.
511    #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_HAS_POPUP")]
512    HasPopup,
513    /// Indicates keyboard shortcuts that an
514    ///    author has implemented to activate or give focus to an element. Value type:
515    ///    string. The format of the value is a space-separated list of shortcuts, with
516    ///    each shortcut consisting of one or more modifiers (`Control`, `Alt` or `Shift`),
517    ///    followed by a non-modifier key, all separated by `+`.
518    ///    Examples: `F2`, `Alt-F`, `Control+Shift+N`
519    #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_KEY_SHORTCUTS")]
520    KeyShortcuts,
521    /// Defines a string value that labels the current
522    ///    element. Value type: string
523    #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_LABEL")]
524    Label,
525    /// Defines the hierarchical level of an element
526    ///    within a structure. Value type: integer
527    #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_LEVEL")]
528    Level,
529    /// Indicates whether an element is modal when
530    ///    displayed. Value type: boolean
531    #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_MODAL")]
532    Modal,
533    /// Indicates whether a text box accepts
534    ///    multiple lines of input or only a single line. Value type: boolean
535    #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_MULTI_LINE")]
536    MultiLine,
537    /// Indicates that the user may select
538    ///    more than one item from the current selectable descendants. Value type:
539    ///    boolean
540    #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_MULTI_SELECTABLE")]
541    MultiSelectable,
542    /// Indicates whether the element's
543    ///    orientation is horizontal, vertical, or unknown/ambiguous. Value type:
544    ///    [`Orientation`][crate::Orientation]
545    #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_ORIENTATION")]
546    Orientation,
547    /// Defines a short hint (a word or short
548    ///    phrase) intended to aid the user with data entry when the control has no
549    ///    value. A hint could be a sample value or a brief description of the expected
550    ///    format. Value type: string
551    #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_PLACEHOLDER")]
552    Placeholder,
553    /// Indicates that the element is not editable,
554    ///    but is otherwise operable. Value type: boolean
555    #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_READ_ONLY")]
556    ReadOnly,
557    /// Indicates that user input is required on
558    ///    the element before a form may be submitted. Value type: boolean
559    #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_REQUIRED")]
560    Required,
561    /// Defines a human-readable,
562    ///    author-localized description for the role of an element. Value type: string
563    #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_ROLE_DESCRIPTION")]
564    RoleDescription,
565    /// Indicates if items in a table or grid are
566    ///    sorted in ascending or descending order. Value type: [`AccessibleSort`][crate::AccessibleSort]
567    #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_SORT")]
568    Sort,
569    /// Defines the maximum allowed value for a
570    ///    range widget. Value type: double
571    #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_VALUE_MAX")]
572    ValueMax,
573    /// Defines the minimum allowed value for a
574    ///    range widget. Value type: double
575    #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_VALUE_MIN")]
576    ValueMin,
577    /// Defines the current value for a range widget.
578    ///    Value type: double
579    #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_VALUE_NOW")]
580    ValueNow,
581    /// Defines the human readable text alternative
582    ///    of aria-valuenow for a range widget. Value type: string
583    #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_VALUE_TEXT")]
584    ValueText,
585    /// Defines a string value that provides a description of non-standard keyboard
586    /// interactions of the current element. Value type: string
587    #[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/// The possible accessible relations of a [`Accessible`][crate::Accessible].
726///
727/// Accessible relations can be references to other widgets,
728/// integers or strings.
729#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
730#[non_exhaustive]
731#[doc(alias = "GtkAccessibleRelation")]
732pub enum AccessibleRelation {
733    /// Identifies the currently active
734    ///    element when focus is on a composite widget, combobox, textbox, group,
735    ///    or application. Value type: reference
736    #[doc(alias = "GTK_ACCESSIBLE_RELATION_ACTIVE_DESCENDANT")]
737    ActiveDescendant,
738    /// Defines the total number of columns
739    ///    in a table, grid, or treegrid. Value type: integer
740    #[doc(alias = "GTK_ACCESSIBLE_RELATION_COL_COUNT")]
741    ColCount,
742    /// Defines an element's column index or
743    ///    position with respect to the total number of columns within a table,
744    ///    grid, or treegrid. Value type: integer
745    #[doc(alias = "GTK_ACCESSIBLE_RELATION_COL_INDEX")]
746    ColIndex,
747    /// Defines a human readable text
748    ///   alternative of [`ColIndex`][Self::ColIndex]. Value type: string
749    #[doc(alias = "GTK_ACCESSIBLE_RELATION_COL_INDEX_TEXT")]
750    ColIndexText,
751    /// Defines the number of columns spanned
752    ///   by a cell or gridcell within a table, grid, or treegrid. Value type: integer
753    #[doc(alias = "GTK_ACCESSIBLE_RELATION_COL_SPAN")]
754    ColSpan,
755    /// Identifies the element (or elements) whose
756    ///    contents or presence are controlled by the current element. Value type: reference
757    #[doc(alias = "GTK_ACCESSIBLE_RELATION_CONTROLS")]
758    Controls,
759    /// Identifies the element (or elements)
760    ///    that describes the object. Value type: reference
761    #[doc(alias = "GTK_ACCESSIBLE_RELATION_DESCRIBED_BY")]
762    DescribedBy,
763    /// Identifies the element (or elements) that
764    ///    provide additional information related to the object. Value type: reference
765    #[doc(alias = "GTK_ACCESSIBLE_RELATION_DETAILS")]
766    Details,
767    /// Identifies the element (or elements) that
768    ///    provide an error message for an object. Value type: reference
769    #[doc(alias = "GTK_ACCESSIBLE_RELATION_ERROR_MESSAGE")]
770    ErrorMessage,
771    /// Identifies the next element (or elements)
772    ///    in an alternate reading order of content which, at the user's discretion,
773    ///    allows assistive technology to override the general default of reading in
774    ///    document source order. Value type: reference
775    #[doc(alias = "GTK_ACCESSIBLE_RELATION_FLOW_TO")]
776    FlowTo,
777    /// Identifies the element (or elements)
778    ///    that labels the current element. Value type: reference
779    #[doc(alias = "GTK_ACCESSIBLE_RELATION_LABELLED_BY")]
780    LabelledBy,
781    /// Identifies an element (or elements) in order
782    ///    to define a visual, functional, or contextual parent/child relationship
783    ///    between elements where the widget hierarchy cannot be used to represent
784    ///    the relationship. Value type: reference
785    #[doc(alias = "GTK_ACCESSIBLE_RELATION_OWNS")]
786    Owns,
787    /// Defines an element's number or position
788    ///    in the current set of listitems or treeitems. Value type: integer
789    #[doc(alias = "GTK_ACCESSIBLE_RELATION_POS_IN_SET")]
790    PosInSet,
791    /// Defines the total number of rows in a table,
792    ///    grid, or treegrid. Value type: integer
793    #[doc(alias = "GTK_ACCESSIBLE_RELATION_ROW_COUNT")]
794    RowCount,
795    /// Defines an element's row index or position
796    ///    with respect to the total number of rows within a table, grid, or treegrid.
797    ///    Value type: integer
798    #[doc(alias = "GTK_ACCESSIBLE_RELATION_ROW_INDEX")]
799    RowIndex,
800    /// Defines a human readable text
801    ///    alternative of aria-rowindex. Value type: string
802    #[doc(alias = "GTK_ACCESSIBLE_RELATION_ROW_INDEX_TEXT")]
803    RowIndexText,
804    /// Defines the number of rows spanned by a
805    ///    cell or gridcell within a table, grid, or treegrid. Value type: integer
806    #[doc(alias = "GTK_ACCESSIBLE_RELATION_ROW_SPAN")]
807    RowSpan,
808    /// Defines the number of items in the current
809    ///    set of listitems or treeitems. Value type: integer
810    #[doc(alias = "GTK_ACCESSIBLE_RELATION_SET_SIZE")]
811    SetSize,
812    /// Identifies the element (or elements) that are labeled by the
813    /// current element. Value type: reference
814    ///
815    /// This relation is managed by GTK and should not be set from application code.
816    #[cfg(feature = "v4_18")]
817    #[cfg_attr(docsrs, doc(cfg(feature = "v4_18")))]
818    #[doc(alias = "GTK_ACCESSIBLE_RELATION_LABEL_FOR")]
819    LabelFor,
820    /// Identifies the element (or elements) that are described by
821    /// the current element. Value type: reference
822    ///
823    /// This relation is managed by GTK and should not be set from application code.
824    #[cfg(feature = "v4_18")]
825    #[cfg_attr(docsrs, doc(cfg(feature = "v4_18")))]
826    #[doc(alias = "GTK_ACCESSIBLE_RELATION_DESCRIPTION_FOR")]
827    DescriptionFor,
828    /// Identifies the element (or elements) that the current
829    /// element is controlled by. Value type: reference
830    ///
831    /// This relation is managed by GTK and should not be set from application code.
832    #[cfg(feature = "v4_18")]
833    #[cfg_attr(docsrs, doc(cfg(feature = "v4_18")))]
834    #[doc(alias = "GTK_ACCESSIBLE_RELATION_CONTROLLED_BY")]
835    ControlledBy,
836    /// Identifies the element (or elements) for which the current
837    /// element provides additional information. Value type: reference
838    ///
839    /// This relation is managed by GTK and should not be set from application code.
840    #[cfg(feature = "v4_18")]
841    #[cfg_attr(docsrs, doc(cfg(feature = "v4_18")))]
842    #[doc(alias = "GTK_ACCESSIBLE_RELATION_DETAILS_FOR")]
843    DetailsFor,
844    /// Identifies the element (or elements) for which the current
845    /// element provides an error message. Value type: reference
846    ///
847    /// This relation is managed by GTK and should not be set from application code.
848    #[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    /// Identifies the previous element (or elements) in an alternate
853    /// reading order of content which, at the user's discretion, allows
854    /// assistive technology to override the general default of reading in
855    /// document source order. Value type: reference
856    ///
857    /// This relation is managed by GTK and should not be set from application code.
858    #[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/// The accessible role for a [`Accessible`][crate::Accessible] implementation.
1015///
1016/// Abstract roles are only used as part of the ontology; application
1017/// developers must not use abstract roles in their code.
1018#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1019#[non_exhaustive]
1020#[doc(alias = "GtkAccessibleRole")]
1021pub enum AccessibleRole {
1022    /// An element with important, and usually
1023    ///   time-sensitive, information
1024    #[doc(alias = "GTK_ACCESSIBLE_ROLE_ALERT")]
1025    Alert,
1026    /// A type of dialog that contains an
1027    ///   alert message
1028    #[doc(alias = "GTK_ACCESSIBLE_ROLE_ALERT_DIALOG")]
1029    AlertDialog,
1030    /// Unused
1031    #[doc(alias = "GTK_ACCESSIBLE_ROLE_BANNER")]
1032    Banner,
1033    /// An input element that allows for
1034    ///   user-triggered actions when clicked or pressed
1035    #[doc(alias = "GTK_ACCESSIBLE_ROLE_BUTTON")]
1036    Button,
1037    /// Unused
1038    #[doc(alias = "GTK_ACCESSIBLE_ROLE_CAPTION")]
1039    Caption,
1040    /// Unused
1041    #[doc(alias = "GTK_ACCESSIBLE_ROLE_CELL")]
1042    Cell,
1043    /// A checkable input element that has
1044    ///   three possible values: `true`, `false`, or `mixed`
1045    #[doc(alias = "GTK_ACCESSIBLE_ROLE_CHECKBOX")]
1046    Checkbox,
1047    /// A header in a columned list.
1048    #[doc(alias = "GTK_ACCESSIBLE_ROLE_COLUMN_HEADER")]
1049    ColumnHeader,
1050    /// An input that controls another element,
1051    ///   such as a list or a grid, that can dynamically pop up to help the user
1052    ///   set the value of the input
1053    #[doc(alias = "GTK_ACCESSIBLE_ROLE_COMBO_BOX")]
1054    ComboBox,
1055    /// Abstract role.
1056    #[doc(alias = "GTK_ACCESSIBLE_ROLE_COMMAND")]
1057    Command,
1058    /// Abstract role.
1059    #[doc(alias = "GTK_ACCESSIBLE_ROLE_COMPOSITE")]
1060    Composite,
1061    /// A dialog is a window that is designed to interrupt
1062    ///   the current processing of an application in order to prompt the user to enter
1063    ///   information or require a response.
1064    #[doc(alias = "GTK_ACCESSIBLE_ROLE_DIALOG")]
1065    Dialog,
1066    /// Content that assistive technology users may want to
1067    ///   browse in a reading mode.
1068    #[doc(alias = "GTK_ACCESSIBLE_ROLE_DOCUMENT")]
1069    Document,
1070    /// Unused
1071    #[doc(alias = "GTK_ACCESSIBLE_ROLE_FEED")]
1072    Feed,
1073    /// Unused
1074    #[doc(alias = "GTK_ACCESSIBLE_ROLE_FORM")]
1075    Form,
1076    /// A nameless container that has no semantic meaning
1077    ///   of its own. This is the role that GTK uses by default for widgets.
1078    #[doc(alias = "GTK_ACCESSIBLE_ROLE_GENERIC")]
1079    Generic,
1080    /// A grid of items.
1081    #[doc(alias = "GTK_ACCESSIBLE_ROLE_GRID")]
1082    Grid,
1083    /// An item in a grid or tree grid.
1084    #[doc(alias = "GTK_ACCESSIBLE_ROLE_GRID_CELL")]
1085    GridCell,
1086    /// An element that groups multiple related widgets. GTK uses
1087    ///   this role for various containers, like [`HeaderBar`][crate::HeaderBar] or [`Notebook`][crate::Notebook].
1088    #[doc(alias = "GTK_ACCESSIBLE_ROLE_GROUP")]
1089    Group,
1090    /// Unused
1091    #[doc(alias = "GTK_ACCESSIBLE_ROLE_HEADING")]
1092    Heading,
1093    /// An image.
1094    #[doc(alias = "GTK_ACCESSIBLE_ROLE_IMG")]
1095    Img,
1096    /// Abstract role.
1097    #[doc(alias = "GTK_ACCESSIBLE_ROLE_INPUT")]
1098    Input,
1099    /// A visible name or caption for a user interface component.
1100    #[doc(alias = "GTK_ACCESSIBLE_ROLE_LABEL")]
1101    Label,
1102    /// Abstract role.
1103    #[doc(alias = "GTK_ACCESSIBLE_ROLE_LANDMARK")]
1104    Landmark,
1105    /// Unused
1106    #[doc(alias = "GTK_ACCESSIBLE_ROLE_LEGEND")]
1107    Legend,
1108    /// A clickable link.
1109    #[doc(alias = "GTK_ACCESSIBLE_ROLE_LINK")]
1110    Link,
1111    /// A list of items.
1112    #[doc(alias = "GTK_ACCESSIBLE_ROLE_LIST")]
1113    List,
1114    /// Unused.
1115    #[doc(alias = "GTK_ACCESSIBLE_ROLE_LIST_BOX")]
1116    ListBox,
1117    /// An item in a list.
1118    #[doc(alias = "GTK_ACCESSIBLE_ROLE_LIST_ITEM")]
1119    ListItem,
1120    /// Unused
1121    #[doc(alias = "GTK_ACCESSIBLE_ROLE_LOG")]
1122    Log,
1123    /// Unused
1124    #[doc(alias = "GTK_ACCESSIBLE_ROLE_MAIN")]
1125    Main,
1126    /// Unused
1127    #[doc(alias = "GTK_ACCESSIBLE_ROLE_MARQUEE")]
1128    Marquee,
1129    /// Unused
1130    #[doc(alias = "GTK_ACCESSIBLE_ROLE_MATH")]
1131    Math,
1132    /// An element that represents a value within a known range.
1133    #[doc(alias = "GTK_ACCESSIBLE_ROLE_METER")]
1134    Meter,
1135    /// A menu.
1136    #[doc(alias = "GTK_ACCESSIBLE_ROLE_MENU")]
1137    Menu,
1138    /// A menubar.
1139    #[doc(alias = "GTK_ACCESSIBLE_ROLE_MENU_BAR")]
1140    MenuBar,
1141    /// An item in a menu.
1142    #[doc(alias = "GTK_ACCESSIBLE_ROLE_MENU_ITEM")]
1143    MenuItem,
1144    /// A check item in a menu.
1145    #[doc(alias = "GTK_ACCESSIBLE_ROLE_MENU_ITEM_CHECKBOX")]
1146    MenuItemCheckbox,
1147    /// A radio item in a menu.
1148    #[doc(alias = "GTK_ACCESSIBLE_ROLE_MENU_ITEM_RADIO")]
1149    MenuItemRadio,
1150    /// Unused
1151    #[doc(alias = "GTK_ACCESSIBLE_ROLE_NAVIGATION")]
1152    Navigation,
1153    /// An element that is not represented to accessibility technologies.
1154    ///   This role is synonymous to @GTK_ACCESSIBLE_ROLE_PRESENTATION.
1155    #[doc(alias = "GTK_ACCESSIBLE_ROLE_NONE")]
1156    None,
1157    /// Unused
1158    #[doc(alias = "GTK_ACCESSIBLE_ROLE_NOTE")]
1159    Note,
1160    /// Unused
1161    #[doc(alias = "GTK_ACCESSIBLE_ROLE_OPTION")]
1162    Option,
1163    /// An element that is not represented to accessibility technologies.
1164    ///   This role is synonymous to @GTK_ACCESSIBLE_ROLE_NONE.
1165    #[doc(alias = "GTK_ACCESSIBLE_ROLE_PRESENTATION")]
1166    Presentation,
1167    /// An element that displays the progress
1168    ///   status for tasks that take a long time.
1169    #[doc(alias = "GTK_ACCESSIBLE_ROLE_PROGRESS_BAR")]
1170    ProgressBar,
1171    /// A checkable input in a group of radio roles,
1172    ///   only one of which can be checked at a time.
1173    #[doc(alias = "GTK_ACCESSIBLE_ROLE_RADIO")]
1174    Radio,
1175    /// Unused
1176    #[doc(alias = "GTK_ACCESSIBLE_ROLE_RADIO_GROUP")]
1177    RadioGroup,
1178    /// Abstract role.
1179    #[doc(alias = "GTK_ACCESSIBLE_ROLE_RANGE")]
1180    Range,
1181    /// Unused
1182    #[doc(alias = "GTK_ACCESSIBLE_ROLE_REGION")]
1183    Region,
1184    /// A row in a columned list.
1185    #[doc(alias = "GTK_ACCESSIBLE_ROLE_ROW")]
1186    Row,
1187    /// Unused
1188    #[doc(alias = "GTK_ACCESSIBLE_ROLE_ROW_GROUP")]
1189    RowGroup,
1190    /// Unused
1191    #[doc(alias = "GTK_ACCESSIBLE_ROLE_ROW_HEADER")]
1192    RowHeader,
1193    /// A graphical object that controls the scrolling
1194    ///   of content within a viewing area, regardless of whether the content is fully
1195    ///   displayed within the viewing area.
1196    #[doc(alias = "GTK_ACCESSIBLE_ROLE_SCROLLBAR")]
1197    Scrollbar,
1198    /// Unused
1199    #[doc(alias = "GTK_ACCESSIBLE_ROLE_SEARCH")]
1200    Search,
1201    /// A type of textbox intended for specifying
1202    ///   search criteria.
1203    #[doc(alias = "GTK_ACCESSIBLE_ROLE_SEARCH_BOX")]
1204    SearchBox,
1205    /// Abstract role.
1206    #[doc(alias = "GTK_ACCESSIBLE_ROLE_SECTION")]
1207    Section,
1208    /// Abstract role.
1209    #[doc(alias = "GTK_ACCESSIBLE_ROLE_SECTION_HEAD")]
1210    SectionHead,
1211    /// Abstract role.
1212    #[doc(alias = "GTK_ACCESSIBLE_ROLE_SELECT")]
1213    Select,
1214    /// A divider that separates and distinguishes
1215    ///   sections of content or groups of menuitems.
1216    #[doc(alias = "GTK_ACCESSIBLE_ROLE_SEPARATOR")]
1217    Separator,
1218    /// A user input where the user selects a value
1219    ///   from within a given range.
1220    #[doc(alias = "GTK_ACCESSIBLE_ROLE_SLIDER")]
1221    Slider,
1222    /// A form of range that expects the user to
1223    ///   select from among discrete choices.
1224    #[doc(alias = "GTK_ACCESSIBLE_ROLE_SPIN_BUTTON")]
1225    SpinButton,
1226    /// Unused
1227    #[doc(alias = "GTK_ACCESSIBLE_ROLE_STATUS")]
1228    Status,
1229    /// Abstract role.
1230    #[doc(alias = "GTK_ACCESSIBLE_ROLE_STRUCTURE")]
1231    Structure,
1232    /// A type of checkbox that represents on/off values,
1233    ///   as opposed to checked/unchecked values.
1234    #[doc(alias = "GTK_ACCESSIBLE_ROLE_SWITCH")]
1235    Switch,
1236    /// An item in a list of tab used for switching pages.
1237    #[doc(alias = "GTK_ACCESSIBLE_ROLE_TAB")]
1238    Tab,
1239    /// Unused
1240    #[doc(alias = "GTK_ACCESSIBLE_ROLE_TABLE")]
1241    Table,
1242    /// A list of tabs for switching pages.
1243    #[doc(alias = "GTK_ACCESSIBLE_ROLE_TAB_LIST")]
1244    TabList,
1245    /// A page in a notebook or stack.
1246    #[doc(alias = "GTK_ACCESSIBLE_ROLE_TAB_PANEL")]
1247    TabPanel,
1248    /// A type of input that allows free-form text
1249    ///   as its value.
1250    #[doc(alias = "GTK_ACCESSIBLE_ROLE_TEXT_BOX")]
1251    TextBox,
1252    /// Unused
1253    #[doc(alias = "GTK_ACCESSIBLE_ROLE_TIME")]
1254    Time,
1255    /// Unused
1256    #[doc(alias = "GTK_ACCESSIBLE_ROLE_TIMER")]
1257    Timer,
1258    /// Unused
1259    #[doc(alias = "GTK_ACCESSIBLE_ROLE_TOOLBAR")]
1260    Toolbar,
1261    /// Unused
1262    #[doc(alias = "GTK_ACCESSIBLE_ROLE_TOOLTIP")]
1263    Tooltip,
1264    /// Unused
1265    #[doc(alias = "GTK_ACCESSIBLE_ROLE_TREE")]
1266    Tree,
1267    /// A treeview-like, columned list.
1268    #[doc(alias = "GTK_ACCESSIBLE_ROLE_TREE_GRID")]
1269    TreeGrid,
1270    /// Unused
1271    #[doc(alias = "GTK_ACCESSIBLE_ROLE_TREE_ITEM")]
1272    TreeItem,
1273    /// Abstract role for interactive components of a
1274    ///   graphical user interface
1275    #[doc(alias = "GTK_ACCESSIBLE_ROLE_WIDGET")]
1276    Widget,
1277    /// Abstract role for windows.
1278    #[doc(alias = "GTK_ACCESSIBLE_ROLE_WINDOW")]
1279    Window,
1280    /// A type of push button which stays pressed until depressed by a second
1281    /// activation.
1282    #[cfg(feature = "v4_10")]
1283    #[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
1284    #[doc(alias = "GTK_ACCESSIBLE_ROLE_TOGGLE_BUTTON")]
1285    ToggleButton,
1286    /// A toplevel element of a graphical user interface.
1287    ///
1288    /// This is the role that GTK uses by default for windows.
1289    #[cfg(feature = "v4_12")]
1290    #[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
1291    #[doc(alias = "GTK_ACCESSIBLE_ROLE_APPLICATION")]
1292    Application,
1293    /// A paragraph of content.
1294    #[cfg(feature = "v4_14")]
1295    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1296    #[doc(alias = "GTK_ACCESSIBLE_ROLE_PARAGRAPH")]
1297    Paragraph,
1298    /// A section of content that is quoted from another source.
1299    #[cfg(feature = "v4_14")]
1300    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1301    #[doc(alias = "GTK_ACCESSIBLE_ROLE_BLOCK_QUOTE")]
1302    BlockQuote,
1303    /// A section of a page that consists of a composition that forms an independent
1304    /// part of a document, page, or site.
1305    #[cfg(feature = "v4_14")]
1306    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1307    #[doc(alias = "GTK_ACCESSIBLE_ROLE_ARTICLE")]
1308    Article,
1309    /// A comment contains content expressing reaction to other content.
1310    #[cfg(feature = "v4_14")]
1311    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1312    #[doc(alias = "GTK_ACCESSIBLE_ROLE_COMMENT")]
1313    Comment,
1314    /// A virtual terminal.
1315    #[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/// The possible values for the [`AccessibleProperty::Sort`][crate::AccessibleProperty::Sort]
1586/// accessible property.
1587#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1588#[non_exhaustive]
1589#[doc(alias = "GtkAccessibleSort")]
1590pub enum AccessibleSort {
1591    /// There is no defined sort applied to the column.
1592    #[doc(alias = "GTK_ACCESSIBLE_SORT_NONE")]
1593    None,
1594    /// Items are sorted in ascending order by this column.
1595    #[doc(alias = "GTK_ACCESSIBLE_SORT_ASCENDING")]
1596    Ascending,
1597    /// Items are sorted in descending order by this column.
1598    #[doc(alias = "GTK_ACCESSIBLE_SORT_DESCENDING")]
1599    Descending,
1600    /// A sort algorithm other than ascending or
1601    ///    descending has been applied.
1602    #[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/// The possible accessible states of a [`Accessible`][crate::Accessible].
1697#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1698#[non_exhaustive]
1699#[doc(alias = "GtkAccessibleState")]
1700pub enum AccessibleState {
1701    /// A “busy” state. This state has boolean values
1702    #[doc(alias = "GTK_ACCESSIBLE_STATE_BUSY")]
1703    Busy,
1704    /// A “checked” state; indicates the current
1705    ///   state of a [`CheckButton`][crate::CheckButton]. Value type: [`AccessibleTristate`][crate::AccessibleTristate]
1706    #[doc(alias = "GTK_ACCESSIBLE_STATE_CHECKED")]
1707    Checked,
1708    /// A “disabled” state; corresponds to the
1709    ///   [`sensitive`][struct@crate::Widget#sensitive] property. It indicates a UI element
1710    ///   that is perceivable, but not editable or operable. Value type: boolean
1711    #[doc(alias = "GTK_ACCESSIBLE_STATE_DISABLED")]
1712    Disabled,
1713    /// An “expanded” state; corresponds to the
1714    ///   [`expanded`][struct@crate::Expander#expanded] property. Value type: boolean
1715    ///   or undefined
1716    #[doc(alias = "GTK_ACCESSIBLE_STATE_EXPANDED")]
1717    Expanded,
1718    /// A “hidden” state; corresponds to the
1719    ///   [`visible`][struct@crate::Widget#visible] property. You can use this state
1720    ///   explicitly on UI elements that should not be exposed to an assistive
1721    ///   technology. Value type: boolean
1722    ///   See also: [`Disabled`][Self::Disabled]
1723    #[doc(alias = "GTK_ACCESSIBLE_STATE_HIDDEN")]
1724    Hidden,
1725    /// An “invalid” state; set when a widget
1726    ///   is showing an error. Value type: [`AccessibleInvalidState`][crate::AccessibleInvalidState]
1727    #[doc(alias = "GTK_ACCESSIBLE_STATE_INVALID")]
1728    Invalid,
1729    /// A “pressed” state; indicates the current
1730    ///   state of a [`ToggleButton`][crate::ToggleButton]. Value type: [`AccessibleTristate`][crate::AccessibleTristate]
1731    ///   enumeration
1732    #[doc(alias = "GTK_ACCESSIBLE_STATE_PRESSED")]
1733    Pressed,
1734    /// A “selected” state; set when a widget
1735    ///   is selected. Value type: boolean or undefined
1736    #[doc(alias = "GTK_ACCESSIBLE_STATE_SELECTED")]
1737    Selected,
1738    /// Indicates that a widget with the GTK_ACCESSIBLE_ROLE_LINK has been visited.
1739    /// Value type: boolean.
1740    #[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/// The type of contents change operation.
1859#[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    /// contents change as the result of
1866    ///   an insert operation
1867    #[doc(alias = "GTK_ACCESSIBLE_TEXT_CONTENT_CHANGE_INSERT")]
1868    Insert,
1869    /// contents change as the result of
1870    ///   a remove operation
1871    #[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/// The granularity for queries about the text contents of a [`AccessibleText`][crate::AccessibleText]
1978/// implementation.
1979#[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    /// Use the boundary between
1986    ///   characters (including non-printing characters)
1987    #[doc(alias = "GTK_ACCESSIBLE_TEXT_GRANULARITY_CHARACTER")]
1988    Character,
1989    /// Use the boundary between words,
1990    ///   starting from the beginning of the current word and ending at the
1991    ///   beginning of the next word
1992    #[doc(alias = "GTK_ACCESSIBLE_TEXT_GRANULARITY_WORD")]
1993    Word,
1994    /// Use the boundary between
1995    ///   sentences, starting from the beginning of the current sentence and
1996    ///   ending at the beginning of the next sentence
1997    #[doc(alias = "GTK_ACCESSIBLE_TEXT_GRANULARITY_SENTENCE")]
1998    Sentence,
1999    /// Use the boundary between lines,
2000    ///   starting from the beginning of the current line and ending at the
2001    ///   beginning of the next line
2002    #[doc(alias = "GTK_ACCESSIBLE_TEXT_GRANULARITY_LINE")]
2003    Line,
2004    /// Use the boundary between
2005    ///   paragraphs, starting from the beginning of the current paragraph and
2006    ///   ending at the beginning of the next paragraph
2007    #[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/// The possible values for the [`AccessibleState::Pressed`][crate::AccessibleState::Pressed]
2120/// accessible state.
2121///
2122/// Note that the [`False`][Self::False] and
2123/// [`True`][Self::True] have the same values
2124/// as [`false`] and [`true`].
2125#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2126#[non_exhaustive]
2127#[doc(alias = "GtkAccessibleTristate")]
2128pub enum AccessibleTristate {
2129    /// The state is `false`
2130    #[doc(alias = "GTK_ACCESSIBLE_TRISTATE_FALSE")]
2131    False,
2132    /// The state is `true`
2133    #[doc(alias = "GTK_ACCESSIBLE_TRISTATE_TRUE")]
2134    True,
2135    /// The state is `mixed`
2136    #[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/// Used to indicate the direction in which an arrow should point.
2229#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2230#[non_exhaustive]
2231#[doc(alias = "GtkArrowType")]
2232pub enum ArrowType {
2233    /// Represents an upward pointing arrow.
2234    #[doc(alias = "GTK_ARROW_UP")]
2235    Up,
2236    /// Represents a downward pointing arrow.
2237    #[doc(alias = "GTK_ARROW_DOWN")]
2238    Down,
2239    /// Represents a left pointing arrow.
2240    #[doc(alias = "GTK_ARROW_LEFT")]
2241    Left,
2242    /// Represents a right pointing arrow.
2243    #[doc(alias = "GTK_ARROW_RIGHT")]
2244    Right,
2245    /// No arrow.
2246    #[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/// Determines the page role inside a [`Assistant`][crate::Assistant].
2343///
2344/// The role is used to handle buttons sensitivity and visibility.
2345///
2346/// Note that an assistant needs to end its page flow with a page of type
2347/// [`Confirm`][Self::Confirm], [`Summary`][Self::Summary] or
2348/// [`Progress`][Self::Progress] to be correct.
2349///
2350/// The Cancel button will only be shown if the page isn’t “committed”.
2351/// See gtk_assistant_commit() for details.
2352#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2353#[non_exhaustive]
2354#[doc(alias = "GtkAssistantPageType")]
2355pub enum AssistantPageType {
2356    /// The page has regular contents. Both the
2357    ///  Back and forward buttons will be shown.
2358    #[doc(alias = "GTK_ASSISTANT_PAGE_CONTENT")]
2359    Content,
2360    /// The page contains an introduction to the
2361    ///  assistant task. Only the Forward button will be shown if there is a
2362    ///   next page.
2363    #[doc(alias = "GTK_ASSISTANT_PAGE_INTRO")]
2364    Intro,
2365    /// The page lets the user confirm or deny the
2366    ///  changes. The Back and Apply buttons will be shown.
2367    #[doc(alias = "GTK_ASSISTANT_PAGE_CONFIRM")]
2368    Confirm,
2369    /// The page informs the user of the changes
2370    ///  done. Only the Close button will be shown.
2371    #[doc(alias = "GTK_ASSISTANT_PAGE_SUMMARY")]
2372    Summary,
2373    /// Used for tasks that take a long time to
2374    ///  complete, blocks the assistant until the page is marked as complete.
2375    ///   Only the back button will be shown.
2376    #[doc(alias = "GTK_ASSISTANT_PAGE_PROGRESS")]
2377    Progress,
2378    /// Used for when other page types are not
2379    ///  appropriate. No buttons will be shown, and the application must
2380    ///  add its own buttons through gtk_assistant_add_action_widget().
2381    #[doc(alias = "GTK_ASSISTANT_PAGE_CUSTOM")]
2382    Custom,
2383    #[doc(hidden)]
2384    __Unknown(i32),
2385}
2386
2387#[doc(hidden)]
2388impl IntoGlib for AssistantPageType {
2389    type GlibType = ffi::GtkAssistantPageType;
2390
2391    #[inline]
2392    fn into_glib(self) -> ffi::GtkAssistantPageType {
2393        match self {
2394            Self::Content => ffi::GTK_ASSISTANT_PAGE_CONTENT,
2395            Self::Intro => ffi::GTK_ASSISTANT_PAGE_INTRO,
2396            Self::Confirm => ffi::GTK_ASSISTANT_PAGE_CONFIRM,
2397            Self::Summary => ffi::GTK_ASSISTANT_PAGE_SUMMARY,
2398            Self::Progress => ffi::GTK_ASSISTANT_PAGE_PROGRESS,
2399            Self::Custom => ffi::GTK_ASSISTANT_PAGE_CUSTOM,
2400            Self::__Unknown(value) => value,
2401        }
2402    }
2403}
2404
2405#[doc(hidden)]
2406impl FromGlib<ffi::GtkAssistantPageType> for AssistantPageType {
2407    #[inline]
2408    unsafe fn from_glib(value: ffi::GtkAssistantPageType) -> Self {
2409        skip_assert_initialized!();
2410
2411        match value {
2412            ffi::GTK_ASSISTANT_PAGE_CONTENT => Self::Content,
2413            ffi::GTK_ASSISTANT_PAGE_INTRO => Self::Intro,
2414            ffi::GTK_ASSISTANT_PAGE_CONFIRM => Self::Confirm,
2415            ffi::GTK_ASSISTANT_PAGE_SUMMARY => Self::Summary,
2416            ffi::GTK_ASSISTANT_PAGE_PROGRESS => Self::Progress,
2417            ffi::GTK_ASSISTANT_PAGE_CUSTOM => Self::Custom,
2418            value => Self::__Unknown(value),
2419        }
2420    }
2421}
2422
2423impl StaticType for AssistantPageType {
2424    #[inline]
2425    #[doc(alias = "gtk_assistant_page_type_get_type")]
2426    fn static_type() -> glib::Type {
2427        unsafe { from_glib(ffi::gtk_assistant_page_type_get_type()) }
2428    }
2429}
2430
2431impl glib::HasParamSpec for AssistantPageType {
2432    type ParamSpec = glib::ParamSpecEnum;
2433    type SetValue = Self;
2434    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2435
2436    fn param_spec_builder() -> Self::BuilderFn {
2437        Self::ParamSpec::builder_with_default
2438    }
2439}
2440
2441impl glib::value::ValueType for AssistantPageType {
2442    type Type = Self;
2443}
2444
2445unsafe impl<'a> glib::value::FromValue<'a> for AssistantPageType {
2446    type Checker = glib::value::GenericValueTypeChecker<Self>;
2447
2448    #[inline]
2449    unsafe fn from_value(value: &'a glib::Value) -> Self {
2450        skip_assert_initialized!();
2451        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2452    }
2453}
2454
2455impl ToValue for AssistantPageType {
2456    #[inline]
2457    fn to_value(&self) -> glib::Value {
2458        let mut value = glib::Value::for_value_type::<Self>();
2459        unsafe {
2460            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2461        }
2462        value
2463    }
2464
2465    #[inline]
2466    fn value_type(&self) -> glib::Type {
2467        Self::static_type()
2468    }
2469}
2470
2471impl From<AssistantPageType> for glib::Value {
2472    #[inline]
2473    fn from(v: AssistantPageType) -> Self {
2474        skip_assert_initialized!();
2475        ToValue::to_value(&v)
2476    }
2477}
2478
2479/// Baseline position in a row of widgets.
2480///
2481/// Whenever a container has some form of natural row it may align
2482/// children in that row along a common typographical baseline. If
2483/// the amount of vertical space in the row is taller than the total
2484/// requested height of the baseline-aligned children then it can use a
2485/// [`BaselinePosition`][crate::BaselinePosition] to select where to put the baseline inside the
2486/// extra available space.
2487#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2488#[non_exhaustive]
2489#[doc(alias = "GtkBaselinePosition")]
2490pub enum BaselinePosition {
2491    /// Align the baseline at the top
2492    #[doc(alias = "GTK_BASELINE_POSITION_TOP")]
2493    Top,
2494    /// Center the baseline
2495    #[doc(alias = "GTK_BASELINE_POSITION_CENTER")]
2496    Center,
2497    /// Align the baseline at the bottom
2498    #[doc(alias = "GTK_BASELINE_POSITION_BOTTOM")]
2499    Bottom,
2500    #[doc(hidden)]
2501    __Unknown(i32),
2502}
2503
2504#[doc(hidden)]
2505impl IntoGlib for BaselinePosition {
2506    type GlibType = ffi::GtkBaselinePosition;
2507
2508    #[inline]
2509    fn into_glib(self) -> ffi::GtkBaselinePosition {
2510        match self {
2511            Self::Top => ffi::GTK_BASELINE_POSITION_TOP,
2512            Self::Center => ffi::GTK_BASELINE_POSITION_CENTER,
2513            Self::Bottom => ffi::GTK_BASELINE_POSITION_BOTTOM,
2514            Self::__Unknown(value) => value,
2515        }
2516    }
2517}
2518
2519#[doc(hidden)]
2520impl FromGlib<ffi::GtkBaselinePosition> for BaselinePosition {
2521    #[inline]
2522    unsafe fn from_glib(value: ffi::GtkBaselinePosition) -> Self {
2523        skip_assert_initialized!();
2524
2525        match value {
2526            ffi::GTK_BASELINE_POSITION_TOP => Self::Top,
2527            ffi::GTK_BASELINE_POSITION_CENTER => Self::Center,
2528            ffi::GTK_BASELINE_POSITION_BOTTOM => Self::Bottom,
2529            value => Self::__Unknown(value),
2530        }
2531    }
2532}
2533
2534impl StaticType for BaselinePosition {
2535    #[inline]
2536    #[doc(alias = "gtk_baseline_position_get_type")]
2537    fn static_type() -> glib::Type {
2538        unsafe { from_glib(ffi::gtk_baseline_position_get_type()) }
2539    }
2540}
2541
2542impl glib::HasParamSpec for BaselinePosition {
2543    type ParamSpec = glib::ParamSpecEnum;
2544    type SetValue = Self;
2545    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2546
2547    fn param_spec_builder() -> Self::BuilderFn {
2548        Self::ParamSpec::builder_with_default
2549    }
2550}
2551
2552impl glib::value::ValueType for BaselinePosition {
2553    type Type = Self;
2554}
2555
2556unsafe impl<'a> glib::value::FromValue<'a> for BaselinePosition {
2557    type Checker = glib::value::GenericValueTypeChecker<Self>;
2558
2559    #[inline]
2560    unsafe fn from_value(value: &'a glib::Value) -> Self {
2561        skip_assert_initialized!();
2562        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2563    }
2564}
2565
2566impl ToValue for BaselinePosition {
2567    #[inline]
2568    fn to_value(&self) -> glib::Value {
2569        let mut value = glib::Value::for_value_type::<Self>();
2570        unsafe {
2571            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2572        }
2573        value
2574    }
2575
2576    #[inline]
2577    fn value_type(&self) -> glib::Type {
2578        Self::static_type()
2579    }
2580}
2581
2582impl From<BaselinePosition> for glib::Value {
2583    #[inline]
2584    fn from(v: BaselinePosition) -> Self {
2585        skip_assert_initialized!();
2586        ToValue::to_value(&v)
2587    }
2588}
2589
2590/// Describes how the border of a UI element should be rendered.
2591#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2592#[non_exhaustive]
2593#[doc(alias = "GtkBorderStyle")]
2594pub enum BorderStyle {
2595    /// No visible border
2596    #[doc(alias = "GTK_BORDER_STYLE_NONE")]
2597    None,
2598    /// Same as [`None`][Self::None]
2599    #[doc(alias = "GTK_BORDER_STYLE_HIDDEN")]
2600    Hidden,
2601    /// A single line segment
2602    #[doc(alias = "GTK_BORDER_STYLE_SOLID")]
2603    Solid,
2604    /// Looks as if the content is sunken into the canvas
2605    #[doc(alias = "GTK_BORDER_STYLE_INSET")]
2606    Inset,
2607    /// Looks as if the content is coming out of the canvas
2608    #[doc(alias = "GTK_BORDER_STYLE_OUTSET")]
2609    Outset,
2610    /// A series of round dots
2611    #[doc(alias = "GTK_BORDER_STYLE_DOTTED")]
2612    Dotted,
2613    /// A series of square-ended dashes
2614    #[doc(alias = "GTK_BORDER_STYLE_DASHED")]
2615    Dashed,
2616    /// Two parallel lines with some space between them
2617    #[doc(alias = "GTK_BORDER_STYLE_DOUBLE")]
2618    Double,
2619    /// Looks as if it were carved in the canvas
2620    #[doc(alias = "GTK_BORDER_STYLE_GROOVE")]
2621    Groove,
2622    /// Looks as if it were coming out of the canvas
2623    #[doc(alias = "GTK_BORDER_STYLE_RIDGE")]
2624    Ridge,
2625    #[doc(hidden)]
2626    __Unknown(i32),
2627}
2628
2629#[doc(hidden)]
2630impl IntoGlib for BorderStyle {
2631    type GlibType = ffi::GtkBorderStyle;
2632
2633    #[inline]
2634    fn into_glib(self) -> ffi::GtkBorderStyle {
2635        match self {
2636            Self::None => ffi::GTK_BORDER_STYLE_NONE,
2637            Self::Hidden => ffi::GTK_BORDER_STYLE_HIDDEN,
2638            Self::Solid => ffi::GTK_BORDER_STYLE_SOLID,
2639            Self::Inset => ffi::GTK_BORDER_STYLE_INSET,
2640            Self::Outset => ffi::GTK_BORDER_STYLE_OUTSET,
2641            Self::Dotted => ffi::GTK_BORDER_STYLE_DOTTED,
2642            Self::Dashed => ffi::GTK_BORDER_STYLE_DASHED,
2643            Self::Double => ffi::GTK_BORDER_STYLE_DOUBLE,
2644            Self::Groove => ffi::GTK_BORDER_STYLE_GROOVE,
2645            Self::Ridge => ffi::GTK_BORDER_STYLE_RIDGE,
2646            Self::__Unknown(value) => value,
2647        }
2648    }
2649}
2650
2651#[doc(hidden)]
2652impl FromGlib<ffi::GtkBorderStyle> for BorderStyle {
2653    #[inline]
2654    unsafe fn from_glib(value: ffi::GtkBorderStyle) -> Self {
2655        skip_assert_initialized!();
2656
2657        match value {
2658            ffi::GTK_BORDER_STYLE_NONE => Self::None,
2659            ffi::GTK_BORDER_STYLE_HIDDEN => Self::Hidden,
2660            ffi::GTK_BORDER_STYLE_SOLID => Self::Solid,
2661            ffi::GTK_BORDER_STYLE_INSET => Self::Inset,
2662            ffi::GTK_BORDER_STYLE_OUTSET => Self::Outset,
2663            ffi::GTK_BORDER_STYLE_DOTTED => Self::Dotted,
2664            ffi::GTK_BORDER_STYLE_DASHED => Self::Dashed,
2665            ffi::GTK_BORDER_STYLE_DOUBLE => Self::Double,
2666            ffi::GTK_BORDER_STYLE_GROOVE => Self::Groove,
2667            ffi::GTK_BORDER_STYLE_RIDGE => Self::Ridge,
2668            value => Self::__Unknown(value),
2669        }
2670    }
2671}
2672
2673impl StaticType for BorderStyle {
2674    #[inline]
2675    #[doc(alias = "gtk_border_style_get_type")]
2676    fn static_type() -> glib::Type {
2677        unsafe { from_glib(ffi::gtk_border_style_get_type()) }
2678    }
2679}
2680
2681impl glib::HasParamSpec for BorderStyle {
2682    type ParamSpec = glib::ParamSpecEnum;
2683    type SetValue = Self;
2684    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2685
2686    fn param_spec_builder() -> Self::BuilderFn {
2687        Self::ParamSpec::builder_with_default
2688    }
2689}
2690
2691impl glib::value::ValueType for BorderStyle {
2692    type Type = Self;
2693}
2694
2695unsafe impl<'a> glib::value::FromValue<'a> for BorderStyle {
2696    type Checker = glib::value::GenericValueTypeChecker<Self>;
2697
2698    #[inline]
2699    unsafe fn from_value(value: &'a glib::Value) -> Self {
2700        skip_assert_initialized!();
2701        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2702    }
2703}
2704
2705impl ToValue for BorderStyle {
2706    #[inline]
2707    fn to_value(&self) -> glib::Value {
2708        let mut value = glib::Value::for_value_type::<Self>();
2709        unsafe {
2710            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2711        }
2712        value
2713    }
2714
2715    #[inline]
2716    fn value_type(&self) -> glib::Type {
2717        Self::static_type()
2718    }
2719}
2720
2721impl From<BorderStyle> for glib::Value {
2722    #[inline]
2723    fn from(v: BorderStyle) -> Self {
2724        skip_assert_initialized!();
2725        ToValue::to_value(&v)
2726    }
2727}
2728
2729/// Error codes that identify various errors that can occur while using
2730/// [`Builder`][crate::Builder].
2731#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2732#[non_exhaustive]
2733#[doc(alias = "GtkBuilderError")]
2734pub enum BuilderError {
2735    /// A type-func attribute didn’t name
2736    ///  a function that returns a `GType`.
2737    #[doc(alias = "GTK_BUILDER_ERROR_INVALID_TYPE_FUNCTION")]
2738    InvalidTypeFunction,
2739    /// The input contained a tag that [`Builder`][crate::Builder]
2740    ///  can’t handle.
2741    #[doc(alias = "GTK_BUILDER_ERROR_UNHANDLED_TAG")]
2742    UnhandledTag,
2743    /// An attribute that is required by
2744    ///  [`Builder`][crate::Builder] was missing.
2745    #[doc(alias = "GTK_BUILDER_ERROR_MISSING_ATTRIBUTE")]
2746    MissingAttribute,
2747    /// [`Builder`][crate::Builder] found an attribute that
2748    ///  it doesn’t understand.
2749    #[doc(alias = "GTK_BUILDER_ERROR_INVALID_ATTRIBUTE")]
2750    InvalidAttribute,
2751    /// [`Builder`][crate::Builder] found a tag that
2752    ///  it doesn’t understand.
2753    #[doc(alias = "GTK_BUILDER_ERROR_INVALID_TAG")]
2754    InvalidTag,
2755    /// A required property value was
2756    ///  missing.
2757    #[doc(alias = "GTK_BUILDER_ERROR_MISSING_PROPERTY_VALUE")]
2758    MissingPropertyValue,
2759    /// [`Builder`][crate::Builder] couldn’t parse
2760    ///  some attribute value.
2761    #[doc(alias = "GTK_BUILDER_ERROR_INVALID_VALUE")]
2762    InvalidValue,
2763    /// The input file requires a newer version
2764    ///  of GTK.
2765    #[doc(alias = "GTK_BUILDER_ERROR_VERSION_MISMATCH")]
2766    VersionMismatch,
2767    /// An object id occurred twice.
2768    #[doc(alias = "GTK_BUILDER_ERROR_DUPLICATE_ID")]
2769    DuplicateId,
2770    /// A specified object type is of the same type or
2771    ///  derived from the type of the composite class being extended with builder XML.
2772    #[doc(alias = "GTK_BUILDER_ERROR_OBJECT_TYPE_REFUSED")]
2773    ObjectTypeRefused,
2774    /// The wrong type was specified in a composite class’s template XML
2775    #[doc(alias = "GTK_BUILDER_ERROR_TEMPLATE_MISMATCH")]
2776    TemplateMismatch,
2777    /// The specified property is unknown for the object class.
2778    #[doc(alias = "GTK_BUILDER_ERROR_INVALID_PROPERTY")]
2779    InvalidProperty,
2780    /// The specified signal is unknown for the object class.
2781    #[doc(alias = "GTK_BUILDER_ERROR_INVALID_SIGNAL")]
2782    InvalidSignal,
2783    /// An object id is unknown.
2784    #[doc(alias = "GTK_BUILDER_ERROR_INVALID_ID")]
2785    InvalidId,
2786    /// A function could not be found. This often happens
2787    ///   when symbols are set to be kept private. Compiling code with -rdynamic or using the
2788    ///   `gmodule-export-2.0` pkgconfig module can fix this problem.
2789    #[doc(alias = "GTK_BUILDER_ERROR_INVALID_FUNCTION")]
2790    InvalidFunction,
2791    #[doc(hidden)]
2792    __Unknown(i32),
2793}
2794
2795#[doc(hidden)]
2796impl IntoGlib for BuilderError {
2797    type GlibType = ffi::GtkBuilderError;
2798
2799    fn into_glib(self) -> ffi::GtkBuilderError {
2800        match self {
2801            Self::InvalidTypeFunction => ffi::GTK_BUILDER_ERROR_INVALID_TYPE_FUNCTION,
2802            Self::UnhandledTag => ffi::GTK_BUILDER_ERROR_UNHANDLED_TAG,
2803            Self::MissingAttribute => ffi::GTK_BUILDER_ERROR_MISSING_ATTRIBUTE,
2804            Self::InvalidAttribute => ffi::GTK_BUILDER_ERROR_INVALID_ATTRIBUTE,
2805            Self::InvalidTag => ffi::GTK_BUILDER_ERROR_INVALID_TAG,
2806            Self::MissingPropertyValue => ffi::GTK_BUILDER_ERROR_MISSING_PROPERTY_VALUE,
2807            Self::InvalidValue => ffi::GTK_BUILDER_ERROR_INVALID_VALUE,
2808            Self::VersionMismatch => ffi::GTK_BUILDER_ERROR_VERSION_MISMATCH,
2809            Self::DuplicateId => ffi::GTK_BUILDER_ERROR_DUPLICATE_ID,
2810            Self::ObjectTypeRefused => ffi::GTK_BUILDER_ERROR_OBJECT_TYPE_REFUSED,
2811            Self::TemplateMismatch => ffi::GTK_BUILDER_ERROR_TEMPLATE_MISMATCH,
2812            Self::InvalidProperty => ffi::GTK_BUILDER_ERROR_INVALID_PROPERTY,
2813            Self::InvalidSignal => ffi::GTK_BUILDER_ERROR_INVALID_SIGNAL,
2814            Self::InvalidId => ffi::GTK_BUILDER_ERROR_INVALID_ID,
2815            Self::InvalidFunction => ffi::GTK_BUILDER_ERROR_INVALID_FUNCTION,
2816            Self::__Unknown(value) => value,
2817        }
2818    }
2819}
2820
2821#[doc(hidden)]
2822impl FromGlib<ffi::GtkBuilderError> for BuilderError {
2823    unsafe fn from_glib(value: ffi::GtkBuilderError) -> Self {
2824        skip_assert_initialized!();
2825
2826        match value {
2827            ffi::GTK_BUILDER_ERROR_INVALID_TYPE_FUNCTION => Self::InvalidTypeFunction,
2828            ffi::GTK_BUILDER_ERROR_UNHANDLED_TAG => Self::UnhandledTag,
2829            ffi::GTK_BUILDER_ERROR_MISSING_ATTRIBUTE => Self::MissingAttribute,
2830            ffi::GTK_BUILDER_ERROR_INVALID_ATTRIBUTE => Self::InvalidAttribute,
2831            ffi::GTK_BUILDER_ERROR_INVALID_TAG => Self::InvalidTag,
2832            ffi::GTK_BUILDER_ERROR_MISSING_PROPERTY_VALUE => Self::MissingPropertyValue,
2833            ffi::GTK_BUILDER_ERROR_INVALID_VALUE => Self::InvalidValue,
2834            ffi::GTK_BUILDER_ERROR_VERSION_MISMATCH => Self::VersionMismatch,
2835            ffi::GTK_BUILDER_ERROR_DUPLICATE_ID => Self::DuplicateId,
2836            ffi::GTK_BUILDER_ERROR_OBJECT_TYPE_REFUSED => Self::ObjectTypeRefused,
2837            ffi::GTK_BUILDER_ERROR_TEMPLATE_MISMATCH => Self::TemplateMismatch,
2838            ffi::GTK_BUILDER_ERROR_INVALID_PROPERTY => Self::InvalidProperty,
2839            ffi::GTK_BUILDER_ERROR_INVALID_SIGNAL => Self::InvalidSignal,
2840            ffi::GTK_BUILDER_ERROR_INVALID_ID => Self::InvalidId,
2841            ffi::GTK_BUILDER_ERROR_INVALID_FUNCTION => Self::InvalidFunction,
2842            value => Self::__Unknown(value),
2843        }
2844    }
2845}
2846
2847impl glib::error::ErrorDomain for BuilderError {
2848    #[inline]
2849    fn domain() -> glib::Quark {
2850        skip_assert_initialized!();
2851
2852        unsafe { from_glib(ffi::gtk_builder_error_quark()) }
2853    }
2854
2855    #[inline]
2856    fn code(self) -> i32 {
2857        self.into_glib()
2858    }
2859
2860    #[inline]
2861    #[allow(clippy::match_single_binding)]
2862    fn from(code: i32) -> Option<Self> {
2863        skip_assert_initialized!();
2864        match unsafe { from_glib(code) } {
2865            value => Some(value),
2866        }
2867    }
2868}
2869
2870impl StaticType for BuilderError {
2871    #[inline]
2872    #[doc(alias = "gtk_builder_error_get_type")]
2873    fn static_type() -> glib::Type {
2874        unsafe { from_glib(ffi::gtk_builder_error_get_type()) }
2875    }
2876}
2877
2878impl glib::HasParamSpec for BuilderError {
2879    type ParamSpec = glib::ParamSpecEnum;
2880    type SetValue = Self;
2881    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2882
2883    fn param_spec_builder() -> Self::BuilderFn {
2884        Self::ParamSpec::builder_with_default
2885    }
2886}
2887
2888impl glib::value::ValueType for BuilderError {
2889    type Type = Self;
2890}
2891
2892unsafe impl<'a> glib::value::FromValue<'a> for BuilderError {
2893    type Checker = glib::value::GenericValueTypeChecker<Self>;
2894
2895    #[inline]
2896    unsafe fn from_value(value: &'a glib::Value) -> Self {
2897        skip_assert_initialized!();
2898        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2899    }
2900}
2901
2902impl ToValue for BuilderError {
2903    #[inline]
2904    fn to_value(&self) -> glib::Value {
2905        let mut value = glib::Value::for_value_type::<Self>();
2906        unsafe {
2907            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2908        }
2909        value
2910    }
2911
2912    #[inline]
2913    fn value_type(&self) -> glib::Type {
2914        Self::static_type()
2915    }
2916}
2917
2918impl From<BuilderError> for glib::Value {
2919    #[inline]
2920    fn from(v: BuilderError) -> Self {
2921        skip_assert_initialized!();
2922        ToValue::to_value(&v)
2923    }
2924}
2925
2926/// Prebuilt sets of buttons for [`Dialog`][crate::Dialog].
2927///
2928/// If none of these choices are appropriate, simply use
2929/// [`None`][Self::None] and call [`DialogExtManual::add_buttons()`][crate::prelude::DialogExtManual::add_buttons()].
2930///
2931/// > Please note that [`Ok`][Self::Ok], [`YesNo`][Self::YesNo]
2932/// > and [`OkCancel`][Self::OkCancel] are discouraged by the
2933/// > [GNOME Human Interface Guidelines](https://developer.gnome.org/hig/).
2934#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2935#[non_exhaustive]
2936#[doc(alias = "GtkButtonsType")]
2937pub enum ButtonsType {
2938    /// no buttons at all
2939    #[doc(alias = "GTK_BUTTONS_NONE")]
2940    None,
2941    /// an OK button
2942    #[doc(alias = "GTK_BUTTONS_OK")]
2943    Ok,
2944    /// a Close button
2945    #[doc(alias = "GTK_BUTTONS_CLOSE")]
2946    Close,
2947    /// a Cancel button
2948    #[doc(alias = "GTK_BUTTONS_CANCEL")]
2949    Cancel,
2950    /// Yes and No buttons
2951    #[doc(alias = "GTK_BUTTONS_YES_NO")]
2952    YesNo,
2953    /// OK and Cancel buttons
2954    #[doc(alias = "GTK_BUTTONS_OK_CANCEL")]
2955    OkCancel,
2956    #[doc(hidden)]
2957    __Unknown(i32),
2958}
2959
2960#[doc(hidden)]
2961impl IntoGlib for ButtonsType {
2962    type GlibType = ffi::GtkButtonsType;
2963
2964    #[inline]
2965    fn into_glib(self) -> ffi::GtkButtonsType {
2966        match self {
2967            Self::None => ffi::GTK_BUTTONS_NONE,
2968            Self::Ok => ffi::GTK_BUTTONS_OK,
2969            Self::Close => ffi::GTK_BUTTONS_CLOSE,
2970            Self::Cancel => ffi::GTK_BUTTONS_CANCEL,
2971            Self::YesNo => ffi::GTK_BUTTONS_YES_NO,
2972            Self::OkCancel => ffi::GTK_BUTTONS_OK_CANCEL,
2973            Self::__Unknown(value) => value,
2974        }
2975    }
2976}
2977
2978#[doc(hidden)]
2979impl FromGlib<ffi::GtkButtonsType> for ButtonsType {
2980    #[inline]
2981    unsafe fn from_glib(value: ffi::GtkButtonsType) -> Self {
2982        skip_assert_initialized!();
2983
2984        match value {
2985            ffi::GTK_BUTTONS_NONE => Self::None,
2986            ffi::GTK_BUTTONS_OK => Self::Ok,
2987            ffi::GTK_BUTTONS_CLOSE => Self::Close,
2988            ffi::GTK_BUTTONS_CANCEL => Self::Cancel,
2989            ffi::GTK_BUTTONS_YES_NO => Self::YesNo,
2990            ffi::GTK_BUTTONS_OK_CANCEL => Self::OkCancel,
2991            value => Self::__Unknown(value),
2992        }
2993    }
2994}
2995
2996impl StaticType for ButtonsType {
2997    #[inline]
2998    #[doc(alias = "gtk_buttons_type_get_type")]
2999    fn static_type() -> glib::Type {
3000        unsafe { from_glib(ffi::gtk_buttons_type_get_type()) }
3001    }
3002}
3003
3004impl glib::HasParamSpec for ButtonsType {
3005    type ParamSpec = glib::ParamSpecEnum;
3006    type SetValue = Self;
3007    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3008
3009    fn param_spec_builder() -> Self::BuilderFn {
3010        Self::ParamSpec::builder_with_default
3011    }
3012}
3013
3014impl glib::value::ValueType for ButtonsType {
3015    type Type = Self;
3016}
3017
3018unsafe impl<'a> glib::value::FromValue<'a> for ButtonsType {
3019    type Checker = glib::value::GenericValueTypeChecker<Self>;
3020
3021    #[inline]
3022    unsafe fn from_value(value: &'a glib::Value) -> Self {
3023        skip_assert_initialized!();
3024        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3025    }
3026}
3027
3028impl ToValue for ButtonsType {
3029    #[inline]
3030    fn to_value(&self) -> glib::Value {
3031        let mut value = glib::Value::for_value_type::<Self>();
3032        unsafe {
3033            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3034        }
3035        value
3036    }
3037
3038    #[inline]
3039    fn value_type(&self) -> glib::Type {
3040        Self::static_type()
3041    }
3042}
3043
3044impl From<ButtonsType> for glib::Value {
3045    #[inline]
3046    fn from(v: ButtonsType) -> Self {
3047        skip_assert_initialized!();
3048        ToValue::to_value(&v)
3049    }
3050}
3051
3052/// The available modes for [`accel-mode`][struct@crate::CellRendererAccel#accel-mode].
3053#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3054#[non_exhaustive]
3055#[doc(alias = "GtkCellRendererAccelMode")]
3056pub enum CellRendererAccelMode {
3057    /// GTK accelerators mode
3058    #[doc(alias = "GTK_CELL_RENDERER_ACCEL_MODE_GTK")]
3059    Gtk,
3060    /// Other accelerator mode
3061    #[doc(alias = "GTK_CELL_RENDERER_ACCEL_MODE_OTHER")]
3062    Other,
3063    #[doc(hidden)]
3064    __Unknown(i32),
3065}
3066
3067#[doc(hidden)]
3068impl IntoGlib for CellRendererAccelMode {
3069    type GlibType = ffi::GtkCellRendererAccelMode;
3070
3071    #[inline]
3072    fn into_glib(self) -> ffi::GtkCellRendererAccelMode {
3073        match self {
3074            Self::Gtk => ffi::GTK_CELL_RENDERER_ACCEL_MODE_GTK,
3075            Self::Other => ffi::GTK_CELL_RENDERER_ACCEL_MODE_OTHER,
3076            Self::__Unknown(value) => value,
3077        }
3078    }
3079}
3080
3081#[doc(hidden)]
3082impl FromGlib<ffi::GtkCellRendererAccelMode> for CellRendererAccelMode {
3083    #[inline]
3084    unsafe fn from_glib(value: ffi::GtkCellRendererAccelMode) -> Self {
3085        skip_assert_initialized!();
3086
3087        match value {
3088            ffi::GTK_CELL_RENDERER_ACCEL_MODE_GTK => Self::Gtk,
3089            ffi::GTK_CELL_RENDERER_ACCEL_MODE_OTHER => Self::Other,
3090            value => Self::__Unknown(value),
3091        }
3092    }
3093}
3094
3095impl StaticType for CellRendererAccelMode {
3096    #[inline]
3097    #[doc(alias = "gtk_cell_renderer_accel_mode_get_type")]
3098    fn static_type() -> glib::Type {
3099        unsafe { from_glib(ffi::gtk_cell_renderer_accel_mode_get_type()) }
3100    }
3101}
3102
3103impl glib::HasParamSpec for CellRendererAccelMode {
3104    type ParamSpec = glib::ParamSpecEnum;
3105    type SetValue = Self;
3106    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3107
3108    fn param_spec_builder() -> Self::BuilderFn {
3109        Self::ParamSpec::builder_with_default
3110    }
3111}
3112
3113impl glib::value::ValueType for CellRendererAccelMode {
3114    type Type = Self;
3115}
3116
3117unsafe impl<'a> glib::value::FromValue<'a> for CellRendererAccelMode {
3118    type Checker = glib::value::GenericValueTypeChecker<Self>;
3119
3120    #[inline]
3121    unsafe fn from_value(value: &'a glib::Value) -> Self {
3122        skip_assert_initialized!();
3123        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3124    }
3125}
3126
3127impl ToValue for CellRendererAccelMode {
3128    #[inline]
3129    fn to_value(&self) -> glib::Value {
3130        let mut value = glib::Value::for_value_type::<Self>();
3131        unsafe {
3132            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3133        }
3134        value
3135    }
3136
3137    #[inline]
3138    fn value_type(&self) -> glib::Type {
3139        Self::static_type()
3140    }
3141}
3142
3143impl From<CellRendererAccelMode> for glib::Value {
3144    #[inline]
3145    fn from(v: CellRendererAccelMode) -> Self {
3146        skip_assert_initialized!();
3147        ToValue::to_value(&v)
3148    }
3149}
3150
3151/// Identifies how the user can interact with a particular cell.
3152#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3153#[non_exhaustive]
3154#[doc(alias = "GtkCellRendererMode")]
3155pub enum CellRendererMode {
3156    /// The cell is just for display
3157    ///  and cannot be interacted with.  Note that this doesn’t mean that eg. the
3158    ///  row being drawn can’t be selected -- just that a particular element of
3159    ///  it cannot be individually modified.
3160    #[doc(alias = "GTK_CELL_RENDERER_MODE_INERT")]
3161    Inert,
3162    /// The cell can be clicked.
3163    #[doc(alias = "GTK_CELL_RENDERER_MODE_ACTIVATABLE")]
3164    Activatable,
3165    /// The cell can be edited or otherwise modified.
3166    #[doc(alias = "GTK_CELL_RENDERER_MODE_EDITABLE")]
3167    Editable,
3168    #[doc(hidden)]
3169    __Unknown(i32),
3170}
3171
3172#[doc(hidden)]
3173impl IntoGlib for CellRendererMode {
3174    type GlibType = ffi::GtkCellRendererMode;
3175
3176    #[inline]
3177    fn into_glib(self) -> ffi::GtkCellRendererMode {
3178        match self {
3179            Self::Inert => ffi::GTK_CELL_RENDERER_MODE_INERT,
3180            Self::Activatable => ffi::GTK_CELL_RENDERER_MODE_ACTIVATABLE,
3181            Self::Editable => ffi::GTK_CELL_RENDERER_MODE_EDITABLE,
3182            Self::__Unknown(value) => value,
3183        }
3184    }
3185}
3186
3187#[doc(hidden)]
3188impl FromGlib<ffi::GtkCellRendererMode> for CellRendererMode {
3189    #[inline]
3190    unsafe fn from_glib(value: ffi::GtkCellRendererMode) -> Self {
3191        skip_assert_initialized!();
3192
3193        match value {
3194            ffi::GTK_CELL_RENDERER_MODE_INERT => Self::Inert,
3195            ffi::GTK_CELL_RENDERER_MODE_ACTIVATABLE => Self::Activatable,
3196            ffi::GTK_CELL_RENDERER_MODE_EDITABLE => Self::Editable,
3197            value => Self::__Unknown(value),
3198        }
3199    }
3200}
3201
3202impl StaticType for CellRendererMode {
3203    #[inline]
3204    #[doc(alias = "gtk_cell_renderer_mode_get_type")]
3205    fn static_type() -> glib::Type {
3206        unsafe { from_glib(ffi::gtk_cell_renderer_mode_get_type()) }
3207    }
3208}
3209
3210impl glib::HasParamSpec for CellRendererMode {
3211    type ParamSpec = glib::ParamSpecEnum;
3212    type SetValue = Self;
3213    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3214
3215    fn param_spec_builder() -> Self::BuilderFn {
3216        Self::ParamSpec::builder_with_default
3217    }
3218}
3219
3220impl glib::value::ValueType for CellRendererMode {
3221    type Type = Self;
3222}
3223
3224unsafe impl<'a> glib::value::FromValue<'a> for CellRendererMode {
3225    type Checker = glib::value::GenericValueTypeChecker<Self>;
3226
3227    #[inline]
3228    unsafe fn from_value(value: &'a glib::Value) -> Self {
3229        skip_assert_initialized!();
3230        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3231    }
3232}
3233
3234impl ToValue for CellRendererMode {
3235    #[inline]
3236    fn to_value(&self) -> glib::Value {
3237        let mut value = glib::Value::for_value_type::<Self>();
3238        unsafe {
3239            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3240        }
3241        value
3242    }
3243
3244    #[inline]
3245    fn value_type(&self) -> glib::Type {
3246        Self::static_type()
3247    }
3248}
3249
3250impl From<CellRendererMode> for glib::Value {
3251    #[inline]
3252    fn from(v: CellRendererMode) -> Self {
3253        skip_assert_initialized!();
3254        ToValue::to_value(&v)
3255    }
3256}
3257
3258/// Describes how a [`StringSorter`][crate::StringSorter] turns strings into sort keys to
3259/// compare them.
3260///
3261/// Note that the result of sorting will in general depend on the current locale
3262/// unless the mode is @GTK_COLLATION_NONE.
3263#[cfg(feature = "v4_10")]
3264#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
3265#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3266#[non_exhaustive]
3267#[doc(alias = "GtkCollation")]
3268pub enum Collation {
3269    /// Don't do any collation
3270    #[doc(alias = "GTK_COLLATION_NONE")]
3271    None,
3272    /// Use `utf8_collate_key()`
3273    #[doc(alias = "GTK_COLLATION_UNICODE")]
3274    Unicode,
3275    /// Use `utf8_collate_key_for_filename()`
3276    #[doc(alias = "GTK_COLLATION_FILENAME")]
3277    Filename,
3278    #[doc(hidden)]
3279    __Unknown(i32),
3280}
3281
3282#[cfg(feature = "v4_10")]
3283#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
3284#[doc(hidden)]
3285impl IntoGlib for Collation {
3286    type GlibType = ffi::GtkCollation;
3287
3288    #[inline]
3289    fn into_glib(self) -> ffi::GtkCollation {
3290        match self {
3291            Self::None => ffi::GTK_COLLATION_NONE,
3292            Self::Unicode => ffi::GTK_COLLATION_UNICODE,
3293            Self::Filename => ffi::GTK_COLLATION_FILENAME,
3294            Self::__Unknown(value) => value,
3295        }
3296    }
3297}
3298
3299#[cfg(feature = "v4_10")]
3300#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
3301#[doc(hidden)]
3302impl FromGlib<ffi::GtkCollation> for Collation {
3303    #[inline]
3304    unsafe fn from_glib(value: ffi::GtkCollation) -> Self {
3305        skip_assert_initialized!();
3306
3307        match value {
3308            ffi::GTK_COLLATION_NONE => Self::None,
3309            ffi::GTK_COLLATION_UNICODE => Self::Unicode,
3310            ffi::GTK_COLLATION_FILENAME => Self::Filename,
3311            value => Self::__Unknown(value),
3312        }
3313    }
3314}
3315
3316#[cfg(feature = "v4_10")]
3317#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
3318impl StaticType for Collation {
3319    #[inline]
3320    #[doc(alias = "gtk_collation_get_type")]
3321    fn static_type() -> glib::Type {
3322        unsafe { from_glib(ffi::gtk_collation_get_type()) }
3323    }
3324}
3325
3326#[cfg(feature = "v4_10")]
3327#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
3328impl glib::HasParamSpec for Collation {
3329    type ParamSpec = glib::ParamSpecEnum;
3330    type SetValue = Self;
3331    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3332
3333    fn param_spec_builder() -> Self::BuilderFn {
3334        Self::ParamSpec::builder_with_default
3335    }
3336}
3337
3338#[cfg(feature = "v4_10")]
3339#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
3340impl glib::value::ValueType for Collation {
3341    type Type = Self;
3342}
3343
3344#[cfg(feature = "v4_10")]
3345#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
3346unsafe impl<'a> glib::value::FromValue<'a> for Collation {
3347    type Checker = glib::value::GenericValueTypeChecker<Self>;
3348
3349    #[inline]
3350    unsafe fn from_value(value: &'a glib::Value) -> Self {
3351        skip_assert_initialized!();
3352        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3353    }
3354}
3355
3356#[cfg(feature = "v4_10")]
3357#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
3358impl ToValue for Collation {
3359    #[inline]
3360    fn to_value(&self) -> glib::Value {
3361        let mut value = glib::Value::for_value_type::<Self>();
3362        unsafe {
3363            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3364        }
3365        value
3366    }
3367
3368    #[inline]
3369    fn value_type(&self) -> glib::Type {
3370        Self::static_type()
3371    }
3372}
3373
3374#[cfg(feature = "v4_10")]
3375#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
3376impl From<Collation> for glib::Value {
3377    #[inline]
3378    fn from(v: Collation) -> Self {
3379        skip_assert_initialized!();
3380        ToValue::to_value(&v)
3381    }
3382}
3383
3384/// The widget attributes that can be used when creating a [`Constraint`][crate::Constraint].
3385#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3386#[non_exhaustive]
3387#[doc(alias = "GtkConstraintAttribute")]
3388pub enum ConstraintAttribute {
3389    /// No attribute, used for constant
3390    ///   relations
3391    #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_NONE")]
3392    None,
3393    /// The left edge of a widget, regardless of
3394    ///   text direction
3395    #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_LEFT")]
3396    Left,
3397    /// The right edge of a widget, regardless
3398    ///   of text direction
3399    #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_RIGHT")]
3400    Right,
3401    /// The top edge of a widget
3402    #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_TOP")]
3403    Top,
3404    /// The bottom edge of a widget
3405    #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_BOTTOM")]
3406    Bottom,
3407    /// The leading edge of a widget, depending
3408    ///   on text direction; equivalent to [`Left`][Self::Left] for LTR
3409    ///   languages, and [`Right`][Self::Right] for RTL ones
3410    #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_START")]
3411    Start,
3412    /// The trailing edge of a widget, depending
3413    ///   on text direction; equivalent to [`Right`][Self::Right] for LTR
3414    ///   languages, and [`Left`][Self::Left] for RTL ones
3415    #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_END")]
3416    End,
3417    /// The width of a widget
3418    #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_WIDTH")]
3419    Width,
3420    /// The height of a widget
3421    #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_HEIGHT")]
3422    Height,
3423    /// The center of a widget, on the
3424    ///   horizontal axis
3425    #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_CENTER_X")]
3426    CenterX,
3427    /// The center of a widget, on the
3428    ///   vertical axis
3429    #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_CENTER_Y")]
3430    CenterY,
3431    /// The baseline of a widget
3432    #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_BASELINE")]
3433    Baseline,
3434    #[doc(hidden)]
3435    __Unknown(i32),
3436}
3437
3438#[doc(hidden)]
3439impl IntoGlib for ConstraintAttribute {
3440    type GlibType = ffi::GtkConstraintAttribute;
3441
3442    #[inline]
3443    fn into_glib(self) -> ffi::GtkConstraintAttribute {
3444        match self {
3445            Self::None => ffi::GTK_CONSTRAINT_ATTRIBUTE_NONE,
3446            Self::Left => ffi::GTK_CONSTRAINT_ATTRIBUTE_LEFT,
3447            Self::Right => ffi::GTK_CONSTRAINT_ATTRIBUTE_RIGHT,
3448            Self::Top => ffi::GTK_CONSTRAINT_ATTRIBUTE_TOP,
3449            Self::Bottom => ffi::GTK_CONSTRAINT_ATTRIBUTE_BOTTOM,
3450            Self::Start => ffi::GTK_CONSTRAINT_ATTRIBUTE_START,
3451            Self::End => ffi::GTK_CONSTRAINT_ATTRIBUTE_END,
3452            Self::Width => ffi::GTK_CONSTRAINT_ATTRIBUTE_WIDTH,
3453            Self::Height => ffi::GTK_CONSTRAINT_ATTRIBUTE_HEIGHT,
3454            Self::CenterX => ffi::GTK_CONSTRAINT_ATTRIBUTE_CENTER_X,
3455            Self::CenterY => ffi::GTK_CONSTRAINT_ATTRIBUTE_CENTER_Y,
3456            Self::Baseline => ffi::GTK_CONSTRAINT_ATTRIBUTE_BASELINE,
3457            Self::__Unknown(value) => value,
3458        }
3459    }
3460}
3461
3462#[doc(hidden)]
3463impl FromGlib<ffi::GtkConstraintAttribute> for ConstraintAttribute {
3464    #[inline]
3465    unsafe fn from_glib(value: ffi::GtkConstraintAttribute) -> Self {
3466        skip_assert_initialized!();
3467
3468        match value {
3469            ffi::GTK_CONSTRAINT_ATTRIBUTE_NONE => Self::None,
3470            ffi::GTK_CONSTRAINT_ATTRIBUTE_LEFT => Self::Left,
3471            ffi::GTK_CONSTRAINT_ATTRIBUTE_RIGHT => Self::Right,
3472            ffi::GTK_CONSTRAINT_ATTRIBUTE_TOP => Self::Top,
3473            ffi::GTK_CONSTRAINT_ATTRIBUTE_BOTTOM => Self::Bottom,
3474            ffi::GTK_CONSTRAINT_ATTRIBUTE_START => Self::Start,
3475            ffi::GTK_CONSTRAINT_ATTRIBUTE_END => Self::End,
3476            ffi::GTK_CONSTRAINT_ATTRIBUTE_WIDTH => Self::Width,
3477            ffi::GTK_CONSTRAINT_ATTRIBUTE_HEIGHT => Self::Height,
3478            ffi::GTK_CONSTRAINT_ATTRIBUTE_CENTER_X => Self::CenterX,
3479            ffi::GTK_CONSTRAINT_ATTRIBUTE_CENTER_Y => Self::CenterY,
3480            ffi::GTK_CONSTRAINT_ATTRIBUTE_BASELINE => Self::Baseline,
3481            value => Self::__Unknown(value),
3482        }
3483    }
3484}
3485
3486impl StaticType for ConstraintAttribute {
3487    #[inline]
3488    #[doc(alias = "gtk_constraint_attribute_get_type")]
3489    fn static_type() -> glib::Type {
3490        unsafe { from_glib(ffi::gtk_constraint_attribute_get_type()) }
3491    }
3492}
3493
3494impl glib::HasParamSpec for ConstraintAttribute {
3495    type ParamSpec = glib::ParamSpecEnum;
3496    type SetValue = Self;
3497    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3498
3499    fn param_spec_builder() -> Self::BuilderFn {
3500        Self::ParamSpec::builder_with_default
3501    }
3502}
3503
3504impl glib::value::ValueType for ConstraintAttribute {
3505    type Type = Self;
3506}
3507
3508unsafe impl<'a> glib::value::FromValue<'a> for ConstraintAttribute {
3509    type Checker = glib::value::GenericValueTypeChecker<Self>;
3510
3511    #[inline]
3512    unsafe fn from_value(value: &'a glib::Value) -> Self {
3513        skip_assert_initialized!();
3514        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3515    }
3516}
3517
3518impl ToValue for ConstraintAttribute {
3519    #[inline]
3520    fn to_value(&self) -> glib::Value {
3521        let mut value = glib::Value::for_value_type::<Self>();
3522        unsafe {
3523            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3524        }
3525        value
3526    }
3527
3528    #[inline]
3529    fn value_type(&self) -> glib::Type {
3530        Self::static_type()
3531    }
3532}
3533
3534impl From<ConstraintAttribute> for glib::Value {
3535    #[inline]
3536    fn from(v: ConstraintAttribute) -> Self {
3537        skip_assert_initialized!();
3538        ToValue::to_value(&v)
3539    }
3540}
3541
3542/// The relation between two terms of a constraint.
3543#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3544#[non_exhaustive]
3545#[doc(alias = "GtkConstraintRelation")]
3546pub enum ConstraintRelation {
3547    /// Less than, or equal
3548    #[doc(alias = "GTK_CONSTRAINT_RELATION_LE")]
3549    Le,
3550    /// Equal
3551    #[doc(alias = "GTK_CONSTRAINT_RELATION_EQ")]
3552    Eq,
3553    /// Greater than, or equal
3554    #[doc(alias = "GTK_CONSTRAINT_RELATION_GE")]
3555    Ge,
3556    #[doc(hidden)]
3557    __Unknown(i32),
3558}
3559
3560#[doc(hidden)]
3561impl IntoGlib for ConstraintRelation {
3562    type GlibType = ffi::GtkConstraintRelation;
3563
3564    #[inline]
3565    fn into_glib(self) -> ffi::GtkConstraintRelation {
3566        match self {
3567            Self::Le => ffi::GTK_CONSTRAINT_RELATION_LE,
3568            Self::Eq => ffi::GTK_CONSTRAINT_RELATION_EQ,
3569            Self::Ge => ffi::GTK_CONSTRAINT_RELATION_GE,
3570            Self::__Unknown(value) => value,
3571        }
3572    }
3573}
3574
3575#[doc(hidden)]
3576impl FromGlib<ffi::GtkConstraintRelation> for ConstraintRelation {
3577    #[inline]
3578    unsafe fn from_glib(value: ffi::GtkConstraintRelation) -> Self {
3579        skip_assert_initialized!();
3580
3581        match value {
3582            ffi::GTK_CONSTRAINT_RELATION_LE => Self::Le,
3583            ffi::GTK_CONSTRAINT_RELATION_EQ => Self::Eq,
3584            ffi::GTK_CONSTRAINT_RELATION_GE => Self::Ge,
3585            value => Self::__Unknown(value),
3586        }
3587    }
3588}
3589
3590impl StaticType for ConstraintRelation {
3591    #[inline]
3592    #[doc(alias = "gtk_constraint_relation_get_type")]
3593    fn static_type() -> glib::Type {
3594        unsafe { from_glib(ffi::gtk_constraint_relation_get_type()) }
3595    }
3596}
3597
3598impl glib::HasParamSpec for ConstraintRelation {
3599    type ParamSpec = glib::ParamSpecEnum;
3600    type SetValue = Self;
3601    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3602
3603    fn param_spec_builder() -> Self::BuilderFn {
3604        Self::ParamSpec::builder_with_default
3605    }
3606}
3607
3608impl glib::value::ValueType for ConstraintRelation {
3609    type Type = Self;
3610}
3611
3612unsafe impl<'a> glib::value::FromValue<'a> for ConstraintRelation {
3613    type Checker = glib::value::GenericValueTypeChecker<Self>;
3614
3615    #[inline]
3616    unsafe fn from_value(value: &'a glib::Value) -> Self {
3617        skip_assert_initialized!();
3618        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3619    }
3620}
3621
3622impl ToValue for ConstraintRelation {
3623    #[inline]
3624    fn to_value(&self) -> glib::Value {
3625        let mut value = glib::Value::for_value_type::<Self>();
3626        unsafe {
3627            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3628        }
3629        value
3630    }
3631
3632    #[inline]
3633    fn value_type(&self) -> glib::Type {
3634        Self::static_type()
3635    }
3636}
3637
3638impl From<ConstraintRelation> for glib::Value {
3639    #[inline]
3640    fn from(v: ConstraintRelation) -> Self {
3641        skip_assert_initialized!();
3642        ToValue::to_value(&v)
3643    }
3644}
3645
3646/// The strength of a constraint, expressed as a symbolic constant.
3647///
3648/// The strength of a [`Constraint`][crate::Constraint] can be expressed with any positive
3649/// integer; the values of this enumeration can be used for readability.
3650#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3651#[non_exhaustive]
3652#[doc(alias = "GtkConstraintStrength")]
3653pub enum ConstraintStrength {
3654    /// The constraint is required towards solving the layout
3655    #[doc(alias = "GTK_CONSTRAINT_STRENGTH_REQUIRED")]
3656    Required,
3657    /// A strong constraint
3658    #[doc(alias = "GTK_CONSTRAINT_STRENGTH_STRONG")]
3659    Strong,
3660    /// A medium constraint
3661    #[doc(alias = "GTK_CONSTRAINT_STRENGTH_MEDIUM")]
3662    Medium,
3663    /// A weak constraint
3664    #[doc(alias = "GTK_CONSTRAINT_STRENGTH_WEAK")]
3665    Weak,
3666    #[doc(hidden)]
3667    __Unknown(i32),
3668}
3669
3670#[doc(hidden)]
3671impl IntoGlib for ConstraintStrength {
3672    type GlibType = ffi::GtkConstraintStrength;
3673
3674    #[inline]
3675    fn into_glib(self) -> ffi::GtkConstraintStrength {
3676        match self {
3677            Self::Required => ffi::GTK_CONSTRAINT_STRENGTH_REQUIRED,
3678            Self::Strong => ffi::GTK_CONSTRAINT_STRENGTH_STRONG,
3679            Self::Medium => ffi::GTK_CONSTRAINT_STRENGTH_MEDIUM,
3680            Self::Weak => ffi::GTK_CONSTRAINT_STRENGTH_WEAK,
3681            Self::__Unknown(value) => value,
3682        }
3683    }
3684}
3685
3686#[doc(hidden)]
3687impl FromGlib<ffi::GtkConstraintStrength> for ConstraintStrength {
3688    #[inline]
3689    unsafe fn from_glib(value: ffi::GtkConstraintStrength) -> Self {
3690        skip_assert_initialized!();
3691
3692        match value {
3693            ffi::GTK_CONSTRAINT_STRENGTH_REQUIRED => Self::Required,
3694            ffi::GTK_CONSTRAINT_STRENGTH_STRONG => Self::Strong,
3695            ffi::GTK_CONSTRAINT_STRENGTH_MEDIUM => Self::Medium,
3696            ffi::GTK_CONSTRAINT_STRENGTH_WEAK => Self::Weak,
3697            value => Self::__Unknown(value),
3698        }
3699    }
3700}
3701
3702impl StaticType for ConstraintStrength {
3703    #[inline]
3704    #[doc(alias = "gtk_constraint_strength_get_type")]
3705    fn static_type() -> glib::Type {
3706        unsafe { from_glib(ffi::gtk_constraint_strength_get_type()) }
3707    }
3708}
3709
3710impl glib::HasParamSpec for ConstraintStrength {
3711    type ParamSpec = glib::ParamSpecEnum;
3712    type SetValue = Self;
3713    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3714
3715    fn param_spec_builder() -> Self::BuilderFn {
3716        Self::ParamSpec::builder_with_default
3717    }
3718}
3719
3720impl glib::value::ValueType for ConstraintStrength {
3721    type Type = Self;
3722}
3723
3724unsafe impl<'a> glib::value::FromValue<'a> for ConstraintStrength {
3725    type Checker = glib::value::GenericValueTypeChecker<Self>;
3726
3727    #[inline]
3728    unsafe fn from_value(value: &'a glib::Value) -> Self {
3729        skip_assert_initialized!();
3730        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3731    }
3732}
3733
3734impl ToValue for ConstraintStrength {
3735    #[inline]
3736    fn to_value(&self) -> glib::Value {
3737        let mut value = glib::Value::for_value_type::<Self>();
3738        unsafe {
3739            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3740        }
3741        value
3742    }
3743
3744    #[inline]
3745    fn value_type(&self) -> glib::Type {
3746        Self::static_type()
3747    }
3748}
3749
3750impl From<ConstraintStrength> for glib::Value {
3751    #[inline]
3752    fn from(v: ConstraintStrength) -> Self {
3753        skip_assert_initialized!();
3754        ToValue::to_value(&v)
3755    }
3756}
3757
3758/// Domain for VFL parsing errors.
3759#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3760#[non_exhaustive]
3761#[doc(alias = "GtkConstraintVflParserError")]
3762pub enum ConstraintVflParserError {
3763    /// Invalid or unknown symbol
3764    #[doc(alias = "GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_SYMBOL")]
3765    Symbol,
3766    /// Invalid or unknown attribute
3767    #[doc(alias = "GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_ATTRIBUTE")]
3768    Attribute,
3769    /// Invalid or unknown view
3770    #[doc(alias = "GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_VIEW")]
3771    View,
3772    /// Invalid or unknown metric
3773    #[doc(alias = "GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_METRIC")]
3774    Metric,
3775    /// Invalid or unknown priority
3776    #[doc(alias = "GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_PRIORITY")]
3777    Priority,
3778    /// Invalid or unknown relation
3779    #[doc(alias = "GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_RELATION")]
3780    Relation,
3781    #[doc(hidden)]
3782    __Unknown(i32),
3783}
3784
3785#[doc(hidden)]
3786impl IntoGlib for ConstraintVflParserError {
3787    type GlibType = ffi::GtkConstraintVflParserError;
3788
3789    #[inline]
3790    fn into_glib(self) -> ffi::GtkConstraintVflParserError {
3791        match self {
3792            Self::Symbol => ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_SYMBOL,
3793            Self::Attribute => ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_ATTRIBUTE,
3794            Self::View => ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_VIEW,
3795            Self::Metric => ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_METRIC,
3796            Self::Priority => ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_PRIORITY,
3797            Self::Relation => ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_RELATION,
3798            Self::__Unknown(value) => value,
3799        }
3800    }
3801}
3802
3803#[doc(hidden)]
3804impl FromGlib<ffi::GtkConstraintVflParserError> for ConstraintVflParserError {
3805    #[inline]
3806    unsafe fn from_glib(value: ffi::GtkConstraintVflParserError) -> Self {
3807        skip_assert_initialized!();
3808
3809        match value {
3810            ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_SYMBOL => Self::Symbol,
3811            ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_ATTRIBUTE => Self::Attribute,
3812            ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_VIEW => Self::View,
3813            ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_METRIC => Self::Metric,
3814            ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_PRIORITY => Self::Priority,
3815            ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_RELATION => Self::Relation,
3816            value => Self::__Unknown(value),
3817        }
3818    }
3819}
3820
3821impl glib::error::ErrorDomain for ConstraintVflParserError {
3822    #[inline]
3823    fn domain() -> glib::Quark {
3824        skip_assert_initialized!();
3825
3826        unsafe { from_glib(ffi::gtk_constraint_vfl_parser_error_quark()) }
3827    }
3828
3829    #[inline]
3830    fn code(self) -> i32 {
3831        self.into_glib()
3832    }
3833
3834    #[inline]
3835    #[allow(clippy::match_single_binding)]
3836    fn from(code: i32) -> Option<Self> {
3837        skip_assert_initialized!();
3838        match unsafe { from_glib(code) } {
3839            value => Some(value),
3840        }
3841    }
3842}
3843
3844impl StaticType for ConstraintVflParserError {
3845    #[inline]
3846    #[doc(alias = "gtk_constraint_vfl_parser_error_get_type")]
3847    fn static_type() -> glib::Type {
3848        unsafe { from_glib(ffi::gtk_constraint_vfl_parser_error_get_type()) }
3849    }
3850}
3851
3852impl glib::HasParamSpec for ConstraintVflParserError {
3853    type ParamSpec = glib::ParamSpecEnum;
3854    type SetValue = Self;
3855    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3856
3857    fn param_spec_builder() -> Self::BuilderFn {
3858        Self::ParamSpec::builder_with_default
3859    }
3860}
3861
3862impl glib::value::ValueType for ConstraintVflParserError {
3863    type Type = Self;
3864}
3865
3866unsafe impl<'a> glib::value::FromValue<'a> for ConstraintVflParserError {
3867    type Checker = glib::value::GenericValueTypeChecker<Self>;
3868
3869    #[inline]
3870    unsafe fn from_value(value: &'a glib::Value) -> Self {
3871        skip_assert_initialized!();
3872        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3873    }
3874}
3875
3876impl ToValue for ConstraintVflParserError {
3877    #[inline]
3878    fn to_value(&self) -> glib::Value {
3879        let mut value = glib::Value::for_value_type::<Self>();
3880        unsafe {
3881            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3882        }
3883        value
3884    }
3885
3886    #[inline]
3887    fn value_type(&self) -> glib::Type {
3888        Self::static_type()
3889    }
3890}
3891
3892impl From<ConstraintVflParserError> for glib::Value {
3893    #[inline]
3894    fn from(v: ConstraintVflParserError) -> Self {
3895        skip_assert_initialized!();
3896        ToValue::to_value(&v)
3897    }
3898}
3899
3900/// Controls how a content should be made to fit inside an allocation.
3901#[cfg(feature = "v4_8")]
3902#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
3903#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3904#[non_exhaustive]
3905#[doc(alias = "GtkContentFit")]
3906pub enum ContentFit {
3907    /// Make the content fill the entire allocation,
3908    ///   without taking its aspect ratio in consideration. The resulting
3909    ///   content will appear as stretched if its aspect ratio is different
3910    ///   from the allocation aspect ratio.
3911    #[doc(alias = "GTK_CONTENT_FIT_FILL")]
3912    Fill,
3913    /// Scale the content to fit the allocation,
3914    ///   while taking its aspect ratio in consideration. The resulting
3915    ///   content will appear as letterboxed if its aspect ratio is different
3916    ///   from the allocation aspect ratio.
3917    #[doc(alias = "GTK_CONTENT_FIT_CONTAIN")]
3918    Contain,
3919    /// Cover the entire allocation, while taking
3920    ///   the content aspect ratio in consideration. The resulting content
3921    ///   will appear as clipped if its aspect ratio is different from the
3922    ///   allocation aspect ratio.
3923    #[doc(alias = "GTK_CONTENT_FIT_COVER")]
3924    Cover,
3925    /// The content is scaled down to fit the
3926    ///   allocation, if needed, otherwise its original size is used.
3927    #[doc(alias = "GTK_CONTENT_FIT_SCALE_DOWN")]
3928    ScaleDown,
3929    #[doc(hidden)]
3930    __Unknown(i32),
3931}
3932
3933#[cfg(feature = "v4_8")]
3934#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
3935#[doc(hidden)]
3936impl IntoGlib for ContentFit {
3937    type GlibType = ffi::GtkContentFit;
3938
3939    #[inline]
3940    fn into_glib(self) -> ffi::GtkContentFit {
3941        match self {
3942            Self::Fill => ffi::GTK_CONTENT_FIT_FILL,
3943            Self::Contain => ffi::GTK_CONTENT_FIT_CONTAIN,
3944            Self::Cover => ffi::GTK_CONTENT_FIT_COVER,
3945            Self::ScaleDown => ffi::GTK_CONTENT_FIT_SCALE_DOWN,
3946            Self::__Unknown(value) => value,
3947        }
3948    }
3949}
3950
3951#[cfg(feature = "v4_8")]
3952#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
3953#[doc(hidden)]
3954impl FromGlib<ffi::GtkContentFit> for ContentFit {
3955    #[inline]
3956    unsafe fn from_glib(value: ffi::GtkContentFit) -> Self {
3957        skip_assert_initialized!();
3958
3959        match value {
3960            ffi::GTK_CONTENT_FIT_FILL => Self::Fill,
3961            ffi::GTK_CONTENT_FIT_CONTAIN => Self::Contain,
3962            ffi::GTK_CONTENT_FIT_COVER => Self::Cover,
3963            ffi::GTK_CONTENT_FIT_SCALE_DOWN => Self::ScaleDown,
3964            value => Self::__Unknown(value),
3965        }
3966    }
3967}
3968
3969#[cfg(feature = "v4_8")]
3970#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
3971impl StaticType for ContentFit {
3972    #[inline]
3973    #[doc(alias = "gtk_content_fit_get_type")]
3974    fn static_type() -> glib::Type {
3975        unsafe { from_glib(ffi::gtk_content_fit_get_type()) }
3976    }
3977}
3978
3979#[cfg(feature = "v4_8")]
3980#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
3981impl glib::HasParamSpec for ContentFit {
3982    type ParamSpec = glib::ParamSpecEnum;
3983    type SetValue = Self;
3984    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3985
3986    fn param_spec_builder() -> Self::BuilderFn {
3987        Self::ParamSpec::builder_with_default
3988    }
3989}
3990
3991#[cfg(feature = "v4_8")]
3992#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
3993impl glib::value::ValueType for ContentFit {
3994    type Type = Self;
3995}
3996
3997#[cfg(feature = "v4_8")]
3998#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
3999unsafe impl<'a> glib::value::FromValue<'a> for ContentFit {
4000    type Checker = glib::value::GenericValueTypeChecker<Self>;
4001
4002    #[inline]
4003    unsafe fn from_value(value: &'a glib::Value) -> Self {
4004        skip_assert_initialized!();
4005        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4006    }
4007}
4008
4009#[cfg(feature = "v4_8")]
4010#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
4011impl ToValue for ContentFit {
4012    #[inline]
4013    fn to_value(&self) -> glib::Value {
4014        let mut value = glib::Value::for_value_type::<Self>();
4015        unsafe {
4016            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4017        }
4018        value
4019    }
4020
4021    #[inline]
4022    fn value_type(&self) -> glib::Type {
4023        Self::static_type()
4024    }
4025}
4026
4027#[cfg(feature = "v4_8")]
4028#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
4029impl From<ContentFit> for glib::Value {
4030    #[inline]
4031    fn from(v: ContentFit) -> Self {
4032        skip_assert_initialized!();
4033        ToValue::to_value(&v)
4034    }
4035}
4036
4037/// Specifies which corner a child widget should be placed in when packed into
4038/// a [`ScrolledWindow`][crate::ScrolledWindow]
4039///
4040/// This is effectively the opposite of where the scroll bars are placed.
4041#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4042#[non_exhaustive]
4043#[doc(alias = "GtkCornerType")]
4044pub enum CornerType {
4045    /// Place the scrollbars on the right and bottom of the
4046    ///   widget (default behaviour).
4047    #[doc(alias = "GTK_CORNER_TOP_LEFT")]
4048    TopLeft,
4049    /// Place the scrollbars on the top and right of the
4050    ///   widget.
4051    #[doc(alias = "GTK_CORNER_BOTTOM_LEFT")]
4052    BottomLeft,
4053    /// Place the scrollbars on the left and bottom of the
4054    ///   widget.
4055    #[doc(alias = "GTK_CORNER_TOP_RIGHT")]
4056    TopRight,
4057    /// Place the scrollbars on the top and left of the
4058    ///   widget.
4059    #[doc(alias = "GTK_CORNER_BOTTOM_RIGHT")]
4060    BottomRight,
4061    #[doc(hidden)]
4062    __Unknown(i32),
4063}
4064
4065#[doc(hidden)]
4066impl IntoGlib for CornerType {
4067    type GlibType = ffi::GtkCornerType;
4068
4069    #[inline]
4070    fn into_glib(self) -> ffi::GtkCornerType {
4071        match self {
4072            Self::TopLeft => ffi::GTK_CORNER_TOP_LEFT,
4073            Self::BottomLeft => ffi::GTK_CORNER_BOTTOM_LEFT,
4074            Self::TopRight => ffi::GTK_CORNER_TOP_RIGHT,
4075            Self::BottomRight => ffi::GTK_CORNER_BOTTOM_RIGHT,
4076            Self::__Unknown(value) => value,
4077        }
4078    }
4079}
4080
4081#[doc(hidden)]
4082impl FromGlib<ffi::GtkCornerType> for CornerType {
4083    #[inline]
4084    unsafe fn from_glib(value: ffi::GtkCornerType) -> Self {
4085        skip_assert_initialized!();
4086
4087        match value {
4088            ffi::GTK_CORNER_TOP_LEFT => Self::TopLeft,
4089            ffi::GTK_CORNER_BOTTOM_LEFT => Self::BottomLeft,
4090            ffi::GTK_CORNER_TOP_RIGHT => Self::TopRight,
4091            ffi::GTK_CORNER_BOTTOM_RIGHT => Self::BottomRight,
4092            value => Self::__Unknown(value),
4093        }
4094    }
4095}
4096
4097impl StaticType for CornerType {
4098    #[inline]
4099    #[doc(alias = "gtk_corner_type_get_type")]
4100    fn static_type() -> glib::Type {
4101        unsafe { from_glib(ffi::gtk_corner_type_get_type()) }
4102    }
4103}
4104
4105impl glib::HasParamSpec for CornerType {
4106    type ParamSpec = glib::ParamSpecEnum;
4107    type SetValue = Self;
4108    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4109
4110    fn param_spec_builder() -> Self::BuilderFn {
4111        Self::ParamSpec::builder_with_default
4112    }
4113}
4114
4115impl glib::value::ValueType for CornerType {
4116    type Type = Self;
4117}
4118
4119unsafe impl<'a> glib::value::FromValue<'a> for CornerType {
4120    type Checker = glib::value::GenericValueTypeChecker<Self>;
4121
4122    #[inline]
4123    unsafe fn from_value(value: &'a glib::Value) -> Self {
4124        skip_assert_initialized!();
4125        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4126    }
4127}
4128
4129impl ToValue for CornerType {
4130    #[inline]
4131    fn to_value(&self) -> glib::Value {
4132        let mut value = glib::Value::for_value_type::<Self>();
4133        unsafe {
4134            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4135        }
4136        value
4137    }
4138
4139    #[inline]
4140    fn value_type(&self) -> glib::Type {
4141        Self::static_type()
4142    }
4143}
4144
4145impl From<CornerType> for glib::Value {
4146    #[inline]
4147    fn from(v: CornerType) -> Self {
4148        skip_assert_initialized!();
4149        ToValue::to_value(&v)
4150    }
4151}
4152
4153/// Errors that can occur while parsing CSS.
4154///
4155/// These errors are unexpected and will cause parts of the given CSS
4156/// to be ignored.
4157#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4158#[non_exhaustive]
4159#[doc(alias = "GtkCssParserError")]
4160pub enum CssParserError {
4161    /// Unknown failure.
4162    #[doc(alias = "GTK_CSS_PARSER_ERROR_FAILED")]
4163    Failed,
4164    /// The given text does not form valid syntax
4165    #[doc(alias = "GTK_CSS_PARSER_ERROR_SYNTAX")]
4166    Syntax,
4167    /// Failed to import a resource
4168    #[doc(alias = "GTK_CSS_PARSER_ERROR_IMPORT")]
4169    Import,
4170    /// The given name has not been defined
4171    #[doc(alias = "GTK_CSS_PARSER_ERROR_NAME")]
4172    Name,
4173    /// The given value is not correct
4174    #[doc(alias = "GTK_CSS_PARSER_ERROR_UNKNOWN_VALUE")]
4175    UnknownValue,
4176    #[doc(hidden)]
4177    __Unknown(i32),
4178}
4179
4180#[doc(hidden)]
4181impl IntoGlib for CssParserError {
4182    type GlibType = ffi::GtkCssParserError;
4183
4184    #[inline]
4185    fn into_glib(self) -> ffi::GtkCssParserError {
4186        match self {
4187            Self::Failed => ffi::GTK_CSS_PARSER_ERROR_FAILED,
4188            Self::Syntax => ffi::GTK_CSS_PARSER_ERROR_SYNTAX,
4189            Self::Import => ffi::GTK_CSS_PARSER_ERROR_IMPORT,
4190            Self::Name => ffi::GTK_CSS_PARSER_ERROR_NAME,
4191            Self::UnknownValue => ffi::GTK_CSS_PARSER_ERROR_UNKNOWN_VALUE,
4192            Self::__Unknown(value) => value,
4193        }
4194    }
4195}
4196
4197#[doc(hidden)]
4198impl FromGlib<ffi::GtkCssParserError> for CssParserError {
4199    #[inline]
4200    unsafe fn from_glib(value: ffi::GtkCssParserError) -> Self {
4201        skip_assert_initialized!();
4202
4203        match value {
4204            ffi::GTK_CSS_PARSER_ERROR_FAILED => Self::Failed,
4205            ffi::GTK_CSS_PARSER_ERROR_SYNTAX => Self::Syntax,
4206            ffi::GTK_CSS_PARSER_ERROR_IMPORT => Self::Import,
4207            ffi::GTK_CSS_PARSER_ERROR_NAME => Self::Name,
4208            ffi::GTK_CSS_PARSER_ERROR_UNKNOWN_VALUE => Self::UnknownValue,
4209            value => Self::__Unknown(value),
4210        }
4211    }
4212}
4213
4214impl glib::error::ErrorDomain for CssParserError {
4215    #[inline]
4216    fn domain() -> glib::Quark {
4217        skip_assert_initialized!();
4218
4219        unsafe { from_glib(ffi::gtk_css_parser_error_quark()) }
4220    }
4221
4222    #[inline]
4223    fn code(self) -> i32 {
4224        self.into_glib()
4225    }
4226
4227    #[inline]
4228    #[allow(clippy::match_single_binding)]
4229    fn from(code: i32) -> Option<Self> {
4230        skip_assert_initialized!();
4231        match unsafe { from_glib(code) } {
4232            Self::__Unknown(_) => Some(Self::Failed),
4233            value => Some(value),
4234        }
4235    }
4236}
4237
4238/// Warnings that can occur while parsing CSS.
4239///
4240/// Unlike [`CssParserError`][crate::CssParserError]s, warnings do not cause the parser to
4241/// skip any input, but they indicate issues that should be fixed.
4242#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4243#[non_exhaustive]
4244#[doc(alias = "GtkCssParserWarning")]
4245pub enum CssParserWarning {
4246    /// The given construct is
4247    ///   deprecated and will be removed in a future version
4248    #[doc(alias = "GTK_CSS_PARSER_WARNING_DEPRECATED")]
4249    Deprecated,
4250    /// A syntax construct was used
4251    ///   that should be avoided
4252    #[doc(alias = "GTK_CSS_PARSER_WARNING_SYNTAX")]
4253    Syntax,
4254    /// A feature is not implemented
4255    #[doc(alias = "GTK_CSS_PARSER_WARNING_UNIMPLEMENTED")]
4256    Unimplemented,
4257    #[doc(hidden)]
4258    __Unknown(i32),
4259}
4260
4261#[doc(hidden)]
4262impl IntoGlib for CssParserWarning {
4263    type GlibType = ffi::GtkCssParserWarning;
4264
4265    #[inline]
4266    fn into_glib(self) -> ffi::GtkCssParserWarning {
4267        match self {
4268            Self::Deprecated => ffi::GTK_CSS_PARSER_WARNING_DEPRECATED,
4269            Self::Syntax => ffi::GTK_CSS_PARSER_WARNING_SYNTAX,
4270            Self::Unimplemented => ffi::GTK_CSS_PARSER_WARNING_UNIMPLEMENTED,
4271            Self::__Unknown(value) => value,
4272        }
4273    }
4274}
4275
4276#[doc(hidden)]
4277impl FromGlib<ffi::GtkCssParserWarning> for CssParserWarning {
4278    #[inline]
4279    unsafe fn from_glib(value: ffi::GtkCssParserWarning) -> Self {
4280        skip_assert_initialized!();
4281
4282        match value {
4283            ffi::GTK_CSS_PARSER_WARNING_DEPRECATED => Self::Deprecated,
4284            ffi::GTK_CSS_PARSER_WARNING_SYNTAX => Self::Syntax,
4285            ffi::GTK_CSS_PARSER_WARNING_UNIMPLEMENTED => Self::Unimplemented,
4286            value => Self::__Unknown(value),
4287        }
4288    }
4289}
4290
4291/// Passed to various keybinding signals for deleting text.
4292#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4293#[non_exhaustive]
4294#[doc(alias = "GtkDeleteType")]
4295pub enum DeleteType {
4296    /// Delete characters.
4297    #[doc(alias = "GTK_DELETE_CHARS")]
4298    Chars,
4299    /// Delete only the portion of the word to the
4300    ///   left/right of cursor if we’re in the middle of a word.
4301    #[doc(alias = "GTK_DELETE_WORD_ENDS")]
4302    WordEnds,
4303    /// Delete words.
4304    #[doc(alias = "GTK_DELETE_WORDS")]
4305    Words,
4306    /// Delete display-lines. Display-lines
4307    ///   refers to the visible lines, with respect to the current line
4308    ///   breaks. As opposed to paragraphs, which are defined by line
4309    ///   breaks in the input.
4310    #[doc(alias = "GTK_DELETE_DISPLAY_LINES")]
4311    DisplayLines,
4312    /// Delete only the portion of the
4313    ///   display-line to the left/right of cursor.
4314    #[doc(alias = "GTK_DELETE_DISPLAY_LINE_ENDS")]
4315    DisplayLineEnds,
4316    /// Delete to the end of the
4317    ///   paragraph. Like C-k in Emacs (or its reverse).
4318    #[doc(alias = "GTK_DELETE_PARAGRAPH_ENDS")]
4319    ParagraphEnds,
4320    /// Delete entire line. Like C-k in pico.
4321    #[doc(alias = "GTK_DELETE_PARAGRAPHS")]
4322    Paragraphs,
4323    /// Delete only whitespace. Like M-\ in Emacs.
4324    #[doc(alias = "GTK_DELETE_WHITESPACE")]
4325    Whitespace,
4326    #[doc(hidden)]
4327    __Unknown(i32),
4328}
4329
4330#[doc(hidden)]
4331impl IntoGlib for DeleteType {
4332    type GlibType = ffi::GtkDeleteType;
4333
4334    #[inline]
4335    fn into_glib(self) -> ffi::GtkDeleteType {
4336        match self {
4337            Self::Chars => ffi::GTK_DELETE_CHARS,
4338            Self::WordEnds => ffi::GTK_DELETE_WORD_ENDS,
4339            Self::Words => ffi::GTK_DELETE_WORDS,
4340            Self::DisplayLines => ffi::GTK_DELETE_DISPLAY_LINES,
4341            Self::DisplayLineEnds => ffi::GTK_DELETE_DISPLAY_LINE_ENDS,
4342            Self::ParagraphEnds => ffi::GTK_DELETE_PARAGRAPH_ENDS,
4343            Self::Paragraphs => ffi::GTK_DELETE_PARAGRAPHS,
4344            Self::Whitespace => ffi::GTK_DELETE_WHITESPACE,
4345            Self::__Unknown(value) => value,
4346        }
4347    }
4348}
4349
4350#[doc(hidden)]
4351impl FromGlib<ffi::GtkDeleteType> for DeleteType {
4352    #[inline]
4353    unsafe fn from_glib(value: ffi::GtkDeleteType) -> Self {
4354        skip_assert_initialized!();
4355
4356        match value {
4357            ffi::GTK_DELETE_CHARS => Self::Chars,
4358            ffi::GTK_DELETE_WORD_ENDS => Self::WordEnds,
4359            ffi::GTK_DELETE_WORDS => Self::Words,
4360            ffi::GTK_DELETE_DISPLAY_LINES => Self::DisplayLines,
4361            ffi::GTK_DELETE_DISPLAY_LINE_ENDS => Self::DisplayLineEnds,
4362            ffi::GTK_DELETE_PARAGRAPH_ENDS => Self::ParagraphEnds,
4363            ffi::GTK_DELETE_PARAGRAPHS => Self::Paragraphs,
4364            ffi::GTK_DELETE_WHITESPACE => Self::Whitespace,
4365            value => Self::__Unknown(value),
4366        }
4367    }
4368}
4369
4370impl StaticType for DeleteType {
4371    #[inline]
4372    #[doc(alias = "gtk_delete_type_get_type")]
4373    fn static_type() -> glib::Type {
4374        unsafe { from_glib(ffi::gtk_delete_type_get_type()) }
4375    }
4376}
4377
4378impl glib::HasParamSpec for DeleteType {
4379    type ParamSpec = glib::ParamSpecEnum;
4380    type SetValue = Self;
4381    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4382
4383    fn param_spec_builder() -> Self::BuilderFn {
4384        Self::ParamSpec::builder_with_default
4385    }
4386}
4387
4388impl glib::value::ValueType for DeleteType {
4389    type Type = Self;
4390}
4391
4392unsafe impl<'a> glib::value::FromValue<'a> for DeleteType {
4393    type Checker = glib::value::GenericValueTypeChecker<Self>;
4394
4395    #[inline]
4396    unsafe fn from_value(value: &'a glib::Value) -> Self {
4397        skip_assert_initialized!();
4398        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4399    }
4400}
4401
4402impl ToValue for DeleteType {
4403    #[inline]
4404    fn to_value(&self) -> glib::Value {
4405        let mut value = glib::Value::for_value_type::<Self>();
4406        unsafe {
4407            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4408        }
4409        value
4410    }
4411
4412    #[inline]
4413    fn value_type(&self) -> glib::Type {
4414        Self::static_type()
4415    }
4416}
4417
4418impl From<DeleteType> for glib::Value {
4419    #[inline]
4420    fn from(v: DeleteType) -> Self {
4421        skip_assert_initialized!();
4422        ToValue::to_value(&v)
4423    }
4424}
4425
4426/// Error codes in the `GTK_DIALOG_ERROR` domain that can be returned
4427/// by async dialog functions.
4428#[cfg(feature = "v4_10")]
4429#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
4430#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4431#[non_exhaustive]
4432#[doc(alias = "GtkDialogError")]
4433pub enum DialogError {
4434    /// Generic error condition for when
4435    ///   an operation fails and no more specific code is applicable
4436    #[doc(alias = "GTK_DIALOG_ERROR_FAILED")]
4437    Failed,
4438    /// The async function call was cancelled
4439    ///   via its `GCancellable`
4440    #[doc(alias = "GTK_DIALOG_ERROR_CANCELLED")]
4441    Cancelled,
4442    /// The operation was cancelled
4443    ///   by the user (via a Cancel or Close button)
4444    #[doc(alias = "GTK_DIALOG_ERROR_DISMISSED")]
4445    Dismissed,
4446    #[doc(hidden)]
4447    __Unknown(i32),
4448}
4449
4450#[cfg(feature = "v4_10")]
4451#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
4452#[doc(hidden)]
4453impl IntoGlib for DialogError {
4454    type GlibType = ffi::GtkDialogError;
4455
4456    #[inline]
4457    fn into_glib(self) -> ffi::GtkDialogError {
4458        match self {
4459            Self::Failed => ffi::GTK_DIALOG_ERROR_FAILED,
4460            Self::Cancelled => ffi::GTK_DIALOG_ERROR_CANCELLED,
4461            Self::Dismissed => ffi::GTK_DIALOG_ERROR_DISMISSED,
4462            Self::__Unknown(value) => value,
4463        }
4464    }
4465}
4466
4467#[cfg(feature = "v4_10")]
4468#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
4469#[doc(hidden)]
4470impl FromGlib<ffi::GtkDialogError> for DialogError {
4471    #[inline]
4472    unsafe fn from_glib(value: ffi::GtkDialogError) -> Self {
4473        skip_assert_initialized!();
4474
4475        match value {
4476            ffi::GTK_DIALOG_ERROR_FAILED => Self::Failed,
4477            ffi::GTK_DIALOG_ERROR_CANCELLED => Self::Cancelled,
4478            ffi::GTK_DIALOG_ERROR_DISMISSED => Self::Dismissed,
4479            value => Self::__Unknown(value),
4480        }
4481    }
4482}
4483
4484#[cfg(feature = "v4_10")]
4485#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
4486impl glib::error::ErrorDomain for DialogError {
4487    #[inline]
4488    fn domain() -> glib::Quark {
4489        skip_assert_initialized!();
4490
4491        unsafe { from_glib(ffi::gtk_dialog_error_quark()) }
4492    }
4493
4494    #[inline]
4495    fn code(self) -> i32 {
4496        self.into_glib()
4497    }
4498
4499    #[inline]
4500    #[allow(clippy::match_single_binding)]
4501    fn from(code: i32) -> Option<Self> {
4502        skip_assert_initialized!();
4503        match unsafe { from_glib(code) } {
4504            Self::__Unknown(_) => Some(Self::Failed),
4505            value => Some(value),
4506        }
4507    }
4508}
4509
4510#[cfg(feature = "v4_10")]
4511#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
4512impl StaticType for DialogError {
4513    #[inline]
4514    #[doc(alias = "gtk_dialog_error_get_type")]
4515    fn static_type() -> glib::Type {
4516        unsafe { from_glib(ffi::gtk_dialog_error_get_type()) }
4517    }
4518}
4519
4520#[cfg(feature = "v4_10")]
4521#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
4522impl glib::HasParamSpec for DialogError {
4523    type ParamSpec = glib::ParamSpecEnum;
4524    type SetValue = Self;
4525    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4526
4527    fn param_spec_builder() -> Self::BuilderFn {
4528        Self::ParamSpec::builder_with_default
4529    }
4530}
4531
4532#[cfg(feature = "v4_10")]
4533#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
4534impl glib::value::ValueType for DialogError {
4535    type Type = Self;
4536}
4537
4538#[cfg(feature = "v4_10")]
4539#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
4540unsafe impl<'a> glib::value::FromValue<'a> for DialogError {
4541    type Checker = glib::value::GenericValueTypeChecker<Self>;
4542
4543    #[inline]
4544    unsafe fn from_value(value: &'a glib::Value) -> Self {
4545        skip_assert_initialized!();
4546        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4547    }
4548}
4549
4550#[cfg(feature = "v4_10")]
4551#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
4552impl ToValue for DialogError {
4553    #[inline]
4554    fn to_value(&self) -> glib::Value {
4555        let mut value = glib::Value::for_value_type::<Self>();
4556        unsafe {
4557            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4558        }
4559        value
4560    }
4561
4562    #[inline]
4563    fn value_type(&self) -> glib::Type {
4564        Self::static_type()
4565    }
4566}
4567
4568#[cfg(feature = "v4_10")]
4569#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
4570impl From<DialogError> for glib::Value {
4571    #[inline]
4572    fn from(v: DialogError) -> Self {
4573        skip_assert_initialized!();
4574        ToValue::to_value(&v)
4575    }
4576}
4577
4578/// Focus movement types.
4579#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4580#[non_exhaustive]
4581#[doc(alias = "GtkDirectionType")]
4582pub enum DirectionType {
4583    /// Move forward.
4584    #[doc(alias = "GTK_DIR_TAB_FORWARD")]
4585    TabForward,
4586    /// Move backward.
4587    #[doc(alias = "GTK_DIR_TAB_BACKWARD")]
4588    TabBackward,
4589    /// Move up.
4590    #[doc(alias = "GTK_DIR_UP")]
4591    Up,
4592    /// Move down.
4593    #[doc(alias = "GTK_DIR_DOWN")]
4594    Down,
4595    /// Move left.
4596    #[doc(alias = "GTK_DIR_LEFT")]
4597    Left,
4598    /// Move right.
4599    #[doc(alias = "GTK_DIR_RIGHT")]
4600    Right,
4601    #[doc(hidden)]
4602    __Unknown(i32),
4603}
4604
4605#[doc(hidden)]
4606impl IntoGlib for DirectionType {
4607    type GlibType = ffi::GtkDirectionType;
4608
4609    #[inline]
4610    fn into_glib(self) -> ffi::GtkDirectionType {
4611        match self {
4612            Self::TabForward => ffi::GTK_DIR_TAB_FORWARD,
4613            Self::TabBackward => ffi::GTK_DIR_TAB_BACKWARD,
4614            Self::Up => ffi::GTK_DIR_UP,
4615            Self::Down => ffi::GTK_DIR_DOWN,
4616            Self::Left => ffi::GTK_DIR_LEFT,
4617            Self::Right => ffi::GTK_DIR_RIGHT,
4618            Self::__Unknown(value) => value,
4619        }
4620    }
4621}
4622
4623#[doc(hidden)]
4624impl FromGlib<ffi::GtkDirectionType> for DirectionType {
4625    #[inline]
4626    unsafe fn from_glib(value: ffi::GtkDirectionType) -> Self {
4627        skip_assert_initialized!();
4628
4629        match value {
4630            ffi::GTK_DIR_TAB_FORWARD => Self::TabForward,
4631            ffi::GTK_DIR_TAB_BACKWARD => Self::TabBackward,
4632            ffi::GTK_DIR_UP => Self::Up,
4633            ffi::GTK_DIR_DOWN => Self::Down,
4634            ffi::GTK_DIR_LEFT => Self::Left,
4635            ffi::GTK_DIR_RIGHT => Self::Right,
4636            value => Self::__Unknown(value),
4637        }
4638    }
4639}
4640
4641impl StaticType for DirectionType {
4642    #[inline]
4643    #[doc(alias = "gtk_direction_type_get_type")]
4644    fn static_type() -> glib::Type {
4645        unsafe { from_glib(ffi::gtk_direction_type_get_type()) }
4646    }
4647}
4648
4649impl glib::HasParamSpec for DirectionType {
4650    type ParamSpec = glib::ParamSpecEnum;
4651    type SetValue = Self;
4652    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4653
4654    fn param_spec_builder() -> Self::BuilderFn {
4655        Self::ParamSpec::builder_with_default
4656    }
4657}
4658
4659impl glib::value::ValueType for DirectionType {
4660    type Type = Self;
4661}
4662
4663unsafe impl<'a> glib::value::FromValue<'a> for DirectionType {
4664    type Checker = glib::value::GenericValueTypeChecker<Self>;
4665
4666    #[inline]
4667    unsafe fn from_value(value: &'a glib::Value) -> Self {
4668        skip_assert_initialized!();
4669        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4670    }
4671}
4672
4673impl ToValue for DirectionType {
4674    #[inline]
4675    fn to_value(&self) -> glib::Value {
4676        let mut value = glib::Value::for_value_type::<Self>();
4677        unsafe {
4678            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4679        }
4680        value
4681    }
4682
4683    #[inline]
4684    fn value_type(&self) -> glib::Type {
4685        Self::static_type()
4686    }
4687}
4688
4689impl From<DirectionType> for glib::Value {
4690    #[inline]
4691    fn from(v: DirectionType) -> Self {
4692        skip_assert_initialized!();
4693        ToValue::to_value(&v)
4694    }
4695}
4696
4697/// The identifiers for [`Editable`][crate::Editable] properties.
4698///
4699/// See [`Editable::install_properties()`][crate::Editable::install_properties()] for details on how to
4700/// implement the [`Editable`][crate::Editable] interface.
4701#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4702#[non_exhaustive]
4703#[doc(alias = "GtkEditableProperties")]
4704pub enum EditableProperties {
4705    /// the property id for [`text`][struct@crate::Editable#text]
4706    #[doc(alias = "GTK_EDITABLE_PROP_TEXT")]
4707    PropText,
4708    /// the property id for [`cursor-position`][struct@crate::Editable#cursor-position]
4709    #[doc(alias = "GTK_EDITABLE_PROP_CURSOR_POSITION")]
4710    PropCursorPosition,
4711    /// the property id for [`selection-bound`][struct@crate::Editable#selection-bound]
4712    #[doc(alias = "GTK_EDITABLE_PROP_SELECTION_BOUND")]
4713    PropSelectionBound,
4714    /// the property id for [`editable`][struct@crate::Editable#editable]
4715    #[doc(alias = "GTK_EDITABLE_PROP_EDITABLE")]
4716    PropEditable,
4717    /// the property id for [`width-chars`][struct@crate::Editable#width-chars]
4718    #[doc(alias = "GTK_EDITABLE_PROP_WIDTH_CHARS")]
4719    PropWidthChars,
4720    /// the property id for [`max-width-chars`][struct@crate::Editable#max-width-chars]
4721    #[doc(alias = "GTK_EDITABLE_PROP_MAX_WIDTH_CHARS")]
4722    PropMaxWidthChars,
4723    /// the property id for [`xalign`][struct@crate::Editable#xalign]
4724    #[doc(alias = "GTK_EDITABLE_PROP_XALIGN")]
4725    PropXalign,
4726    /// the property id for [`enable-undo`][struct@crate::Editable#enable-undo]
4727    #[doc(alias = "GTK_EDITABLE_PROP_ENABLE_UNDO")]
4728    PropEnableUndo,
4729    /// the number of properties
4730    #[doc(alias = "GTK_EDITABLE_NUM_PROPERTIES")]
4731    NumProperties,
4732    #[doc(hidden)]
4733    __Unknown(i32),
4734}
4735
4736#[doc(hidden)]
4737impl IntoGlib for EditableProperties {
4738    type GlibType = ffi::GtkEditableProperties;
4739
4740    #[inline]
4741    fn into_glib(self) -> ffi::GtkEditableProperties {
4742        match self {
4743            Self::PropText => ffi::GTK_EDITABLE_PROP_TEXT,
4744            Self::PropCursorPosition => ffi::GTK_EDITABLE_PROP_CURSOR_POSITION,
4745            Self::PropSelectionBound => ffi::GTK_EDITABLE_PROP_SELECTION_BOUND,
4746            Self::PropEditable => ffi::GTK_EDITABLE_PROP_EDITABLE,
4747            Self::PropWidthChars => ffi::GTK_EDITABLE_PROP_WIDTH_CHARS,
4748            Self::PropMaxWidthChars => ffi::GTK_EDITABLE_PROP_MAX_WIDTH_CHARS,
4749            Self::PropXalign => ffi::GTK_EDITABLE_PROP_XALIGN,
4750            Self::PropEnableUndo => ffi::GTK_EDITABLE_PROP_ENABLE_UNDO,
4751            Self::NumProperties => ffi::GTK_EDITABLE_NUM_PROPERTIES,
4752            Self::__Unknown(value) => value,
4753        }
4754    }
4755}
4756
4757#[doc(hidden)]
4758impl FromGlib<ffi::GtkEditableProperties> for EditableProperties {
4759    #[inline]
4760    unsafe fn from_glib(value: ffi::GtkEditableProperties) -> Self {
4761        skip_assert_initialized!();
4762
4763        match value {
4764            ffi::GTK_EDITABLE_PROP_TEXT => Self::PropText,
4765            ffi::GTK_EDITABLE_PROP_CURSOR_POSITION => Self::PropCursorPosition,
4766            ffi::GTK_EDITABLE_PROP_SELECTION_BOUND => Self::PropSelectionBound,
4767            ffi::GTK_EDITABLE_PROP_EDITABLE => Self::PropEditable,
4768            ffi::GTK_EDITABLE_PROP_WIDTH_CHARS => Self::PropWidthChars,
4769            ffi::GTK_EDITABLE_PROP_MAX_WIDTH_CHARS => Self::PropMaxWidthChars,
4770            ffi::GTK_EDITABLE_PROP_XALIGN => Self::PropXalign,
4771            ffi::GTK_EDITABLE_PROP_ENABLE_UNDO => Self::PropEnableUndo,
4772            ffi::GTK_EDITABLE_NUM_PROPERTIES => Self::NumProperties,
4773            value => Self::__Unknown(value),
4774        }
4775    }
4776}
4777
4778impl StaticType for EditableProperties {
4779    #[inline]
4780    #[doc(alias = "gtk_editable_properties_get_type")]
4781    fn static_type() -> glib::Type {
4782        unsafe { from_glib(ffi::gtk_editable_properties_get_type()) }
4783    }
4784}
4785
4786impl glib::HasParamSpec for EditableProperties {
4787    type ParamSpec = glib::ParamSpecEnum;
4788    type SetValue = Self;
4789    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4790
4791    fn param_spec_builder() -> Self::BuilderFn {
4792        Self::ParamSpec::builder_with_default
4793    }
4794}
4795
4796impl glib::value::ValueType for EditableProperties {
4797    type Type = Self;
4798}
4799
4800unsafe impl<'a> glib::value::FromValue<'a> for EditableProperties {
4801    type Checker = glib::value::GenericValueTypeChecker<Self>;
4802
4803    #[inline]
4804    unsafe fn from_value(value: &'a glib::Value) -> Self {
4805        skip_assert_initialized!();
4806        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4807    }
4808}
4809
4810impl ToValue for EditableProperties {
4811    #[inline]
4812    fn to_value(&self) -> glib::Value {
4813        let mut value = glib::Value::for_value_type::<Self>();
4814        unsafe {
4815            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4816        }
4817        value
4818    }
4819
4820    #[inline]
4821    fn value_type(&self) -> glib::Type {
4822        Self::static_type()
4823    }
4824}
4825
4826impl From<EditableProperties> for glib::Value {
4827    #[inline]
4828    fn from(v: EditableProperties) -> Self {
4829        skip_assert_initialized!();
4830        ToValue::to_value(&v)
4831    }
4832}
4833
4834/// Specifies the side of the entry at which an icon is placed.
4835#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4836#[non_exhaustive]
4837#[doc(alias = "GtkEntryIconPosition")]
4838pub enum EntryIconPosition {
4839    /// At the beginning of the entry (depending on the text direction).
4840    #[doc(alias = "GTK_ENTRY_ICON_PRIMARY")]
4841    Primary,
4842    /// At the end of the entry (depending on the text direction).
4843    #[doc(alias = "GTK_ENTRY_ICON_SECONDARY")]
4844    Secondary,
4845    #[doc(hidden)]
4846    __Unknown(i32),
4847}
4848
4849#[doc(hidden)]
4850impl IntoGlib for EntryIconPosition {
4851    type GlibType = ffi::GtkEntryIconPosition;
4852
4853    #[inline]
4854    fn into_glib(self) -> ffi::GtkEntryIconPosition {
4855        match self {
4856            Self::Primary => ffi::GTK_ENTRY_ICON_PRIMARY,
4857            Self::Secondary => ffi::GTK_ENTRY_ICON_SECONDARY,
4858            Self::__Unknown(value) => value,
4859        }
4860    }
4861}
4862
4863#[doc(hidden)]
4864impl FromGlib<ffi::GtkEntryIconPosition> for EntryIconPosition {
4865    #[inline]
4866    unsafe fn from_glib(value: ffi::GtkEntryIconPosition) -> Self {
4867        skip_assert_initialized!();
4868
4869        match value {
4870            ffi::GTK_ENTRY_ICON_PRIMARY => Self::Primary,
4871            ffi::GTK_ENTRY_ICON_SECONDARY => Self::Secondary,
4872            value => Self::__Unknown(value),
4873        }
4874    }
4875}
4876
4877impl StaticType for EntryIconPosition {
4878    #[inline]
4879    #[doc(alias = "gtk_entry_icon_position_get_type")]
4880    fn static_type() -> glib::Type {
4881        unsafe { from_glib(ffi::gtk_entry_icon_position_get_type()) }
4882    }
4883}
4884
4885impl glib::HasParamSpec for EntryIconPosition {
4886    type ParamSpec = glib::ParamSpecEnum;
4887    type SetValue = Self;
4888    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4889
4890    fn param_spec_builder() -> Self::BuilderFn {
4891        Self::ParamSpec::builder_with_default
4892    }
4893}
4894
4895impl glib::value::ValueType for EntryIconPosition {
4896    type Type = Self;
4897}
4898
4899unsafe impl<'a> glib::value::FromValue<'a> for EntryIconPosition {
4900    type Checker = glib::value::GenericValueTypeChecker<Self>;
4901
4902    #[inline]
4903    unsafe fn from_value(value: &'a glib::Value) -> Self {
4904        skip_assert_initialized!();
4905        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4906    }
4907}
4908
4909impl ToValue for EntryIconPosition {
4910    #[inline]
4911    fn to_value(&self) -> glib::Value {
4912        let mut value = glib::Value::for_value_type::<Self>();
4913        unsafe {
4914            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4915        }
4916        value
4917    }
4918
4919    #[inline]
4920    fn value_type(&self) -> glib::Type {
4921        Self::static_type()
4922    }
4923}
4924
4925impl From<EntryIconPosition> for glib::Value {
4926    #[inline]
4927    fn from(v: EntryIconPosition) -> Self {
4928        skip_assert_initialized!();
4929        ToValue::to_value(&v)
4930    }
4931}
4932
4933/// Describes the state of a [`gdk::EventSequence`][crate::gdk::EventSequence] in a [`Gesture`][crate::Gesture].
4934#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4935#[non_exhaustive]
4936#[doc(alias = "GtkEventSequenceState")]
4937pub enum EventSequenceState {
4938    /// The sequence is handled, but not grabbed.
4939    #[doc(alias = "GTK_EVENT_SEQUENCE_NONE")]
4940    None,
4941    /// The sequence is handled and grabbed.
4942    #[doc(alias = "GTK_EVENT_SEQUENCE_CLAIMED")]
4943    Claimed,
4944    /// The sequence is denied.
4945    #[doc(alias = "GTK_EVENT_SEQUENCE_DENIED")]
4946    Denied,
4947    #[doc(hidden)]
4948    __Unknown(i32),
4949}
4950
4951#[doc(hidden)]
4952impl IntoGlib for EventSequenceState {
4953    type GlibType = ffi::GtkEventSequenceState;
4954
4955    #[inline]
4956    fn into_glib(self) -> ffi::GtkEventSequenceState {
4957        match self {
4958            Self::None => ffi::GTK_EVENT_SEQUENCE_NONE,
4959            Self::Claimed => ffi::GTK_EVENT_SEQUENCE_CLAIMED,
4960            Self::Denied => ffi::GTK_EVENT_SEQUENCE_DENIED,
4961            Self::__Unknown(value) => value,
4962        }
4963    }
4964}
4965
4966#[doc(hidden)]
4967impl FromGlib<ffi::GtkEventSequenceState> for EventSequenceState {
4968    #[inline]
4969    unsafe fn from_glib(value: ffi::GtkEventSequenceState) -> Self {
4970        skip_assert_initialized!();
4971
4972        match value {
4973            ffi::GTK_EVENT_SEQUENCE_NONE => Self::None,
4974            ffi::GTK_EVENT_SEQUENCE_CLAIMED => Self::Claimed,
4975            ffi::GTK_EVENT_SEQUENCE_DENIED => Self::Denied,
4976            value => Self::__Unknown(value),
4977        }
4978    }
4979}
4980
4981impl StaticType for EventSequenceState {
4982    #[inline]
4983    #[doc(alias = "gtk_event_sequence_state_get_type")]
4984    fn static_type() -> glib::Type {
4985        unsafe { from_glib(ffi::gtk_event_sequence_state_get_type()) }
4986    }
4987}
4988
4989impl glib::HasParamSpec for EventSequenceState {
4990    type ParamSpec = glib::ParamSpecEnum;
4991    type SetValue = Self;
4992    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4993
4994    fn param_spec_builder() -> Self::BuilderFn {
4995        Self::ParamSpec::builder_with_default
4996    }
4997}
4998
4999impl glib::value::ValueType for EventSequenceState {
5000    type Type = Self;
5001}
5002
5003unsafe impl<'a> glib::value::FromValue<'a> for EventSequenceState {
5004    type Checker = glib::value::GenericValueTypeChecker<Self>;
5005
5006    #[inline]
5007    unsafe fn from_value(value: &'a glib::Value) -> Self {
5008        skip_assert_initialized!();
5009        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5010    }
5011}
5012
5013impl ToValue for EventSequenceState {
5014    #[inline]
5015    fn to_value(&self) -> glib::Value {
5016        let mut value = glib::Value::for_value_type::<Self>();
5017        unsafe {
5018            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5019        }
5020        value
5021    }
5022
5023    #[inline]
5024    fn value_type(&self) -> glib::Type {
5025        Self::static_type()
5026    }
5027}
5028
5029impl From<EventSequenceState> for glib::Value {
5030    #[inline]
5031    fn from(v: EventSequenceState) -> Self {
5032        skip_assert_initialized!();
5033        ToValue::to_value(&v)
5034    }
5035}
5036
5037/// Describes whether a [`FileChooser`][crate::FileChooser] is being used to open existing files
5038/// or to save to a possibly new file.
5039#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5040#[non_exhaustive]
5041#[doc(alias = "GtkFileChooserAction")]
5042pub enum FileChooserAction {
5043    /// Indicates open mode.  The file chooser
5044    ///  will only let the user pick an existing file.
5045    #[doc(alias = "GTK_FILE_CHOOSER_ACTION_OPEN")]
5046    Open,
5047    /// Indicates save mode.  The file chooser
5048    ///  will let the user pick an existing file, or type in a new
5049    ///  filename.
5050    #[doc(alias = "GTK_FILE_CHOOSER_ACTION_SAVE")]
5051    Save,
5052    /// Indicates an Open mode for
5053    ///  selecting folders.  The file chooser will let the user pick an
5054    ///  existing folder.
5055    #[doc(alias = "GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER")]
5056    SelectFolder,
5057    #[doc(hidden)]
5058    __Unknown(i32),
5059}
5060
5061#[doc(hidden)]
5062impl IntoGlib for FileChooserAction {
5063    type GlibType = ffi::GtkFileChooserAction;
5064
5065    #[inline]
5066    fn into_glib(self) -> ffi::GtkFileChooserAction {
5067        match self {
5068            Self::Open => ffi::GTK_FILE_CHOOSER_ACTION_OPEN,
5069            Self::Save => ffi::GTK_FILE_CHOOSER_ACTION_SAVE,
5070            Self::SelectFolder => ffi::GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
5071            Self::__Unknown(value) => value,
5072        }
5073    }
5074}
5075
5076#[doc(hidden)]
5077impl FromGlib<ffi::GtkFileChooserAction> for FileChooserAction {
5078    #[inline]
5079    unsafe fn from_glib(value: ffi::GtkFileChooserAction) -> Self {
5080        skip_assert_initialized!();
5081
5082        match value {
5083            ffi::GTK_FILE_CHOOSER_ACTION_OPEN => Self::Open,
5084            ffi::GTK_FILE_CHOOSER_ACTION_SAVE => Self::Save,
5085            ffi::GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER => Self::SelectFolder,
5086            value => Self::__Unknown(value),
5087        }
5088    }
5089}
5090
5091impl StaticType for FileChooserAction {
5092    #[inline]
5093    #[doc(alias = "gtk_file_chooser_action_get_type")]
5094    fn static_type() -> glib::Type {
5095        unsafe { from_glib(ffi::gtk_file_chooser_action_get_type()) }
5096    }
5097}
5098
5099impl glib::HasParamSpec for FileChooserAction {
5100    type ParamSpec = glib::ParamSpecEnum;
5101    type SetValue = Self;
5102    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5103
5104    fn param_spec_builder() -> Self::BuilderFn {
5105        Self::ParamSpec::builder_with_default
5106    }
5107}
5108
5109impl glib::value::ValueType for FileChooserAction {
5110    type Type = Self;
5111}
5112
5113unsafe impl<'a> glib::value::FromValue<'a> for FileChooserAction {
5114    type Checker = glib::value::GenericValueTypeChecker<Self>;
5115
5116    #[inline]
5117    unsafe fn from_value(value: &'a glib::Value) -> Self {
5118        skip_assert_initialized!();
5119        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5120    }
5121}
5122
5123impl ToValue for FileChooserAction {
5124    #[inline]
5125    fn to_value(&self) -> glib::Value {
5126        let mut value = glib::Value::for_value_type::<Self>();
5127        unsafe {
5128            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5129        }
5130        value
5131    }
5132
5133    #[inline]
5134    fn value_type(&self) -> glib::Type {
5135        Self::static_type()
5136    }
5137}
5138
5139impl From<FileChooserAction> for glib::Value {
5140    #[inline]
5141    fn from(v: FileChooserAction) -> Self {
5142        skip_assert_initialized!();
5143        ToValue::to_value(&v)
5144    }
5145}
5146
5147/// These identify the various errors that can occur while calling
5148/// [`FileChooser`][crate::FileChooser] functions.
5149#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5150#[non_exhaustive]
5151#[doc(alias = "GtkFileChooserError")]
5152pub enum FileChooserError {
5153    /// Indicates that a file does not exist.
5154    #[doc(alias = "GTK_FILE_CHOOSER_ERROR_NONEXISTENT")]
5155    Nonexistent,
5156    /// Indicates a malformed filename.
5157    #[doc(alias = "GTK_FILE_CHOOSER_ERROR_BAD_FILENAME")]
5158    BadFilename,
5159    /// Indicates a duplicate path (e.g. when
5160    ///  adding a bookmark).
5161    #[doc(alias = "GTK_FILE_CHOOSER_ERROR_ALREADY_EXISTS")]
5162    AlreadyExists,
5163    /// Indicates an incomplete hostname
5164    ///  (e.g. "http://foo" without a slash after that).
5165    #[doc(alias = "GTK_FILE_CHOOSER_ERROR_INCOMPLETE_HOSTNAME")]
5166    IncompleteHostname,
5167    #[doc(hidden)]
5168    __Unknown(i32),
5169}
5170
5171#[doc(hidden)]
5172impl IntoGlib for FileChooserError {
5173    type GlibType = ffi::GtkFileChooserError;
5174
5175    #[inline]
5176    fn into_glib(self) -> ffi::GtkFileChooserError {
5177        match self {
5178            Self::Nonexistent => ffi::GTK_FILE_CHOOSER_ERROR_NONEXISTENT,
5179            Self::BadFilename => ffi::GTK_FILE_CHOOSER_ERROR_BAD_FILENAME,
5180            Self::AlreadyExists => ffi::GTK_FILE_CHOOSER_ERROR_ALREADY_EXISTS,
5181            Self::IncompleteHostname => ffi::GTK_FILE_CHOOSER_ERROR_INCOMPLETE_HOSTNAME,
5182            Self::__Unknown(value) => value,
5183        }
5184    }
5185}
5186
5187#[doc(hidden)]
5188impl FromGlib<ffi::GtkFileChooserError> for FileChooserError {
5189    #[inline]
5190    unsafe fn from_glib(value: ffi::GtkFileChooserError) -> Self {
5191        skip_assert_initialized!();
5192
5193        match value {
5194            ffi::GTK_FILE_CHOOSER_ERROR_NONEXISTENT => Self::Nonexistent,
5195            ffi::GTK_FILE_CHOOSER_ERROR_BAD_FILENAME => Self::BadFilename,
5196            ffi::GTK_FILE_CHOOSER_ERROR_ALREADY_EXISTS => Self::AlreadyExists,
5197            ffi::GTK_FILE_CHOOSER_ERROR_INCOMPLETE_HOSTNAME => Self::IncompleteHostname,
5198            value => Self::__Unknown(value),
5199        }
5200    }
5201}
5202
5203impl glib::error::ErrorDomain for FileChooserError {
5204    #[inline]
5205    fn domain() -> glib::Quark {
5206        skip_assert_initialized!();
5207
5208        unsafe { from_glib(ffi::gtk_file_chooser_error_quark()) }
5209    }
5210
5211    #[inline]
5212    fn code(self) -> i32 {
5213        self.into_glib()
5214    }
5215
5216    #[inline]
5217    #[allow(clippy::match_single_binding)]
5218    fn from(code: i32) -> Option<Self> {
5219        skip_assert_initialized!();
5220        match unsafe { from_glib(code) } {
5221            value => Some(value),
5222        }
5223    }
5224}
5225
5226impl StaticType for FileChooserError {
5227    #[inline]
5228    #[doc(alias = "gtk_file_chooser_error_get_type")]
5229    fn static_type() -> glib::Type {
5230        unsafe { from_glib(ffi::gtk_file_chooser_error_get_type()) }
5231    }
5232}
5233
5234impl glib::HasParamSpec for FileChooserError {
5235    type ParamSpec = glib::ParamSpecEnum;
5236    type SetValue = Self;
5237    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5238
5239    fn param_spec_builder() -> Self::BuilderFn {
5240        Self::ParamSpec::builder_with_default
5241    }
5242}
5243
5244impl glib::value::ValueType for FileChooserError {
5245    type Type = Self;
5246}
5247
5248unsafe impl<'a> glib::value::FromValue<'a> for FileChooserError {
5249    type Checker = glib::value::GenericValueTypeChecker<Self>;
5250
5251    #[inline]
5252    unsafe fn from_value(value: &'a glib::Value) -> Self {
5253        skip_assert_initialized!();
5254        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5255    }
5256}
5257
5258impl ToValue for FileChooserError {
5259    #[inline]
5260    fn to_value(&self) -> glib::Value {
5261        let mut value = glib::Value::for_value_type::<Self>();
5262        unsafe {
5263            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5264        }
5265        value
5266    }
5267
5268    #[inline]
5269    fn value_type(&self) -> glib::Type {
5270        Self::static_type()
5271    }
5272}
5273
5274impl From<FileChooserError> for glib::Value {
5275    #[inline]
5276    fn from(v: FileChooserError) -> Self {
5277        skip_assert_initialized!();
5278        ToValue::to_value(&v)
5279    }
5280}
5281
5282/// Describes changes in a filter in more detail and allows objects
5283/// using the filter to optimize refiltering items.
5284///
5285/// If you are writing an implementation and are not sure which
5286/// value to pass, `GTK_FILTER_CHANGE_DIFFERENT` is always a correct
5287/// choice.
5288#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5289#[non_exhaustive]
5290#[doc(alias = "GtkFilterChange")]
5291pub enum FilterChange {
5292    /// The filter change cannot be
5293    ///   described with any of the other enumeration values
5294    #[doc(alias = "GTK_FILTER_CHANGE_DIFFERENT")]
5295    Different,
5296    /// The filter is less strict than
5297    ///   it was before: All items that it used to return true
5298    ///   still return true, others now may, too.
5299    #[doc(alias = "GTK_FILTER_CHANGE_LESS_STRICT")]
5300    LessStrict,
5301    /// The filter is more strict than
5302    ///   it was before: All items that it used to return false
5303    ///   still return false, others now may, too.
5304    #[doc(alias = "GTK_FILTER_CHANGE_MORE_STRICT")]
5305    MoreStrict,
5306    #[doc(hidden)]
5307    __Unknown(i32),
5308}
5309
5310#[doc(hidden)]
5311impl IntoGlib for FilterChange {
5312    type GlibType = ffi::GtkFilterChange;
5313
5314    #[inline]
5315    fn into_glib(self) -> ffi::GtkFilterChange {
5316        match self {
5317            Self::Different => ffi::GTK_FILTER_CHANGE_DIFFERENT,
5318            Self::LessStrict => ffi::GTK_FILTER_CHANGE_LESS_STRICT,
5319            Self::MoreStrict => ffi::GTK_FILTER_CHANGE_MORE_STRICT,
5320            Self::__Unknown(value) => value,
5321        }
5322    }
5323}
5324
5325#[doc(hidden)]
5326impl FromGlib<ffi::GtkFilterChange> for FilterChange {
5327    #[inline]
5328    unsafe fn from_glib(value: ffi::GtkFilterChange) -> Self {
5329        skip_assert_initialized!();
5330
5331        match value {
5332            ffi::GTK_FILTER_CHANGE_DIFFERENT => Self::Different,
5333            ffi::GTK_FILTER_CHANGE_LESS_STRICT => Self::LessStrict,
5334            ffi::GTK_FILTER_CHANGE_MORE_STRICT => Self::MoreStrict,
5335            value => Self::__Unknown(value),
5336        }
5337    }
5338}
5339
5340impl StaticType for FilterChange {
5341    #[inline]
5342    #[doc(alias = "gtk_filter_change_get_type")]
5343    fn static_type() -> glib::Type {
5344        unsafe { from_glib(ffi::gtk_filter_change_get_type()) }
5345    }
5346}
5347
5348impl glib::HasParamSpec for FilterChange {
5349    type ParamSpec = glib::ParamSpecEnum;
5350    type SetValue = Self;
5351    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5352
5353    fn param_spec_builder() -> Self::BuilderFn {
5354        Self::ParamSpec::builder_with_default
5355    }
5356}
5357
5358impl glib::value::ValueType for FilterChange {
5359    type Type = Self;
5360}
5361
5362unsafe impl<'a> glib::value::FromValue<'a> for FilterChange {
5363    type Checker = glib::value::GenericValueTypeChecker<Self>;
5364
5365    #[inline]
5366    unsafe fn from_value(value: &'a glib::Value) -> Self {
5367        skip_assert_initialized!();
5368        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5369    }
5370}
5371
5372impl ToValue for FilterChange {
5373    #[inline]
5374    fn to_value(&self) -> glib::Value {
5375        let mut value = glib::Value::for_value_type::<Self>();
5376        unsafe {
5377            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5378        }
5379        value
5380    }
5381
5382    #[inline]
5383    fn value_type(&self) -> glib::Type {
5384        Self::static_type()
5385    }
5386}
5387
5388impl From<FilterChange> for glib::Value {
5389    #[inline]
5390    fn from(v: FilterChange) -> Self {
5391        skip_assert_initialized!();
5392        ToValue::to_value(&v)
5393    }
5394}
5395
5396/// Describes the known strictness of a filter.
5397///
5398/// Note that for filters where the strictness is not known,
5399/// `GTK_FILTER_MATCH_SOME` is always an acceptable value,
5400/// even if a filter does match all or no items.
5401#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5402#[non_exhaustive]
5403#[doc(alias = "GtkFilterMatch")]
5404pub enum FilterMatch {
5405    /// The filter matches some items,
5406    ///   [`FilterExt::match_()`][crate::prelude::FilterExt::match_()] may return true or false
5407    #[doc(alias = "GTK_FILTER_MATCH_SOME")]
5408    Some,
5409    /// The filter does not match any item,
5410    ///   [`FilterExt::match_()`][crate::prelude::FilterExt::match_()] will always return false
5411    #[doc(alias = "GTK_FILTER_MATCH_NONE")]
5412    None,
5413    /// The filter matches all items,
5414    ///   [`FilterExt::match_()`][crate::prelude::FilterExt::match_()] will alays return true
5415    #[doc(alias = "GTK_FILTER_MATCH_ALL")]
5416    All,
5417    #[doc(hidden)]
5418    __Unknown(i32),
5419}
5420
5421#[doc(hidden)]
5422impl IntoGlib for FilterMatch {
5423    type GlibType = ffi::GtkFilterMatch;
5424
5425    #[inline]
5426    fn into_glib(self) -> ffi::GtkFilterMatch {
5427        match self {
5428            Self::Some => ffi::GTK_FILTER_MATCH_SOME,
5429            Self::None => ffi::GTK_FILTER_MATCH_NONE,
5430            Self::All => ffi::GTK_FILTER_MATCH_ALL,
5431            Self::__Unknown(value) => value,
5432        }
5433    }
5434}
5435
5436#[doc(hidden)]
5437impl FromGlib<ffi::GtkFilterMatch> for FilterMatch {
5438    #[inline]
5439    unsafe fn from_glib(value: ffi::GtkFilterMatch) -> Self {
5440        skip_assert_initialized!();
5441
5442        match value {
5443            ffi::GTK_FILTER_MATCH_SOME => Self::Some,
5444            ffi::GTK_FILTER_MATCH_NONE => Self::None,
5445            ffi::GTK_FILTER_MATCH_ALL => Self::All,
5446            value => Self::__Unknown(value),
5447        }
5448    }
5449}
5450
5451impl StaticType for FilterMatch {
5452    #[inline]
5453    #[doc(alias = "gtk_filter_match_get_type")]
5454    fn static_type() -> glib::Type {
5455        unsafe { from_glib(ffi::gtk_filter_match_get_type()) }
5456    }
5457}
5458
5459impl glib::HasParamSpec for FilterMatch {
5460    type ParamSpec = glib::ParamSpecEnum;
5461    type SetValue = Self;
5462    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5463
5464    fn param_spec_builder() -> Self::BuilderFn {
5465        Self::ParamSpec::builder_with_default
5466    }
5467}
5468
5469impl glib::value::ValueType for FilterMatch {
5470    type Type = Self;
5471}
5472
5473unsafe impl<'a> glib::value::FromValue<'a> for FilterMatch {
5474    type Checker = glib::value::GenericValueTypeChecker<Self>;
5475
5476    #[inline]
5477    unsafe fn from_value(value: &'a glib::Value) -> Self {
5478        skip_assert_initialized!();
5479        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5480    }
5481}
5482
5483impl ToValue for FilterMatch {
5484    #[inline]
5485    fn to_value(&self) -> glib::Value {
5486        let mut value = glib::Value::for_value_type::<Self>();
5487        unsafe {
5488            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5489        }
5490        value
5491    }
5492
5493    #[inline]
5494    fn value_type(&self) -> glib::Type {
5495        Self::static_type()
5496    }
5497}
5498
5499impl From<FilterMatch> for glib::Value {
5500    #[inline]
5501    fn from(v: FilterMatch) -> Self {
5502        skip_assert_initialized!();
5503        ToValue::to_value(&v)
5504    }
5505}
5506
5507/// The level of granularity for the font selection.
5508///
5509/// Depending on this value, the [`pango::FontDescription`][crate::pango::FontDescription] that
5510/// is returned by [`FontDialogButton::font_desc()`][crate::FontDialogButton::font_desc()]
5511/// will have more or less fields set.
5512#[cfg(feature = "v4_10")]
5513#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
5514#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5515#[non_exhaustive]
5516#[doc(alias = "GtkFontLevel")]
5517pub enum FontLevel {
5518    /// Select a font family
5519    #[doc(alias = "GTK_FONT_LEVEL_FAMILY")]
5520    Family,
5521    /// Select a font face (i.e. a family and a style)
5522    #[doc(alias = "GTK_FONT_LEVEL_FACE")]
5523    Face,
5524    /// Select a font (i.e. a face with a size, and possibly font variations)
5525    #[doc(alias = "GTK_FONT_LEVEL_FONT")]
5526    Font,
5527    /// Select a font and font features
5528    #[doc(alias = "GTK_FONT_LEVEL_FEATURES")]
5529    Features,
5530    #[doc(hidden)]
5531    __Unknown(i32),
5532}
5533
5534#[cfg(feature = "v4_10")]
5535#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
5536#[doc(hidden)]
5537impl IntoGlib for FontLevel {
5538    type GlibType = ffi::GtkFontLevel;
5539
5540    #[inline]
5541    fn into_glib(self) -> ffi::GtkFontLevel {
5542        match self {
5543            Self::Family => ffi::GTK_FONT_LEVEL_FAMILY,
5544            Self::Face => ffi::GTK_FONT_LEVEL_FACE,
5545            Self::Font => ffi::GTK_FONT_LEVEL_FONT,
5546            Self::Features => ffi::GTK_FONT_LEVEL_FEATURES,
5547            Self::__Unknown(value) => value,
5548        }
5549    }
5550}
5551
5552#[cfg(feature = "v4_10")]
5553#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
5554#[doc(hidden)]
5555impl FromGlib<ffi::GtkFontLevel> for FontLevel {
5556    #[inline]
5557    unsafe fn from_glib(value: ffi::GtkFontLevel) -> Self {
5558        skip_assert_initialized!();
5559
5560        match value {
5561            ffi::GTK_FONT_LEVEL_FAMILY => Self::Family,
5562            ffi::GTK_FONT_LEVEL_FACE => Self::Face,
5563            ffi::GTK_FONT_LEVEL_FONT => Self::Font,
5564            ffi::GTK_FONT_LEVEL_FEATURES => Self::Features,
5565            value => Self::__Unknown(value),
5566        }
5567    }
5568}
5569
5570#[cfg(feature = "v4_10")]
5571#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
5572impl StaticType for FontLevel {
5573    #[inline]
5574    #[doc(alias = "gtk_font_level_get_type")]
5575    fn static_type() -> glib::Type {
5576        unsafe { from_glib(ffi::gtk_font_level_get_type()) }
5577    }
5578}
5579
5580#[cfg(feature = "v4_10")]
5581#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
5582impl glib::HasParamSpec for FontLevel {
5583    type ParamSpec = glib::ParamSpecEnum;
5584    type SetValue = Self;
5585    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5586
5587    fn param_spec_builder() -> Self::BuilderFn {
5588        Self::ParamSpec::builder_with_default
5589    }
5590}
5591
5592#[cfg(feature = "v4_10")]
5593#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
5594impl glib::value::ValueType for FontLevel {
5595    type Type = Self;
5596}
5597
5598#[cfg(feature = "v4_10")]
5599#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
5600unsafe impl<'a> glib::value::FromValue<'a> for FontLevel {
5601    type Checker = glib::value::GenericValueTypeChecker<Self>;
5602
5603    #[inline]
5604    unsafe fn from_value(value: &'a glib::Value) -> Self {
5605        skip_assert_initialized!();
5606        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5607    }
5608}
5609
5610#[cfg(feature = "v4_10")]
5611#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
5612impl ToValue for FontLevel {
5613    #[inline]
5614    fn to_value(&self) -> glib::Value {
5615        let mut value = glib::Value::for_value_type::<Self>();
5616        unsafe {
5617            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5618        }
5619        value
5620    }
5621
5622    #[inline]
5623    fn value_type(&self) -> glib::Type {
5624        Self::static_type()
5625    }
5626}
5627
5628#[cfg(feature = "v4_10")]
5629#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
5630impl From<FontLevel> for glib::Value {
5631    #[inline]
5632    fn from(v: FontLevel) -> Self {
5633        skip_assert_initialized!();
5634        ToValue::to_value(&v)
5635    }
5636}
5637
5638/// Values for the [`gtk-font-rendering`][struct@crate::Settings#gtk-font-rendering] setting
5639/// that influence how GTK renders fonts.
5640#[cfg(feature = "v4_16")]
5641#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
5642#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5643#[non_exhaustive]
5644#[doc(alias = "GtkFontRendering")]
5645pub enum FontRendering {
5646    /// Set up font rendering automatically,
5647    ///   taking factors like screen resolution and scale into account
5648    #[doc(alias = "GTK_FONT_RENDERING_AUTOMATIC")]
5649    Automatic,
5650    /// Follow low-level font-related settings
5651    ///   when configuring font rendering
5652    #[doc(alias = "GTK_FONT_RENDERING_MANUAL")]
5653    Manual,
5654    #[doc(hidden)]
5655    __Unknown(i32),
5656}
5657
5658#[cfg(feature = "v4_16")]
5659#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
5660#[doc(hidden)]
5661impl IntoGlib for FontRendering {
5662    type GlibType = ffi::GtkFontRendering;
5663
5664    #[inline]
5665    fn into_glib(self) -> ffi::GtkFontRendering {
5666        match self {
5667            Self::Automatic => ffi::GTK_FONT_RENDERING_AUTOMATIC,
5668            Self::Manual => ffi::GTK_FONT_RENDERING_MANUAL,
5669            Self::__Unknown(value) => value,
5670        }
5671    }
5672}
5673
5674#[cfg(feature = "v4_16")]
5675#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
5676#[doc(hidden)]
5677impl FromGlib<ffi::GtkFontRendering> for FontRendering {
5678    #[inline]
5679    unsafe fn from_glib(value: ffi::GtkFontRendering) -> Self {
5680        skip_assert_initialized!();
5681
5682        match value {
5683            ffi::GTK_FONT_RENDERING_AUTOMATIC => Self::Automatic,
5684            ffi::GTK_FONT_RENDERING_MANUAL => Self::Manual,
5685            value => Self::__Unknown(value),
5686        }
5687    }
5688}
5689
5690#[cfg(feature = "v4_16")]
5691#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
5692impl StaticType for FontRendering {
5693    #[inline]
5694    #[doc(alias = "gtk_font_rendering_get_type")]
5695    fn static_type() -> glib::Type {
5696        unsafe { from_glib(ffi::gtk_font_rendering_get_type()) }
5697    }
5698}
5699
5700#[cfg(feature = "v4_16")]
5701#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
5702impl glib::HasParamSpec for FontRendering {
5703    type ParamSpec = glib::ParamSpecEnum;
5704    type SetValue = Self;
5705    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5706
5707    fn param_spec_builder() -> Self::BuilderFn {
5708        Self::ParamSpec::builder_with_default
5709    }
5710}
5711
5712#[cfg(feature = "v4_16")]
5713#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
5714impl glib::value::ValueType for FontRendering {
5715    type Type = Self;
5716}
5717
5718#[cfg(feature = "v4_16")]
5719#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
5720unsafe impl<'a> glib::value::FromValue<'a> for FontRendering {
5721    type Checker = glib::value::GenericValueTypeChecker<Self>;
5722
5723    #[inline]
5724    unsafe fn from_value(value: &'a glib::Value) -> Self {
5725        skip_assert_initialized!();
5726        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5727    }
5728}
5729
5730#[cfg(feature = "v4_16")]
5731#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
5732impl ToValue for FontRendering {
5733    #[inline]
5734    fn to_value(&self) -> glib::Value {
5735        let mut value = glib::Value::for_value_type::<Self>();
5736        unsafe {
5737            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5738        }
5739        value
5740    }
5741
5742    #[inline]
5743    fn value_type(&self) -> glib::Type {
5744        Self::static_type()
5745    }
5746}
5747
5748#[cfg(feature = "v4_16")]
5749#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
5750impl From<FontRendering> for glib::Value {
5751    #[inline]
5752    fn from(v: FontRendering) -> Self {
5753        skip_assert_initialized!();
5754        ToValue::to_value(&v)
5755    }
5756}
5757
5758/// Represents the state of graphics offloading.
5759#[cfg(feature = "v4_14")]
5760#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
5761#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5762#[non_exhaustive]
5763#[doc(alias = "GtkGraphicsOffloadEnabled")]
5764pub enum GraphicsOffloadEnabled {
5765    /// Graphics offloading is enabled.
5766    #[doc(alias = "GTK_GRAPHICS_OFFLOAD_ENABLED")]
5767    Enabled,
5768    /// Graphics offloading is disabled.
5769    #[doc(alias = "GTK_GRAPHICS_OFFLOAD_DISABLED")]
5770    Disabled,
5771    #[doc(hidden)]
5772    __Unknown(i32),
5773}
5774
5775#[cfg(feature = "v4_14")]
5776#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
5777#[doc(hidden)]
5778impl IntoGlib for GraphicsOffloadEnabled {
5779    type GlibType = ffi::GtkGraphicsOffloadEnabled;
5780
5781    #[inline]
5782    fn into_glib(self) -> ffi::GtkGraphicsOffloadEnabled {
5783        match self {
5784            Self::Enabled => ffi::GTK_GRAPHICS_OFFLOAD_ENABLED,
5785            Self::Disabled => ffi::GTK_GRAPHICS_OFFLOAD_DISABLED,
5786            Self::__Unknown(value) => value,
5787        }
5788    }
5789}
5790
5791#[cfg(feature = "v4_14")]
5792#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
5793#[doc(hidden)]
5794impl FromGlib<ffi::GtkGraphicsOffloadEnabled> for GraphicsOffloadEnabled {
5795    #[inline]
5796    unsafe fn from_glib(value: ffi::GtkGraphicsOffloadEnabled) -> Self {
5797        skip_assert_initialized!();
5798
5799        match value {
5800            ffi::GTK_GRAPHICS_OFFLOAD_ENABLED => Self::Enabled,
5801            ffi::GTK_GRAPHICS_OFFLOAD_DISABLED => Self::Disabled,
5802            value => Self::__Unknown(value),
5803        }
5804    }
5805}
5806
5807#[cfg(feature = "v4_14")]
5808#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
5809impl StaticType for GraphicsOffloadEnabled {
5810    #[inline]
5811    #[doc(alias = "gtk_graphics_offload_enabled_get_type")]
5812    fn static_type() -> glib::Type {
5813        unsafe { from_glib(ffi::gtk_graphics_offload_enabled_get_type()) }
5814    }
5815}
5816
5817#[cfg(feature = "v4_14")]
5818#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
5819impl glib::HasParamSpec for GraphicsOffloadEnabled {
5820    type ParamSpec = glib::ParamSpecEnum;
5821    type SetValue = Self;
5822    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5823
5824    fn param_spec_builder() -> Self::BuilderFn {
5825        Self::ParamSpec::builder_with_default
5826    }
5827}
5828
5829#[cfg(feature = "v4_14")]
5830#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
5831impl glib::value::ValueType for GraphicsOffloadEnabled {
5832    type Type = Self;
5833}
5834
5835#[cfg(feature = "v4_14")]
5836#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
5837unsafe impl<'a> glib::value::FromValue<'a> for GraphicsOffloadEnabled {
5838    type Checker = glib::value::GenericValueTypeChecker<Self>;
5839
5840    #[inline]
5841    unsafe fn from_value(value: &'a glib::Value) -> Self {
5842        skip_assert_initialized!();
5843        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5844    }
5845}
5846
5847#[cfg(feature = "v4_14")]
5848#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
5849impl ToValue for GraphicsOffloadEnabled {
5850    #[inline]
5851    fn to_value(&self) -> glib::Value {
5852        let mut value = glib::Value::for_value_type::<Self>();
5853        unsafe {
5854            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5855        }
5856        value
5857    }
5858
5859    #[inline]
5860    fn value_type(&self) -> glib::Type {
5861        Self::static_type()
5862    }
5863}
5864
5865#[cfg(feature = "v4_14")]
5866#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
5867impl From<GraphicsOffloadEnabled> for glib::Value {
5868    #[inline]
5869    fn from(v: GraphicsOffloadEnabled) -> Self {
5870        skip_assert_initialized!();
5871        ToValue::to_value(&v)
5872    }
5873}
5874
5875/// Built-in icon sizes.
5876///
5877/// Icon sizes default to being inherited. Where they cannot be
5878/// inherited, text size is the default.
5879///
5880/// All widgets which use [`IconSize`][crate::IconSize] set the normal-icons or
5881/// large-icons style classes correspondingly, and let themes
5882/// determine the actual size to be used with the
5883/// `-gtk-icon-size` CSS property.
5884#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5885#[non_exhaustive]
5886#[doc(alias = "GtkIconSize")]
5887pub enum IconSize {
5888    /// Keep the size of the parent element
5889    #[doc(alias = "GTK_ICON_SIZE_INHERIT")]
5890    Inherit,
5891    /// Size similar to text size
5892    #[doc(alias = "GTK_ICON_SIZE_NORMAL")]
5893    Normal,
5894    /// Large size, for example in an icon view
5895    #[doc(alias = "GTK_ICON_SIZE_LARGE")]
5896    Large,
5897    #[doc(hidden)]
5898    __Unknown(i32),
5899}
5900
5901#[doc(hidden)]
5902impl IntoGlib for IconSize {
5903    type GlibType = ffi::GtkIconSize;
5904
5905    #[inline]
5906    fn into_glib(self) -> ffi::GtkIconSize {
5907        match self {
5908            Self::Inherit => ffi::GTK_ICON_SIZE_INHERIT,
5909            Self::Normal => ffi::GTK_ICON_SIZE_NORMAL,
5910            Self::Large => ffi::GTK_ICON_SIZE_LARGE,
5911            Self::__Unknown(value) => value,
5912        }
5913    }
5914}
5915
5916#[doc(hidden)]
5917impl FromGlib<ffi::GtkIconSize> for IconSize {
5918    #[inline]
5919    unsafe fn from_glib(value: ffi::GtkIconSize) -> Self {
5920        skip_assert_initialized!();
5921
5922        match value {
5923            ffi::GTK_ICON_SIZE_INHERIT => Self::Inherit,
5924            ffi::GTK_ICON_SIZE_NORMAL => Self::Normal,
5925            ffi::GTK_ICON_SIZE_LARGE => Self::Large,
5926            value => Self::__Unknown(value),
5927        }
5928    }
5929}
5930
5931impl StaticType for IconSize {
5932    #[inline]
5933    #[doc(alias = "gtk_icon_size_get_type")]
5934    fn static_type() -> glib::Type {
5935        unsafe { from_glib(ffi::gtk_icon_size_get_type()) }
5936    }
5937}
5938
5939impl glib::HasParamSpec for IconSize {
5940    type ParamSpec = glib::ParamSpecEnum;
5941    type SetValue = Self;
5942    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5943
5944    fn param_spec_builder() -> Self::BuilderFn {
5945        Self::ParamSpec::builder_with_default
5946    }
5947}
5948
5949impl glib::value::ValueType for IconSize {
5950    type Type = Self;
5951}
5952
5953unsafe impl<'a> glib::value::FromValue<'a> for IconSize {
5954    type Checker = glib::value::GenericValueTypeChecker<Self>;
5955
5956    #[inline]
5957    unsafe fn from_value(value: &'a glib::Value) -> Self {
5958        skip_assert_initialized!();
5959        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5960    }
5961}
5962
5963impl ToValue for IconSize {
5964    #[inline]
5965    fn to_value(&self) -> glib::Value {
5966        let mut value = glib::Value::for_value_type::<Self>();
5967        unsafe {
5968            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5969        }
5970        value
5971    }
5972
5973    #[inline]
5974    fn value_type(&self) -> glib::Type {
5975        Self::static_type()
5976    }
5977}
5978
5979impl From<IconSize> for glib::Value {
5980    #[inline]
5981    fn from(v: IconSize) -> Self {
5982        skip_assert_initialized!();
5983        ToValue::to_value(&v)
5984    }
5985}
5986
5987/// Error codes for [`IconTheme`][crate::IconTheme] operations.
5988#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5989#[non_exhaustive]
5990#[doc(alias = "GtkIconThemeError")]
5991pub enum IconThemeError {
5992    /// The icon specified does not exist in the theme
5993    #[doc(alias = "GTK_ICON_THEME_NOT_FOUND")]
5994    NotFound,
5995    /// An unspecified error occurred.
5996    #[doc(alias = "GTK_ICON_THEME_FAILED")]
5997    Failed,
5998    #[doc(hidden)]
5999    __Unknown(i32),
6000}
6001
6002#[doc(hidden)]
6003impl IntoGlib for IconThemeError {
6004    type GlibType = ffi::GtkIconThemeError;
6005
6006    #[inline]
6007    fn into_glib(self) -> ffi::GtkIconThemeError {
6008        match self {
6009            Self::NotFound => ffi::GTK_ICON_THEME_NOT_FOUND,
6010            Self::Failed => ffi::GTK_ICON_THEME_FAILED,
6011            Self::__Unknown(value) => value,
6012        }
6013    }
6014}
6015
6016#[doc(hidden)]
6017impl FromGlib<ffi::GtkIconThemeError> for IconThemeError {
6018    #[inline]
6019    unsafe fn from_glib(value: ffi::GtkIconThemeError) -> Self {
6020        skip_assert_initialized!();
6021
6022        match value {
6023            ffi::GTK_ICON_THEME_NOT_FOUND => Self::NotFound,
6024            ffi::GTK_ICON_THEME_FAILED => Self::Failed,
6025            value => Self::__Unknown(value),
6026        }
6027    }
6028}
6029
6030impl glib::error::ErrorDomain for IconThemeError {
6031    #[inline]
6032    fn domain() -> glib::Quark {
6033        skip_assert_initialized!();
6034
6035        unsafe { from_glib(ffi::gtk_icon_theme_error_quark()) }
6036    }
6037
6038    #[inline]
6039    fn code(self) -> i32 {
6040        self.into_glib()
6041    }
6042
6043    #[inline]
6044    #[allow(clippy::match_single_binding)]
6045    fn from(code: i32) -> Option<Self> {
6046        skip_assert_initialized!();
6047        match unsafe { from_glib(code) } {
6048            Self::__Unknown(_) => Some(Self::Failed),
6049            value => Some(value),
6050        }
6051    }
6052}
6053
6054impl StaticType for IconThemeError {
6055    #[inline]
6056    #[doc(alias = "gtk_icon_theme_error_get_type")]
6057    fn static_type() -> glib::Type {
6058        unsafe { from_glib(ffi::gtk_icon_theme_error_get_type()) }
6059    }
6060}
6061
6062impl glib::HasParamSpec for IconThemeError {
6063    type ParamSpec = glib::ParamSpecEnum;
6064    type SetValue = Self;
6065    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
6066
6067    fn param_spec_builder() -> Self::BuilderFn {
6068        Self::ParamSpec::builder_with_default
6069    }
6070}
6071
6072impl glib::value::ValueType for IconThemeError {
6073    type Type = Self;
6074}
6075
6076unsafe impl<'a> glib::value::FromValue<'a> for IconThemeError {
6077    type Checker = glib::value::GenericValueTypeChecker<Self>;
6078
6079    #[inline]
6080    unsafe fn from_value(value: &'a glib::Value) -> Self {
6081        skip_assert_initialized!();
6082        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
6083    }
6084}
6085
6086impl ToValue for IconThemeError {
6087    #[inline]
6088    fn to_value(&self) -> glib::Value {
6089        let mut value = glib::Value::for_value_type::<Self>();
6090        unsafe {
6091            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
6092        }
6093        value
6094    }
6095
6096    #[inline]
6097    fn value_type(&self) -> glib::Type {
6098        Self::static_type()
6099    }
6100}
6101
6102impl From<IconThemeError> for glib::Value {
6103    #[inline]
6104    fn from(v: IconThemeError) -> Self {
6105        skip_assert_initialized!();
6106        ToValue::to_value(&v)
6107    }
6108}
6109
6110/// An enum for determining where a dropped item goes.
6111#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6112#[non_exhaustive]
6113#[doc(alias = "GtkIconViewDropPosition")]
6114pub enum IconViewDropPosition {
6115    /// no drop possible
6116    #[doc(alias = "GTK_ICON_VIEW_NO_DROP")]
6117    NoDrop,
6118    /// dropped item replaces the item
6119    #[doc(alias = "GTK_ICON_VIEW_DROP_INTO")]
6120    DropInto,
6121    /// dropped item is inserted to the left
6122    #[doc(alias = "GTK_ICON_VIEW_DROP_LEFT")]
6123    DropLeft,
6124    /// dropped item is inserted to the right
6125    #[doc(alias = "GTK_ICON_VIEW_DROP_RIGHT")]
6126    DropRight,
6127    /// dropped item is inserted above
6128    #[doc(alias = "GTK_ICON_VIEW_DROP_ABOVE")]
6129    DropAbove,
6130    /// dropped item is inserted below
6131    #[doc(alias = "GTK_ICON_VIEW_DROP_BELOW")]
6132    DropBelow,
6133    #[doc(hidden)]
6134    __Unknown(i32),
6135}
6136
6137#[doc(hidden)]
6138impl IntoGlib for IconViewDropPosition {
6139    type GlibType = ffi::GtkIconViewDropPosition;
6140
6141    #[inline]
6142    fn into_glib(self) -> ffi::GtkIconViewDropPosition {
6143        match self {
6144            Self::NoDrop => ffi::GTK_ICON_VIEW_NO_DROP,
6145            Self::DropInto => ffi::GTK_ICON_VIEW_DROP_INTO,
6146            Self::DropLeft => ffi::GTK_ICON_VIEW_DROP_LEFT,
6147            Self::DropRight => ffi::GTK_ICON_VIEW_DROP_RIGHT,
6148            Self::DropAbove => ffi::GTK_ICON_VIEW_DROP_ABOVE,
6149            Self::DropBelow => ffi::GTK_ICON_VIEW_DROP_BELOW,
6150            Self::__Unknown(value) => value,
6151        }
6152    }
6153}
6154
6155#[doc(hidden)]
6156impl FromGlib<ffi::GtkIconViewDropPosition> for IconViewDropPosition {
6157    #[inline]
6158    unsafe fn from_glib(value: ffi::GtkIconViewDropPosition) -> Self {
6159        skip_assert_initialized!();
6160
6161        match value {
6162            ffi::GTK_ICON_VIEW_NO_DROP => Self::NoDrop,
6163            ffi::GTK_ICON_VIEW_DROP_INTO => Self::DropInto,
6164            ffi::GTK_ICON_VIEW_DROP_LEFT => Self::DropLeft,
6165            ffi::GTK_ICON_VIEW_DROP_RIGHT => Self::DropRight,
6166            ffi::GTK_ICON_VIEW_DROP_ABOVE => Self::DropAbove,
6167            ffi::GTK_ICON_VIEW_DROP_BELOW => Self::DropBelow,
6168            value => Self::__Unknown(value),
6169        }
6170    }
6171}
6172
6173impl StaticType for IconViewDropPosition {
6174    #[inline]
6175    #[doc(alias = "gtk_icon_view_drop_position_get_type")]
6176    fn static_type() -> glib::Type {
6177        unsafe { from_glib(ffi::gtk_icon_view_drop_position_get_type()) }
6178    }
6179}
6180
6181impl glib::HasParamSpec for IconViewDropPosition {
6182    type ParamSpec = glib::ParamSpecEnum;
6183    type SetValue = Self;
6184    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
6185
6186    fn param_spec_builder() -> Self::BuilderFn {
6187        Self::ParamSpec::builder_with_default
6188    }
6189}
6190
6191impl glib::value::ValueType for IconViewDropPosition {
6192    type Type = Self;
6193}
6194
6195unsafe impl<'a> glib::value::FromValue<'a> for IconViewDropPosition {
6196    type Checker = glib::value::GenericValueTypeChecker<Self>;
6197
6198    #[inline]
6199    unsafe fn from_value(value: &'a glib::Value) -> Self {
6200        skip_assert_initialized!();
6201        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
6202    }
6203}
6204
6205impl ToValue for IconViewDropPosition {
6206    #[inline]
6207    fn to_value(&self) -> glib::Value {
6208        let mut value = glib::Value::for_value_type::<Self>();
6209        unsafe {
6210            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
6211        }
6212        value
6213    }
6214
6215    #[inline]
6216    fn value_type(&self) -> glib::Type {
6217        Self::static_type()
6218    }
6219}
6220
6221impl From<IconViewDropPosition> for glib::Value {
6222    #[inline]
6223    fn from(v: IconViewDropPosition) -> Self {
6224        skip_assert_initialized!();
6225        ToValue::to_value(&v)
6226    }
6227}
6228
6229/// Describes the image data representation used by a [`Image`][crate::Image].
6230///
6231/// If you want to get the image from the widget, you can only get the
6232/// currently-stored representation; for instance, if the gtk_image_get_storage_type()
6233/// returns [`Paintable`][Self::Paintable], then you can call gtk_image_get_paintable().
6234///
6235/// For empty images, you can request any storage type (call any of the "get"
6236/// functions), but they will all return [`None`] values.
6237#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6238#[non_exhaustive]
6239#[doc(alias = "GtkImageType")]
6240pub enum ImageType {
6241    /// there is no image displayed by the widget
6242    #[doc(alias = "GTK_IMAGE_EMPTY")]
6243    Empty,
6244    /// the widget contains a named icon
6245    #[doc(alias = "GTK_IMAGE_ICON_NAME")]
6246    IconName,
6247    /// the widget contains a `GIcon`
6248    #[doc(alias = "GTK_IMAGE_GICON")]
6249    Gicon,
6250    /// the widget contains a [`gdk::Paintable`][crate::gdk::Paintable]
6251    #[doc(alias = "GTK_IMAGE_PAINTABLE")]
6252    Paintable,
6253    #[doc(hidden)]
6254    __Unknown(i32),
6255}
6256
6257#[doc(hidden)]
6258impl IntoGlib for ImageType {
6259    type GlibType = ffi::GtkImageType;
6260
6261    #[inline]
6262    fn into_glib(self) -> ffi::GtkImageType {
6263        match self {
6264            Self::Empty => ffi::GTK_IMAGE_EMPTY,
6265            Self::IconName => ffi::GTK_IMAGE_ICON_NAME,
6266            Self::Gicon => ffi::GTK_IMAGE_GICON,
6267            Self::Paintable => ffi::GTK_IMAGE_PAINTABLE,
6268            Self::__Unknown(value) => value,
6269        }
6270    }
6271}
6272
6273#[doc(hidden)]
6274impl FromGlib<ffi::GtkImageType> for ImageType {
6275    #[inline]
6276    unsafe fn from_glib(value: ffi::GtkImageType) -> Self {
6277        skip_assert_initialized!();
6278
6279        match value {
6280            ffi::GTK_IMAGE_EMPTY => Self::Empty,
6281            ffi::GTK_IMAGE_ICON_NAME => Self::IconName,
6282            ffi::GTK_IMAGE_GICON => Self::Gicon,
6283            ffi::GTK_IMAGE_PAINTABLE => Self::Paintable,
6284            value => Self::__Unknown(value),
6285        }
6286    }
6287}
6288
6289impl StaticType for ImageType {
6290    #[inline]
6291    #[doc(alias = "gtk_image_type_get_type")]
6292    fn static_type() -> glib::Type {
6293        unsafe { from_glib(ffi::gtk_image_type_get_type()) }
6294    }
6295}
6296
6297impl glib::HasParamSpec for ImageType {
6298    type ParamSpec = glib::ParamSpecEnum;
6299    type SetValue = Self;
6300    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
6301
6302    fn param_spec_builder() -> Self::BuilderFn {
6303        Self::ParamSpec::builder_with_default
6304    }
6305}
6306
6307impl glib::value::ValueType for ImageType {
6308    type Type = Self;
6309}
6310
6311unsafe impl<'a> glib::value::FromValue<'a> for ImageType {
6312    type Checker = glib::value::GenericValueTypeChecker<Self>;
6313
6314    #[inline]
6315    unsafe fn from_value(value: &'a glib::Value) -> Self {
6316        skip_assert_initialized!();
6317        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
6318    }
6319}
6320
6321impl ToValue for ImageType {
6322    #[inline]
6323    fn to_value(&self) -> glib::Value {
6324        let mut value = glib::Value::for_value_type::<Self>();
6325        unsafe {
6326            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
6327        }
6328        value
6329    }
6330
6331    #[inline]
6332    fn value_type(&self) -> glib::Type {
6333        Self::static_type()
6334    }
6335}
6336
6337impl From<ImageType> for glib::Value {
6338    #[inline]
6339    fn from(v: ImageType) -> Self {
6340        skip_assert_initialized!();
6341        ToValue::to_value(&v)
6342    }
6343}
6344
6345/// Describes primary purpose of the input widget.
6346///
6347/// This information is useful for on-screen keyboards and similar input
6348/// methods to decide which keys should be presented to the user.
6349///
6350/// Note that the purpose is not meant to impose a totally strict rule
6351/// about allowed characters, and does not replace input validation.
6352/// It is fine for an on-screen keyboard to let the user override the
6353/// character set restriction that is expressed by the purpose. The
6354/// application is expected to validate the entry contents, even if
6355/// it specified a purpose.
6356///
6357/// The difference between [`Digits`][Self::Digits] and
6358/// [`Number`][Self::Number] is that the former accepts only digits
6359/// while the latter also some punctuation (like commas or points, plus,
6360/// minus) and “e” or “E” as in 3.14E+000.
6361///
6362/// This enumeration may be extended in the future; input methods should
6363/// interpret unknown values as “free form”.
6364#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6365#[non_exhaustive]
6366#[doc(alias = "GtkInputPurpose")]
6367pub enum InputPurpose {
6368    /// Allow any character
6369    #[doc(alias = "GTK_INPUT_PURPOSE_FREE_FORM")]
6370    FreeForm,
6371    /// Allow only alphabetic characters
6372    #[doc(alias = "GTK_INPUT_PURPOSE_ALPHA")]
6373    Alpha,
6374    /// Allow only digits
6375    #[doc(alias = "GTK_INPUT_PURPOSE_DIGITS")]
6376    Digits,
6377    /// Edited field expects numbers
6378    #[doc(alias = "GTK_INPUT_PURPOSE_NUMBER")]
6379    Number,
6380    /// Edited field expects phone number
6381    #[doc(alias = "GTK_INPUT_PURPOSE_PHONE")]
6382    Phone,
6383    /// Edited field expects URL
6384    #[doc(alias = "GTK_INPUT_PURPOSE_URL")]
6385    Url,
6386    /// Edited field expects email address
6387    #[doc(alias = "GTK_INPUT_PURPOSE_EMAIL")]
6388    Email,
6389    /// Edited field expects the name of a person
6390    #[doc(alias = "GTK_INPUT_PURPOSE_NAME")]
6391    Name,
6392    /// Like [`FreeForm`][Self::FreeForm], but characters are hidden
6393    #[doc(alias = "GTK_INPUT_PURPOSE_PASSWORD")]
6394    Password,
6395    /// Like [`Digits`][Self::Digits], but characters are hidden
6396    #[doc(alias = "GTK_INPUT_PURPOSE_PIN")]
6397    Pin,
6398    /// Allow any character, in addition to control codes
6399    #[doc(alias = "GTK_INPUT_PURPOSE_TERMINAL")]
6400    Terminal,
6401    #[doc(hidden)]
6402    __Unknown(i32),
6403}
6404
6405#[doc(hidden)]
6406impl IntoGlib for InputPurpose {
6407    type GlibType = ffi::GtkInputPurpose;
6408
6409    #[inline]
6410    fn into_glib(self) -> ffi::GtkInputPurpose {
6411        match self {
6412            Self::FreeForm => ffi::GTK_INPUT_PURPOSE_FREE_FORM,
6413            Self::Alpha => ffi::GTK_INPUT_PURPOSE_ALPHA,
6414            Self::Digits => ffi::GTK_INPUT_PURPOSE_DIGITS,
6415            Self::Number => ffi::GTK_INPUT_PURPOSE_NUMBER,
6416            Self::Phone => ffi::GTK_INPUT_PURPOSE_PHONE,
6417            Self::Url => ffi::GTK_INPUT_PURPOSE_URL,
6418            Self::Email => ffi::GTK_INPUT_PURPOSE_EMAIL,
6419            Self::Name => ffi::GTK_INPUT_PURPOSE_NAME,
6420            Self::Password => ffi::GTK_INPUT_PURPOSE_PASSWORD,
6421            Self::Pin => ffi::GTK_INPUT_PURPOSE_PIN,
6422            Self::Terminal => ffi::GTK_INPUT_PURPOSE_TERMINAL,
6423            Self::__Unknown(value) => value,
6424        }
6425    }
6426}
6427
6428#[doc(hidden)]
6429impl FromGlib<ffi::GtkInputPurpose> for InputPurpose {
6430    #[inline]
6431    unsafe fn from_glib(value: ffi::GtkInputPurpose) -> Self {
6432        skip_assert_initialized!();
6433
6434        match value {
6435            ffi::GTK_INPUT_PURPOSE_FREE_FORM => Self::FreeForm,
6436            ffi::GTK_INPUT_PURPOSE_ALPHA => Self::Alpha,
6437            ffi::GTK_INPUT_PURPOSE_DIGITS => Self::Digits,
6438            ffi::GTK_INPUT_PURPOSE_NUMBER => Self::Number,
6439            ffi::GTK_INPUT_PURPOSE_PHONE => Self::Phone,
6440            ffi::GTK_INPUT_PURPOSE_URL => Self::Url,
6441            ffi::GTK_INPUT_PURPOSE_EMAIL => Self::Email,
6442            ffi::GTK_INPUT_PURPOSE_NAME => Self::Name,
6443            ffi::GTK_INPUT_PURPOSE_PASSWORD => Self::Password,
6444            ffi::GTK_INPUT_PURPOSE_PIN => Self::Pin,
6445            ffi::GTK_INPUT_PURPOSE_TERMINAL => Self::Terminal,
6446            value => Self::__Unknown(value),
6447        }
6448    }
6449}
6450
6451impl StaticType for InputPurpose {
6452    #[inline]
6453    #[doc(alias = "gtk_input_purpose_get_type")]
6454    fn static_type() -> glib::Type {
6455        unsafe { from_glib(ffi::gtk_input_purpose_get_type()) }
6456    }
6457}
6458
6459impl glib::HasParamSpec for InputPurpose {
6460    type ParamSpec = glib::ParamSpecEnum;
6461    type SetValue = Self;
6462    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
6463
6464    fn param_spec_builder() -> Self::BuilderFn {
6465        Self::ParamSpec::builder_with_default
6466    }
6467}
6468
6469impl glib::value::ValueType for InputPurpose {
6470    type Type = Self;
6471}
6472
6473unsafe impl<'a> glib::value::FromValue<'a> for InputPurpose {
6474    type Checker = glib::value::GenericValueTypeChecker<Self>;
6475
6476    #[inline]
6477    unsafe fn from_value(value: &'a glib::Value) -> Self {
6478        skip_assert_initialized!();
6479        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
6480    }
6481}
6482
6483impl ToValue for InputPurpose {
6484    #[inline]
6485    fn to_value(&self) -> glib::Value {
6486        let mut value = glib::Value::for_value_type::<Self>();
6487        unsafe {
6488            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
6489        }
6490        value
6491    }
6492
6493    #[inline]
6494    fn value_type(&self) -> glib::Type {
6495        Self::static_type()
6496    }
6497}
6498
6499impl From<InputPurpose> for glib::Value {
6500    #[inline]
6501    fn from(v: InputPurpose) -> Self {
6502        skip_assert_initialized!();
6503        ToValue::to_value(&v)
6504    }
6505}
6506
6507/// The different methods to handle text in #GtkInscription when it doesn't
6508/// fit the available space.
6509#[cfg(feature = "v4_8")]
6510#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
6511#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6512#[non_exhaustive]
6513#[doc(alias = "GtkInscriptionOverflow")]
6514pub enum InscriptionOverflow {
6515    /// Clip the remaining text
6516    #[doc(alias = "GTK_INSCRIPTION_OVERFLOW_CLIP")]
6517    Clip,
6518    /// Omit characters at the start of the text
6519    #[doc(alias = "GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_START")]
6520    EllipsizeStart,
6521    /// Omit characters at the middle of the text
6522    #[doc(alias = "GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_MIDDLE")]
6523    EllipsizeMiddle,
6524    /// Omit characters at the end of the text
6525    #[doc(alias = "GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_END")]
6526    EllipsizeEnd,
6527    #[doc(hidden)]
6528    __Unknown(i32),
6529}
6530
6531#[cfg(feature = "v4_8")]
6532#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
6533#[doc(hidden)]
6534impl IntoGlib for InscriptionOverflow {
6535    type GlibType = ffi::GtkInscriptionOverflow;
6536
6537    #[inline]
6538    fn into_glib(self) -> ffi::GtkInscriptionOverflow {
6539        match self {
6540            Self::Clip => ffi::GTK_INSCRIPTION_OVERFLOW_CLIP,
6541            Self::EllipsizeStart => ffi::GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_START,
6542            Self::EllipsizeMiddle => ffi::GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_MIDDLE,
6543            Self::EllipsizeEnd => ffi::GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_END,
6544            Self::__Unknown(value) => value,
6545        }
6546    }
6547}
6548
6549#[cfg(feature = "v4_8")]
6550#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
6551#[doc(hidden)]
6552impl FromGlib<ffi::GtkInscriptionOverflow> for InscriptionOverflow {
6553    #[inline]
6554    unsafe fn from_glib(value: ffi::GtkInscriptionOverflow) -> Self {
6555        skip_assert_initialized!();
6556
6557        match value {
6558            ffi::GTK_INSCRIPTION_OVERFLOW_CLIP => Self::Clip,
6559            ffi::GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_START => Self::EllipsizeStart,
6560            ffi::GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_MIDDLE => Self::EllipsizeMiddle,
6561            ffi::GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_END => Self::EllipsizeEnd,
6562            value => Self::__Unknown(value),
6563        }
6564    }
6565}
6566
6567#[cfg(feature = "v4_8")]
6568#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
6569impl StaticType for InscriptionOverflow {
6570    #[inline]
6571    #[doc(alias = "gtk_inscription_overflow_get_type")]
6572    fn static_type() -> glib::Type {
6573        unsafe { from_glib(ffi::gtk_inscription_overflow_get_type()) }
6574    }
6575}
6576
6577#[cfg(feature = "v4_8")]
6578#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
6579impl glib::HasParamSpec for InscriptionOverflow {
6580    type ParamSpec = glib::ParamSpecEnum;
6581    type SetValue = Self;
6582    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
6583
6584    fn param_spec_builder() -> Self::BuilderFn {
6585        Self::ParamSpec::builder_with_default
6586    }
6587}
6588
6589#[cfg(feature = "v4_8")]
6590#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
6591impl glib::value::ValueType for InscriptionOverflow {
6592    type Type = Self;
6593}
6594
6595#[cfg(feature = "v4_8")]
6596#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
6597unsafe impl<'a> glib::value::FromValue<'a> for InscriptionOverflow {
6598    type Checker = glib::value::GenericValueTypeChecker<Self>;
6599
6600    #[inline]
6601    unsafe fn from_value(value: &'a glib::Value) -> Self {
6602        skip_assert_initialized!();
6603        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
6604    }
6605}
6606
6607#[cfg(feature = "v4_8")]
6608#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
6609impl ToValue for InscriptionOverflow {
6610    #[inline]
6611    fn to_value(&self) -> glib::Value {
6612        let mut value = glib::Value::for_value_type::<Self>();
6613        unsafe {
6614            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
6615        }
6616        value
6617    }
6618
6619    #[inline]
6620    fn value_type(&self) -> glib::Type {
6621        Self::static_type()
6622    }
6623}
6624
6625#[cfg(feature = "v4_8")]
6626#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
6627impl From<InscriptionOverflow> for glib::Value {
6628    #[inline]
6629    fn from(v: InscriptionOverflow) -> Self {
6630        skip_assert_initialized!();
6631        ToValue::to_value(&v)
6632    }
6633}
6634
6635/// Used for justifying the text inside a [`Label`][crate::Label] widget.
6636#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6637#[non_exhaustive]
6638#[doc(alias = "GtkJustification")]
6639pub enum Justification {
6640    /// The text is placed at the left edge of the label.
6641    #[doc(alias = "GTK_JUSTIFY_LEFT")]
6642    Left,
6643    /// The text is placed at the right edge of the label.
6644    #[doc(alias = "GTK_JUSTIFY_RIGHT")]
6645    Right,
6646    /// The text is placed in the center of the label.
6647    #[doc(alias = "GTK_JUSTIFY_CENTER")]
6648    Center,
6649    /// The text is placed is distributed across the label.
6650    #[doc(alias = "GTK_JUSTIFY_FILL")]
6651    Fill,
6652    #[doc(hidden)]
6653    __Unknown(i32),
6654}
6655
6656#[doc(hidden)]
6657impl IntoGlib for Justification {
6658    type GlibType = ffi::GtkJustification;
6659
6660    #[inline]
6661    fn into_glib(self) -> ffi::GtkJustification {
6662        match self {
6663            Self::Left => ffi::GTK_JUSTIFY_LEFT,
6664            Self::Right => ffi::GTK_JUSTIFY_RIGHT,
6665            Self::Center => ffi::GTK_JUSTIFY_CENTER,
6666            Self::Fill => ffi::GTK_JUSTIFY_FILL,
6667            Self::__Unknown(value) => value,
6668        }
6669    }
6670}
6671
6672#[doc(hidden)]
6673impl FromGlib<ffi::GtkJustification> for Justification {
6674    #[inline]
6675    unsafe fn from_glib(value: ffi::GtkJustification) -> Self {
6676        skip_assert_initialized!();
6677
6678        match value {
6679            ffi::GTK_JUSTIFY_LEFT => Self::Left,
6680            ffi::GTK_JUSTIFY_RIGHT => Self::Right,
6681            ffi::GTK_JUSTIFY_CENTER => Self::Center,
6682            ffi::GTK_JUSTIFY_FILL => Self::Fill,
6683            value => Self::__Unknown(value),
6684        }
6685    }
6686}
6687
6688impl StaticType for Justification {
6689    #[inline]
6690    #[doc(alias = "gtk_justification_get_type")]
6691    fn static_type() -> glib::Type {
6692        unsafe { from_glib(ffi::gtk_justification_get_type()) }
6693    }
6694}
6695
6696impl glib::HasParamSpec for Justification {
6697    type ParamSpec = glib::ParamSpecEnum;
6698    type SetValue = Self;
6699    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
6700
6701    fn param_spec_builder() -> Self::BuilderFn {
6702        Self::ParamSpec::builder_with_default
6703    }
6704}
6705
6706impl glib::value::ValueType for Justification {
6707    type Type = Self;
6708}
6709
6710unsafe impl<'a> glib::value::FromValue<'a> for Justification {
6711    type Checker = glib::value::GenericValueTypeChecker<Self>;
6712
6713    #[inline]
6714    unsafe fn from_value(value: &'a glib::Value) -> Self {
6715        skip_assert_initialized!();
6716        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
6717    }
6718}
6719
6720impl ToValue for Justification {
6721    #[inline]
6722    fn to_value(&self) -> glib::Value {
6723        let mut value = glib::Value::for_value_type::<Self>();
6724        unsafe {
6725            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
6726        }
6727        value
6728    }
6729
6730    #[inline]
6731    fn value_type(&self) -> glib::Type {
6732        Self::static_type()
6733    }
6734}
6735
6736impl From<Justification> for glib::Value {
6737    #[inline]
6738    fn from(v: Justification) -> Self {
6739        skip_assert_initialized!();
6740        ToValue::to_value(&v)
6741    }
6742}
6743
6744/// Describes how [`LevelBar`][crate::LevelBar] contents should be rendered.
6745///
6746/// Note that this enumeration could be extended with additional modes
6747/// in the future.
6748#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6749#[non_exhaustive]
6750#[doc(alias = "GtkLevelBarMode")]
6751pub enum LevelBarMode {
6752    /// the bar has a continuous mode
6753    #[doc(alias = "GTK_LEVEL_BAR_MODE_CONTINUOUS")]
6754    Continuous,
6755    /// the bar has a discrete mode
6756    #[doc(alias = "GTK_LEVEL_BAR_MODE_DISCRETE")]
6757    Discrete,
6758    #[doc(hidden)]
6759    __Unknown(i32),
6760}
6761
6762#[doc(hidden)]
6763impl IntoGlib for LevelBarMode {
6764    type GlibType = ffi::GtkLevelBarMode;
6765
6766    #[inline]
6767    fn into_glib(self) -> ffi::GtkLevelBarMode {
6768        match self {
6769            Self::Continuous => ffi::GTK_LEVEL_BAR_MODE_CONTINUOUS,
6770            Self::Discrete => ffi::GTK_LEVEL_BAR_MODE_DISCRETE,
6771            Self::__Unknown(value) => value,
6772        }
6773    }
6774}
6775
6776#[doc(hidden)]
6777impl FromGlib<ffi::GtkLevelBarMode> for LevelBarMode {
6778    #[inline]
6779    unsafe fn from_glib(value: ffi::GtkLevelBarMode) -> Self {
6780        skip_assert_initialized!();
6781
6782        match value {
6783            ffi::GTK_LEVEL_BAR_MODE_CONTINUOUS => Self::Continuous,
6784            ffi::GTK_LEVEL_BAR_MODE_DISCRETE => Self::Discrete,
6785            value => Self::__Unknown(value),
6786        }
6787    }
6788}
6789
6790impl StaticType for LevelBarMode {
6791    #[inline]
6792    #[doc(alias = "gtk_level_bar_mode_get_type")]
6793    fn static_type() -> glib::Type {
6794        unsafe { from_glib(ffi::gtk_level_bar_mode_get_type()) }
6795    }
6796}
6797
6798impl glib::HasParamSpec for LevelBarMode {
6799    type ParamSpec = glib::ParamSpecEnum;
6800    type SetValue = Self;
6801    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
6802
6803    fn param_spec_builder() -> Self::BuilderFn {
6804        Self::ParamSpec::builder_with_default
6805    }
6806}
6807
6808impl glib::value::ValueType for LevelBarMode {
6809    type Type = Self;
6810}
6811
6812unsafe impl<'a> glib::value::FromValue<'a> for LevelBarMode {
6813    type Checker = glib::value::GenericValueTypeChecker<Self>;
6814
6815    #[inline]
6816    unsafe fn from_value(value: &'a glib::Value) -> Self {
6817        skip_assert_initialized!();
6818        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
6819    }
6820}
6821
6822impl ToValue for LevelBarMode {
6823    #[inline]
6824    fn to_value(&self) -> glib::Value {
6825        let mut value = glib::Value::for_value_type::<Self>();
6826        unsafe {
6827            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
6828        }
6829        value
6830    }
6831
6832    #[inline]
6833    fn value_type(&self) -> glib::Type {
6834        Self::static_type()
6835    }
6836}
6837
6838impl From<LevelBarMode> for glib::Value {
6839    #[inline]
6840    fn from(v: LevelBarMode) -> Self {
6841        skip_assert_initialized!();
6842        ToValue::to_value(&v)
6843    }
6844}
6845
6846/// The type of license for an application.
6847///
6848/// This enumeration can be expanded at later date.
6849#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6850#[non_exhaustive]
6851#[doc(alias = "GtkLicense")]
6852pub enum License {
6853    /// No license specified
6854    #[doc(alias = "GTK_LICENSE_UNKNOWN")]
6855    Unknown,
6856    /// A license text is going to be specified by the
6857    ///   developer
6858    #[doc(alias = "GTK_LICENSE_CUSTOM")]
6859    Custom,
6860    /// The GNU General Public License, version 2.0 or later
6861    #[doc(alias = "GTK_LICENSE_GPL_2_0")]
6862    Gpl20,
6863    /// The GNU General Public License, version 3.0 or later
6864    #[doc(alias = "GTK_LICENSE_GPL_3_0")]
6865    Gpl30,
6866    /// The GNU Lesser General Public License, version 2.1 or later
6867    #[doc(alias = "GTK_LICENSE_LGPL_2_1")]
6868    Lgpl21,
6869    /// The GNU Lesser General Public License, version 3.0 or later
6870    #[doc(alias = "GTK_LICENSE_LGPL_3_0")]
6871    Lgpl30,
6872    /// The BSD standard license
6873    #[doc(alias = "GTK_LICENSE_BSD")]
6874    Bsd,
6875    /// The MIT/X11 standard license
6876    #[doc(alias = "GTK_LICENSE_MIT_X11")]
6877    MitX11,
6878    /// The Artistic License, version 2.0
6879    #[doc(alias = "GTK_LICENSE_ARTISTIC")]
6880    Artistic,
6881    /// The GNU General Public License, version 2.0 only
6882    #[doc(alias = "GTK_LICENSE_GPL_2_0_ONLY")]
6883    Gpl20Only,
6884    /// The GNU General Public License, version 3.0 only
6885    #[doc(alias = "GTK_LICENSE_GPL_3_0_ONLY")]
6886    Gpl30Only,
6887    /// The GNU Lesser General Public License, version 2.1 only
6888    #[doc(alias = "GTK_LICENSE_LGPL_2_1_ONLY")]
6889    Lgpl21Only,
6890    /// The GNU Lesser General Public License, version 3.0 only
6891    #[doc(alias = "GTK_LICENSE_LGPL_3_0_ONLY")]
6892    Lgpl30Only,
6893    /// The GNU Affero General Public License, version 3.0 or later
6894    #[doc(alias = "GTK_LICENSE_AGPL_3_0")]
6895    Agpl30,
6896    /// The GNU Affero General Public License, version 3.0 only
6897    #[doc(alias = "GTK_LICENSE_AGPL_3_0_ONLY")]
6898    Agpl30Only,
6899    /// The 3-clause BSD licence
6900    #[doc(alias = "GTK_LICENSE_BSD_3")]
6901    Bsd3,
6902    /// The Apache License, version 2.0
6903    #[doc(alias = "GTK_LICENSE_APACHE_2_0")]
6904    Apache20,
6905    /// The Mozilla Public License, version 2.0
6906    #[doc(alias = "GTK_LICENSE_MPL_2_0")]
6907    Mpl20,
6908    /// Zero-Clause BSD license
6909    #[cfg(feature = "v4_14")]
6910    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
6911    #[doc(alias = "GTK_LICENSE_0BSD")]
6912    _0bsd,
6913    #[doc(hidden)]
6914    __Unknown(i32),
6915}
6916
6917#[doc(hidden)]
6918impl IntoGlib for License {
6919    type GlibType = ffi::GtkLicense;
6920
6921    fn into_glib(self) -> ffi::GtkLicense {
6922        match self {
6923            Self::Unknown => ffi::GTK_LICENSE_UNKNOWN,
6924            Self::Custom => ffi::GTK_LICENSE_CUSTOM,
6925            Self::Gpl20 => ffi::GTK_LICENSE_GPL_2_0,
6926            Self::Gpl30 => ffi::GTK_LICENSE_GPL_3_0,
6927            Self::Lgpl21 => ffi::GTK_LICENSE_LGPL_2_1,
6928            Self::Lgpl30 => ffi::GTK_LICENSE_LGPL_3_0,
6929            Self::Bsd => ffi::GTK_LICENSE_BSD,
6930            Self::MitX11 => ffi::GTK_LICENSE_MIT_X11,
6931            Self::Artistic => ffi::GTK_LICENSE_ARTISTIC,
6932            Self::Gpl20Only => ffi::GTK_LICENSE_GPL_2_0_ONLY,
6933            Self::Gpl30Only => ffi::GTK_LICENSE_GPL_3_0_ONLY,
6934            Self::Lgpl21Only => ffi::GTK_LICENSE_LGPL_2_1_ONLY,
6935            Self::Lgpl30Only => ffi::GTK_LICENSE_LGPL_3_0_ONLY,
6936            Self::Agpl30 => ffi::GTK_LICENSE_AGPL_3_0,
6937            Self::Agpl30Only => ffi::GTK_LICENSE_AGPL_3_0_ONLY,
6938            Self::Bsd3 => ffi::GTK_LICENSE_BSD_3,
6939            Self::Apache20 => ffi::GTK_LICENSE_APACHE_2_0,
6940            Self::Mpl20 => ffi::GTK_LICENSE_MPL_2_0,
6941            #[cfg(feature = "v4_14")]
6942            Self::_0bsd => ffi::GTK_LICENSE_0BSD,
6943            Self::__Unknown(value) => value,
6944        }
6945    }
6946}
6947
6948#[doc(hidden)]
6949impl FromGlib<ffi::GtkLicense> for License {
6950    unsafe fn from_glib(value: ffi::GtkLicense) -> Self {
6951        skip_assert_initialized!();
6952
6953        match value {
6954            ffi::GTK_LICENSE_UNKNOWN => Self::Unknown,
6955            ffi::GTK_LICENSE_CUSTOM => Self::Custom,
6956            ffi::GTK_LICENSE_GPL_2_0 => Self::Gpl20,
6957            ffi::GTK_LICENSE_GPL_3_0 => Self::Gpl30,
6958            ffi::GTK_LICENSE_LGPL_2_1 => Self::Lgpl21,
6959            ffi::GTK_LICENSE_LGPL_3_0 => Self::Lgpl30,
6960            ffi::GTK_LICENSE_BSD => Self::Bsd,
6961            ffi::GTK_LICENSE_MIT_X11 => Self::MitX11,
6962            ffi::GTK_LICENSE_ARTISTIC => Self::Artistic,
6963            ffi::GTK_LICENSE_GPL_2_0_ONLY => Self::Gpl20Only,
6964            ffi::GTK_LICENSE_GPL_3_0_ONLY => Self::Gpl30Only,
6965            ffi::GTK_LICENSE_LGPL_2_1_ONLY => Self::Lgpl21Only,
6966            ffi::GTK_LICENSE_LGPL_3_0_ONLY => Self::Lgpl30Only,
6967            ffi::GTK_LICENSE_AGPL_3_0 => Self::Agpl30,
6968            ffi::GTK_LICENSE_AGPL_3_0_ONLY => Self::Agpl30Only,
6969            ffi::GTK_LICENSE_BSD_3 => Self::Bsd3,
6970            ffi::GTK_LICENSE_APACHE_2_0 => Self::Apache20,
6971            ffi::GTK_LICENSE_MPL_2_0 => Self::Mpl20,
6972            #[cfg(feature = "v4_14")]
6973            ffi::GTK_LICENSE_0BSD => Self::_0bsd,
6974            value => Self::__Unknown(value),
6975        }
6976    }
6977}
6978
6979impl StaticType for License {
6980    #[inline]
6981    #[doc(alias = "gtk_license_get_type")]
6982    fn static_type() -> glib::Type {
6983        unsafe { from_glib(ffi::gtk_license_get_type()) }
6984    }
6985}
6986
6987impl glib::HasParamSpec for License {
6988    type ParamSpec = glib::ParamSpecEnum;
6989    type SetValue = Self;
6990    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
6991
6992    fn param_spec_builder() -> Self::BuilderFn {
6993        Self::ParamSpec::builder_with_default
6994    }
6995}
6996
6997impl glib::value::ValueType for License {
6998    type Type = Self;
6999}
7000
7001unsafe impl<'a> glib::value::FromValue<'a> for License {
7002    type Checker = glib::value::GenericValueTypeChecker<Self>;
7003
7004    #[inline]
7005    unsafe fn from_value(value: &'a glib::Value) -> Self {
7006        skip_assert_initialized!();
7007        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
7008    }
7009}
7010
7011impl ToValue for License {
7012    #[inline]
7013    fn to_value(&self) -> glib::Value {
7014        let mut value = glib::Value::for_value_type::<Self>();
7015        unsafe {
7016            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
7017        }
7018        value
7019    }
7020
7021    #[inline]
7022    fn value_type(&self) -> glib::Type {
7023        Self::static_type()
7024    }
7025}
7026
7027impl From<License> for glib::Value {
7028    #[inline]
7029    fn from(v: License) -> Self {
7030        skip_assert_initialized!();
7031        ToValue::to_value(&v)
7032    }
7033}
7034
7035/// Used to configure the focus behavior in the `GTK_DIR_TAB_FORWARD`
7036/// and `GTK_DIR_TAB_BACKWARD` direction, like the <kbd>Tab</kbd> key
7037/// in a [`ListView`][crate::ListView].
7038#[cfg(feature = "v4_12")]
7039#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
7040#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7041#[non_exhaustive]
7042#[doc(alias = "GtkListTabBehavior")]
7043pub enum ListTabBehavior {
7044    /// Cycle through all focusable items of the list
7045    #[doc(alias = "GTK_LIST_TAB_ALL")]
7046    All,
7047    /// Cycle through a single list element, then move
7048    ///   focus out of the list. Moving focus between items needs to be
7049    ///   done with the arrow keys.
7050    #[doc(alias = "GTK_LIST_TAB_ITEM")]
7051    Item,
7052    /// Cycle only through a single cell, then
7053    ///   move focus out of the list. Moving focus between cells needs to
7054    ///   be done with the arrow keys. This is only relevant for
7055    ///   cell-based widgets like #GtkColumnView, otherwise it behaves
7056    ///   like `GTK_LIST_TAB_ITEM`.
7057    #[doc(alias = "GTK_LIST_TAB_CELL")]
7058    Cell,
7059    #[doc(hidden)]
7060    __Unknown(i32),
7061}
7062
7063#[cfg(feature = "v4_12")]
7064#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
7065#[doc(hidden)]
7066impl IntoGlib for ListTabBehavior {
7067    type GlibType = ffi::GtkListTabBehavior;
7068
7069    #[inline]
7070    fn into_glib(self) -> ffi::GtkListTabBehavior {
7071        match self {
7072            Self::All => ffi::GTK_LIST_TAB_ALL,
7073            Self::Item => ffi::GTK_LIST_TAB_ITEM,
7074            Self::Cell => ffi::GTK_LIST_TAB_CELL,
7075            Self::__Unknown(value) => value,
7076        }
7077    }
7078}
7079
7080#[cfg(feature = "v4_12")]
7081#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
7082#[doc(hidden)]
7083impl FromGlib<ffi::GtkListTabBehavior> for ListTabBehavior {
7084    #[inline]
7085    unsafe fn from_glib(value: ffi::GtkListTabBehavior) -> Self {
7086        skip_assert_initialized!();
7087
7088        match value {
7089            ffi::GTK_LIST_TAB_ALL => Self::All,
7090            ffi::GTK_LIST_TAB_ITEM => Self::Item,
7091            ffi::GTK_LIST_TAB_CELL => Self::Cell,
7092            value => Self::__Unknown(value),
7093        }
7094    }
7095}
7096
7097#[cfg(feature = "v4_12")]
7098#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
7099impl StaticType for ListTabBehavior {
7100    #[inline]
7101    #[doc(alias = "gtk_list_tab_behavior_get_type")]
7102    fn static_type() -> glib::Type {
7103        unsafe { from_glib(ffi::gtk_list_tab_behavior_get_type()) }
7104    }
7105}
7106
7107#[cfg(feature = "v4_12")]
7108#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
7109impl glib::HasParamSpec for ListTabBehavior {
7110    type ParamSpec = glib::ParamSpecEnum;
7111    type SetValue = Self;
7112    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
7113
7114    fn param_spec_builder() -> Self::BuilderFn {
7115        Self::ParamSpec::builder_with_default
7116    }
7117}
7118
7119#[cfg(feature = "v4_12")]
7120#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
7121impl glib::value::ValueType for ListTabBehavior {
7122    type Type = Self;
7123}
7124
7125#[cfg(feature = "v4_12")]
7126#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
7127unsafe impl<'a> glib::value::FromValue<'a> for ListTabBehavior {
7128    type Checker = glib::value::GenericValueTypeChecker<Self>;
7129
7130    #[inline]
7131    unsafe fn from_value(value: &'a glib::Value) -> Self {
7132        skip_assert_initialized!();
7133        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
7134    }
7135}
7136
7137#[cfg(feature = "v4_12")]
7138#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
7139impl ToValue for ListTabBehavior {
7140    #[inline]
7141    fn to_value(&self) -> glib::Value {
7142        let mut value = glib::Value::for_value_type::<Self>();
7143        unsafe {
7144            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
7145        }
7146        value
7147    }
7148
7149    #[inline]
7150    fn value_type(&self) -> glib::Type {
7151        Self::static_type()
7152    }
7153}
7154
7155#[cfg(feature = "v4_12")]
7156#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
7157impl From<ListTabBehavior> for glib::Value {
7158    #[inline]
7159    fn from(v: ListTabBehavior) -> Self {
7160        skip_assert_initialized!();
7161        ToValue::to_value(&v)
7162    }
7163}
7164
7165/// The type of message being displayed in a [`MessageDialog`][crate::MessageDialog].
7166#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7167#[non_exhaustive]
7168#[doc(alias = "GtkMessageType")]
7169pub enum MessageType {
7170    /// Informational message
7171    #[doc(alias = "GTK_MESSAGE_INFO")]
7172    Info,
7173    /// Non-fatal warning message
7174    #[doc(alias = "GTK_MESSAGE_WARNING")]
7175    Warning,
7176    /// Question requiring a choice
7177    #[doc(alias = "GTK_MESSAGE_QUESTION")]
7178    Question,
7179    /// Fatal error message
7180    #[doc(alias = "GTK_MESSAGE_ERROR")]
7181    Error,
7182    /// None of the above
7183    #[doc(alias = "GTK_MESSAGE_OTHER")]
7184    Other,
7185    #[doc(hidden)]
7186    __Unknown(i32),
7187}
7188
7189#[doc(hidden)]
7190impl IntoGlib for MessageType {
7191    type GlibType = ffi::GtkMessageType;
7192
7193    #[inline]
7194    fn into_glib(self) -> ffi::GtkMessageType {
7195        match self {
7196            Self::Info => ffi::GTK_MESSAGE_INFO,
7197            Self::Warning => ffi::GTK_MESSAGE_WARNING,
7198            Self::Question => ffi::GTK_MESSAGE_QUESTION,
7199            Self::Error => ffi::GTK_MESSAGE_ERROR,
7200            Self::Other => ffi::GTK_MESSAGE_OTHER,
7201            Self::__Unknown(value) => value,
7202        }
7203    }
7204}
7205
7206#[doc(hidden)]
7207impl FromGlib<ffi::GtkMessageType> for MessageType {
7208    #[inline]
7209    unsafe fn from_glib(value: ffi::GtkMessageType) -> Self {
7210        skip_assert_initialized!();
7211
7212        match value {
7213            ffi::GTK_MESSAGE_INFO => Self::Info,
7214            ffi::GTK_MESSAGE_WARNING => Self::Warning,
7215            ffi::GTK_MESSAGE_QUESTION => Self::Question,
7216            ffi::GTK_MESSAGE_ERROR => Self::Error,
7217            ffi::GTK_MESSAGE_OTHER => Self::Other,
7218            value => Self::__Unknown(value),
7219        }
7220    }
7221}
7222
7223impl StaticType for MessageType {
7224    #[inline]
7225    #[doc(alias = "gtk_message_type_get_type")]
7226    fn static_type() -> glib::Type {
7227        unsafe { from_glib(ffi::gtk_message_type_get_type()) }
7228    }
7229}
7230
7231impl glib::HasParamSpec for MessageType {
7232    type ParamSpec = glib::ParamSpecEnum;
7233    type SetValue = Self;
7234    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
7235
7236    fn param_spec_builder() -> Self::BuilderFn {
7237        Self::ParamSpec::builder_with_default
7238    }
7239}
7240
7241impl glib::value::ValueType for MessageType {
7242    type Type = Self;
7243}
7244
7245unsafe impl<'a> glib::value::FromValue<'a> for MessageType {
7246    type Checker = glib::value::GenericValueTypeChecker<Self>;
7247
7248    #[inline]
7249    unsafe fn from_value(value: &'a glib::Value) -> Self {
7250        skip_assert_initialized!();
7251        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
7252    }
7253}
7254
7255impl ToValue for MessageType {
7256    #[inline]
7257    fn to_value(&self) -> glib::Value {
7258        let mut value = glib::Value::for_value_type::<Self>();
7259        unsafe {
7260            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
7261        }
7262        value
7263    }
7264
7265    #[inline]
7266    fn value_type(&self) -> glib::Type {
7267        Self::static_type()
7268    }
7269}
7270
7271impl From<MessageType> for glib::Value {
7272    #[inline]
7273    fn from(v: MessageType) -> Self {
7274        skip_assert_initialized!();
7275        ToValue::to_value(&v)
7276    }
7277}
7278
7279/// Passed as argument to various keybinding signals for moving the
7280/// cursor position.
7281#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7282#[non_exhaustive]
7283#[doc(alias = "GtkMovementStep")]
7284pub enum MovementStep {
7285    /// Move forward or back by graphemes
7286    #[doc(alias = "GTK_MOVEMENT_LOGICAL_POSITIONS")]
7287    LogicalPositions,
7288    /// Move left or right by graphemes
7289    #[doc(alias = "GTK_MOVEMENT_VISUAL_POSITIONS")]
7290    VisualPositions,
7291    /// Move forward or back by words
7292    #[doc(alias = "GTK_MOVEMENT_WORDS")]
7293    Words,
7294    /// Move up or down lines (wrapped lines)
7295    #[doc(alias = "GTK_MOVEMENT_DISPLAY_LINES")]
7296    DisplayLines,
7297    /// Move to either end of a line
7298    #[doc(alias = "GTK_MOVEMENT_DISPLAY_LINE_ENDS")]
7299    DisplayLineEnds,
7300    /// Move up or down paragraphs (newline-ended lines)
7301    #[doc(alias = "GTK_MOVEMENT_PARAGRAPHS")]
7302    Paragraphs,
7303    /// Move to either end of a paragraph
7304    #[doc(alias = "GTK_MOVEMENT_PARAGRAPH_ENDS")]
7305    ParagraphEnds,
7306    /// Move by pages
7307    #[doc(alias = "GTK_MOVEMENT_PAGES")]
7308    Pages,
7309    /// Move to ends of the buffer
7310    #[doc(alias = "GTK_MOVEMENT_BUFFER_ENDS")]
7311    BufferEnds,
7312    /// Move horizontally by pages
7313    #[doc(alias = "GTK_MOVEMENT_HORIZONTAL_PAGES")]
7314    HorizontalPages,
7315    #[doc(hidden)]
7316    __Unknown(i32),
7317}
7318
7319#[doc(hidden)]
7320impl IntoGlib for MovementStep {
7321    type GlibType = ffi::GtkMovementStep;
7322
7323    #[inline]
7324    fn into_glib(self) -> ffi::GtkMovementStep {
7325        match self {
7326            Self::LogicalPositions => ffi::GTK_MOVEMENT_LOGICAL_POSITIONS,
7327            Self::VisualPositions => ffi::GTK_MOVEMENT_VISUAL_POSITIONS,
7328            Self::Words => ffi::GTK_MOVEMENT_WORDS,
7329            Self::DisplayLines => ffi::GTK_MOVEMENT_DISPLAY_LINES,
7330            Self::DisplayLineEnds => ffi::GTK_MOVEMENT_DISPLAY_LINE_ENDS,
7331            Self::Paragraphs => ffi::GTK_MOVEMENT_PARAGRAPHS,
7332            Self::ParagraphEnds => ffi::GTK_MOVEMENT_PARAGRAPH_ENDS,
7333            Self::Pages => ffi::GTK_MOVEMENT_PAGES,
7334            Self::BufferEnds => ffi::GTK_MOVEMENT_BUFFER_ENDS,
7335            Self::HorizontalPages => ffi::GTK_MOVEMENT_HORIZONTAL_PAGES,
7336            Self::__Unknown(value) => value,
7337        }
7338    }
7339}
7340
7341#[doc(hidden)]
7342impl FromGlib<ffi::GtkMovementStep> for MovementStep {
7343    #[inline]
7344    unsafe fn from_glib(value: ffi::GtkMovementStep) -> Self {
7345        skip_assert_initialized!();
7346
7347        match value {
7348            ffi::GTK_MOVEMENT_LOGICAL_POSITIONS => Self::LogicalPositions,
7349            ffi::GTK_MOVEMENT_VISUAL_POSITIONS => Self::VisualPositions,
7350            ffi::GTK_MOVEMENT_WORDS => Self::Words,
7351            ffi::GTK_MOVEMENT_DISPLAY_LINES => Self::DisplayLines,
7352            ffi::GTK_MOVEMENT_DISPLAY_LINE_ENDS => Self::DisplayLineEnds,
7353            ffi::GTK_MOVEMENT_PARAGRAPHS => Self::Paragraphs,
7354            ffi::GTK_MOVEMENT_PARAGRAPH_ENDS => Self::ParagraphEnds,
7355            ffi::GTK_MOVEMENT_PAGES => Self::Pages,
7356            ffi::GTK_MOVEMENT_BUFFER_ENDS => Self::BufferEnds,
7357            ffi::GTK_MOVEMENT_HORIZONTAL_PAGES => Self::HorizontalPages,
7358            value => Self::__Unknown(value),
7359        }
7360    }
7361}
7362
7363impl StaticType for MovementStep {
7364    #[inline]
7365    #[doc(alias = "gtk_movement_step_get_type")]
7366    fn static_type() -> glib::Type {
7367        unsafe { from_glib(ffi::gtk_movement_step_get_type()) }
7368    }
7369}
7370
7371impl glib::HasParamSpec for MovementStep {
7372    type ParamSpec = glib::ParamSpecEnum;
7373    type SetValue = Self;
7374    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
7375
7376    fn param_spec_builder() -> Self::BuilderFn {
7377        Self::ParamSpec::builder_with_default
7378    }
7379}
7380
7381impl glib::value::ValueType for MovementStep {
7382    type Type = Self;
7383}
7384
7385unsafe impl<'a> glib::value::FromValue<'a> for MovementStep {
7386    type Checker = glib::value::GenericValueTypeChecker<Self>;
7387
7388    #[inline]
7389    unsafe fn from_value(value: &'a glib::Value) -> Self {
7390        skip_assert_initialized!();
7391        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
7392    }
7393}
7394
7395impl ToValue for MovementStep {
7396    #[inline]
7397    fn to_value(&self) -> glib::Value {
7398        let mut value = glib::Value::for_value_type::<Self>();
7399        unsafe {
7400            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
7401        }
7402        value
7403    }
7404
7405    #[inline]
7406    fn value_type(&self) -> glib::Type {
7407        Self::static_type()
7408    }
7409}
7410
7411impl From<MovementStep> for glib::Value {
7412    #[inline]
7413    fn from(v: MovementStep) -> Self {
7414        skip_assert_initialized!();
7415        ToValue::to_value(&v)
7416    }
7417}
7418
7419/// Options for selecting a different wrap mode for natural size
7420/// requests.
7421///
7422/// See for example the [`natural-wrap-mode`][struct@crate::Label#natural-wrap-mode] property.
7423#[cfg(feature = "v4_6")]
7424#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
7425#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7426#[non_exhaustive]
7427#[doc(alias = "GtkNaturalWrapMode")]
7428pub enum NaturalWrapMode {
7429    /// Inherit the minimum size request.
7430    ///   In particular, this should be used with [`pango::WrapMode::Char`][crate::pango::WrapMode::Char].
7431    #[doc(alias = "GTK_NATURAL_WRAP_INHERIT")]
7432    Inherit,
7433    /// Try not to wrap the text. This mode is the
7434    ///   closest to GTK3's behavior but can lead to a wide label leaving
7435    ///   lots of empty space below the text.
7436    #[doc(alias = "GTK_NATURAL_WRAP_NONE")]
7437    None,
7438    /// Attempt to wrap at word boundaries. This
7439    ///   is useful in particular when using [`pango::WrapMode::WordChar`][crate::pango::WrapMode::WordChar] as the
7440    ///   wrap mode.
7441    #[doc(alias = "GTK_NATURAL_WRAP_WORD")]
7442    Word,
7443    #[doc(hidden)]
7444    __Unknown(i32),
7445}
7446
7447#[cfg(feature = "v4_6")]
7448#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
7449#[doc(hidden)]
7450impl IntoGlib for NaturalWrapMode {
7451    type GlibType = ffi::GtkNaturalWrapMode;
7452
7453    #[inline]
7454    fn into_glib(self) -> ffi::GtkNaturalWrapMode {
7455        match self {
7456            Self::Inherit => ffi::GTK_NATURAL_WRAP_INHERIT,
7457            Self::None => ffi::GTK_NATURAL_WRAP_NONE,
7458            Self::Word => ffi::GTK_NATURAL_WRAP_WORD,
7459            Self::__Unknown(value) => value,
7460        }
7461    }
7462}
7463
7464#[cfg(feature = "v4_6")]
7465#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
7466#[doc(hidden)]
7467impl FromGlib<ffi::GtkNaturalWrapMode> for NaturalWrapMode {
7468    #[inline]
7469    unsafe fn from_glib(value: ffi::GtkNaturalWrapMode) -> Self {
7470        skip_assert_initialized!();
7471
7472        match value {
7473            ffi::GTK_NATURAL_WRAP_INHERIT => Self::Inherit,
7474            ffi::GTK_NATURAL_WRAP_NONE => Self::None,
7475            ffi::GTK_NATURAL_WRAP_WORD => Self::Word,
7476            value => Self::__Unknown(value),
7477        }
7478    }
7479}
7480
7481#[cfg(feature = "v4_6")]
7482#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
7483impl StaticType for NaturalWrapMode {
7484    #[inline]
7485    #[doc(alias = "gtk_natural_wrap_mode_get_type")]
7486    fn static_type() -> glib::Type {
7487        unsafe { from_glib(ffi::gtk_natural_wrap_mode_get_type()) }
7488    }
7489}
7490
7491#[cfg(feature = "v4_6")]
7492#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
7493impl glib::HasParamSpec for NaturalWrapMode {
7494    type ParamSpec = glib::ParamSpecEnum;
7495    type SetValue = Self;
7496    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
7497
7498    fn param_spec_builder() -> Self::BuilderFn {
7499        Self::ParamSpec::builder_with_default
7500    }
7501}
7502
7503#[cfg(feature = "v4_6")]
7504#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
7505impl glib::value::ValueType for NaturalWrapMode {
7506    type Type = Self;
7507}
7508
7509#[cfg(feature = "v4_6")]
7510#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
7511unsafe impl<'a> glib::value::FromValue<'a> for NaturalWrapMode {
7512    type Checker = glib::value::GenericValueTypeChecker<Self>;
7513
7514    #[inline]
7515    unsafe fn from_value(value: &'a glib::Value) -> Self {
7516        skip_assert_initialized!();
7517        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
7518    }
7519}
7520
7521#[cfg(feature = "v4_6")]
7522#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
7523impl ToValue for NaturalWrapMode {
7524    #[inline]
7525    fn to_value(&self) -> glib::Value {
7526        let mut value = glib::Value::for_value_type::<Self>();
7527        unsafe {
7528            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
7529        }
7530        value
7531    }
7532
7533    #[inline]
7534    fn value_type(&self) -> glib::Type {
7535        Self::static_type()
7536    }
7537}
7538
7539#[cfg(feature = "v4_6")]
7540#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
7541impl From<NaturalWrapMode> for glib::Value {
7542    #[inline]
7543    fn from(v: NaturalWrapMode) -> Self {
7544        skip_assert_initialized!();
7545        ToValue::to_value(&v)
7546    }
7547}
7548
7549/// The parameter used in the action signals of [`Notebook`][crate::Notebook].
7550#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7551#[non_exhaustive]
7552#[doc(alias = "GtkNotebookTab")]
7553pub enum NotebookTab {
7554    /// the first tab in the notebook
7555    #[doc(alias = "GTK_NOTEBOOK_TAB_FIRST")]
7556    First,
7557    /// the last tab in the notebook
7558    #[doc(alias = "GTK_NOTEBOOK_TAB_LAST")]
7559    Last,
7560    #[doc(hidden)]
7561    __Unknown(i32),
7562}
7563
7564#[doc(hidden)]
7565impl IntoGlib for NotebookTab {
7566    type GlibType = ffi::GtkNotebookTab;
7567
7568    #[inline]
7569    fn into_glib(self) -> ffi::GtkNotebookTab {
7570        match self {
7571            Self::First => ffi::GTK_NOTEBOOK_TAB_FIRST,
7572            Self::Last => ffi::GTK_NOTEBOOK_TAB_LAST,
7573            Self::__Unknown(value) => value,
7574        }
7575    }
7576}
7577
7578#[doc(hidden)]
7579impl FromGlib<ffi::GtkNotebookTab> for NotebookTab {
7580    #[inline]
7581    unsafe fn from_glib(value: ffi::GtkNotebookTab) -> Self {
7582        skip_assert_initialized!();
7583
7584        match value {
7585            ffi::GTK_NOTEBOOK_TAB_FIRST => Self::First,
7586            ffi::GTK_NOTEBOOK_TAB_LAST => Self::Last,
7587            value => Self::__Unknown(value),
7588        }
7589    }
7590}
7591
7592impl StaticType for NotebookTab {
7593    #[inline]
7594    #[doc(alias = "gtk_notebook_tab_get_type")]
7595    fn static_type() -> glib::Type {
7596        unsafe { from_glib(ffi::gtk_notebook_tab_get_type()) }
7597    }
7598}
7599
7600impl glib::HasParamSpec for NotebookTab {
7601    type ParamSpec = glib::ParamSpecEnum;
7602    type SetValue = Self;
7603    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
7604
7605    fn param_spec_builder() -> Self::BuilderFn {
7606        Self::ParamSpec::builder_with_default
7607    }
7608}
7609
7610impl glib::value::ValueType for NotebookTab {
7611    type Type = Self;
7612}
7613
7614unsafe impl<'a> glib::value::FromValue<'a> for NotebookTab {
7615    type Checker = glib::value::GenericValueTypeChecker<Self>;
7616
7617    #[inline]
7618    unsafe fn from_value(value: &'a glib::Value) -> Self {
7619        skip_assert_initialized!();
7620        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
7621    }
7622}
7623
7624impl ToValue for NotebookTab {
7625    #[inline]
7626    fn to_value(&self) -> glib::Value {
7627        let mut value = glib::Value::for_value_type::<Self>();
7628        unsafe {
7629            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
7630        }
7631        value
7632    }
7633
7634    #[inline]
7635    fn value_type(&self) -> glib::Type {
7636        Self::static_type()
7637    }
7638}
7639
7640impl From<NotebookTab> for glib::Value {
7641    #[inline]
7642    fn from(v: NotebookTab) -> Self {
7643        skip_assert_initialized!();
7644        ToValue::to_value(&v)
7645    }
7646}
7647
7648/// Used to determine the layout of pages on a sheet when printing
7649/// multiple pages per sheet.
7650#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7651#[non_exhaustive]
7652#[doc(alias = "GtkNumberUpLayout")]
7653pub enum NumberUpLayout {
7654    /// ![](layout-lrtb.png)
7655    #[doc(alias = "GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM")]
7656    Lrtb,
7657    /// ![](layout-lrbt.png)
7658    #[doc(alias = "GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_BOTTOM_TO_TOP")]
7659    Lrbt,
7660    /// ![](layout-rltb.png)
7661    #[doc(alias = "GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM")]
7662    Rltb,
7663    /// ![](layout-rlbt.png)
7664    #[doc(alias = "GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_BOTTOM_TO_TOP")]
7665    Rlbt,
7666    /// ![](layout-tblr.png)
7667    #[doc(alias = "GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_LEFT_TO_RIGHT")]
7668    Tblr,
7669    /// ![](layout-tbrl.png)
7670    #[doc(alias = "GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_RIGHT_TO_LEFT")]
7671    Tbrl,
7672    /// ![](layout-btlr.png)
7673    #[doc(alias = "GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_LEFT_TO_RIGHT")]
7674    Btlr,
7675    /// ![](layout-btrl.png)
7676    #[doc(alias = "GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_RIGHT_TO_LEFT")]
7677    Btrl,
7678    #[doc(hidden)]
7679    __Unknown(i32),
7680}
7681
7682#[doc(hidden)]
7683impl IntoGlib for NumberUpLayout {
7684    type GlibType = ffi::GtkNumberUpLayout;
7685
7686    #[inline]
7687    fn into_glib(self) -> ffi::GtkNumberUpLayout {
7688        match self {
7689            Self::Lrtb => ffi::GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM,
7690            Self::Lrbt => ffi::GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_BOTTOM_TO_TOP,
7691            Self::Rltb => ffi::GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM,
7692            Self::Rlbt => ffi::GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_BOTTOM_TO_TOP,
7693            Self::Tblr => ffi::GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_LEFT_TO_RIGHT,
7694            Self::Tbrl => ffi::GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_RIGHT_TO_LEFT,
7695            Self::Btlr => ffi::GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_LEFT_TO_RIGHT,
7696            Self::Btrl => ffi::GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_RIGHT_TO_LEFT,
7697            Self::__Unknown(value) => value,
7698        }
7699    }
7700}
7701
7702#[doc(hidden)]
7703impl FromGlib<ffi::GtkNumberUpLayout> for NumberUpLayout {
7704    #[inline]
7705    unsafe fn from_glib(value: ffi::GtkNumberUpLayout) -> Self {
7706        skip_assert_initialized!();
7707
7708        match value {
7709            ffi::GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM => Self::Lrtb,
7710            ffi::GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_BOTTOM_TO_TOP => Self::Lrbt,
7711            ffi::GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM => Self::Rltb,
7712            ffi::GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_BOTTOM_TO_TOP => Self::Rlbt,
7713            ffi::GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_LEFT_TO_RIGHT => Self::Tblr,
7714            ffi::GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_RIGHT_TO_LEFT => Self::Tbrl,
7715            ffi::GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_LEFT_TO_RIGHT => Self::Btlr,
7716            ffi::GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_RIGHT_TO_LEFT => Self::Btrl,
7717            value => Self::__Unknown(value),
7718        }
7719    }
7720}
7721
7722impl StaticType for NumberUpLayout {
7723    #[inline]
7724    #[doc(alias = "gtk_number_up_layout_get_type")]
7725    fn static_type() -> glib::Type {
7726        unsafe { from_glib(ffi::gtk_number_up_layout_get_type()) }
7727    }
7728}
7729
7730impl glib::HasParamSpec for NumberUpLayout {
7731    type ParamSpec = glib::ParamSpecEnum;
7732    type SetValue = Self;
7733    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
7734
7735    fn param_spec_builder() -> Self::BuilderFn {
7736        Self::ParamSpec::builder_with_default
7737    }
7738}
7739
7740impl glib::value::ValueType for NumberUpLayout {
7741    type Type = Self;
7742}
7743
7744unsafe impl<'a> glib::value::FromValue<'a> for NumberUpLayout {
7745    type Checker = glib::value::GenericValueTypeChecker<Self>;
7746
7747    #[inline]
7748    unsafe fn from_value(value: &'a glib::Value) -> Self {
7749        skip_assert_initialized!();
7750        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
7751    }
7752}
7753
7754impl ToValue for NumberUpLayout {
7755    #[inline]
7756    fn to_value(&self) -> glib::Value {
7757        let mut value = glib::Value::for_value_type::<Self>();
7758        unsafe {
7759            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
7760        }
7761        value
7762    }
7763
7764    #[inline]
7765    fn value_type(&self) -> glib::Type {
7766        Self::static_type()
7767    }
7768}
7769
7770impl From<NumberUpLayout> for glib::Value {
7771    #[inline]
7772    fn from(v: NumberUpLayout) -> Self {
7773        skip_assert_initialized!();
7774        ToValue::to_value(&v)
7775    }
7776}
7777
7778/// Describes the way two values can be compared.
7779///
7780/// These values can be used with a `callback::GLib::CompareFunc. However,
7781/// a `GCompareFunc` is allowed to return any integer values.
7782/// For converting such a value to a [`Ordering`][crate::Ordering] value, use
7783/// `Gtk::Ordering::from_cmpfunc()`.
7784#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7785#[non_exhaustive]
7786#[doc(alias = "GtkOrdering")]
7787pub enum Ordering {
7788    /// the first value is smaller than the second
7789    #[doc(alias = "GTK_ORDERING_SMALLER")]
7790    Smaller,
7791    /// the two values are equal
7792    #[doc(alias = "GTK_ORDERING_EQUAL")]
7793    Equal,
7794    /// the first value is larger than the second
7795    #[doc(alias = "GTK_ORDERING_LARGER")]
7796    Larger,
7797    #[doc(hidden)]
7798    __Unknown(i32),
7799}
7800
7801#[doc(hidden)]
7802impl IntoGlib for Ordering {
7803    type GlibType = ffi::GtkOrdering;
7804
7805    #[inline]
7806    fn into_glib(self) -> ffi::GtkOrdering {
7807        match self {
7808            Self::Smaller => ffi::GTK_ORDERING_SMALLER,
7809            Self::Equal => ffi::GTK_ORDERING_EQUAL,
7810            Self::Larger => ffi::GTK_ORDERING_LARGER,
7811            Self::__Unknown(value) => value,
7812        }
7813    }
7814}
7815
7816#[doc(hidden)]
7817impl FromGlib<ffi::GtkOrdering> for Ordering {
7818    #[inline]
7819    unsafe fn from_glib(value: ffi::GtkOrdering) -> Self {
7820        skip_assert_initialized!();
7821
7822        match value {
7823            ffi::GTK_ORDERING_SMALLER => Self::Smaller,
7824            ffi::GTK_ORDERING_EQUAL => Self::Equal,
7825            ffi::GTK_ORDERING_LARGER => Self::Larger,
7826            value => Self::__Unknown(value),
7827        }
7828    }
7829}
7830
7831impl StaticType for Ordering {
7832    #[inline]
7833    #[doc(alias = "gtk_ordering_get_type")]
7834    fn static_type() -> glib::Type {
7835        unsafe { from_glib(ffi::gtk_ordering_get_type()) }
7836    }
7837}
7838
7839impl glib::HasParamSpec for Ordering {
7840    type ParamSpec = glib::ParamSpecEnum;
7841    type SetValue = Self;
7842    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
7843
7844    fn param_spec_builder() -> Self::BuilderFn {
7845        Self::ParamSpec::builder_with_default
7846    }
7847}
7848
7849impl glib::value::ValueType for Ordering {
7850    type Type = Self;
7851}
7852
7853unsafe impl<'a> glib::value::FromValue<'a> for Ordering {
7854    type Checker = glib::value::GenericValueTypeChecker<Self>;
7855
7856    #[inline]
7857    unsafe fn from_value(value: &'a glib::Value) -> Self {
7858        skip_assert_initialized!();
7859        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
7860    }
7861}
7862
7863impl ToValue for Ordering {
7864    #[inline]
7865    fn to_value(&self) -> glib::Value {
7866        let mut value = glib::Value::for_value_type::<Self>();
7867        unsafe {
7868            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
7869        }
7870        value
7871    }
7872
7873    #[inline]
7874    fn value_type(&self) -> glib::Type {
7875        Self::static_type()
7876    }
7877}
7878
7879impl From<Ordering> for glib::Value {
7880    #[inline]
7881    fn from(v: Ordering) -> Self {
7882        skip_assert_initialized!();
7883        ToValue::to_value(&v)
7884    }
7885}
7886
7887/// Represents the orientation of widgets and other objects.
7888///
7889/// Typical examples are [`Box`][crate::Box] or [`GesturePan`][crate::GesturePan].
7890#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7891#[non_exhaustive]
7892#[doc(alias = "GtkOrientation")]
7893pub enum Orientation {
7894    /// The element is in horizontal orientation.
7895    #[doc(alias = "GTK_ORIENTATION_HORIZONTAL")]
7896    Horizontal,
7897    /// The element is in vertical orientation.
7898    #[doc(alias = "GTK_ORIENTATION_VERTICAL")]
7899    Vertical,
7900    #[doc(hidden)]
7901    __Unknown(i32),
7902}
7903
7904#[doc(hidden)]
7905impl IntoGlib for Orientation {
7906    type GlibType = ffi::GtkOrientation;
7907
7908    #[inline]
7909    fn into_glib(self) -> ffi::GtkOrientation {
7910        match self {
7911            Self::Horizontal => ffi::GTK_ORIENTATION_HORIZONTAL,
7912            Self::Vertical => ffi::GTK_ORIENTATION_VERTICAL,
7913            Self::__Unknown(value) => value,
7914        }
7915    }
7916}
7917
7918#[doc(hidden)]
7919impl FromGlib<ffi::GtkOrientation> for Orientation {
7920    #[inline]
7921    unsafe fn from_glib(value: ffi::GtkOrientation) -> Self {
7922        skip_assert_initialized!();
7923
7924        match value {
7925            ffi::GTK_ORIENTATION_HORIZONTAL => Self::Horizontal,
7926            ffi::GTK_ORIENTATION_VERTICAL => Self::Vertical,
7927            value => Self::__Unknown(value),
7928        }
7929    }
7930}
7931
7932impl StaticType for Orientation {
7933    #[inline]
7934    #[doc(alias = "gtk_orientation_get_type")]
7935    fn static_type() -> glib::Type {
7936        unsafe { from_glib(ffi::gtk_orientation_get_type()) }
7937    }
7938}
7939
7940impl glib::HasParamSpec for Orientation {
7941    type ParamSpec = glib::ParamSpecEnum;
7942    type SetValue = Self;
7943    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
7944
7945    fn param_spec_builder() -> Self::BuilderFn {
7946        Self::ParamSpec::builder_with_default
7947    }
7948}
7949
7950impl glib::value::ValueType for Orientation {
7951    type Type = Self;
7952}
7953
7954unsafe impl<'a> glib::value::FromValue<'a> for Orientation {
7955    type Checker = glib::value::GenericValueTypeChecker<Self>;
7956
7957    #[inline]
7958    unsafe fn from_value(value: &'a glib::Value) -> Self {
7959        skip_assert_initialized!();
7960        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
7961    }
7962}
7963
7964impl ToValue for Orientation {
7965    #[inline]
7966    fn to_value(&self) -> glib::Value {
7967        let mut value = glib::Value::for_value_type::<Self>();
7968        unsafe {
7969            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
7970        }
7971        value
7972    }
7973
7974    #[inline]
7975    fn value_type(&self) -> glib::Type {
7976        Self::static_type()
7977    }
7978}
7979
7980impl From<Orientation> for glib::Value {
7981    #[inline]
7982    fn from(v: Orientation) -> Self {
7983        skip_assert_initialized!();
7984        ToValue::to_value(&v)
7985    }
7986}
7987
7988/// Defines how content overflowing a given area should be handled.
7989///
7990/// This is used in [`WidgetExt::set_overflow()`][crate::prelude::WidgetExt::set_overflow()]. The
7991/// [`overflow`][struct@crate::Widget#overflow] property is modeled after the
7992/// CSS overflow property, but implements it only partially.
7993#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7994#[non_exhaustive]
7995#[doc(alias = "GtkOverflow")]
7996pub enum Overflow {
7997    /// No change is applied. Content is drawn at the specified
7998    ///   position.
7999    #[doc(alias = "GTK_OVERFLOW_VISIBLE")]
8000    Visible,
8001    /// Content is clipped to the bounds of the area. Content
8002    ///   outside the area is not drawn and cannot be interacted with.
8003    #[doc(alias = "GTK_OVERFLOW_HIDDEN")]
8004    Hidden,
8005    #[doc(hidden)]
8006    __Unknown(i32),
8007}
8008
8009#[doc(hidden)]
8010impl IntoGlib for Overflow {
8011    type GlibType = ffi::GtkOverflow;
8012
8013    #[inline]
8014    fn into_glib(self) -> ffi::GtkOverflow {
8015        match self {
8016            Self::Visible => ffi::GTK_OVERFLOW_VISIBLE,
8017            Self::Hidden => ffi::GTK_OVERFLOW_HIDDEN,
8018            Self::__Unknown(value) => value,
8019        }
8020    }
8021}
8022
8023#[doc(hidden)]
8024impl FromGlib<ffi::GtkOverflow> for Overflow {
8025    #[inline]
8026    unsafe fn from_glib(value: ffi::GtkOverflow) -> Self {
8027        skip_assert_initialized!();
8028
8029        match value {
8030            ffi::GTK_OVERFLOW_VISIBLE => Self::Visible,
8031            ffi::GTK_OVERFLOW_HIDDEN => Self::Hidden,
8032            value => Self::__Unknown(value),
8033        }
8034    }
8035}
8036
8037impl StaticType for Overflow {
8038    #[inline]
8039    #[doc(alias = "gtk_overflow_get_type")]
8040    fn static_type() -> glib::Type {
8041        unsafe { from_glib(ffi::gtk_overflow_get_type()) }
8042    }
8043}
8044
8045impl glib::HasParamSpec for Overflow {
8046    type ParamSpec = glib::ParamSpecEnum;
8047    type SetValue = Self;
8048    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
8049
8050    fn param_spec_builder() -> Self::BuilderFn {
8051        Self::ParamSpec::builder_with_default
8052    }
8053}
8054
8055impl glib::value::ValueType for Overflow {
8056    type Type = Self;
8057}
8058
8059unsafe impl<'a> glib::value::FromValue<'a> for Overflow {
8060    type Checker = glib::value::GenericValueTypeChecker<Self>;
8061
8062    #[inline]
8063    unsafe fn from_value(value: &'a glib::Value) -> Self {
8064        skip_assert_initialized!();
8065        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
8066    }
8067}
8068
8069impl ToValue for Overflow {
8070    #[inline]
8071    fn to_value(&self) -> glib::Value {
8072        let mut value = glib::Value::for_value_type::<Self>();
8073        unsafe {
8074            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
8075        }
8076        value
8077    }
8078
8079    #[inline]
8080    fn value_type(&self) -> glib::Type {
8081        Self::static_type()
8082    }
8083}
8084
8085impl From<Overflow> for glib::Value {
8086    #[inline]
8087    fn from(v: Overflow) -> Self {
8088        skip_assert_initialized!();
8089        ToValue::to_value(&v)
8090    }
8091}
8092
8093/// Represents the packing location of a children in its parent.
8094///
8095/// See [`WindowControls`][crate::WindowControls] for example.
8096#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
8097#[non_exhaustive]
8098#[doc(alias = "GtkPackType")]
8099pub enum PackType {
8100    /// The child is packed into the start of the widget
8101    #[doc(alias = "GTK_PACK_START")]
8102    Start,
8103    /// The child is packed into the end of the widget
8104    #[doc(alias = "GTK_PACK_END")]
8105    End,
8106    #[doc(hidden)]
8107    __Unknown(i32),
8108}
8109
8110#[doc(hidden)]
8111impl IntoGlib for PackType {
8112    type GlibType = ffi::GtkPackType;
8113
8114    #[inline]
8115    fn into_glib(self) -> ffi::GtkPackType {
8116        match self {
8117            Self::Start => ffi::GTK_PACK_START,
8118            Self::End => ffi::GTK_PACK_END,
8119            Self::__Unknown(value) => value,
8120        }
8121    }
8122}
8123
8124#[doc(hidden)]
8125impl FromGlib<ffi::GtkPackType> for PackType {
8126    #[inline]
8127    unsafe fn from_glib(value: ffi::GtkPackType) -> Self {
8128        skip_assert_initialized!();
8129
8130        match value {
8131            ffi::GTK_PACK_START => Self::Start,
8132            ffi::GTK_PACK_END => Self::End,
8133            value => Self::__Unknown(value),
8134        }
8135    }
8136}
8137
8138impl StaticType for PackType {
8139    #[inline]
8140    #[doc(alias = "gtk_pack_type_get_type")]
8141    fn static_type() -> glib::Type {
8142        unsafe { from_glib(ffi::gtk_pack_type_get_type()) }
8143    }
8144}
8145
8146impl glib::HasParamSpec for PackType {
8147    type ParamSpec = glib::ParamSpecEnum;
8148    type SetValue = Self;
8149    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
8150
8151    fn param_spec_builder() -> Self::BuilderFn {
8152        Self::ParamSpec::builder_with_default
8153    }
8154}
8155
8156impl glib::value::ValueType for PackType {
8157    type Type = Self;
8158}
8159
8160unsafe impl<'a> glib::value::FromValue<'a> for PackType {
8161    type Checker = glib::value::GenericValueTypeChecker<Self>;
8162
8163    #[inline]
8164    unsafe fn from_value(value: &'a glib::Value) -> Self {
8165        skip_assert_initialized!();
8166        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
8167    }
8168}
8169
8170impl ToValue for PackType {
8171    #[inline]
8172    fn to_value(&self) -> glib::Value {
8173        let mut value = glib::Value::for_value_type::<Self>();
8174        unsafe {
8175            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
8176        }
8177        value
8178    }
8179
8180    #[inline]
8181    fn value_type(&self) -> glib::Type {
8182        Self::static_type()
8183    }
8184}
8185
8186impl From<PackType> for glib::Value {
8187    #[inline]
8188    fn from(v: PackType) -> Self {
8189        skip_assert_initialized!();
8190        ToValue::to_value(&v)
8191    }
8192}
8193
8194/// The type of a pad action.
8195#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
8196#[non_exhaustive]
8197#[doc(alias = "GtkPadActionType")]
8198pub enum PadActionType {
8199    /// Action is triggered by a pad button
8200    #[doc(alias = "GTK_PAD_ACTION_BUTTON")]
8201    Button,
8202    /// Action is triggered by a pad ring
8203    #[doc(alias = "GTK_PAD_ACTION_RING")]
8204    Ring,
8205    /// Action is triggered by a pad strip
8206    #[doc(alias = "GTK_PAD_ACTION_STRIP")]
8207    Strip,
8208    #[doc(hidden)]
8209    __Unknown(i32),
8210}
8211
8212#[doc(hidden)]
8213impl IntoGlib for PadActionType {
8214    type GlibType = ffi::GtkPadActionType;
8215
8216    #[inline]
8217    fn into_glib(self) -> ffi::GtkPadActionType {
8218        match self {
8219            Self::Button => ffi::GTK_PAD_ACTION_BUTTON,
8220            Self::Ring => ffi::GTK_PAD_ACTION_RING,
8221            Self::Strip => ffi::GTK_PAD_ACTION_STRIP,
8222            Self::__Unknown(value) => value,
8223        }
8224    }
8225}
8226
8227#[doc(hidden)]
8228impl FromGlib<ffi::GtkPadActionType> for PadActionType {
8229    #[inline]
8230    unsafe fn from_glib(value: ffi::GtkPadActionType) -> Self {
8231        skip_assert_initialized!();
8232
8233        match value {
8234            ffi::GTK_PAD_ACTION_BUTTON => Self::Button,
8235            ffi::GTK_PAD_ACTION_RING => Self::Ring,
8236            ffi::GTK_PAD_ACTION_STRIP => Self::Strip,
8237            value => Self::__Unknown(value),
8238        }
8239    }
8240}
8241
8242impl StaticType for PadActionType {
8243    #[inline]
8244    #[doc(alias = "gtk_pad_action_type_get_type")]
8245    fn static_type() -> glib::Type {
8246        unsafe { from_glib(ffi::gtk_pad_action_type_get_type()) }
8247    }
8248}
8249
8250impl glib::HasParamSpec for PadActionType {
8251    type ParamSpec = glib::ParamSpecEnum;
8252    type SetValue = Self;
8253    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
8254
8255    fn param_spec_builder() -> Self::BuilderFn {
8256        Self::ParamSpec::builder_with_default
8257    }
8258}
8259
8260impl glib::value::ValueType for PadActionType {
8261    type Type = Self;
8262}
8263
8264unsafe impl<'a> glib::value::FromValue<'a> for PadActionType {
8265    type Checker = glib::value::GenericValueTypeChecker<Self>;
8266
8267    #[inline]
8268    unsafe fn from_value(value: &'a glib::Value) -> Self {
8269        skip_assert_initialized!();
8270        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
8271    }
8272}
8273
8274impl ToValue for PadActionType {
8275    #[inline]
8276    fn to_value(&self) -> glib::Value {
8277        let mut value = glib::Value::for_value_type::<Self>();
8278        unsafe {
8279            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
8280        }
8281        value
8282    }
8283
8284    #[inline]
8285    fn value_type(&self) -> glib::Type {
8286        Self::static_type()
8287    }
8288}
8289
8290impl From<PadActionType> for glib::Value {
8291    #[inline]
8292    fn from(v: PadActionType) -> Self {
8293        skip_assert_initialized!();
8294        ToValue::to_value(&v)
8295    }
8296}
8297
8298/// See also gtk_print_settings_set_orientation().
8299#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
8300#[non_exhaustive]
8301#[doc(alias = "GtkPageOrientation")]
8302pub enum PageOrientation {
8303    /// Portrait mode.
8304    #[doc(alias = "GTK_PAGE_ORIENTATION_PORTRAIT")]
8305    Portrait,
8306    /// Landscape mode.
8307    #[doc(alias = "GTK_PAGE_ORIENTATION_LANDSCAPE")]
8308    Landscape,
8309    /// Reverse portrait mode.
8310    #[doc(alias = "GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT")]
8311    ReversePortrait,
8312    /// Reverse landscape mode.
8313    #[doc(alias = "GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE")]
8314    ReverseLandscape,
8315    #[doc(hidden)]
8316    __Unknown(i32),
8317}
8318
8319#[doc(hidden)]
8320impl IntoGlib for PageOrientation {
8321    type GlibType = ffi::GtkPageOrientation;
8322
8323    #[inline]
8324    fn into_glib(self) -> ffi::GtkPageOrientation {
8325        match self {
8326            Self::Portrait => ffi::GTK_PAGE_ORIENTATION_PORTRAIT,
8327            Self::Landscape => ffi::GTK_PAGE_ORIENTATION_LANDSCAPE,
8328            Self::ReversePortrait => ffi::GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT,
8329            Self::ReverseLandscape => ffi::GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE,
8330            Self::__Unknown(value) => value,
8331        }
8332    }
8333}
8334
8335#[doc(hidden)]
8336impl FromGlib<ffi::GtkPageOrientation> for PageOrientation {
8337    #[inline]
8338    unsafe fn from_glib(value: ffi::GtkPageOrientation) -> Self {
8339        skip_assert_initialized!();
8340
8341        match value {
8342            ffi::GTK_PAGE_ORIENTATION_PORTRAIT => Self::Portrait,
8343            ffi::GTK_PAGE_ORIENTATION_LANDSCAPE => Self::Landscape,
8344            ffi::GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT => Self::ReversePortrait,
8345            ffi::GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE => Self::ReverseLandscape,
8346            value => Self::__Unknown(value),
8347        }
8348    }
8349}
8350
8351impl StaticType for PageOrientation {
8352    #[inline]
8353    #[doc(alias = "gtk_page_orientation_get_type")]
8354    fn static_type() -> glib::Type {
8355        unsafe { from_glib(ffi::gtk_page_orientation_get_type()) }
8356    }
8357}
8358
8359impl glib::HasParamSpec for PageOrientation {
8360    type ParamSpec = glib::ParamSpecEnum;
8361    type SetValue = Self;
8362    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
8363
8364    fn param_spec_builder() -> Self::BuilderFn {
8365        Self::ParamSpec::builder_with_default
8366    }
8367}
8368
8369impl glib::value::ValueType for PageOrientation {
8370    type Type = Self;
8371}
8372
8373unsafe impl<'a> glib::value::FromValue<'a> for PageOrientation {
8374    type Checker = glib::value::GenericValueTypeChecker<Self>;
8375
8376    #[inline]
8377    unsafe fn from_value(value: &'a glib::Value) -> Self {
8378        skip_assert_initialized!();
8379        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
8380    }
8381}
8382
8383impl ToValue for PageOrientation {
8384    #[inline]
8385    fn to_value(&self) -> glib::Value {
8386        let mut value = glib::Value::for_value_type::<Self>();
8387        unsafe {
8388            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
8389        }
8390        value
8391    }
8392
8393    #[inline]
8394    fn value_type(&self) -> glib::Type {
8395        Self::static_type()
8396    }
8397}
8398
8399impl From<PageOrientation> for glib::Value {
8400    #[inline]
8401    fn from(v: PageOrientation) -> Self {
8402        skip_assert_initialized!();
8403        ToValue::to_value(&v)
8404    }
8405}
8406
8407/// See also gtk_print_job_set_page_set().
8408#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
8409#[non_exhaustive]
8410#[doc(alias = "GtkPageSet")]
8411pub enum PageSet {
8412    /// All pages.
8413    #[doc(alias = "GTK_PAGE_SET_ALL")]
8414    All,
8415    /// Even pages.
8416    #[doc(alias = "GTK_PAGE_SET_EVEN")]
8417    Even,
8418    /// Odd pages.
8419    #[doc(alias = "GTK_PAGE_SET_ODD")]
8420    Odd,
8421    #[doc(hidden)]
8422    __Unknown(i32),
8423}
8424
8425#[doc(hidden)]
8426impl IntoGlib for PageSet {
8427    type GlibType = ffi::GtkPageSet;
8428
8429    #[inline]
8430    fn into_glib(self) -> ffi::GtkPageSet {
8431        match self {
8432            Self::All => ffi::GTK_PAGE_SET_ALL,
8433            Self::Even => ffi::GTK_PAGE_SET_EVEN,
8434            Self::Odd => ffi::GTK_PAGE_SET_ODD,
8435            Self::__Unknown(value) => value,
8436        }
8437    }
8438}
8439
8440#[doc(hidden)]
8441impl FromGlib<ffi::GtkPageSet> for PageSet {
8442    #[inline]
8443    unsafe fn from_glib(value: ffi::GtkPageSet) -> Self {
8444        skip_assert_initialized!();
8445
8446        match value {
8447            ffi::GTK_PAGE_SET_ALL => Self::All,
8448            ffi::GTK_PAGE_SET_EVEN => Self::Even,
8449            ffi::GTK_PAGE_SET_ODD => Self::Odd,
8450            value => Self::__Unknown(value),
8451        }
8452    }
8453}
8454
8455impl StaticType for PageSet {
8456    #[inline]
8457    #[doc(alias = "gtk_page_set_get_type")]
8458    fn static_type() -> glib::Type {
8459        unsafe { from_glib(ffi::gtk_page_set_get_type()) }
8460    }
8461}
8462
8463impl glib::HasParamSpec for PageSet {
8464    type ParamSpec = glib::ParamSpecEnum;
8465    type SetValue = Self;
8466    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
8467
8468    fn param_spec_builder() -> Self::BuilderFn {
8469        Self::ParamSpec::builder_with_default
8470    }
8471}
8472
8473impl glib::value::ValueType for PageSet {
8474    type Type = Self;
8475}
8476
8477unsafe impl<'a> glib::value::FromValue<'a> for PageSet {
8478    type Checker = glib::value::GenericValueTypeChecker<Self>;
8479
8480    #[inline]
8481    unsafe fn from_value(value: &'a glib::Value) -> Self {
8482        skip_assert_initialized!();
8483        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
8484    }
8485}
8486
8487impl ToValue for PageSet {
8488    #[inline]
8489    fn to_value(&self) -> glib::Value {
8490        let mut value = glib::Value::for_value_type::<Self>();
8491        unsafe {
8492            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
8493        }
8494        value
8495    }
8496
8497    #[inline]
8498    fn value_type(&self) -> glib::Type {
8499        Self::static_type()
8500    }
8501}
8502
8503impl From<PageSet> for glib::Value {
8504    #[inline]
8505    fn from(v: PageSet) -> Self {
8506        skip_assert_initialized!();
8507        ToValue::to_value(&v)
8508    }
8509}
8510
8511/// Describes the panning direction of a [`GesturePan`][crate::GesturePan].
8512#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
8513#[non_exhaustive]
8514#[doc(alias = "GtkPanDirection")]
8515pub enum PanDirection {
8516    /// panned towards the left
8517    #[doc(alias = "GTK_PAN_DIRECTION_LEFT")]
8518    Left,
8519    /// panned towards the right
8520    #[doc(alias = "GTK_PAN_DIRECTION_RIGHT")]
8521    Right,
8522    /// panned upwards
8523    #[doc(alias = "GTK_PAN_DIRECTION_UP")]
8524    Up,
8525    /// panned downwards
8526    #[doc(alias = "GTK_PAN_DIRECTION_DOWN")]
8527    Down,
8528    #[doc(hidden)]
8529    __Unknown(i32),
8530}
8531
8532#[doc(hidden)]
8533impl IntoGlib for PanDirection {
8534    type GlibType = ffi::GtkPanDirection;
8535
8536    #[inline]
8537    fn into_glib(self) -> ffi::GtkPanDirection {
8538        match self {
8539            Self::Left => ffi::GTK_PAN_DIRECTION_LEFT,
8540            Self::Right => ffi::GTK_PAN_DIRECTION_RIGHT,
8541            Self::Up => ffi::GTK_PAN_DIRECTION_UP,
8542            Self::Down => ffi::GTK_PAN_DIRECTION_DOWN,
8543            Self::__Unknown(value) => value,
8544        }
8545    }
8546}
8547
8548#[doc(hidden)]
8549impl FromGlib<ffi::GtkPanDirection> for PanDirection {
8550    #[inline]
8551    unsafe fn from_glib(value: ffi::GtkPanDirection) -> Self {
8552        skip_assert_initialized!();
8553
8554        match value {
8555            ffi::GTK_PAN_DIRECTION_LEFT => Self::Left,
8556            ffi::GTK_PAN_DIRECTION_RIGHT => Self::Right,
8557            ffi::GTK_PAN_DIRECTION_UP => Self::Up,
8558            ffi::GTK_PAN_DIRECTION_DOWN => Self::Down,
8559            value => Self::__Unknown(value),
8560        }
8561    }
8562}
8563
8564impl StaticType for PanDirection {
8565    #[inline]
8566    #[doc(alias = "gtk_pan_direction_get_type")]
8567    fn static_type() -> glib::Type {
8568        unsafe { from_glib(ffi::gtk_pan_direction_get_type()) }
8569    }
8570}
8571
8572impl glib::HasParamSpec for PanDirection {
8573    type ParamSpec = glib::ParamSpecEnum;
8574    type SetValue = Self;
8575    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
8576
8577    fn param_spec_builder() -> Self::BuilderFn {
8578        Self::ParamSpec::builder_with_default
8579    }
8580}
8581
8582impl glib::value::ValueType for PanDirection {
8583    type Type = Self;
8584}
8585
8586unsafe impl<'a> glib::value::FromValue<'a> for PanDirection {
8587    type Checker = glib::value::GenericValueTypeChecker<Self>;
8588
8589    #[inline]
8590    unsafe fn from_value(value: &'a glib::Value) -> Self {
8591        skip_assert_initialized!();
8592        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
8593    }
8594}
8595
8596impl ToValue for PanDirection {
8597    #[inline]
8598    fn to_value(&self) -> glib::Value {
8599        let mut value = glib::Value::for_value_type::<Self>();
8600        unsafe {
8601            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
8602        }
8603        value
8604    }
8605
8606    #[inline]
8607    fn value_type(&self) -> glib::Type {
8608        Self::static_type()
8609    }
8610}
8611
8612impl From<PanDirection> for glib::Value {
8613    #[inline]
8614    fn from(v: PanDirection) -> Self {
8615        skip_assert_initialized!();
8616        ToValue::to_value(&v)
8617    }
8618}
8619
8620/// Determines how the size should be computed to achieve the one of the
8621/// visibility mode for the scrollbars.
8622#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
8623#[non_exhaustive]
8624#[doc(alias = "GtkPolicyType")]
8625pub enum PolicyType {
8626    /// The scrollbar is always visible. The view size is
8627    ///   independent of the content.
8628    #[doc(alias = "GTK_POLICY_ALWAYS")]
8629    Always,
8630    /// The scrollbar will appear and disappear as necessary.
8631    ///   For example, when all of a [`TreeView`][crate::TreeView] can not be seen.
8632    #[doc(alias = "GTK_POLICY_AUTOMATIC")]
8633    Automatic,
8634    /// The scrollbar should never appear. In this mode the
8635    ///   content determines the size.
8636    #[doc(alias = "GTK_POLICY_NEVER")]
8637    Never,
8638    /// Don't show a scrollbar, but don't force the
8639    ///   size to follow the content. This can be used e.g. to make multiple
8640    ///   scrolled windows share a scrollbar.
8641    #[doc(alias = "GTK_POLICY_EXTERNAL")]
8642    External,
8643    #[doc(hidden)]
8644    __Unknown(i32),
8645}
8646
8647#[doc(hidden)]
8648impl IntoGlib for PolicyType {
8649    type GlibType = ffi::GtkPolicyType;
8650
8651    #[inline]
8652    fn into_glib(self) -> ffi::GtkPolicyType {
8653        match self {
8654            Self::Always => ffi::GTK_POLICY_ALWAYS,
8655            Self::Automatic => ffi::GTK_POLICY_AUTOMATIC,
8656            Self::Never => ffi::GTK_POLICY_NEVER,
8657            Self::External => ffi::GTK_POLICY_EXTERNAL,
8658            Self::__Unknown(value) => value,
8659        }
8660    }
8661}
8662
8663#[doc(hidden)]
8664impl FromGlib<ffi::GtkPolicyType> for PolicyType {
8665    #[inline]
8666    unsafe fn from_glib(value: ffi::GtkPolicyType) -> Self {
8667        skip_assert_initialized!();
8668
8669        match value {
8670            ffi::GTK_POLICY_ALWAYS => Self::Always,
8671            ffi::GTK_POLICY_AUTOMATIC => Self::Automatic,
8672            ffi::GTK_POLICY_NEVER => Self::Never,
8673            ffi::GTK_POLICY_EXTERNAL => Self::External,
8674            value => Self::__Unknown(value),
8675        }
8676    }
8677}
8678
8679impl StaticType for PolicyType {
8680    #[inline]
8681    #[doc(alias = "gtk_policy_type_get_type")]
8682    fn static_type() -> glib::Type {
8683        unsafe { from_glib(ffi::gtk_policy_type_get_type()) }
8684    }
8685}
8686
8687impl glib::HasParamSpec for PolicyType {
8688    type ParamSpec = glib::ParamSpecEnum;
8689    type SetValue = Self;
8690    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
8691
8692    fn param_spec_builder() -> Self::BuilderFn {
8693        Self::ParamSpec::builder_with_default
8694    }
8695}
8696
8697impl glib::value::ValueType for PolicyType {
8698    type Type = Self;
8699}
8700
8701unsafe impl<'a> glib::value::FromValue<'a> for PolicyType {
8702    type Checker = glib::value::GenericValueTypeChecker<Self>;
8703
8704    #[inline]
8705    unsafe fn from_value(value: &'a glib::Value) -> Self {
8706        skip_assert_initialized!();
8707        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
8708    }
8709}
8710
8711impl ToValue for PolicyType {
8712    #[inline]
8713    fn to_value(&self) -> glib::Value {
8714        let mut value = glib::Value::for_value_type::<Self>();
8715        unsafe {
8716            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
8717        }
8718        value
8719    }
8720
8721    #[inline]
8722    fn value_type(&self) -> glib::Type {
8723        Self::static_type()
8724    }
8725}
8726
8727impl From<PolicyType> for glib::Value {
8728    #[inline]
8729    fn from(v: PolicyType) -> Self {
8730        skip_assert_initialized!();
8731        ToValue::to_value(&v)
8732    }
8733}
8734
8735/// Describes which edge of a widget a certain feature is positioned at.
8736///
8737/// For examples, see the tabs of a [`Notebook`][crate::Notebook], or the label
8738/// of a [`Scale`][crate::Scale].
8739#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
8740#[non_exhaustive]
8741#[doc(alias = "GtkPositionType")]
8742pub enum PositionType {
8743    /// The feature is at the left edge.
8744    #[doc(alias = "GTK_POS_LEFT")]
8745    Left,
8746    /// The feature is at the right edge.
8747    #[doc(alias = "GTK_POS_RIGHT")]
8748    Right,
8749    /// The feature is at the top edge.
8750    #[doc(alias = "GTK_POS_TOP")]
8751    Top,
8752    /// The feature is at the bottom edge.
8753    #[doc(alias = "GTK_POS_BOTTOM")]
8754    Bottom,
8755    #[doc(hidden)]
8756    __Unknown(i32),
8757}
8758
8759#[doc(hidden)]
8760impl IntoGlib for PositionType {
8761    type GlibType = ffi::GtkPositionType;
8762
8763    #[inline]
8764    fn into_glib(self) -> ffi::GtkPositionType {
8765        match self {
8766            Self::Left => ffi::GTK_POS_LEFT,
8767            Self::Right => ffi::GTK_POS_RIGHT,
8768            Self::Top => ffi::GTK_POS_TOP,
8769            Self::Bottom => ffi::GTK_POS_BOTTOM,
8770            Self::__Unknown(value) => value,
8771        }
8772    }
8773}
8774
8775#[doc(hidden)]
8776impl FromGlib<ffi::GtkPositionType> for PositionType {
8777    #[inline]
8778    unsafe fn from_glib(value: ffi::GtkPositionType) -> Self {
8779        skip_assert_initialized!();
8780
8781        match value {
8782            ffi::GTK_POS_LEFT => Self::Left,
8783            ffi::GTK_POS_RIGHT => Self::Right,
8784            ffi::GTK_POS_TOP => Self::Top,
8785            ffi::GTK_POS_BOTTOM => Self::Bottom,
8786            value => Self::__Unknown(value),
8787        }
8788    }
8789}
8790
8791impl StaticType for PositionType {
8792    #[inline]
8793    #[doc(alias = "gtk_position_type_get_type")]
8794    fn static_type() -> glib::Type {
8795        unsafe { from_glib(ffi::gtk_position_type_get_type()) }
8796    }
8797}
8798
8799impl glib::HasParamSpec for PositionType {
8800    type ParamSpec = glib::ParamSpecEnum;
8801    type SetValue = Self;
8802    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
8803
8804    fn param_spec_builder() -> Self::BuilderFn {
8805        Self::ParamSpec::builder_with_default
8806    }
8807}
8808
8809impl glib::value::ValueType for PositionType {
8810    type Type = Self;
8811}
8812
8813unsafe impl<'a> glib::value::FromValue<'a> for PositionType {
8814    type Checker = glib::value::GenericValueTypeChecker<Self>;
8815
8816    #[inline]
8817    unsafe fn from_value(value: &'a glib::Value) -> Self {
8818        skip_assert_initialized!();
8819        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
8820    }
8821}
8822
8823impl ToValue for PositionType {
8824    #[inline]
8825    fn to_value(&self) -> glib::Value {
8826        let mut value = glib::Value::for_value_type::<Self>();
8827        unsafe {
8828            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
8829        }
8830        value
8831    }
8832
8833    #[inline]
8834    fn value_type(&self) -> glib::Type {
8835        Self::static_type()
8836    }
8837}
8838
8839impl From<PositionType> for glib::Value {
8840    #[inline]
8841    fn from(v: PositionType) -> Self {
8842        skip_assert_initialized!();
8843        ToValue::to_value(&v)
8844    }
8845}
8846
8847/// See also gtk_print_settings_set_duplex().
8848#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
8849#[non_exhaustive]
8850#[doc(alias = "GtkPrintDuplex")]
8851pub enum PrintDuplex {
8852    /// No duplex.
8853    #[doc(alias = "GTK_PRINT_DUPLEX_SIMPLEX")]
8854    Simplex,
8855    /// Horizontal duplex.
8856    #[doc(alias = "GTK_PRINT_DUPLEX_HORIZONTAL")]
8857    Horizontal,
8858    /// Vertical duplex.
8859    #[doc(alias = "GTK_PRINT_DUPLEX_VERTICAL")]
8860    Vertical,
8861    #[doc(hidden)]
8862    __Unknown(i32),
8863}
8864
8865#[doc(hidden)]
8866impl IntoGlib for PrintDuplex {
8867    type GlibType = ffi::GtkPrintDuplex;
8868
8869    #[inline]
8870    fn into_glib(self) -> ffi::GtkPrintDuplex {
8871        match self {
8872            Self::Simplex => ffi::GTK_PRINT_DUPLEX_SIMPLEX,
8873            Self::Horizontal => ffi::GTK_PRINT_DUPLEX_HORIZONTAL,
8874            Self::Vertical => ffi::GTK_PRINT_DUPLEX_VERTICAL,
8875            Self::__Unknown(value) => value,
8876        }
8877    }
8878}
8879
8880#[doc(hidden)]
8881impl FromGlib<ffi::GtkPrintDuplex> for PrintDuplex {
8882    #[inline]
8883    unsafe fn from_glib(value: ffi::GtkPrintDuplex) -> Self {
8884        skip_assert_initialized!();
8885
8886        match value {
8887            ffi::GTK_PRINT_DUPLEX_SIMPLEX => Self::Simplex,
8888            ffi::GTK_PRINT_DUPLEX_HORIZONTAL => Self::Horizontal,
8889            ffi::GTK_PRINT_DUPLEX_VERTICAL => Self::Vertical,
8890            value => Self::__Unknown(value),
8891        }
8892    }
8893}
8894
8895impl StaticType for PrintDuplex {
8896    #[inline]
8897    #[doc(alias = "gtk_print_duplex_get_type")]
8898    fn static_type() -> glib::Type {
8899        unsafe { from_glib(ffi::gtk_print_duplex_get_type()) }
8900    }
8901}
8902
8903impl glib::HasParamSpec for PrintDuplex {
8904    type ParamSpec = glib::ParamSpecEnum;
8905    type SetValue = Self;
8906    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
8907
8908    fn param_spec_builder() -> Self::BuilderFn {
8909        Self::ParamSpec::builder_with_default
8910    }
8911}
8912
8913impl glib::value::ValueType for PrintDuplex {
8914    type Type = Self;
8915}
8916
8917unsafe impl<'a> glib::value::FromValue<'a> for PrintDuplex {
8918    type Checker = glib::value::GenericValueTypeChecker<Self>;
8919
8920    #[inline]
8921    unsafe fn from_value(value: &'a glib::Value) -> Self {
8922        skip_assert_initialized!();
8923        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
8924    }
8925}
8926
8927impl ToValue for PrintDuplex {
8928    #[inline]
8929    fn to_value(&self) -> glib::Value {
8930        let mut value = glib::Value::for_value_type::<Self>();
8931        unsafe {
8932            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
8933        }
8934        value
8935    }
8936
8937    #[inline]
8938    fn value_type(&self) -> glib::Type {
8939        Self::static_type()
8940    }
8941}
8942
8943impl From<PrintDuplex> for glib::Value {
8944    #[inline]
8945    fn from(v: PrintDuplex) -> Self {
8946        skip_assert_initialized!();
8947        ToValue::to_value(&v)
8948    }
8949}
8950
8951/// Error codes that identify various errors that can occur while
8952/// using the GTK printing support.
8953#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
8954#[non_exhaustive]
8955#[doc(alias = "GtkPrintError")]
8956pub enum PrintError {
8957    /// An unspecified error occurred.
8958    #[doc(alias = "GTK_PRINT_ERROR_GENERAL")]
8959    General,
8960    /// An internal error occurred.
8961    #[doc(alias = "GTK_PRINT_ERROR_INTERNAL_ERROR")]
8962    InternalError,
8963    /// A memory allocation failed.
8964    #[doc(alias = "GTK_PRINT_ERROR_NOMEM")]
8965    Nomem,
8966    /// An error occurred while loading a page setup
8967    ///   or paper size from a key file.
8968    #[doc(alias = "GTK_PRINT_ERROR_INVALID_FILE")]
8969    InvalidFile,
8970    #[doc(hidden)]
8971    __Unknown(i32),
8972}
8973
8974#[doc(hidden)]
8975impl IntoGlib for PrintError {
8976    type GlibType = ffi::GtkPrintError;
8977
8978    #[inline]
8979    fn into_glib(self) -> ffi::GtkPrintError {
8980        match self {
8981            Self::General => ffi::GTK_PRINT_ERROR_GENERAL,
8982            Self::InternalError => ffi::GTK_PRINT_ERROR_INTERNAL_ERROR,
8983            Self::Nomem => ffi::GTK_PRINT_ERROR_NOMEM,
8984            Self::InvalidFile => ffi::GTK_PRINT_ERROR_INVALID_FILE,
8985            Self::__Unknown(value) => value,
8986        }
8987    }
8988}
8989
8990#[doc(hidden)]
8991impl FromGlib<ffi::GtkPrintError> for PrintError {
8992    #[inline]
8993    unsafe fn from_glib(value: ffi::GtkPrintError) -> Self {
8994        skip_assert_initialized!();
8995
8996        match value {
8997            ffi::GTK_PRINT_ERROR_GENERAL => Self::General,
8998            ffi::GTK_PRINT_ERROR_INTERNAL_ERROR => Self::InternalError,
8999            ffi::GTK_PRINT_ERROR_NOMEM => Self::Nomem,
9000            ffi::GTK_PRINT_ERROR_INVALID_FILE => Self::InvalidFile,
9001            value => Self::__Unknown(value),
9002        }
9003    }
9004}
9005
9006impl glib::error::ErrorDomain for PrintError {
9007    #[inline]
9008    fn domain() -> glib::Quark {
9009        skip_assert_initialized!();
9010
9011        unsafe { from_glib(ffi::gtk_print_error_quark()) }
9012    }
9013
9014    #[inline]
9015    fn code(self) -> i32 {
9016        self.into_glib()
9017    }
9018
9019    #[inline]
9020    #[allow(clippy::match_single_binding)]
9021    fn from(code: i32) -> Option<Self> {
9022        skip_assert_initialized!();
9023        match unsafe { from_glib(code) } {
9024            value => Some(value),
9025        }
9026    }
9027}
9028
9029impl StaticType for PrintError {
9030    #[inline]
9031    #[doc(alias = "gtk_print_error_get_type")]
9032    fn static_type() -> glib::Type {
9033        unsafe { from_glib(ffi::gtk_print_error_get_type()) }
9034    }
9035}
9036
9037impl glib::HasParamSpec for PrintError {
9038    type ParamSpec = glib::ParamSpecEnum;
9039    type SetValue = Self;
9040    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
9041
9042    fn param_spec_builder() -> Self::BuilderFn {
9043        Self::ParamSpec::builder_with_default
9044    }
9045}
9046
9047impl glib::value::ValueType for PrintError {
9048    type Type = Self;
9049}
9050
9051unsafe impl<'a> glib::value::FromValue<'a> for PrintError {
9052    type Checker = glib::value::GenericValueTypeChecker<Self>;
9053
9054    #[inline]
9055    unsafe fn from_value(value: &'a glib::Value) -> Self {
9056        skip_assert_initialized!();
9057        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
9058    }
9059}
9060
9061impl ToValue for PrintError {
9062    #[inline]
9063    fn to_value(&self) -> glib::Value {
9064        let mut value = glib::Value::for_value_type::<Self>();
9065        unsafe {
9066            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
9067        }
9068        value
9069    }
9070
9071    #[inline]
9072    fn value_type(&self) -> glib::Type {
9073        Self::static_type()
9074    }
9075}
9076
9077impl From<PrintError> for glib::Value {
9078    #[inline]
9079    fn from(v: PrintError) -> Self {
9080        skip_assert_initialized!();
9081        ToValue::to_value(&v)
9082    }
9083}
9084
9085/// Determines what action the print operation should perform.
9086///
9087/// A parameter of this typs is passed to [`PrintOperationExt::run()`][crate::prelude::PrintOperationExt::run()].
9088#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
9089#[non_exhaustive]
9090#[doc(alias = "GtkPrintOperationAction")]
9091pub enum PrintOperationAction {
9092    /// Show the print dialog.
9093    #[doc(alias = "GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG")]
9094    PrintDialog,
9095    /// Start to print without showing
9096    ///   the print dialog, based on the current print settings.
9097    #[doc(alias = "GTK_PRINT_OPERATION_ACTION_PRINT")]
9098    Print,
9099    /// Show the print preview.
9100    #[doc(alias = "GTK_PRINT_OPERATION_ACTION_PREVIEW")]
9101    Preview,
9102    /// Export to a file. This requires
9103    ///   the export-filename property to be set.
9104    #[doc(alias = "GTK_PRINT_OPERATION_ACTION_EXPORT")]
9105    Export,
9106    #[doc(hidden)]
9107    __Unknown(i32),
9108}
9109
9110#[doc(hidden)]
9111impl IntoGlib for PrintOperationAction {
9112    type GlibType = ffi::GtkPrintOperationAction;
9113
9114    #[inline]
9115    fn into_glib(self) -> ffi::GtkPrintOperationAction {
9116        match self {
9117            Self::PrintDialog => ffi::GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG,
9118            Self::Print => ffi::GTK_PRINT_OPERATION_ACTION_PRINT,
9119            Self::Preview => ffi::GTK_PRINT_OPERATION_ACTION_PREVIEW,
9120            Self::Export => ffi::GTK_PRINT_OPERATION_ACTION_EXPORT,
9121            Self::__Unknown(value) => value,
9122        }
9123    }
9124}
9125
9126#[doc(hidden)]
9127impl FromGlib<ffi::GtkPrintOperationAction> for PrintOperationAction {
9128    #[inline]
9129    unsafe fn from_glib(value: ffi::GtkPrintOperationAction) -> Self {
9130        skip_assert_initialized!();
9131
9132        match value {
9133            ffi::GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG => Self::PrintDialog,
9134            ffi::GTK_PRINT_OPERATION_ACTION_PRINT => Self::Print,
9135            ffi::GTK_PRINT_OPERATION_ACTION_PREVIEW => Self::Preview,
9136            ffi::GTK_PRINT_OPERATION_ACTION_EXPORT => Self::Export,
9137            value => Self::__Unknown(value),
9138        }
9139    }
9140}
9141
9142impl StaticType for PrintOperationAction {
9143    #[inline]
9144    #[doc(alias = "gtk_print_operation_action_get_type")]
9145    fn static_type() -> glib::Type {
9146        unsafe { from_glib(ffi::gtk_print_operation_action_get_type()) }
9147    }
9148}
9149
9150impl glib::HasParamSpec for PrintOperationAction {
9151    type ParamSpec = glib::ParamSpecEnum;
9152    type SetValue = Self;
9153    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
9154
9155    fn param_spec_builder() -> Self::BuilderFn {
9156        Self::ParamSpec::builder_with_default
9157    }
9158}
9159
9160impl glib::value::ValueType for PrintOperationAction {
9161    type Type = Self;
9162}
9163
9164unsafe impl<'a> glib::value::FromValue<'a> for PrintOperationAction {
9165    type Checker = glib::value::GenericValueTypeChecker<Self>;
9166
9167    #[inline]
9168    unsafe fn from_value(value: &'a glib::Value) -> Self {
9169        skip_assert_initialized!();
9170        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
9171    }
9172}
9173
9174impl ToValue for PrintOperationAction {
9175    #[inline]
9176    fn to_value(&self) -> glib::Value {
9177        let mut value = glib::Value::for_value_type::<Self>();
9178        unsafe {
9179            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
9180        }
9181        value
9182    }
9183
9184    #[inline]
9185    fn value_type(&self) -> glib::Type {
9186        Self::static_type()
9187    }
9188}
9189
9190impl From<PrintOperationAction> for glib::Value {
9191    #[inline]
9192    fn from(v: PrintOperationAction) -> Self {
9193        skip_assert_initialized!();
9194        ToValue::to_value(&v)
9195    }
9196}
9197
9198/// The result of a print operation.
9199///
9200/// A value of this type is returned by [`PrintOperationExt::run()`][crate::prelude::PrintOperationExt::run()].
9201#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
9202#[non_exhaustive]
9203#[doc(alias = "GtkPrintOperationResult")]
9204pub enum PrintOperationResult {
9205    /// An error has occurred.
9206    #[doc(alias = "GTK_PRINT_OPERATION_RESULT_ERROR")]
9207    Error,
9208    /// The print settings should be stored.
9209    #[doc(alias = "GTK_PRINT_OPERATION_RESULT_APPLY")]
9210    Apply,
9211    /// The print operation has been canceled,
9212    ///   the print settings should not be stored.
9213    #[doc(alias = "GTK_PRINT_OPERATION_RESULT_CANCEL")]
9214    Cancel,
9215    /// The print operation is not complete
9216    ///   yet. This value will only be returned when running asynchronously.
9217    #[doc(alias = "GTK_PRINT_OPERATION_RESULT_IN_PROGRESS")]
9218    InProgress,
9219    #[doc(hidden)]
9220    __Unknown(i32),
9221}
9222
9223#[doc(hidden)]
9224impl IntoGlib for PrintOperationResult {
9225    type GlibType = ffi::GtkPrintOperationResult;
9226
9227    #[inline]
9228    fn into_glib(self) -> ffi::GtkPrintOperationResult {
9229        match self {
9230            Self::Error => ffi::GTK_PRINT_OPERATION_RESULT_ERROR,
9231            Self::Apply => ffi::GTK_PRINT_OPERATION_RESULT_APPLY,
9232            Self::Cancel => ffi::GTK_PRINT_OPERATION_RESULT_CANCEL,
9233            Self::InProgress => ffi::GTK_PRINT_OPERATION_RESULT_IN_PROGRESS,
9234            Self::__Unknown(value) => value,
9235        }
9236    }
9237}
9238
9239#[doc(hidden)]
9240impl FromGlib<ffi::GtkPrintOperationResult> for PrintOperationResult {
9241    #[inline]
9242    unsafe fn from_glib(value: ffi::GtkPrintOperationResult) -> Self {
9243        skip_assert_initialized!();
9244
9245        match value {
9246            ffi::GTK_PRINT_OPERATION_RESULT_ERROR => Self::Error,
9247            ffi::GTK_PRINT_OPERATION_RESULT_APPLY => Self::Apply,
9248            ffi::GTK_PRINT_OPERATION_RESULT_CANCEL => Self::Cancel,
9249            ffi::GTK_PRINT_OPERATION_RESULT_IN_PROGRESS => Self::InProgress,
9250            value => Self::__Unknown(value),
9251        }
9252    }
9253}
9254
9255impl StaticType for PrintOperationResult {
9256    #[inline]
9257    #[doc(alias = "gtk_print_operation_result_get_type")]
9258    fn static_type() -> glib::Type {
9259        unsafe { from_glib(ffi::gtk_print_operation_result_get_type()) }
9260    }
9261}
9262
9263impl glib::HasParamSpec for PrintOperationResult {
9264    type ParamSpec = glib::ParamSpecEnum;
9265    type SetValue = Self;
9266    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
9267
9268    fn param_spec_builder() -> Self::BuilderFn {
9269        Self::ParamSpec::builder_with_default
9270    }
9271}
9272
9273impl glib::value::ValueType for PrintOperationResult {
9274    type Type = Self;
9275}
9276
9277unsafe impl<'a> glib::value::FromValue<'a> for PrintOperationResult {
9278    type Checker = glib::value::GenericValueTypeChecker<Self>;
9279
9280    #[inline]
9281    unsafe fn from_value(value: &'a glib::Value) -> Self {
9282        skip_assert_initialized!();
9283        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
9284    }
9285}
9286
9287impl ToValue for PrintOperationResult {
9288    #[inline]
9289    fn to_value(&self) -> glib::Value {
9290        let mut value = glib::Value::for_value_type::<Self>();
9291        unsafe {
9292            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
9293        }
9294        value
9295    }
9296
9297    #[inline]
9298    fn value_type(&self) -> glib::Type {
9299        Self::static_type()
9300    }
9301}
9302
9303impl From<PrintOperationResult> for glib::Value {
9304    #[inline]
9305    fn from(v: PrintOperationResult) -> Self {
9306        skip_assert_initialized!();
9307        ToValue::to_value(&v)
9308    }
9309}
9310
9311/// See also gtk_print_job_set_pages()
9312#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
9313#[non_exhaustive]
9314#[doc(alias = "GtkPrintPages")]
9315pub enum PrintPages {
9316    /// All pages.
9317    #[doc(alias = "GTK_PRINT_PAGES_ALL")]
9318    All,
9319    /// Current page.
9320    #[doc(alias = "GTK_PRINT_PAGES_CURRENT")]
9321    Current,
9322    /// Range of pages.
9323    #[doc(alias = "GTK_PRINT_PAGES_RANGES")]
9324    Ranges,
9325    /// Selected pages.
9326    #[doc(alias = "GTK_PRINT_PAGES_SELECTION")]
9327    Selection,
9328    #[doc(hidden)]
9329    __Unknown(i32),
9330}
9331
9332#[doc(hidden)]
9333impl IntoGlib for PrintPages {
9334    type GlibType = ffi::GtkPrintPages;
9335
9336    #[inline]
9337    fn into_glib(self) -> ffi::GtkPrintPages {
9338        match self {
9339            Self::All => ffi::GTK_PRINT_PAGES_ALL,
9340            Self::Current => ffi::GTK_PRINT_PAGES_CURRENT,
9341            Self::Ranges => ffi::GTK_PRINT_PAGES_RANGES,
9342            Self::Selection => ffi::GTK_PRINT_PAGES_SELECTION,
9343            Self::__Unknown(value) => value,
9344        }
9345    }
9346}
9347
9348#[doc(hidden)]
9349impl FromGlib<ffi::GtkPrintPages> for PrintPages {
9350    #[inline]
9351    unsafe fn from_glib(value: ffi::GtkPrintPages) -> Self {
9352        skip_assert_initialized!();
9353
9354        match value {
9355            ffi::GTK_PRINT_PAGES_ALL => Self::All,
9356            ffi::GTK_PRINT_PAGES_CURRENT => Self::Current,
9357            ffi::GTK_PRINT_PAGES_RANGES => Self::Ranges,
9358            ffi::GTK_PRINT_PAGES_SELECTION => Self::Selection,
9359            value => Self::__Unknown(value),
9360        }
9361    }
9362}
9363
9364impl StaticType for PrintPages {
9365    #[inline]
9366    #[doc(alias = "gtk_print_pages_get_type")]
9367    fn static_type() -> glib::Type {
9368        unsafe { from_glib(ffi::gtk_print_pages_get_type()) }
9369    }
9370}
9371
9372impl glib::HasParamSpec for PrintPages {
9373    type ParamSpec = glib::ParamSpecEnum;
9374    type SetValue = Self;
9375    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
9376
9377    fn param_spec_builder() -> Self::BuilderFn {
9378        Self::ParamSpec::builder_with_default
9379    }
9380}
9381
9382impl glib::value::ValueType for PrintPages {
9383    type Type = Self;
9384}
9385
9386unsafe impl<'a> glib::value::FromValue<'a> for PrintPages {
9387    type Checker = glib::value::GenericValueTypeChecker<Self>;
9388
9389    #[inline]
9390    unsafe fn from_value(value: &'a glib::Value) -> Self {
9391        skip_assert_initialized!();
9392        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
9393    }
9394}
9395
9396impl ToValue for PrintPages {
9397    #[inline]
9398    fn to_value(&self) -> glib::Value {
9399        let mut value = glib::Value::for_value_type::<Self>();
9400        unsafe {
9401            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
9402        }
9403        value
9404    }
9405
9406    #[inline]
9407    fn value_type(&self) -> glib::Type {
9408        Self::static_type()
9409    }
9410}
9411
9412impl From<PrintPages> for glib::Value {
9413    #[inline]
9414    fn from(v: PrintPages) -> Self {
9415        skip_assert_initialized!();
9416        ToValue::to_value(&v)
9417    }
9418}
9419
9420/// See also gtk_print_settings_set_quality().
9421#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
9422#[non_exhaustive]
9423#[doc(alias = "GtkPrintQuality")]
9424pub enum PrintQuality {
9425    /// Low quality.
9426    #[doc(alias = "GTK_PRINT_QUALITY_LOW")]
9427    Low,
9428    /// Normal quality.
9429    #[doc(alias = "GTK_PRINT_QUALITY_NORMAL")]
9430    Normal,
9431    /// High quality.
9432    #[doc(alias = "GTK_PRINT_QUALITY_HIGH")]
9433    High,
9434    /// Draft quality.
9435    #[doc(alias = "GTK_PRINT_QUALITY_DRAFT")]
9436    Draft,
9437    #[doc(hidden)]
9438    __Unknown(i32),
9439}
9440
9441#[doc(hidden)]
9442impl IntoGlib for PrintQuality {
9443    type GlibType = ffi::GtkPrintQuality;
9444
9445    #[inline]
9446    fn into_glib(self) -> ffi::GtkPrintQuality {
9447        match self {
9448            Self::Low => ffi::GTK_PRINT_QUALITY_LOW,
9449            Self::Normal => ffi::GTK_PRINT_QUALITY_NORMAL,
9450            Self::High => ffi::GTK_PRINT_QUALITY_HIGH,
9451            Self::Draft => ffi::GTK_PRINT_QUALITY_DRAFT,
9452            Self::__Unknown(value) => value,
9453        }
9454    }
9455}
9456
9457#[doc(hidden)]
9458impl FromGlib<ffi::GtkPrintQuality> for PrintQuality {
9459    #[inline]
9460    unsafe fn from_glib(value: ffi::GtkPrintQuality) -> Self {
9461        skip_assert_initialized!();
9462
9463        match value {
9464            ffi::GTK_PRINT_QUALITY_LOW => Self::Low,
9465            ffi::GTK_PRINT_QUALITY_NORMAL => Self::Normal,
9466            ffi::GTK_PRINT_QUALITY_HIGH => Self::High,
9467            ffi::GTK_PRINT_QUALITY_DRAFT => Self::Draft,
9468            value => Self::__Unknown(value),
9469        }
9470    }
9471}
9472
9473impl StaticType for PrintQuality {
9474    #[inline]
9475    #[doc(alias = "gtk_print_quality_get_type")]
9476    fn static_type() -> glib::Type {
9477        unsafe { from_glib(ffi::gtk_print_quality_get_type()) }
9478    }
9479}
9480
9481impl glib::HasParamSpec for PrintQuality {
9482    type ParamSpec = glib::ParamSpecEnum;
9483    type SetValue = Self;
9484    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
9485
9486    fn param_spec_builder() -> Self::BuilderFn {
9487        Self::ParamSpec::builder_with_default
9488    }
9489}
9490
9491impl glib::value::ValueType for PrintQuality {
9492    type Type = Self;
9493}
9494
9495unsafe impl<'a> glib::value::FromValue<'a> for PrintQuality {
9496    type Checker = glib::value::GenericValueTypeChecker<Self>;
9497
9498    #[inline]
9499    unsafe fn from_value(value: &'a glib::Value) -> Self {
9500        skip_assert_initialized!();
9501        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
9502    }
9503}
9504
9505impl ToValue for PrintQuality {
9506    #[inline]
9507    fn to_value(&self) -> glib::Value {
9508        let mut value = glib::Value::for_value_type::<Self>();
9509        unsafe {
9510            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
9511        }
9512        value
9513    }
9514
9515    #[inline]
9516    fn value_type(&self) -> glib::Type {
9517        Self::static_type()
9518    }
9519}
9520
9521impl From<PrintQuality> for glib::Value {
9522    #[inline]
9523    fn from(v: PrintQuality) -> Self {
9524        skip_assert_initialized!();
9525        ToValue::to_value(&v)
9526    }
9527}
9528
9529/// The status gives a rough indication of the completion of a running
9530/// print operation.
9531#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
9532#[non_exhaustive]
9533#[doc(alias = "GtkPrintStatus")]
9534pub enum PrintStatus {
9535    /// The printing has not started yet; this
9536    ///   status is set initially, and while the print dialog is shown.
9537    #[doc(alias = "GTK_PRINT_STATUS_INITIAL")]
9538    Initial,
9539    /// This status is set while the begin-print
9540    ///   signal is emitted and during pagination.
9541    #[doc(alias = "GTK_PRINT_STATUS_PREPARING")]
9542    Preparing,
9543    /// This status is set while the
9544    ///   pages are being rendered.
9545    #[doc(alias = "GTK_PRINT_STATUS_GENERATING_DATA")]
9546    GeneratingData,
9547    /// The print job is being sent off to the
9548    ///   printer.
9549    #[doc(alias = "GTK_PRINT_STATUS_SENDING_DATA")]
9550    SendingData,
9551    /// The print job has been sent to the printer,
9552    ///   but is not printed for some reason, e.g. the printer may be stopped.
9553    #[doc(alias = "GTK_PRINT_STATUS_PENDING")]
9554    Pending,
9555    /// Some problem has occurred during
9556    ///   printing, e.g. a paper jam.
9557    #[doc(alias = "GTK_PRINT_STATUS_PENDING_ISSUE")]
9558    PendingIssue,
9559    /// The printer is processing the print job.
9560    #[doc(alias = "GTK_PRINT_STATUS_PRINTING")]
9561    Printing,
9562    /// The printing has been completed successfully.
9563    #[doc(alias = "GTK_PRINT_STATUS_FINISHED")]
9564    Finished,
9565    /// The printing has been aborted.
9566    #[doc(alias = "GTK_PRINT_STATUS_FINISHED_ABORTED")]
9567    FinishedAborted,
9568    #[doc(hidden)]
9569    __Unknown(i32),
9570}
9571
9572#[doc(hidden)]
9573impl IntoGlib for PrintStatus {
9574    type GlibType = ffi::GtkPrintStatus;
9575
9576    #[inline]
9577    fn into_glib(self) -> ffi::GtkPrintStatus {
9578        match self {
9579            Self::Initial => ffi::GTK_PRINT_STATUS_INITIAL,
9580            Self::Preparing => ffi::GTK_PRINT_STATUS_PREPARING,
9581            Self::GeneratingData => ffi::GTK_PRINT_STATUS_GENERATING_DATA,
9582            Self::SendingData => ffi::GTK_PRINT_STATUS_SENDING_DATA,
9583            Self::Pending => ffi::GTK_PRINT_STATUS_PENDING,
9584            Self::PendingIssue => ffi::GTK_PRINT_STATUS_PENDING_ISSUE,
9585            Self::Printing => ffi::GTK_PRINT_STATUS_PRINTING,
9586            Self::Finished => ffi::GTK_PRINT_STATUS_FINISHED,
9587            Self::FinishedAborted => ffi::GTK_PRINT_STATUS_FINISHED_ABORTED,
9588            Self::__Unknown(value) => value,
9589        }
9590    }
9591}
9592
9593#[doc(hidden)]
9594impl FromGlib<ffi::GtkPrintStatus> for PrintStatus {
9595    #[inline]
9596    unsafe fn from_glib(value: ffi::GtkPrintStatus) -> Self {
9597        skip_assert_initialized!();
9598
9599        match value {
9600            ffi::GTK_PRINT_STATUS_INITIAL => Self::Initial,
9601            ffi::GTK_PRINT_STATUS_PREPARING => Self::Preparing,
9602            ffi::GTK_PRINT_STATUS_GENERATING_DATA => Self::GeneratingData,
9603            ffi::GTK_PRINT_STATUS_SENDING_DATA => Self::SendingData,
9604            ffi::GTK_PRINT_STATUS_PENDING => Self::Pending,
9605            ffi::GTK_PRINT_STATUS_PENDING_ISSUE => Self::PendingIssue,
9606            ffi::GTK_PRINT_STATUS_PRINTING => Self::Printing,
9607            ffi::GTK_PRINT_STATUS_FINISHED => Self::Finished,
9608            ffi::GTK_PRINT_STATUS_FINISHED_ABORTED => Self::FinishedAborted,
9609            value => Self::__Unknown(value),
9610        }
9611    }
9612}
9613
9614impl StaticType for PrintStatus {
9615    #[inline]
9616    #[doc(alias = "gtk_print_status_get_type")]
9617    fn static_type() -> glib::Type {
9618        unsafe { from_glib(ffi::gtk_print_status_get_type()) }
9619    }
9620}
9621
9622impl glib::HasParamSpec for PrintStatus {
9623    type ParamSpec = glib::ParamSpecEnum;
9624    type SetValue = Self;
9625    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
9626
9627    fn param_spec_builder() -> Self::BuilderFn {
9628        Self::ParamSpec::builder_with_default
9629    }
9630}
9631
9632impl glib::value::ValueType for PrintStatus {
9633    type Type = Self;
9634}
9635
9636unsafe impl<'a> glib::value::FromValue<'a> for PrintStatus {
9637    type Checker = glib::value::GenericValueTypeChecker<Self>;
9638
9639    #[inline]
9640    unsafe fn from_value(value: &'a glib::Value) -> Self {
9641        skip_assert_initialized!();
9642        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
9643    }
9644}
9645
9646impl ToValue for PrintStatus {
9647    #[inline]
9648    fn to_value(&self) -> glib::Value {
9649        let mut value = glib::Value::for_value_type::<Self>();
9650        unsafe {
9651            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
9652        }
9653        value
9654    }
9655
9656    #[inline]
9657    fn value_type(&self) -> glib::Type {
9658        Self::static_type()
9659    }
9660}
9661
9662impl From<PrintStatus> for glib::Value {
9663    #[inline]
9664    fn from(v: PrintStatus) -> Self {
9665        skip_assert_initialized!();
9666        ToValue::to_value(&v)
9667    }
9668}
9669
9670/// Describes limits of a [`EventController`][crate::EventController] for handling events
9671/// targeting other widgets.
9672#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
9673#[non_exhaustive]
9674#[doc(alias = "GtkPropagationLimit")]
9675pub enum PropagationLimit {
9676    /// Events are handled regardless of what their
9677    ///   target is.
9678    #[doc(alias = "GTK_LIMIT_NONE")]
9679    None,
9680    /// Events are only handled if their target is in
9681    ///   the same [`Native`][crate::Native] (or widget with [`limit-events`][struct@crate::Widget#limit-events]
9682    ///   set) as the event controllers widget.
9683    ///   Note that some event types have two targets (origin and destination).
9684    #[doc(alias = "GTK_LIMIT_SAME_NATIVE")]
9685    SameNative,
9686    #[doc(hidden)]
9687    __Unknown(i32),
9688}
9689
9690#[doc(hidden)]
9691impl IntoGlib for PropagationLimit {
9692    type GlibType = ffi::GtkPropagationLimit;
9693
9694    #[inline]
9695    fn into_glib(self) -> ffi::GtkPropagationLimit {
9696        match self {
9697            Self::None => ffi::GTK_LIMIT_NONE,
9698            Self::SameNative => ffi::GTK_LIMIT_SAME_NATIVE,
9699            Self::__Unknown(value) => value,
9700        }
9701    }
9702}
9703
9704#[doc(hidden)]
9705impl FromGlib<ffi::GtkPropagationLimit> for PropagationLimit {
9706    #[inline]
9707    unsafe fn from_glib(value: ffi::GtkPropagationLimit) -> Self {
9708        skip_assert_initialized!();
9709
9710        match value {
9711            ffi::GTK_LIMIT_NONE => Self::None,
9712            ffi::GTK_LIMIT_SAME_NATIVE => Self::SameNative,
9713            value => Self::__Unknown(value),
9714        }
9715    }
9716}
9717
9718impl StaticType for PropagationLimit {
9719    #[inline]
9720    #[doc(alias = "gtk_propagation_limit_get_type")]
9721    fn static_type() -> glib::Type {
9722        unsafe { from_glib(ffi::gtk_propagation_limit_get_type()) }
9723    }
9724}
9725
9726impl glib::HasParamSpec for PropagationLimit {
9727    type ParamSpec = glib::ParamSpecEnum;
9728    type SetValue = Self;
9729    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
9730
9731    fn param_spec_builder() -> Self::BuilderFn {
9732        Self::ParamSpec::builder_with_default
9733    }
9734}
9735
9736impl glib::value::ValueType for PropagationLimit {
9737    type Type = Self;
9738}
9739
9740unsafe impl<'a> glib::value::FromValue<'a> for PropagationLimit {
9741    type Checker = glib::value::GenericValueTypeChecker<Self>;
9742
9743    #[inline]
9744    unsafe fn from_value(value: &'a glib::Value) -> Self {
9745        skip_assert_initialized!();
9746        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
9747    }
9748}
9749
9750impl ToValue for PropagationLimit {
9751    #[inline]
9752    fn to_value(&self) -> glib::Value {
9753        let mut value = glib::Value::for_value_type::<Self>();
9754        unsafe {
9755            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
9756        }
9757        value
9758    }
9759
9760    #[inline]
9761    fn value_type(&self) -> glib::Type {
9762        Self::static_type()
9763    }
9764}
9765
9766impl From<PropagationLimit> for glib::Value {
9767    #[inline]
9768    fn from(v: PropagationLimit) -> Self {
9769        skip_assert_initialized!();
9770        ToValue::to_value(&v)
9771    }
9772}
9773
9774/// Describes the stage at which events are fed into a [`EventController`][crate::EventController].
9775#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
9776#[non_exhaustive]
9777#[doc(alias = "GtkPropagationPhase")]
9778pub enum PropagationPhase {
9779    /// Events are not delivered.
9780    #[doc(alias = "GTK_PHASE_NONE")]
9781    None,
9782    /// Events are delivered in the capture phase. The
9783    ///   capture phase happens before the bubble phase, runs from the toplevel down
9784    ///   to the event widget. This option should only be used on containers that
9785    ///   might possibly handle events before their children do.
9786    #[doc(alias = "GTK_PHASE_CAPTURE")]
9787    Capture,
9788    /// Events are delivered in the bubble phase. The bubble
9789    ///   phase happens after the capture phase, and before the default handlers
9790    ///   are run. This phase runs from the event widget, up to the toplevel.
9791    #[doc(alias = "GTK_PHASE_BUBBLE")]
9792    Bubble,
9793    /// Events are delivered in the default widget event handlers,
9794    ///   note that widget implementations must chain up on button, motion, touch and
9795    ///   grab broken handlers for controllers in this phase to be run.
9796    #[doc(alias = "GTK_PHASE_TARGET")]
9797    Target,
9798    #[doc(hidden)]
9799    __Unknown(i32),
9800}
9801
9802#[doc(hidden)]
9803impl IntoGlib for PropagationPhase {
9804    type GlibType = ffi::GtkPropagationPhase;
9805
9806    #[inline]
9807    fn into_glib(self) -> ffi::GtkPropagationPhase {
9808        match self {
9809            Self::None => ffi::GTK_PHASE_NONE,
9810            Self::Capture => ffi::GTK_PHASE_CAPTURE,
9811            Self::Bubble => ffi::GTK_PHASE_BUBBLE,
9812            Self::Target => ffi::GTK_PHASE_TARGET,
9813            Self::__Unknown(value) => value,
9814        }
9815    }
9816}
9817
9818#[doc(hidden)]
9819impl FromGlib<ffi::GtkPropagationPhase> for PropagationPhase {
9820    #[inline]
9821    unsafe fn from_glib(value: ffi::GtkPropagationPhase) -> Self {
9822        skip_assert_initialized!();
9823
9824        match value {
9825            ffi::GTK_PHASE_NONE => Self::None,
9826            ffi::GTK_PHASE_CAPTURE => Self::Capture,
9827            ffi::GTK_PHASE_BUBBLE => Self::Bubble,
9828            ffi::GTK_PHASE_TARGET => Self::Target,
9829            value => Self::__Unknown(value),
9830        }
9831    }
9832}
9833
9834impl StaticType for PropagationPhase {
9835    #[inline]
9836    #[doc(alias = "gtk_propagation_phase_get_type")]
9837    fn static_type() -> glib::Type {
9838        unsafe { from_glib(ffi::gtk_propagation_phase_get_type()) }
9839    }
9840}
9841
9842impl glib::HasParamSpec for PropagationPhase {
9843    type ParamSpec = glib::ParamSpecEnum;
9844    type SetValue = Self;
9845    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
9846
9847    fn param_spec_builder() -> Self::BuilderFn {
9848        Self::ParamSpec::builder_with_default
9849    }
9850}
9851
9852impl glib::value::ValueType for PropagationPhase {
9853    type Type = Self;
9854}
9855
9856unsafe impl<'a> glib::value::FromValue<'a> for PropagationPhase {
9857    type Checker = glib::value::GenericValueTypeChecker<Self>;
9858
9859    #[inline]
9860    unsafe fn from_value(value: &'a glib::Value) -> Self {
9861        skip_assert_initialized!();
9862        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
9863    }
9864}
9865
9866impl ToValue for PropagationPhase {
9867    #[inline]
9868    fn to_value(&self) -> glib::Value {
9869        let mut value = glib::Value::for_value_type::<Self>();
9870        unsafe {
9871            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
9872        }
9873        value
9874    }
9875
9876    #[inline]
9877    fn value_type(&self) -> glib::Type {
9878        Self::static_type()
9879    }
9880}
9881
9882impl From<PropagationPhase> for glib::Value {
9883    #[inline]
9884    fn from(v: PropagationPhase) -> Self {
9885        skip_assert_initialized!();
9886        ToValue::to_value(&v)
9887    }
9888}
9889
9890/// Error codes for [`RecentManager`][crate::RecentManager] operations
9891#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
9892#[non_exhaustive]
9893#[doc(alias = "GtkRecentManagerError")]
9894pub enum RecentManagerError {
9895    /// the URI specified does not exists in
9896    ///   the recently used resources list.
9897    #[doc(alias = "GTK_RECENT_MANAGER_ERROR_NOT_FOUND")]
9898    NotFound,
9899    /// the URI specified is not valid.
9900    #[doc(alias = "GTK_RECENT_MANAGER_ERROR_INVALID_URI")]
9901    InvalidUri,
9902    /// the supplied string is not
9903    ///   UTF-8 encoded.
9904    #[doc(alias = "GTK_RECENT_MANAGER_ERROR_INVALID_ENCODING")]
9905    InvalidEncoding,
9906    /// no application has registered
9907    ///   the specified item.
9908    #[doc(alias = "GTK_RECENT_MANAGER_ERROR_NOT_REGISTERED")]
9909    NotRegistered,
9910    /// failure while reading the recently used
9911    ///   resources file.
9912    #[doc(alias = "GTK_RECENT_MANAGER_ERROR_READ")]
9913    Read,
9914    /// failure while writing the recently used
9915    ///   resources file.
9916    #[doc(alias = "GTK_RECENT_MANAGER_ERROR_WRITE")]
9917    Write,
9918    /// unspecified error.
9919    #[doc(alias = "GTK_RECENT_MANAGER_ERROR_UNKNOWN")]
9920    Unknown,
9921    #[doc(hidden)]
9922    __Unknown(i32),
9923}
9924
9925#[doc(hidden)]
9926impl IntoGlib for RecentManagerError {
9927    type GlibType = ffi::GtkRecentManagerError;
9928
9929    #[inline]
9930    fn into_glib(self) -> ffi::GtkRecentManagerError {
9931        match self {
9932            Self::NotFound => ffi::GTK_RECENT_MANAGER_ERROR_NOT_FOUND,
9933            Self::InvalidUri => ffi::GTK_RECENT_MANAGER_ERROR_INVALID_URI,
9934            Self::InvalidEncoding => ffi::GTK_RECENT_MANAGER_ERROR_INVALID_ENCODING,
9935            Self::NotRegistered => ffi::GTK_RECENT_MANAGER_ERROR_NOT_REGISTERED,
9936            Self::Read => ffi::GTK_RECENT_MANAGER_ERROR_READ,
9937            Self::Write => ffi::GTK_RECENT_MANAGER_ERROR_WRITE,
9938            Self::Unknown => ffi::GTK_RECENT_MANAGER_ERROR_UNKNOWN,
9939            Self::__Unknown(value) => value,
9940        }
9941    }
9942}
9943
9944#[doc(hidden)]
9945impl FromGlib<ffi::GtkRecentManagerError> for RecentManagerError {
9946    #[inline]
9947    unsafe fn from_glib(value: ffi::GtkRecentManagerError) -> Self {
9948        skip_assert_initialized!();
9949
9950        match value {
9951            ffi::GTK_RECENT_MANAGER_ERROR_NOT_FOUND => Self::NotFound,
9952            ffi::GTK_RECENT_MANAGER_ERROR_INVALID_URI => Self::InvalidUri,
9953            ffi::GTK_RECENT_MANAGER_ERROR_INVALID_ENCODING => Self::InvalidEncoding,
9954            ffi::GTK_RECENT_MANAGER_ERROR_NOT_REGISTERED => Self::NotRegistered,
9955            ffi::GTK_RECENT_MANAGER_ERROR_READ => Self::Read,
9956            ffi::GTK_RECENT_MANAGER_ERROR_WRITE => Self::Write,
9957            ffi::GTK_RECENT_MANAGER_ERROR_UNKNOWN => Self::Unknown,
9958            value => Self::__Unknown(value),
9959        }
9960    }
9961}
9962
9963impl glib::error::ErrorDomain for RecentManagerError {
9964    #[inline]
9965    fn domain() -> glib::Quark {
9966        skip_assert_initialized!();
9967
9968        unsafe { from_glib(ffi::gtk_recent_manager_error_quark()) }
9969    }
9970
9971    #[inline]
9972    fn code(self) -> i32 {
9973        self.into_glib()
9974    }
9975
9976    #[inline]
9977    #[allow(clippy::match_single_binding)]
9978    fn from(code: i32) -> Option<Self> {
9979        skip_assert_initialized!();
9980        match unsafe { from_glib(code) } {
9981            value => Some(value),
9982        }
9983    }
9984}
9985
9986impl StaticType for RecentManagerError {
9987    #[inline]
9988    #[doc(alias = "gtk_recent_manager_error_get_type")]
9989    fn static_type() -> glib::Type {
9990        unsafe { from_glib(ffi::gtk_recent_manager_error_get_type()) }
9991    }
9992}
9993
9994impl glib::HasParamSpec for RecentManagerError {
9995    type ParamSpec = glib::ParamSpecEnum;
9996    type SetValue = Self;
9997    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
9998
9999    fn param_spec_builder() -> Self::BuilderFn {
10000        Self::ParamSpec::builder_with_default
10001    }
10002}
10003
10004impl glib::value::ValueType for RecentManagerError {
10005    type Type = Self;
10006}
10007
10008unsafe impl<'a> glib::value::FromValue<'a> for RecentManagerError {
10009    type Checker = glib::value::GenericValueTypeChecker<Self>;
10010
10011    #[inline]
10012    unsafe fn from_value(value: &'a glib::Value) -> Self {
10013        skip_assert_initialized!();
10014        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
10015    }
10016}
10017
10018impl ToValue for RecentManagerError {
10019    #[inline]
10020    fn to_value(&self) -> glib::Value {
10021        let mut value = glib::Value::for_value_type::<Self>();
10022        unsafe {
10023            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
10024        }
10025        value
10026    }
10027
10028    #[inline]
10029    fn value_type(&self) -> glib::Type {
10030        Self::static_type()
10031    }
10032}
10033
10034impl From<RecentManagerError> for glib::Value {
10035    #[inline]
10036    fn from(v: RecentManagerError) -> Self {
10037        skip_assert_initialized!();
10038        ToValue::to_value(&v)
10039    }
10040}
10041
10042/// These enumeration values describe the possible transitions
10043/// when the child of a [`Revealer`][crate::Revealer] widget is shown or hidden.
10044#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
10045#[non_exhaustive]
10046#[doc(alias = "GtkRevealerTransitionType")]
10047pub enum RevealerTransitionType {
10048    /// No transition
10049    #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_NONE")]
10050    None,
10051    /// Fade in
10052    #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_CROSSFADE")]
10053    Crossfade,
10054    /// Slide in from the left
10055    #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT")]
10056    SlideRight,
10057    /// Slide in from the right
10058    #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_SLIDE_LEFT")]
10059    SlideLeft,
10060    /// Slide in from the bottom
10061    #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_SLIDE_UP")]
10062    SlideUp,
10063    /// Slide in from the top
10064    #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN")]
10065    SlideDown,
10066    /// Floop in from the left
10067    #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_SWING_RIGHT")]
10068    SwingRight,
10069    /// Floop in from the right
10070    #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_SWING_LEFT")]
10071    SwingLeft,
10072    /// Floop in from the bottom
10073    #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_SWING_UP")]
10074    SwingUp,
10075    /// Floop in from the top
10076    #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_SWING_DOWN")]
10077    SwingDown,
10078    #[doc(hidden)]
10079    __Unknown(i32),
10080}
10081
10082#[doc(hidden)]
10083impl IntoGlib for RevealerTransitionType {
10084    type GlibType = ffi::GtkRevealerTransitionType;
10085
10086    #[inline]
10087    fn into_glib(self) -> ffi::GtkRevealerTransitionType {
10088        match self {
10089            Self::None => ffi::GTK_REVEALER_TRANSITION_TYPE_NONE,
10090            Self::Crossfade => ffi::GTK_REVEALER_TRANSITION_TYPE_CROSSFADE,
10091            Self::SlideRight => ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT,
10092            Self::SlideLeft => ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_LEFT,
10093            Self::SlideUp => ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_UP,
10094            Self::SlideDown => ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN,
10095            Self::SwingRight => ffi::GTK_REVEALER_TRANSITION_TYPE_SWING_RIGHT,
10096            Self::SwingLeft => ffi::GTK_REVEALER_TRANSITION_TYPE_SWING_LEFT,
10097            Self::SwingUp => ffi::GTK_REVEALER_TRANSITION_TYPE_SWING_UP,
10098            Self::SwingDown => ffi::GTK_REVEALER_TRANSITION_TYPE_SWING_DOWN,
10099            Self::__Unknown(value) => value,
10100        }
10101    }
10102}
10103
10104#[doc(hidden)]
10105impl FromGlib<ffi::GtkRevealerTransitionType> for RevealerTransitionType {
10106    #[inline]
10107    unsafe fn from_glib(value: ffi::GtkRevealerTransitionType) -> Self {
10108        skip_assert_initialized!();
10109
10110        match value {
10111            ffi::GTK_REVEALER_TRANSITION_TYPE_NONE => Self::None,
10112            ffi::GTK_REVEALER_TRANSITION_TYPE_CROSSFADE => Self::Crossfade,
10113            ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT => Self::SlideRight,
10114            ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_LEFT => Self::SlideLeft,
10115            ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_UP => Self::SlideUp,
10116            ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN => Self::SlideDown,
10117            ffi::GTK_REVEALER_TRANSITION_TYPE_SWING_RIGHT => Self::SwingRight,
10118            ffi::GTK_REVEALER_TRANSITION_TYPE_SWING_LEFT => Self::SwingLeft,
10119            ffi::GTK_REVEALER_TRANSITION_TYPE_SWING_UP => Self::SwingUp,
10120            ffi::GTK_REVEALER_TRANSITION_TYPE_SWING_DOWN => Self::SwingDown,
10121            value => Self::__Unknown(value),
10122        }
10123    }
10124}
10125
10126impl StaticType for RevealerTransitionType {
10127    #[inline]
10128    #[doc(alias = "gtk_revealer_transition_type_get_type")]
10129    fn static_type() -> glib::Type {
10130        unsafe { from_glib(ffi::gtk_revealer_transition_type_get_type()) }
10131    }
10132}
10133
10134impl glib::HasParamSpec for RevealerTransitionType {
10135    type ParamSpec = glib::ParamSpecEnum;
10136    type SetValue = Self;
10137    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
10138
10139    fn param_spec_builder() -> Self::BuilderFn {
10140        Self::ParamSpec::builder_with_default
10141    }
10142}
10143
10144impl glib::value::ValueType for RevealerTransitionType {
10145    type Type = Self;
10146}
10147
10148unsafe impl<'a> glib::value::FromValue<'a> for RevealerTransitionType {
10149    type Checker = glib::value::GenericValueTypeChecker<Self>;
10150
10151    #[inline]
10152    unsafe fn from_value(value: &'a glib::Value) -> Self {
10153        skip_assert_initialized!();
10154        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
10155    }
10156}
10157
10158impl ToValue for RevealerTransitionType {
10159    #[inline]
10160    fn to_value(&self) -> glib::Value {
10161        let mut value = glib::Value::for_value_type::<Self>();
10162        unsafe {
10163            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
10164        }
10165        value
10166    }
10167
10168    #[inline]
10169    fn value_type(&self) -> glib::Type {
10170        Self::static_type()
10171    }
10172}
10173
10174impl From<RevealerTransitionType> for glib::Value {
10175    #[inline]
10176    fn from(v: RevealerTransitionType) -> Self {
10177        skip_assert_initialized!();
10178        ToValue::to_value(&v)
10179    }
10180}
10181
10182/// Passed as argument to various keybinding signals.
10183#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
10184#[non_exhaustive]
10185#[doc(alias = "GtkScrollStep")]
10186pub enum ScrollStep {
10187    /// Scroll in steps.
10188    #[doc(alias = "GTK_SCROLL_STEPS")]
10189    Steps,
10190    /// Scroll by pages.
10191    #[doc(alias = "GTK_SCROLL_PAGES")]
10192    Pages,
10193    /// Scroll to ends.
10194    #[doc(alias = "GTK_SCROLL_ENDS")]
10195    Ends,
10196    /// Scroll in horizontal steps.
10197    #[doc(alias = "GTK_SCROLL_HORIZONTAL_STEPS")]
10198    HorizontalSteps,
10199    /// Scroll by horizontal pages.
10200    #[doc(alias = "GTK_SCROLL_HORIZONTAL_PAGES")]
10201    HorizontalPages,
10202    /// Scroll to the horizontal ends.
10203    #[doc(alias = "GTK_SCROLL_HORIZONTAL_ENDS")]
10204    HorizontalEnds,
10205    #[doc(hidden)]
10206    __Unknown(i32),
10207}
10208
10209#[doc(hidden)]
10210impl IntoGlib for ScrollStep {
10211    type GlibType = ffi::GtkScrollStep;
10212
10213    #[inline]
10214    fn into_glib(self) -> ffi::GtkScrollStep {
10215        match self {
10216            Self::Steps => ffi::GTK_SCROLL_STEPS,
10217            Self::Pages => ffi::GTK_SCROLL_PAGES,
10218            Self::Ends => ffi::GTK_SCROLL_ENDS,
10219            Self::HorizontalSteps => ffi::GTK_SCROLL_HORIZONTAL_STEPS,
10220            Self::HorizontalPages => ffi::GTK_SCROLL_HORIZONTAL_PAGES,
10221            Self::HorizontalEnds => ffi::GTK_SCROLL_HORIZONTAL_ENDS,
10222            Self::__Unknown(value) => value,
10223        }
10224    }
10225}
10226
10227#[doc(hidden)]
10228impl FromGlib<ffi::GtkScrollStep> for ScrollStep {
10229    #[inline]
10230    unsafe fn from_glib(value: ffi::GtkScrollStep) -> Self {
10231        skip_assert_initialized!();
10232
10233        match value {
10234            ffi::GTK_SCROLL_STEPS => Self::Steps,
10235            ffi::GTK_SCROLL_PAGES => Self::Pages,
10236            ffi::GTK_SCROLL_ENDS => Self::Ends,
10237            ffi::GTK_SCROLL_HORIZONTAL_STEPS => Self::HorizontalSteps,
10238            ffi::GTK_SCROLL_HORIZONTAL_PAGES => Self::HorizontalPages,
10239            ffi::GTK_SCROLL_HORIZONTAL_ENDS => Self::HorizontalEnds,
10240            value => Self::__Unknown(value),
10241        }
10242    }
10243}
10244
10245impl StaticType for ScrollStep {
10246    #[inline]
10247    #[doc(alias = "gtk_scroll_step_get_type")]
10248    fn static_type() -> glib::Type {
10249        unsafe { from_glib(ffi::gtk_scroll_step_get_type()) }
10250    }
10251}
10252
10253impl glib::HasParamSpec for ScrollStep {
10254    type ParamSpec = glib::ParamSpecEnum;
10255    type SetValue = Self;
10256    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
10257
10258    fn param_spec_builder() -> Self::BuilderFn {
10259        Self::ParamSpec::builder_with_default
10260    }
10261}
10262
10263impl glib::value::ValueType for ScrollStep {
10264    type Type = Self;
10265}
10266
10267unsafe impl<'a> glib::value::FromValue<'a> for ScrollStep {
10268    type Checker = glib::value::GenericValueTypeChecker<Self>;
10269
10270    #[inline]
10271    unsafe fn from_value(value: &'a glib::Value) -> Self {
10272        skip_assert_initialized!();
10273        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
10274    }
10275}
10276
10277impl ToValue for ScrollStep {
10278    #[inline]
10279    fn to_value(&self) -> glib::Value {
10280        let mut value = glib::Value::for_value_type::<Self>();
10281        unsafe {
10282            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
10283        }
10284        value
10285    }
10286
10287    #[inline]
10288    fn value_type(&self) -> glib::Type {
10289        Self::static_type()
10290    }
10291}
10292
10293impl From<ScrollStep> for glib::Value {
10294    #[inline]
10295    fn from(v: ScrollStep) -> Self {
10296        skip_assert_initialized!();
10297        ToValue::to_value(&v)
10298    }
10299}
10300
10301/// Scrolling types.
10302#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
10303#[non_exhaustive]
10304#[doc(alias = "GtkScrollType")]
10305pub enum ScrollType {
10306    /// No scrolling.
10307    #[doc(alias = "GTK_SCROLL_NONE")]
10308    None,
10309    /// Jump to new location.
10310    #[doc(alias = "GTK_SCROLL_JUMP")]
10311    Jump,
10312    /// Step backward.
10313    #[doc(alias = "GTK_SCROLL_STEP_BACKWARD")]
10314    StepBackward,
10315    /// Step forward.
10316    #[doc(alias = "GTK_SCROLL_STEP_FORWARD")]
10317    StepForward,
10318    /// Page backward.
10319    #[doc(alias = "GTK_SCROLL_PAGE_BACKWARD")]
10320    PageBackward,
10321    /// Page forward.
10322    #[doc(alias = "GTK_SCROLL_PAGE_FORWARD")]
10323    PageForward,
10324    /// Step up.
10325    #[doc(alias = "GTK_SCROLL_STEP_UP")]
10326    StepUp,
10327    /// Step down.
10328    #[doc(alias = "GTK_SCROLL_STEP_DOWN")]
10329    StepDown,
10330    /// Page up.
10331    #[doc(alias = "GTK_SCROLL_PAGE_UP")]
10332    PageUp,
10333    /// Page down.
10334    #[doc(alias = "GTK_SCROLL_PAGE_DOWN")]
10335    PageDown,
10336    /// Step to the left.
10337    #[doc(alias = "GTK_SCROLL_STEP_LEFT")]
10338    StepLeft,
10339    /// Step to the right.
10340    #[doc(alias = "GTK_SCROLL_STEP_RIGHT")]
10341    StepRight,
10342    /// Page to the left.
10343    #[doc(alias = "GTK_SCROLL_PAGE_LEFT")]
10344    PageLeft,
10345    /// Page to the right.
10346    #[doc(alias = "GTK_SCROLL_PAGE_RIGHT")]
10347    PageRight,
10348    /// Scroll to start.
10349    #[doc(alias = "GTK_SCROLL_START")]
10350    Start,
10351    /// Scroll to end.
10352    #[doc(alias = "GTK_SCROLL_END")]
10353    End,
10354    #[doc(hidden)]
10355    __Unknown(i32),
10356}
10357
10358#[doc(hidden)]
10359impl IntoGlib for ScrollType {
10360    type GlibType = ffi::GtkScrollType;
10361
10362    fn into_glib(self) -> ffi::GtkScrollType {
10363        match self {
10364            Self::None => ffi::GTK_SCROLL_NONE,
10365            Self::Jump => ffi::GTK_SCROLL_JUMP,
10366            Self::StepBackward => ffi::GTK_SCROLL_STEP_BACKWARD,
10367            Self::StepForward => ffi::GTK_SCROLL_STEP_FORWARD,
10368            Self::PageBackward => ffi::GTK_SCROLL_PAGE_BACKWARD,
10369            Self::PageForward => ffi::GTK_SCROLL_PAGE_FORWARD,
10370            Self::StepUp => ffi::GTK_SCROLL_STEP_UP,
10371            Self::StepDown => ffi::GTK_SCROLL_STEP_DOWN,
10372            Self::PageUp => ffi::GTK_SCROLL_PAGE_UP,
10373            Self::PageDown => ffi::GTK_SCROLL_PAGE_DOWN,
10374            Self::StepLeft => ffi::GTK_SCROLL_STEP_LEFT,
10375            Self::StepRight => ffi::GTK_SCROLL_STEP_RIGHT,
10376            Self::PageLeft => ffi::GTK_SCROLL_PAGE_LEFT,
10377            Self::PageRight => ffi::GTK_SCROLL_PAGE_RIGHT,
10378            Self::Start => ffi::GTK_SCROLL_START,
10379            Self::End => ffi::GTK_SCROLL_END,
10380            Self::__Unknown(value) => value,
10381        }
10382    }
10383}
10384
10385#[doc(hidden)]
10386impl FromGlib<ffi::GtkScrollType> for ScrollType {
10387    unsafe fn from_glib(value: ffi::GtkScrollType) -> Self {
10388        skip_assert_initialized!();
10389
10390        match value {
10391            ffi::GTK_SCROLL_NONE => Self::None,
10392            ffi::GTK_SCROLL_JUMP => Self::Jump,
10393            ffi::GTK_SCROLL_STEP_BACKWARD => Self::StepBackward,
10394            ffi::GTK_SCROLL_STEP_FORWARD => Self::StepForward,
10395            ffi::GTK_SCROLL_PAGE_BACKWARD => Self::PageBackward,
10396            ffi::GTK_SCROLL_PAGE_FORWARD => Self::PageForward,
10397            ffi::GTK_SCROLL_STEP_UP => Self::StepUp,
10398            ffi::GTK_SCROLL_STEP_DOWN => Self::StepDown,
10399            ffi::GTK_SCROLL_PAGE_UP => Self::PageUp,
10400            ffi::GTK_SCROLL_PAGE_DOWN => Self::PageDown,
10401            ffi::GTK_SCROLL_STEP_LEFT => Self::StepLeft,
10402            ffi::GTK_SCROLL_STEP_RIGHT => Self::StepRight,
10403            ffi::GTK_SCROLL_PAGE_LEFT => Self::PageLeft,
10404            ffi::GTK_SCROLL_PAGE_RIGHT => Self::PageRight,
10405            ffi::GTK_SCROLL_START => Self::Start,
10406            ffi::GTK_SCROLL_END => Self::End,
10407            value => Self::__Unknown(value),
10408        }
10409    }
10410}
10411
10412impl StaticType for ScrollType {
10413    #[inline]
10414    #[doc(alias = "gtk_scroll_type_get_type")]
10415    fn static_type() -> glib::Type {
10416        unsafe { from_glib(ffi::gtk_scroll_type_get_type()) }
10417    }
10418}
10419
10420impl glib::HasParamSpec for ScrollType {
10421    type ParamSpec = glib::ParamSpecEnum;
10422    type SetValue = Self;
10423    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
10424
10425    fn param_spec_builder() -> Self::BuilderFn {
10426        Self::ParamSpec::builder_with_default
10427    }
10428}
10429
10430impl glib::value::ValueType for ScrollType {
10431    type Type = Self;
10432}
10433
10434unsafe impl<'a> glib::value::FromValue<'a> for ScrollType {
10435    type Checker = glib::value::GenericValueTypeChecker<Self>;
10436
10437    #[inline]
10438    unsafe fn from_value(value: &'a glib::Value) -> Self {
10439        skip_assert_initialized!();
10440        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
10441    }
10442}
10443
10444impl ToValue for ScrollType {
10445    #[inline]
10446    fn to_value(&self) -> glib::Value {
10447        let mut value = glib::Value::for_value_type::<Self>();
10448        unsafe {
10449            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
10450        }
10451        value
10452    }
10453
10454    #[inline]
10455    fn value_type(&self) -> glib::Type {
10456        Self::static_type()
10457    }
10458}
10459
10460impl From<ScrollType> for glib::Value {
10461    #[inline]
10462    fn from(v: ScrollType) -> Self {
10463        skip_assert_initialized!();
10464        ToValue::to_value(&v)
10465    }
10466}
10467
10468/// Defines the policy to be used in a scrollable widget when updating
10469/// the scrolled window adjustments in a given orientation.
10470#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
10471#[non_exhaustive]
10472#[doc(alias = "GtkScrollablePolicy")]
10473pub enum ScrollablePolicy {
10474    /// Scrollable adjustments are based on the minimum size
10475    #[doc(alias = "GTK_SCROLL_MINIMUM")]
10476    Minimum,
10477    /// Scrollable adjustments are based on the natural size
10478    #[doc(alias = "GTK_SCROLL_NATURAL")]
10479    Natural,
10480    #[doc(hidden)]
10481    __Unknown(i32),
10482}
10483
10484#[doc(hidden)]
10485impl IntoGlib for ScrollablePolicy {
10486    type GlibType = ffi::GtkScrollablePolicy;
10487
10488    #[inline]
10489    fn into_glib(self) -> ffi::GtkScrollablePolicy {
10490        match self {
10491            Self::Minimum => ffi::GTK_SCROLL_MINIMUM,
10492            Self::Natural => ffi::GTK_SCROLL_NATURAL,
10493            Self::__Unknown(value) => value,
10494        }
10495    }
10496}
10497
10498#[doc(hidden)]
10499impl FromGlib<ffi::GtkScrollablePolicy> for ScrollablePolicy {
10500    #[inline]
10501    unsafe fn from_glib(value: ffi::GtkScrollablePolicy) -> Self {
10502        skip_assert_initialized!();
10503
10504        match value {
10505            ffi::GTK_SCROLL_MINIMUM => Self::Minimum,
10506            ffi::GTK_SCROLL_NATURAL => Self::Natural,
10507            value => Self::__Unknown(value),
10508        }
10509    }
10510}
10511
10512impl StaticType for ScrollablePolicy {
10513    #[inline]
10514    #[doc(alias = "gtk_scrollable_policy_get_type")]
10515    fn static_type() -> glib::Type {
10516        unsafe { from_glib(ffi::gtk_scrollable_policy_get_type()) }
10517    }
10518}
10519
10520impl glib::HasParamSpec for ScrollablePolicy {
10521    type ParamSpec = glib::ParamSpecEnum;
10522    type SetValue = Self;
10523    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
10524
10525    fn param_spec_builder() -> Self::BuilderFn {
10526        Self::ParamSpec::builder_with_default
10527    }
10528}
10529
10530impl glib::value::ValueType for ScrollablePolicy {
10531    type Type = Self;
10532}
10533
10534unsafe impl<'a> glib::value::FromValue<'a> for ScrollablePolicy {
10535    type Checker = glib::value::GenericValueTypeChecker<Self>;
10536
10537    #[inline]
10538    unsafe fn from_value(value: &'a glib::Value) -> Self {
10539        skip_assert_initialized!();
10540        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
10541    }
10542}
10543
10544impl ToValue for ScrollablePolicy {
10545    #[inline]
10546    fn to_value(&self) -> glib::Value {
10547        let mut value = glib::Value::for_value_type::<Self>();
10548        unsafe {
10549            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
10550        }
10551        value
10552    }
10553
10554    #[inline]
10555    fn value_type(&self) -> glib::Type {
10556        Self::static_type()
10557    }
10558}
10559
10560impl From<ScrollablePolicy> for glib::Value {
10561    #[inline]
10562    fn from(v: ScrollablePolicy) -> Self {
10563        skip_assert_initialized!();
10564        ToValue::to_value(&v)
10565    }
10566}
10567
10568/// Used to control what selections users are allowed to make.
10569#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
10570#[non_exhaustive]
10571#[doc(alias = "GtkSelectionMode")]
10572pub enum SelectionMode {
10573    /// No selection is possible.
10574    #[doc(alias = "GTK_SELECTION_NONE")]
10575    None,
10576    /// Zero or one element may be selected.
10577    #[doc(alias = "GTK_SELECTION_SINGLE")]
10578    Single,
10579    /// Exactly one element is selected.
10580    ///   In some circumstances, such as initially or during a search
10581    ///   operation, it’s possible for no element to be selected with
10582    ///   [`Browse`][Self::Browse]. What is really enforced is that the user
10583    ///   can’t deselect a currently selected element except by selecting
10584    ///   another element.
10585    #[doc(alias = "GTK_SELECTION_BROWSE")]
10586    Browse,
10587    /// Any number of elements may be selected.
10588    ///   The Ctrl key may be used to enlarge the selection, and Shift
10589    ///   key to select between the focus and the child pointed to.
10590    ///   Some widgets may also allow Click-drag to select a range of elements.
10591    #[doc(alias = "GTK_SELECTION_MULTIPLE")]
10592    Multiple,
10593    #[doc(hidden)]
10594    __Unknown(i32),
10595}
10596
10597#[doc(hidden)]
10598impl IntoGlib for SelectionMode {
10599    type GlibType = ffi::GtkSelectionMode;
10600
10601    #[inline]
10602    fn into_glib(self) -> ffi::GtkSelectionMode {
10603        match self {
10604            Self::None => ffi::GTK_SELECTION_NONE,
10605            Self::Single => ffi::GTK_SELECTION_SINGLE,
10606            Self::Browse => ffi::GTK_SELECTION_BROWSE,
10607            Self::Multiple => ffi::GTK_SELECTION_MULTIPLE,
10608            Self::__Unknown(value) => value,
10609        }
10610    }
10611}
10612
10613#[doc(hidden)]
10614impl FromGlib<ffi::GtkSelectionMode> for SelectionMode {
10615    #[inline]
10616    unsafe fn from_glib(value: ffi::GtkSelectionMode) -> Self {
10617        skip_assert_initialized!();
10618
10619        match value {
10620            ffi::GTK_SELECTION_NONE => Self::None,
10621            ffi::GTK_SELECTION_SINGLE => Self::Single,
10622            ffi::GTK_SELECTION_BROWSE => Self::Browse,
10623            ffi::GTK_SELECTION_MULTIPLE => Self::Multiple,
10624            value => Self::__Unknown(value),
10625        }
10626    }
10627}
10628
10629impl StaticType for SelectionMode {
10630    #[inline]
10631    #[doc(alias = "gtk_selection_mode_get_type")]
10632    fn static_type() -> glib::Type {
10633        unsafe { from_glib(ffi::gtk_selection_mode_get_type()) }
10634    }
10635}
10636
10637impl glib::HasParamSpec for SelectionMode {
10638    type ParamSpec = glib::ParamSpecEnum;
10639    type SetValue = Self;
10640    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
10641
10642    fn param_spec_builder() -> Self::BuilderFn {
10643        Self::ParamSpec::builder_with_default
10644    }
10645}
10646
10647impl glib::value::ValueType for SelectionMode {
10648    type Type = Self;
10649}
10650
10651unsafe impl<'a> glib::value::FromValue<'a> for SelectionMode {
10652    type Checker = glib::value::GenericValueTypeChecker<Self>;
10653
10654    #[inline]
10655    unsafe fn from_value(value: &'a glib::Value) -> Self {
10656        skip_assert_initialized!();
10657        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
10658    }
10659}
10660
10661impl ToValue for SelectionMode {
10662    #[inline]
10663    fn to_value(&self) -> glib::Value {
10664        let mut value = glib::Value::for_value_type::<Self>();
10665        unsafe {
10666            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
10667        }
10668        value
10669    }
10670
10671    #[inline]
10672    fn value_type(&self) -> glib::Type {
10673        Self::static_type()
10674    }
10675}
10676
10677impl From<SelectionMode> for glib::Value {
10678    #[inline]
10679    fn from(v: SelectionMode) -> Self {
10680        skip_assert_initialized!();
10681        ToValue::to_value(&v)
10682    }
10683}
10684
10685/// Determines how GTK handles the sensitivity of various controls,
10686/// such as combo box buttons.
10687#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
10688#[non_exhaustive]
10689#[doc(alias = "GtkSensitivityType")]
10690pub enum SensitivityType {
10691    /// The control is made insensitive if no
10692    ///   action can be triggered
10693    #[doc(alias = "GTK_SENSITIVITY_AUTO")]
10694    Auto,
10695    /// The control is always sensitive
10696    #[doc(alias = "GTK_SENSITIVITY_ON")]
10697    On,
10698    /// The control is always insensitive
10699    #[doc(alias = "GTK_SENSITIVITY_OFF")]
10700    Off,
10701    #[doc(hidden)]
10702    __Unknown(i32),
10703}
10704
10705#[doc(hidden)]
10706impl IntoGlib for SensitivityType {
10707    type GlibType = ffi::GtkSensitivityType;
10708
10709    #[inline]
10710    fn into_glib(self) -> ffi::GtkSensitivityType {
10711        match self {
10712            Self::Auto => ffi::GTK_SENSITIVITY_AUTO,
10713            Self::On => ffi::GTK_SENSITIVITY_ON,
10714            Self::Off => ffi::GTK_SENSITIVITY_OFF,
10715            Self::__Unknown(value) => value,
10716        }
10717    }
10718}
10719
10720#[doc(hidden)]
10721impl FromGlib<ffi::GtkSensitivityType> for SensitivityType {
10722    #[inline]
10723    unsafe fn from_glib(value: ffi::GtkSensitivityType) -> Self {
10724        skip_assert_initialized!();
10725
10726        match value {
10727            ffi::GTK_SENSITIVITY_AUTO => Self::Auto,
10728            ffi::GTK_SENSITIVITY_ON => Self::On,
10729            ffi::GTK_SENSITIVITY_OFF => Self::Off,
10730            value => Self::__Unknown(value),
10731        }
10732    }
10733}
10734
10735impl StaticType for SensitivityType {
10736    #[inline]
10737    #[doc(alias = "gtk_sensitivity_type_get_type")]
10738    fn static_type() -> glib::Type {
10739        unsafe { from_glib(ffi::gtk_sensitivity_type_get_type()) }
10740    }
10741}
10742
10743impl glib::HasParamSpec for SensitivityType {
10744    type ParamSpec = glib::ParamSpecEnum;
10745    type SetValue = Self;
10746    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
10747
10748    fn param_spec_builder() -> Self::BuilderFn {
10749        Self::ParamSpec::builder_with_default
10750    }
10751}
10752
10753impl glib::value::ValueType for SensitivityType {
10754    type Type = Self;
10755}
10756
10757unsafe impl<'a> glib::value::FromValue<'a> for SensitivityType {
10758    type Checker = glib::value::GenericValueTypeChecker<Self>;
10759
10760    #[inline]
10761    unsafe fn from_value(value: &'a glib::Value) -> Self {
10762        skip_assert_initialized!();
10763        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
10764    }
10765}
10766
10767impl ToValue for SensitivityType {
10768    #[inline]
10769    fn to_value(&self) -> glib::Value {
10770        let mut value = glib::Value::for_value_type::<Self>();
10771        unsafe {
10772            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
10773        }
10774        value
10775    }
10776
10777    #[inline]
10778    fn value_type(&self) -> glib::Type {
10779        Self::static_type()
10780    }
10781}
10782
10783impl From<SensitivityType> for glib::Value {
10784    #[inline]
10785    fn from(v: SensitivityType) -> Self {
10786        skip_assert_initialized!();
10787        ToValue::to_value(&v)
10788    }
10789}
10790
10791/// Describes where [`Shortcut`][crate::Shortcut]s added to a
10792/// [`ShortcutController`][crate::ShortcutController] get handled.
10793#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
10794#[non_exhaustive]
10795#[doc(alias = "GtkShortcutScope")]
10796pub enum ShortcutScope {
10797    /// Shortcuts are handled inside
10798    ///   the widget the controller belongs to.
10799    #[doc(alias = "GTK_SHORTCUT_SCOPE_LOCAL")]
10800    Local,
10801    /// Shortcuts are handled by
10802    ///   the first ancestor that is a [`ShortcutManager`][crate::ShortcutManager]
10803    #[doc(alias = "GTK_SHORTCUT_SCOPE_MANAGED")]
10804    Managed,
10805    /// Shortcuts are handled by
10806    ///   the root widget.
10807    #[doc(alias = "GTK_SHORTCUT_SCOPE_GLOBAL")]
10808    Global,
10809    #[doc(hidden)]
10810    __Unknown(i32),
10811}
10812
10813#[doc(hidden)]
10814impl IntoGlib for ShortcutScope {
10815    type GlibType = ffi::GtkShortcutScope;
10816
10817    #[inline]
10818    fn into_glib(self) -> ffi::GtkShortcutScope {
10819        match self {
10820            Self::Local => ffi::GTK_SHORTCUT_SCOPE_LOCAL,
10821            Self::Managed => ffi::GTK_SHORTCUT_SCOPE_MANAGED,
10822            Self::Global => ffi::GTK_SHORTCUT_SCOPE_GLOBAL,
10823            Self::__Unknown(value) => value,
10824        }
10825    }
10826}
10827
10828#[doc(hidden)]
10829impl FromGlib<ffi::GtkShortcutScope> for ShortcutScope {
10830    #[inline]
10831    unsafe fn from_glib(value: ffi::GtkShortcutScope) -> Self {
10832        skip_assert_initialized!();
10833
10834        match value {
10835            ffi::GTK_SHORTCUT_SCOPE_LOCAL => Self::Local,
10836            ffi::GTK_SHORTCUT_SCOPE_MANAGED => Self::Managed,
10837            ffi::GTK_SHORTCUT_SCOPE_GLOBAL => Self::Global,
10838            value => Self::__Unknown(value),
10839        }
10840    }
10841}
10842
10843impl StaticType for ShortcutScope {
10844    #[inline]
10845    #[doc(alias = "gtk_shortcut_scope_get_type")]
10846    fn static_type() -> glib::Type {
10847        unsafe { from_glib(ffi::gtk_shortcut_scope_get_type()) }
10848    }
10849}
10850
10851impl glib::HasParamSpec for ShortcutScope {
10852    type ParamSpec = glib::ParamSpecEnum;
10853    type SetValue = Self;
10854    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
10855
10856    fn param_spec_builder() -> Self::BuilderFn {
10857        Self::ParamSpec::builder_with_default
10858    }
10859}
10860
10861impl glib::value::ValueType for ShortcutScope {
10862    type Type = Self;
10863}
10864
10865unsafe impl<'a> glib::value::FromValue<'a> for ShortcutScope {
10866    type Checker = glib::value::GenericValueTypeChecker<Self>;
10867
10868    #[inline]
10869    unsafe fn from_value(value: &'a glib::Value) -> Self {
10870        skip_assert_initialized!();
10871        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
10872    }
10873}
10874
10875impl ToValue for ShortcutScope {
10876    #[inline]
10877    fn to_value(&self) -> glib::Value {
10878        let mut value = glib::Value::for_value_type::<Self>();
10879        unsafe {
10880            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
10881        }
10882        value
10883    }
10884
10885    #[inline]
10886    fn value_type(&self) -> glib::Type {
10887        Self::static_type()
10888    }
10889}
10890
10891impl From<ShortcutScope> for glib::Value {
10892    #[inline]
10893    fn from(v: ShortcutScope) -> Self {
10894        skip_assert_initialized!();
10895        ToValue::to_value(&v)
10896    }
10897}
10898
10899/// GtkShortcutType specifies the kind of shortcut that is being described.
10900///
10901/// More values may be added to this enumeration over time.
10902#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
10903#[non_exhaustive]
10904#[doc(alias = "GtkShortcutType")]
10905pub enum ShortcutType {
10906    /// The shortcut is a keyboard accelerator. The GtkShortcutsShortcut:accelerator
10907    ///   property will be used.
10908    #[doc(alias = "GTK_SHORTCUT_ACCELERATOR")]
10909    Accelerator,
10910    /// The shortcut is a pinch gesture. GTK provides an icon and subtitle.
10911    #[doc(alias = "GTK_SHORTCUT_GESTURE_PINCH")]
10912    GesturePinch,
10913    /// The shortcut is a stretch gesture. GTK provides an icon and subtitle.
10914    #[doc(alias = "GTK_SHORTCUT_GESTURE_STRETCH")]
10915    GestureStretch,
10916    /// The shortcut is a clockwise rotation gesture. GTK provides an icon and subtitle.
10917    #[doc(alias = "GTK_SHORTCUT_GESTURE_ROTATE_CLOCKWISE")]
10918    GestureRotateClockwise,
10919    /// The shortcut is a counterclockwise rotation gesture. GTK provides an icon and subtitle.
10920    #[doc(alias = "GTK_SHORTCUT_GESTURE_ROTATE_COUNTERCLOCKWISE")]
10921    GestureRotateCounterclockwise,
10922    /// The shortcut is a two-finger swipe gesture. GTK provides an icon and subtitle.
10923    #[doc(alias = "GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_LEFT")]
10924    GestureTwoFingerSwipeLeft,
10925    /// The shortcut is a two-finger swipe gesture. GTK provides an icon and subtitle.
10926    #[doc(alias = "GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_RIGHT")]
10927    GestureTwoFingerSwipeRight,
10928    /// The shortcut is a gesture. The GtkShortcutsShortcut:icon property will be
10929    ///   used.
10930    #[doc(alias = "GTK_SHORTCUT_GESTURE")]
10931    Gesture,
10932    /// The shortcut is a swipe gesture. GTK provides an icon and subtitle.
10933    #[doc(alias = "GTK_SHORTCUT_GESTURE_SWIPE_LEFT")]
10934    GestureSwipeLeft,
10935    /// The shortcut is a swipe gesture. GTK provides an icon and subtitle.
10936    #[doc(alias = "GTK_SHORTCUT_GESTURE_SWIPE_RIGHT")]
10937    GestureSwipeRight,
10938    #[doc(hidden)]
10939    __Unknown(i32),
10940}
10941
10942#[doc(hidden)]
10943impl IntoGlib for ShortcutType {
10944    type GlibType = ffi::GtkShortcutType;
10945
10946    #[inline]
10947    fn into_glib(self) -> ffi::GtkShortcutType {
10948        match self {
10949            Self::Accelerator => ffi::GTK_SHORTCUT_ACCELERATOR,
10950            Self::GesturePinch => ffi::GTK_SHORTCUT_GESTURE_PINCH,
10951            Self::GestureStretch => ffi::GTK_SHORTCUT_GESTURE_STRETCH,
10952            Self::GestureRotateClockwise => ffi::GTK_SHORTCUT_GESTURE_ROTATE_CLOCKWISE,
10953            Self::GestureRotateCounterclockwise => {
10954                ffi::GTK_SHORTCUT_GESTURE_ROTATE_COUNTERCLOCKWISE
10955            }
10956            Self::GestureTwoFingerSwipeLeft => ffi::GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_LEFT,
10957            Self::GestureTwoFingerSwipeRight => ffi::GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_RIGHT,
10958            Self::Gesture => ffi::GTK_SHORTCUT_GESTURE,
10959            Self::GestureSwipeLeft => ffi::GTK_SHORTCUT_GESTURE_SWIPE_LEFT,
10960            Self::GestureSwipeRight => ffi::GTK_SHORTCUT_GESTURE_SWIPE_RIGHT,
10961            Self::__Unknown(value) => value,
10962        }
10963    }
10964}
10965
10966#[doc(hidden)]
10967impl FromGlib<ffi::GtkShortcutType> for ShortcutType {
10968    #[inline]
10969    unsafe fn from_glib(value: ffi::GtkShortcutType) -> Self {
10970        skip_assert_initialized!();
10971
10972        match value {
10973            ffi::GTK_SHORTCUT_ACCELERATOR => Self::Accelerator,
10974            ffi::GTK_SHORTCUT_GESTURE_PINCH => Self::GesturePinch,
10975            ffi::GTK_SHORTCUT_GESTURE_STRETCH => Self::GestureStretch,
10976            ffi::GTK_SHORTCUT_GESTURE_ROTATE_CLOCKWISE => Self::GestureRotateClockwise,
10977            ffi::GTK_SHORTCUT_GESTURE_ROTATE_COUNTERCLOCKWISE => {
10978                Self::GestureRotateCounterclockwise
10979            }
10980            ffi::GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_LEFT => Self::GestureTwoFingerSwipeLeft,
10981            ffi::GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_RIGHT => Self::GestureTwoFingerSwipeRight,
10982            ffi::GTK_SHORTCUT_GESTURE => Self::Gesture,
10983            ffi::GTK_SHORTCUT_GESTURE_SWIPE_LEFT => Self::GestureSwipeLeft,
10984            ffi::GTK_SHORTCUT_GESTURE_SWIPE_RIGHT => Self::GestureSwipeRight,
10985            value => Self::__Unknown(value),
10986        }
10987    }
10988}
10989
10990impl StaticType for ShortcutType {
10991    #[inline]
10992    #[doc(alias = "gtk_shortcut_type_get_type")]
10993    fn static_type() -> glib::Type {
10994        unsafe { from_glib(ffi::gtk_shortcut_type_get_type()) }
10995    }
10996}
10997
10998impl glib::HasParamSpec for ShortcutType {
10999    type ParamSpec = glib::ParamSpecEnum;
11000    type SetValue = Self;
11001    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
11002
11003    fn param_spec_builder() -> Self::BuilderFn {
11004        Self::ParamSpec::builder_with_default
11005    }
11006}
11007
11008impl glib::value::ValueType for ShortcutType {
11009    type Type = Self;
11010}
11011
11012unsafe impl<'a> glib::value::FromValue<'a> for ShortcutType {
11013    type Checker = glib::value::GenericValueTypeChecker<Self>;
11014
11015    #[inline]
11016    unsafe fn from_value(value: &'a glib::Value) -> Self {
11017        skip_assert_initialized!();
11018        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
11019    }
11020}
11021
11022impl ToValue for ShortcutType {
11023    #[inline]
11024    fn to_value(&self) -> glib::Value {
11025        let mut value = glib::Value::for_value_type::<Self>();
11026        unsafe {
11027            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
11028        }
11029        value
11030    }
11031
11032    #[inline]
11033    fn value_type(&self) -> glib::Type {
11034        Self::static_type()
11035    }
11036}
11037
11038impl From<ShortcutType> for glib::Value {
11039    #[inline]
11040    fn from(v: ShortcutType) -> Self {
11041        skip_assert_initialized!();
11042        ToValue::to_value(&v)
11043    }
11044}
11045
11046/// The mode of the size group determines the directions in which the size
11047/// group affects the requested sizes of its component widgets.
11048#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
11049#[non_exhaustive]
11050#[doc(alias = "GtkSizeGroupMode")]
11051pub enum SizeGroupMode {
11052    /// group has no effect
11053    #[doc(alias = "GTK_SIZE_GROUP_NONE")]
11054    None,
11055    /// group affects horizontal requisition
11056    #[doc(alias = "GTK_SIZE_GROUP_HORIZONTAL")]
11057    Horizontal,
11058    /// group affects vertical requisition
11059    #[doc(alias = "GTK_SIZE_GROUP_VERTICAL")]
11060    Vertical,
11061    /// group affects both horizontal and vertical requisition
11062    #[doc(alias = "GTK_SIZE_GROUP_BOTH")]
11063    Both,
11064    #[doc(hidden)]
11065    __Unknown(i32),
11066}
11067
11068#[doc(hidden)]
11069impl IntoGlib for SizeGroupMode {
11070    type GlibType = ffi::GtkSizeGroupMode;
11071
11072    #[inline]
11073    fn into_glib(self) -> ffi::GtkSizeGroupMode {
11074        match self {
11075            Self::None => ffi::GTK_SIZE_GROUP_NONE,
11076            Self::Horizontal => ffi::GTK_SIZE_GROUP_HORIZONTAL,
11077            Self::Vertical => ffi::GTK_SIZE_GROUP_VERTICAL,
11078            Self::Both => ffi::GTK_SIZE_GROUP_BOTH,
11079            Self::__Unknown(value) => value,
11080        }
11081    }
11082}
11083
11084#[doc(hidden)]
11085impl FromGlib<ffi::GtkSizeGroupMode> for SizeGroupMode {
11086    #[inline]
11087    unsafe fn from_glib(value: ffi::GtkSizeGroupMode) -> Self {
11088        skip_assert_initialized!();
11089
11090        match value {
11091            ffi::GTK_SIZE_GROUP_NONE => Self::None,
11092            ffi::GTK_SIZE_GROUP_HORIZONTAL => Self::Horizontal,
11093            ffi::GTK_SIZE_GROUP_VERTICAL => Self::Vertical,
11094            ffi::GTK_SIZE_GROUP_BOTH => Self::Both,
11095            value => Self::__Unknown(value),
11096        }
11097    }
11098}
11099
11100impl StaticType for SizeGroupMode {
11101    #[inline]
11102    #[doc(alias = "gtk_size_group_mode_get_type")]
11103    fn static_type() -> glib::Type {
11104        unsafe { from_glib(ffi::gtk_size_group_mode_get_type()) }
11105    }
11106}
11107
11108impl glib::HasParamSpec for SizeGroupMode {
11109    type ParamSpec = glib::ParamSpecEnum;
11110    type SetValue = Self;
11111    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
11112
11113    fn param_spec_builder() -> Self::BuilderFn {
11114        Self::ParamSpec::builder_with_default
11115    }
11116}
11117
11118impl glib::value::ValueType for SizeGroupMode {
11119    type Type = Self;
11120}
11121
11122unsafe impl<'a> glib::value::FromValue<'a> for SizeGroupMode {
11123    type Checker = glib::value::GenericValueTypeChecker<Self>;
11124
11125    #[inline]
11126    unsafe fn from_value(value: &'a glib::Value) -> Self {
11127        skip_assert_initialized!();
11128        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
11129    }
11130}
11131
11132impl ToValue for SizeGroupMode {
11133    #[inline]
11134    fn to_value(&self) -> glib::Value {
11135        let mut value = glib::Value::for_value_type::<Self>();
11136        unsafe {
11137            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
11138        }
11139        value
11140    }
11141
11142    #[inline]
11143    fn value_type(&self) -> glib::Type {
11144        Self::static_type()
11145    }
11146}
11147
11148impl From<SizeGroupMode> for glib::Value {
11149    #[inline]
11150    fn from(v: SizeGroupMode) -> Self {
11151        skip_assert_initialized!();
11152        ToValue::to_value(&v)
11153    }
11154}
11155
11156/// Specifies a preference for height-for-width or
11157/// width-for-height geometry management.
11158#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
11159#[non_exhaustive]
11160#[doc(alias = "GtkSizeRequestMode")]
11161pub enum SizeRequestMode {
11162    /// Prefer height-for-width geometry management
11163    #[doc(alias = "GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH")]
11164    HeightForWidth,
11165    /// Prefer width-for-height geometry management
11166    #[doc(alias = "GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT")]
11167    WidthForHeight,
11168    /// Don’t trade height-for-width or width-for-height
11169    #[doc(alias = "GTK_SIZE_REQUEST_CONSTANT_SIZE")]
11170    ConstantSize,
11171    #[doc(hidden)]
11172    __Unknown(i32),
11173}
11174
11175#[doc(hidden)]
11176impl IntoGlib for SizeRequestMode {
11177    type GlibType = ffi::GtkSizeRequestMode;
11178
11179    #[inline]
11180    fn into_glib(self) -> ffi::GtkSizeRequestMode {
11181        match self {
11182            Self::HeightForWidth => ffi::GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH,
11183            Self::WidthForHeight => ffi::GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT,
11184            Self::ConstantSize => ffi::GTK_SIZE_REQUEST_CONSTANT_SIZE,
11185            Self::__Unknown(value) => value,
11186        }
11187    }
11188}
11189
11190#[doc(hidden)]
11191impl FromGlib<ffi::GtkSizeRequestMode> for SizeRequestMode {
11192    #[inline]
11193    unsafe fn from_glib(value: ffi::GtkSizeRequestMode) -> Self {
11194        skip_assert_initialized!();
11195
11196        match value {
11197            ffi::GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH => Self::HeightForWidth,
11198            ffi::GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT => Self::WidthForHeight,
11199            ffi::GTK_SIZE_REQUEST_CONSTANT_SIZE => Self::ConstantSize,
11200            value => Self::__Unknown(value),
11201        }
11202    }
11203}
11204
11205impl StaticType for SizeRequestMode {
11206    #[inline]
11207    #[doc(alias = "gtk_size_request_mode_get_type")]
11208    fn static_type() -> glib::Type {
11209        unsafe { from_glib(ffi::gtk_size_request_mode_get_type()) }
11210    }
11211}
11212
11213impl glib::HasParamSpec for SizeRequestMode {
11214    type ParamSpec = glib::ParamSpecEnum;
11215    type SetValue = Self;
11216    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
11217
11218    fn param_spec_builder() -> Self::BuilderFn {
11219        Self::ParamSpec::builder_with_default
11220    }
11221}
11222
11223impl glib::value::ValueType for SizeRequestMode {
11224    type Type = Self;
11225}
11226
11227unsafe impl<'a> glib::value::FromValue<'a> for SizeRequestMode {
11228    type Checker = glib::value::GenericValueTypeChecker<Self>;
11229
11230    #[inline]
11231    unsafe fn from_value(value: &'a glib::Value) -> Self {
11232        skip_assert_initialized!();
11233        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
11234    }
11235}
11236
11237impl ToValue for SizeRequestMode {
11238    #[inline]
11239    fn to_value(&self) -> glib::Value {
11240        let mut value = glib::Value::for_value_type::<Self>();
11241        unsafe {
11242            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
11243        }
11244        value
11245    }
11246
11247    #[inline]
11248    fn value_type(&self) -> glib::Type {
11249        Self::static_type()
11250    }
11251}
11252
11253impl From<SizeRequestMode> for glib::Value {
11254    #[inline]
11255    fn from(v: SizeRequestMode) -> Self {
11256        skip_assert_initialized!();
11257        ToValue::to_value(&v)
11258    }
11259}
11260
11261/// Determines the direction of a sort.
11262#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
11263#[non_exhaustive]
11264#[doc(alias = "GtkSortType")]
11265pub enum SortType {
11266    /// Sorting is in ascending order.
11267    #[doc(alias = "GTK_SORT_ASCENDING")]
11268    Ascending,
11269    /// Sorting is in descending order.
11270    #[doc(alias = "GTK_SORT_DESCENDING")]
11271    Descending,
11272    #[doc(hidden)]
11273    __Unknown(i32),
11274}
11275
11276#[doc(hidden)]
11277impl IntoGlib for SortType {
11278    type GlibType = ffi::GtkSortType;
11279
11280    #[inline]
11281    fn into_glib(self) -> ffi::GtkSortType {
11282        match self {
11283            Self::Ascending => ffi::GTK_SORT_ASCENDING,
11284            Self::Descending => ffi::GTK_SORT_DESCENDING,
11285            Self::__Unknown(value) => value,
11286        }
11287    }
11288}
11289
11290#[doc(hidden)]
11291impl FromGlib<ffi::GtkSortType> for SortType {
11292    #[inline]
11293    unsafe fn from_glib(value: ffi::GtkSortType) -> Self {
11294        skip_assert_initialized!();
11295
11296        match value {
11297            ffi::GTK_SORT_ASCENDING => Self::Ascending,
11298            ffi::GTK_SORT_DESCENDING => Self::Descending,
11299            value => Self::__Unknown(value),
11300        }
11301    }
11302}
11303
11304impl StaticType for SortType {
11305    #[inline]
11306    #[doc(alias = "gtk_sort_type_get_type")]
11307    fn static_type() -> glib::Type {
11308        unsafe { from_glib(ffi::gtk_sort_type_get_type()) }
11309    }
11310}
11311
11312impl glib::HasParamSpec for SortType {
11313    type ParamSpec = glib::ParamSpecEnum;
11314    type SetValue = Self;
11315    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
11316
11317    fn param_spec_builder() -> Self::BuilderFn {
11318        Self::ParamSpec::builder_with_default
11319    }
11320}
11321
11322impl glib::value::ValueType for SortType {
11323    type Type = Self;
11324}
11325
11326unsafe impl<'a> glib::value::FromValue<'a> for SortType {
11327    type Checker = glib::value::GenericValueTypeChecker<Self>;
11328
11329    #[inline]
11330    unsafe fn from_value(value: &'a glib::Value) -> Self {
11331        skip_assert_initialized!();
11332        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
11333    }
11334}
11335
11336impl ToValue for SortType {
11337    #[inline]
11338    fn to_value(&self) -> glib::Value {
11339        let mut value = glib::Value::for_value_type::<Self>();
11340        unsafe {
11341            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
11342        }
11343        value
11344    }
11345
11346    #[inline]
11347    fn value_type(&self) -> glib::Type {
11348        Self::static_type()
11349    }
11350}
11351
11352impl From<SortType> for glib::Value {
11353    #[inline]
11354    fn from(v: SortType) -> Self {
11355        skip_assert_initialized!();
11356        ToValue::to_value(&v)
11357    }
11358}
11359
11360/// Describes changes in a sorter in more detail and allows users
11361/// to optimize resorting.
11362#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
11363#[non_exhaustive]
11364#[doc(alias = "GtkSorterChange")]
11365pub enum SorterChange {
11366    /// The sorter change cannot be described
11367    ///   by any of the other enumeration values
11368    #[doc(alias = "GTK_SORTER_CHANGE_DIFFERENT")]
11369    Different,
11370    /// The sort order was inverted. Comparisons
11371    ///   that returned [`Ordering::Smaller`][crate::Ordering::Smaller] now return [`Ordering::Larger`][crate::Ordering::Larger]
11372    ///   and vice versa. Other comparisons return the same values as before.
11373    #[doc(alias = "GTK_SORTER_CHANGE_INVERTED")]
11374    Inverted,
11375    /// The sorter is less strict: Comparisons
11376    ///   may now return [`Ordering::Equal`][crate::Ordering::Equal] that did not do so before.
11377    #[doc(alias = "GTK_SORTER_CHANGE_LESS_STRICT")]
11378    LessStrict,
11379    /// The sorter is more strict: Comparisons
11380    ///   that did return [`Ordering::Equal`][crate::Ordering::Equal] may not do so anymore.
11381    #[doc(alias = "GTK_SORTER_CHANGE_MORE_STRICT")]
11382    MoreStrict,
11383    #[doc(hidden)]
11384    __Unknown(i32),
11385}
11386
11387#[doc(hidden)]
11388impl IntoGlib for SorterChange {
11389    type GlibType = ffi::GtkSorterChange;
11390
11391    #[inline]
11392    fn into_glib(self) -> ffi::GtkSorterChange {
11393        match self {
11394            Self::Different => ffi::GTK_SORTER_CHANGE_DIFFERENT,
11395            Self::Inverted => ffi::GTK_SORTER_CHANGE_INVERTED,
11396            Self::LessStrict => ffi::GTK_SORTER_CHANGE_LESS_STRICT,
11397            Self::MoreStrict => ffi::GTK_SORTER_CHANGE_MORE_STRICT,
11398            Self::__Unknown(value) => value,
11399        }
11400    }
11401}
11402
11403#[doc(hidden)]
11404impl FromGlib<ffi::GtkSorterChange> for SorterChange {
11405    #[inline]
11406    unsafe fn from_glib(value: ffi::GtkSorterChange) -> Self {
11407        skip_assert_initialized!();
11408
11409        match value {
11410            ffi::GTK_SORTER_CHANGE_DIFFERENT => Self::Different,
11411            ffi::GTK_SORTER_CHANGE_INVERTED => Self::Inverted,
11412            ffi::GTK_SORTER_CHANGE_LESS_STRICT => Self::LessStrict,
11413            ffi::GTK_SORTER_CHANGE_MORE_STRICT => Self::MoreStrict,
11414            value => Self::__Unknown(value),
11415        }
11416    }
11417}
11418
11419impl StaticType for SorterChange {
11420    #[inline]
11421    #[doc(alias = "gtk_sorter_change_get_type")]
11422    fn static_type() -> glib::Type {
11423        unsafe { from_glib(ffi::gtk_sorter_change_get_type()) }
11424    }
11425}
11426
11427impl glib::HasParamSpec for SorterChange {
11428    type ParamSpec = glib::ParamSpecEnum;
11429    type SetValue = Self;
11430    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
11431
11432    fn param_spec_builder() -> Self::BuilderFn {
11433        Self::ParamSpec::builder_with_default
11434    }
11435}
11436
11437impl glib::value::ValueType for SorterChange {
11438    type Type = Self;
11439}
11440
11441unsafe impl<'a> glib::value::FromValue<'a> for SorterChange {
11442    type Checker = glib::value::GenericValueTypeChecker<Self>;
11443
11444    #[inline]
11445    unsafe fn from_value(value: &'a glib::Value) -> Self {
11446        skip_assert_initialized!();
11447        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
11448    }
11449}
11450
11451impl ToValue for SorterChange {
11452    #[inline]
11453    fn to_value(&self) -> glib::Value {
11454        let mut value = glib::Value::for_value_type::<Self>();
11455        unsafe {
11456            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
11457        }
11458        value
11459    }
11460
11461    #[inline]
11462    fn value_type(&self) -> glib::Type {
11463        Self::static_type()
11464    }
11465}
11466
11467impl From<SorterChange> for glib::Value {
11468    #[inline]
11469    fn from(v: SorterChange) -> Self {
11470        skip_assert_initialized!();
11471        ToValue::to_value(&v)
11472    }
11473}
11474
11475/// Describes the type of order that a [`Sorter`][crate::Sorter] may produce.
11476#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
11477#[non_exhaustive]
11478#[doc(alias = "GtkSorterOrder")]
11479pub enum SorterOrder {
11480    /// A partial order. Any [`Ordering`][crate::Ordering] is possible.
11481    #[doc(alias = "GTK_SORTER_ORDER_PARTIAL")]
11482    Partial,
11483    /// No order, all elements are considered equal.
11484    ///   gtk_sorter_compare() will only return [`Ordering::Equal`][crate::Ordering::Equal].
11485    #[doc(alias = "GTK_SORTER_ORDER_NONE")]
11486    None,
11487    /// A total order. gtk_sorter_compare() will only
11488    ///   return [`Ordering::Equal`][crate::Ordering::Equal] if an item is compared with itself. Two
11489    ///   different items will never cause this value to be returned.
11490    #[doc(alias = "GTK_SORTER_ORDER_TOTAL")]
11491    Total,
11492    #[doc(hidden)]
11493    __Unknown(i32),
11494}
11495
11496#[doc(hidden)]
11497impl IntoGlib for SorterOrder {
11498    type GlibType = ffi::GtkSorterOrder;
11499
11500    #[inline]
11501    fn into_glib(self) -> ffi::GtkSorterOrder {
11502        match self {
11503            Self::Partial => ffi::GTK_SORTER_ORDER_PARTIAL,
11504            Self::None => ffi::GTK_SORTER_ORDER_NONE,
11505            Self::Total => ffi::GTK_SORTER_ORDER_TOTAL,
11506            Self::__Unknown(value) => value,
11507        }
11508    }
11509}
11510
11511#[doc(hidden)]
11512impl FromGlib<ffi::GtkSorterOrder> for SorterOrder {
11513    #[inline]
11514    unsafe fn from_glib(value: ffi::GtkSorterOrder) -> Self {
11515        skip_assert_initialized!();
11516
11517        match value {
11518            ffi::GTK_SORTER_ORDER_PARTIAL => Self::Partial,
11519            ffi::GTK_SORTER_ORDER_NONE => Self::None,
11520            ffi::GTK_SORTER_ORDER_TOTAL => Self::Total,
11521            value => Self::__Unknown(value),
11522        }
11523    }
11524}
11525
11526impl StaticType for SorterOrder {
11527    #[inline]
11528    #[doc(alias = "gtk_sorter_order_get_type")]
11529    fn static_type() -> glib::Type {
11530        unsafe { from_glib(ffi::gtk_sorter_order_get_type()) }
11531    }
11532}
11533
11534impl glib::HasParamSpec for SorterOrder {
11535    type ParamSpec = glib::ParamSpecEnum;
11536    type SetValue = Self;
11537    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
11538
11539    fn param_spec_builder() -> Self::BuilderFn {
11540        Self::ParamSpec::builder_with_default
11541    }
11542}
11543
11544impl glib::value::ValueType for SorterOrder {
11545    type Type = Self;
11546}
11547
11548unsafe impl<'a> glib::value::FromValue<'a> for SorterOrder {
11549    type Checker = glib::value::GenericValueTypeChecker<Self>;
11550
11551    #[inline]
11552    unsafe fn from_value(value: &'a glib::Value) -> Self {
11553        skip_assert_initialized!();
11554        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
11555    }
11556}
11557
11558impl ToValue for SorterOrder {
11559    #[inline]
11560    fn to_value(&self) -> glib::Value {
11561        let mut value = glib::Value::for_value_type::<Self>();
11562        unsafe {
11563            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
11564        }
11565        value
11566    }
11567
11568    #[inline]
11569    fn value_type(&self) -> glib::Type {
11570        Self::static_type()
11571    }
11572}
11573
11574impl From<SorterOrder> for glib::Value {
11575    #[inline]
11576    fn from(v: SorterOrder) -> Self {
11577        skip_assert_initialized!();
11578        ToValue::to_value(&v)
11579    }
11580}
11581
11582/// Determines whether the spin button displays values outside the adjustment
11583/// bounds.
11584///
11585/// See [`SpinButton::set_update_policy()`][crate::SpinButton::set_update_policy()].
11586#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
11587#[non_exhaustive]
11588#[doc(alias = "GtkSpinButtonUpdatePolicy")]
11589pub enum SpinButtonUpdatePolicy {
11590    /// When refreshing your [`SpinButton`][crate::SpinButton], the value is
11591    ///   always displayed
11592    #[doc(alias = "GTK_UPDATE_ALWAYS")]
11593    Always,
11594    /// When refreshing your [`SpinButton`][crate::SpinButton], the value is
11595    ///   only displayed if it is valid within the bounds of the spin button's
11596    ///   adjustment
11597    #[doc(alias = "GTK_UPDATE_IF_VALID")]
11598    IfValid,
11599    #[doc(hidden)]
11600    __Unknown(i32),
11601}
11602
11603#[doc(hidden)]
11604impl IntoGlib for SpinButtonUpdatePolicy {
11605    type GlibType = ffi::GtkSpinButtonUpdatePolicy;
11606
11607    #[inline]
11608    fn into_glib(self) -> ffi::GtkSpinButtonUpdatePolicy {
11609        match self {
11610            Self::Always => ffi::GTK_UPDATE_ALWAYS,
11611            Self::IfValid => ffi::GTK_UPDATE_IF_VALID,
11612            Self::__Unknown(value) => value,
11613        }
11614    }
11615}
11616
11617#[doc(hidden)]
11618impl FromGlib<ffi::GtkSpinButtonUpdatePolicy> for SpinButtonUpdatePolicy {
11619    #[inline]
11620    unsafe fn from_glib(value: ffi::GtkSpinButtonUpdatePolicy) -> Self {
11621        skip_assert_initialized!();
11622
11623        match value {
11624            ffi::GTK_UPDATE_ALWAYS => Self::Always,
11625            ffi::GTK_UPDATE_IF_VALID => Self::IfValid,
11626            value => Self::__Unknown(value),
11627        }
11628    }
11629}
11630
11631impl StaticType for SpinButtonUpdatePolicy {
11632    #[inline]
11633    #[doc(alias = "gtk_spin_button_update_policy_get_type")]
11634    fn static_type() -> glib::Type {
11635        unsafe { from_glib(ffi::gtk_spin_button_update_policy_get_type()) }
11636    }
11637}
11638
11639impl glib::HasParamSpec for SpinButtonUpdatePolicy {
11640    type ParamSpec = glib::ParamSpecEnum;
11641    type SetValue = Self;
11642    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
11643
11644    fn param_spec_builder() -> Self::BuilderFn {
11645        Self::ParamSpec::builder_with_default
11646    }
11647}
11648
11649impl glib::value::ValueType for SpinButtonUpdatePolicy {
11650    type Type = Self;
11651}
11652
11653unsafe impl<'a> glib::value::FromValue<'a> for SpinButtonUpdatePolicy {
11654    type Checker = glib::value::GenericValueTypeChecker<Self>;
11655
11656    #[inline]
11657    unsafe fn from_value(value: &'a glib::Value) -> Self {
11658        skip_assert_initialized!();
11659        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
11660    }
11661}
11662
11663impl ToValue for SpinButtonUpdatePolicy {
11664    #[inline]
11665    fn to_value(&self) -> glib::Value {
11666        let mut value = glib::Value::for_value_type::<Self>();
11667        unsafe {
11668            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
11669        }
11670        value
11671    }
11672
11673    #[inline]
11674    fn value_type(&self) -> glib::Type {
11675        Self::static_type()
11676    }
11677}
11678
11679impl From<SpinButtonUpdatePolicy> for glib::Value {
11680    #[inline]
11681    fn from(v: SpinButtonUpdatePolicy) -> Self {
11682        skip_assert_initialized!();
11683        ToValue::to_value(&v)
11684    }
11685}
11686
11687/// The values of the GtkSpinType enumeration are used to specify the
11688/// change to make in gtk_spin_button_spin().
11689#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
11690#[non_exhaustive]
11691#[doc(alias = "GtkSpinType")]
11692pub enum SpinType {
11693    /// Increment by the adjustments step increment.
11694    #[doc(alias = "GTK_SPIN_STEP_FORWARD")]
11695    StepForward,
11696    /// Decrement by the adjustments step increment.
11697    #[doc(alias = "GTK_SPIN_STEP_BACKWARD")]
11698    StepBackward,
11699    /// Increment by the adjustments page increment.
11700    #[doc(alias = "GTK_SPIN_PAGE_FORWARD")]
11701    PageForward,
11702    /// Decrement by the adjustments page increment.
11703    #[doc(alias = "GTK_SPIN_PAGE_BACKWARD")]
11704    PageBackward,
11705    /// Go to the adjustments lower bound.
11706    #[doc(alias = "GTK_SPIN_HOME")]
11707    Home,
11708    /// Go to the adjustments upper bound.
11709    #[doc(alias = "GTK_SPIN_END")]
11710    End,
11711    /// Change by a specified amount.
11712    #[doc(alias = "GTK_SPIN_USER_DEFINED")]
11713    UserDefined,
11714    #[doc(hidden)]
11715    __Unknown(i32),
11716}
11717
11718#[doc(hidden)]
11719impl IntoGlib for SpinType {
11720    type GlibType = ffi::GtkSpinType;
11721
11722    #[inline]
11723    fn into_glib(self) -> ffi::GtkSpinType {
11724        match self {
11725            Self::StepForward => ffi::GTK_SPIN_STEP_FORWARD,
11726            Self::StepBackward => ffi::GTK_SPIN_STEP_BACKWARD,
11727            Self::PageForward => ffi::GTK_SPIN_PAGE_FORWARD,
11728            Self::PageBackward => ffi::GTK_SPIN_PAGE_BACKWARD,
11729            Self::Home => ffi::GTK_SPIN_HOME,
11730            Self::End => ffi::GTK_SPIN_END,
11731            Self::UserDefined => ffi::GTK_SPIN_USER_DEFINED,
11732            Self::__Unknown(value) => value,
11733        }
11734    }
11735}
11736
11737#[doc(hidden)]
11738impl FromGlib<ffi::GtkSpinType> for SpinType {
11739    #[inline]
11740    unsafe fn from_glib(value: ffi::GtkSpinType) -> Self {
11741        skip_assert_initialized!();
11742
11743        match value {
11744            ffi::GTK_SPIN_STEP_FORWARD => Self::StepForward,
11745            ffi::GTK_SPIN_STEP_BACKWARD => Self::StepBackward,
11746            ffi::GTK_SPIN_PAGE_FORWARD => Self::PageForward,
11747            ffi::GTK_SPIN_PAGE_BACKWARD => Self::PageBackward,
11748            ffi::GTK_SPIN_HOME => Self::Home,
11749            ffi::GTK_SPIN_END => Self::End,
11750            ffi::GTK_SPIN_USER_DEFINED => Self::UserDefined,
11751            value => Self::__Unknown(value),
11752        }
11753    }
11754}
11755
11756impl StaticType for SpinType {
11757    #[inline]
11758    #[doc(alias = "gtk_spin_type_get_type")]
11759    fn static_type() -> glib::Type {
11760        unsafe { from_glib(ffi::gtk_spin_type_get_type()) }
11761    }
11762}
11763
11764impl glib::HasParamSpec for SpinType {
11765    type ParamSpec = glib::ParamSpecEnum;
11766    type SetValue = Self;
11767    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
11768
11769    fn param_spec_builder() -> Self::BuilderFn {
11770        Self::ParamSpec::builder_with_default
11771    }
11772}
11773
11774impl glib::value::ValueType for SpinType {
11775    type Type = Self;
11776}
11777
11778unsafe impl<'a> glib::value::FromValue<'a> for SpinType {
11779    type Checker = glib::value::GenericValueTypeChecker<Self>;
11780
11781    #[inline]
11782    unsafe fn from_value(value: &'a glib::Value) -> Self {
11783        skip_assert_initialized!();
11784        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
11785    }
11786}
11787
11788impl ToValue for SpinType {
11789    #[inline]
11790    fn to_value(&self) -> glib::Value {
11791        let mut value = glib::Value::for_value_type::<Self>();
11792        unsafe {
11793            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
11794        }
11795        value
11796    }
11797
11798    #[inline]
11799    fn value_type(&self) -> glib::Type {
11800        Self::static_type()
11801    }
11802}
11803
11804impl From<SpinType> for glib::Value {
11805    #[inline]
11806    fn from(v: SpinType) -> Self {
11807        skip_assert_initialized!();
11808        ToValue::to_value(&v)
11809    }
11810}
11811
11812/// Possible transitions between pages in a [`Stack`][crate::Stack] widget.
11813///
11814/// New values may be added to this enumeration over time.
11815#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
11816#[non_exhaustive]
11817#[doc(alias = "GtkStackTransitionType")]
11818pub enum StackTransitionType {
11819    /// No transition
11820    #[doc(alias = "GTK_STACK_TRANSITION_TYPE_NONE")]
11821    None,
11822    /// A cross-fade
11823    #[doc(alias = "GTK_STACK_TRANSITION_TYPE_CROSSFADE")]
11824    Crossfade,
11825    /// Slide from left to right
11826    #[doc(alias = "GTK_STACK_TRANSITION_TYPE_SLIDE_RIGHT")]
11827    SlideRight,
11828    /// Slide from right to left
11829    #[doc(alias = "GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT")]
11830    SlideLeft,
11831    /// Slide from bottom up
11832    #[doc(alias = "GTK_STACK_TRANSITION_TYPE_SLIDE_UP")]
11833    SlideUp,
11834    /// Slide from top down
11835    #[doc(alias = "GTK_STACK_TRANSITION_TYPE_SLIDE_DOWN")]
11836    SlideDown,
11837    /// Slide from left or right according to the children order
11838    #[doc(alias = "GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT")]
11839    SlideLeftRight,
11840    /// Slide from top down or bottom up according to the order
11841    #[doc(alias = "GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN")]
11842    SlideUpDown,
11843    /// Cover the old page by sliding up
11844    #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_UP")]
11845    OverUp,
11846    /// Cover the old page by sliding down
11847    #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_DOWN")]
11848    OverDown,
11849    /// Cover the old page by sliding to the left
11850    #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_LEFT")]
11851    OverLeft,
11852    /// Cover the old page by sliding to the right
11853    #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_RIGHT")]
11854    OverRight,
11855    /// Uncover the new page by sliding up
11856    #[doc(alias = "GTK_STACK_TRANSITION_TYPE_UNDER_UP")]
11857    UnderUp,
11858    /// Uncover the new page by sliding down
11859    #[doc(alias = "GTK_STACK_TRANSITION_TYPE_UNDER_DOWN")]
11860    UnderDown,
11861    /// Uncover the new page by sliding to the left
11862    #[doc(alias = "GTK_STACK_TRANSITION_TYPE_UNDER_LEFT")]
11863    UnderLeft,
11864    /// Uncover the new page by sliding to the right
11865    #[doc(alias = "GTK_STACK_TRANSITION_TYPE_UNDER_RIGHT")]
11866    UnderRight,
11867    /// Cover the old page sliding up or uncover the new page sliding down, according to order
11868    #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_UP_DOWN")]
11869    OverUpDown,
11870    /// Cover the old page sliding down or uncover the new page sliding up, according to order
11871    #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_DOWN_UP")]
11872    OverDownUp,
11873    /// Cover the old page sliding left or uncover the new page sliding right, according to order
11874    #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_LEFT_RIGHT")]
11875    OverLeftRight,
11876    /// Cover the old page sliding right or uncover the new page sliding left, according to order
11877    #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_RIGHT_LEFT")]
11878    OverRightLeft,
11879    /// Pretend the pages are sides of a cube and rotate that cube to the left
11880    #[doc(alias = "GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT")]
11881    RotateLeft,
11882    /// Pretend the pages are sides of a cube and rotate that cube to the right
11883    #[doc(alias = "GTK_STACK_TRANSITION_TYPE_ROTATE_RIGHT")]
11884    RotateRight,
11885    /// Pretend the pages are sides of a cube and rotate that cube to the left or right according to the children order
11886    #[doc(alias = "GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT_RIGHT")]
11887    RotateLeftRight,
11888    #[doc(hidden)]
11889    __Unknown(i32),
11890}
11891
11892#[doc(hidden)]
11893impl IntoGlib for StackTransitionType {
11894    type GlibType = ffi::GtkStackTransitionType;
11895
11896    fn into_glib(self) -> ffi::GtkStackTransitionType {
11897        match self {
11898            Self::None => ffi::GTK_STACK_TRANSITION_TYPE_NONE,
11899            Self::Crossfade => ffi::GTK_STACK_TRANSITION_TYPE_CROSSFADE,
11900            Self::SlideRight => ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_RIGHT,
11901            Self::SlideLeft => ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT,
11902            Self::SlideUp => ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_UP,
11903            Self::SlideDown => ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_DOWN,
11904            Self::SlideLeftRight => ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT,
11905            Self::SlideUpDown => ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN,
11906            Self::OverUp => ffi::GTK_STACK_TRANSITION_TYPE_OVER_UP,
11907            Self::OverDown => ffi::GTK_STACK_TRANSITION_TYPE_OVER_DOWN,
11908            Self::OverLeft => ffi::GTK_STACK_TRANSITION_TYPE_OVER_LEFT,
11909            Self::OverRight => ffi::GTK_STACK_TRANSITION_TYPE_OVER_RIGHT,
11910            Self::UnderUp => ffi::GTK_STACK_TRANSITION_TYPE_UNDER_UP,
11911            Self::UnderDown => ffi::GTK_STACK_TRANSITION_TYPE_UNDER_DOWN,
11912            Self::UnderLeft => ffi::GTK_STACK_TRANSITION_TYPE_UNDER_LEFT,
11913            Self::UnderRight => ffi::GTK_STACK_TRANSITION_TYPE_UNDER_RIGHT,
11914            Self::OverUpDown => ffi::GTK_STACK_TRANSITION_TYPE_OVER_UP_DOWN,
11915            Self::OverDownUp => ffi::GTK_STACK_TRANSITION_TYPE_OVER_DOWN_UP,
11916            Self::OverLeftRight => ffi::GTK_STACK_TRANSITION_TYPE_OVER_LEFT_RIGHT,
11917            Self::OverRightLeft => ffi::GTK_STACK_TRANSITION_TYPE_OVER_RIGHT_LEFT,
11918            Self::RotateLeft => ffi::GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT,
11919            Self::RotateRight => ffi::GTK_STACK_TRANSITION_TYPE_ROTATE_RIGHT,
11920            Self::RotateLeftRight => ffi::GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT_RIGHT,
11921            Self::__Unknown(value) => value,
11922        }
11923    }
11924}
11925
11926#[doc(hidden)]
11927impl FromGlib<ffi::GtkStackTransitionType> for StackTransitionType {
11928    unsafe fn from_glib(value: ffi::GtkStackTransitionType) -> Self {
11929        skip_assert_initialized!();
11930
11931        match value {
11932            ffi::GTK_STACK_TRANSITION_TYPE_NONE => Self::None,
11933            ffi::GTK_STACK_TRANSITION_TYPE_CROSSFADE => Self::Crossfade,
11934            ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_RIGHT => Self::SlideRight,
11935            ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT => Self::SlideLeft,
11936            ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_UP => Self::SlideUp,
11937            ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_DOWN => Self::SlideDown,
11938            ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT => Self::SlideLeftRight,
11939            ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN => Self::SlideUpDown,
11940            ffi::GTK_STACK_TRANSITION_TYPE_OVER_UP => Self::OverUp,
11941            ffi::GTK_STACK_TRANSITION_TYPE_OVER_DOWN => Self::OverDown,
11942            ffi::GTK_STACK_TRANSITION_TYPE_OVER_LEFT => Self::OverLeft,
11943            ffi::GTK_STACK_TRANSITION_TYPE_OVER_RIGHT => Self::OverRight,
11944            ffi::GTK_STACK_TRANSITION_TYPE_UNDER_UP => Self::UnderUp,
11945            ffi::GTK_STACK_TRANSITION_TYPE_UNDER_DOWN => Self::UnderDown,
11946            ffi::GTK_STACK_TRANSITION_TYPE_UNDER_LEFT => Self::UnderLeft,
11947            ffi::GTK_STACK_TRANSITION_TYPE_UNDER_RIGHT => Self::UnderRight,
11948            ffi::GTK_STACK_TRANSITION_TYPE_OVER_UP_DOWN => Self::OverUpDown,
11949            ffi::GTK_STACK_TRANSITION_TYPE_OVER_DOWN_UP => Self::OverDownUp,
11950            ffi::GTK_STACK_TRANSITION_TYPE_OVER_LEFT_RIGHT => Self::OverLeftRight,
11951            ffi::GTK_STACK_TRANSITION_TYPE_OVER_RIGHT_LEFT => Self::OverRightLeft,
11952            ffi::GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT => Self::RotateLeft,
11953            ffi::GTK_STACK_TRANSITION_TYPE_ROTATE_RIGHT => Self::RotateRight,
11954            ffi::GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT_RIGHT => Self::RotateLeftRight,
11955            value => Self::__Unknown(value),
11956        }
11957    }
11958}
11959
11960impl StaticType for StackTransitionType {
11961    #[inline]
11962    #[doc(alias = "gtk_stack_transition_type_get_type")]
11963    fn static_type() -> glib::Type {
11964        unsafe { from_glib(ffi::gtk_stack_transition_type_get_type()) }
11965    }
11966}
11967
11968impl glib::HasParamSpec for StackTransitionType {
11969    type ParamSpec = glib::ParamSpecEnum;
11970    type SetValue = Self;
11971    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
11972
11973    fn param_spec_builder() -> Self::BuilderFn {
11974        Self::ParamSpec::builder_with_default
11975    }
11976}
11977
11978impl glib::value::ValueType for StackTransitionType {
11979    type Type = Self;
11980}
11981
11982unsafe impl<'a> glib::value::FromValue<'a> for StackTransitionType {
11983    type Checker = glib::value::GenericValueTypeChecker<Self>;
11984
11985    #[inline]
11986    unsafe fn from_value(value: &'a glib::Value) -> Self {
11987        skip_assert_initialized!();
11988        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
11989    }
11990}
11991
11992impl ToValue for StackTransitionType {
11993    #[inline]
11994    fn to_value(&self) -> glib::Value {
11995        let mut value = glib::Value::for_value_type::<Self>();
11996        unsafe {
11997            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
11998        }
11999        value
12000    }
12001
12002    #[inline]
12003    fn value_type(&self) -> glib::Type {
12004        Self::static_type()
12005    }
12006}
12007
12008impl From<StackTransitionType> for glib::Value {
12009    #[inline]
12010    fn from(v: StackTransitionType) -> Self {
12011        skip_assert_initialized!();
12012        ToValue::to_value(&v)
12013    }
12014}
12015
12016/// Specifies how search strings are matched inside text.
12017#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
12018#[non_exhaustive]
12019#[doc(alias = "GtkStringFilterMatchMode")]
12020pub enum StringFilterMatchMode {
12021    /// The search string and
12022    ///   text must match exactly
12023    #[doc(alias = "GTK_STRING_FILTER_MATCH_MODE_EXACT")]
12024    Exact,
12025    /// The search string
12026    ///   must be contained as a substring inside the text
12027    #[doc(alias = "GTK_STRING_FILTER_MATCH_MODE_SUBSTRING")]
12028    Substring,
12029    /// The text must begin
12030    ///   with the search string
12031    #[doc(alias = "GTK_STRING_FILTER_MATCH_MODE_PREFIX")]
12032    Prefix,
12033    #[doc(hidden)]
12034    __Unknown(i32),
12035}
12036
12037#[doc(hidden)]
12038impl IntoGlib for StringFilterMatchMode {
12039    type GlibType = ffi::GtkStringFilterMatchMode;
12040
12041    #[inline]
12042    fn into_glib(self) -> ffi::GtkStringFilterMatchMode {
12043        match self {
12044            Self::Exact => ffi::GTK_STRING_FILTER_MATCH_MODE_EXACT,
12045            Self::Substring => ffi::GTK_STRING_FILTER_MATCH_MODE_SUBSTRING,
12046            Self::Prefix => ffi::GTK_STRING_FILTER_MATCH_MODE_PREFIX,
12047            Self::__Unknown(value) => value,
12048        }
12049    }
12050}
12051
12052#[doc(hidden)]
12053impl FromGlib<ffi::GtkStringFilterMatchMode> for StringFilterMatchMode {
12054    #[inline]
12055    unsafe fn from_glib(value: ffi::GtkStringFilterMatchMode) -> Self {
12056        skip_assert_initialized!();
12057
12058        match value {
12059            ffi::GTK_STRING_FILTER_MATCH_MODE_EXACT => Self::Exact,
12060            ffi::GTK_STRING_FILTER_MATCH_MODE_SUBSTRING => Self::Substring,
12061            ffi::GTK_STRING_FILTER_MATCH_MODE_PREFIX => Self::Prefix,
12062            value => Self::__Unknown(value),
12063        }
12064    }
12065}
12066
12067impl StaticType for StringFilterMatchMode {
12068    #[inline]
12069    #[doc(alias = "gtk_string_filter_match_mode_get_type")]
12070    fn static_type() -> glib::Type {
12071        unsafe { from_glib(ffi::gtk_string_filter_match_mode_get_type()) }
12072    }
12073}
12074
12075impl glib::HasParamSpec for StringFilterMatchMode {
12076    type ParamSpec = glib::ParamSpecEnum;
12077    type SetValue = Self;
12078    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
12079
12080    fn param_spec_builder() -> Self::BuilderFn {
12081        Self::ParamSpec::builder_with_default
12082    }
12083}
12084
12085impl glib::value::ValueType for StringFilterMatchMode {
12086    type Type = Self;
12087}
12088
12089unsafe impl<'a> glib::value::FromValue<'a> for StringFilterMatchMode {
12090    type Checker = glib::value::GenericValueTypeChecker<Self>;
12091
12092    #[inline]
12093    unsafe fn from_value(value: &'a glib::Value) -> Self {
12094        skip_assert_initialized!();
12095        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
12096    }
12097}
12098
12099impl ToValue for StringFilterMatchMode {
12100    #[inline]
12101    fn to_value(&self) -> glib::Value {
12102        let mut value = glib::Value::for_value_type::<Self>();
12103        unsafe {
12104            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
12105        }
12106        value
12107    }
12108
12109    #[inline]
12110    fn value_type(&self) -> glib::Type {
12111        Self::static_type()
12112    }
12113}
12114
12115impl From<StringFilterMatchMode> for glib::Value {
12116    #[inline]
12117    fn from(v: StringFilterMatchMode) -> Self {
12118        skip_assert_initialized!();
12119        ToValue::to_value(&v)
12120    }
12121}
12122
12123/// The indexes of colors passed to symbolic color rendering, such as
12124/// `vfunc::Gtk::SymbolicPaintable::snapshot_symbolic`.
12125///
12126/// More values may be added over time.
12127#[cfg(feature = "v4_6")]
12128#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
12129#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
12130#[non_exhaustive]
12131#[doc(alias = "GtkSymbolicColor")]
12132pub enum SymbolicColor {
12133    /// The default foreground color
12134    #[doc(alias = "GTK_SYMBOLIC_COLOR_FOREGROUND")]
12135    Foreground,
12136    /// Indication color for errors
12137    #[doc(alias = "GTK_SYMBOLIC_COLOR_ERROR")]
12138    Error,
12139    /// Indication color for warnings
12140    #[doc(alias = "GTK_SYMBOLIC_COLOR_WARNING")]
12141    Warning,
12142    /// Indication color for success
12143    #[doc(alias = "GTK_SYMBOLIC_COLOR_SUCCESS")]
12144    Success,
12145    #[doc(hidden)]
12146    __Unknown(i32),
12147}
12148
12149#[cfg(feature = "v4_6")]
12150#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
12151#[doc(hidden)]
12152impl IntoGlib for SymbolicColor {
12153    type GlibType = ffi::GtkSymbolicColor;
12154
12155    #[inline]
12156    fn into_glib(self) -> ffi::GtkSymbolicColor {
12157        match self {
12158            Self::Foreground => ffi::GTK_SYMBOLIC_COLOR_FOREGROUND,
12159            Self::Error => ffi::GTK_SYMBOLIC_COLOR_ERROR,
12160            Self::Warning => ffi::GTK_SYMBOLIC_COLOR_WARNING,
12161            Self::Success => ffi::GTK_SYMBOLIC_COLOR_SUCCESS,
12162            Self::__Unknown(value) => value,
12163        }
12164    }
12165}
12166
12167#[cfg(feature = "v4_6")]
12168#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
12169#[doc(hidden)]
12170impl FromGlib<ffi::GtkSymbolicColor> for SymbolicColor {
12171    #[inline]
12172    unsafe fn from_glib(value: ffi::GtkSymbolicColor) -> Self {
12173        skip_assert_initialized!();
12174
12175        match value {
12176            ffi::GTK_SYMBOLIC_COLOR_FOREGROUND => Self::Foreground,
12177            ffi::GTK_SYMBOLIC_COLOR_ERROR => Self::Error,
12178            ffi::GTK_SYMBOLIC_COLOR_WARNING => Self::Warning,
12179            ffi::GTK_SYMBOLIC_COLOR_SUCCESS => Self::Success,
12180            value => Self::__Unknown(value),
12181        }
12182    }
12183}
12184
12185#[cfg(feature = "v4_6")]
12186#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
12187impl StaticType for SymbolicColor {
12188    #[inline]
12189    #[doc(alias = "gtk_symbolic_color_get_type")]
12190    fn static_type() -> glib::Type {
12191        unsafe { from_glib(ffi::gtk_symbolic_color_get_type()) }
12192    }
12193}
12194
12195#[cfg(feature = "v4_6")]
12196#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
12197impl glib::HasParamSpec for SymbolicColor {
12198    type ParamSpec = glib::ParamSpecEnum;
12199    type SetValue = Self;
12200    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
12201
12202    fn param_spec_builder() -> Self::BuilderFn {
12203        Self::ParamSpec::builder_with_default
12204    }
12205}
12206
12207#[cfg(feature = "v4_6")]
12208#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
12209impl glib::value::ValueType for SymbolicColor {
12210    type Type = Self;
12211}
12212
12213#[cfg(feature = "v4_6")]
12214#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
12215unsafe impl<'a> glib::value::FromValue<'a> for SymbolicColor {
12216    type Checker = glib::value::GenericValueTypeChecker<Self>;
12217
12218    #[inline]
12219    unsafe fn from_value(value: &'a glib::Value) -> Self {
12220        skip_assert_initialized!();
12221        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
12222    }
12223}
12224
12225#[cfg(feature = "v4_6")]
12226#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
12227impl ToValue for SymbolicColor {
12228    #[inline]
12229    fn to_value(&self) -> glib::Value {
12230        let mut value = glib::Value::for_value_type::<Self>();
12231        unsafe {
12232            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
12233        }
12234        value
12235    }
12236
12237    #[inline]
12238    fn value_type(&self) -> glib::Type {
12239        Self::static_type()
12240    }
12241}
12242
12243#[cfg(feature = "v4_6")]
12244#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
12245impl From<SymbolicColor> for glib::Value {
12246    #[inline]
12247    fn from(v: SymbolicColor) -> Self {
12248        skip_assert_initialized!();
12249        ToValue::to_value(&v)
12250    }
12251}
12252
12253/// Values that can be passed to the [`WidgetImpl::system_setting_changed()`][crate::subclass::prelude::WidgetImpl::system_setting_changed()]
12254/// vfunc.
12255///
12256/// The values indicate which system setting has changed.
12257/// Widgets may need to drop caches, or react otherwise.
12258///
12259/// Most of the values correspond to [`Settings`][crate::Settings] properties.
12260///
12261/// More values may be added over time.
12262#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
12263#[non_exhaustive]
12264#[doc(alias = "GtkSystemSetting")]
12265pub enum SystemSetting {
12266    /// the [`gtk-xft-dpi`][struct@crate::Settings#gtk-xft-dpi] setting has changed
12267    #[doc(alias = "GTK_SYSTEM_SETTING_DPI")]
12268    Dpi,
12269    /// The [`gtk-font-name`][struct@crate::Settings#gtk-font-name] setting has changed
12270    #[doc(alias = "GTK_SYSTEM_SETTING_FONT_NAME")]
12271    FontName,
12272    /// The font configuration has changed in a way that
12273    ///   requires text to be redrawn. This can be any of the
12274    ///   [`gtk-xft-antialias`][struct@crate::Settings#gtk-xft-antialias],
12275    ///   [`gtk-xft-hinting`][struct@crate::Settings#gtk-xft-hinting],
12276    ///   [`gtk-xft-hintstyle`][struct@crate::Settings#gtk-xft-hintstyle],
12277    ///   [`gtk-xft-rgba`][struct@crate::Settings#gtk-xft-rgba] or
12278    ///   [`gtk-fontconfig-timestamp`][struct@crate::Settings#gtk-fontconfig-timestamp] settings
12279    #[doc(alias = "GTK_SYSTEM_SETTING_FONT_CONFIG")]
12280    FontConfig,
12281    /// The display has changed
12282    #[doc(alias = "GTK_SYSTEM_SETTING_DISPLAY")]
12283    Display,
12284    /// The icon theme has changed in a way that requires
12285    ///   icons to be looked up again
12286    #[doc(alias = "GTK_SYSTEM_SETTING_ICON_THEME")]
12287    IconTheme,
12288    #[doc(hidden)]
12289    __Unknown(i32),
12290}
12291
12292#[doc(hidden)]
12293impl IntoGlib for SystemSetting {
12294    type GlibType = ffi::GtkSystemSetting;
12295
12296    #[inline]
12297    fn into_glib(self) -> ffi::GtkSystemSetting {
12298        match self {
12299            Self::Dpi => ffi::GTK_SYSTEM_SETTING_DPI,
12300            Self::FontName => ffi::GTK_SYSTEM_SETTING_FONT_NAME,
12301            Self::FontConfig => ffi::GTK_SYSTEM_SETTING_FONT_CONFIG,
12302            Self::Display => ffi::GTK_SYSTEM_SETTING_DISPLAY,
12303            Self::IconTheme => ffi::GTK_SYSTEM_SETTING_ICON_THEME,
12304            Self::__Unknown(value) => value,
12305        }
12306    }
12307}
12308
12309#[doc(hidden)]
12310impl FromGlib<ffi::GtkSystemSetting> for SystemSetting {
12311    #[inline]
12312    unsafe fn from_glib(value: ffi::GtkSystemSetting) -> Self {
12313        skip_assert_initialized!();
12314
12315        match value {
12316            ffi::GTK_SYSTEM_SETTING_DPI => Self::Dpi,
12317            ffi::GTK_SYSTEM_SETTING_FONT_NAME => Self::FontName,
12318            ffi::GTK_SYSTEM_SETTING_FONT_CONFIG => Self::FontConfig,
12319            ffi::GTK_SYSTEM_SETTING_DISPLAY => Self::Display,
12320            ffi::GTK_SYSTEM_SETTING_ICON_THEME => Self::IconTheme,
12321            value => Self::__Unknown(value),
12322        }
12323    }
12324}
12325
12326impl StaticType for SystemSetting {
12327    #[inline]
12328    #[doc(alias = "gtk_system_setting_get_type")]
12329    fn static_type() -> glib::Type {
12330        unsafe { from_glib(ffi::gtk_system_setting_get_type()) }
12331    }
12332}
12333
12334impl glib::HasParamSpec for SystemSetting {
12335    type ParamSpec = glib::ParamSpecEnum;
12336    type SetValue = Self;
12337    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
12338
12339    fn param_spec_builder() -> Self::BuilderFn {
12340        Self::ParamSpec::builder_with_default
12341    }
12342}
12343
12344impl glib::value::ValueType for SystemSetting {
12345    type Type = Self;
12346}
12347
12348unsafe impl<'a> glib::value::FromValue<'a> for SystemSetting {
12349    type Checker = glib::value::GenericValueTypeChecker<Self>;
12350
12351    #[inline]
12352    unsafe fn from_value(value: &'a glib::Value) -> Self {
12353        skip_assert_initialized!();
12354        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
12355    }
12356}
12357
12358impl ToValue for SystemSetting {
12359    #[inline]
12360    fn to_value(&self) -> glib::Value {
12361        let mut value = glib::Value::for_value_type::<Self>();
12362        unsafe {
12363            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
12364        }
12365        value
12366    }
12367
12368    #[inline]
12369    fn value_type(&self) -> glib::Type {
12370        Self::static_type()
12371    }
12372}
12373
12374impl From<SystemSetting> for glib::Value {
12375    #[inline]
12376    fn from(v: SystemSetting) -> Self {
12377        skip_assert_initialized!();
12378        ToValue::to_value(&v)
12379    }
12380}
12381
12382/// Reading directions for text.
12383#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
12384#[non_exhaustive]
12385#[doc(alias = "GtkTextDirection")]
12386pub enum TextDirection {
12387    /// No direction.
12388    #[doc(alias = "GTK_TEXT_DIR_NONE")]
12389    None,
12390    /// Left to right text direction.
12391    #[doc(alias = "GTK_TEXT_DIR_LTR")]
12392    Ltr,
12393    /// Right to left text direction.
12394    #[doc(alias = "GTK_TEXT_DIR_RTL")]
12395    Rtl,
12396    #[doc(hidden)]
12397    __Unknown(i32),
12398}
12399
12400#[doc(hidden)]
12401impl IntoGlib for TextDirection {
12402    type GlibType = ffi::GtkTextDirection;
12403
12404    #[inline]
12405    fn into_glib(self) -> ffi::GtkTextDirection {
12406        match self {
12407            Self::None => ffi::GTK_TEXT_DIR_NONE,
12408            Self::Ltr => ffi::GTK_TEXT_DIR_LTR,
12409            Self::Rtl => ffi::GTK_TEXT_DIR_RTL,
12410            Self::__Unknown(value) => value,
12411        }
12412    }
12413}
12414
12415#[doc(hidden)]
12416impl FromGlib<ffi::GtkTextDirection> for TextDirection {
12417    #[inline]
12418    unsafe fn from_glib(value: ffi::GtkTextDirection) -> Self {
12419        skip_assert_initialized!();
12420
12421        match value {
12422            ffi::GTK_TEXT_DIR_NONE => Self::None,
12423            ffi::GTK_TEXT_DIR_LTR => Self::Ltr,
12424            ffi::GTK_TEXT_DIR_RTL => Self::Rtl,
12425            value => Self::__Unknown(value),
12426        }
12427    }
12428}
12429
12430impl StaticType for TextDirection {
12431    #[inline]
12432    #[doc(alias = "gtk_text_direction_get_type")]
12433    fn static_type() -> glib::Type {
12434        unsafe { from_glib(ffi::gtk_text_direction_get_type()) }
12435    }
12436}
12437
12438impl glib::HasParamSpec for TextDirection {
12439    type ParamSpec = glib::ParamSpecEnum;
12440    type SetValue = Self;
12441    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
12442
12443    fn param_spec_builder() -> Self::BuilderFn {
12444        Self::ParamSpec::builder_with_default
12445    }
12446}
12447
12448impl glib::value::ValueType for TextDirection {
12449    type Type = Self;
12450}
12451
12452unsafe impl<'a> glib::value::FromValue<'a> for TextDirection {
12453    type Checker = glib::value::GenericValueTypeChecker<Self>;
12454
12455    #[inline]
12456    unsafe fn from_value(value: &'a glib::Value) -> Self {
12457        skip_assert_initialized!();
12458        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
12459    }
12460}
12461
12462impl ToValue for TextDirection {
12463    #[inline]
12464    fn to_value(&self) -> glib::Value {
12465        let mut value = glib::Value::for_value_type::<Self>();
12466        unsafe {
12467            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
12468        }
12469        value
12470    }
12471
12472    #[inline]
12473    fn value_type(&self) -> glib::Type {
12474        Self::static_type()
12475    }
12476}
12477
12478impl From<TextDirection> for glib::Value {
12479    #[inline]
12480    fn from(v: TextDirection) -> Self {
12481        skip_assert_initialized!();
12482        ToValue::to_value(&v)
12483    }
12484}
12485
12486/// Granularity types that extend the text selection. Use the
12487/// `GtkTextView::extend-selection` signal to customize the selection.
12488#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
12489#[non_exhaustive]
12490#[doc(alias = "GtkTextExtendSelection")]
12491pub enum TextExtendSelection {
12492    /// Selects the current word. It is triggered by
12493    ///   a double-click for example.
12494    #[doc(alias = "GTK_TEXT_EXTEND_SELECTION_WORD")]
12495    Word,
12496    /// Selects the current line. It is triggered by
12497    ///   a triple-click for example.
12498    #[doc(alias = "GTK_TEXT_EXTEND_SELECTION_LINE")]
12499    Line,
12500    #[doc(hidden)]
12501    __Unknown(i32),
12502}
12503
12504#[doc(hidden)]
12505impl IntoGlib for TextExtendSelection {
12506    type GlibType = ffi::GtkTextExtendSelection;
12507
12508    #[inline]
12509    fn into_glib(self) -> ffi::GtkTextExtendSelection {
12510        match self {
12511            Self::Word => ffi::GTK_TEXT_EXTEND_SELECTION_WORD,
12512            Self::Line => ffi::GTK_TEXT_EXTEND_SELECTION_LINE,
12513            Self::__Unknown(value) => value,
12514        }
12515    }
12516}
12517
12518#[doc(hidden)]
12519impl FromGlib<ffi::GtkTextExtendSelection> for TextExtendSelection {
12520    #[inline]
12521    unsafe fn from_glib(value: ffi::GtkTextExtendSelection) -> Self {
12522        skip_assert_initialized!();
12523
12524        match value {
12525            ffi::GTK_TEXT_EXTEND_SELECTION_WORD => Self::Word,
12526            ffi::GTK_TEXT_EXTEND_SELECTION_LINE => Self::Line,
12527            value => Self::__Unknown(value),
12528        }
12529    }
12530}
12531
12532impl StaticType for TextExtendSelection {
12533    #[inline]
12534    #[doc(alias = "gtk_text_extend_selection_get_type")]
12535    fn static_type() -> glib::Type {
12536        unsafe { from_glib(ffi::gtk_text_extend_selection_get_type()) }
12537    }
12538}
12539
12540impl glib::HasParamSpec for TextExtendSelection {
12541    type ParamSpec = glib::ParamSpecEnum;
12542    type SetValue = Self;
12543    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
12544
12545    fn param_spec_builder() -> Self::BuilderFn {
12546        Self::ParamSpec::builder_with_default
12547    }
12548}
12549
12550impl glib::value::ValueType for TextExtendSelection {
12551    type Type = Self;
12552}
12553
12554unsafe impl<'a> glib::value::FromValue<'a> for TextExtendSelection {
12555    type Checker = glib::value::GenericValueTypeChecker<Self>;
12556
12557    #[inline]
12558    unsafe fn from_value(value: &'a glib::Value) -> Self {
12559        skip_assert_initialized!();
12560        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
12561    }
12562}
12563
12564impl ToValue for TextExtendSelection {
12565    #[inline]
12566    fn to_value(&self) -> glib::Value {
12567        let mut value = glib::Value::for_value_type::<Self>();
12568        unsafe {
12569            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
12570        }
12571        value
12572    }
12573
12574    #[inline]
12575    fn value_type(&self) -> glib::Type {
12576        Self::static_type()
12577    }
12578}
12579
12580impl From<TextExtendSelection> for glib::Value {
12581    #[inline]
12582    fn from(v: TextExtendSelection) -> Self {
12583        skip_assert_initialized!();
12584        ToValue::to_value(&v)
12585    }
12586}
12587
12588/// Used to reference the layers of [`TextView`][crate::TextView] for the purpose of customized
12589/// drawing with the ::snapshot_layer vfunc.
12590#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
12591#[non_exhaustive]
12592#[doc(alias = "GtkTextViewLayer")]
12593pub enum TextViewLayer {
12594    /// The layer rendered below the text (but above the background).
12595    #[doc(alias = "GTK_TEXT_VIEW_LAYER_BELOW_TEXT")]
12596    BelowText,
12597    /// The layer rendered above the text.
12598    #[doc(alias = "GTK_TEXT_VIEW_LAYER_ABOVE_TEXT")]
12599    AboveText,
12600    #[doc(hidden)]
12601    __Unknown(i32),
12602}
12603
12604#[doc(hidden)]
12605impl IntoGlib for TextViewLayer {
12606    type GlibType = ffi::GtkTextViewLayer;
12607
12608    #[inline]
12609    fn into_glib(self) -> ffi::GtkTextViewLayer {
12610        match self {
12611            Self::BelowText => ffi::GTK_TEXT_VIEW_LAYER_BELOW_TEXT,
12612            Self::AboveText => ffi::GTK_TEXT_VIEW_LAYER_ABOVE_TEXT,
12613            Self::__Unknown(value) => value,
12614        }
12615    }
12616}
12617
12618#[doc(hidden)]
12619impl FromGlib<ffi::GtkTextViewLayer> for TextViewLayer {
12620    #[inline]
12621    unsafe fn from_glib(value: ffi::GtkTextViewLayer) -> Self {
12622        skip_assert_initialized!();
12623
12624        match value {
12625            ffi::GTK_TEXT_VIEW_LAYER_BELOW_TEXT => Self::BelowText,
12626            ffi::GTK_TEXT_VIEW_LAYER_ABOVE_TEXT => Self::AboveText,
12627            value => Self::__Unknown(value),
12628        }
12629    }
12630}
12631
12632impl StaticType for TextViewLayer {
12633    #[inline]
12634    #[doc(alias = "gtk_text_view_layer_get_type")]
12635    fn static_type() -> glib::Type {
12636        unsafe { from_glib(ffi::gtk_text_view_layer_get_type()) }
12637    }
12638}
12639
12640impl glib::HasParamSpec for TextViewLayer {
12641    type ParamSpec = glib::ParamSpecEnum;
12642    type SetValue = Self;
12643    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
12644
12645    fn param_spec_builder() -> Self::BuilderFn {
12646        Self::ParamSpec::builder_with_default
12647    }
12648}
12649
12650impl glib::value::ValueType for TextViewLayer {
12651    type Type = Self;
12652}
12653
12654unsafe impl<'a> glib::value::FromValue<'a> for TextViewLayer {
12655    type Checker = glib::value::GenericValueTypeChecker<Self>;
12656
12657    #[inline]
12658    unsafe fn from_value(value: &'a glib::Value) -> Self {
12659        skip_assert_initialized!();
12660        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
12661    }
12662}
12663
12664impl ToValue for TextViewLayer {
12665    #[inline]
12666    fn to_value(&self) -> glib::Value {
12667        let mut value = glib::Value::for_value_type::<Self>();
12668        unsafe {
12669            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
12670        }
12671        value
12672    }
12673
12674    #[inline]
12675    fn value_type(&self) -> glib::Type {
12676        Self::static_type()
12677    }
12678}
12679
12680impl From<TextViewLayer> for glib::Value {
12681    #[inline]
12682    fn from(v: TextViewLayer) -> Self {
12683        skip_assert_initialized!();
12684        ToValue::to_value(&v)
12685    }
12686}
12687
12688/// Used to reference the parts of [`TextView`][crate::TextView].
12689#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
12690#[non_exhaustive]
12691#[doc(alias = "GtkTextWindowType")]
12692pub enum TextWindowType {
12693    /// Window that floats over scrolling areas.
12694    #[doc(alias = "GTK_TEXT_WINDOW_WIDGET")]
12695    Widget,
12696    /// Scrollable text window.
12697    #[doc(alias = "GTK_TEXT_WINDOW_TEXT")]
12698    Text,
12699    /// Left side border window.
12700    #[doc(alias = "GTK_TEXT_WINDOW_LEFT")]
12701    Left,
12702    /// Right side border window.
12703    #[doc(alias = "GTK_TEXT_WINDOW_RIGHT")]
12704    Right,
12705    /// Top border window.
12706    #[doc(alias = "GTK_TEXT_WINDOW_TOP")]
12707    Top,
12708    /// Bottom border window.
12709    #[doc(alias = "GTK_TEXT_WINDOW_BOTTOM")]
12710    Bottom,
12711    #[doc(hidden)]
12712    __Unknown(i32),
12713}
12714
12715#[doc(hidden)]
12716impl IntoGlib for TextWindowType {
12717    type GlibType = ffi::GtkTextWindowType;
12718
12719    #[inline]
12720    fn into_glib(self) -> ffi::GtkTextWindowType {
12721        match self {
12722            Self::Widget => ffi::GTK_TEXT_WINDOW_WIDGET,
12723            Self::Text => ffi::GTK_TEXT_WINDOW_TEXT,
12724            Self::Left => ffi::GTK_TEXT_WINDOW_LEFT,
12725            Self::Right => ffi::GTK_TEXT_WINDOW_RIGHT,
12726            Self::Top => ffi::GTK_TEXT_WINDOW_TOP,
12727            Self::Bottom => ffi::GTK_TEXT_WINDOW_BOTTOM,
12728            Self::__Unknown(value) => value,
12729        }
12730    }
12731}
12732
12733#[doc(hidden)]
12734impl FromGlib<ffi::GtkTextWindowType> for TextWindowType {
12735    #[inline]
12736    unsafe fn from_glib(value: ffi::GtkTextWindowType) -> Self {
12737        skip_assert_initialized!();
12738
12739        match value {
12740            ffi::GTK_TEXT_WINDOW_WIDGET => Self::Widget,
12741            ffi::GTK_TEXT_WINDOW_TEXT => Self::Text,
12742            ffi::GTK_TEXT_WINDOW_LEFT => Self::Left,
12743            ffi::GTK_TEXT_WINDOW_RIGHT => Self::Right,
12744            ffi::GTK_TEXT_WINDOW_TOP => Self::Top,
12745            ffi::GTK_TEXT_WINDOW_BOTTOM => Self::Bottom,
12746            value => Self::__Unknown(value),
12747        }
12748    }
12749}
12750
12751impl StaticType for TextWindowType {
12752    #[inline]
12753    #[doc(alias = "gtk_text_window_type_get_type")]
12754    fn static_type() -> glib::Type {
12755        unsafe { from_glib(ffi::gtk_text_window_type_get_type()) }
12756    }
12757}
12758
12759impl glib::HasParamSpec for TextWindowType {
12760    type ParamSpec = glib::ParamSpecEnum;
12761    type SetValue = Self;
12762    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
12763
12764    fn param_spec_builder() -> Self::BuilderFn {
12765        Self::ParamSpec::builder_with_default
12766    }
12767}
12768
12769impl glib::value::ValueType for TextWindowType {
12770    type Type = Self;
12771}
12772
12773unsafe impl<'a> glib::value::FromValue<'a> for TextWindowType {
12774    type Checker = glib::value::GenericValueTypeChecker<Self>;
12775
12776    #[inline]
12777    unsafe fn from_value(value: &'a glib::Value) -> Self {
12778        skip_assert_initialized!();
12779        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
12780    }
12781}
12782
12783impl ToValue for TextWindowType {
12784    #[inline]
12785    fn to_value(&self) -> glib::Value {
12786        let mut value = glib::Value::for_value_type::<Self>();
12787        unsafe {
12788            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
12789        }
12790        value
12791    }
12792
12793    #[inline]
12794    fn value_type(&self) -> glib::Type {
12795        Self::static_type()
12796    }
12797}
12798
12799impl From<TextWindowType> for glib::Value {
12800    #[inline]
12801    fn from(v: TextWindowType) -> Self {
12802        skip_assert_initialized!();
12803        ToValue::to_value(&v)
12804    }
12805}
12806
12807/// The sizing method the column uses to determine its width.  Please note
12808/// that [`Autosize`][Self::Autosize] are inefficient for large views, and
12809/// can make columns appear choppy.
12810#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
12811#[non_exhaustive]
12812#[doc(alias = "GtkTreeViewColumnSizing")]
12813pub enum TreeViewColumnSizing {
12814    /// Columns only get bigger in reaction to changes in the model
12815    #[doc(alias = "GTK_TREE_VIEW_COLUMN_GROW_ONLY")]
12816    GrowOnly,
12817    /// Columns resize to be the optimal size every time the model changes.
12818    #[doc(alias = "GTK_TREE_VIEW_COLUMN_AUTOSIZE")]
12819    Autosize,
12820    /// Columns are a fixed numbers of pixels wide.
12821    #[doc(alias = "GTK_TREE_VIEW_COLUMN_FIXED")]
12822    Fixed,
12823    #[doc(hidden)]
12824    __Unknown(i32),
12825}
12826
12827#[doc(hidden)]
12828impl IntoGlib for TreeViewColumnSizing {
12829    type GlibType = ffi::GtkTreeViewColumnSizing;
12830
12831    #[inline]
12832    fn into_glib(self) -> ffi::GtkTreeViewColumnSizing {
12833        match self {
12834            Self::GrowOnly => ffi::GTK_TREE_VIEW_COLUMN_GROW_ONLY,
12835            Self::Autosize => ffi::GTK_TREE_VIEW_COLUMN_AUTOSIZE,
12836            Self::Fixed => ffi::GTK_TREE_VIEW_COLUMN_FIXED,
12837            Self::__Unknown(value) => value,
12838        }
12839    }
12840}
12841
12842#[doc(hidden)]
12843impl FromGlib<ffi::GtkTreeViewColumnSizing> for TreeViewColumnSizing {
12844    #[inline]
12845    unsafe fn from_glib(value: ffi::GtkTreeViewColumnSizing) -> Self {
12846        skip_assert_initialized!();
12847
12848        match value {
12849            ffi::GTK_TREE_VIEW_COLUMN_GROW_ONLY => Self::GrowOnly,
12850            ffi::GTK_TREE_VIEW_COLUMN_AUTOSIZE => Self::Autosize,
12851            ffi::GTK_TREE_VIEW_COLUMN_FIXED => Self::Fixed,
12852            value => Self::__Unknown(value),
12853        }
12854    }
12855}
12856
12857impl StaticType for TreeViewColumnSizing {
12858    #[inline]
12859    #[doc(alias = "gtk_tree_view_column_sizing_get_type")]
12860    fn static_type() -> glib::Type {
12861        unsafe { from_glib(ffi::gtk_tree_view_column_sizing_get_type()) }
12862    }
12863}
12864
12865impl glib::HasParamSpec for TreeViewColumnSizing {
12866    type ParamSpec = glib::ParamSpecEnum;
12867    type SetValue = Self;
12868    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
12869
12870    fn param_spec_builder() -> Self::BuilderFn {
12871        Self::ParamSpec::builder_with_default
12872    }
12873}
12874
12875impl glib::value::ValueType for TreeViewColumnSizing {
12876    type Type = Self;
12877}
12878
12879unsafe impl<'a> glib::value::FromValue<'a> for TreeViewColumnSizing {
12880    type Checker = glib::value::GenericValueTypeChecker<Self>;
12881
12882    #[inline]
12883    unsafe fn from_value(value: &'a glib::Value) -> Self {
12884        skip_assert_initialized!();
12885        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
12886    }
12887}
12888
12889impl ToValue for TreeViewColumnSizing {
12890    #[inline]
12891    fn to_value(&self) -> glib::Value {
12892        let mut value = glib::Value::for_value_type::<Self>();
12893        unsafe {
12894            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
12895        }
12896        value
12897    }
12898
12899    #[inline]
12900    fn value_type(&self) -> glib::Type {
12901        Self::static_type()
12902    }
12903}
12904
12905impl From<TreeViewColumnSizing> for glib::Value {
12906    #[inline]
12907    fn from(v: TreeViewColumnSizing) -> Self {
12908        skip_assert_initialized!();
12909        ToValue::to_value(&v)
12910    }
12911}
12912
12913/// An enum for determining where a dropped row goes.
12914#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
12915#[non_exhaustive]
12916#[doc(alias = "GtkTreeViewDropPosition")]
12917pub enum TreeViewDropPosition {
12918    /// dropped row is inserted before
12919    #[doc(alias = "GTK_TREE_VIEW_DROP_BEFORE")]
12920    Before,
12921    /// dropped row is inserted after
12922    #[doc(alias = "GTK_TREE_VIEW_DROP_AFTER")]
12923    After,
12924    /// dropped row becomes a child or is inserted before
12925    #[doc(alias = "GTK_TREE_VIEW_DROP_INTO_OR_BEFORE")]
12926    IntoOrBefore,
12927    /// dropped row becomes a child or is inserted after
12928    #[doc(alias = "GTK_TREE_VIEW_DROP_INTO_OR_AFTER")]
12929    IntoOrAfter,
12930    #[doc(hidden)]
12931    __Unknown(i32),
12932}
12933
12934#[doc(hidden)]
12935impl IntoGlib for TreeViewDropPosition {
12936    type GlibType = ffi::GtkTreeViewDropPosition;
12937
12938    #[inline]
12939    fn into_glib(self) -> ffi::GtkTreeViewDropPosition {
12940        match self {
12941            Self::Before => ffi::GTK_TREE_VIEW_DROP_BEFORE,
12942            Self::After => ffi::GTK_TREE_VIEW_DROP_AFTER,
12943            Self::IntoOrBefore => ffi::GTK_TREE_VIEW_DROP_INTO_OR_BEFORE,
12944            Self::IntoOrAfter => ffi::GTK_TREE_VIEW_DROP_INTO_OR_AFTER,
12945            Self::__Unknown(value) => value,
12946        }
12947    }
12948}
12949
12950#[doc(hidden)]
12951impl FromGlib<ffi::GtkTreeViewDropPosition> for TreeViewDropPosition {
12952    #[inline]
12953    unsafe fn from_glib(value: ffi::GtkTreeViewDropPosition) -> Self {
12954        skip_assert_initialized!();
12955
12956        match value {
12957            ffi::GTK_TREE_VIEW_DROP_BEFORE => Self::Before,
12958            ffi::GTK_TREE_VIEW_DROP_AFTER => Self::After,
12959            ffi::GTK_TREE_VIEW_DROP_INTO_OR_BEFORE => Self::IntoOrBefore,
12960            ffi::GTK_TREE_VIEW_DROP_INTO_OR_AFTER => Self::IntoOrAfter,
12961            value => Self::__Unknown(value),
12962        }
12963    }
12964}
12965
12966impl StaticType for TreeViewDropPosition {
12967    #[inline]
12968    #[doc(alias = "gtk_tree_view_drop_position_get_type")]
12969    fn static_type() -> glib::Type {
12970        unsafe { from_glib(ffi::gtk_tree_view_drop_position_get_type()) }
12971    }
12972}
12973
12974impl glib::HasParamSpec for TreeViewDropPosition {
12975    type ParamSpec = glib::ParamSpecEnum;
12976    type SetValue = Self;
12977    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
12978
12979    fn param_spec_builder() -> Self::BuilderFn {
12980        Self::ParamSpec::builder_with_default
12981    }
12982}
12983
12984impl glib::value::ValueType for TreeViewDropPosition {
12985    type Type = Self;
12986}
12987
12988unsafe impl<'a> glib::value::FromValue<'a> for TreeViewDropPosition {
12989    type Checker = glib::value::GenericValueTypeChecker<Self>;
12990
12991    #[inline]
12992    unsafe fn from_value(value: &'a glib::Value) -> Self {
12993        skip_assert_initialized!();
12994        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
12995    }
12996}
12997
12998impl ToValue for TreeViewDropPosition {
12999    #[inline]
13000    fn to_value(&self) -> glib::Value {
13001        let mut value = glib::Value::for_value_type::<Self>();
13002        unsafe {
13003            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
13004        }
13005        value
13006    }
13007
13008    #[inline]
13009    fn value_type(&self) -> glib::Type {
13010        Self::static_type()
13011    }
13012}
13013
13014impl From<TreeViewDropPosition> for glib::Value {
13015    #[inline]
13016    fn from(v: TreeViewDropPosition) -> Self {
13017        skip_assert_initialized!();
13018        ToValue::to_value(&v)
13019    }
13020}
13021
13022/// Used to indicate which grid lines to draw in a tree view.
13023#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
13024#[non_exhaustive]
13025#[doc(alias = "GtkTreeViewGridLines")]
13026pub enum TreeViewGridLines {
13027    /// No grid lines.
13028    #[doc(alias = "GTK_TREE_VIEW_GRID_LINES_NONE")]
13029    None,
13030    /// Horizontal grid lines.
13031    #[doc(alias = "GTK_TREE_VIEW_GRID_LINES_HORIZONTAL")]
13032    Horizontal,
13033    /// Vertical grid lines.
13034    #[doc(alias = "GTK_TREE_VIEW_GRID_LINES_VERTICAL")]
13035    Vertical,
13036    /// Horizontal and vertical grid lines.
13037    #[doc(alias = "GTK_TREE_VIEW_GRID_LINES_BOTH")]
13038    Both,
13039    #[doc(hidden)]
13040    __Unknown(i32),
13041}
13042
13043#[doc(hidden)]
13044impl IntoGlib for TreeViewGridLines {
13045    type GlibType = ffi::GtkTreeViewGridLines;
13046
13047    #[inline]
13048    fn into_glib(self) -> ffi::GtkTreeViewGridLines {
13049        match self {
13050            Self::None => ffi::GTK_TREE_VIEW_GRID_LINES_NONE,
13051            Self::Horizontal => ffi::GTK_TREE_VIEW_GRID_LINES_HORIZONTAL,
13052            Self::Vertical => ffi::GTK_TREE_VIEW_GRID_LINES_VERTICAL,
13053            Self::Both => ffi::GTK_TREE_VIEW_GRID_LINES_BOTH,
13054            Self::__Unknown(value) => value,
13055        }
13056    }
13057}
13058
13059#[doc(hidden)]
13060impl FromGlib<ffi::GtkTreeViewGridLines> for TreeViewGridLines {
13061    #[inline]
13062    unsafe fn from_glib(value: ffi::GtkTreeViewGridLines) -> Self {
13063        skip_assert_initialized!();
13064
13065        match value {
13066            ffi::GTK_TREE_VIEW_GRID_LINES_NONE => Self::None,
13067            ffi::GTK_TREE_VIEW_GRID_LINES_HORIZONTAL => Self::Horizontal,
13068            ffi::GTK_TREE_VIEW_GRID_LINES_VERTICAL => Self::Vertical,
13069            ffi::GTK_TREE_VIEW_GRID_LINES_BOTH => Self::Both,
13070            value => Self::__Unknown(value),
13071        }
13072    }
13073}
13074
13075impl StaticType for TreeViewGridLines {
13076    #[inline]
13077    #[doc(alias = "gtk_tree_view_grid_lines_get_type")]
13078    fn static_type() -> glib::Type {
13079        unsafe { from_glib(ffi::gtk_tree_view_grid_lines_get_type()) }
13080    }
13081}
13082
13083impl glib::HasParamSpec for TreeViewGridLines {
13084    type ParamSpec = glib::ParamSpecEnum;
13085    type SetValue = Self;
13086    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
13087
13088    fn param_spec_builder() -> Self::BuilderFn {
13089        Self::ParamSpec::builder_with_default
13090    }
13091}
13092
13093impl glib::value::ValueType for TreeViewGridLines {
13094    type Type = Self;
13095}
13096
13097unsafe impl<'a> glib::value::FromValue<'a> for TreeViewGridLines {
13098    type Checker = glib::value::GenericValueTypeChecker<Self>;
13099
13100    #[inline]
13101    unsafe fn from_value(value: &'a glib::Value) -> Self {
13102        skip_assert_initialized!();
13103        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
13104    }
13105}
13106
13107impl ToValue for TreeViewGridLines {
13108    #[inline]
13109    fn to_value(&self) -> glib::Value {
13110        let mut value = glib::Value::for_value_type::<Self>();
13111        unsafe {
13112            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
13113        }
13114        value
13115    }
13116
13117    #[inline]
13118    fn value_type(&self) -> glib::Type {
13119        Self::static_type()
13120    }
13121}
13122
13123impl From<TreeViewGridLines> for glib::Value {
13124    #[inline]
13125    fn from(v: TreeViewGridLines) -> Self {
13126        skip_assert_initialized!();
13127        ToValue::to_value(&v)
13128    }
13129}
13130
13131/// See also gtk_print_settings_set_paper_width().
13132#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
13133#[non_exhaustive]
13134#[doc(alias = "GtkUnit")]
13135pub enum Unit {
13136    /// No units.
13137    #[doc(alias = "GTK_UNIT_NONE")]
13138    None,
13139    /// Dimensions in points.
13140    #[doc(alias = "GTK_UNIT_POINTS")]
13141    Points,
13142    /// Dimensions in inches.
13143    #[doc(alias = "GTK_UNIT_INCH")]
13144    Inch,
13145    /// Dimensions in millimeters
13146    #[doc(alias = "GTK_UNIT_MM")]
13147    Mm,
13148    #[doc(hidden)]
13149    __Unknown(i32),
13150}
13151
13152#[doc(hidden)]
13153impl IntoGlib for Unit {
13154    type GlibType = ffi::GtkUnit;
13155
13156    #[inline]
13157    fn into_glib(self) -> ffi::GtkUnit {
13158        match self {
13159            Self::None => ffi::GTK_UNIT_NONE,
13160            Self::Points => ffi::GTK_UNIT_POINTS,
13161            Self::Inch => ffi::GTK_UNIT_INCH,
13162            Self::Mm => ffi::GTK_UNIT_MM,
13163            Self::__Unknown(value) => value,
13164        }
13165    }
13166}
13167
13168#[doc(hidden)]
13169impl FromGlib<ffi::GtkUnit> for Unit {
13170    #[inline]
13171    unsafe fn from_glib(value: ffi::GtkUnit) -> Self {
13172        skip_assert_initialized!();
13173
13174        match value {
13175            ffi::GTK_UNIT_NONE => Self::None,
13176            ffi::GTK_UNIT_POINTS => Self::Points,
13177            ffi::GTK_UNIT_INCH => Self::Inch,
13178            ffi::GTK_UNIT_MM => Self::Mm,
13179            value => Self::__Unknown(value),
13180        }
13181    }
13182}
13183
13184impl StaticType for Unit {
13185    #[inline]
13186    #[doc(alias = "gtk_unit_get_type")]
13187    fn static_type() -> glib::Type {
13188        unsafe { from_glib(ffi::gtk_unit_get_type()) }
13189    }
13190}
13191
13192impl glib::HasParamSpec for Unit {
13193    type ParamSpec = glib::ParamSpecEnum;
13194    type SetValue = Self;
13195    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
13196
13197    fn param_spec_builder() -> Self::BuilderFn {
13198        Self::ParamSpec::builder_with_default
13199    }
13200}
13201
13202impl glib::value::ValueType for Unit {
13203    type Type = Self;
13204}
13205
13206unsafe impl<'a> glib::value::FromValue<'a> for Unit {
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
13216impl ToValue for Unit {
13217    #[inline]
13218    fn to_value(&self) -> glib::Value {
13219        let mut value = glib::Value::for_value_type::<Self>();
13220        unsafe {
13221            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
13222        }
13223        value
13224    }
13225
13226    #[inline]
13227    fn value_type(&self) -> glib::Type {
13228        Self::static_type()
13229    }
13230}
13231
13232impl From<Unit> for glib::Value {
13233    #[inline]
13234    fn from(v: Unit) -> Self {
13235        skip_assert_initialized!();
13236        ToValue::to_value(&v)
13237    }
13238}
13239
13240/// Describes a type of line wrapping.
13241#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
13242#[non_exhaustive]
13243#[doc(alias = "GtkWrapMode")]
13244pub enum WrapMode {
13245    /// do not wrap lines; just make the text area wider
13246    #[doc(alias = "GTK_WRAP_NONE")]
13247    None,
13248    /// wrap text, breaking lines anywhere the cursor can
13249    ///   appear (between characters, usually - if you want to be technical,
13250    ///   between graphemes, see pango_get_log_attrs())
13251    #[doc(alias = "GTK_WRAP_CHAR")]
13252    Char,
13253    /// wrap text, breaking lines in between words
13254    #[doc(alias = "GTK_WRAP_WORD")]
13255    Word,
13256    /// wrap text, breaking lines in between words, or if
13257    ///   that is not enough, also between graphemes
13258    #[doc(alias = "GTK_WRAP_WORD_CHAR")]
13259    WordChar,
13260    #[doc(hidden)]
13261    __Unknown(i32),
13262}
13263
13264#[doc(hidden)]
13265impl IntoGlib for WrapMode {
13266    type GlibType = ffi::GtkWrapMode;
13267
13268    #[inline]
13269    fn into_glib(self) -> ffi::GtkWrapMode {
13270        match self {
13271            Self::None => ffi::GTK_WRAP_NONE,
13272            Self::Char => ffi::GTK_WRAP_CHAR,
13273            Self::Word => ffi::GTK_WRAP_WORD,
13274            Self::WordChar => ffi::GTK_WRAP_WORD_CHAR,
13275            Self::__Unknown(value) => value,
13276        }
13277    }
13278}
13279
13280#[doc(hidden)]
13281impl FromGlib<ffi::GtkWrapMode> for WrapMode {
13282    #[inline]
13283    unsafe fn from_glib(value: ffi::GtkWrapMode) -> Self {
13284        skip_assert_initialized!();
13285
13286        match value {
13287            ffi::GTK_WRAP_NONE => Self::None,
13288            ffi::GTK_WRAP_CHAR => Self::Char,
13289            ffi::GTK_WRAP_WORD => Self::Word,
13290            ffi::GTK_WRAP_WORD_CHAR => Self::WordChar,
13291            value => Self::__Unknown(value),
13292        }
13293    }
13294}
13295
13296impl StaticType for WrapMode {
13297    #[inline]
13298    #[doc(alias = "gtk_wrap_mode_get_type")]
13299    fn static_type() -> glib::Type {
13300        unsafe { from_glib(ffi::gtk_wrap_mode_get_type()) }
13301    }
13302}
13303
13304impl glib::HasParamSpec for WrapMode {
13305    type ParamSpec = glib::ParamSpecEnum;
13306    type SetValue = Self;
13307    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
13308
13309    fn param_spec_builder() -> Self::BuilderFn {
13310        Self::ParamSpec::builder_with_default
13311    }
13312}
13313
13314impl glib::value::ValueType for WrapMode {
13315    type Type = Self;
13316}
13317
13318unsafe impl<'a> glib::value::FromValue<'a> for WrapMode {
13319    type Checker = glib::value::GenericValueTypeChecker<Self>;
13320
13321    #[inline]
13322    unsafe fn from_value(value: &'a glib::Value) -> Self {
13323        skip_assert_initialized!();
13324        from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
13325    }
13326}
13327
13328impl ToValue for WrapMode {
13329    #[inline]
13330    fn to_value(&self) -> glib::Value {
13331        let mut value = glib::Value::for_value_type::<Self>();
13332        unsafe {
13333            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
13334        }
13335        value
13336    }
13337
13338    #[inline]
13339    fn value_type(&self) -> glib::Type {
13340        Self::static_type()
13341    }
13342}
13343
13344impl From<WrapMode> for glib::Value {
13345    #[inline]
13346    fn from(v: WrapMode) -> Self {
13347        skip_assert_initialized!();
13348        ToValue::to_value(&v)
13349    }
13350}
gtk4/auto/enums.rs

gtk4/auto/
enums.rs
