gtk4/auto/

enums.rs

// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT

use crate::ffi;
use glib::{prelude::*, translate::*};

/// The priority of an accessibility announcement.
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkAccessibleAnnouncementPriority")]
pub enum AccessibleAnnouncementPriority {
    /// The announcement is low priority,
    ///   and might be read only on the user's request.
    #[doc(alias = "GTK_ACCESSIBLE_ANNOUNCEMENT_PRIORITY_LOW")]
    Low,
    /// The announcement is of medium
    ///   priority, and is usually spoken at the next opportunity, such as at the
    ///   end of speaking the current sentence or when the user pauses typing.
    #[doc(alias = "GTK_ACCESSIBLE_ANNOUNCEMENT_PRIORITY_MEDIUM")]
    Medium,
    /// The announcement is of high
    ///   priority, and is usually spoken immediately. Because an interruption
    ///   might disorient users or cause them to not complete their current task,
    ///   authors SHOULD NOT use high priority announcements unless the
    ///   interruption is imperative. An example would be a notification about a
    ///   critical battery power level.
    #[doc(alias = "GTK_ACCESSIBLE_ANNOUNCEMENT_PRIORITY_HIGH")]
    High,
    #[doc(hidden)]
    __Unknown(i32),
}

#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
#[doc(hidden)]
impl IntoGlib for AccessibleAnnouncementPriority {
    type GlibType = ffi::GtkAccessibleAnnouncementPriority;

    #[inline]
    fn into_glib(self) -> ffi::GtkAccessibleAnnouncementPriority {
        match self {
            Self::Low => ffi::GTK_ACCESSIBLE_ANNOUNCEMENT_PRIORITY_LOW,
            Self::Medium => ffi::GTK_ACCESSIBLE_ANNOUNCEMENT_PRIORITY_MEDIUM,
            Self::High => ffi::GTK_ACCESSIBLE_ANNOUNCEMENT_PRIORITY_HIGH,
            Self::__Unknown(value) => value,
        }
    }
}

#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
#[doc(hidden)]
impl FromGlib<ffi::GtkAccessibleAnnouncementPriority> for AccessibleAnnouncementPriority {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkAccessibleAnnouncementPriority) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_ACCESSIBLE_ANNOUNCEMENT_PRIORITY_LOW => Self::Low,
            ffi::GTK_ACCESSIBLE_ANNOUNCEMENT_PRIORITY_MEDIUM => Self::Medium,
            ffi::GTK_ACCESSIBLE_ANNOUNCEMENT_PRIORITY_HIGH => Self::High,
            value => Self::__Unknown(value),
        }
    }
}

#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
impl StaticType for AccessibleAnnouncementPriority {
    #[inline]
    #[doc(alias = "gtk_accessible_announcement_priority_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_accessible_announcement_priority_get_type()) }
    }
}

#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
impl glib::HasParamSpec for AccessibleAnnouncementPriority {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
impl glib::value::ValueType for AccessibleAnnouncementPriority {
    type Type = Self;
}

#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
unsafe impl<'a> glib::value::FromValue<'a> for AccessibleAnnouncementPriority {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
impl ToValue for AccessibleAnnouncementPriority {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
impl From<AccessibleAnnouncementPriority> for glib::Value {
    #[inline]
    fn from(v: AccessibleAnnouncementPriority) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// The possible values for the [`AccessibleProperty::Autocomplete`][crate::AccessibleProperty::Autocomplete]
/// accessible property.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkAccessibleAutocomplete")]
pub enum AccessibleAutocomplete {
    /// Automatic suggestions are not displayed.
    #[doc(alias = "GTK_ACCESSIBLE_AUTOCOMPLETE_NONE")]
    None,
    /// When a user is providing input, text
    ///    suggesting one way to complete the provided input may be dynamically
    ///    inserted after the caret.
    #[doc(alias = "GTK_ACCESSIBLE_AUTOCOMPLETE_INLINE")]
    Inline,
    /// When a user is providing input, an element
    ///    containing a collection of values that could complete the provided input
    ///    may be displayed.
    #[doc(alias = "GTK_ACCESSIBLE_AUTOCOMPLETE_LIST")]
    List,
    /// When a user is providing input, an element
    ///    containing a collection of values that could complete the provided input
    ///    may be displayed. If displayed, one value in the collection is automatically
    ///    selected, and the text needed to complete the automatically selected value
    ///    appears after the caret in the input.
    #[doc(alias = "GTK_ACCESSIBLE_AUTOCOMPLETE_BOTH")]
    Both,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for AccessibleAutocomplete {
    type GlibType = ffi::GtkAccessibleAutocomplete;

    #[inline]
    fn into_glib(self) -> ffi::GtkAccessibleAutocomplete {
        match self {
            Self::None => ffi::GTK_ACCESSIBLE_AUTOCOMPLETE_NONE,
            Self::Inline => ffi::GTK_ACCESSIBLE_AUTOCOMPLETE_INLINE,
            Self::List => ffi::GTK_ACCESSIBLE_AUTOCOMPLETE_LIST,
            Self::Both => ffi::GTK_ACCESSIBLE_AUTOCOMPLETE_BOTH,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkAccessibleAutocomplete> for AccessibleAutocomplete {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkAccessibleAutocomplete) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_ACCESSIBLE_AUTOCOMPLETE_NONE => Self::None,
            ffi::GTK_ACCESSIBLE_AUTOCOMPLETE_INLINE => Self::Inline,
            ffi::GTK_ACCESSIBLE_AUTOCOMPLETE_LIST => Self::List,
            ffi::GTK_ACCESSIBLE_AUTOCOMPLETE_BOTH => Self::Both,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for AccessibleAutocomplete {
    #[inline]
    #[doc(alias = "gtk_accessible_autocomplete_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_accessible_autocomplete_get_type()) }
    }
}

impl glib::HasParamSpec for AccessibleAutocomplete {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for AccessibleAutocomplete {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for AccessibleAutocomplete {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for AccessibleAutocomplete {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<AccessibleAutocomplete> for glib::Value {
    #[inline]
    fn from(v: AccessibleAutocomplete) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// The possible values for the [`AccessibleState::Invalid`][crate::AccessibleState::Invalid]
/// accessible state.
///
/// Note that the [`False`][Self::False] and
/// [`True`][Self::True] have the same values
/// as [`false`] and [`true`].
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkAccessibleInvalidState")]
pub enum AccessibleInvalidState {
    /// There are no detected errors in the value
    #[doc(alias = "GTK_ACCESSIBLE_INVALID_FALSE")]
    False,
    /// The value entered by the user has failed validation
    #[doc(alias = "GTK_ACCESSIBLE_INVALID_TRUE")]
    True,
    /// A grammatical error was detected
    #[doc(alias = "GTK_ACCESSIBLE_INVALID_GRAMMAR")]
    Grammar,
    /// A spelling error was detected
    #[doc(alias = "GTK_ACCESSIBLE_INVALID_SPELLING")]
    Spelling,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for AccessibleInvalidState {
    type GlibType = ffi::GtkAccessibleInvalidState;

    #[inline]
    fn into_glib(self) -> ffi::GtkAccessibleInvalidState {
        match self {
            Self::False => ffi::GTK_ACCESSIBLE_INVALID_FALSE,
            Self::True => ffi::GTK_ACCESSIBLE_INVALID_TRUE,
            Self::Grammar => ffi::GTK_ACCESSIBLE_INVALID_GRAMMAR,
            Self::Spelling => ffi::GTK_ACCESSIBLE_INVALID_SPELLING,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkAccessibleInvalidState> for AccessibleInvalidState {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkAccessibleInvalidState) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_ACCESSIBLE_INVALID_FALSE => Self::False,
            ffi::GTK_ACCESSIBLE_INVALID_TRUE => Self::True,
            ffi::GTK_ACCESSIBLE_INVALID_GRAMMAR => Self::Grammar,
            ffi::GTK_ACCESSIBLE_INVALID_SPELLING => Self::Spelling,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for AccessibleInvalidState {
    #[inline]
    #[doc(alias = "gtk_accessible_invalid_state_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_accessible_invalid_state_get_type()) }
    }
}

impl glib::HasParamSpec for AccessibleInvalidState {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for AccessibleInvalidState {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for AccessibleInvalidState {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for AccessibleInvalidState {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<AccessibleInvalidState> for glib::Value {
    #[inline]
    fn from(v: AccessibleInvalidState) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// The various platform states which can be queried
/// using [`AccessibleExt::platform_state()`][crate::prelude::AccessibleExt::platform_state()].
#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkAccessiblePlatformState")]
pub enum AccessiblePlatformState {
    /// whether the accessible can be focused
    #[doc(alias = "GTK_ACCESSIBLE_PLATFORM_STATE_FOCUSABLE")]
    Focusable,
    /// whether the accessible has focus
    #[doc(alias = "GTK_ACCESSIBLE_PLATFORM_STATE_FOCUSED")]
    Focused,
    /// whether the accessible is active
    #[doc(alias = "GTK_ACCESSIBLE_PLATFORM_STATE_ACTIVE")]
    Active,
    #[doc(hidden)]
    __Unknown(i32),
}

#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
#[doc(hidden)]
impl IntoGlib for AccessiblePlatformState {
    type GlibType = ffi::GtkAccessiblePlatformState;

    #[inline]
    fn into_glib(self) -> ffi::GtkAccessiblePlatformState {
        match self {
            Self::Focusable => ffi::GTK_ACCESSIBLE_PLATFORM_STATE_FOCUSABLE,
            Self::Focused => ffi::GTK_ACCESSIBLE_PLATFORM_STATE_FOCUSED,
            Self::Active => ffi::GTK_ACCESSIBLE_PLATFORM_STATE_ACTIVE,
            Self::__Unknown(value) => value,
        }
    }
}

#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
#[doc(hidden)]
impl FromGlib<ffi::GtkAccessiblePlatformState> for AccessiblePlatformState {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkAccessiblePlatformState) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_ACCESSIBLE_PLATFORM_STATE_FOCUSABLE => Self::Focusable,
            ffi::GTK_ACCESSIBLE_PLATFORM_STATE_FOCUSED => Self::Focused,
            ffi::GTK_ACCESSIBLE_PLATFORM_STATE_ACTIVE => Self::Active,
            value => Self::__Unknown(value),
        }
    }
}

#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
impl StaticType for AccessiblePlatformState {
    #[inline]
    #[doc(alias = "gtk_accessible_platform_state_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_accessible_platform_state_get_type()) }
    }
}

#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
impl glib::HasParamSpec for AccessiblePlatformState {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
impl glib::value::ValueType for AccessiblePlatformState {
    type Type = Self;
}

#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
unsafe impl<'a> glib::value::FromValue<'a> for AccessiblePlatformState {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
impl ToValue for AccessiblePlatformState {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
impl From<AccessiblePlatformState> for glib::Value {
    #[inline]
    fn from(v: AccessiblePlatformState) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// The possible accessible properties of a [`Accessible`][crate::Accessible].
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkAccessibleProperty")]
pub enum AccessibleProperty {
    /// Indicates whether inputting text
    ///    could trigger display of one or more predictions of the user's intended
    ///    value for a combobox, searchbox, or textbox and specifies how predictions
    ///    would be presented if they were made. Value type: [`AccessibleAutocomplete`][crate::AccessibleAutocomplete]
    #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_AUTOCOMPLETE")]
    Autocomplete,
    /// Defines a string value that describes
    ///    or annotates the current element. Value type: string
    #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_DESCRIPTION")]
    Description,
    /// Indicates the availability of interactive
    ///    popup element, such as menu or popover, that can be triggered by an
    ///    element. Contrary to “aria-haspopup”, it doesn't indicate the type of the
    ///    element, as such it cannot be used to indicate the availability of more
    ///    complex elements such as dialog. Value type: boolean
    #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_HAS_POPUP")]
    HasPopup,
    /// Indicates keyboard shortcuts that an
    ///    author has implemented to activate or give focus to an element. Value type:
    ///    string. The format of the value is a space-separated list of shortcuts, with
    ///    each shortcut consisting of one or more modifiers (`Control`, `Alt` or `Shift`),
    ///    followed by a non-modifier key, all separated by `+`. The
    ///    [WAI-ARIA](https://www.w3.org/TR/wai-aria/#aria-keyshortcuts) reference
    ///    specifies how to build keyboard shortcuts strings, with specific values
    ///    for each key which are the same regardless of the language, so these
    ///    strings can't be built from localized key names. You can convert an
    ///    accelerator into the matching key shortcuts label with
    ///    [`accelerator_get_accessible_label()`][crate::accelerator_get_accessible_label()].
    ///    Examples: `F2`, `Alt+F`, `Control+Shift+N`
    #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_KEY_SHORTCUTS")]
    KeyShortcuts,
    /// Defines a string value that labels the current
    ///    element. Value type: string
    #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_LABEL")]
    Label,
    /// Defines the hierarchical level of an element
    ///    within a structure. Value type: integer
    #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_LEVEL")]
    Level,
    /// Indicates whether an element is modal when
    ///    displayed. Value type: boolean
    #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_MODAL")]
    Modal,
    /// Indicates whether a text box accepts
    ///    multiple lines of input or only a single line. Value type: boolean
    #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_MULTI_LINE")]
    MultiLine,
    /// Indicates that the user may select
    ///    more than one item from the current selectable descendants. Value type:
    ///    boolean
    #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_MULTI_SELECTABLE")]
    MultiSelectable,
    /// Indicates whether the element's
    ///    orientation is horizontal, vertical, or unknown/ambiguous. Value type:
    ///    [`Orientation`][crate::Orientation]
    #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_ORIENTATION")]
    Orientation,
    /// Defines a short hint (a word or short
    ///    phrase) intended to aid the user with data entry when the control has no
    ///    value. A hint could be a sample value or a brief description of the expected
    ///    format. Value type: string
    #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_PLACEHOLDER")]
    Placeholder,
    /// Indicates that the element is not editable,
    ///    but is otherwise operable. Value type: boolean
    #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_READ_ONLY")]
    ReadOnly,
    /// Indicates that user input is required on
    ///    the element before a form may be submitted. Value type: boolean
    #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_REQUIRED")]
    Required,
    /// Defines a human-readable,
    ///    author-localized description for the role of an element. Value type: string
    #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_ROLE_DESCRIPTION")]
    RoleDescription,
    /// Indicates if items in a table or grid are
    ///    sorted in ascending or descending order. Value type: [`AccessibleSort`][crate::AccessibleSort]
    #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_SORT")]
    Sort,
    /// Defines the maximum allowed value for a
    ///    range widget. Value type: double
    #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_VALUE_MAX")]
    ValueMax,
    /// Defines the minimum allowed value for a
    ///    range widget. Value type: double
    #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_VALUE_MIN")]
    ValueMin,
    /// Defines the current value for a range widget.
    ///    Value type: double
    #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_VALUE_NOW")]
    ValueNow,
    /// Defines the human readable text alternative
    ///    of [enum@Gtk.AccessibleProperty.VALUE_NOW] for a range widget. Value type: string
    #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_VALUE_TEXT")]
    ValueText,
    /// Defines a string value that provides a description of non-standard keyboard
    /// interactions of the current element. Value type: string
    #[cfg(feature = "v4_16")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
    #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_HELP_TEXT")]
    HelpText,
    #[doc(hidden)]
    __Unknown(i32),
}

impl AccessibleProperty {
    #[doc(alias = "gtk_accessible_property_init_value")]
    pub fn init_value(self, value: &mut glib::Value) {
        assert_initialized_main_thread!();
        unsafe {
            ffi::gtk_accessible_property_init_value(self.into_glib(), value.to_glib_none_mut().0);
        }
    }
}

#[doc(hidden)]
impl IntoGlib for AccessibleProperty {
    type GlibType = ffi::GtkAccessibleProperty;

    fn into_glib(self) -> ffi::GtkAccessibleProperty {
        match self {
            Self::Autocomplete => ffi::GTK_ACCESSIBLE_PROPERTY_AUTOCOMPLETE,
            Self::Description => ffi::GTK_ACCESSIBLE_PROPERTY_DESCRIPTION,
            Self::HasPopup => ffi::GTK_ACCESSIBLE_PROPERTY_HAS_POPUP,
            Self::KeyShortcuts => ffi::GTK_ACCESSIBLE_PROPERTY_KEY_SHORTCUTS,
            Self::Label => ffi::GTK_ACCESSIBLE_PROPERTY_LABEL,
            Self::Level => ffi::GTK_ACCESSIBLE_PROPERTY_LEVEL,
            Self::Modal => ffi::GTK_ACCESSIBLE_PROPERTY_MODAL,
            Self::MultiLine => ffi::GTK_ACCESSIBLE_PROPERTY_MULTI_LINE,
            Self::MultiSelectable => ffi::GTK_ACCESSIBLE_PROPERTY_MULTI_SELECTABLE,
            Self::Orientation => ffi::GTK_ACCESSIBLE_PROPERTY_ORIENTATION,
            Self::Placeholder => ffi::GTK_ACCESSIBLE_PROPERTY_PLACEHOLDER,
            Self::ReadOnly => ffi::GTK_ACCESSIBLE_PROPERTY_READ_ONLY,
            Self::Required => ffi::GTK_ACCESSIBLE_PROPERTY_REQUIRED,
            Self::RoleDescription => ffi::GTK_ACCESSIBLE_PROPERTY_ROLE_DESCRIPTION,
            Self::Sort => ffi::GTK_ACCESSIBLE_PROPERTY_SORT,
            Self::ValueMax => ffi::GTK_ACCESSIBLE_PROPERTY_VALUE_MAX,
            Self::ValueMin => ffi::GTK_ACCESSIBLE_PROPERTY_VALUE_MIN,
            Self::ValueNow => ffi::GTK_ACCESSIBLE_PROPERTY_VALUE_NOW,
            Self::ValueText => ffi::GTK_ACCESSIBLE_PROPERTY_VALUE_TEXT,
            #[cfg(feature = "v4_16")]
            Self::HelpText => ffi::GTK_ACCESSIBLE_PROPERTY_HELP_TEXT,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkAccessibleProperty> for AccessibleProperty {
    unsafe fn from_glib(value: ffi::GtkAccessibleProperty) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_ACCESSIBLE_PROPERTY_AUTOCOMPLETE => Self::Autocomplete,
            ffi::GTK_ACCESSIBLE_PROPERTY_DESCRIPTION => Self::Description,
            ffi::GTK_ACCESSIBLE_PROPERTY_HAS_POPUP => Self::HasPopup,
            ffi::GTK_ACCESSIBLE_PROPERTY_KEY_SHORTCUTS => Self::KeyShortcuts,
            ffi::GTK_ACCESSIBLE_PROPERTY_LABEL => Self::Label,
            ffi::GTK_ACCESSIBLE_PROPERTY_LEVEL => Self::Level,
            ffi::GTK_ACCESSIBLE_PROPERTY_MODAL => Self::Modal,
            ffi::GTK_ACCESSIBLE_PROPERTY_MULTI_LINE => Self::MultiLine,
            ffi::GTK_ACCESSIBLE_PROPERTY_MULTI_SELECTABLE => Self::MultiSelectable,
            ffi::GTK_ACCESSIBLE_PROPERTY_ORIENTATION => Self::Orientation,
            ffi::GTK_ACCESSIBLE_PROPERTY_PLACEHOLDER => Self::Placeholder,
            ffi::GTK_ACCESSIBLE_PROPERTY_READ_ONLY => Self::ReadOnly,
            ffi::GTK_ACCESSIBLE_PROPERTY_REQUIRED => Self::Required,
            ffi::GTK_ACCESSIBLE_PROPERTY_ROLE_DESCRIPTION => Self::RoleDescription,
            ffi::GTK_ACCESSIBLE_PROPERTY_SORT => Self::Sort,
            ffi::GTK_ACCESSIBLE_PROPERTY_VALUE_MAX => Self::ValueMax,
            ffi::GTK_ACCESSIBLE_PROPERTY_VALUE_MIN => Self::ValueMin,
            ffi::GTK_ACCESSIBLE_PROPERTY_VALUE_NOW => Self::ValueNow,
            ffi::GTK_ACCESSIBLE_PROPERTY_VALUE_TEXT => Self::ValueText,
            #[cfg(feature = "v4_16")]
            ffi::GTK_ACCESSIBLE_PROPERTY_HELP_TEXT => Self::HelpText,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for AccessibleProperty {
    #[inline]
    #[doc(alias = "gtk_accessible_property_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_accessible_property_get_type()) }
    }
}

impl glib::HasParamSpec for AccessibleProperty {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for AccessibleProperty {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for AccessibleProperty {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for AccessibleProperty {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<AccessibleProperty> for glib::Value {
    #[inline]
    fn from(v: AccessibleProperty) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// The possible accessible relations of a [`Accessible`][crate::Accessible].
///
/// Accessible relations can be references to other widgets,
/// integers or strings.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkAccessibleRelation")]
pub enum AccessibleRelation {
    /// Identifies the currently active
    ///    element when focus is on a composite widget, combobox, textbox, group,
    ///    or application. Value type: reference
    #[doc(alias = "GTK_ACCESSIBLE_RELATION_ACTIVE_DESCENDANT")]
    ActiveDescendant,
    /// Defines the total number of columns
    ///    in a table, grid, or treegrid. Value type: integer
    #[doc(alias = "GTK_ACCESSIBLE_RELATION_COL_COUNT")]
    ColCount,
    /// Defines an element's column index or
    ///    position with respect to the total number of columns within a table,
    ///    grid, or treegrid. Value type: integer
    #[doc(alias = "GTK_ACCESSIBLE_RELATION_COL_INDEX")]
    ColIndex,
    /// Defines a human readable text
    ///   alternative of [`ColIndex`][Self::ColIndex]. Value type: string
    #[doc(alias = "GTK_ACCESSIBLE_RELATION_COL_INDEX_TEXT")]
    ColIndexText,
    /// Defines the number of columns spanned
    ///   by a cell or gridcell within a table, grid, or treegrid. Value type: integer
    #[doc(alias = "GTK_ACCESSIBLE_RELATION_COL_SPAN")]
    ColSpan,
    /// Identifies the element (or elements) whose
    ///    contents or presence are controlled by the current element. Value type: reference
    #[doc(alias = "GTK_ACCESSIBLE_RELATION_CONTROLS")]
    Controls,
    /// Identifies the element (or elements)
    ///    that describes the object. Value type: reference
    #[doc(alias = "GTK_ACCESSIBLE_RELATION_DESCRIBED_BY")]
    DescribedBy,
    /// Identifies the element (or elements) that
    ///    provide additional information related to the object. Value type: reference
    #[doc(alias = "GTK_ACCESSIBLE_RELATION_DETAILS")]
    Details,
    /// Identifies the element (or elements) that
    ///    provide an error message for an object. Value type: reference
    #[doc(alias = "GTK_ACCESSIBLE_RELATION_ERROR_MESSAGE")]
    ErrorMessage,
    /// Identifies the next element (or elements)
    ///    in an alternate reading order of content which, at the user's discretion,
    ///    allows assistive technology to override the general default of reading in
    ///    document source order. Value type: reference
    #[doc(alias = "GTK_ACCESSIBLE_RELATION_FLOW_TO")]
    FlowTo,
    /// Identifies the element (or elements)
    ///    that labels the current element. Value type: reference
    #[doc(alias = "GTK_ACCESSIBLE_RELATION_LABELLED_BY")]
    LabelledBy,
    /// Identifies an element (or elements) in order
    ///    to define a visual, functional, or contextual parent/child relationship
    ///    between elements where the widget hierarchy cannot be used to represent
    ///    the relationship. Value type: reference
    #[doc(alias = "GTK_ACCESSIBLE_RELATION_OWNS")]
    Owns,
    /// Defines an element's number or position
    ///    in the current set of listitems or treeitems. Value type: integer
    #[doc(alias = "GTK_ACCESSIBLE_RELATION_POS_IN_SET")]
    PosInSet,
    /// Defines the total number of rows in a table,
    ///    grid, or treegrid. Value type: integer
    #[doc(alias = "GTK_ACCESSIBLE_RELATION_ROW_COUNT")]
    RowCount,
    /// Defines an element's row index or position
    ///    with respect to the total number of rows within a table, grid, or treegrid.
    ///    Value type: integer
    #[doc(alias = "GTK_ACCESSIBLE_RELATION_ROW_INDEX")]
    RowIndex,
    /// Defines a human readable text
    ///    alternative of [enum@Gtk.AccessibleRelation.ROW_INDEX]. Value type: string
    #[doc(alias = "GTK_ACCESSIBLE_RELATION_ROW_INDEX_TEXT")]
    RowIndexText,
    /// Defines the number of rows spanned by a
    ///    cell or gridcell within a table, grid, or treegrid. Value type: integer
    #[doc(alias = "GTK_ACCESSIBLE_RELATION_ROW_SPAN")]
    RowSpan,
    /// Defines the number of items in the current
    ///    set of listitems or treeitems. Value type: integer
    #[doc(alias = "GTK_ACCESSIBLE_RELATION_SET_SIZE")]
    SetSize,
    /// Identifies the element (or elements) that are labeled by the
    /// current element. Value type: reference
    ///
    /// This relation is managed by GTK and should not be set from application code.
    #[cfg(feature = "v4_18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_18")))]
    #[doc(alias = "GTK_ACCESSIBLE_RELATION_LABEL_FOR")]
    LabelFor,
    /// Identifies the element (or elements) that are described by
    /// the current element. Value type: reference
    ///
    /// This relation is managed by GTK and should not be set from application code.
    #[cfg(feature = "v4_18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_18")))]
    #[doc(alias = "GTK_ACCESSIBLE_RELATION_DESCRIPTION_FOR")]
    DescriptionFor,
    /// Identifies the element (or elements) that the current
    /// element is controlled by. Value type: reference
    ///
    /// This relation is managed by GTK and should not be set from application code.
    #[cfg(feature = "v4_18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_18")))]
    #[doc(alias = "GTK_ACCESSIBLE_RELATION_CONTROLLED_BY")]
    ControlledBy,
    /// Identifies the element (or elements) for which the current
    /// element provides additional information. Value type: reference
    ///
    /// This relation is managed by GTK and should not be set from application code.
    #[cfg(feature = "v4_18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_18")))]
    #[doc(alias = "GTK_ACCESSIBLE_RELATION_DETAILS_FOR")]
    DetailsFor,
    /// Identifies the element (or elements) for which the current
    /// element provides an error message. Value type: reference
    ///
    /// This relation is managed by GTK and should not be set from application code.
    #[cfg(feature = "v4_18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_18")))]
    #[doc(alias = "GTK_ACCESSIBLE_RELATION_ERROR_MESSAGE_FOR")]
    ErrorMessageFor,
    /// Identifies the previous element (or elements) in an alternate
    /// reading order of content which, at the user's discretion, allows
    /// assistive technology to override the general default of reading in
    /// document source order. Value type: reference
    ///
    /// This relation is managed by GTK and should not be set from application code.
    #[cfg(feature = "v4_18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_18")))]
    #[doc(alias = "GTK_ACCESSIBLE_RELATION_FLOW_FROM")]
    FlowFrom,
    #[doc(hidden)]
    __Unknown(i32),
}

impl AccessibleRelation {
    #[doc(alias = "gtk_accessible_relation_init_value")]
    pub fn init_value(self, value: &mut glib::Value) {
        assert_initialized_main_thread!();
        unsafe {
            ffi::gtk_accessible_relation_init_value(self.into_glib(), value.to_glib_none_mut().0);
        }
    }
}

#[doc(hidden)]
impl IntoGlib for AccessibleRelation {
    type GlibType = ffi::GtkAccessibleRelation;

    fn into_glib(self) -> ffi::GtkAccessibleRelation {
        match self {
            Self::ActiveDescendant => ffi::GTK_ACCESSIBLE_RELATION_ACTIVE_DESCENDANT,
            Self::ColCount => ffi::GTK_ACCESSIBLE_RELATION_COL_COUNT,
            Self::ColIndex => ffi::GTK_ACCESSIBLE_RELATION_COL_INDEX,
            Self::ColIndexText => ffi::GTK_ACCESSIBLE_RELATION_COL_INDEX_TEXT,
            Self::ColSpan => ffi::GTK_ACCESSIBLE_RELATION_COL_SPAN,
            Self::Controls => ffi::GTK_ACCESSIBLE_RELATION_CONTROLS,
            Self::DescribedBy => ffi::GTK_ACCESSIBLE_RELATION_DESCRIBED_BY,
            Self::Details => ffi::GTK_ACCESSIBLE_RELATION_DETAILS,
            Self::ErrorMessage => ffi::GTK_ACCESSIBLE_RELATION_ERROR_MESSAGE,
            Self::FlowTo => ffi::GTK_ACCESSIBLE_RELATION_FLOW_TO,
            Self::LabelledBy => ffi::GTK_ACCESSIBLE_RELATION_LABELLED_BY,
            Self::Owns => ffi::GTK_ACCESSIBLE_RELATION_OWNS,
            Self::PosInSet => ffi::GTK_ACCESSIBLE_RELATION_POS_IN_SET,
            Self::RowCount => ffi::GTK_ACCESSIBLE_RELATION_ROW_COUNT,
            Self::RowIndex => ffi::GTK_ACCESSIBLE_RELATION_ROW_INDEX,
            Self::RowIndexText => ffi::GTK_ACCESSIBLE_RELATION_ROW_INDEX_TEXT,
            Self::RowSpan => ffi::GTK_ACCESSIBLE_RELATION_ROW_SPAN,
            Self::SetSize => ffi::GTK_ACCESSIBLE_RELATION_SET_SIZE,
            #[cfg(feature = "v4_18")]
            Self::LabelFor => ffi::GTK_ACCESSIBLE_RELATION_LABEL_FOR,
            #[cfg(feature = "v4_18")]
            Self::DescriptionFor => ffi::GTK_ACCESSIBLE_RELATION_DESCRIPTION_FOR,
            #[cfg(feature = "v4_18")]
            Self::ControlledBy => ffi::GTK_ACCESSIBLE_RELATION_CONTROLLED_BY,
            #[cfg(feature = "v4_18")]
            Self::DetailsFor => ffi::GTK_ACCESSIBLE_RELATION_DETAILS_FOR,
            #[cfg(feature = "v4_18")]
            Self::ErrorMessageFor => ffi::GTK_ACCESSIBLE_RELATION_ERROR_MESSAGE_FOR,
            #[cfg(feature = "v4_18")]
            Self::FlowFrom => ffi::GTK_ACCESSIBLE_RELATION_FLOW_FROM,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkAccessibleRelation> for AccessibleRelation {
    unsafe fn from_glib(value: ffi::GtkAccessibleRelation) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_ACCESSIBLE_RELATION_ACTIVE_DESCENDANT => Self::ActiveDescendant,
            ffi::GTK_ACCESSIBLE_RELATION_COL_COUNT => Self::ColCount,
            ffi::GTK_ACCESSIBLE_RELATION_COL_INDEX => Self::ColIndex,
            ffi::GTK_ACCESSIBLE_RELATION_COL_INDEX_TEXT => Self::ColIndexText,
            ffi::GTK_ACCESSIBLE_RELATION_COL_SPAN => Self::ColSpan,
            ffi::GTK_ACCESSIBLE_RELATION_CONTROLS => Self::Controls,
            ffi::GTK_ACCESSIBLE_RELATION_DESCRIBED_BY => Self::DescribedBy,
            ffi::GTK_ACCESSIBLE_RELATION_DETAILS => Self::Details,
            ffi::GTK_ACCESSIBLE_RELATION_ERROR_MESSAGE => Self::ErrorMessage,
            ffi::GTK_ACCESSIBLE_RELATION_FLOW_TO => Self::FlowTo,
            ffi::GTK_ACCESSIBLE_RELATION_LABELLED_BY => Self::LabelledBy,
            ffi::GTK_ACCESSIBLE_RELATION_OWNS => Self::Owns,
            ffi::GTK_ACCESSIBLE_RELATION_POS_IN_SET => Self::PosInSet,
            ffi::GTK_ACCESSIBLE_RELATION_ROW_COUNT => Self::RowCount,
            ffi::GTK_ACCESSIBLE_RELATION_ROW_INDEX => Self::RowIndex,
            ffi::GTK_ACCESSIBLE_RELATION_ROW_INDEX_TEXT => Self::RowIndexText,
            ffi::GTK_ACCESSIBLE_RELATION_ROW_SPAN => Self::RowSpan,
            ffi::GTK_ACCESSIBLE_RELATION_SET_SIZE => Self::SetSize,
            #[cfg(feature = "v4_18")]
            ffi::GTK_ACCESSIBLE_RELATION_LABEL_FOR => Self::LabelFor,
            #[cfg(feature = "v4_18")]
            ffi::GTK_ACCESSIBLE_RELATION_DESCRIPTION_FOR => Self::DescriptionFor,
            #[cfg(feature = "v4_18")]
            ffi::GTK_ACCESSIBLE_RELATION_CONTROLLED_BY => Self::ControlledBy,
            #[cfg(feature = "v4_18")]
            ffi::GTK_ACCESSIBLE_RELATION_DETAILS_FOR => Self::DetailsFor,
            #[cfg(feature = "v4_18")]
            ffi::GTK_ACCESSIBLE_RELATION_ERROR_MESSAGE_FOR => Self::ErrorMessageFor,
            #[cfg(feature = "v4_18")]
            ffi::GTK_ACCESSIBLE_RELATION_FLOW_FROM => Self::FlowFrom,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for AccessibleRelation {
    #[inline]
    #[doc(alias = "gtk_accessible_relation_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_accessible_relation_get_type()) }
    }
}

impl glib::HasParamSpec for AccessibleRelation {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for AccessibleRelation {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for AccessibleRelation {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for AccessibleRelation {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<AccessibleRelation> for glib::Value {
    #[inline]
    fn from(v: AccessibleRelation) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// The accessible role for a [`Accessible`][crate::Accessible] implementation.
///
/// Abstract roles are only used as part of the ontology; application
/// developers must not use abstract roles in their code.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkAccessibleRole")]
pub enum AccessibleRole {
    /// An element with important, and usually
    ///   time-sensitive, information
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_ALERT")]
    Alert,
    /// A type of dialog that contains an
    ///   alert message
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_ALERT_DIALOG")]
    AlertDialog,
    /// Unused
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_BANNER")]
    Banner,
    /// An input element that allows for
    ///   user-triggered actions when clicked or pressed
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_BUTTON")]
    Button,
    /// Unused
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_CAPTION")]
    Caption,
    /// Unused
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_CELL")]
    Cell,
    /// A checkable input element that has
    ///   three possible values: `true`, `false`, or `mixed`
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_CHECKBOX")]
    Checkbox,
    /// A header in a columned list.
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_COLUMN_HEADER")]
    ColumnHeader,
    /// An input that controls another element,
    ///   such as a list or a grid, that can dynamically pop up to help the user
    ///   set the value of the input
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_COMBO_BOX")]
    ComboBox,
    /// Abstract role.
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_COMMAND")]
    Command,
    /// Abstract role.
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_COMPOSITE")]
    Composite,
    /// A dialog is a window that is designed to interrupt
    ///   the current processing of an application in order to prompt the user to enter
    ///   information or require a response.
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_DIALOG")]
    Dialog,
    /// Content that assistive technology users may want to
    ///   browse in a reading mode.
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_DOCUMENT")]
    Document,
    /// Unused
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_FEED")]
    Feed,
    /// Unused
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_FORM")]
    Form,
    /// A nameless container that has no semantic meaning
    ///   of its own. This is the role that GTK uses by default for widgets.
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_GENERIC")]
    Generic,
    /// A grid of items.
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_GRID")]
    Grid,
    /// An item in a grid or tree grid.
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_GRID_CELL")]
    GridCell,
    /// An element that groups multiple related widgets. GTK uses
    ///   this role for various containers, like [`HeaderBar`][crate::HeaderBar] or [`Notebook`][crate::Notebook].
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_GROUP")]
    Group,
    /// Unused
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_HEADING")]
    Heading,
    /// An image.
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_IMG")]
    Img,
    /// Abstract role.
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_INPUT")]
    Input,
    /// A visible name or caption for a user interface component.
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_LABEL")]
    Label,
    /// Abstract role.
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_LANDMARK")]
    Landmark,
    /// Unused
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_LEGEND")]
    Legend,
    /// A clickable link.
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_LINK")]
    Link,
    /// A list of items.
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_LIST")]
    List,
    /// Unused.
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_LIST_BOX")]
    ListBox,
    /// An item in a list.
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_LIST_ITEM")]
    ListItem,
    /// Unused
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_LOG")]
    Log,
    /// Unused
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_MAIN")]
    Main,
    /// Unused
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_MARQUEE")]
    Marquee,
    /// Unused
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_MATH")]
    Math,
    /// An element that represents a value within a known range.
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_METER")]
    Meter,
    /// A menu.
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_MENU")]
    Menu,
    /// A menubar.
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_MENU_BAR")]
    MenuBar,
    /// An item in a menu.
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_MENU_ITEM")]
    MenuItem,
    /// A check item in a menu.
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_MENU_ITEM_CHECKBOX")]
    MenuItemCheckbox,
    /// A radio item in a menu.
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_MENU_ITEM_RADIO")]
    MenuItemRadio,
    /// Unused
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_NAVIGATION")]
    Navigation,
    /// An element that is not represented to accessibility technologies.
    ///   This role is synonymous to @GTK_ACCESSIBLE_ROLE_PRESENTATION.
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_NONE")]
    None,
    /// Unused
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_NOTE")]
    Note,
    /// Unused
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_OPTION")]
    Option,
    /// An element that is not represented to accessibility technologies.
    ///   This role is synonymous to @GTK_ACCESSIBLE_ROLE_NONE.
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_PRESENTATION")]
    Presentation,
    /// An element that displays the progress
    ///   status for tasks that take a long time.
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_PROGRESS_BAR")]
    ProgressBar,
    /// A checkable input in a group of radio roles,
    ///   only one of which can be checked at a time.
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_RADIO")]
    Radio,
    /// Unused
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_RADIO_GROUP")]
    RadioGroup,
    /// Abstract role.
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_RANGE")]
    Range,
    /// Unused
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_REGION")]
    Region,
    /// A row in a columned list.
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_ROW")]
    Row,
    /// Unused
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_ROW_GROUP")]
    RowGroup,
    /// Unused
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_ROW_HEADER")]
    RowHeader,
    /// A graphical object that controls the scrolling
    ///   of content within a viewing area, regardless of whether the content is fully
    ///   displayed within the viewing area.
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_SCROLLBAR")]
    Scrollbar,
    /// Unused
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_SEARCH")]
    Search,
    /// A type of textbox intended for specifying
    ///   search criteria.
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_SEARCH_BOX")]
    SearchBox,
    /// Abstract role.
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_SECTION")]
    Section,
    /// Abstract role.
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_SECTION_HEAD")]
    SectionHead,
    /// Abstract role.
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_SELECT")]
    Select,
    /// A divider that separates and distinguishes
    ///   sections of content or groups of menuitems.
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_SEPARATOR")]
    Separator,
    /// A user input where the user selects a value
    ///   from within a given range.
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_SLIDER")]
    Slider,
    /// A form of range that expects the user to
    ///   select from among discrete choices.
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_SPIN_BUTTON")]
    SpinButton,
    /// Unused
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_STATUS")]
    Status,
    /// Abstract role.
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_STRUCTURE")]
    Structure,
    /// A type of checkbox that represents on/off values,
    ///   as opposed to checked/unchecked values.
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_SWITCH")]
    Switch,
    /// An item in a list of tab used for switching pages.
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_TAB")]
    Tab,
    /// Unused
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_TABLE")]
    Table,
    /// A list of tabs for switching pages.
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_TAB_LIST")]
    TabList,
    /// A page in a notebook or stack.
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_TAB_PANEL")]
    TabPanel,
    /// A type of input that allows free-form text
    ///   as its value.
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_TEXT_BOX")]
    TextBox,
    /// Unused
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_TIME")]
    Time,
    /// Unused
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_TIMER")]
    Timer,
    /// Unused
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_TOOLBAR")]
    Toolbar,
    /// Unused
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_TOOLTIP")]
    Tooltip,
    /// Unused
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_TREE")]
    Tree,
    /// A treeview-like, columned list.
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_TREE_GRID")]
    TreeGrid,
    /// Unused
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_TREE_ITEM")]
    TreeItem,
    /// Abstract role for interactive components of a
    ///   graphical user interface
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_WIDGET")]
    Widget,
    /// Abstract role for windows.
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_WINDOW")]
    Window,
    /// A type of push button which stays pressed until depressed by a second
    /// activation.
    #[cfg(feature = "v4_10")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_TOGGLE_BUTTON")]
    ToggleButton,
    /// A toplevel element of a graphical user interface.
    ///
    /// This is the role that GTK uses by default for windows.
    #[cfg(feature = "v4_12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_APPLICATION")]
    Application,
    /// A paragraph of content.
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_PARAGRAPH")]
    Paragraph,
    /// A section of content that is quoted from another source.
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_BLOCK_QUOTE")]
    BlockQuote,
    /// A section of a page that consists of a composition that forms an independent
    /// part of a document, page, or site.
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_ARTICLE")]
    Article,
    /// A comment contains content expressing reaction to other content.
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_COMMENT")]
    Comment,
    /// A virtual terminal.
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    #[doc(alias = "GTK_ACCESSIBLE_ROLE_TERMINAL")]
    Terminal,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for AccessibleRole {
    type GlibType = ffi::GtkAccessibleRole;

    fn into_glib(self) -> ffi::GtkAccessibleRole {
        match self {
            Self::Alert => ffi::GTK_ACCESSIBLE_ROLE_ALERT,
            Self::AlertDialog => ffi::GTK_ACCESSIBLE_ROLE_ALERT_DIALOG,
            Self::Banner => ffi::GTK_ACCESSIBLE_ROLE_BANNER,
            Self::Button => ffi::GTK_ACCESSIBLE_ROLE_BUTTON,
            Self::Caption => ffi::GTK_ACCESSIBLE_ROLE_CAPTION,
            Self::Cell => ffi::GTK_ACCESSIBLE_ROLE_CELL,
            Self::Checkbox => ffi::GTK_ACCESSIBLE_ROLE_CHECKBOX,
            Self::ColumnHeader => ffi::GTK_ACCESSIBLE_ROLE_COLUMN_HEADER,
            Self::ComboBox => ffi::GTK_ACCESSIBLE_ROLE_COMBO_BOX,
            Self::Command => ffi::GTK_ACCESSIBLE_ROLE_COMMAND,
            Self::Composite => ffi::GTK_ACCESSIBLE_ROLE_COMPOSITE,
            Self::Dialog => ffi::GTK_ACCESSIBLE_ROLE_DIALOG,
            Self::Document => ffi::GTK_ACCESSIBLE_ROLE_DOCUMENT,
            Self::Feed => ffi::GTK_ACCESSIBLE_ROLE_FEED,
            Self::Form => ffi::GTK_ACCESSIBLE_ROLE_FORM,
            Self::Generic => ffi::GTK_ACCESSIBLE_ROLE_GENERIC,
            Self::Grid => ffi::GTK_ACCESSIBLE_ROLE_GRID,
            Self::GridCell => ffi::GTK_ACCESSIBLE_ROLE_GRID_CELL,
            Self::Group => ffi::GTK_ACCESSIBLE_ROLE_GROUP,
            Self::Heading => ffi::GTK_ACCESSIBLE_ROLE_HEADING,
            Self::Img => ffi::GTK_ACCESSIBLE_ROLE_IMG,
            Self::Input => ffi::GTK_ACCESSIBLE_ROLE_INPUT,
            Self::Label => ffi::GTK_ACCESSIBLE_ROLE_LABEL,
            Self::Landmark => ffi::GTK_ACCESSIBLE_ROLE_LANDMARK,
            Self::Legend => ffi::GTK_ACCESSIBLE_ROLE_LEGEND,
            Self::Link => ffi::GTK_ACCESSIBLE_ROLE_LINK,
            Self::List => ffi::GTK_ACCESSIBLE_ROLE_LIST,
            Self::ListBox => ffi::GTK_ACCESSIBLE_ROLE_LIST_BOX,
            Self::ListItem => ffi::GTK_ACCESSIBLE_ROLE_LIST_ITEM,
            Self::Log => ffi::GTK_ACCESSIBLE_ROLE_LOG,
            Self::Main => ffi::GTK_ACCESSIBLE_ROLE_MAIN,
            Self::Marquee => ffi::GTK_ACCESSIBLE_ROLE_MARQUEE,
            Self::Math => ffi::GTK_ACCESSIBLE_ROLE_MATH,
            Self::Meter => ffi::GTK_ACCESSIBLE_ROLE_METER,
            Self::Menu => ffi::GTK_ACCESSIBLE_ROLE_MENU,
            Self::MenuBar => ffi::GTK_ACCESSIBLE_ROLE_MENU_BAR,
            Self::MenuItem => ffi::GTK_ACCESSIBLE_ROLE_MENU_ITEM,
            Self::MenuItemCheckbox => ffi::GTK_ACCESSIBLE_ROLE_MENU_ITEM_CHECKBOX,
            Self::MenuItemRadio => ffi::GTK_ACCESSIBLE_ROLE_MENU_ITEM_RADIO,
            Self::Navigation => ffi::GTK_ACCESSIBLE_ROLE_NAVIGATION,
            Self::None => ffi::GTK_ACCESSIBLE_ROLE_NONE,
            Self::Note => ffi::GTK_ACCESSIBLE_ROLE_NOTE,
            Self::Option => ffi::GTK_ACCESSIBLE_ROLE_OPTION,
            Self::Presentation => ffi::GTK_ACCESSIBLE_ROLE_PRESENTATION,
            Self::ProgressBar => ffi::GTK_ACCESSIBLE_ROLE_PROGRESS_BAR,
            Self::Radio => ffi::GTK_ACCESSIBLE_ROLE_RADIO,
            Self::RadioGroup => ffi::GTK_ACCESSIBLE_ROLE_RADIO_GROUP,
            Self::Range => ffi::GTK_ACCESSIBLE_ROLE_RANGE,
            Self::Region => ffi::GTK_ACCESSIBLE_ROLE_REGION,
            Self::Row => ffi::GTK_ACCESSIBLE_ROLE_ROW,
            Self::RowGroup => ffi::GTK_ACCESSIBLE_ROLE_ROW_GROUP,
            Self::RowHeader => ffi::GTK_ACCESSIBLE_ROLE_ROW_HEADER,
            Self::Scrollbar => ffi::GTK_ACCESSIBLE_ROLE_SCROLLBAR,
            Self::Search => ffi::GTK_ACCESSIBLE_ROLE_SEARCH,
            Self::SearchBox => ffi::GTK_ACCESSIBLE_ROLE_SEARCH_BOX,
            Self::Section => ffi::GTK_ACCESSIBLE_ROLE_SECTION,
            Self::SectionHead => ffi::GTK_ACCESSIBLE_ROLE_SECTION_HEAD,
            Self::Select => ffi::GTK_ACCESSIBLE_ROLE_SELECT,
            Self::Separator => ffi::GTK_ACCESSIBLE_ROLE_SEPARATOR,
            Self::Slider => ffi::GTK_ACCESSIBLE_ROLE_SLIDER,
            Self::SpinButton => ffi::GTK_ACCESSIBLE_ROLE_SPIN_BUTTON,
            Self::Status => ffi::GTK_ACCESSIBLE_ROLE_STATUS,
            Self::Structure => ffi::GTK_ACCESSIBLE_ROLE_STRUCTURE,
            Self::Switch => ffi::GTK_ACCESSIBLE_ROLE_SWITCH,
            Self::Tab => ffi::GTK_ACCESSIBLE_ROLE_TAB,
            Self::Table => ffi::GTK_ACCESSIBLE_ROLE_TABLE,
            Self::TabList => ffi::GTK_ACCESSIBLE_ROLE_TAB_LIST,
            Self::TabPanel => ffi::GTK_ACCESSIBLE_ROLE_TAB_PANEL,
            Self::TextBox => ffi::GTK_ACCESSIBLE_ROLE_TEXT_BOX,
            Self::Time => ffi::GTK_ACCESSIBLE_ROLE_TIME,
            Self::Timer => ffi::GTK_ACCESSIBLE_ROLE_TIMER,
            Self::Toolbar => ffi::GTK_ACCESSIBLE_ROLE_TOOLBAR,
            Self::Tooltip => ffi::GTK_ACCESSIBLE_ROLE_TOOLTIP,
            Self::Tree => ffi::GTK_ACCESSIBLE_ROLE_TREE,
            Self::TreeGrid => ffi::GTK_ACCESSIBLE_ROLE_TREE_GRID,
            Self::TreeItem => ffi::GTK_ACCESSIBLE_ROLE_TREE_ITEM,
            Self::Widget => ffi::GTK_ACCESSIBLE_ROLE_WIDGET,
            Self::Window => ffi::GTK_ACCESSIBLE_ROLE_WINDOW,
            #[cfg(feature = "v4_10")]
            Self::ToggleButton => ffi::GTK_ACCESSIBLE_ROLE_TOGGLE_BUTTON,
            #[cfg(feature = "v4_12")]
            Self::Application => ffi::GTK_ACCESSIBLE_ROLE_APPLICATION,
            #[cfg(feature = "v4_14")]
            Self::Paragraph => ffi::GTK_ACCESSIBLE_ROLE_PARAGRAPH,
            #[cfg(feature = "v4_14")]
            Self::BlockQuote => ffi::GTK_ACCESSIBLE_ROLE_BLOCK_QUOTE,
            #[cfg(feature = "v4_14")]
            Self::Article => ffi::GTK_ACCESSIBLE_ROLE_ARTICLE,
            #[cfg(feature = "v4_14")]
            Self::Comment => ffi::GTK_ACCESSIBLE_ROLE_COMMENT,
            #[cfg(feature = "v4_14")]
            Self::Terminal => ffi::GTK_ACCESSIBLE_ROLE_TERMINAL,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkAccessibleRole> for AccessibleRole {
    unsafe fn from_glib(value: ffi::GtkAccessibleRole) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_ACCESSIBLE_ROLE_ALERT => Self::Alert,
            ffi::GTK_ACCESSIBLE_ROLE_ALERT_DIALOG => Self::AlertDialog,
            ffi::GTK_ACCESSIBLE_ROLE_BANNER => Self::Banner,
            ffi::GTK_ACCESSIBLE_ROLE_BUTTON => Self::Button,
            ffi::GTK_ACCESSIBLE_ROLE_CAPTION => Self::Caption,
            ffi::GTK_ACCESSIBLE_ROLE_CELL => Self::Cell,
            ffi::GTK_ACCESSIBLE_ROLE_CHECKBOX => Self::Checkbox,
            ffi::GTK_ACCESSIBLE_ROLE_COLUMN_HEADER => Self::ColumnHeader,
            ffi::GTK_ACCESSIBLE_ROLE_COMBO_BOX => Self::ComboBox,
            ffi::GTK_ACCESSIBLE_ROLE_COMMAND => Self::Command,
            ffi::GTK_ACCESSIBLE_ROLE_COMPOSITE => Self::Composite,
            ffi::GTK_ACCESSIBLE_ROLE_DIALOG => Self::Dialog,
            ffi::GTK_ACCESSIBLE_ROLE_DOCUMENT => Self::Document,
            ffi::GTK_ACCESSIBLE_ROLE_FEED => Self::Feed,
            ffi::GTK_ACCESSIBLE_ROLE_FORM => Self::Form,
            ffi::GTK_ACCESSIBLE_ROLE_GENERIC => Self::Generic,
            ffi::GTK_ACCESSIBLE_ROLE_GRID => Self::Grid,
            ffi::GTK_ACCESSIBLE_ROLE_GRID_CELL => Self::GridCell,
            ffi::GTK_ACCESSIBLE_ROLE_GROUP => Self::Group,
            ffi::GTK_ACCESSIBLE_ROLE_HEADING => Self::Heading,
            ffi::GTK_ACCESSIBLE_ROLE_IMG => Self::Img,
            ffi::GTK_ACCESSIBLE_ROLE_INPUT => Self::Input,
            ffi::GTK_ACCESSIBLE_ROLE_LABEL => Self::Label,
            ffi::GTK_ACCESSIBLE_ROLE_LANDMARK => Self::Landmark,
            ffi::GTK_ACCESSIBLE_ROLE_LEGEND => Self::Legend,
            ffi::GTK_ACCESSIBLE_ROLE_LINK => Self::Link,
            ffi::GTK_ACCESSIBLE_ROLE_LIST => Self::List,
            ffi::GTK_ACCESSIBLE_ROLE_LIST_BOX => Self::ListBox,
            ffi::GTK_ACCESSIBLE_ROLE_LIST_ITEM => Self::ListItem,
            ffi::GTK_ACCESSIBLE_ROLE_LOG => Self::Log,
            ffi::GTK_ACCESSIBLE_ROLE_MAIN => Self::Main,
            ffi::GTK_ACCESSIBLE_ROLE_MARQUEE => Self::Marquee,
            ffi::GTK_ACCESSIBLE_ROLE_MATH => Self::Math,
            ffi::GTK_ACCESSIBLE_ROLE_METER => Self::Meter,
            ffi::GTK_ACCESSIBLE_ROLE_MENU => Self::Menu,
            ffi::GTK_ACCESSIBLE_ROLE_MENU_BAR => Self::MenuBar,
            ffi::GTK_ACCESSIBLE_ROLE_MENU_ITEM => Self::MenuItem,
            ffi::GTK_ACCESSIBLE_ROLE_MENU_ITEM_CHECKBOX => Self::MenuItemCheckbox,
            ffi::GTK_ACCESSIBLE_ROLE_MENU_ITEM_RADIO => Self::MenuItemRadio,
            ffi::GTK_ACCESSIBLE_ROLE_NAVIGATION => Self::Navigation,
            ffi::GTK_ACCESSIBLE_ROLE_NONE => Self::None,
            ffi::GTK_ACCESSIBLE_ROLE_NOTE => Self::Note,
            ffi::GTK_ACCESSIBLE_ROLE_OPTION => Self::Option,
            ffi::GTK_ACCESSIBLE_ROLE_PRESENTATION => Self::Presentation,
            ffi::GTK_ACCESSIBLE_ROLE_PROGRESS_BAR => Self::ProgressBar,
            ffi::GTK_ACCESSIBLE_ROLE_RADIO => Self::Radio,
            ffi::GTK_ACCESSIBLE_ROLE_RADIO_GROUP => Self::RadioGroup,
            ffi::GTK_ACCESSIBLE_ROLE_RANGE => Self::Range,
            ffi::GTK_ACCESSIBLE_ROLE_REGION => Self::Region,
            ffi::GTK_ACCESSIBLE_ROLE_ROW => Self::Row,
            ffi::GTK_ACCESSIBLE_ROLE_ROW_GROUP => Self::RowGroup,
            ffi::GTK_ACCESSIBLE_ROLE_ROW_HEADER => Self::RowHeader,
            ffi::GTK_ACCESSIBLE_ROLE_SCROLLBAR => Self::Scrollbar,
            ffi::GTK_ACCESSIBLE_ROLE_SEARCH => Self::Search,
            ffi::GTK_ACCESSIBLE_ROLE_SEARCH_BOX => Self::SearchBox,
            ffi::GTK_ACCESSIBLE_ROLE_SECTION => Self::Section,
            ffi::GTK_ACCESSIBLE_ROLE_SECTION_HEAD => Self::SectionHead,
            ffi::GTK_ACCESSIBLE_ROLE_SELECT => Self::Select,
            ffi::GTK_ACCESSIBLE_ROLE_SEPARATOR => Self::Separator,
            ffi::GTK_ACCESSIBLE_ROLE_SLIDER => Self::Slider,
            ffi::GTK_ACCESSIBLE_ROLE_SPIN_BUTTON => Self::SpinButton,
            ffi::GTK_ACCESSIBLE_ROLE_STATUS => Self::Status,
            ffi::GTK_ACCESSIBLE_ROLE_STRUCTURE => Self::Structure,
            ffi::GTK_ACCESSIBLE_ROLE_SWITCH => Self::Switch,
            ffi::GTK_ACCESSIBLE_ROLE_TAB => Self::Tab,
            ffi::GTK_ACCESSIBLE_ROLE_TABLE => Self::Table,
            ffi::GTK_ACCESSIBLE_ROLE_TAB_LIST => Self::TabList,
            ffi::GTK_ACCESSIBLE_ROLE_TAB_PANEL => Self::TabPanel,
            ffi::GTK_ACCESSIBLE_ROLE_TEXT_BOX => Self::TextBox,
            ffi::GTK_ACCESSIBLE_ROLE_TIME => Self::Time,
            ffi::GTK_ACCESSIBLE_ROLE_TIMER => Self::Timer,
            ffi::GTK_ACCESSIBLE_ROLE_TOOLBAR => Self::Toolbar,
            ffi::GTK_ACCESSIBLE_ROLE_TOOLTIP => Self::Tooltip,
            ffi::GTK_ACCESSIBLE_ROLE_TREE => Self::Tree,
            ffi::GTK_ACCESSIBLE_ROLE_TREE_GRID => Self::TreeGrid,
            ffi::GTK_ACCESSIBLE_ROLE_TREE_ITEM => Self::TreeItem,
            ffi::GTK_ACCESSIBLE_ROLE_WIDGET => Self::Widget,
            ffi::GTK_ACCESSIBLE_ROLE_WINDOW => Self::Window,
            #[cfg(feature = "v4_10")]
            ffi::GTK_ACCESSIBLE_ROLE_TOGGLE_BUTTON => Self::ToggleButton,
            #[cfg(feature = "v4_12")]
            ffi::GTK_ACCESSIBLE_ROLE_APPLICATION => Self::Application,
            #[cfg(feature = "v4_14")]
            ffi::GTK_ACCESSIBLE_ROLE_PARAGRAPH => Self::Paragraph,
            #[cfg(feature = "v4_14")]
            ffi::GTK_ACCESSIBLE_ROLE_BLOCK_QUOTE => Self::BlockQuote,
            #[cfg(feature = "v4_14")]
            ffi::GTK_ACCESSIBLE_ROLE_ARTICLE => Self::Article,
            #[cfg(feature = "v4_14")]
            ffi::GTK_ACCESSIBLE_ROLE_COMMENT => Self::Comment,
            #[cfg(feature = "v4_14")]
            ffi::GTK_ACCESSIBLE_ROLE_TERMINAL => Self::Terminal,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for AccessibleRole {
    #[inline]
    #[doc(alias = "gtk_accessible_role_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_accessible_role_get_type()) }
    }
}

impl glib::HasParamSpec for AccessibleRole {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for AccessibleRole {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for AccessibleRole {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for AccessibleRole {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<AccessibleRole> for glib::Value {
    #[inline]
    fn from(v: AccessibleRole) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// The possible values for the [`AccessibleProperty::Sort`][crate::AccessibleProperty::Sort]
/// accessible property.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkAccessibleSort")]
pub enum AccessibleSort {
    /// There is no defined sort applied to the column.
    #[doc(alias = "GTK_ACCESSIBLE_SORT_NONE")]
    None,
    /// Items are sorted in ascending order by this column.
    #[doc(alias = "GTK_ACCESSIBLE_SORT_ASCENDING")]
    Ascending,
    /// Items are sorted in descending order by this column.
    #[doc(alias = "GTK_ACCESSIBLE_SORT_DESCENDING")]
    Descending,
    /// A sort algorithm other than ascending or
    ///    descending has been applied.
    #[doc(alias = "GTK_ACCESSIBLE_SORT_OTHER")]
    Other,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for AccessibleSort {
    type GlibType = ffi::GtkAccessibleSort;

    #[inline]
    fn into_glib(self) -> ffi::GtkAccessibleSort {
        match self {
            Self::None => ffi::GTK_ACCESSIBLE_SORT_NONE,
            Self::Ascending => ffi::GTK_ACCESSIBLE_SORT_ASCENDING,
            Self::Descending => ffi::GTK_ACCESSIBLE_SORT_DESCENDING,
            Self::Other => ffi::GTK_ACCESSIBLE_SORT_OTHER,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkAccessibleSort> for AccessibleSort {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkAccessibleSort) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_ACCESSIBLE_SORT_NONE => Self::None,
            ffi::GTK_ACCESSIBLE_SORT_ASCENDING => Self::Ascending,
            ffi::GTK_ACCESSIBLE_SORT_DESCENDING => Self::Descending,
            ffi::GTK_ACCESSIBLE_SORT_OTHER => Self::Other,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for AccessibleSort {
    #[inline]
    #[doc(alias = "gtk_accessible_sort_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_accessible_sort_get_type()) }
    }
}

impl glib::HasParamSpec for AccessibleSort {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for AccessibleSort {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for AccessibleSort {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for AccessibleSort {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<AccessibleSort> for glib::Value {
    #[inline]
    fn from(v: AccessibleSort) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// The possible accessible states of a [`Accessible`][crate::Accessible].
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkAccessibleState")]
pub enum AccessibleState {
    /// A “busy” state. This state has boolean values
    #[doc(alias = "GTK_ACCESSIBLE_STATE_BUSY")]
    Busy,
    /// A “checked” state; indicates the current
    ///   state of a [`CheckButton`][crate::CheckButton]. Value type: [`AccessibleTristate`][crate::AccessibleTristate]
    #[doc(alias = "GTK_ACCESSIBLE_STATE_CHECKED")]
    Checked,
    /// A “disabled” state; corresponds to the
    ///   [`sensitive`][struct@crate::Widget#sensitive] property. It indicates a UI element
    ///   that is perceivable, but not editable or operable. Value type: boolean
    #[doc(alias = "GTK_ACCESSIBLE_STATE_DISABLED")]
    Disabled,
    /// An “expanded” state; corresponds to the
    ///   [`expanded`][struct@crate::Expander#expanded] property. Value type: boolean
    ///   or undefined
    #[doc(alias = "GTK_ACCESSIBLE_STATE_EXPANDED")]
    Expanded,
    /// A “hidden” state; corresponds to the
    ///   [`visible`][struct@crate::Widget#visible] property. You can use this state
    ///   explicitly on UI elements that should not be exposed to an assistive
    ///   technology. Value type: boolean
    ///   See also: [`Disabled`][Self::Disabled]
    #[doc(alias = "GTK_ACCESSIBLE_STATE_HIDDEN")]
    Hidden,
    /// An “invalid” state; set when a widget
    ///   is showing an error. Value type: [`AccessibleInvalidState`][crate::AccessibleInvalidState]
    #[doc(alias = "GTK_ACCESSIBLE_STATE_INVALID")]
    Invalid,
    /// A “pressed” state; indicates the current
    ///   state of a [`ToggleButton`][crate::ToggleButton]. Value type: [`AccessibleTristate`][crate::AccessibleTristate]
    ///   enumeration
    #[doc(alias = "GTK_ACCESSIBLE_STATE_PRESSED")]
    Pressed,
    /// A “selected” state; set when a widget
    ///   is selected. Value type: boolean or undefined
    #[doc(alias = "GTK_ACCESSIBLE_STATE_SELECTED")]
    Selected,
    /// Indicates that a widget with the GTK_ACCESSIBLE_ROLE_LINK has been visited.
    /// Value type: boolean.
    #[cfg(feature = "v4_12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
    #[doc(alias = "GTK_ACCESSIBLE_STATE_VISITED")]
    Visited,
    #[doc(hidden)]
    __Unknown(i32),
}

impl AccessibleState {
    #[doc(alias = "gtk_accessible_state_init_value")]
    pub fn init_value(self, value: &mut glib::Value) {
        assert_initialized_main_thread!();
        unsafe {
            ffi::gtk_accessible_state_init_value(self.into_glib(), value.to_glib_none_mut().0);
        }
    }
}

#[doc(hidden)]
impl IntoGlib for AccessibleState {
    type GlibType = ffi::GtkAccessibleState;

    #[inline]
    fn into_glib(self) -> ffi::GtkAccessibleState {
        match self {
            Self::Busy => ffi::GTK_ACCESSIBLE_STATE_BUSY,
            Self::Checked => ffi::GTK_ACCESSIBLE_STATE_CHECKED,
            Self::Disabled => ffi::GTK_ACCESSIBLE_STATE_DISABLED,
            Self::Expanded => ffi::GTK_ACCESSIBLE_STATE_EXPANDED,
            Self::Hidden => ffi::GTK_ACCESSIBLE_STATE_HIDDEN,
            Self::Invalid => ffi::GTK_ACCESSIBLE_STATE_INVALID,
            Self::Pressed => ffi::GTK_ACCESSIBLE_STATE_PRESSED,
            Self::Selected => ffi::GTK_ACCESSIBLE_STATE_SELECTED,
            #[cfg(feature = "v4_12")]
            Self::Visited => ffi::GTK_ACCESSIBLE_STATE_VISITED,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkAccessibleState> for AccessibleState {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkAccessibleState) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_ACCESSIBLE_STATE_BUSY => Self::Busy,
            ffi::GTK_ACCESSIBLE_STATE_CHECKED => Self::Checked,
            ffi::GTK_ACCESSIBLE_STATE_DISABLED => Self::Disabled,
            ffi::GTK_ACCESSIBLE_STATE_EXPANDED => Self::Expanded,
            ffi::GTK_ACCESSIBLE_STATE_HIDDEN => Self::Hidden,
            ffi::GTK_ACCESSIBLE_STATE_INVALID => Self::Invalid,
            ffi::GTK_ACCESSIBLE_STATE_PRESSED => Self::Pressed,
            ffi::GTK_ACCESSIBLE_STATE_SELECTED => Self::Selected,
            #[cfg(feature = "v4_12")]
            ffi::GTK_ACCESSIBLE_STATE_VISITED => Self::Visited,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for AccessibleState {
    #[inline]
    #[doc(alias = "gtk_accessible_state_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_accessible_state_get_type()) }
    }
}

impl glib::HasParamSpec for AccessibleState {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for AccessibleState {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for AccessibleState {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for AccessibleState {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<AccessibleState> for glib::Value {
    #[inline]
    fn from(v: AccessibleState) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// The type of contents change operation.
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkAccessibleTextContentChange")]
pub enum AccessibleTextContentChange {
    /// contents change as the result of
    ///   an insert operation
    #[doc(alias = "GTK_ACCESSIBLE_TEXT_CONTENT_CHANGE_INSERT")]
    Insert,
    /// contents change as the result of
    ///   a remove operation
    #[doc(alias = "GTK_ACCESSIBLE_TEXT_CONTENT_CHANGE_REMOVE")]
    Remove,
    #[doc(hidden)]
    __Unknown(i32),
}

#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
#[doc(hidden)]
impl IntoGlib for AccessibleTextContentChange {
    type GlibType = ffi::GtkAccessibleTextContentChange;

    #[inline]
    fn into_glib(self) -> ffi::GtkAccessibleTextContentChange {
        match self {
            Self::Insert => ffi::GTK_ACCESSIBLE_TEXT_CONTENT_CHANGE_INSERT,
            Self::Remove => ffi::GTK_ACCESSIBLE_TEXT_CONTENT_CHANGE_REMOVE,
            Self::__Unknown(value) => value,
        }
    }
}

#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
#[doc(hidden)]
impl FromGlib<ffi::GtkAccessibleTextContentChange> for AccessibleTextContentChange {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkAccessibleTextContentChange) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_ACCESSIBLE_TEXT_CONTENT_CHANGE_INSERT => Self::Insert,
            ffi::GTK_ACCESSIBLE_TEXT_CONTENT_CHANGE_REMOVE => Self::Remove,
            value => Self::__Unknown(value),
        }
    }
}

#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
impl StaticType for AccessibleTextContentChange {
    #[inline]
    #[doc(alias = "gtk_accessible_text_content_change_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_accessible_text_content_change_get_type()) }
    }
}

#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
impl glib::HasParamSpec for AccessibleTextContentChange {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
impl glib::value::ValueType for AccessibleTextContentChange {
    type Type = Self;
}

#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
unsafe impl<'a> glib::value::FromValue<'a> for AccessibleTextContentChange {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
impl ToValue for AccessibleTextContentChange {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
impl From<AccessibleTextContentChange> for glib::Value {
    #[inline]
    fn from(v: AccessibleTextContentChange) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// The granularity for queries about the text contents of a [`AccessibleText`][crate::AccessibleText]
/// implementation.
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkAccessibleTextGranularity")]
pub enum AccessibleTextGranularity {
    /// Use the boundary between
    ///   characters (including non-printing characters)
    #[doc(alias = "GTK_ACCESSIBLE_TEXT_GRANULARITY_CHARACTER")]
    Character,
    /// Use the boundary between words,
    ///   starting from the beginning of the current word and ending at the
    ///   beginning of the next word
    #[doc(alias = "GTK_ACCESSIBLE_TEXT_GRANULARITY_WORD")]
    Word,
    /// Use the boundary between
    ///   sentences, starting from the beginning of the current sentence and
    ///   ending at the beginning of the next sentence
    #[doc(alias = "GTK_ACCESSIBLE_TEXT_GRANULARITY_SENTENCE")]
    Sentence,
    /// Use the boundary between lines,
    ///   starting from the beginning of the current line and ending at the
    ///   beginning of the next line
    #[doc(alias = "GTK_ACCESSIBLE_TEXT_GRANULARITY_LINE")]
    Line,
    /// Use the boundary between
    ///   paragraphs, starting from the beginning of the current paragraph and
    ///   ending at the beginning of the next paragraph
    #[doc(alias = "GTK_ACCESSIBLE_TEXT_GRANULARITY_PARAGRAPH")]
    Paragraph,
    #[doc(hidden)]
    __Unknown(i32),
}

#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
#[doc(hidden)]
impl IntoGlib for AccessibleTextGranularity {
    type GlibType = ffi::GtkAccessibleTextGranularity;

    #[inline]
    fn into_glib(self) -> ffi::GtkAccessibleTextGranularity {
        match self {
            Self::Character => ffi::GTK_ACCESSIBLE_TEXT_GRANULARITY_CHARACTER,
            Self::Word => ffi::GTK_ACCESSIBLE_TEXT_GRANULARITY_WORD,
            Self::Sentence => ffi::GTK_ACCESSIBLE_TEXT_GRANULARITY_SENTENCE,
            Self::Line => ffi::GTK_ACCESSIBLE_TEXT_GRANULARITY_LINE,
            Self::Paragraph => ffi::GTK_ACCESSIBLE_TEXT_GRANULARITY_PARAGRAPH,
            Self::__Unknown(value) => value,
        }
    }
}

#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
#[doc(hidden)]
impl FromGlib<ffi::GtkAccessibleTextGranularity> for AccessibleTextGranularity {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkAccessibleTextGranularity) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_ACCESSIBLE_TEXT_GRANULARITY_CHARACTER => Self::Character,
            ffi::GTK_ACCESSIBLE_TEXT_GRANULARITY_WORD => Self::Word,
            ffi::GTK_ACCESSIBLE_TEXT_GRANULARITY_SENTENCE => Self::Sentence,
            ffi::GTK_ACCESSIBLE_TEXT_GRANULARITY_LINE => Self::Line,
            ffi::GTK_ACCESSIBLE_TEXT_GRANULARITY_PARAGRAPH => Self::Paragraph,
            value => Self::__Unknown(value),
        }
    }
}

#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
impl StaticType for AccessibleTextGranularity {
    #[inline]
    #[doc(alias = "gtk_accessible_text_granularity_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_accessible_text_granularity_get_type()) }
    }
}

#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
impl glib::HasParamSpec for AccessibleTextGranularity {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
impl glib::value::ValueType for AccessibleTextGranularity {
    type Type = Self;
}

#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
unsafe impl<'a> glib::value::FromValue<'a> for AccessibleTextGranularity {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
impl ToValue for AccessibleTextGranularity {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
impl From<AccessibleTextGranularity> for glib::Value {
    #[inline]
    fn from(v: AccessibleTextGranularity) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// The possible values for the [`AccessibleState::Pressed`][crate::AccessibleState::Pressed]
/// accessible state.
///
/// Note that the [`False`][Self::False] and
/// [`True`][Self::True] have the same values
/// as [`false`] and [`true`].
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkAccessibleTristate")]
pub enum AccessibleTristate {
    /// The state is `false`
    #[doc(alias = "GTK_ACCESSIBLE_TRISTATE_FALSE")]
    False,
    /// The state is `true`
    #[doc(alias = "GTK_ACCESSIBLE_TRISTATE_TRUE")]
    True,
    /// The state is `mixed`
    #[doc(alias = "GTK_ACCESSIBLE_TRISTATE_MIXED")]
    Mixed,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for AccessibleTristate {
    type GlibType = ffi::GtkAccessibleTristate;

    #[inline]
    fn into_glib(self) -> ffi::GtkAccessibleTristate {
        match self {
            Self::False => ffi::GTK_ACCESSIBLE_TRISTATE_FALSE,
            Self::True => ffi::GTK_ACCESSIBLE_TRISTATE_TRUE,
            Self::Mixed => ffi::GTK_ACCESSIBLE_TRISTATE_MIXED,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkAccessibleTristate> for AccessibleTristate {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkAccessibleTristate) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_ACCESSIBLE_TRISTATE_FALSE => Self::False,
            ffi::GTK_ACCESSIBLE_TRISTATE_TRUE => Self::True,
            ffi::GTK_ACCESSIBLE_TRISTATE_MIXED => Self::Mixed,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for AccessibleTristate {
    #[inline]
    #[doc(alias = "gtk_accessible_tristate_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_accessible_tristate_get_type()) }
    }
}

impl glib::HasParamSpec for AccessibleTristate {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for AccessibleTristate {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for AccessibleTristate {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for AccessibleTristate {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<AccessibleTristate> for glib::Value {
    #[inline]
    fn from(v: AccessibleTristate) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Indicates the direction in which an arrow should point.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkArrowType")]
pub enum ArrowType {
    /// Represents an upward pointing arrow.
    #[doc(alias = "GTK_ARROW_UP")]
    Up,
    /// Represents a downward pointing arrow.
    #[doc(alias = "GTK_ARROW_DOWN")]
    Down,
    /// Represents a left pointing arrow.
    #[doc(alias = "GTK_ARROW_LEFT")]
    Left,
    /// Represents a right pointing arrow.
    #[doc(alias = "GTK_ARROW_RIGHT")]
    Right,
    /// No arrow.
    #[doc(alias = "GTK_ARROW_NONE")]
    None,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for ArrowType {
    type GlibType = ffi::GtkArrowType;

    #[inline]
    fn into_glib(self) -> ffi::GtkArrowType {
        match self {
            Self::Up => ffi::GTK_ARROW_UP,
            Self::Down => ffi::GTK_ARROW_DOWN,
            Self::Left => ffi::GTK_ARROW_LEFT,
            Self::Right => ffi::GTK_ARROW_RIGHT,
            Self::None => ffi::GTK_ARROW_NONE,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkArrowType> for ArrowType {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkArrowType) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_ARROW_UP => Self::Up,
            ffi::GTK_ARROW_DOWN => Self::Down,
            ffi::GTK_ARROW_LEFT => Self::Left,
            ffi::GTK_ARROW_RIGHT => Self::Right,
            ffi::GTK_ARROW_NONE => Self::None,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for ArrowType {
    #[inline]
    #[doc(alias = "gtk_arrow_type_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_arrow_type_get_type()) }
    }
}

impl glib::HasParamSpec for ArrowType {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for ArrowType {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for ArrowType {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for ArrowType {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<ArrowType> for glib::Value {
    #[inline]
    fn from(v: ArrowType) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Determines the role of a page inside a [`Assistant`][crate::Assistant].
///
/// The role is used to handle buttons sensitivity and visibility.
///
/// Note that an assistant needs to end its page flow with a page of type
/// [`Confirm`][Self::Confirm], [`Summary`][Self::Summary] or
/// [`Progress`][Self::Progress] to be correct.
///
/// The Cancel button will only be shown if the page isn’t “committed”.
/// See gtk_assistant_commit() for details.
///
/// # Deprecated since 4.10
///
/// [`Assistant`][crate::Assistant] will be removed in GTK 5
#[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkAssistantPageType")]
pub enum AssistantPageType {
    /// The page has regular contents. Both the
    ///  Back and forward buttons will be shown.
    #[doc(alias = "GTK_ASSISTANT_PAGE_CONTENT")]
    Content,
    /// The page contains an introduction to the
    ///  assistant task. Only the Forward button will be shown if there is a
    ///   next page.
    #[doc(alias = "GTK_ASSISTANT_PAGE_INTRO")]
    Intro,
    /// The page lets the user confirm or deny the
    ///  changes. The Back and Apply buttons will be shown.
    #[doc(alias = "GTK_ASSISTANT_PAGE_CONFIRM")]
    Confirm,
    /// The page informs the user of the changes
    ///  done. Only the Close button will be shown.
    #[doc(alias = "GTK_ASSISTANT_PAGE_SUMMARY")]
    Summary,
    /// Used for tasks that take a long time to
    ///  complete, blocks the assistant until the page is marked as complete.
    ///   Only the back button will be shown.
    #[doc(alias = "GTK_ASSISTANT_PAGE_PROGRESS")]
    Progress,
    /// Used for when other page types are not
    ///  appropriate. No buttons will be shown, and the application must
    ///  add its own buttons through gtk_assistant_add_action_widget().
    #[doc(alias = "GTK_ASSISTANT_PAGE_CUSTOM")]
    Custom,
    #[doc(hidden)]
    __Unknown(i32),
}

#[allow(deprecated)]
#[doc(hidden)]
impl IntoGlib for AssistantPageType {
    type GlibType = ffi::GtkAssistantPageType;

    #[inline]
    fn into_glib(self) -> ffi::GtkAssistantPageType {
        match self {
            Self::Content => ffi::GTK_ASSISTANT_PAGE_CONTENT,
            Self::Intro => ffi::GTK_ASSISTANT_PAGE_INTRO,
            Self::Confirm => ffi::GTK_ASSISTANT_PAGE_CONFIRM,
            Self::Summary => ffi::GTK_ASSISTANT_PAGE_SUMMARY,
            Self::Progress => ffi::GTK_ASSISTANT_PAGE_PROGRESS,
            Self::Custom => ffi::GTK_ASSISTANT_PAGE_CUSTOM,
            Self::__Unknown(value) => value,
        }
    }
}

#[allow(deprecated)]
#[doc(hidden)]
impl FromGlib<ffi::GtkAssistantPageType> for AssistantPageType {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkAssistantPageType) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_ASSISTANT_PAGE_CONTENT => Self::Content,
            ffi::GTK_ASSISTANT_PAGE_INTRO => Self::Intro,
            ffi::GTK_ASSISTANT_PAGE_CONFIRM => Self::Confirm,
            ffi::GTK_ASSISTANT_PAGE_SUMMARY => Self::Summary,
            ffi::GTK_ASSISTANT_PAGE_PROGRESS => Self::Progress,
            ffi::GTK_ASSISTANT_PAGE_CUSTOM => Self::Custom,
            value => Self::__Unknown(value),
        }
    }
}

#[allow(deprecated)]
impl StaticType for AssistantPageType {
    #[inline]
    #[doc(alias = "gtk_assistant_page_type_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_assistant_page_type_get_type()) }
    }
}

#[allow(deprecated)]
impl glib::HasParamSpec for AssistantPageType {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

#[allow(deprecated)]
impl glib::value::ValueType for AssistantPageType {
    type Type = Self;
}

#[allow(deprecated)]
unsafe impl<'a> glib::value::FromValue<'a> for AssistantPageType {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

#[allow(deprecated)]
impl ToValue for AssistantPageType {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

#[allow(deprecated)]
impl From<AssistantPageType> for glib::Value {
    #[inline]
    fn from(v: AssistantPageType) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Baseline position in a row of widgets.
///
/// Whenever a container has some form of natural row it may align
/// children in that row along a common typographical baseline. If
/// the amount of vertical space in the row is taller than the total
/// requested height of the baseline-aligned children then it can use a
/// [`BaselinePosition`][crate::BaselinePosition] to select where to put the baseline inside the
/// extra available space.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkBaselinePosition")]
pub enum BaselinePosition {
    /// Align the baseline at the top
    #[doc(alias = "GTK_BASELINE_POSITION_TOP")]
    Top,
    /// Center the baseline
    #[doc(alias = "GTK_BASELINE_POSITION_CENTER")]
    Center,
    /// Align the baseline at the bottom
    #[doc(alias = "GTK_BASELINE_POSITION_BOTTOM")]
    Bottom,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for BaselinePosition {
    type GlibType = ffi::GtkBaselinePosition;

    #[inline]
    fn into_glib(self) -> ffi::GtkBaselinePosition {
        match self {
            Self::Top => ffi::GTK_BASELINE_POSITION_TOP,
            Self::Center => ffi::GTK_BASELINE_POSITION_CENTER,
            Self::Bottom => ffi::GTK_BASELINE_POSITION_BOTTOM,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkBaselinePosition> for BaselinePosition {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkBaselinePosition) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_BASELINE_POSITION_TOP => Self::Top,
            ffi::GTK_BASELINE_POSITION_CENTER => Self::Center,
            ffi::GTK_BASELINE_POSITION_BOTTOM => Self::Bottom,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for BaselinePosition {
    #[inline]
    #[doc(alias = "gtk_baseline_position_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_baseline_position_get_type()) }
    }
}

impl glib::HasParamSpec for BaselinePosition {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for BaselinePosition {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for BaselinePosition {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for BaselinePosition {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<BaselinePosition> for glib::Value {
    #[inline]
    fn from(v: BaselinePosition) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Describes how the border of a UI element should be rendered.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkBorderStyle")]
pub enum BorderStyle {
    /// No visible border
    #[doc(alias = "GTK_BORDER_STYLE_NONE")]
    None,
    /// Same as [`None`][Self::None]
    #[doc(alias = "GTK_BORDER_STYLE_HIDDEN")]
    Hidden,
    /// A single line segment
    #[doc(alias = "GTK_BORDER_STYLE_SOLID")]
    Solid,
    /// Looks as if the content is sunken into the canvas
    #[doc(alias = "GTK_BORDER_STYLE_INSET")]
    Inset,
    /// Looks as if the content is coming out of the canvas
    #[doc(alias = "GTK_BORDER_STYLE_OUTSET")]
    Outset,
    /// A series of round dots
    #[doc(alias = "GTK_BORDER_STYLE_DOTTED")]
    Dotted,
    /// A series of square-ended dashes
    #[doc(alias = "GTK_BORDER_STYLE_DASHED")]
    Dashed,
    /// Two parallel lines with some space between them
    #[doc(alias = "GTK_BORDER_STYLE_DOUBLE")]
    Double,
    /// Looks as if it were carved in the canvas
    #[doc(alias = "GTK_BORDER_STYLE_GROOVE")]
    Groove,
    /// Looks as if it were coming out of the canvas
    #[doc(alias = "GTK_BORDER_STYLE_RIDGE")]
    Ridge,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for BorderStyle {
    type GlibType = ffi::GtkBorderStyle;

    #[inline]
    fn into_glib(self) -> ffi::GtkBorderStyle {
        match self {
            Self::None => ffi::GTK_BORDER_STYLE_NONE,
            Self::Hidden => ffi::GTK_BORDER_STYLE_HIDDEN,
            Self::Solid => ffi::GTK_BORDER_STYLE_SOLID,
            Self::Inset => ffi::GTK_BORDER_STYLE_INSET,
            Self::Outset => ffi::GTK_BORDER_STYLE_OUTSET,
            Self::Dotted => ffi::GTK_BORDER_STYLE_DOTTED,
            Self::Dashed => ffi::GTK_BORDER_STYLE_DASHED,
            Self::Double => ffi::GTK_BORDER_STYLE_DOUBLE,
            Self::Groove => ffi::GTK_BORDER_STYLE_GROOVE,
            Self::Ridge => ffi::GTK_BORDER_STYLE_RIDGE,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkBorderStyle> for BorderStyle {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkBorderStyle) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_BORDER_STYLE_NONE => Self::None,
            ffi::GTK_BORDER_STYLE_HIDDEN => Self::Hidden,
            ffi::GTK_BORDER_STYLE_SOLID => Self::Solid,
            ffi::GTK_BORDER_STYLE_INSET => Self::Inset,
            ffi::GTK_BORDER_STYLE_OUTSET => Self::Outset,
            ffi::GTK_BORDER_STYLE_DOTTED => Self::Dotted,
            ffi::GTK_BORDER_STYLE_DASHED => Self::Dashed,
            ffi::GTK_BORDER_STYLE_DOUBLE => Self::Double,
            ffi::GTK_BORDER_STYLE_GROOVE => Self::Groove,
            ffi::GTK_BORDER_STYLE_RIDGE => Self::Ridge,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for BorderStyle {
    #[inline]
    #[doc(alias = "gtk_border_style_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_border_style_get_type()) }
    }
}

impl glib::HasParamSpec for BorderStyle {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for BorderStyle {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for BorderStyle {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for BorderStyle {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<BorderStyle> for glib::Value {
    #[inline]
    fn from(v: BorderStyle) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Error codes that identify various errors that can occur while using
/// [`Builder`][crate::Builder].
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkBuilderError")]
pub enum BuilderError {
    /// A type-func attribute didn’t name
    ///  a function that returns a `GType`.
    #[doc(alias = "GTK_BUILDER_ERROR_INVALID_TYPE_FUNCTION")]
    InvalidTypeFunction,
    /// The input contained a tag that [`Builder`][crate::Builder]
    ///  can’t handle.
    #[doc(alias = "GTK_BUILDER_ERROR_UNHANDLED_TAG")]
    UnhandledTag,
    /// An attribute that is required by
    ///  [`Builder`][crate::Builder] was missing.
    #[doc(alias = "GTK_BUILDER_ERROR_MISSING_ATTRIBUTE")]
    MissingAttribute,
    /// [`Builder`][crate::Builder] found an attribute that
    ///  it doesn’t understand.
    #[doc(alias = "GTK_BUILDER_ERROR_INVALID_ATTRIBUTE")]
    InvalidAttribute,
    /// [`Builder`][crate::Builder] found a tag that
    ///  it doesn’t understand.
    #[doc(alias = "GTK_BUILDER_ERROR_INVALID_TAG")]
    InvalidTag,
    /// A required property value was
    ///  missing.
    #[doc(alias = "GTK_BUILDER_ERROR_MISSING_PROPERTY_VALUE")]
    MissingPropertyValue,
    /// [`Builder`][crate::Builder] couldn’t parse
    ///  some attribute value.
    #[doc(alias = "GTK_BUILDER_ERROR_INVALID_VALUE")]
    InvalidValue,
    /// The input file requires a newer version
    ///  of GTK.
    #[doc(alias = "GTK_BUILDER_ERROR_VERSION_MISMATCH")]
    VersionMismatch,
    /// An object id occurred twice.
    #[doc(alias = "GTK_BUILDER_ERROR_DUPLICATE_ID")]
    DuplicateId,
    /// A specified object type is of the same type or
    ///  derived from the type of the composite class being extended with builder XML.
    #[doc(alias = "GTK_BUILDER_ERROR_OBJECT_TYPE_REFUSED")]
    ObjectTypeRefused,
    /// The wrong type was specified in a composite class’s template XML
    #[doc(alias = "GTK_BUILDER_ERROR_TEMPLATE_MISMATCH")]
    TemplateMismatch,
    /// The specified property is unknown for the object class.
    #[doc(alias = "GTK_BUILDER_ERROR_INVALID_PROPERTY")]
    InvalidProperty,
    /// The specified signal is unknown for the object class.
    #[doc(alias = "GTK_BUILDER_ERROR_INVALID_SIGNAL")]
    InvalidSignal,
    /// An object id is unknown.
    #[doc(alias = "GTK_BUILDER_ERROR_INVALID_ID")]
    InvalidId,
    /// A function could not be found. This often happens
    ///   when symbols are set to be kept private. Compiling code with -rdynamic or using the
    ///   `gmodule-export-2.0` pkgconfig module can fix this problem.
    #[doc(alias = "GTK_BUILDER_ERROR_INVALID_FUNCTION")]
    InvalidFunction,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for BuilderError {
    type GlibType = ffi::GtkBuilderError;

    fn into_glib(self) -> ffi::GtkBuilderError {
        match self {
            Self::InvalidTypeFunction => ffi::GTK_BUILDER_ERROR_INVALID_TYPE_FUNCTION,
            Self::UnhandledTag => ffi::GTK_BUILDER_ERROR_UNHANDLED_TAG,
            Self::MissingAttribute => ffi::GTK_BUILDER_ERROR_MISSING_ATTRIBUTE,
            Self::InvalidAttribute => ffi::GTK_BUILDER_ERROR_INVALID_ATTRIBUTE,
            Self::InvalidTag => ffi::GTK_BUILDER_ERROR_INVALID_TAG,
            Self::MissingPropertyValue => ffi::GTK_BUILDER_ERROR_MISSING_PROPERTY_VALUE,
            Self::InvalidValue => ffi::GTK_BUILDER_ERROR_INVALID_VALUE,
            Self::VersionMismatch => ffi::GTK_BUILDER_ERROR_VERSION_MISMATCH,
            Self::DuplicateId => ffi::GTK_BUILDER_ERROR_DUPLICATE_ID,
            Self::ObjectTypeRefused => ffi::GTK_BUILDER_ERROR_OBJECT_TYPE_REFUSED,
            Self::TemplateMismatch => ffi::GTK_BUILDER_ERROR_TEMPLATE_MISMATCH,
            Self::InvalidProperty => ffi::GTK_BUILDER_ERROR_INVALID_PROPERTY,
            Self::InvalidSignal => ffi::GTK_BUILDER_ERROR_INVALID_SIGNAL,
            Self::InvalidId => ffi::GTK_BUILDER_ERROR_INVALID_ID,
            Self::InvalidFunction => ffi::GTK_BUILDER_ERROR_INVALID_FUNCTION,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkBuilderError> for BuilderError {
    unsafe fn from_glib(value: ffi::GtkBuilderError) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_BUILDER_ERROR_INVALID_TYPE_FUNCTION => Self::InvalidTypeFunction,
            ffi::GTK_BUILDER_ERROR_UNHANDLED_TAG => Self::UnhandledTag,
            ffi::GTK_BUILDER_ERROR_MISSING_ATTRIBUTE => Self::MissingAttribute,
            ffi::GTK_BUILDER_ERROR_INVALID_ATTRIBUTE => Self::InvalidAttribute,
            ffi::GTK_BUILDER_ERROR_INVALID_TAG => Self::InvalidTag,
            ffi::GTK_BUILDER_ERROR_MISSING_PROPERTY_VALUE => Self::MissingPropertyValue,
            ffi::GTK_BUILDER_ERROR_INVALID_VALUE => Self::InvalidValue,
            ffi::GTK_BUILDER_ERROR_VERSION_MISMATCH => Self::VersionMismatch,
            ffi::GTK_BUILDER_ERROR_DUPLICATE_ID => Self::DuplicateId,
            ffi::GTK_BUILDER_ERROR_OBJECT_TYPE_REFUSED => Self::ObjectTypeRefused,
            ffi::GTK_BUILDER_ERROR_TEMPLATE_MISMATCH => Self::TemplateMismatch,
            ffi::GTK_BUILDER_ERROR_INVALID_PROPERTY => Self::InvalidProperty,
            ffi::GTK_BUILDER_ERROR_INVALID_SIGNAL => Self::InvalidSignal,
            ffi::GTK_BUILDER_ERROR_INVALID_ID => Self::InvalidId,
            ffi::GTK_BUILDER_ERROR_INVALID_FUNCTION => Self::InvalidFunction,
            value => Self::__Unknown(value),
        }
    }
}

impl glib::error::ErrorDomain for BuilderError {
    #[inline]
    fn domain() -> glib::Quark {
        skip_assert_initialized!();

        unsafe { from_glib(ffi::gtk_builder_error_quark()) }
    }

    #[inline]
    fn code(self) -> i32 {
        self.into_glib()
    }

    #[inline]
    #[allow(clippy::match_single_binding)]
    fn from(code: i32) -> Option<Self> {
        skip_assert_initialized!();
        match unsafe { from_glib(code) } {
            value => Some(value),
        }
    }
}

impl StaticType for BuilderError {
    #[inline]
    #[doc(alias = "gtk_builder_error_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_builder_error_get_type()) }
    }
}

impl glib::HasParamSpec for BuilderError {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for BuilderError {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for BuilderError {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for BuilderError {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<BuilderError> for glib::Value {
    #[inline]
    fn from(v: BuilderError) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Prebuilt sets of buttons for [`Dialog`][crate::Dialog].
///
/// If none of these choices are appropriate, simply use
/// [`None`][Self::None] and call [`DialogExtManual::add_buttons()`][crate::prelude::DialogExtManual::add_buttons()].
///
/// > Please note that [`Ok`][Self::Ok], [`YesNo`][Self::YesNo]
/// > and [`OkCancel`][Self::OkCancel] are discouraged by the
/// > [GNOME Human Interface Guidelines](https://developer.gnome.org/hig/).
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkButtonsType")]
pub enum ButtonsType {
    /// no buttons at all
    #[doc(alias = "GTK_BUTTONS_NONE")]
    None,
    /// an OK button
    #[doc(alias = "GTK_BUTTONS_OK")]
    Ok,
    /// a Close button
    #[doc(alias = "GTK_BUTTONS_CLOSE")]
    Close,
    /// a Cancel button
    #[doc(alias = "GTK_BUTTONS_CANCEL")]
    Cancel,
    /// Yes and No buttons
    #[doc(alias = "GTK_BUTTONS_YES_NO")]
    YesNo,
    /// OK and Cancel buttons
    #[doc(alias = "GTK_BUTTONS_OK_CANCEL")]
    OkCancel,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for ButtonsType {
    type GlibType = ffi::GtkButtonsType;

    #[inline]
    fn into_glib(self) -> ffi::GtkButtonsType {
        match self {
            Self::None => ffi::GTK_BUTTONS_NONE,
            Self::Ok => ffi::GTK_BUTTONS_OK,
            Self::Close => ffi::GTK_BUTTONS_CLOSE,
            Self::Cancel => ffi::GTK_BUTTONS_CANCEL,
            Self::YesNo => ffi::GTK_BUTTONS_YES_NO,
            Self::OkCancel => ffi::GTK_BUTTONS_OK_CANCEL,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkButtonsType> for ButtonsType {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkButtonsType) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_BUTTONS_NONE => Self::None,
            ffi::GTK_BUTTONS_OK => Self::Ok,
            ffi::GTK_BUTTONS_CLOSE => Self::Close,
            ffi::GTK_BUTTONS_CANCEL => Self::Cancel,
            ffi::GTK_BUTTONS_YES_NO => Self::YesNo,
            ffi::GTK_BUTTONS_OK_CANCEL => Self::OkCancel,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for ButtonsType {
    #[inline]
    #[doc(alias = "gtk_buttons_type_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_buttons_type_get_type()) }
    }
}

impl glib::HasParamSpec for ButtonsType {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for ButtonsType {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for ButtonsType {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for ButtonsType {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<ButtonsType> for glib::Value {
    #[inline]
    fn from(v: ButtonsType) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// The available modes for [`accel-mode`][struct@crate::CellRendererAccel#accel-mode].
///
/// # Deprecated since 4.20
///
/// There is no replacement
#[cfg_attr(feature = "v4_20", deprecated = "Since 4.20")]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkCellRendererAccelMode")]
pub enum CellRendererAccelMode {
    /// GTK accelerators mode
    #[doc(alias = "GTK_CELL_RENDERER_ACCEL_MODE_GTK")]
    Gtk,
    /// Other accelerator mode
    #[doc(alias = "GTK_CELL_RENDERER_ACCEL_MODE_OTHER")]
    Other,
    #[doc(hidden)]
    __Unknown(i32),
}

#[allow(deprecated)]
#[doc(hidden)]
impl IntoGlib for CellRendererAccelMode {
    type GlibType = ffi::GtkCellRendererAccelMode;

    #[inline]
    fn into_glib(self) -> ffi::GtkCellRendererAccelMode {
        match self {
            Self::Gtk => ffi::GTK_CELL_RENDERER_ACCEL_MODE_GTK,
            Self::Other => ffi::GTK_CELL_RENDERER_ACCEL_MODE_OTHER,
            Self::__Unknown(value) => value,
        }
    }
}

#[allow(deprecated)]
#[doc(hidden)]
impl FromGlib<ffi::GtkCellRendererAccelMode> for CellRendererAccelMode {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkCellRendererAccelMode) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_CELL_RENDERER_ACCEL_MODE_GTK => Self::Gtk,
            ffi::GTK_CELL_RENDERER_ACCEL_MODE_OTHER => Self::Other,
            value => Self::__Unknown(value),
        }
    }
}

#[allow(deprecated)]
impl StaticType for CellRendererAccelMode {
    #[inline]
    #[doc(alias = "gtk_cell_renderer_accel_mode_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_cell_renderer_accel_mode_get_type()) }
    }
}

#[allow(deprecated)]
impl glib::HasParamSpec for CellRendererAccelMode {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

#[allow(deprecated)]
impl glib::value::ValueType for CellRendererAccelMode {
    type Type = Self;
}

#[allow(deprecated)]
unsafe impl<'a> glib::value::FromValue<'a> for CellRendererAccelMode {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

#[allow(deprecated)]
impl ToValue for CellRendererAccelMode {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

#[allow(deprecated)]
impl From<CellRendererAccelMode> for glib::Value {
    #[inline]
    fn from(v: CellRendererAccelMode) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Identifies how the user can interact with a particular cell.
///
/// # Deprecated since 4.20
///
/// There is no replacement.
#[cfg_attr(feature = "v4_20", deprecated = "Since 4.20")]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkCellRendererMode")]
pub enum CellRendererMode {
    /// The cell is just for display
    ///  and cannot be interacted with.  Note that this doesn’t mean that eg. the
    ///  row being drawn can’t be selected -- just that a particular element of
    ///  it cannot be individually modified.
    #[doc(alias = "GTK_CELL_RENDERER_MODE_INERT")]
    Inert,
    /// The cell can be clicked.
    #[doc(alias = "GTK_CELL_RENDERER_MODE_ACTIVATABLE")]
    Activatable,
    /// The cell can be edited or otherwise modified.
    #[doc(alias = "GTK_CELL_RENDERER_MODE_EDITABLE")]
    Editable,
    #[doc(hidden)]
    __Unknown(i32),
}

#[allow(deprecated)]
#[doc(hidden)]
impl IntoGlib for CellRendererMode {
    type GlibType = ffi::GtkCellRendererMode;

    #[inline]
    fn into_glib(self) -> ffi::GtkCellRendererMode {
        match self {
            Self::Inert => ffi::GTK_CELL_RENDERER_MODE_INERT,
            Self::Activatable => ffi::GTK_CELL_RENDERER_MODE_ACTIVATABLE,
            Self::Editable => ffi::GTK_CELL_RENDERER_MODE_EDITABLE,
            Self::__Unknown(value) => value,
        }
    }
}

#[allow(deprecated)]
#[doc(hidden)]
impl FromGlib<ffi::GtkCellRendererMode> for CellRendererMode {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkCellRendererMode) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_CELL_RENDERER_MODE_INERT => Self::Inert,
            ffi::GTK_CELL_RENDERER_MODE_ACTIVATABLE => Self::Activatable,
            ffi::GTK_CELL_RENDERER_MODE_EDITABLE => Self::Editable,
            value => Self::__Unknown(value),
        }
    }
}

#[allow(deprecated)]
impl StaticType for CellRendererMode {
    #[inline]
    #[doc(alias = "gtk_cell_renderer_mode_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_cell_renderer_mode_get_type()) }
    }
}

#[allow(deprecated)]
impl glib::HasParamSpec for CellRendererMode {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

#[allow(deprecated)]
impl glib::value::ValueType for CellRendererMode {
    type Type = Self;
}

#[allow(deprecated)]
unsafe impl<'a> glib::value::FromValue<'a> for CellRendererMode {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

#[allow(deprecated)]
impl ToValue for CellRendererMode {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

#[allow(deprecated)]
impl From<CellRendererMode> for glib::Value {
    #[inline]
    fn from(v: CellRendererMode) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Describes how a [`StringSorter`][crate::StringSorter] turns strings into sort keys to
/// compare them.
///
/// Note that the result of sorting will in general depend on the current locale
/// unless the mode is @GTK_COLLATION_NONE.
#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkCollation")]
pub enum Collation {
    /// Don't do any collation
    #[doc(alias = "GTK_COLLATION_NONE")]
    None,
    /// Use `utf8_collate_key()`
    #[doc(alias = "GTK_COLLATION_UNICODE")]
    Unicode,
    /// Use `utf8_collate_key_for_filename()`
    #[doc(alias = "GTK_COLLATION_FILENAME")]
    Filename,
    #[doc(hidden)]
    __Unknown(i32),
}

#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
#[doc(hidden)]
impl IntoGlib for Collation {
    type GlibType = ffi::GtkCollation;

    #[inline]
    fn into_glib(self) -> ffi::GtkCollation {
        match self {
            Self::None => ffi::GTK_COLLATION_NONE,
            Self::Unicode => ffi::GTK_COLLATION_UNICODE,
            Self::Filename => ffi::GTK_COLLATION_FILENAME,
            Self::__Unknown(value) => value,
        }
    }
}

#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
#[doc(hidden)]
impl FromGlib<ffi::GtkCollation> for Collation {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkCollation) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_COLLATION_NONE => Self::None,
            ffi::GTK_COLLATION_UNICODE => Self::Unicode,
            ffi::GTK_COLLATION_FILENAME => Self::Filename,
            value => Self::__Unknown(value),
        }
    }
}

#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
impl StaticType for Collation {
    #[inline]
    #[doc(alias = "gtk_collation_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_collation_get_type()) }
    }
}

#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
impl glib::HasParamSpec for Collation {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
impl glib::value::ValueType for Collation {
    type Type = Self;
}

#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
unsafe impl<'a> glib::value::FromValue<'a> for Collation {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
impl ToValue for Collation {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
impl From<Collation> for glib::Value {
    #[inline]
    fn from(v: Collation) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// The widget attributes that can be used when creating a [`Constraint`][crate::Constraint].
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkConstraintAttribute")]
pub enum ConstraintAttribute {
    /// No attribute, used for constant
    ///   relations
    #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_NONE")]
    None,
    /// The left edge of a widget, regardless of
    ///   text direction
    #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_LEFT")]
    Left,
    /// The right edge of a widget, regardless
    ///   of text direction
    #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_RIGHT")]
    Right,
    /// The top edge of a widget
    #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_TOP")]
    Top,
    /// The bottom edge of a widget
    #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_BOTTOM")]
    Bottom,
    /// The leading edge of a widget, depending
    ///   on text direction; equivalent to [`Left`][Self::Left] for LTR
    ///   languages, and [`Right`][Self::Right] for RTL ones
    #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_START")]
    Start,
    /// The trailing edge of a widget, depending
    ///   on text direction; equivalent to [`Right`][Self::Right] for LTR
    ///   languages, and [`Left`][Self::Left] for RTL ones
    #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_END")]
    End,
    /// The width of a widget
    #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_WIDTH")]
    Width,
    /// The height of a widget
    #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_HEIGHT")]
    Height,
    /// The center of a widget, on the
    ///   horizontal axis
    #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_CENTER_X")]
    CenterX,
    /// The center of a widget, on the
    ///   vertical axis
    #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_CENTER_Y")]
    CenterY,
    /// The baseline of a widget
    #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_BASELINE")]
    Baseline,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for ConstraintAttribute {
    type GlibType = ffi::GtkConstraintAttribute;

    #[inline]
    fn into_glib(self) -> ffi::GtkConstraintAttribute {
        match self {
            Self::None => ffi::GTK_CONSTRAINT_ATTRIBUTE_NONE,
            Self::Left => ffi::GTK_CONSTRAINT_ATTRIBUTE_LEFT,
            Self::Right => ffi::GTK_CONSTRAINT_ATTRIBUTE_RIGHT,
            Self::Top => ffi::GTK_CONSTRAINT_ATTRIBUTE_TOP,
            Self::Bottom => ffi::GTK_CONSTRAINT_ATTRIBUTE_BOTTOM,
            Self::Start => ffi::GTK_CONSTRAINT_ATTRIBUTE_START,
            Self::End => ffi::GTK_CONSTRAINT_ATTRIBUTE_END,
            Self::Width => ffi::GTK_CONSTRAINT_ATTRIBUTE_WIDTH,
            Self::Height => ffi::GTK_CONSTRAINT_ATTRIBUTE_HEIGHT,
            Self::CenterX => ffi::GTK_CONSTRAINT_ATTRIBUTE_CENTER_X,
            Self::CenterY => ffi::GTK_CONSTRAINT_ATTRIBUTE_CENTER_Y,
            Self::Baseline => ffi::GTK_CONSTRAINT_ATTRIBUTE_BASELINE,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkConstraintAttribute> for ConstraintAttribute {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkConstraintAttribute) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_CONSTRAINT_ATTRIBUTE_NONE => Self::None,
            ffi::GTK_CONSTRAINT_ATTRIBUTE_LEFT => Self::Left,
            ffi::GTK_CONSTRAINT_ATTRIBUTE_RIGHT => Self::Right,
            ffi::GTK_CONSTRAINT_ATTRIBUTE_TOP => Self::Top,
            ffi::GTK_CONSTRAINT_ATTRIBUTE_BOTTOM => Self::Bottom,
            ffi::GTK_CONSTRAINT_ATTRIBUTE_START => Self::Start,
            ffi::GTK_CONSTRAINT_ATTRIBUTE_END => Self::End,
            ffi::GTK_CONSTRAINT_ATTRIBUTE_WIDTH => Self::Width,
            ffi::GTK_CONSTRAINT_ATTRIBUTE_HEIGHT => Self::Height,
            ffi::GTK_CONSTRAINT_ATTRIBUTE_CENTER_X => Self::CenterX,
            ffi::GTK_CONSTRAINT_ATTRIBUTE_CENTER_Y => Self::CenterY,
            ffi::GTK_CONSTRAINT_ATTRIBUTE_BASELINE => Self::Baseline,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for ConstraintAttribute {
    #[inline]
    #[doc(alias = "gtk_constraint_attribute_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_constraint_attribute_get_type()) }
    }
}

impl glib::HasParamSpec for ConstraintAttribute {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for ConstraintAttribute {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for ConstraintAttribute {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for ConstraintAttribute {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<ConstraintAttribute> for glib::Value {
    #[inline]
    fn from(v: ConstraintAttribute) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// The relation between two terms of a constraint.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkConstraintRelation")]
pub enum ConstraintRelation {
    /// Less than, or equal
    #[doc(alias = "GTK_CONSTRAINT_RELATION_LE")]
    Le,
    /// Equal
    #[doc(alias = "GTK_CONSTRAINT_RELATION_EQ")]
    Eq,
    /// Greater than, or equal
    #[doc(alias = "GTK_CONSTRAINT_RELATION_GE")]
    Ge,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for ConstraintRelation {
    type GlibType = ffi::GtkConstraintRelation;

    #[inline]
    fn into_glib(self) -> ffi::GtkConstraintRelation {
        match self {
            Self::Le => ffi::GTK_CONSTRAINT_RELATION_LE,
            Self::Eq => ffi::GTK_CONSTRAINT_RELATION_EQ,
            Self::Ge => ffi::GTK_CONSTRAINT_RELATION_GE,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkConstraintRelation> for ConstraintRelation {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkConstraintRelation) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_CONSTRAINT_RELATION_LE => Self::Le,
            ffi::GTK_CONSTRAINT_RELATION_EQ => Self::Eq,
            ffi::GTK_CONSTRAINT_RELATION_GE => Self::Ge,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for ConstraintRelation {
    #[inline]
    #[doc(alias = "gtk_constraint_relation_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_constraint_relation_get_type()) }
    }
}

impl glib::HasParamSpec for ConstraintRelation {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for ConstraintRelation {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for ConstraintRelation {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for ConstraintRelation {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<ConstraintRelation> for glib::Value {
    #[inline]
    fn from(v: ConstraintRelation) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// The strength of a constraint, expressed as a symbolic constant.
///
/// The strength of a [`Constraint`][crate::Constraint] can be expressed with any positive
/// integer; the values of this enumeration can be used for readability.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkConstraintStrength")]
pub enum ConstraintStrength {
    /// The constraint is required towards solving the layout
    #[doc(alias = "GTK_CONSTRAINT_STRENGTH_REQUIRED")]
    Required,
    /// A strong constraint
    #[doc(alias = "GTK_CONSTRAINT_STRENGTH_STRONG")]
    Strong,
    /// A medium constraint
    #[doc(alias = "GTK_CONSTRAINT_STRENGTH_MEDIUM")]
    Medium,
    /// A weak constraint
    #[doc(alias = "GTK_CONSTRAINT_STRENGTH_WEAK")]
    Weak,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for ConstraintStrength {
    type GlibType = ffi::GtkConstraintStrength;

    #[inline]
    fn into_glib(self) -> ffi::GtkConstraintStrength {
        match self {
            Self::Required => ffi::GTK_CONSTRAINT_STRENGTH_REQUIRED,
            Self::Strong => ffi::GTK_CONSTRAINT_STRENGTH_STRONG,
            Self::Medium => ffi::GTK_CONSTRAINT_STRENGTH_MEDIUM,
            Self::Weak => ffi::GTK_CONSTRAINT_STRENGTH_WEAK,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkConstraintStrength> for ConstraintStrength {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkConstraintStrength) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_CONSTRAINT_STRENGTH_REQUIRED => Self::Required,
            ffi::GTK_CONSTRAINT_STRENGTH_STRONG => Self::Strong,
            ffi::GTK_CONSTRAINT_STRENGTH_MEDIUM => Self::Medium,
            ffi::GTK_CONSTRAINT_STRENGTH_WEAK => Self::Weak,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for ConstraintStrength {
    #[inline]
    #[doc(alias = "gtk_constraint_strength_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_constraint_strength_get_type()) }
    }
}

impl glib::HasParamSpec for ConstraintStrength {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for ConstraintStrength {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for ConstraintStrength {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for ConstraintStrength {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<ConstraintStrength> for glib::Value {
    #[inline]
    fn from(v: ConstraintStrength) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Domain for VFL parsing errors.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkConstraintVflParserError")]
pub enum ConstraintVflParserError {
    /// Invalid or unknown symbol
    #[doc(alias = "GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_SYMBOL")]
    InvalidSymbol,
    /// Invalid or unknown attribute
    #[doc(alias = "GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_ATTRIBUTE")]
    InvalidAttribute,
    /// Invalid or unknown view
    #[doc(alias = "GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_VIEW")]
    InvalidView,
    /// Invalid or unknown metric
    #[doc(alias = "GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_METRIC")]
    InvalidMetric,
    /// Invalid or unknown priority
    #[doc(alias = "GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_PRIORITY")]
    InvalidPriority,
    /// Invalid or unknown relation
    #[doc(alias = "GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_RELATION")]
    InvalidRelation,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for ConstraintVflParserError {
    type GlibType = ffi::GtkConstraintVflParserError;

    #[inline]
    fn into_glib(self) -> ffi::GtkConstraintVflParserError {
        match self {
            Self::InvalidSymbol => ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_SYMBOL,
            Self::InvalidAttribute => ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_ATTRIBUTE,
            Self::InvalidView => ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_VIEW,
            Self::InvalidMetric => ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_METRIC,
            Self::InvalidPriority => ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_PRIORITY,
            Self::InvalidRelation => ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_RELATION,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkConstraintVflParserError> for ConstraintVflParserError {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkConstraintVflParserError) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_SYMBOL => Self::InvalidSymbol,
            ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_ATTRIBUTE => Self::InvalidAttribute,
            ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_VIEW => Self::InvalidView,
            ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_METRIC => Self::InvalidMetric,
            ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_PRIORITY => Self::InvalidPriority,
            ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_RELATION => Self::InvalidRelation,
            value => Self::__Unknown(value),
        }
    }
}

impl glib::error::ErrorDomain for ConstraintVflParserError {
    #[inline]
    fn domain() -> glib::Quark {
        skip_assert_initialized!();

        unsafe { from_glib(ffi::gtk_constraint_vfl_parser_error_quark()) }
    }

    #[inline]
    fn code(self) -> i32 {
        self.into_glib()
    }

    #[inline]
    #[allow(clippy::match_single_binding)]
    fn from(code: i32) -> Option<Self> {
        skip_assert_initialized!();
        match unsafe { from_glib(code) } {
            value => Some(value),
        }
    }
}

impl StaticType for ConstraintVflParserError {
    #[inline]
    #[doc(alias = "gtk_constraint_vfl_parser_error_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_constraint_vfl_parser_error_get_type()) }
    }
}

impl glib::HasParamSpec for ConstraintVflParserError {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for ConstraintVflParserError {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for ConstraintVflParserError {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for ConstraintVflParserError {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<ConstraintVflParserError> for glib::Value {
    #[inline]
    fn from(v: ConstraintVflParserError) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Controls how a content should be made to fit inside an allocation.
#[cfg(feature = "v4_8")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkContentFit")]
pub enum ContentFit {
    /// Make the content fill the entire allocation,
    ///   without taking its aspect ratio in consideration. The resulting
    ///   content will appear as stretched if its aspect ratio is different
    ///   from the allocation aspect ratio.
    #[doc(alias = "GTK_CONTENT_FIT_FILL")]
    Fill,
    /// Scale the content to fit the allocation,
    ///   while taking its aspect ratio in consideration. The resulting
    ///   content will appear as letterboxed if its aspect ratio is different
    ///   from the allocation aspect ratio.
    #[doc(alias = "GTK_CONTENT_FIT_CONTAIN")]
    Contain,
    /// Cover the entire allocation, while taking
    ///   the content aspect ratio in consideration. The resulting content
    ///   will appear as clipped if its aspect ratio is different from the
    ///   allocation aspect ratio.
    #[doc(alias = "GTK_CONTENT_FIT_COVER")]
    Cover,
    /// The content is scaled down to fit the
    ///   allocation, if needed, otherwise its original size is used.
    #[doc(alias = "GTK_CONTENT_FIT_SCALE_DOWN")]
    ScaleDown,
    #[doc(hidden)]
    __Unknown(i32),
}

#[cfg(feature = "v4_8")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
#[doc(hidden)]
impl IntoGlib for ContentFit {
    type GlibType = ffi::GtkContentFit;

    #[inline]
    fn into_glib(self) -> ffi::GtkContentFit {
        match self {
            Self::Fill => ffi::GTK_CONTENT_FIT_FILL,
            Self::Contain => ffi::GTK_CONTENT_FIT_CONTAIN,
            Self::Cover => ffi::GTK_CONTENT_FIT_COVER,
            Self::ScaleDown => ffi::GTK_CONTENT_FIT_SCALE_DOWN,
            Self::__Unknown(value) => value,
        }
    }
}

#[cfg(feature = "v4_8")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
#[doc(hidden)]
impl FromGlib<ffi::GtkContentFit> for ContentFit {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkContentFit) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_CONTENT_FIT_FILL => Self::Fill,
            ffi::GTK_CONTENT_FIT_CONTAIN => Self::Contain,
            ffi::GTK_CONTENT_FIT_COVER => Self::Cover,
            ffi::GTK_CONTENT_FIT_SCALE_DOWN => Self::ScaleDown,
            value => Self::__Unknown(value),
        }
    }
}

#[cfg(feature = "v4_8")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
impl StaticType for ContentFit {
    #[inline]
    #[doc(alias = "gtk_content_fit_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_content_fit_get_type()) }
    }
}

#[cfg(feature = "v4_8")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
impl glib::HasParamSpec for ContentFit {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

#[cfg(feature = "v4_8")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
impl glib::value::ValueType for ContentFit {
    type Type = Self;
}

#[cfg(feature = "v4_8")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
unsafe impl<'a> glib::value::FromValue<'a> for ContentFit {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

#[cfg(feature = "v4_8")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
impl ToValue for ContentFit {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

#[cfg(feature = "v4_8")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
impl From<ContentFit> for glib::Value {
    #[inline]
    fn from(v: ContentFit) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Specifies which corner a child widget should be placed in when packed into
/// a [`ScrolledWindow`][crate::ScrolledWindow]
///
/// This is effectively the opposite of where the scroll bars are placed.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkCornerType")]
pub enum CornerType {
    /// Place the scrollbars on the right and bottom of the
    ///   widget (default behaviour).
    #[doc(alias = "GTK_CORNER_TOP_LEFT")]
    TopLeft,
    /// Place the scrollbars on the top and right of the
    ///   widget.
    #[doc(alias = "GTK_CORNER_BOTTOM_LEFT")]
    BottomLeft,
    /// Place the scrollbars on the left and bottom of the
    ///   widget.
    #[doc(alias = "GTK_CORNER_TOP_RIGHT")]
    TopRight,
    /// Place the scrollbars on the top and left of the
    ///   widget.
    #[doc(alias = "GTK_CORNER_BOTTOM_RIGHT")]
    BottomRight,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for CornerType {
    type GlibType = ffi::GtkCornerType;

    #[inline]
    fn into_glib(self) -> ffi::GtkCornerType {
        match self {
            Self::TopLeft => ffi::GTK_CORNER_TOP_LEFT,
            Self::BottomLeft => ffi::GTK_CORNER_BOTTOM_LEFT,
            Self::TopRight => ffi::GTK_CORNER_TOP_RIGHT,
            Self::BottomRight => ffi::GTK_CORNER_BOTTOM_RIGHT,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkCornerType> for CornerType {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkCornerType) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_CORNER_TOP_LEFT => Self::TopLeft,
            ffi::GTK_CORNER_BOTTOM_LEFT => Self::BottomLeft,
            ffi::GTK_CORNER_TOP_RIGHT => Self::TopRight,
            ffi::GTK_CORNER_BOTTOM_RIGHT => Self::BottomRight,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for CornerType {
    #[inline]
    #[doc(alias = "gtk_corner_type_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_corner_type_get_type()) }
    }
}

impl glib::HasParamSpec for CornerType {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for CornerType {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for CornerType {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for CornerType {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<CornerType> for glib::Value {
    #[inline]
    fn from(v: CornerType) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Errors that can occur while parsing CSS.
///
/// These errors are unexpected and will cause parts of the given CSS
/// to be ignored.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkCssParserError")]
pub enum CssParserError {
    /// Unknown failure.
    #[doc(alias = "GTK_CSS_PARSER_ERROR_FAILED")]
    Failed,
    /// The given text does not form valid syntax
    #[doc(alias = "GTK_CSS_PARSER_ERROR_SYNTAX")]
    Syntax,
    /// Failed to import a resource
    #[doc(alias = "GTK_CSS_PARSER_ERROR_IMPORT")]
    Import,
    /// The given name has not been defined
    #[doc(alias = "GTK_CSS_PARSER_ERROR_NAME")]
    Name,
    /// The given value is not correct
    #[doc(alias = "GTK_CSS_PARSER_ERROR_UNKNOWN_VALUE")]
    UnknownValue,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for CssParserError {
    type GlibType = ffi::GtkCssParserError;

    #[inline]
    fn into_glib(self) -> ffi::GtkCssParserError {
        match self {
            Self::Failed => ffi::GTK_CSS_PARSER_ERROR_FAILED,
            Self::Syntax => ffi::GTK_CSS_PARSER_ERROR_SYNTAX,
            Self::Import => ffi::GTK_CSS_PARSER_ERROR_IMPORT,
            Self::Name => ffi::GTK_CSS_PARSER_ERROR_NAME,
            Self::UnknownValue => ffi::GTK_CSS_PARSER_ERROR_UNKNOWN_VALUE,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkCssParserError> for CssParserError {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkCssParserError) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_CSS_PARSER_ERROR_FAILED => Self::Failed,
            ffi::GTK_CSS_PARSER_ERROR_SYNTAX => Self::Syntax,
            ffi::GTK_CSS_PARSER_ERROR_IMPORT => Self::Import,
            ffi::GTK_CSS_PARSER_ERROR_NAME => Self::Name,
            ffi::GTK_CSS_PARSER_ERROR_UNKNOWN_VALUE => Self::UnknownValue,
            value => Self::__Unknown(value),
        }
    }
}

impl glib::error::ErrorDomain for CssParserError {
    #[inline]
    fn domain() -> glib::Quark {
        skip_assert_initialized!();

        unsafe { from_glib(ffi::gtk_css_parser_error_quark()) }
    }

    #[inline]
    fn code(self) -> i32 {
        self.into_glib()
    }

    #[inline]
    #[allow(clippy::match_single_binding)]
    fn from(code: i32) -> Option<Self> {
        skip_assert_initialized!();
        match unsafe { from_glib(code) } {
            Self::__Unknown(_) => Some(Self::Failed),
            value => Some(value),
        }
    }
}

/// Warnings that can occur while parsing CSS.
///
/// Unlike [`CssParserError`][crate::CssParserError]s, warnings do not cause the parser to
/// skip any input, but they indicate issues that should be fixed.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkCssParserWarning")]
pub enum CssParserWarning {
    /// The given construct is
    ///   deprecated and will be removed in a future version
    #[doc(alias = "GTK_CSS_PARSER_WARNING_DEPRECATED")]
    Deprecated,
    /// A syntax construct was used
    ///   that should be avoided
    #[doc(alias = "GTK_CSS_PARSER_WARNING_SYNTAX")]
    Syntax,
    /// A feature is not implemented
    #[doc(alias = "GTK_CSS_PARSER_WARNING_UNIMPLEMENTED")]
    Unimplemented,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for CssParserWarning {
    type GlibType = ffi::GtkCssParserWarning;

    #[inline]
    fn into_glib(self) -> ffi::GtkCssParserWarning {
        match self {
            Self::Deprecated => ffi::GTK_CSS_PARSER_WARNING_DEPRECATED,
            Self::Syntax => ffi::GTK_CSS_PARSER_WARNING_SYNTAX,
            Self::Unimplemented => ffi::GTK_CSS_PARSER_WARNING_UNIMPLEMENTED,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkCssParserWarning> for CssParserWarning {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkCssParserWarning) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_CSS_PARSER_WARNING_DEPRECATED => Self::Deprecated,
            ffi::GTK_CSS_PARSER_WARNING_SYNTAX => Self::Syntax,
            ffi::GTK_CSS_PARSER_WARNING_UNIMPLEMENTED => Self::Unimplemented,
            value => Self::__Unknown(value),
        }
    }
}

/// Passed to various keybinding signals for deleting text.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkDeleteType")]
pub enum DeleteType {
    /// Delete characters.
    #[doc(alias = "GTK_DELETE_CHARS")]
    Chars,
    /// Delete only the portion of the word to the
    ///   left/right of cursor if we’re in the middle of a word.
    #[doc(alias = "GTK_DELETE_WORD_ENDS")]
    WordEnds,
    /// Delete words.
    #[doc(alias = "GTK_DELETE_WORDS")]
    Words,
    /// Delete display-lines. Display-lines
    ///   refers to the visible lines, with respect to the current line
    ///   breaks. As opposed to paragraphs, which are defined by line
    ///   breaks in the input.
    #[doc(alias = "GTK_DELETE_DISPLAY_LINES")]
    DisplayLines,
    /// Delete only the portion of the
    ///   display-line to the left/right of cursor.
    #[doc(alias = "GTK_DELETE_DISPLAY_LINE_ENDS")]
    DisplayLineEnds,
    /// Delete to the end of the
    ///   paragraph. Like C-k in Emacs (or its reverse).
    #[doc(alias = "GTK_DELETE_PARAGRAPH_ENDS")]
    ParagraphEnds,
    /// Delete entire line. Like C-k in pico.
    #[doc(alias = "GTK_DELETE_PARAGRAPHS")]
    Paragraphs,
    /// Delete only whitespace. Like M-\ in Emacs.
    #[doc(alias = "GTK_DELETE_WHITESPACE")]
    Whitespace,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for DeleteType {
    type GlibType = ffi::GtkDeleteType;

    #[inline]
    fn into_glib(self) -> ffi::GtkDeleteType {
        match self {
            Self::Chars => ffi::GTK_DELETE_CHARS,
            Self::WordEnds => ffi::GTK_DELETE_WORD_ENDS,
            Self::Words => ffi::GTK_DELETE_WORDS,
            Self::DisplayLines => ffi::GTK_DELETE_DISPLAY_LINES,
            Self::DisplayLineEnds => ffi::GTK_DELETE_DISPLAY_LINE_ENDS,
            Self::ParagraphEnds => ffi::GTK_DELETE_PARAGRAPH_ENDS,
            Self::Paragraphs => ffi::GTK_DELETE_PARAGRAPHS,
            Self::Whitespace => ffi::GTK_DELETE_WHITESPACE,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkDeleteType> for DeleteType {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkDeleteType) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_DELETE_CHARS => Self::Chars,
            ffi::GTK_DELETE_WORD_ENDS => Self::WordEnds,
            ffi::GTK_DELETE_WORDS => Self::Words,
            ffi::GTK_DELETE_DISPLAY_LINES => Self::DisplayLines,
            ffi::GTK_DELETE_DISPLAY_LINE_ENDS => Self::DisplayLineEnds,
            ffi::GTK_DELETE_PARAGRAPH_ENDS => Self::ParagraphEnds,
            ffi::GTK_DELETE_PARAGRAPHS => Self::Paragraphs,
            ffi::GTK_DELETE_WHITESPACE => Self::Whitespace,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for DeleteType {
    #[inline]
    #[doc(alias = "gtk_delete_type_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_delete_type_get_type()) }
    }
}

impl glib::HasParamSpec for DeleteType {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for DeleteType {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for DeleteType {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for DeleteType {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<DeleteType> for glib::Value {
    #[inline]
    fn from(v: DeleteType) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Error codes in the `GTK_DIALOG_ERROR` domain that can be returned
/// by async dialog functions.
#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkDialogError")]
pub enum DialogError {
    /// Generic error condition for when
    ///   an operation fails and no more specific code is applicable
    #[doc(alias = "GTK_DIALOG_ERROR_FAILED")]
    Failed,
    /// The async function call was cancelled
    ///   via its `GCancellable`
    #[doc(alias = "GTK_DIALOG_ERROR_CANCELLED")]
    Cancelled,
    /// The operation was cancelled
    ///   by the user (via a Cancel or Close button)
    #[doc(alias = "GTK_DIALOG_ERROR_DISMISSED")]
    Dismissed,
    #[doc(hidden)]
    __Unknown(i32),
}

#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
#[doc(hidden)]
impl IntoGlib for DialogError {
    type GlibType = ffi::GtkDialogError;

    #[inline]
    fn into_glib(self) -> ffi::GtkDialogError {
        match self {
            Self::Failed => ffi::GTK_DIALOG_ERROR_FAILED,
            Self::Cancelled => ffi::GTK_DIALOG_ERROR_CANCELLED,
            Self::Dismissed => ffi::GTK_DIALOG_ERROR_DISMISSED,
            Self::__Unknown(value) => value,
        }
    }
}

#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
#[doc(hidden)]
impl FromGlib<ffi::GtkDialogError> for DialogError {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkDialogError) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_DIALOG_ERROR_FAILED => Self::Failed,
            ffi::GTK_DIALOG_ERROR_CANCELLED => Self::Cancelled,
            ffi::GTK_DIALOG_ERROR_DISMISSED => Self::Dismissed,
            value => Self::__Unknown(value),
        }
    }
}

#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
impl glib::error::ErrorDomain for DialogError {
    #[inline]
    fn domain() -> glib::Quark {
        skip_assert_initialized!();

        unsafe { from_glib(ffi::gtk_dialog_error_quark()) }
    }

    #[inline]
    fn code(self) -> i32 {
        self.into_glib()
    }

    #[inline]
    #[allow(clippy::match_single_binding)]
    fn from(code: i32) -> Option<Self> {
        skip_assert_initialized!();
        match unsafe { from_glib(code) } {
            Self::__Unknown(_) => Some(Self::Failed),
            value => Some(value),
        }
    }
}

#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
impl StaticType for DialogError {
    #[inline]
    #[doc(alias = "gtk_dialog_error_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_dialog_error_get_type()) }
    }
}

#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
impl glib::HasParamSpec for DialogError {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
impl glib::value::ValueType for DialogError {
    type Type = Self;
}

#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
unsafe impl<'a> glib::value::FromValue<'a> for DialogError {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
impl ToValue for DialogError {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
impl From<DialogError> for glib::Value {
    #[inline]
    fn from(v: DialogError) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Focus movement types.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkDirectionType")]
pub enum DirectionType {
    /// Move forward.
    #[doc(alias = "GTK_DIR_TAB_FORWARD")]
    TabForward,
    /// Move backward.
    #[doc(alias = "GTK_DIR_TAB_BACKWARD")]
    TabBackward,
    /// Move up.
    #[doc(alias = "GTK_DIR_UP")]
    Up,
    /// Move down.
    #[doc(alias = "GTK_DIR_DOWN")]
    Down,
    /// Move left.
    #[doc(alias = "GTK_DIR_LEFT")]
    Left,
    /// Move right.
    #[doc(alias = "GTK_DIR_RIGHT")]
    Right,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for DirectionType {
    type GlibType = ffi::GtkDirectionType;

    #[inline]
    fn into_glib(self) -> ffi::GtkDirectionType {
        match self {
            Self::TabForward => ffi::GTK_DIR_TAB_FORWARD,
            Self::TabBackward => ffi::GTK_DIR_TAB_BACKWARD,
            Self::Up => ffi::GTK_DIR_UP,
            Self::Down => ffi::GTK_DIR_DOWN,
            Self::Left => ffi::GTK_DIR_LEFT,
            Self::Right => ffi::GTK_DIR_RIGHT,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkDirectionType> for DirectionType {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkDirectionType) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_DIR_TAB_FORWARD => Self::TabForward,
            ffi::GTK_DIR_TAB_BACKWARD => Self::TabBackward,
            ffi::GTK_DIR_UP => Self::Up,
            ffi::GTK_DIR_DOWN => Self::Down,
            ffi::GTK_DIR_LEFT => Self::Left,
            ffi::GTK_DIR_RIGHT => Self::Right,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for DirectionType {
    #[inline]
    #[doc(alias = "gtk_direction_type_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_direction_type_get_type()) }
    }
}

impl glib::HasParamSpec for DirectionType {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for DirectionType {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for DirectionType {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for DirectionType {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<DirectionType> for glib::Value {
    #[inline]
    fn from(v: DirectionType) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// The identifiers for [`Editable`][crate::Editable] properties.
///
/// See [`Editable::install_properties()`][crate::Editable::install_properties()] for details on how to
/// implement the [`Editable`][crate::Editable] interface.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkEditableProperties")]
pub enum EditableProperties {
    /// the property id for [`text`][struct@crate::Editable#text]
    #[doc(alias = "GTK_EDITABLE_PROP_TEXT")]
    PropText,
    /// the property id for [`cursor-position`][struct@crate::Editable#cursor-position]
    #[doc(alias = "GTK_EDITABLE_PROP_CURSOR_POSITION")]
    PropCursorPosition,
    /// the property id for [`selection-bound`][struct@crate::Editable#selection-bound]
    #[doc(alias = "GTK_EDITABLE_PROP_SELECTION_BOUND")]
    PropSelectionBound,
    /// the property id for [`editable`][struct@crate::Editable#editable]
    #[doc(alias = "GTK_EDITABLE_PROP_EDITABLE")]
    PropEditable,
    /// the property id for [`width-chars`][struct@crate::Editable#width-chars]
    #[doc(alias = "GTK_EDITABLE_PROP_WIDTH_CHARS")]
    PropWidthChars,
    /// the property id for [`max-width-chars`][struct@crate::Editable#max-width-chars]
    #[doc(alias = "GTK_EDITABLE_PROP_MAX_WIDTH_CHARS")]
    PropMaxWidthChars,
    /// the property id for [`xalign`][struct@crate::Editable#xalign]
    #[doc(alias = "GTK_EDITABLE_PROP_XALIGN")]
    PropXalign,
    /// the property id for [`enable-undo`][struct@crate::Editable#enable-undo]
    #[doc(alias = "GTK_EDITABLE_PROP_ENABLE_UNDO")]
    PropEnableUndo,
    /// the property id for [`complete-text`][struct@crate::Editable#complete-text]
    #[doc(alias = "GTK_EDITABLE_PROP_COMPLETE_TEXT")]
    PropCompleteText,
    /// the property id for [`input-interceptor`][struct@crate::Editable#input-interceptor]
    #[doc(alias = "GTK_EDITABLE_PROP_INPUT_INTERCEPTOR")]
    PropInputInterceptor,
    /// the number of properties
    #[doc(alias = "GTK_EDITABLE_NUM_PROPERTIES")]
    NumProperties,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for EditableProperties {
    type GlibType = ffi::GtkEditableProperties;

    #[inline]
    fn into_glib(self) -> ffi::GtkEditableProperties {
        match self {
            Self::PropText => ffi::GTK_EDITABLE_PROP_TEXT,
            Self::PropCursorPosition => ffi::GTK_EDITABLE_PROP_CURSOR_POSITION,
            Self::PropSelectionBound => ffi::GTK_EDITABLE_PROP_SELECTION_BOUND,
            Self::PropEditable => ffi::GTK_EDITABLE_PROP_EDITABLE,
            Self::PropWidthChars => ffi::GTK_EDITABLE_PROP_WIDTH_CHARS,
            Self::PropMaxWidthChars => ffi::GTK_EDITABLE_PROP_MAX_WIDTH_CHARS,
            Self::PropXalign => ffi::GTK_EDITABLE_PROP_XALIGN,
            Self::PropEnableUndo => ffi::GTK_EDITABLE_PROP_ENABLE_UNDO,
            Self::PropCompleteText => ffi::GTK_EDITABLE_PROP_COMPLETE_TEXT,
            Self::PropInputInterceptor => ffi::GTK_EDITABLE_PROP_INPUT_INTERCEPTOR,
            Self::NumProperties => ffi::GTK_EDITABLE_NUM_PROPERTIES,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkEditableProperties> for EditableProperties {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkEditableProperties) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_EDITABLE_PROP_TEXT => Self::PropText,
            ffi::GTK_EDITABLE_PROP_CURSOR_POSITION => Self::PropCursorPosition,
            ffi::GTK_EDITABLE_PROP_SELECTION_BOUND => Self::PropSelectionBound,
            ffi::GTK_EDITABLE_PROP_EDITABLE => Self::PropEditable,
            ffi::GTK_EDITABLE_PROP_WIDTH_CHARS => Self::PropWidthChars,
            ffi::GTK_EDITABLE_PROP_MAX_WIDTH_CHARS => Self::PropMaxWidthChars,
            ffi::GTK_EDITABLE_PROP_XALIGN => Self::PropXalign,
            ffi::GTK_EDITABLE_PROP_ENABLE_UNDO => Self::PropEnableUndo,
            ffi::GTK_EDITABLE_PROP_COMPLETE_TEXT => Self::PropCompleteText,
            ffi::GTK_EDITABLE_PROP_INPUT_INTERCEPTOR => Self::PropInputInterceptor,
            ffi::GTK_EDITABLE_NUM_PROPERTIES => Self::NumProperties,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for EditableProperties {
    #[inline]
    #[doc(alias = "gtk_editable_properties_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_editable_properties_get_type()) }
    }
}

impl glib::HasParamSpec for EditableProperties {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for EditableProperties {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for EditableProperties {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for EditableProperties {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<EditableProperties> for glib::Value {
    #[inline]
    fn from(v: EditableProperties) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Specifies the side of the entry at which an icon is placed.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkEntryIconPosition")]
pub enum EntryIconPosition {
    /// At the beginning of the entry (depending on the text direction).
    #[doc(alias = "GTK_ENTRY_ICON_PRIMARY")]
    Primary,
    /// At the end of the entry (depending on the text direction).
    #[doc(alias = "GTK_ENTRY_ICON_SECONDARY")]
    Secondary,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for EntryIconPosition {
    type GlibType = ffi::GtkEntryIconPosition;

    #[inline]
    fn into_glib(self) -> ffi::GtkEntryIconPosition {
        match self {
            Self::Primary => ffi::GTK_ENTRY_ICON_PRIMARY,
            Self::Secondary => ffi::GTK_ENTRY_ICON_SECONDARY,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkEntryIconPosition> for EntryIconPosition {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkEntryIconPosition) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_ENTRY_ICON_PRIMARY => Self::Primary,
            ffi::GTK_ENTRY_ICON_SECONDARY => Self::Secondary,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for EntryIconPosition {
    #[inline]
    #[doc(alias = "gtk_entry_icon_position_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_entry_icon_position_get_type()) }
    }
}

impl glib::HasParamSpec for EntryIconPosition {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for EntryIconPosition {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for EntryIconPosition {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for EntryIconPosition {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<EntryIconPosition> for glib::Value {
    #[inline]
    fn from(v: EntryIconPosition) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Describes the state of a [`gdk::EventSequence`][crate::gdk::EventSequence] in a [`Gesture`][crate::Gesture].
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkEventSequenceState")]
pub enum EventSequenceState {
    /// The sequence is handled, but not grabbed.
    #[doc(alias = "GTK_EVENT_SEQUENCE_NONE")]
    None,
    /// The sequence is handled and grabbed.
    #[doc(alias = "GTK_EVENT_SEQUENCE_CLAIMED")]
    Claimed,
    /// The sequence is denied.
    #[doc(alias = "GTK_EVENT_SEQUENCE_DENIED")]
    Denied,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for EventSequenceState {
    type GlibType = ffi::GtkEventSequenceState;

    #[inline]
    fn into_glib(self) -> ffi::GtkEventSequenceState {
        match self {
            Self::None => ffi::GTK_EVENT_SEQUENCE_NONE,
            Self::Claimed => ffi::GTK_EVENT_SEQUENCE_CLAIMED,
            Self::Denied => ffi::GTK_EVENT_SEQUENCE_DENIED,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkEventSequenceState> for EventSequenceState {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkEventSequenceState) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_EVENT_SEQUENCE_NONE => Self::None,
            ffi::GTK_EVENT_SEQUENCE_CLAIMED => Self::Claimed,
            ffi::GTK_EVENT_SEQUENCE_DENIED => Self::Denied,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for EventSequenceState {
    #[inline]
    #[doc(alias = "gtk_event_sequence_state_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_event_sequence_state_get_type()) }
    }
}

impl glib::HasParamSpec for EventSequenceState {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for EventSequenceState {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for EventSequenceState {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for EventSequenceState {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<EventSequenceState> for glib::Value {
    #[inline]
    fn from(v: EventSequenceState) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Describes whether a [`FileChooser`][crate::FileChooser] is being used to open existing files
/// or to save to a possibly new file.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkFileChooserAction")]
pub enum FileChooserAction {
    /// Indicates open mode.  The file chooser
    ///  will only let the user pick an existing file.
    #[doc(alias = "GTK_FILE_CHOOSER_ACTION_OPEN")]
    Open,
    /// Indicates save mode.  The file chooser
    ///  will let the user pick an existing file, or type in a new
    ///  filename.
    #[doc(alias = "GTK_FILE_CHOOSER_ACTION_SAVE")]
    Save,
    /// Indicates an Open mode for
    ///  selecting folders.  The file chooser will let the user pick an
    ///  existing folder.
    #[doc(alias = "GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER")]
    SelectFolder,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for FileChooserAction {
    type GlibType = ffi::GtkFileChooserAction;

    #[inline]
    fn into_glib(self) -> ffi::GtkFileChooserAction {
        match self {
            Self::Open => ffi::GTK_FILE_CHOOSER_ACTION_OPEN,
            Self::Save => ffi::GTK_FILE_CHOOSER_ACTION_SAVE,
            Self::SelectFolder => ffi::GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkFileChooserAction> for FileChooserAction {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkFileChooserAction) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_FILE_CHOOSER_ACTION_OPEN => Self::Open,
            ffi::GTK_FILE_CHOOSER_ACTION_SAVE => Self::Save,
            ffi::GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER => Self::SelectFolder,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for FileChooserAction {
    #[inline]
    #[doc(alias = "gtk_file_chooser_action_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_file_chooser_action_get_type()) }
    }
}

impl glib::HasParamSpec for FileChooserAction {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for FileChooserAction {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for FileChooserAction {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for FileChooserAction {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<FileChooserAction> for glib::Value {
    #[inline]
    fn from(v: FileChooserAction) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// These identify the various errors that can occur while calling
/// [`FileChooser`][crate::FileChooser] functions.
///
/// # Deprecated since 4.20
///
/// There is no replacement
#[cfg_attr(feature = "v4_20", deprecated = "Since 4.20")]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkFileChooserError")]
pub enum FileChooserError {
    /// Indicates that a file does not exist.
    #[doc(alias = "GTK_FILE_CHOOSER_ERROR_NONEXISTENT")]
    Nonexistent,
    /// Indicates a malformed filename.
    #[doc(alias = "GTK_FILE_CHOOSER_ERROR_BAD_FILENAME")]
    BadFilename,
    /// Indicates a duplicate path (e.g. when
    ///  adding a bookmark).
    #[doc(alias = "GTK_FILE_CHOOSER_ERROR_ALREADY_EXISTS")]
    AlreadyExists,
    /// Indicates an incomplete hostname
    ///  (e.g. "http://foo" without a slash after that).
    #[doc(alias = "GTK_FILE_CHOOSER_ERROR_INCOMPLETE_HOSTNAME")]
    IncompleteHostname,
    #[doc(hidden)]
    __Unknown(i32),
}

#[allow(deprecated)]
#[doc(hidden)]
impl IntoGlib for FileChooserError {
    type GlibType = ffi::GtkFileChooserError;

    #[inline]
    fn into_glib(self) -> ffi::GtkFileChooserError {
        match self {
            Self::Nonexistent => ffi::GTK_FILE_CHOOSER_ERROR_NONEXISTENT,
            Self::BadFilename => ffi::GTK_FILE_CHOOSER_ERROR_BAD_FILENAME,
            Self::AlreadyExists => ffi::GTK_FILE_CHOOSER_ERROR_ALREADY_EXISTS,
            Self::IncompleteHostname => ffi::GTK_FILE_CHOOSER_ERROR_INCOMPLETE_HOSTNAME,
            Self::__Unknown(value) => value,
        }
    }
}

#[allow(deprecated)]
#[doc(hidden)]
impl FromGlib<ffi::GtkFileChooserError> for FileChooserError {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkFileChooserError) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_FILE_CHOOSER_ERROR_NONEXISTENT => Self::Nonexistent,
            ffi::GTK_FILE_CHOOSER_ERROR_BAD_FILENAME => Self::BadFilename,
            ffi::GTK_FILE_CHOOSER_ERROR_ALREADY_EXISTS => Self::AlreadyExists,
            ffi::GTK_FILE_CHOOSER_ERROR_INCOMPLETE_HOSTNAME => Self::IncompleteHostname,
            value => Self::__Unknown(value),
        }
    }
}

#[allow(deprecated)]
impl glib::error::ErrorDomain for FileChooserError {
    #[inline]
    fn domain() -> glib::Quark {
        skip_assert_initialized!();

        unsafe { from_glib(ffi::gtk_file_chooser_error_quark()) }
    }

    #[inline]
    fn code(self) -> i32 {
        self.into_glib()
    }

    #[inline]
    #[allow(clippy::match_single_binding)]
    fn from(code: i32) -> Option<Self> {
        skip_assert_initialized!();
        match unsafe { from_glib(code) } {
            value => Some(value),
        }
    }
}

#[allow(deprecated)]
impl StaticType for FileChooserError {
    #[inline]
    #[doc(alias = "gtk_file_chooser_error_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_file_chooser_error_get_type()) }
    }
}

#[allow(deprecated)]
impl glib::HasParamSpec for FileChooserError {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

#[allow(deprecated)]
impl glib::value::ValueType for FileChooserError {
    type Type = Self;
}

#[allow(deprecated)]
unsafe impl<'a> glib::value::FromValue<'a> for FileChooserError {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

#[allow(deprecated)]
impl ToValue for FileChooserError {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

#[allow(deprecated)]
impl From<FileChooserError> for glib::Value {
    #[inline]
    fn from(v: FileChooserError) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Describes changes in a filter in more detail and allows objects
/// using the filter to optimize refiltering items.
///
/// If you are writing an implementation and are not sure which
/// value to pass, `GTK_FILTER_CHANGE_DIFFERENT` is always a correct
/// choice.
///
/// New values may be added in the future.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkFilterChange")]
pub enum FilterChange {
    /// The filter change cannot be
    ///   described with any of the other enumeration values
    #[doc(alias = "GTK_FILTER_CHANGE_DIFFERENT")]
    Different,
    /// The filter is less strict than
    ///   it was before: All items that it used to return true
    ///   still return true, others now may, too.
    #[doc(alias = "GTK_FILTER_CHANGE_LESS_STRICT")]
    LessStrict,
    /// The filter is more strict than
    ///   it was before: All items that it used to return false
    ///   still return false, others now may, too.
    #[doc(alias = "GTK_FILTER_CHANGE_MORE_STRICT")]
    MoreStrict,
    /// Similar to [enum@Gtk.FilterChange.DIFFERENT],
    /// but signs that item watches should be recreated. This is used by
    /// [`FilterListModel`][crate::FilterListModel] to keep the list up-to-date when items
    /// change.
    #[cfg(feature = "v4_20")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
    #[doc(alias = "GTK_FILTER_CHANGE_DIFFERENT_REWATCH")]
    DifferentRewatch,
    /// Similar to [enum@Gtk.FilterChange.LESS_STRICT],
    /// but signs that item watches should be recreated. This is used by
    /// [`FilterListModel`][crate::FilterListModel] to keep the list up-to-date when items
    /// change.
    #[cfg(feature = "v4_20")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
    #[doc(alias = "GTK_FILTER_CHANGE_LESS_STRICT_REWATCH")]
    LessStrictRewatch,
    /// Similar to [enum@Gtk.FilterChange.MORE_STRICT],
    /// but signs that item watches should be recreated. This is used by
    /// [`FilterListModel`][crate::FilterListModel] to keep the list up-to-date when items
    /// change.
    #[cfg(feature = "v4_20")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
    #[doc(alias = "GTK_FILTER_CHANGE_MORE_STRICT_REWATCH")]
    MoreStrictRewatch,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for FilterChange {
    type GlibType = ffi::GtkFilterChange;

    #[inline]
    fn into_glib(self) -> ffi::GtkFilterChange {
        match self {
            Self::Different => ffi::GTK_FILTER_CHANGE_DIFFERENT,
            Self::LessStrict => ffi::GTK_FILTER_CHANGE_LESS_STRICT,
            Self::MoreStrict => ffi::GTK_FILTER_CHANGE_MORE_STRICT,
            #[cfg(feature = "v4_20")]
            Self::DifferentRewatch => ffi::GTK_FILTER_CHANGE_DIFFERENT_REWATCH,
            #[cfg(feature = "v4_20")]
            Self::LessStrictRewatch => ffi::GTK_FILTER_CHANGE_LESS_STRICT_REWATCH,
            #[cfg(feature = "v4_20")]
            Self::MoreStrictRewatch => ffi::GTK_FILTER_CHANGE_MORE_STRICT_REWATCH,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkFilterChange> for FilterChange {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkFilterChange) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_FILTER_CHANGE_DIFFERENT => Self::Different,
            ffi::GTK_FILTER_CHANGE_LESS_STRICT => Self::LessStrict,
            ffi::GTK_FILTER_CHANGE_MORE_STRICT => Self::MoreStrict,
            #[cfg(feature = "v4_20")]
            ffi::GTK_FILTER_CHANGE_DIFFERENT_REWATCH => Self::DifferentRewatch,
            #[cfg(feature = "v4_20")]
            ffi::GTK_FILTER_CHANGE_LESS_STRICT_REWATCH => Self::LessStrictRewatch,
            #[cfg(feature = "v4_20")]
            ffi::GTK_FILTER_CHANGE_MORE_STRICT_REWATCH => Self::MoreStrictRewatch,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for FilterChange {
    #[inline]
    #[doc(alias = "gtk_filter_change_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_filter_change_get_type()) }
    }
}

impl glib::HasParamSpec for FilterChange {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for FilterChange {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for FilterChange {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for FilterChange {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<FilterChange> for glib::Value {
    #[inline]
    fn from(v: FilterChange) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Describes the known strictness of a filter.
///
/// Note that for filters where the strictness is not known,
/// `GTK_FILTER_MATCH_SOME` is always an acceptable value,
/// even if a filter does match all or no items.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkFilterMatch")]
pub enum FilterMatch {
    /// The filter matches some items,
    ///   [`FilterExt::match_()`][crate::prelude::FilterExt::match_()] may return true or false
    #[doc(alias = "GTK_FILTER_MATCH_SOME")]
    Some,
    /// The filter does not match any item,
    ///   [`FilterExt::match_()`][crate::prelude::FilterExt::match_()] will always return false
    #[doc(alias = "GTK_FILTER_MATCH_NONE")]
    None,
    /// The filter matches all items,
    ///   [`FilterExt::match_()`][crate::prelude::FilterExt::match_()] will alays return true
    #[doc(alias = "GTK_FILTER_MATCH_ALL")]
    All,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for FilterMatch {
    type GlibType = ffi::GtkFilterMatch;

    #[inline]
    fn into_glib(self) -> ffi::GtkFilterMatch {
        match self {
            Self::Some => ffi::GTK_FILTER_MATCH_SOME,
            Self::None => ffi::GTK_FILTER_MATCH_NONE,
            Self::All => ffi::GTK_FILTER_MATCH_ALL,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkFilterMatch> for FilterMatch {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkFilterMatch) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_FILTER_MATCH_SOME => Self::Some,
            ffi::GTK_FILTER_MATCH_NONE => Self::None,
            ffi::GTK_FILTER_MATCH_ALL => Self::All,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for FilterMatch {
    #[inline]
    #[doc(alias = "gtk_filter_match_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_filter_match_get_type()) }
    }
}

impl glib::HasParamSpec for FilterMatch {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for FilterMatch {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for FilterMatch {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for FilterMatch {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<FilterMatch> for glib::Value {
    #[inline]
    fn from(v: FilterMatch) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// The level of granularity for the font selection.
///
/// Depending on this value, the [`pango::FontDescription`][crate::pango::FontDescription] that
/// is returned by [`FontDialogButton::font_desc()`][crate::FontDialogButton::font_desc()]
/// will have more or less fields set.
#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkFontLevel")]
pub enum FontLevel {
    /// Select a font family
    #[doc(alias = "GTK_FONT_LEVEL_FAMILY")]
    Family,
    /// Select a font face (i.e. a family and a style)
    #[doc(alias = "GTK_FONT_LEVEL_FACE")]
    Face,
    /// Select a font (i.e. a face with a size, and possibly font variations)
    #[doc(alias = "GTK_FONT_LEVEL_FONT")]
    Font,
    /// Select a font and font features
    #[doc(alias = "GTK_FONT_LEVEL_FEATURES")]
    Features,
    #[doc(hidden)]
    __Unknown(i32),
}

#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
#[doc(hidden)]
impl IntoGlib for FontLevel {
    type GlibType = ffi::GtkFontLevel;

    #[inline]
    fn into_glib(self) -> ffi::GtkFontLevel {
        match self {
            Self::Family => ffi::GTK_FONT_LEVEL_FAMILY,
            Self::Face => ffi::GTK_FONT_LEVEL_FACE,
            Self::Font => ffi::GTK_FONT_LEVEL_FONT,
            Self::Features => ffi::GTK_FONT_LEVEL_FEATURES,
            Self::__Unknown(value) => value,
        }
    }
}

#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
#[doc(hidden)]
impl FromGlib<ffi::GtkFontLevel> for FontLevel {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkFontLevel) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_FONT_LEVEL_FAMILY => Self::Family,
            ffi::GTK_FONT_LEVEL_FACE => Self::Face,
            ffi::GTK_FONT_LEVEL_FONT => Self::Font,
            ffi::GTK_FONT_LEVEL_FEATURES => Self::Features,
            value => Self::__Unknown(value),
        }
    }
}

#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
impl StaticType for FontLevel {
    #[inline]
    #[doc(alias = "gtk_font_level_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_font_level_get_type()) }
    }
}

#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
impl glib::HasParamSpec for FontLevel {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
impl glib::value::ValueType for FontLevel {
    type Type = Self;
}

#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
unsafe impl<'a> glib::value::FromValue<'a> for FontLevel {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
impl ToValue for FontLevel {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
impl From<FontLevel> for glib::Value {
    #[inline]
    fn from(v: FontLevel) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Values for the [`gtk-font-rendering`][struct@crate::Settings#gtk-font-rendering] setting
/// that influence how GTK renders fonts.
#[cfg(feature = "v4_16")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkFontRendering")]
pub enum FontRendering {
    /// Set up font rendering automatically,
    ///   taking factors like screen resolution and scale into account
    #[doc(alias = "GTK_FONT_RENDERING_AUTOMATIC")]
    Automatic,
    /// Follow low-level font-related settings
    ///   when configuring font rendering
    #[doc(alias = "GTK_FONT_RENDERING_MANUAL")]
    Manual,
    #[doc(hidden)]
    __Unknown(i32),
}

#[cfg(feature = "v4_16")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
#[doc(hidden)]
impl IntoGlib for FontRendering {
    type GlibType = ffi::GtkFontRendering;

    #[inline]
    fn into_glib(self) -> ffi::GtkFontRendering {
        match self {
            Self::Automatic => ffi::GTK_FONT_RENDERING_AUTOMATIC,
            Self::Manual => ffi::GTK_FONT_RENDERING_MANUAL,
            Self::__Unknown(value) => value,
        }
    }
}

#[cfg(feature = "v4_16")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
#[doc(hidden)]
impl FromGlib<ffi::GtkFontRendering> for FontRendering {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkFontRendering) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_FONT_RENDERING_AUTOMATIC => Self::Automatic,
            ffi::GTK_FONT_RENDERING_MANUAL => Self::Manual,
            value => Self::__Unknown(value),
        }
    }
}

#[cfg(feature = "v4_16")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
impl StaticType for FontRendering {
    #[inline]
    #[doc(alias = "gtk_font_rendering_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_font_rendering_get_type()) }
    }
}

#[cfg(feature = "v4_16")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
impl glib::HasParamSpec for FontRendering {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

#[cfg(feature = "v4_16")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
impl glib::value::ValueType for FontRendering {
    type Type = Self;
}

#[cfg(feature = "v4_16")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
unsafe impl<'a> glib::value::FromValue<'a> for FontRendering {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

#[cfg(feature = "v4_16")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
impl ToValue for FontRendering {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

#[cfg(feature = "v4_16")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
impl From<FontRendering> for glib::Value {
    #[inline]
    fn from(v: FontRendering) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Represents the state of graphics offloading.
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkGraphicsOffloadEnabled")]
pub enum GraphicsOffloadEnabled {
    /// Graphics offloading is enabled.
    #[doc(alias = "GTK_GRAPHICS_OFFLOAD_ENABLED")]
    Enabled,
    /// Graphics offloading is disabled.
    #[doc(alias = "GTK_GRAPHICS_OFFLOAD_DISABLED")]
    Disabled,
    #[doc(hidden)]
    __Unknown(i32),
}

#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
#[doc(hidden)]
impl IntoGlib for GraphicsOffloadEnabled {
    type GlibType = ffi::GtkGraphicsOffloadEnabled;

    #[inline]
    fn into_glib(self) -> ffi::GtkGraphicsOffloadEnabled {
        match self {
            Self::Enabled => ffi::GTK_GRAPHICS_OFFLOAD_ENABLED,
            Self::Disabled => ffi::GTK_GRAPHICS_OFFLOAD_DISABLED,
            Self::__Unknown(value) => value,
        }
    }
}

#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
#[doc(hidden)]
impl FromGlib<ffi::GtkGraphicsOffloadEnabled> for GraphicsOffloadEnabled {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkGraphicsOffloadEnabled) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_GRAPHICS_OFFLOAD_ENABLED => Self::Enabled,
            ffi::GTK_GRAPHICS_OFFLOAD_DISABLED => Self::Disabled,
            value => Self::__Unknown(value),
        }
    }
}

#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
impl StaticType for GraphicsOffloadEnabled {
    #[inline]
    #[doc(alias = "gtk_graphics_offload_enabled_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_graphics_offload_enabled_get_type()) }
    }
}

#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
impl glib::HasParamSpec for GraphicsOffloadEnabled {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
impl glib::value::ValueType for GraphicsOffloadEnabled {
    type Type = Self;
}

#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
unsafe impl<'a> glib::value::FromValue<'a> for GraphicsOffloadEnabled {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
impl ToValue for GraphicsOffloadEnabled {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
impl From<GraphicsOffloadEnabled> for glib::Value {
    #[inline]
    fn from(v: GraphicsOffloadEnabled) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Built-in icon sizes.
///
/// Icon sizes default to being inherited. Where they cannot be
/// inherited, text size is the default.
///
/// All widgets which use [`IconSize`][crate::IconSize] set the normal-icons or
/// large-icons style classes correspondingly, and let themes
/// determine the actual size to be used with the
/// `-gtk-icon-size` CSS property.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkIconSize")]
pub enum IconSize {
    /// Keep the size of the parent element
    #[doc(alias = "GTK_ICON_SIZE_INHERIT")]
    Inherit,
    /// Size similar to text size
    #[doc(alias = "GTK_ICON_SIZE_NORMAL")]
    Normal,
    /// Large size, for example in an icon view
    #[doc(alias = "GTK_ICON_SIZE_LARGE")]
    Large,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for IconSize {
    type GlibType = ffi::GtkIconSize;

    #[inline]
    fn into_glib(self) -> ffi::GtkIconSize {
        match self {
            Self::Inherit => ffi::GTK_ICON_SIZE_INHERIT,
            Self::Normal => ffi::GTK_ICON_SIZE_NORMAL,
            Self::Large => ffi::GTK_ICON_SIZE_LARGE,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkIconSize> for IconSize {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkIconSize) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_ICON_SIZE_INHERIT => Self::Inherit,
            ffi::GTK_ICON_SIZE_NORMAL => Self::Normal,
            ffi::GTK_ICON_SIZE_LARGE => Self::Large,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for IconSize {
    #[inline]
    #[doc(alias = "gtk_icon_size_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_icon_size_get_type()) }
    }
}

impl glib::HasParamSpec for IconSize {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for IconSize {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for IconSize {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for IconSize {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<IconSize> for glib::Value {
    #[inline]
    fn from(v: IconSize) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Error codes for [`IconTheme`][crate::IconTheme] operations.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkIconThemeError")]
pub enum IconThemeError {
    /// The icon specified does not exist in the theme
    #[doc(alias = "GTK_ICON_THEME_NOT_FOUND")]
    NotFound,
    /// An unspecified error occurred.
    #[doc(alias = "GTK_ICON_THEME_FAILED")]
    Failed,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for IconThemeError {
    type GlibType = ffi::GtkIconThemeError;

    #[inline]
    fn into_glib(self) -> ffi::GtkIconThemeError {
        match self {
            Self::NotFound => ffi::GTK_ICON_THEME_NOT_FOUND,
            Self::Failed => ffi::GTK_ICON_THEME_FAILED,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkIconThemeError> for IconThemeError {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkIconThemeError) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_ICON_THEME_NOT_FOUND => Self::NotFound,
            ffi::GTK_ICON_THEME_FAILED => Self::Failed,
            value => Self::__Unknown(value),
        }
    }
}

impl glib::error::ErrorDomain for IconThemeError {
    #[inline]
    fn domain() -> glib::Quark {
        skip_assert_initialized!();

        unsafe { from_glib(ffi::gtk_icon_theme_error_quark()) }
    }

    #[inline]
    fn code(self) -> i32 {
        self.into_glib()
    }

    #[inline]
    #[allow(clippy::match_single_binding)]
    fn from(code: i32) -> Option<Self> {
        skip_assert_initialized!();
        match unsafe { from_glib(code) } {
            Self::__Unknown(_) => Some(Self::Failed),
            value => Some(value),
        }
    }
}

impl StaticType for IconThemeError {
    #[inline]
    #[doc(alias = "gtk_icon_theme_error_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_icon_theme_error_get_type()) }
    }
}

impl glib::HasParamSpec for IconThemeError {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for IconThemeError {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for IconThemeError {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for IconThemeError {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<IconThemeError> for glib::Value {
    #[inline]
    fn from(v: IconThemeError) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// An enum for determining where a dropped item goes.
///
/// # Deprecated since 4.20
///
/// There is no replacement.
#[cfg_attr(feature = "v4_20", deprecated = "Since 4.20")]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkIconViewDropPosition")]
pub enum IconViewDropPosition {
    /// no drop possible
    #[doc(alias = "GTK_ICON_VIEW_NO_DROP")]
    NoDrop,
    /// dropped item replaces the item
    #[doc(alias = "GTK_ICON_VIEW_DROP_INTO")]
    DropInto,
    /// dropped item is inserted to the left
    #[doc(alias = "GTK_ICON_VIEW_DROP_LEFT")]
    DropLeft,
    /// dropped item is inserted to the right
    #[doc(alias = "GTK_ICON_VIEW_DROP_RIGHT")]
    DropRight,
    /// dropped item is inserted above
    #[doc(alias = "GTK_ICON_VIEW_DROP_ABOVE")]
    DropAbove,
    /// dropped item is inserted below
    #[doc(alias = "GTK_ICON_VIEW_DROP_BELOW")]
    DropBelow,
    #[doc(hidden)]
    __Unknown(i32),
}

#[allow(deprecated)]
#[doc(hidden)]
impl IntoGlib for IconViewDropPosition {
    type GlibType = ffi::GtkIconViewDropPosition;

    #[inline]
    fn into_glib(self) -> ffi::GtkIconViewDropPosition {
        match self {
            Self::NoDrop => ffi::GTK_ICON_VIEW_NO_DROP,
            Self::DropInto => ffi::GTK_ICON_VIEW_DROP_INTO,
            Self::DropLeft => ffi::GTK_ICON_VIEW_DROP_LEFT,
            Self::DropRight => ffi::GTK_ICON_VIEW_DROP_RIGHT,
            Self::DropAbove => ffi::GTK_ICON_VIEW_DROP_ABOVE,
            Self::DropBelow => ffi::GTK_ICON_VIEW_DROP_BELOW,
            Self::__Unknown(value) => value,
        }
    }
}

#[allow(deprecated)]
#[doc(hidden)]
impl FromGlib<ffi::GtkIconViewDropPosition> for IconViewDropPosition {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkIconViewDropPosition) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_ICON_VIEW_NO_DROP => Self::NoDrop,
            ffi::GTK_ICON_VIEW_DROP_INTO => Self::DropInto,
            ffi::GTK_ICON_VIEW_DROP_LEFT => Self::DropLeft,
            ffi::GTK_ICON_VIEW_DROP_RIGHT => Self::DropRight,
            ffi::GTK_ICON_VIEW_DROP_ABOVE => Self::DropAbove,
            ffi::GTK_ICON_VIEW_DROP_BELOW => Self::DropBelow,
            value => Self::__Unknown(value),
        }
    }
}

#[allow(deprecated)]
impl StaticType for IconViewDropPosition {
    #[inline]
    #[doc(alias = "gtk_icon_view_drop_position_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_icon_view_drop_position_get_type()) }
    }
}

#[allow(deprecated)]
impl glib::HasParamSpec for IconViewDropPosition {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

#[allow(deprecated)]
impl glib::value::ValueType for IconViewDropPosition {
    type Type = Self;
}

#[allow(deprecated)]
unsafe impl<'a> glib::value::FromValue<'a> for IconViewDropPosition {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

#[allow(deprecated)]
impl ToValue for IconViewDropPosition {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

#[allow(deprecated)]
impl From<IconViewDropPosition> for glib::Value {
    #[inline]
    fn from(v: IconViewDropPosition) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Describes the image data representation used by a [`Image`][crate::Image].
///
/// If you want to get the image from the widget, you can only get the
/// currently-stored representation; for instance, if the gtk_image_get_storage_type()
/// returns [`Paintable`][Self::Paintable], then you can call gtk_image_get_paintable().
///
/// For empty images, you can request any storage type (call any of the "get"
/// functions), but they will all return [`None`] values.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkImageType")]
pub enum ImageType {
    /// there is no image displayed by the widget
    #[doc(alias = "GTK_IMAGE_EMPTY")]
    Empty,
    /// the widget contains a named icon
    #[doc(alias = "GTK_IMAGE_ICON_NAME")]
    IconName,
    /// the widget contains a `GIcon`
    #[doc(alias = "GTK_IMAGE_GICON")]
    Gicon,
    /// the widget contains a [`gdk::Paintable`][crate::gdk::Paintable]
    #[doc(alias = "GTK_IMAGE_PAINTABLE")]
    Paintable,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for ImageType {
    type GlibType = ffi::GtkImageType;

    #[inline]
    fn into_glib(self) -> ffi::GtkImageType {
        match self {
            Self::Empty => ffi::GTK_IMAGE_EMPTY,
            Self::IconName => ffi::GTK_IMAGE_ICON_NAME,
            Self::Gicon => ffi::GTK_IMAGE_GICON,
            Self::Paintable => ffi::GTK_IMAGE_PAINTABLE,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkImageType> for ImageType {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkImageType) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_IMAGE_EMPTY => Self::Empty,
            ffi::GTK_IMAGE_ICON_NAME => Self::IconName,
            ffi::GTK_IMAGE_GICON => Self::Gicon,
            ffi::GTK_IMAGE_PAINTABLE => Self::Paintable,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for ImageType {
    #[inline]
    #[doc(alias = "gtk_image_type_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_image_type_get_type()) }
    }
}

impl glib::HasParamSpec for ImageType {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for ImageType {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for ImageType {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for ImageType {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<ImageType> for glib::Value {
    #[inline]
    fn from(v: ImageType) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Describes primary purpose of the input widget.
///
/// This information is useful for on-screen keyboards and similar input
/// methods to decide which keys should be presented to the user.
///
/// Note that the purpose is not meant to impose a totally strict rule
/// about allowed characters, and does not replace input validation.
/// It is fine for an on-screen keyboard to let the user override the
/// character set restriction that is expressed by the purpose. The
/// application is expected to validate the entry contents, even if
/// it specified a purpose.
///
/// The difference between [`Digits`][Self::Digits] and
/// [`Number`][Self::Number] is that the former accepts only digits
/// while the latter also some punctuation (like commas or points, plus,
/// minus) and “e” or “E” as in 3.14E+000.
///
/// This enumeration may be extended in the future; input methods should
/// interpret unknown values as “free form”.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkInputPurpose")]
pub enum InputPurpose {
    /// Allow any character
    #[doc(alias = "GTK_INPUT_PURPOSE_FREE_FORM")]
    FreeForm,
    /// Allow only alphabetic characters
    #[doc(alias = "GTK_INPUT_PURPOSE_ALPHA")]
    Alpha,
    /// Allow only digits
    #[doc(alias = "GTK_INPUT_PURPOSE_DIGITS")]
    Digits,
    /// Edited field expects numbers
    #[doc(alias = "GTK_INPUT_PURPOSE_NUMBER")]
    Number,
    /// Edited field expects phone number
    #[doc(alias = "GTK_INPUT_PURPOSE_PHONE")]
    Phone,
    /// Edited field expects URL
    #[doc(alias = "GTK_INPUT_PURPOSE_URL")]
    Url,
    /// Edited field expects email address
    #[doc(alias = "GTK_INPUT_PURPOSE_EMAIL")]
    Email,
    /// Edited field expects the name of a person
    #[doc(alias = "GTK_INPUT_PURPOSE_NAME")]
    Name,
    /// Like [`FreeForm`][Self::FreeForm], but characters are hidden
    #[doc(alias = "GTK_INPUT_PURPOSE_PASSWORD")]
    Password,
    /// Like [`Digits`][Self::Digits], but characters are hidden
    #[doc(alias = "GTK_INPUT_PURPOSE_PIN")]
    Pin,
    /// Allow any character, in addition to control codes
    #[doc(alias = "GTK_INPUT_PURPOSE_TERMINAL")]
    Terminal,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for InputPurpose {
    type GlibType = ffi::GtkInputPurpose;

    #[inline]
    fn into_glib(self) -> ffi::GtkInputPurpose {
        match self {
            Self::FreeForm => ffi::GTK_INPUT_PURPOSE_FREE_FORM,
            Self::Alpha => ffi::GTK_INPUT_PURPOSE_ALPHA,
            Self::Digits => ffi::GTK_INPUT_PURPOSE_DIGITS,
            Self::Number => ffi::GTK_INPUT_PURPOSE_NUMBER,
            Self::Phone => ffi::GTK_INPUT_PURPOSE_PHONE,
            Self::Url => ffi::GTK_INPUT_PURPOSE_URL,
            Self::Email => ffi::GTK_INPUT_PURPOSE_EMAIL,
            Self::Name => ffi::GTK_INPUT_PURPOSE_NAME,
            Self::Password => ffi::GTK_INPUT_PURPOSE_PASSWORD,
            Self::Pin => ffi::GTK_INPUT_PURPOSE_PIN,
            Self::Terminal => ffi::GTK_INPUT_PURPOSE_TERMINAL,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkInputPurpose> for InputPurpose {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkInputPurpose) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_INPUT_PURPOSE_FREE_FORM => Self::FreeForm,
            ffi::GTK_INPUT_PURPOSE_ALPHA => Self::Alpha,
            ffi::GTK_INPUT_PURPOSE_DIGITS => Self::Digits,
            ffi::GTK_INPUT_PURPOSE_NUMBER => Self::Number,
            ffi::GTK_INPUT_PURPOSE_PHONE => Self::Phone,
            ffi::GTK_INPUT_PURPOSE_URL => Self::Url,
            ffi::GTK_INPUT_PURPOSE_EMAIL => Self::Email,
            ffi::GTK_INPUT_PURPOSE_NAME => Self::Name,
            ffi::GTK_INPUT_PURPOSE_PASSWORD => Self::Password,
            ffi::GTK_INPUT_PURPOSE_PIN => Self::Pin,
            ffi::GTK_INPUT_PURPOSE_TERMINAL => Self::Terminal,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for InputPurpose {
    #[inline]
    #[doc(alias = "gtk_input_purpose_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_input_purpose_get_type()) }
    }
}

impl glib::HasParamSpec for InputPurpose {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for InputPurpose {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for InputPurpose {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for InputPurpose {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<InputPurpose> for glib::Value {
    #[inline]
    fn from(v: InputPurpose) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// The different methods to handle text in #GtkInscription when it doesn't
/// fit the available space.
#[cfg(feature = "v4_8")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkInscriptionOverflow")]
pub enum InscriptionOverflow {
    /// Clip the remaining text
    #[doc(alias = "GTK_INSCRIPTION_OVERFLOW_CLIP")]
    Clip,
    /// Omit characters at the start of the text
    #[doc(alias = "GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_START")]
    EllipsizeStart,
    /// Omit characters at the middle of the text
    #[doc(alias = "GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_MIDDLE")]
    EllipsizeMiddle,
    /// Omit characters at the end of the text
    #[doc(alias = "GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_END")]
    EllipsizeEnd,
    #[doc(hidden)]
    __Unknown(i32),
}

#[cfg(feature = "v4_8")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
#[doc(hidden)]
impl IntoGlib for InscriptionOverflow {
    type GlibType = ffi::GtkInscriptionOverflow;

    #[inline]
    fn into_glib(self) -> ffi::GtkInscriptionOverflow {
        match self {
            Self::Clip => ffi::GTK_INSCRIPTION_OVERFLOW_CLIP,
            Self::EllipsizeStart => ffi::GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_START,
            Self::EllipsizeMiddle => ffi::GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_MIDDLE,
            Self::EllipsizeEnd => ffi::GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_END,
            Self::__Unknown(value) => value,
        }
    }
}

#[cfg(feature = "v4_8")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
#[doc(hidden)]
impl FromGlib<ffi::GtkInscriptionOverflow> for InscriptionOverflow {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkInscriptionOverflow) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_INSCRIPTION_OVERFLOW_CLIP => Self::Clip,
            ffi::GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_START => Self::EllipsizeStart,
            ffi::GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_MIDDLE => Self::EllipsizeMiddle,
            ffi::GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_END => Self::EllipsizeEnd,
            value => Self::__Unknown(value),
        }
    }
}

#[cfg(feature = "v4_8")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
impl StaticType for InscriptionOverflow {
    #[inline]
    #[doc(alias = "gtk_inscription_overflow_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_inscription_overflow_get_type()) }
    }
}

#[cfg(feature = "v4_8")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
impl glib::HasParamSpec for InscriptionOverflow {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

#[cfg(feature = "v4_8")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
impl glib::value::ValueType for InscriptionOverflow {
    type Type = Self;
}

#[cfg(feature = "v4_8")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
unsafe impl<'a> glib::value::FromValue<'a> for InscriptionOverflow {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

#[cfg(feature = "v4_8")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
impl ToValue for InscriptionOverflow {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

#[cfg(feature = "v4_8")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
impl From<InscriptionOverflow> for glib::Value {
    #[inline]
    fn from(v: InscriptionOverflow) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Values for the [`gtk-interface-color-scheme`][struct@crate::Settings#gtk-interface-color-scheme]
/// and [`prefers-color-scheme`][struct@crate::CssProvider#prefers-color-scheme] properties
/// that indicates what color scheme is used.
///
/// This information can be used inside CSS via media queries.
///
/// More values may be added to this enumeration. Unknown values
/// should be treated the same as `GTK_INTERFACE_COLOR_SCHEME_DEFAULT`.
#[cfg(feature = "v4_20")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkInterfaceColorScheme")]
pub enum InterfaceColorScheme {
    /// The system doesn't support color schemes
    #[doc(alias = "GTK_INTERFACE_COLOR_SCHEME_UNSUPPORTED")]
    Unsupported,
    /// The default color scheme is used
    #[doc(alias = "GTK_INTERFACE_COLOR_SCHEME_DEFAULT")]
    Default,
    /// A dark color scheme is used
    #[doc(alias = "GTK_INTERFACE_COLOR_SCHEME_DARK")]
    Dark,
    /// A light color scheme is used
    #[doc(alias = "GTK_INTERFACE_COLOR_SCHEME_LIGHT")]
    Light,
    #[doc(hidden)]
    __Unknown(i32),
}

#[cfg(feature = "v4_20")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
#[doc(hidden)]
impl IntoGlib for InterfaceColorScheme {
    type GlibType = ffi::GtkInterfaceColorScheme;

    #[inline]
    fn into_glib(self) -> ffi::GtkInterfaceColorScheme {
        match self {
            Self::Unsupported => ffi::GTK_INTERFACE_COLOR_SCHEME_UNSUPPORTED,
            Self::Default => ffi::GTK_INTERFACE_COLOR_SCHEME_DEFAULT,
            Self::Dark => ffi::GTK_INTERFACE_COLOR_SCHEME_DARK,
            Self::Light => ffi::GTK_INTERFACE_COLOR_SCHEME_LIGHT,
            Self::__Unknown(value) => value,
        }
    }
}

#[cfg(feature = "v4_20")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
#[doc(hidden)]
impl FromGlib<ffi::GtkInterfaceColorScheme> for InterfaceColorScheme {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkInterfaceColorScheme) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_INTERFACE_COLOR_SCHEME_UNSUPPORTED => Self::Unsupported,
            ffi::GTK_INTERFACE_COLOR_SCHEME_DEFAULT => Self::Default,
            ffi::GTK_INTERFACE_COLOR_SCHEME_DARK => Self::Dark,
            ffi::GTK_INTERFACE_COLOR_SCHEME_LIGHT => Self::Light,
            value => Self::__Unknown(value),
        }
    }
}

#[cfg(feature = "v4_20")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
impl StaticType for InterfaceColorScheme {
    #[inline]
    #[doc(alias = "gtk_interface_color_scheme_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_interface_color_scheme_get_type()) }
    }
}

#[cfg(feature = "v4_20")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
impl glib::HasParamSpec for InterfaceColorScheme {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

#[cfg(feature = "v4_20")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
impl glib::value::ValueType for InterfaceColorScheme {
    type Type = Self;
}

#[cfg(feature = "v4_20")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
unsafe impl<'a> glib::value::FromValue<'a> for InterfaceColorScheme {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

#[cfg(feature = "v4_20")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
impl ToValue for InterfaceColorScheme {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

#[cfg(feature = "v4_20")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
impl From<InterfaceColorScheme> for glib::Value {
    #[inline]
    fn from(v: InterfaceColorScheme) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Values for the [`gtk-interface-contrast`][struct@crate::Settings#gtk-interface-contrast]
/// and [`prefers-contrast`][struct@crate::CssProvider#prefers-contrast] properties
/// that indicates the preferred level of contrast.
///
/// This information can be used inside CSS via media queries.
///
/// More values may be added to this enumeration. Unknown values
/// should be treated the same as `GTK_INTERFACE_CONTRAST_NO_PREFERENCE`.
#[cfg(feature = "v4_20")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkInterfaceContrast")]
pub enum InterfaceContrast {
    /// The system doesn't support contrast levels
    #[doc(alias = "GTK_INTERFACE_CONTRAST_UNSUPPORTED")]
    Unsupported,
    /// No particular preference for contrast
    #[doc(alias = "GTK_INTERFACE_CONTRAST_NO_PREFERENCE")]
    NoPreference,
    /// More contrast is preferred
    #[doc(alias = "GTK_INTERFACE_CONTRAST_MORE")]
    More,
    /// Less contrast is preferred
    #[doc(alias = "GTK_INTERFACE_CONTRAST_LESS")]
    Less,
    #[doc(hidden)]
    __Unknown(i32),
}

#[cfg(feature = "v4_20")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
#[doc(hidden)]
impl IntoGlib for InterfaceContrast {
    type GlibType = ffi::GtkInterfaceContrast;

    #[inline]
    fn into_glib(self) -> ffi::GtkInterfaceContrast {
        match self {
            Self::Unsupported => ffi::GTK_INTERFACE_CONTRAST_UNSUPPORTED,
            Self::NoPreference => ffi::GTK_INTERFACE_CONTRAST_NO_PREFERENCE,
            Self::More => ffi::GTK_INTERFACE_CONTRAST_MORE,
            Self::Less => ffi::GTK_INTERFACE_CONTRAST_LESS,
            Self::__Unknown(value) => value,
        }
    }
}

#[cfg(feature = "v4_20")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
#[doc(hidden)]
impl FromGlib<ffi::GtkInterfaceContrast> for InterfaceContrast {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkInterfaceContrast) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_INTERFACE_CONTRAST_UNSUPPORTED => Self::Unsupported,
            ffi::GTK_INTERFACE_CONTRAST_NO_PREFERENCE => Self::NoPreference,
            ffi::GTK_INTERFACE_CONTRAST_MORE => Self::More,
            ffi::GTK_INTERFACE_CONTRAST_LESS => Self::Less,
            value => Self::__Unknown(value),
        }
    }
}

#[cfg(feature = "v4_20")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
impl StaticType for InterfaceContrast {
    #[inline]
    #[doc(alias = "gtk_interface_contrast_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_interface_contrast_get_type()) }
    }
}

#[cfg(feature = "v4_20")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
impl glib::HasParamSpec for InterfaceContrast {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

#[cfg(feature = "v4_20")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
impl glib::value::ValueType for InterfaceContrast {
    type Type = Self;
}

#[cfg(feature = "v4_20")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
unsafe impl<'a> glib::value::FromValue<'a> for InterfaceContrast {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

#[cfg(feature = "v4_20")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
impl ToValue for InterfaceContrast {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

#[cfg(feature = "v4_20")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
impl From<InterfaceContrast> for glib::Value {
    #[inline]
    fn from(v: InterfaceContrast) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Used for justifying the text inside a [`Label`][crate::Label] widget.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkJustification")]
pub enum Justification {
    /// The text is placed at the left edge of the label.
    #[doc(alias = "GTK_JUSTIFY_LEFT")]
    Left,
    /// The text is placed at the right edge of the label.
    #[doc(alias = "GTK_JUSTIFY_RIGHT")]
    Right,
    /// The text is placed in the center of the label.
    #[doc(alias = "GTK_JUSTIFY_CENTER")]
    Center,
    /// The text is placed is distributed across the label.
    #[doc(alias = "GTK_JUSTIFY_FILL")]
    Fill,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for Justification {
    type GlibType = ffi::GtkJustification;

    #[inline]
    fn into_glib(self) -> ffi::GtkJustification {
        match self {
            Self::Left => ffi::GTK_JUSTIFY_LEFT,
            Self::Right => ffi::GTK_JUSTIFY_RIGHT,
            Self::Center => ffi::GTK_JUSTIFY_CENTER,
            Self::Fill => ffi::GTK_JUSTIFY_FILL,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkJustification> for Justification {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkJustification) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_JUSTIFY_LEFT => Self::Left,
            ffi::GTK_JUSTIFY_RIGHT => Self::Right,
            ffi::GTK_JUSTIFY_CENTER => Self::Center,
            ffi::GTK_JUSTIFY_FILL => Self::Fill,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for Justification {
    #[inline]
    #[doc(alias = "gtk_justification_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_justification_get_type()) }
    }
}

impl glib::HasParamSpec for Justification {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for Justification {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for Justification {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for Justification {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<Justification> for glib::Value {
    #[inline]
    fn from(v: Justification) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Describes how [`LevelBar`][crate::LevelBar] contents should be rendered.
///
/// Note that this enumeration could be extended with additional modes
/// in the future.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkLevelBarMode")]
pub enum LevelBarMode {
    /// the bar has a continuous mode
    #[doc(alias = "GTK_LEVEL_BAR_MODE_CONTINUOUS")]
    Continuous,
    /// the bar has a discrete mode
    #[doc(alias = "GTK_LEVEL_BAR_MODE_DISCRETE")]
    Discrete,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for LevelBarMode {
    type GlibType = ffi::GtkLevelBarMode;

    #[inline]
    fn into_glib(self) -> ffi::GtkLevelBarMode {
        match self {
            Self::Continuous => ffi::GTK_LEVEL_BAR_MODE_CONTINUOUS,
            Self::Discrete => ffi::GTK_LEVEL_BAR_MODE_DISCRETE,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkLevelBarMode> for LevelBarMode {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkLevelBarMode) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_LEVEL_BAR_MODE_CONTINUOUS => Self::Continuous,
            ffi::GTK_LEVEL_BAR_MODE_DISCRETE => Self::Discrete,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for LevelBarMode {
    #[inline]
    #[doc(alias = "gtk_level_bar_mode_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_level_bar_mode_get_type()) }
    }
}

impl glib::HasParamSpec for LevelBarMode {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for LevelBarMode {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for LevelBarMode {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for LevelBarMode {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<LevelBarMode> for glib::Value {
    #[inline]
    fn from(v: LevelBarMode) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// The type of license for an application.
///
/// This enumeration can be expanded at later date.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkLicense")]
pub enum License {
    /// No license specified
    #[doc(alias = "GTK_LICENSE_UNKNOWN")]
    Unknown,
    /// A license text is going to be specified by the
    ///   developer
    #[doc(alias = "GTK_LICENSE_CUSTOM")]
    Custom,
    /// The GNU General Public License, version 2.0 or later
    #[doc(alias = "GTK_LICENSE_GPL_2_0")]
    Gpl20,
    /// The GNU General Public License, version 3.0 or later
    #[doc(alias = "GTK_LICENSE_GPL_3_0")]
    Gpl30,
    /// The GNU Lesser General Public License, version 2.1 or later
    #[doc(alias = "GTK_LICENSE_LGPL_2_1")]
    Lgpl21,
    /// The GNU Lesser General Public License, version 3.0 or later
    #[doc(alias = "GTK_LICENSE_LGPL_3_0")]
    Lgpl30,
    /// The BSD standard license
    #[doc(alias = "GTK_LICENSE_BSD")]
    Bsd,
    /// The MIT/X11 standard license
    #[doc(alias = "GTK_LICENSE_MIT_X11")]
    MitX11,
    /// The Artistic License, version 2.0
    #[doc(alias = "GTK_LICENSE_ARTISTIC")]
    Artistic,
    /// The GNU General Public License, version 2.0 only
    #[doc(alias = "GTK_LICENSE_GPL_2_0_ONLY")]
    Gpl20Only,
    /// The GNU General Public License, version 3.0 only
    #[doc(alias = "GTK_LICENSE_GPL_3_0_ONLY")]
    Gpl30Only,
    /// The GNU Lesser General Public License, version 2.1 only
    #[doc(alias = "GTK_LICENSE_LGPL_2_1_ONLY")]
    Lgpl21Only,
    /// The GNU Lesser General Public License, version 3.0 only
    #[doc(alias = "GTK_LICENSE_LGPL_3_0_ONLY")]
    Lgpl30Only,
    /// The GNU Affero General Public License, version 3.0 or later
    #[doc(alias = "GTK_LICENSE_AGPL_3_0")]
    Agpl30,
    /// The GNU Affero General Public License, version 3.0 only
    #[doc(alias = "GTK_LICENSE_AGPL_3_0_ONLY")]
    Agpl30Only,
    /// The 3-clause BSD licence
    #[doc(alias = "GTK_LICENSE_BSD_3")]
    Bsd3,
    /// The Apache License, version 2.0
    #[doc(alias = "GTK_LICENSE_APACHE_2_0")]
    Apache20,
    /// The Mozilla Public License, version 2.0
    #[doc(alias = "GTK_LICENSE_MPL_2_0")]
    Mpl20,
    /// Zero-Clause BSD license
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    #[doc(alias = "GTK_LICENSE_0BSD")]
    _0bsd,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for License {
    type GlibType = ffi::GtkLicense;

    fn into_glib(self) -> ffi::GtkLicense {
        match self {
            Self::Unknown => ffi::GTK_LICENSE_UNKNOWN,
            Self::Custom => ffi::GTK_LICENSE_CUSTOM,
            Self::Gpl20 => ffi::GTK_LICENSE_GPL_2_0,
            Self::Gpl30 => ffi::GTK_LICENSE_GPL_3_0,
            Self::Lgpl21 => ffi::GTK_LICENSE_LGPL_2_1,
            Self::Lgpl30 => ffi::GTK_LICENSE_LGPL_3_0,
            Self::Bsd => ffi::GTK_LICENSE_BSD,
            Self::MitX11 => ffi::GTK_LICENSE_MIT_X11,
            Self::Artistic => ffi::GTK_LICENSE_ARTISTIC,
            Self::Gpl20Only => ffi::GTK_LICENSE_GPL_2_0_ONLY,
            Self::Gpl30Only => ffi::GTK_LICENSE_GPL_3_0_ONLY,
            Self::Lgpl21Only => ffi::GTK_LICENSE_LGPL_2_1_ONLY,
            Self::Lgpl30Only => ffi::GTK_LICENSE_LGPL_3_0_ONLY,
            Self::Agpl30 => ffi::GTK_LICENSE_AGPL_3_0,
            Self::Agpl30Only => ffi::GTK_LICENSE_AGPL_3_0_ONLY,
            Self::Bsd3 => ffi::GTK_LICENSE_BSD_3,
            Self::Apache20 => ffi::GTK_LICENSE_APACHE_2_0,
            Self::Mpl20 => ffi::GTK_LICENSE_MPL_2_0,
            #[cfg(feature = "v4_14")]
            Self::_0bsd => ffi::GTK_LICENSE_0BSD,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkLicense> for License {
    unsafe fn from_glib(value: ffi::GtkLicense) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_LICENSE_UNKNOWN => Self::Unknown,
            ffi::GTK_LICENSE_CUSTOM => Self::Custom,
            ffi::GTK_LICENSE_GPL_2_0 => Self::Gpl20,
            ffi::GTK_LICENSE_GPL_3_0 => Self::Gpl30,
            ffi::GTK_LICENSE_LGPL_2_1 => Self::Lgpl21,
            ffi::GTK_LICENSE_LGPL_3_0 => Self::Lgpl30,
            ffi::GTK_LICENSE_BSD => Self::Bsd,
            ffi::GTK_LICENSE_MIT_X11 => Self::MitX11,
            ffi::GTK_LICENSE_ARTISTIC => Self::Artistic,
            ffi::GTK_LICENSE_GPL_2_0_ONLY => Self::Gpl20Only,
            ffi::GTK_LICENSE_GPL_3_0_ONLY => Self::Gpl30Only,
            ffi::GTK_LICENSE_LGPL_2_1_ONLY => Self::Lgpl21Only,
            ffi::GTK_LICENSE_LGPL_3_0_ONLY => Self::Lgpl30Only,
            ffi::GTK_LICENSE_AGPL_3_0 => Self::Agpl30,
            ffi::GTK_LICENSE_AGPL_3_0_ONLY => Self::Agpl30Only,
            ffi::GTK_LICENSE_BSD_3 => Self::Bsd3,
            ffi::GTK_LICENSE_APACHE_2_0 => Self::Apache20,
            ffi::GTK_LICENSE_MPL_2_0 => Self::Mpl20,
            #[cfg(feature = "v4_14")]
            ffi::GTK_LICENSE_0BSD => Self::_0bsd,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for License {
    #[inline]
    #[doc(alias = "gtk_license_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_license_get_type()) }
    }
}

impl glib::HasParamSpec for License {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for License {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for License {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for License {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<License> for glib::Value {
    #[inline]
    fn from(v: License) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Used to configure the focus behavior in the `GTK_DIR_TAB_FORWARD`
/// and `GTK_DIR_TAB_BACKWARD` direction, like the <kbd>Tab</kbd> key
/// in a [`ListView`][crate::ListView].
#[cfg(feature = "v4_12")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkListTabBehavior")]
pub enum ListTabBehavior {
    /// Cycle through all focusable items of the list
    #[doc(alias = "GTK_LIST_TAB_ALL")]
    All,
    /// Cycle through a single list element, then move
    ///   focus out of the list. Moving focus between items needs to be
    ///   done with the arrow keys.
    #[doc(alias = "GTK_LIST_TAB_ITEM")]
    Item,
    /// Cycle only through a single cell, then
    ///   move focus out of the list. Moving focus between cells needs to
    ///   be done with the arrow keys. This is only relevant for
    ///   cell-based widgets like #GtkColumnView, otherwise it behaves
    ///   like `GTK_LIST_TAB_ITEM`.
    #[doc(alias = "GTK_LIST_TAB_CELL")]
    Cell,
    #[doc(hidden)]
    __Unknown(i32),
}

#[cfg(feature = "v4_12")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
#[doc(hidden)]
impl IntoGlib for ListTabBehavior {
    type GlibType = ffi::GtkListTabBehavior;

    #[inline]
    fn into_glib(self) -> ffi::GtkListTabBehavior {
        match self {
            Self::All => ffi::GTK_LIST_TAB_ALL,
            Self::Item => ffi::GTK_LIST_TAB_ITEM,
            Self::Cell => ffi::GTK_LIST_TAB_CELL,
            Self::__Unknown(value) => value,
        }
    }
}

#[cfg(feature = "v4_12")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
#[doc(hidden)]
impl FromGlib<ffi::GtkListTabBehavior> for ListTabBehavior {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkListTabBehavior) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_LIST_TAB_ALL => Self::All,
            ffi::GTK_LIST_TAB_ITEM => Self::Item,
            ffi::GTK_LIST_TAB_CELL => Self::Cell,
            value => Self::__Unknown(value),
        }
    }
}

#[cfg(feature = "v4_12")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
impl StaticType for ListTabBehavior {
    #[inline]
    #[doc(alias = "gtk_list_tab_behavior_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_list_tab_behavior_get_type()) }
    }
}

#[cfg(feature = "v4_12")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
impl glib::HasParamSpec for ListTabBehavior {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

#[cfg(feature = "v4_12")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
impl glib::value::ValueType for ListTabBehavior {
    type Type = Self;
}

#[cfg(feature = "v4_12")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
unsafe impl<'a> glib::value::FromValue<'a> for ListTabBehavior {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

#[cfg(feature = "v4_12")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
impl ToValue for ListTabBehavior {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

#[cfg(feature = "v4_12")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
impl From<ListTabBehavior> for glib::Value {
    #[inline]
    fn from(v: ListTabBehavior) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// The type of message being displayed in a [`MessageDialog`][crate::MessageDialog].
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkMessageType")]
pub enum MessageType {
    /// Informational message
    #[doc(alias = "GTK_MESSAGE_INFO")]
    Info,
    /// Non-fatal warning message
    #[doc(alias = "GTK_MESSAGE_WARNING")]
    Warning,
    /// Question requiring a choice
    #[doc(alias = "GTK_MESSAGE_QUESTION")]
    Question,
    /// Fatal error message
    #[doc(alias = "GTK_MESSAGE_ERROR")]
    Error,
    /// None of the above
    #[doc(alias = "GTK_MESSAGE_OTHER")]
    Other,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for MessageType {
    type GlibType = ffi::GtkMessageType;

    #[inline]
    fn into_glib(self) -> ffi::GtkMessageType {
        match self {
            Self::Info => ffi::GTK_MESSAGE_INFO,
            Self::Warning => ffi::GTK_MESSAGE_WARNING,
            Self::Question => ffi::GTK_MESSAGE_QUESTION,
            Self::Error => ffi::GTK_MESSAGE_ERROR,
            Self::Other => ffi::GTK_MESSAGE_OTHER,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkMessageType> for MessageType {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkMessageType) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_MESSAGE_INFO => Self::Info,
            ffi::GTK_MESSAGE_WARNING => Self::Warning,
            ffi::GTK_MESSAGE_QUESTION => Self::Question,
            ffi::GTK_MESSAGE_ERROR => Self::Error,
            ffi::GTK_MESSAGE_OTHER => Self::Other,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for MessageType {
    #[inline]
    #[doc(alias = "gtk_message_type_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_message_type_get_type()) }
    }
}

impl glib::HasParamSpec for MessageType {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for MessageType {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for MessageType {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for MessageType {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<MessageType> for glib::Value {
    #[inline]
    fn from(v: MessageType) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Passed as argument to various keybinding signals for moving the
/// cursor position.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkMovementStep")]
pub enum MovementStep {
    /// Move forward or back by graphemes
    #[doc(alias = "GTK_MOVEMENT_LOGICAL_POSITIONS")]
    LogicalPositions,
    /// Move left or right by graphemes
    #[doc(alias = "GTK_MOVEMENT_VISUAL_POSITIONS")]
    VisualPositions,
    /// Move forward or back by words
    #[doc(alias = "GTK_MOVEMENT_WORDS")]
    Words,
    /// Move up or down lines (wrapped lines)
    #[doc(alias = "GTK_MOVEMENT_DISPLAY_LINES")]
    DisplayLines,
    /// Move to either end of a line
    #[doc(alias = "GTK_MOVEMENT_DISPLAY_LINE_ENDS")]
    DisplayLineEnds,
    /// Move up or down paragraphs (newline-ended lines)
    #[doc(alias = "GTK_MOVEMENT_PARAGRAPHS")]
    Paragraphs,
    /// Move to either end of a paragraph
    #[doc(alias = "GTK_MOVEMENT_PARAGRAPH_ENDS")]
    ParagraphEnds,
    /// Move by pages
    #[doc(alias = "GTK_MOVEMENT_PAGES")]
    Pages,
    /// Move to ends of the buffer
    #[doc(alias = "GTK_MOVEMENT_BUFFER_ENDS")]
    BufferEnds,
    /// Move horizontally by pages
    #[doc(alias = "GTK_MOVEMENT_HORIZONTAL_PAGES")]
    HorizontalPages,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for MovementStep {
    type GlibType = ffi::GtkMovementStep;

    #[inline]
    fn into_glib(self) -> ffi::GtkMovementStep {
        match self {
            Self::LogicalPositions => ffi::GTK_MOVEMENT_LOGICAL_POSITIONS,
            Self::VisualPositions => ffi::GTK_MOVEMENT_VISUAL_POSITIONS,
            Self::Words => ffi::GTK_MOVEMENT_WORDS,
            Self::DisplayLines => ffi::GTK_MOVEMENT_DISPLAY_LINES,
            Self::DisplayLineEnds => ffi::GTK_MOVEMENT_DISPLAY_LINE_ENDS,
            Self::Paragraphs => ffi::GTK_MOVEMENT_PARAGRAPHS,
            Self::ParagraphEnds => ffi::GTK_MOVEMENT_PARAGRAPH_ENDS,
            Self::Pages => ffi::GTK_MOVEMENT_PAGES,
            Self::BufferEnds => ffi::GTK_MOVEMENT_BUFFER_ENDS,
            Self::HorizontalPages => ffi::GTK_MOVEMENT_HORIZONTAL_PAGES,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkMovementStep> for MovementStep {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkMovementStep) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_MOVEMENT_LOGICAL_POSITIONS => Self::LogicalPositions,
            ffi::GTK_MOVEMENT_VISUAL_POSITIONS => Self::VisualPositions,
            ffi::GTK_MOVEMENT_WORDS => Self::Words,
            ffi::GTK_MOVEMENT_DISPLAY_LINES => Self::DisplayLines,
            ffi::GTK_MOVEMENT_DISPLAY_LINE_ENDS => Self::DisplayLineEnds,
            ffi::GTK_MOVEMENT_PARAGRAPHS => Self::Paragraphs,
            ffi::GTK_MOVEMENT_PARAGRAPH_ENDS => Self::ParagraphEnds,
            ffi::GTK_MOVEMENT_PAGES => Self::Pages,
            ffi::GTK_MOVEMENT_BUFFER_ENDS => Self::BufferEnds,
            ffi::GTK_MOVEMENT_HORIZONTAL_PAGES => Self::HorizontalPages,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for MovementStep {
    #[inline]
    #[doc(alias = "gtk_movement_step_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_movement_step_get_type()) }
    }
}

impl glib::HasParamSpec for MovementStep {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for MovementStep {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for MovementStep {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for MovementStep {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<MovementStep> for glib::Value {
    #[inline]
    fn from(v: MovementStep) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Options for selecting a different wrap mode for natural size
/// requests.
///
/// See for example the [`natural-wrap-mode`][struct@crate::Label#natural-wrap-mode] property.
#[cfg(feature = "v4_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkNaturalWrapMode")]
pub enum NaturalWrapMode {
    /// Inherit the minimum size request.
    ///   In particular, this should be used with [`pango::WrapMode::Char`][crate::pango::WrapMode::Char].
    #[doc(alias = "GTK_NATURAL_WRAP_INHERIT")]
    Inherit,
    /// Try not to wrap the text. This mode is the
    ///   closest to GTK3's behavior but can lead to a wide label leaving
    ///   lots of empty space below the text.
    #[doc(alias = "GTK_NATURAL_WRAP_NONE")]
    None,
    /// Attempt to wrap at word boundaries. This
    ///   is useful in particular when using [`pango::WrapMode::WordChar`][crate::pango::WrapMode::WordChar] as the
    ///   wrap mode.
    #[doc(alias = "GTK_NATURAL_WRAP_WORD")]
    Word,
    #[doc(hidden)]
    __Unknown(i32),
}

#[cfg(feature = "v4_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
#[doc(hidden)]
impl IntoGlib for NaturalWrapMode {
    type GlibType = ffi::GtkNaturalWrapMode;

    #[inline]
    fn into_glib(self) -> ffi::GtkNaturalWrapMode {
        match self {
            Self::Inherit => ffi::GTK_NATURAL_WRAP_INHERIT,
            Self::None => ffi::GTK_NATURAL_WRAP_NONE,
            Self::Word => ffi::GTK_NATURAL_WRAP_WORD,
            Self::__Unknown(value) => value,
        }
    }
}

#[cfg(feature = "v4_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
#[doc(hidden)]
impl FromGlib<ffi::GtkNaturalWrapMode> for NaturalWrapMode {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkNaturalWrapMode) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_NATURAL_WRAP_INHERIT => Self::Inherit,
            ffi::GTK_NATURAL_WRAP_NONE => Self::None,
            ffi::GTK_NATURAL_WRAP_WORD => Self::Word,
            value => Self::__Unknown(value),
        }
    }
}

#[cfg(feature = "v4_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
impl StaticType for NaturalWrapMode {
    #[inline]
    #[doc(alias = "gtk_natural_wrap_mode_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_natural_wrap_mode_get_type()) }
    }
}

#[cfg(feature = "v4_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
impl glib::HasParamSpec for NaturalWrapMode {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

#[cfg(feature = "v4_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
impl glib::value::ValueType for NaturalWrapMode {
    type Type = Self;
}

#[cfg(feature = "v4_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
unsafe impl<'a> glib::value::FromValue<'a> for NaturalWrapMode {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

#[cfg(feature = "v4_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
impl ToValue for NaturalWrapMode {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

#[cfg(feature = "v4_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
impl From<NaturalWrapMode> for glib::Value {
    #[inline]
    fn from(v: NaturalWrapMode) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// The parameter used in the action signals of [`Notebook`][crate::Notebook].
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkNotebookTab")]
pub enum NotebookTab {
    /// the first tab in the notebook
    #[doc(alias = "GTK_NOTEBOOK_TAB_FIRST")]
    First,
    /// the last tab in the notebook
    #[doc(alias = "GTK_NOTEBOOK_TAB_LAST")]
    Last,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for NotebookTab {
    type GlibType = ffi::GtkNotebookTab;

    #[inline]
    fn into_glib(self) -> ffi::GtkNotebookTab {
        match self {
            Self::First => ffi::GTK_NOTEBOOK_TAB_FIRST,
            Self::Last => ffi::GTK_NOTEBOOK_TAB_LAST,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkNotebookTab> for NotebookTab {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkNotebookTab) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_NOTEBOOK_TAB_FIRST => Self::First,
            ffi::GTK_NOTEBOOK_TAB_LAST => Self::Last,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for NotebookTab {
    #[inline]
    #[doc(alias = "gtk_notebook_tab_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_notebook_tab_get_type()) }
    }
}

impl glib::HasParamSpec for NotebookTab {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for NotebookTab {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for NotebookTab {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for NotebookTab {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<NotebookTab> for glib::Value {
    #[inline]
    fn from(v: NotebookTab) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Used to determine the layout of pages on a sheet when printing
/// multiple pages per sheet.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkNumberUpLayout")]
pub enum NumberUpLayout {
    /// ![](layout-lrtb.png)
    #[doc(alias = "GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM")]
    Lrtb,
    /// ![](layout-lrbt.png)
    #[doc(alias = "GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_BOTTOM_TO_TOP")]
    Lrbt,
    /// ![](layout-rltb.png)
    #[doc(alias = "GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM")]
    Rltb,
    /// ![](layout-rlbt.png)
    #[doc(alias = "GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_BOTTOM_TO_TOP")]
    Rlbt,
    /// ![](layout-tblr.png)
    #[doc(alias = "GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_LEFT_TO_RIGHT")]
    Tblr,
    /// ![](layout-tbrl.png)
    #[doc(alias = "GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_RIGHT_TO_LEFT")]
    Tbrl,
    /// ![](layout-btlr.png)
    #[doc(alias = "GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_LEFT_TO_RIGHT")]
    Btlr,
    /// ![](layout-btrl.png)
    #[doc(alias = "GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_RIGHT_TO_LEFT")]
    Btrl,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for NumberUpLayout {
    type GlibType = ffi::GtkNumberUpLayout;

    #[inline]
    fn into_glib(self) -> ffi::GtkNumberUpLayout {
        match self {
            Self::Lrtb => ffi::GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM,
            Self::Lrbt => ffi::GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_BOTTOM_TO_TOP,
            Self::Rltb => ffi::GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM,
            Self::Rlbt => ffi::GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_BOTTOM_TO_TOP,
            Self::Tblr => ffi::GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_LEFT_TO_RIGHT,
            Self::Tbrl => ffi::GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_RIGHT_TO_LEFT,
            Self::Btlr => ffi::GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_LEFT_TO_RIGHT,
            Self::Btrl => ffi::GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_RIGHT_TO_LEFT,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkNumberUpLayout> for NumberUpLayout {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkNumberUpLayout) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM => Self::Lrtb,
            ffi::GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_BOTTOM_TO_TOP => Self::Lrbt,
            ffi::GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM => Self::Rltb,
            ffi::GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_BOTTOM_TO_TOP => Self::Rlbt,
            ffi::GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_LEFT_TO_RIGHT => Self::Tblr,
            ffi::GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_RIGHT_TO_LEFT => Self::Tbrl,
            ffi::GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_LEFT_TO_RIGHT => Self::Btlr,
            ffi::GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_RIGHT_TO_LEFT => Self::Btrl,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for NumberUpLayout {
    #[inline]
    #[doc(alias = "gtk_number_up_layout_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_number_up_layout_get_type()) }
    }
}

impl glib::HasParamSpec for NumberUpLayout {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for NumberUpLayout {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for NumberUpLayout {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for NumberUpLayout {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<NumberUpLayout> for glib::Value {
    #[inline]
    fn from(v: NumberUpLayout) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Describes the way two values can be compared.
///
/// These values can be used with a `callback::GLib::CompareFunc. However,
/// a `GCompareFunc` is allowed to return any integer values.
/// For converting such a value to a [`Ordering`][crate::Ordering] value, use
/// `Gtk::Ordering::from_cmpfunc()`.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkOrdering")]
pub enum Ordering {
    /// the first value is smaller than the second
    #[doc(alias = "GTK_ORDERING_SMALLER")]
    Smaller,
    /// the two values are equal
    #[doc(alias = "GTK_ORDERING_EQUAL")]
    Equal,
    /// the first value is larger than the second
    #[doc(alias = "GTK_ORDERING_LARGER")]
    Larger,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for Ordering {
    type GlibType = ffi::GtkOrdering;

    #[inline]
    fn into_glib(self) -> ffi::GtkOrdering {
        match self {
            Self::Smaller => ffi::GTK_ORDERING_SMALLER,
            Self::Equal => ffi::GTK_ORDERING_EQUAL,
            Self::Larger => ffi::GTK_ORDERING_LARGER,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkOrdering> for Ordering {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkOrdering) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_ORDERING_SMALLER => Self::Smaller,
            ffi::GTK_ORDERING_EQUAL => Self::Equal,
            ffi::GTK_ORDERING_LARGER => Self::Larger,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for Ordering {
    #[inline]
    #[doc(alias = "gtk_ordering_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_ordering_get_type()) }
    }
}

impl glib::HasParamSpec for Ordering {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for Ordering {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for Ordering {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for Ordering {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<Ordering> for glib::Value {
    #[inline]
    fn from(v: Ordering) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Represents the orientation of widgets and other objects.
///
/// Typical examples are [`Box`][crate::Box] or [`GesturePan`][crate::GesturePan].
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkOrientation")]
pub enum Orientation {
    /// The element is in horizontal orientation.
    #[doc(alias = "GTK_ORIENTATION_HORIZONTAL")]
    Horizontal,
    /// The element is in vertical orientation.
    #[doc(alias = "GTK_ORIENTATION_VERTICAL")]
    Vertical,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for Orientation {
    type GlibType = ffi::GtkOrientation;

    #[inline]
    fn into_glib(self) -> ffi::GtkOrientation {
        match self {
            Self::Horizontal => ffi::GTK_ORIENTATION_HORIZONTAL,
            Self::Vertical => ffi::GTK_ORIENTATION_VERTICAL,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkOrientation> for Orientation {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkOrientation) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_ORIENTATION_HORIZONTAL => Self::Horizontal,
            ffi::GTK_ORIENTATION_VERTICAL => Self::Vertical,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for Orientation {
    #[inline]
    #[doc(alias = "gtk_orientation_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_orientation_get_type()) }
    }
}

impl glib::HasParamSpec for Orientation {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for Orientation {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for Orientation {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for Orientation {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<Orientation> for glib::Value {
    #[inline]
    fn from(v: Orientation) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Defines how content overflowing a given area should be handled.
///
/// This is used in [`WidgetExt::set_overflow()`][crate::prelude::WidgetExt::set_overflow()]. The
/// [`overflow`][struct@crate::Widget#overflow] property is modeled after the
/// CSS overflow property, but implements it only partially.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkOverflow")]
pub enum Overflow {
    /// No change is applied. Content is drawn at the specified
    ///   position.
    #[doc(alias = "GTK_OVERFLOW_VISIBLE")]
    Visible,
    /// Content is clipped to the bounds of the area. Content
    ///   outside the area is not drawn and cannot be interacted with.
    #[doc(alias = "GTK_OVERFLOW_HIDDEN")]
    Hidden,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for Overflow {
    type GlibType = ffi::GtkOverflow;

    #[inline]
    fn into_glib(self) -> ffi::GtkOverflow {
        match self {
            Self::Visible => ffi::GTK_OVERFLOW_VISIBLE,
            Self::Hidden => ffi::GTK_OVERFLOW_HIDDEN,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkOverflow> for Overflow {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkOverflow) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_OVERFLOW_VISIBLE => Self::Visible,
            ffi::GTK_OVERFLOW_HIDDEN => Self::Hidden,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for Overflow {
    #[inline]
    #[doc(alias = "gtk_overflow_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_overflow_get_type()) }
    }
}

impl glib::HasParamSpec for Overflow {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for Overflow {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for Overflow {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for Overflow {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<Overflow> for glib::Value {
    #[inline]
    fn from(v: Overflow) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Represents the packing location of a children in its parent.
///
/// See [`WindowControls`][crate::WindowControls] for example.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkPackType")]
pub enum PackType {
    /// The child is packed into the start of the widget
    #[doc(alias = "GTK_PACK_START")]
    Start,
    /// The child is packed into the end of the widget
    #[doc(alias = "GTK_PACK_END")]
    End,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for PackType {
    type GlibType = ffi::GtkPackType;

    #[inline]
    fn into_glib(self) -> ffi::GtkPackType {
        match self {
            Self::Start => ffi::GTK_PACK_START,
            Self::End => ffi::GTK_PACK_END,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkPackType> for PackType {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkPackType) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_PACK_START => Self::Start,
            ffi::GTK_PACK_END => Self::End,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for PackType {
    #[inline]
    #[doc(alias = "gtk_pack_type_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_pack_type_get_type()) }
    }
}

impl glib::HasParamSpec for PackType {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for PackType {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for PackType {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for PackType {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<PackType> for glib::Value {
    #[inline]
    fn from(v: PackType) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// The type of a pad action.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkPadActionType")]
pub enum PadActionType {
    /// Action is triggered by a pad button
    #[doc(alias = "GTK_PAD_ACTION_BUTTON")]
    Button,
    /// Action is triggered by a pad ring
    #[doc(alias = "GTK_PAD_ACTION_RING")]
    Ring,
    /// Action is triggered by a pad strip
    #[doc(alias = "GTK_PAD_ACTION_STRIP")]
    Strip,
    /// Action is triggered by a pad dial
    #[doc(alias = "GTK_PAD_ACTION_DIAL")]
    Dial,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for PadActionType {
    type GlibType = ffi::GtkPadActionType;

    #[inline]
    fn into_glib(self) -> ffi::GtkPadActionType {
        match self {
            Self::Button => ffi::GTK_PAD_ACTION_BUTTON,
            Self::Ring => ffi::GTK_PAD_ACTION_RING,
            Self::Strip => ffi::GTK_PAD_ACTION_STRIP,
            Self::Dial => ffi::GTK_PAD_ACTION_DIAL,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkPadActionType> for PadActionType {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkPadActionType) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_PAD_ACTION_BUTTON => Self::Button,
            ffi::GTK_PAD_ACTION_RING => Self::Ring,
            ffi::GTK_PAD_ACTION_STRIP => Self::Strip,
            ffi::GTK_PAD_ACTION_DIAL => Self::Dial,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for PadActionType {
    #[inline]
    #[doc(alias = "gtk_pad_action_type_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_pad_action_type_get_type()) }
    }
}

impl glib::HasParamSpec for PadActionType {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for PadActionType {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for PadActionType {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for PadActionType {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<PadActionType> for glib::Value {
    #[inline]
    fn from(v: PadActionType) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// See also gtk_print_settings_set_orientation().
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkPageOrientation")]
pub enum PageOrientation {
    /// Portrait mode.
    #[doc(alias = "GTK_PAGE_ORIENTATION_PORTRAIT")]
    Portrait,
    /// Landscape mode.
    #[doc(alias = "GTK_PAGE_ORIENTATION_LANDSCAPE")]
    Landscape,
    /// Reverse portrait mode.
    #[doc(alias = "GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT")]
    ReversePortrait,
    /// Reverse landscape mode.
    #[doc(alias = "GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE")]
    ReverseLandscape,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for PageOrientation {
    type GlibType = ffi::GtkPageOrientation;

    #[inline]
    fn into_glib(self) -> ffi::GtkPageOrientation {
        match self {
            Self::Portrait => ffi::GTK_PAGE_ORIENTATION_PORTRAIT,
            Self::Landscape => ffi::GTK_PAGE_ORIENTATION_LANDSCAPE,
            Self::ReversePortrait => ffi::GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT,
            Self::ReverseLandscape => ffi::GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkPageOrientation> for PageOrientation {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkPageOrientation) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_PAGE_ORIENTATION_PORTRAIT => Self::Portrait,
            ffi::GTK_PAGE_ORIENTATION_LANDSCAPE => Self::Landscape,
            ffi::GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT => Self::ReversePortrait,
            ffi::GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE => Self::ReverseLandscape,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for PageOrientation {
    #[inline]
    #[doc(alias = "gtk_page_orientation_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_page_orientation_get_type()) }
    }
}

impl glib::HasParamSpec for PageOrientation {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for PageOrientation {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for PageOrientation {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for PageOrientation {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<PageOrientation> for glib::Value {
    #[inline]
    fn from(v: PageOrientation) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// See also gtk_print_job_set_page_set().
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkPageSet")]
pub enum PageSet {
    /// All pages.
    #[doc(alias = "GTK_PAGE_SET_ALL")]
    All,
    /// Even pages.
    #[doc(alias = "GTK_PAGE_SET_EVEN")]
    Even,
    /// Odd pages.
    #[doc(alias = "GTK_PAGE_SET_ODD")]
    Odd,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for PageSet {
    type GlibType = ffi::GtkPageSet;

    #[inline]
    fn into_glib(self) -> ffi::GtkPageSet {
        match self {
            Self::All => ffi::GTK_PAGE_SET_ALL,
            Self::Even => ffi::GTK_PAGE_SET_EVEN,
            Self::Odd => ffi::GTK_PAGE_SET_ODD,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkPageSet> for PageSet {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkPageSet) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_PAGE_SET_ALL => Self::All,
            ffi::GTK_PAGE_SET_EVEN => Self::Even,
            ffi::GTK_PAGE_SET_ODD => Self::Odd,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for PageSet {
    #[inline]
    #[doc(alias = "gtk_page_set_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_page_set_get_type()) }
    }
}

impl glib::HasParamSpec for PageSet {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for PageSet {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for PageSet {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for PageSet {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<PageSet> for glib::Value {
    #[inline]
    fn from(v: PageSet) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Describes the panning direction of a [`GesturePan`][crate::GesturePan].
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkPanDirection")]
pub enum PanDirection {
    /// panned towards the left
    #[doc(alias = "GTK_PAN_DIRECTION_LEFT")]
    Left,
    /// panned towards the right
    #[doc(alias = "GTK_PAN_DIRECTION_RIGHT")]
    Right,
    /// panned upwards
    #[doc(alias = "GTK_PAN_DIRECTION_UP")]
    Up,
    /// panned downwards
    #[doc(alias = "GTK_PAN_DIRECTION_DOWN")]
    Down,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for PanDirection {
    type GlibType = ffi::GtkPanDirection;

    #[inline]
    fn into_glib(self) -> ffi::GtkPanDirection {
        match self {
            Self::Left => ffi::GTK_PAN_DIRECTION_LEFT,
            Self::Right => ffi::GTK_PAN_DIRECTION_RIGHT,
            Self::Up => ffi::GTK_PAN_DIRECTION_UP,
            Self::Down => ffi::GTK_PAN_DIRECTION_DOWN,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkPanDirection> for PanDirection {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkPanDirection) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_PAN_DIRECTION_LEFT => Self::Left,
            ffi::GTK_PAN_DIRECTION_RIGHT => Self::Right,
            ffi::GTK_PAN_DIRECTION_UP => Self::Up,
            ffi::GTK_PAN_DIRECTION_DOWN => Self::Down,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for PanDirection {
    #[inline]
    #[doc(alias = "gtk_pan_direction_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_pan_direction_get_type()) }
    }
}

impl glib::HasParamSpec for PanDirection {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for PanDirection {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for PanDirection {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for PanDirection {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<PanDirection> for glib::Value {
    #[inline]
    fn from(v: PanDirection) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Determines how the size should be computed to achieve the one of the
/// visibility mode for the scrollbars.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkPolicyType")]
pub enum PolicyType {
    /// The scrollbar is always visible. The view size is
    ///   independent of the content.
    #[doc(alias = "GTK_POLICY_ALWAYS")]
    Always,
    /// The scrollbar will appear and disappear as necessary.
    ///   For example, when all of a [`TreeView`][crate::TreeView] can not be seen.
    #[doc(alias = "GTK_POLICY_AUTOMATIC")]
    Automatic,
    /// The scrollbar should never appear. In this mode the
    ///   content determines the size.
    #[doc(alias = "GTK_POLICY_NEVER")]
    Never,
    /// Don't show a scrollbar, but don't force the
    ///   size to follow the content. This can be used e.g. to make multiple
    ///   scrolled windows share a scrollbar.
    #[doc(alias = "GTK_POLICY_EXTERNAL")]
    External,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for PolicyType {
    type GlibType = ffi::GtkPolicyType;

    #[inline]
    fn into_glib(self) -> ffi::GtkPolicyType {
        match self {
            Self::Always => ffi::GTK_POLICY_ALWAYS,
            Self::Automatic => ffi::GTK_POLICY_AUTOMATIC,
            Self::Never => ffi::GTK_POLICY_NEVER,
            Self::External => ffi::GTK_POLICY_EXTERNAL,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkPolicyType> for PolicyType {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkPolicyType) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_POLICY_ALWAYS => Self::Always,
            ffi::GTK_POLICY_AUTOMATIC => Self::Automatic,
            ffi::GTK_POLICY_NEVER => Self::Never,
            ffi::GTK_POLICY_EXTERNAL => Self::External,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for PolicyType {
    #[inline]
    #[doc(alias = "gtk_policy_type_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_policy_type_get_type()) }
    }
}

impl glib::HasParamSpec for PolicyType {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for PolicyType {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for PolicyType {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for PolicyType {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<PolicyType> for glib::Value {
    #[inline]
    fn from(v: PolicyType) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Describes which edge of a widget a certain feature is positioned at.
///
/// For examples, see the tabs of a [`Notebook`][crate::Notebook], or the label
/// of a [`Scale`][crate::Scale].
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkPositionType")]
pub enum PositionType {
    /// The feature is at the left edge.
    #[doc(alias = "GTK_POS_LEFT")]
    Left,
    /// The feature is at the right edge.
    #[doc(alias = "GTK_POS_RIGHT")]
    Right,
    /// The feature is at the top edge.
    #[doc(alias = "GTK_POS_TOP")]
    Top,
    /// The feature is at the bottom edge.
    #[doc(alias = "GTK_POS_BOTTOM")]
    Bottom,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for PositionType {
    type GlibType = ffi::GtkPositionType;

    #[inline]
    fn into_glib(self) -> ffi::GtkPositionType {
        match self {
            Self::Left => ffi::GTK_POS_LEFT,
            Self::Right => ffi::GTK_POS_RIGHT,
            Self::Top => ffi::GTK_POS_TOP,
            Self::Bottom => ffi::GTK_POS_BOTTOM,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkPositionType> for PositionType {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkPositionType) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_POS_LEFT => Self::Left,
            ffi::GTK_POS_RIGHT => Self::Right,
            ffi::GTK_POS_TOP => Self::Top,
            ffi::GTK_POS_BOTTOM => Self::Bottom,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for PositionType {
    #[inline]
    #[doc(alias = "gtk_position_type_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_position_type_get_type()) }
    }
}

impl glib::HasParamSpec for PositionType {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for PositionType {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for PositionType {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for PositionType {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<PositionType> for glib::Value {
    #[inline]
    fn from(v: PositionType) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// See also gtk_print_settings_set_duplex().
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkPrintDuplex")]
pub enum PrintDuplex {
    /// No duplex.
    #[doc(alias = "GTK_PRINT_DUPLEX_SIMPLEX")]
    Simplex,
    /// Horizontal duplex.
    #[doc(alias = "GTK_PRINT_DUPLEX_HORIZONTAL")]
    Horizontal,
    /// Vertical duplex.
    #[doc(alias = "GTK_PRINT_DUPLEX_VERTICAL")]
    Vertical,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for PrintDuplex {
    type GlibType = ffi::GtkPrintDuplex;

    #[inline]
    fn into_glib(self) -> ffi::GtkPrintDuplex {
        match self {
            Self::Simplex => ffi::GTK_PRINT_DUPLEX_SIMPLEX,
            Self::Horizontal => ffi::GTK_PRINT_DUPLEX_HORIZONTAL,
            Self::Vertical => ffi::GTK_PRINT_DUPLEX_VERTICAL,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkPrintDuplex> for PrintDuplex {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkPrintDuplex) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_PRINT_DUPLEX_SIMPLEX => Self::Simplex,
            ffi::GTK_PRINT_DUPLEX_HORIZONTAL => Self::Horizontal,
            ffi::GTK_PRINT_DUPLEX_VERTICAL => Self::Vertical,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for PrintDuplex {
    #[inline]
    #[doc(alias = "gtk_print_duplex_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_print_duplex_get_type()) }
    }
}

impl glib::HasParamSpec for PrintDuplex {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for PrintDuplex {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for PrintDuplex {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for PrintDuplex {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<PrintDuplex> for glib::Value {
    #[inline]
    fn from(v: PrintDuplex) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Error codes that identify various errors that can occur while
/// using the GTK printing support.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkPrintError")]
pub enum PrintError {
    /// An unspecified error occurred.
    #[doc(alias = "GTK_PRINT_ERROR_GENERAL")]
    General,
    /// An internal error occurred.
    #[doc(alias = "GTK_PRINT_ERROR_INTERNAL_ERROR")]
    InternalError,
    /// A memory allocation failed.
    #[doc(alias = "GTK_PRINT_ERROR_NOMEM")]
    Nomem,
    /// An error occurred while loading a page setup
    ///   or paper size from a key file.
    #[doc(alias = "GTK_PRINT_ERROR_INVALID_FILE")]
    InvalidFile,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for PrintError {
    type GlibType = ffi::GtkPrintError;

    #[inline]
    fn into_glib(self) -> ffi::GtkPrintError {
        match self {
            Self::General => ffi::GTK_PRINT_ERROR_GENERAL,
            Self::InternalError => ffi::GTK_PRINT_ERROR_INTERNAL_ERROR,
            Self::Nomem => ffi::GTK_PRINT_ERROR_NOMEM,
            Self::InvalidFile => ffi::GTK_PRINT_ERROR_INVALID_FILE,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkPrintError> for PrintError {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkPrintError) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_PRINT_ERROR_GENERAL => Self::General,
            ffi::GTK_PRINT_ERROR_INTERNAL_ERROR => Self::InternalError,
            ffi::GTK_PRINT_ERROR_NOMEM => Self::Nomem,
            ffi::GTK_PRINT_ERROR_INVALID_FILE => Self::InvalidFile,
            value => Self::__Unknown(value),
        }
    }
}

impl glib::error::ErrorDomain for PrintError {
    #[inline]
    fn domain() -> glib::Quark {
        skip_assert_initialized!();

        unsafe { from_glib(ffi::gtk_print_error_quark()) }
    }

    #[inline]
    fn code(self) -> i32 {
        self.into_glib()
    }

    #[inline]
    #[allow(clippy::match_single_binding)]
    fn from(code: i32) -> Option<Self> {
        skip_assert_initialized!();
        match unsafe { from_glib(code) } {
            value => Some(value),
        }
    }
}

impl StaticType for PrintError {
    #[inline]
    #[doc(alias = "gtk_print_error_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_print_error_get_type()) }
    }
}

impl glib::HasParamSpec for PrintError {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for PrintError {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for PrintError {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for PrintError {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<PrintError> for glib::Value {
    #[inline]
    fn from(v: PrintError) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Determines what action the print operation should perform.
///
/// A parameter of this typs is passed to [`PrintOperationExt::run()`][crate::prelude::PrintOperationExt::run()].
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkPrintOperationAction")]
pub enum PrintOperationAction {
    /// Show the print dialog.
    #[doc(alias = "GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG")]
    PrintDialog,
    /// Start to print without showing
    ///   the print dialog, based on the current print settings, if possible.
    ///   Depending on the platform, a print dialog might appear anyway.
    #[doc(alias = "GTK_PRINT_OPERATION_ACTION_PRINT")]
    Print,
    /// Show the print preview.
    #[doc(alias = "GTK_PRINT_OPERATION_ACTION_PREVIEW")]
    Preview,
    /// Export to a file. This requires
    ///   the export-filename property to be set.
    #[doc(alias = "GTK_PRINT_OPERATION_ACTION_EXPORT")]
    Export,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for PrintOperationAction {
    type GlibType = ffi::GtkPrintOperationAction;

    #[inline]
    fn into_glib(self) -> ffi::GtkPrintOperationAction {
        match self {
            Self::PrintDialog => ffi::GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG,
            Self::Print => ffi::GTK_PRINT_OPERATION_ACTION_PRINT,
            Self::Preview => ffi::GTK_PRINT_OPERATION_ACTION_PREVIEW,
            Self::Export => ffi::GTK_PRINT_OPERATION_ACTION_EXPORT,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkPrintOperationAction> for PrintOperationAction {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkPrintOperationAction) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG => Self::PrintDialog,
            ffi::GTK_PRINT_OPERATION_ACTION_PRINT => Self::Print,
            ffi::GTK_PRINT_OPERATION_ACTION_PREVIEW => Self::Preview,
            ffi::GTK_PRINT_OPERATION_ACTION_EXPORT => Self::Export,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for PrintOperationAction {
    #[inline]
    #[doc(alias = "gtk_print_operation_action_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_print_operation_action_get_type()) }
    }
}

impl glib::HasParamSpec for PrintOperationAction {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for PrintOperationAction {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for PrintOperationAction {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for PrintOperationAction {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<PrintOperationAction> for glib::Value {
    #[inline]
    fn from(v: PrintOperationAction) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// The result of a print operation.
///
/// A value of this type is returned by [`PrintOperationExt::run()`][crate::prelude::PrintOperationExt::run()].
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkPrintOperationResult")]
pub enum PrintOperationResult {
    /// An error has occurred.
    #[doc(alias = "GTK_PRINT_OPERATION_RESULT_ERROR")]
    Error,
    /// The print settings should be stored.
    #[doc(alias = "GTK_PRINT_OPERATION_RESULT_APPLY")]
    Apply,
    /// The print operation has been canceled,
    ///   the print settings should not be stored.
    #[doc(alias = "GTK_PRINT_OPERATION_RESULT_CANCEL")]
    Cancel,
    /// The print operation is not complete
    ///   yet. This value will only be returned when running asynchronously.
    #[doc(alias = "GTK_PRINT_OPERATION_RESULT_IN_PROGRESS")]
    InProgress,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for PrintOperationResult {
    type GlibType = ffi::GtkPrintOperationResult;

    #[inline]
    fn into_glib(self) -> ffi::GtkPrintOperationResult {
        match self {
            Self::Error => ffi::GTK_PRINT_OPERATION_RESULT_ERROR,
            Self::Apply => ffi::GTK_PRINT_OPERATION_RESULT_APPLY,
            Self::Cancel => ffi::GTK_PRINT_OPERATION_RESULT_CANCEL,
            Self::InProgress => ffi::GTK_PRINT_OPERATION_RESULT_IN_PROGRESS,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkPrintOperationResult> for PrintOperationResult {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkPrintOperationResult) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_PRINT_OPERATION_RESULT_ERROR => Self::Error,
            ffi::GTK_PRINT_OPERATION_RESULT_APPLY => Self::Apply,
            ffi::GTK_PRINT_OPERATION_RESULT_CANCEL => Self::Cancel,
            ffi::GTK_PRINT_OPERATION_RESULT_IN_PROGRESS => Self::InProgress,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for PrintOperationResult {
    #[inline]
    #[doc(alias = "gtk_print_operation_result_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_print_operation_result_get_type()) }
    }
}

impl glib::HasParamSpec for PrintOperationResult {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for PrintOperationResult {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for PrintOperationResult {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for PrintOperationResult {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<PrintOperationResult> for glib::Value {
    #[inline]
    fn from(v: PrintOperationResult) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// See also gtk_print_job_set_pages()
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkPrintPages")]
pub enum PrintPages {
    /// All pages.
    #[doc(alias = "GTK_PRINT_PAGES_ALL")]
    All,
    /// Current page.
    #[doc(alias = "GTK_PRINT_PAGES_CURRENT")]
    Current,
    /// Range of pages.
    #[doc(alias = "GTK_PRINT_PAGES_RANGES")]
    Ranges,
    /// Selected pages.
    #[doc(alias = "GTK_PRINT_PAGES_SELECTION")]
    Selection,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for PrintPages {
    type GlibType = ffi::GtkPrintPages;

    #[inline]
    fn into_glib(self) -> ffi::GtkPrintPages {
        match self {
            Self::All => ffi::GTK_PRINT_PAGES_ALL,
            Self::Current => ffi::GTK_PRINT_PAGES_CURRENT,
            Self::Ranges => ffi::GTK_PRINT_PAGES_RANGES,
            Self::Selection => ffi::GTK_PRINT_PAGES_SELECTION,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkPrintPages> for PrintPages {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkPrintPages) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_PRINT_PAGES_ALL => Self::All,
            ffi::GTK_PRINT_PAGES_CURRENT => Self::Current,
            ffi::GTK_PRINT_PAGES_RANGES => Self::Ranges,
            ffi::GTK_PRINT_PAGES_SELECTION => Self::Selection,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for PrintPages {
    #[inline]
    #[doc(alias = "gtk_print_pages_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_print_pages_get_type()) }
    }
}

impl glib::HasParamSpec for PrintPages {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for PrintPages {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for PrintPages {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for PrintPages {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<PrintPages> for glib::Value {
    #[inline]
    fn from(v: PrintPages) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// See also gtk_print_settings_set_quality().
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkPrintQuality")]
pub enum PrintQuality {
    /// Low quality.
    #[doc(alias = "GTK_PRINT_QUALITY_LOW")]
    Low,
    /// Normal quality.
    #[doc(alias = "GTK_PRINT_QUALITY_NORMAL")]
    Normal,
    /// High quality.
    #[doc(alias = "GTK_PRINT_QUALITY_HIGH")]
    High,
    /// Draft quality.
    #[doc(alias = "GTK_PRINT_QUALITY_DRAFT")]
    Draft,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for PrintQuality {
    type GlibType = ffi::GtkPrintQuality;

    #[inline]
    fn into_glib(self) -> ffi::GtkPrintQuality {
        match self {
            Self::Low => ffi::GTK_PRINT_QUALITY_LOW,
            Self::Normal => ffi::GTK_PRINT_QUALITY_NORMAL,
            Self::High => ffi::GTK_PRINT_QUALITY_HIGH,
            Self::Draft => ffi::GTK_PRINT_QUALITY_DRAFT,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkPrintQuality> for PrintQuality {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkPrintQuality) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_PRINT_QUALITY_LOW => Self::Low,
            ffi::GTK_PRINT_QUALITY_NORMAL => Self::Normal,
            ffi::GTK_PRINT_QUALITY_HIGH => Self::High,
            ffi::GTK_PRINT_QUALITY_DRAFT => Self::Draft,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for PrintQuality {
    #[inline]
    #[doc(alias = "gtk_print_quality_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_print_quality_get_type()) }
    }
}

impl glib::HasParamSpec for PrintQuality {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for PrintQuality {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for PrintQuality {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for PrintQuality {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<PrintQuality> for glib::Value {
    #[inline]
    fn from(v: PrintQuality) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// The status gives a rough indication of the completion of a running
/// print operation.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkPrintStatus")]
pub enum PrintStatus {
    /// The printing has not started yet; this
    ///   status is set initially, and while the print dialog is shown.
    #[doc(alias = "GTK_PRINT_STATUS_INITIAL")]
    Initial,
    /// This status is set while the begin-print
    ///   signal is emitted and during pagination.
    #[doc(alias = "GTK_PRINT_STATUS_PREPARING")]
    Preparing,
    /// This status is set while the
    ///   pages are being rendered.
    #[doc(alias = "GTK_PRINT_STATUS_GENERATING_DATA")]
    GeneratingData,
    /// The print job is being sent off to the
    ///   printer.
    #[doc(alias = "GTK_PRINT_STATUS_SENDING_DATA")]
    SendingData,
    /// The print job has been sent to the printer,
    ///   but is not printed for some reason, e.g. the printer may be stopped.
    #[doc(alias = "GTK_PRINT_STATUS_PENDING")]
    Pending,
    /// Some problem has occurred during
    ///   printing, e.g. a paper jam.
    #[doc(alias = "GTK_PRINT_STATUS_PENDING_ISSUE")]
    PendingIssue,
    /// The printer is processing the print job.
    #[doc(alias = "GTK_PRINT_STATUS_PRINTING")]
    Printing,
    /// The printing has been completed successfully.
    #[doc(alias = "GTK_PRINT_STATUS_FINISHED")]
    Finished,
    /// The printing has been aborted.
    #[doc(alias = "GTK_PRINT_STATUS_FINISHED_ABORTED")]
    FinishedAborted,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for PrintStatus {
    type GlibType = ffi::GtkPrintStatus;

    #[inline]
    fn into_glib(self) -> ffi::GtkPrintStatus {
        match self {
            Self::Initial => ffi::GTK_PRINT_STATUS_INITIAL,
            Self::Preparing => ffi::GTK_PRINT_STATUS_PREPARING,
            Self::GeneratingData => ffi::GTK_PRINT_STATUS_GENERATING_DATA,
            Self::SendingData => ffi::GTK_PRINT_STATUS_SENDING_DATA,
            Self::Pending => ffi::GTK_PRINT_STATUS_PENDING,
            Self::PendingIssue => ffi::GTK_PRINT_STATUS_PENDING_ISSUE,
            Self::Printing => ffi::GTK_PRINT_STATUS_PRINTING,
            Self::Finished => ffi::GTK_PRINT_STATUS_FINISHED,
            Self::FinishedAborted => ffi::GTK_PRINT_STATUS_FINISHED_ABORTED,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkPrintStatus> for PrintStatus {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkPrintStatus) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_PRINT_STATUS_INITIAL => Self::Initial,
            ffi::GTK_PRINT_STATUS_PREPARING => Self::Preparing,
            ffi::GTK_PRINT_STATUS_GENERATING_DATA => Self::GeneratingData,
            ffi::GTK_PRINT_STATUS_SENDING_DATA => Self::SendingData,
            ffi::GTK_PRINT_STATUS_PENDING => Self::Pending,
            ffi::GTK_PRINT_STATUS_PENDING_ISSUE => Self::PendingIssue,
            ffi::GTK_PRINT_STATUS_PRINTING => Self::Printing,
            ffi::GTK_PRINT_STATUS_FINISHED => Self::Finished,
            ffi::GTK_PRINT_STATUS_FINISHED_ABORTED => Self::FinishedAborted,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for PrintStatus {
    #[inline]
    #[doc(alias = "gtk_print_status_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_print_status_get_type()) }
    }
}

impl glib::HasParamSpec for PrintStatus {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for PrintStatus {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for PrintStatus {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for PrintStatus {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<PrintStatus> for glib::Value {
    #[inline]
    fn from(v: PrintStatus) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Describes limits of a [`EventController`][crate::EventController] for handling events
/// targeting other widgets.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkPropagationLimit")]
pub enum PropagationLimit {
    /// Events are handled regardless of what their
    ///   target is.
    #[doc(alias = "GTK_LIMIT_NONE")]
    None,
    /// Events are only handled if their target is in
    ///   the same [`Native`][crate::Native] (or widget with [`limit-events`][struct@crate::Widget#limit-events]
    ///   set) as the event controllers widget.
    ///   Note that some event types have two targets (origin and destination).
    #[doc(alias = "GTK_LIMIT_SAME_NATIVE")]
    SameNative,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for PropagationLimit {
    type GlibType = ffi::GtkPropagationLimit;

    #[inline]
    fn into_glib(self) -> ffi::GtkPropagationLimit {
        match self {
            Self::None => ffi::GTK_LIMIT_NONE,
            Self::SameNative => ffi::GTK_LIMIT_SAME_NATIVE,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkPropagationLimit> for PropagationLimit {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkPropagationLimit) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_LIMIT_NONE => Self::None,
            ffi::GTK_LIMIT_SAME_NATIVE => Self::SameNative,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for PropagationLimit {
    #[inline]
    #[doc(alias = "gtk_propagation_limit_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_propagation_limit_get_type()) }
    }
}

impl glib::HasParamSpec for PropagationLimit {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for PropagationLimit {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for PropagationLimit {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for PropagationLimit {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<PropagationLimit> for glib::Value {
    #[inline]
    fn from(v: PropagationLimit) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Describes the stage at which events are fed into a [`EventController`][crate::EventController].
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkPropagationPhase")]
pub enum PropagationPhase {
    /// Events are not delivered.
    #[doc(alias = "GTK_PHASE_NONE")]
    None,
    /// Events are delivered in the capture phase. The
    ///   capture phase happens before the bubble phase, runs from the toplevel down
    ///   to the event widget. This option should only be used on containers that
    ///   might possibly handle events before their children do.
    #[doc(alias = "GTK_PHASE_CAPTURE")]
    Capture,
    /// Events are delivered in the bubble phase. The bubble
    ///   phase happens after the capture phase, and before the default handlers
    ///   are run. This phase runs from the event widget, up to the toplevel.
    #[doc(alias = "GTK_PHASE_BUBBLE")]
    Bubble,
    /// Events are delivered in the default widget event handlers,
    ///   note that widget implementations must chain up on button, motion, touch and
    ///   grab broken handlers for controllers in this phase to be run.
    #[doc(alias = "GTK_PHASE_TARGET")]
    Target,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for PropagationPhase {
    type GlibType = ffi::GtkPropagationPhase;

    #[inline]
    fn into_glib(self) -> ffi::GtkPropagationPhase {
        match self {
            Self::None => ffi::GTK_PHASE_NONE,
            Self::Capture => ffi::GTK_PHASE_CAPTURE,
            Self::Bubble => ffi::GTK_PHASE_BUBBLE,
            Self::Target => ffi::GTK_PHASE_TARGET,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkPropagationPhase> for PropagationPhase {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkPropagationPhase) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_PHASE_NONE => Self::None,
            ffi::GTK_PHASE_CAPTURE => Self::Capture,
            ffi::GTK_PHASE_BUBBLE => Self::Bubble,
            ffi::GTK_PHASE_TARGET => Self::Target,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for PropagationPhase {
    #[inline]
    #[doc(alias = "gtk_propagation_phase_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_propagation_phase_get_type()) }
    }
}

impl glib::HasParamSpec for PropagationPhase {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for PropagationPhase {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for PropagationPhase {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for PropagationPhase {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<PropagationPhase> for glib::Value {
    #[inline]
    fn from(v: PropagationPhase) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Error codes for [`RecentManager`][crate::RecentManager] operations
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkRecentManagerError")]
pub enum RecentManagerError {
    /// the URI specified does not exists in
    ///   the recently used resources list.
    #[doc(alias = "GTK_RECENT_MANAGER_ERROR_NOT_FOUND")]
    NotFound,
    /// the URI specified is not valid.
    #[doc(alias = "GTK_RECENT_MANAGER_ERROR_INVALID_URI")]
    InvalidUri,
    /// the supplied string is not
    ///   UTF-8 encoded.
    #[doc(alias = "GTK_RECENT_MANAGER_ERROR_INVALID_ENCODING")]
    InvalidEncoding,
    /// no application has registered
    ///   the specified item.
    #[doc(alias = "GTK_RECENT_MANAGER_ERROR_NOT_REGISTERED")]
    NotRegistered,
    /// failure while reading the recently used
    ///   resources file.
    #[doc(alias = "GTK_RECENT_MANAGER_ERROR_READ")]
    Read,
    /// failure while writing the recently used
    ///   resources file.
    #[doc(alias = "GTK_RECENT_MANAGER_ERROR_WRITE")]
    Write,
    /// unspecified error.
    #[doc(alias = "GTK_RECENT_MANAGER_ERROR_UNKNOWN")]
    Unknown,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for RecentManagerError {
    type GlibType = ffi::GtkRecentManagerError;

    #[inline]
    fn into_glib(self) -> ffi::GtkRecentManagerError {
        match self {
            Self::NotFound => ffi::GTK_RECENT_MANAGER_ERROR_NOT_FOUND,
            Self::InvalidUri => ffi::GTK_RECENT_MANAGER_ERROR_INVALID_URI,
            Self::InvalidEncoding => ffi::GTK_RECENT_MANAGER_ERROR_INVALID_ENCODING,
            Self::NotRegistered => ffi::GTK_RECENT_MANAGER_ERROR_NOT_REGISTERED,
            Self::Read => ffi::GTK_RECENT_MANAGER_ERROR_READ,
            Self::Write => ffi::GTK_RECENT_MANAGER_ERROR_WRITE,
            Self::Unknown => ffi::GTK_RECENT_MANAGER_ERROR_UNKNOWN,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkRecentManagerError> for RecentManagerError {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkRecentManagerError) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_RECENT_MANAGER_ERROR_NOT_FOUND => Self::NotFound,
            ffi::GTK_RECENT_MANAGER_ERROR_INVALID_URI => Self::InvalidUri,
            ffi::GTK_RECENT_MANAGER_ERROR_INVALID_ENCODING => Self::InvalidEncoding,
            ffi::GTK_RECENT_MANAGER_ERROR_NOT_REGISTERED => Self::NotRegistered,
            ffi::GTK_RECENT_MANAGER_ERROR_READ => Self::Read,
            ffi::GTK_RECENT_MANAGER_ERROR_WRITE => Self::Write,
            ffi::GTK_RECENT_MANAGER_ERROR_UNKNOWN => Self::Unknown,
            value => Self::__Unknown(value),
        }
    }
}

impl glib::error::ErrorDomain for RecentManagerError {
    #[inline]
    fn domain() -> glib::Quark {
        skip_assert_initialized!();

        unsafe { from_glib(ffi::gtk_recent_manager_error_quark()) }
    }

    #[inline]
    fn code(self) -> i32 {
        self.into_glib()
    }

    #[inline]
    #[allow(clippy::match_single_binding)]
    fn from(code: i32) -> Option<Self> {
        skip_assert_initialized!();
        match unsafe { from_glib(code) } {
            value => Some(value),
        }
    }
}

impl StaticType for RecentManagerError {
    #[inline]
    #[doc(alias = "gtk_recent_manager_error_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_recent_manager_error_get_type()) }
    }
}

impl glib::HasParamSpec for RecentManagerError {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for RecentManagerError {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for RecentManagerError {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for RecentManagerError {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<RecentManagerError> for glib::Value {
    #[inline]
    fn from(v: RecentManagerError) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Values for the [`gtk-interface-reduced-motion`][struct@crate::Settings#gtk-interface-reduced-motion]
/// and [`prefers-reduced-motion`][struct@crate::CssProvider#prefers-reduced-motion] properties
/// that indicates the preferred level of motion animations.
///
/// This information can be used inside CSS via media queries.
#[cfg(feature = "v4_22")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkReducedMotion")]
pub enum ReducedMotion {
    /// The user has made no preference known to the system
    #[doc(alias = "GTK_REDUCED_MOTION_NO_PREFERENCE")]
    NoPreference,
    /// The user has notified the system that they
    ///   prefer an interface that removes or replaces the types of motion-based
    ///   animation that either trigger discomfort for those with vestibular
    ///   motion sensitivity, or distraction for those with attention deficits
    #[doc(alias = "GTK_REDUCED_MOTION_REDUCE")]
    Reduce,
    #[doc(hidden)]
    __Unknown(i32),
}

#[cfg(feature = "v4_22")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
#[doc(hidden)]
impl IntoGlib for ReducedMotion {
    type GlibType = ffi::GtkReducedMotion;

    #[inline]
    fn into_glib(self) -> ffi::GtkReducedMotion {
        match self {
            Self::NoPreference => ffi::GTK_REDUCED_MOTION_NO_PREFERENCE,
            Self::Reduce => ffi::GTK_REDUCED_MOTION_REDUCE,
            Self::__Unknown(value) => value,
        }
    }
}

#[cfg(feature = "v4_22")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
#[doc(hidden)]
impl FromGlib<ffi::GtkReducedMotion> for ReducedMotion {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkReducedMotion) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_REDUCED_MOTION_NO_PREFERENCE => Self::NoPreference,
            ffi::GTK_REDUCED_MOTION_REDUCE => Self::Reduce,
            value => Self::__Unknown(value),
        }
    }
}

#[cfg(feature = "v4_22")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
impl StaticType for ReducedMotion {
    #[inline]
    #[doc(alias = "gtk_reduced_motion_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_reduced_motion_get_type()) }
    }
}

#[cfg(feature = "v4_22")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
impl glib::HasParamSpec for ReducedMotion {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

#[cfg(feature = "v4_22")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
impl glib::value::ValueType for ReducedMotion {
    type Type = Self;
}

#[cfg(feature = "v4_22")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
unsafe impl<'a> glib::value::FromValue<'a> for ReducedMotion {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

#[cfg(feature = "v4_22")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
impl ToValue for ReducedMotion {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

#[cfg(feature = "v4_22")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
impl From<ReducedMotion> for glib::Value {
    #[inline]
    fn from(v: ReducedMotion) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// These enumeration values describe the possible transitions
/// when the child of a [`Revealer`][crate::Revealer] widget is shown or hidden.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkRevealerTransitionType")]
pub enum RevealerTransitionType {
    /// No transition
    #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_NONE")]
    None,
    /// Fade in
    #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_CROSSFADE")]
    Crossfade,
    /// Slide in from the left
    #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT")]
    SlideRight,
    /// Slide in from the right
    #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_SLIDE_LEFT")]
    SlideLeft,
    /// Slide in from the bottom
    #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_SLIDE_UP")]
    SlideUp,
    /// Slide in from the top
    #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN")]
    SlideDown,
    /// Floop in from the left
    #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_SWING_RIGHT")]
    SwingRight,
    /// Floop in from the right
    #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_SWING_LEFT")]
    SwingLeft,
    /// Floop in from the bottom
    #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_SWING_UP")]
    SwingUp,
    /// Floop in from the top
    #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_SWING_DOWN")]
    SwingDown,
    /// Combination of [enum@Gtk.RevealerTransitionType.CROSSFADE]
    /// and [enum@Gtk.RevealerTransitionType.SLIDE_RIGHT].
    #[cfg(feature = "v4_22")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
    #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_FADE_SLIDE_RIGHT")]
    FadeSlideRight,
    /// Combination of [enum@Gtk.RevealerTransitionType.CROSSFADE]
    /// and [enum@Gtk.RevealerTransitionType.SLIDE_LEFT].
    #[cfg(feature = "v4_22")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
    #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_FADE_SLIDE_LEFT")]
    FadeSlideLeft,
    /// Combination of [enum@Gtk.RevealerTransitionType.CROSSFADE]
    /// and [enum@Gtk.RevealerTransitionType.SLIDE_UP].
    #[cfg(feature = "v4_22")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
    #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_FADE_SLIDE_UP")]
    FadeSlideUp,
    /// Combination of [enum@Gtk.RevealerTransitionType.CROSSFADE]
    /// and [enum@Gtk.RevealerTransitionType.SLIDE_DOWN].
    #[cfg(feature = "v4_22")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
    #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_FADE_SLIDE_DOWN")]
    FadeSlideDown,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for RevealerTransitionType {
    type GlibType = ffi::GtkRevealerTransitionType;

    fn into_glib(self) -> ffi::GtkRevealerTransitionType {
        match self {
            Self::None => ffi::GTK_REVEALER_TRANSITION_TYPE_NONE,
            Self::Crossfade => ffi::GTK_REVEALER_TRANSITION_TYPE_CROSSFADE,
            Self::SlideRight => ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT,
            Self::SlideLeft => ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_LEFT,
            Self::SlideUp => ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_UP,
            Self::SlideDown => ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN,
            Self::SwingRight => ffi::GTK_REVEALER_TRANSITION_TYPE_SWING_RIGHT,
            Self::SwingLeft => ffi::GTK_REVEALER_TRANSITION_TYPE_SWING_LEFT,
            Self::SwingUp => ffi::GTK_REVEALER_TRANSITION_TYPE_SWING_UP,
            Self::SwingDown => ffi::GTK_REVEALER_TRANSITION_TYPE_SWING_DOWN,
            #[cfg(feature = "v4_22")]
            Self::FadeSlideRight => ffi::GTK_REVEALER_TRANSITION_TYPE_FADE_SLIDE_RIGHT,
            #[cfg(feature = "v4_22")]
            Self::FadeSlideLeft => ffi::GTK_REVEALER_TRANSITION_TYPE_FADE_SLIDE_LEFT,
            #[cfg(feature = "v4_22")]
            Self::FadeSlideUp => ffi::GTK_REVEALER_TRANSITION_TYPE_FADE_SLIDE_UP,
            #[cfg(feature = "v4_22")]
            Self::FadeSlideDown => ffi::GTK_REVEALER_TRANSITION_TYPE_FADE_SLIDE_DOWN,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkRevealerTransitionType> for RevealerTransitionType {
    unsafe fn from_glib(value: ffi::GtkRevealerTransitionType) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_REVEALER_TRANSITION_TYPE_NONE => Self::None,
            ffi::GTK_REVEALER_TRANSITION_TYPE_CROSSFADE => Self::Crossfade,
            ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT => Self::SlideRight,
            ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_LEFT => Self::SlideLeft,
            ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_UP => Self::SlideUp,
            ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN => Self::SlideDown,
            ffi::GTK_REVEALER_TRANSITION_TYPE_SWING_RIGHT => Self::SwingRight,
            ffi::GTK_REVEALER_TRANSITION_TYPE_SWING_LEFT => Self::SwingLeft,
            ffi::GTK_REVEALER_TRANSITION_TYPE_SWING_UP => Self::SwingUp,
            ffi::GTK_REVEALER_TRANSITION_TYPE_SWING_DOWN => Self::SwingDown,
            #[cfg(feature = "v4_22")]
            ffi::GTK_REVEALER_TRANSITION_TYPE_FADE_SLIDE_RIGHT => Self::FadeSlideRight,
            #[cfg(feature = "v4_22")]
            ffi::GTK_REVEALER_TRANSITION_TYPE_FADE_SLIDE_LEFT => Self::FadeSlideLeft,
            #[cfg(feature = "v4_22")]
            ffi::GTK_REVEALER_TRANSITION_TYPE_FADE_SLIDE_UP => Self::FadeSlideUp,
            #[cfg(feature = "v4_22")]
            ffi::GTK_REVEALER_TRANSITION_TYPE_FADE_SLIDE_DOWN => Self::FadeSlideDown,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for RevealerTransitionType {
    #[inline]
    #[doc(alias = "gtk_revealer_transition_type_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_revealer_transition_type_get_type()) }
    }
}

impl glib::HasParamSpec for RevealerTransitionType {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for RevealerTransitionType {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for RevealerTransitionType {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for RevealerTransitionType {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<RevealerTransitionType> for glib::Value {
    #[inline]
    fn from(v: RevealerTransitionType) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Passed as argument to various keybinding signals.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkScrollStep")]
pub enum ScrollStep {
    /// Scroll in steps.
    #[doc(alias = "GTK_SCROLL_STEPS")]
    Steps,
    /// Scroll by pages.
    #[doc(alias = "GTK_SCROLL_PAGES")]
    Pages,
    /// Scroll to ends.
    #[doc(alias = "GTK_SCROLL_ENDS")]
    Ends,
    /// Scroll in horizontal steps.
    #[doc(alias = "GTK_SCROLL_HORIZONTAL_STEPS")]
    HorizontalSteps,
    /// Scroll by horizontal pages.
    #[doc(alias = "GTK_SCROLL_HORIZONTAL_PAGES")]
    HorizontalPages,
    /// Scroll to the horizontal ends.
    #[doc(alias = "GTK_SCROLL_HORIZONTAL_ENDS")]
    HorizontalEnds,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for ScrollStep {
    type GlibType = ffi::GtkScrollStep;

    #[inline]
    fn into_glib(self) -> ffi::GtkScrollStep {
        match self {
            Self::Steps => ffi::GTK_SCROLL_STEPS,
            Self::Pages => ffi::GTK_SCROLL_PAGES,
            Self::Ends => ffi::GTK_SCROLL_ENDS,
            Self::HorizontalSteps => ffi::GTK_SCROLL_HORIZONTAL_STEPS,
            Self::HorizontalPages => ffi::GTK_SCROLL_HORIZONTAL_PAGES,
            Self::HorizontalEnds => ffi::GTK_SCROLL_HORIZONTAL_ENDS,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkScrollStep> for ScrollStep {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkScrollStep) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_SCROLL_STEPS => Self::Steps,
            ffi::GTK_SCROLL_PAGES => Self::Pages,
            ffi::GTK_SCROLL_ENDS => Self::Ends,
            ffi::GTK_SCROLL_HORIZONTAL_STEPS => Self::HorizontalSteps,
            ffi::GTK_SCROLL_HORIZONTAL_PAGES => Self::HorizontalPages,
            ffi::GTK_SCROLL_HORIZONTAL_ENDS => Self::HorizontalEnds,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for ScrollStep {
    #[inline]
    #[doc(alias = "gtk_scroll_step_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_scroll_step_get_type()) }
    }
}

impl glib::HasParamSpec for ScrollStep {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for ScrollStep {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for ScrollStep {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for ScrollStep {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<ScrollStep> for glib::Value {
    #[inline]
    fn from(v: ScrollStep) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Scrolling types.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkScrollType")]
pub enum ScrollType {
    /// No scrolling.
    #[doc(alias = "GTK_SCROLL_NONE")]
    None,
    /// Jump to new location.
    #[doc(alias = "GTK_SCROLL_JUMP")]
    Jump,
    /// Step backward.
    #[doc(alias = "GTK_SCROLL_STEP_BACKWARD")]
    StepBackward,
    /// Step forward.
    #[doc(alias = "GTK_SCROLL_STEP_FORWARD")]
    StepForward,
    /// Page backward.
    #[doc(alias = "GTK_SCROLL_PAGE_BACKWARD")]
    PageBackward,
    /// Page forward.
    #[doc(alias = "GTK_SCROLL_PAGE_FORWARD")]
    PageForward,
    /// Step up.
    #[doc(alias = "GTK_SCROLL_STEP_UP")]
    StepUp,
    /// Step down.
    #[doc(alias = "GTK_SCROLL_STEP_DOWN")]
    StepDown,
    /// Page up.
    #[doc(alias = "GTK_SCROLL_PAGE_UP")]
    PageUp,
    /// Page down.
    #[doc(alias = "GTK_SCROLL_PAGE_DOWN")]
    PageDown,
    /// Step to the left.
    #[doc(alias = "GTK_SCROLL_STEP_LEFT")]
    StepLeft,
    /// Step to the right.
    #[doc(alias = "GTK_SCROLL_STEP_RIGHT")]
    StepRight,
    /// Page to the left.
    #[doc(alias = "GTK_SCROLL_PAGE_LEFT")]
    PageLeft,
    /// Page to the right.
    #[doc(alias = "GTK_SCROLL_PAGE_RIGHT")]
    PageRight,
    /// Scroll to start.
    #[doc(alias = "GTK_SCROLL_START")]
    Start,
    /// Scroll to end.
    #[doc(alias = "GTK_SCROLL_END")]
    End,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for ScrollType {
    type GlibType = ffi::GtkScrollType;

    fn into_glib(self) -> ffi::GtkScrollType {
        match self {
            Self::None => ffi::GTK_SCROLL_NONE,
            Self::Jump => ffi::GTK_SCROLL_JUMP,
            Self::StepBackward => ffi::GTK_SCROLL_STEP_BACKWARD,
            Self::StepForward => ffi::GTK_SCROLL_STEP_FORWARD,
            Self::PageBackward => ffi::GTK_SCROLL_PAGE_BACKWARD,
            Self::PageForward => ffi::GTK_SCROLL_PAGE_FORWARD,
            Self::StepUp => ffi::GTK_SCROLL_STEP_UP,
            Self::StepDown => ffi::GTK_SCROLL_STEP_DOWN,
            Self::PageUp => ffi::GTK_SCROLL_PAGE_UP,
            Self::PageDown => ffi::GTK_SCROLL_PAGE_DOWN,
            Self::StepLeft => ffi::GTK_SCROLL_STEP_LEFT,
            Self::StepRight => ffi::GTK_SCROLL_STEP_RIGHT,
            Self::PageLeft => ffi::GTK_SCROLL_PAGE_LEFT,
            Self::PageRight => ffi::GTK_SCROLL_PAGE_RIGHT,
            Self::Start => ffi::GTK_SCROLL_START,
            Self::End => ffi::GTK_SCROLL_END,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkScrollType> for ScrollType {
    unsafe fn from_glib(value: ffi::GtkScrollType) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_SCROLL_NONE => Self::None,
            ffi::GTK_SCROLL_JUMP => Self::Jump,
            ffi::GTK_SCROLL_STEP_BACKWARD => Self::StepBackward,
            ffi::GTK_SCROLL_STEP_FORWARD => Self::StepForward,
            ffi::GTK_SCROLL_PAGE_BACKWARD => Self::PageBackward,
            ffi::GTK_SCROLL_PAGE_FORWARD => Self::PageForward,
            ffi::GTK_SCROLL_STEP_UP => Self::StepUp,
            ffi::GTK_SCROLL_STEP_DOWN => Self::StepDown,
            ffi::GTK_SCROLL_PAGE_UP => Self::PageUp,
            ffi::GTK_SCROLL_PAGE_DOWN => Self::PageDown,
            ffi::GTK_SCROLL_STEP_LEFT => Self::StepLeft,
            ffi::GTK_SCROLL_STEP_RIGHT => Self::StepRight,
            ffi::GTK_SCROLL_PAGE_LEFT => Self::PageLeft,
            ffi::GTK_SCROLL_PAGE_RIGHT => Self::PageRight,
            ffi::GTK_SCROLL_START => Self::Start,
            ffi::GTK_SCROLL_END => Self::End,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for ScrollType {
    #[inline]
    #[doc(alias = "gtk_scroll_type_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_scroll_type_get_type()) }
    }
}

impl glib::HasParamSpec for ScrollType {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for ScrollType {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for ScrollType {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for ScrollType {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<ScrollType> for glib::Value {
    #[inline]
    fn from(v: ScrollType) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Defines the policy to be used in a scrollable widget when updating
/// the scrolled window adjustments in a given orientation.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkScrollablePolicy")]
pub enum ScrollablePolicy {
    /// Scrollable adjustments are based on the minimum size
    #[doc(alias = "GTK_SCROLL_MINIMUM")]
    Minimum,
    /// Scrollable adjustments are based on the natural size
    #[doc(alias = "GTK_SCROLL_NATURAL")]
    Natural,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for ScrollablePolicy {
    type GlibType = ffi::GtkScrollablePolicy;

    #[inline]
    fn into_glib(self) -> ffi::GtkScrollablePolicy {
        match self {
            Self::Minimum => ffi::GTK_SCROLL_MINIMUM,
            Self::Natural => ffi::GTK_SCROLL_NATURAL,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkScrollablePolicy> for ScrollablePolicy {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkScrollablePolicy) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_SCROLL_MINIMUM => Self::Minimum,
            ffi::GTK_SCROLL_NATURAL => Self::Natural,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for ScrollablePolicy {
    #[inline]
    #[doc(alias = "gtk_scrollable_policy_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_scrollable_policy_get_type()) }
    }
}

impl glib::HasParamSpec for ScrollablePolicy {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for ScrollablePolicy {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for ScrollablePolicy {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for ScrollablePolicy {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<ScrollablePolicy> for glib::Value {
    #[inline]
    fn from(v: ScrollablePolicy) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Used to control what selections users are allowed to make.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkSelectionMode")]
pub enum SelectionMode {
    /// No selection is possible.
    #[doc(alias = "GTK_SELECTION_NONE")]
    None,
    /// Zero or one element may be selected.
    #[doc(alias = "GTK_SELECTION_SINGLE")]
    Single,
    /// Exactly one element is selected.
    ///   In some circumstances, such as initially or during a search
    ///   operation, it’s possible for no element to be selected with
    ///   [`Browse`][Self::Browse]. What is really enforced is that the user
    ///   can’t deselect a currently selected element except by selecting
    ///   another element.
    #[doc(alias = "GTK_SELECTION_BROWSE")]
    Browse,
    /// Any number of elements may be selected.
    ///   The Ctrl key may be used to enlarge the selection, and Shift
    ///   key to select between the focus and the child pointed to.
    ///   Some widgets may also allow Click-drag to select a range of elements.
    #[doc(alias = "GTK_SELECTION_MULTIPLE")]
    Multiple,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for SelectionMode {
    type GlibType = ffi::GtkSelectionMode;

    #[inline]
    fn into_glib(self) -> ffi::GtkSelectionMode {
        match self {
            Self::None => ffi::GTK_SELECTION_NONE,
            Self::Single => ffi::GTK_SELECTION_SINGLE,
            Self::Browse => ffi::GTK_SELECTION_BROWSE,
            Self::Multiple => ffi::GTK_SELECTION_MULTIPLE,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkSelectionMode> for SelectionMode {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkSelectionMode) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_SELECTION_NONE => Self::None,
            ffi::GTK_SELECTION_SINGLE => Self::Single,
            ffi::GTK_SELECTION_BROWSE => Self::Browse,
            ffi::GTK_SELECTION_MULTIPLE => Self::Multiple,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for SelectionMode {
    #[inline]
    #[doc(alias = "gtk_selection_mode_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_selection_mode_get_type()) }
    }
}

impl glib::HasParamSpec for SelectionMode {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for SelectionMode {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for SelectionMode {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for SelectionMode {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<SelectionMode> for glib::Value {
    #[inline]
    fn from(v: SelectionMode) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Determines how GTK handles the sensitivity of various controls,
/// such as combo box buttons.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkSensitivityType")]
pub enum SensitivityType {
    /// The control is made insensitive if no
    ///   action can be triggered
    #[doc(alias = "GTK_SENSITIVITY_AUTO")]
    Auto,
    /// The control is always sensitive
    #[doc(alias = "GTK_SENSITIVITY_ON")]
    On,
    /// The control is always insensitive
    #[doc(alias = "GTK_SENSITIVITY_OFF")]
    Off,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for SensitivityType {
    type GlibType = ffi::GtkSensitivityType;

    #[inline]
    fn into_glib(self) -> ffi::GtkSensitivityType {
        match self {
            Self::Auto => ffi::GTK_SENSITIVITY_AUTO,
            Self::On => ffi::GTK_SENSITIVITY_ON,
            Self::Off => ffi::GTK_SENSITIVITY_OFF,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkSensitivityType> for SensitivityType {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkSensitivityType) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_SENSITIVITY_AUTO => Self::Auto,
            ffi::GTK_SENSITIVITY_ON => Self::On,
            ffi::GTK_SENSITIVITY_OFF => Self::Off,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for SensitivityType {
    #[inline]
    #[doc(alias = "gtk_sensitivity_type_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_sensitivity_type_get_type()) }
    }
}

impl glib::HasParamSpec for SensitivityType {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for SensitivityType {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for SensitivityType {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for SensitivityType {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<SensitivityType> for glib::Value {
    #[inline]
    fn from(v: SensitivityType) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Describes where [`Shortcut`][crate::Shortcut]s added to a
/// [`ShortcutController`][crate::ShortcutController] get handled.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkShortcutScope")]
pub enum ShortcutScope {
    /// Shortcuts are handled inside
    ///   the widget the controller belongs to.
    #[doc(alias = "GTK_SHORTCUT_SCOPE_LOCAL")]
    Local,
    /// Shortcuts are handled by
    ///   the first ancestor that is a [`ShortcutManager`][crate::ShortcutManager]
    #[doc(alias = "GTK_SHORTCUT_SCOPE_MANAGED")]
    Managed,
    /// Shortcuts are handled by
    ///   the root widget.
    #[doc(alias = "GTK_SHORTCUT_SCOPE_GLOBAL")]
    Global,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for ShortcutScope {
    type GlibType = ffi::GtkShortcutScope;

    #[inline]
    fn into_glib(self) -> ffi::GtkShortcutScope {
        match self {
            Self::Local => ffi::GTK_SHORTCUT_SCOPE_LOCAL,
            Self::Managed => ffi::GTK_SHORTCUT_SCOPE_MANAGED,
            Self::Global => ffi::GTK_SHORTCUT_SCOPE_GLOBAL,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkShortcutScope> for ShortcutScope {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkShortcutScope) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_SHORTCUT_SCOPE_LOCAL => Self::Local,
            ffi::GTK_SHORTCUT_SCOPE_MANAGED => Self::Managed,
            ffi::GTK_SHORTCUT_SCOPE_GLOBAL => Self::Global,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for ShortcutScope {
    #[inline]
    #[doc(alias = "gtk_shortcut_scope_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_shortcut_scope_get_type()) }
    }
}

impl glib::HasParamSpec for ShortcutScope {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for ShortcutScope {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for ShortcutScope {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for ShortcutScope {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<ShortcutScope> for glib::Value {
    #[inline]
    fn from(v: ShortcutScope) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// GtkShortcutType specifies the kind of shortcut that is being described.
///
/// More values may be added to this enumeration over time.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkShortcutType")]
pub enum ShortcutType {
    /// The shortcut is a keyboard accelerator. The GtkShortcutsShortcut:accelerator
    ///   property will be used.
    #[doc(alias = "GTK_SHORTCUT_ACCELERATOR")]
    Accelerator,
    /// The shortcut is a pinch gesture. GTK provides an icon and subtitle.
    #[doc(alias = "GTK_SHORTCUT_GESTURE_PINCH")]
    GesturePinch,
    /// The shortcut is a stretch gesture. GTK provides an icon and subtitle.
    #[doc(alias = "GTK_SHORTCUT_GESTURE_STRETCH")]
    GestureStretch,
    /// The shortcut is a clockwise rotation gesture. GTK provides an icon and subtitle.
    #[doc(alias = "GTK_SHORTCUT_GESTURE_ROTATE_CLOCKWISE")]
    GestureRotateClockwise,
    /// The shortcut is a counterclockwise rotation gesture. GTK provides an icon and subtitle.
    #[doc(alias = "GTK_SHORTCUT_GESTURE_ROTATE_COUNTERCLOCKWISE")]
    GestureRotateCounterclockwise,
    /// The shortcut is a two-finger swipe gesture. GTK provides an icon and subtitle.
    #[doc(alias = "GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_LEFT")]
    GestureTwoFingerSwipeLeft,
    /// The shortcut is a two-finger swipe gesture. GTK provides an icon and subtitle.
    #[doc(alias = "GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_RIGHT")]
    GestureTwoFingerSwipeRight,
    /// The shortcut is a gesture. The GtkShortcutsShortcut:icon property will be
    ///   used.
    #[doc(alias = "GTK_SHORTCUT_GESTURE")]
    Gesture,
    /// The shortcut is a swipe gesture. GTK provides an icon and subtitle.
    #[doc(alias = "GTK_SHORTCUT_GESTURE_SWIPE_LEFT")]
    GestureSwipeLeft,
    /// The shortcut is a swipe gesture. GTK provides an icon and subtitle.
    #[doc(alias = "GTK_SHORTCUT_GESTURE_SWIPE_RIGHT")]
    GestureSwipeRight,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for ShortcutType {
    type GlibType = ffi::GtkShortcutType;

    #[inline]
    fn into_glib(self) -> ffi::GtkShortcutType {
        match self {
            Self::Accelerator => ffi::GTK_SHORTCUT_ACCELERATOR,
            Self::GesturePinch => ffi::GTK_SHORTCUT_GESTURE_PINCH,
            Self::GestureStretch => ffi::GTK_SHORTCUT_GESTURE_STRETCH,
            Self::GestureRotateClockwise => ffi::GTK_SHORTCUT_GESTURE_ROTATE_CLOCKWISE,
            Self::GestureRotateCounterclockwise => {
                ffi::GTK_SHORTCUT_GESTURE_ROTATE_COUNTERCLOCKWISE
            }
            Self::GestureTwoFingerSwipeLeft => ffi::GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_LEFT,
            Self::GestureTwoFingerSwipeRight => ffi::GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_RIGHT,
            Self::Gesture => ffi::GTK_SHORTCUT_GESTURE,
            Self::GestureSwipeLeft => ffi::GTK_SHORTCUT_GESTURE_SWIPE_LEFT,
            Self::GestureSwipeRight => ffi::GTK_SHORTCUT_GESTURE_SWIPE_RIGHT,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkShortcutType> for ShortcutType {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkShortcutType) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_SHORTCUT_ACCELERATOR => Self::Accelerator,
            ffi::GTK_SHORTCUT_GESTURE_PINCH => Self::GesturePinch,
            ffi::GTK_SHORTCUT_GESTURE_STRETCH => Self::GestureStretch,
            ffi::GTK_SHORTCUT_GESTURE_ROTATE_CLOCKWISE => Self::GestureRotateClockwise,
            ffi::GTK_SHORTCUT_GESTURE_ROTATE_COUNTERCLOCKWISE => {
                Self::GestureRotateCounterclockwise
            }
            ffi::GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_LEFT => Self::GestureTwoFingerSwipeLeft,
            ffi::GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_RIGHT => Self::GestureTwoFingerSwipeRight,
            ffi::GTK_SHORTCUT_GESTURE => Self::Gesture,
            ffi::GTK_SHORTCUT_GESTURE_SWIPE_LEFT => Self::GestureSwipeLeft,
            ffi::GTK_SHORTCUT_GESTURE_SWIPE_RIGHT => Self::GestureSwipeRight,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for ShortcutType {
    #[inline]
    #[doc(alias = "gtk_shortcut_type_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_shortcut_type_get_type()) }
    }
}

impl glib::HasParamSpec for ShortcutType {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for ShortcutType {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for ShortcutType {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for ShortcutType {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<ShortcutType> for glib::Value {
    #[inline]
    fn from(v: ShortcutType) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// The mode of the size group determines the directions in which the size
/// group affects the requested sizes of its component widgets.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkSizeGroupMode")]
pub enum SizeGroupMode {
    /// group has no effect
    #[doc(alias = "GTK_SIZE_GROUP_NONE")]
    None,
    /// group affects horizontal requisition
    #[doc(alias = "GTK_SIZE_GROUP_HORIZONTAL")]
    Horizontal,
    /// group affects vertical requisition
    #[doc(alias = "GTK_SIZE_GROUP_VERTICAL")]
    Vertical,
    /// group affects both horizontal and vertical requisition
    #[doc(alias = "GTK_SIZE_GROUP_BOTH")]
    Both,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for SizeGroupMode {
    type GlibType = ffi::GtkSizeGroupMode;

    #[inline]
    fn into_glib(self) -> ffi::GtkSizeGroupMode {
        match self {
            Self::None => ffi::GTK_SIZE_GROUP_NONE,
            Self::Horizontal => ffi::GTK_SIZE_GROUP_HORIZONTAL,
            Self::Vertical => ffi::GTK_SIZE_GROUP_VERTICAL,
            Self::Both => ffi::GTK_SIZE_GROUP_BOTH,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkSizeGroupMode> for SizeGroupMode {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkSizeGroupMode) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_SIZE_GROUP_NONE => Self::None,
            ffi::GTK_SIZE_GROUP_HORIZONTAL => Self::Horizontal,
            ffi::GTK_SIZE_GROUP_VERTICAL => Self::Vertical,
            ffi::GTK_SIZE_GROUP_BOTH => Self::Both,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for SizeGroupMode {
    #[inline]
    #[doc(alias = "gtk_size_group_mode_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_size_group_mode_get_type()) }
    }
}

impl glib::HasParamSpec for SizeGroupMode {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for SizeGroupMode {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for SizeGroupMode {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for SizeGroupMode {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<SizeGroupMode> for glib::Value {
    #[inline]
    fn from(v: SizeGroupMode) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Specifies a preference for height-for-width or
/// width-for-height geometry management.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkSizeRequestMode")]
pub enum SizeRequestMode {
    /// Prefer height-for-width geometry management
    #[doc(alias = "GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH")]
    HeightForWidth,
    /// Prefer width-for-height geometry management
    #[doc(alias = "GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT")]
    WidthForHeight,
    /// Don’t trade height-for-width or width-for-height
    #[doc(alias = "GTK_SIZE_REQUEST_CONSTANT_SIZE")]
    ConstantSize,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for SizeRequestMode {
    type GlibType = ffi::GtkSizeRequestMode;

    #[inline]
    fn into_glib(self) -> ffi::GtkSizeRequestMode {
        match self {
            Self::HeightForWidth => ffi::GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH,
            Self::WidthForHeight => ffi::GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT,
            Self::ConstantSize => ffi::GTK_SIZE_REQUEST_CONSTANT_SIZE,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkSizeRequestMode> for SizeRequestMode {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkSizeRequestMode) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH => Self::HeightForWidth,
            ffi::GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT => Self::WidthForHeight,
            ffi::GTK_SIZE_REQUEST_CONSTANT_SIZE => Self::ConstantSize,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for SizeRequestMode {
    #[inline]
    #[doc(alias = "gtk_size_request_mode_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_size_request_mode_get_type()) }
    }
}

impl glib::HasParamSpec for SizeRequestMode {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for SizeRequestMode {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for SizeRequestMode {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for SizeRequestMode {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<SizeRequestMode> for glib::Value {
    #[inline]
    fn from(v: SizeRequestMode) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Determines the direction of a sort.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkSortType")]
pub enum SortType {
    /// Sorting is in ascending order.
    #[doc(alias = "GTK_SORT_ASCENDING")]
    Ascending,
    /// Sorting is in descending order.
    #[doc(alias = "GTK_SORT_DESCENDING")]
    Descending,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for SortType {
    type GlibType = ffi::GtkSortType;

    #[inline]
    fn into_glib(self) -> ffi::GtkSortType {
        match self {
            Self::Ascending => ffi::GTK_SORT_ASCENDING,
            Self::Descending => ffi::GTK_SORT_DESCENDING,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkSortType> for SortType {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkSortType) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_SORT_ASCENDING => Self::Ascending,
            ffi::GTK_SORT_DESCENDING => Self::Descending,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for SortType {
    #[inline]
    #[doc(alias = "gtk_sort_type_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_sort_type_get_type()) }
    }
}

impl glib::HasParamSpec for SortType {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for SortType {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for SortType {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for SortType {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<SortType> for glib::Value {
    #[inline]
    fn from(v: SortType) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Describes changes in a sorter in more detail and allows users
/// to optimize resorting.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkSorterChange")]
pub enum SorterChange {
    /// The sorter change cannot be described
    ///   by any of the other enumeration values
    #[doc(alias = "GTK_SORTER_CHANGE_DIFFERENT")]
    Different,
    /// The sort order was inverted. Comparisons
    ///   that returned [`Ordering::Smaller`][crate::Ordering::Smaller] now return [`Ordering::Larger`][crate::Ordering::Larger]
    ///   and vice versa. Other comparisons return the same values as before.
    #[doc(alias = "GTK_SORTER_CHANGE_INVERTED")]
    Inverted,
    /// The sorter is less strict: Comparisons
    ///   may now return [`Ordering::Equal`][crate::Ordering::Equal] that did not do so before.
    #[doc(alias = "GTK_SORTER_CHANGE_LESS_STRICT")]
    LessStrict,
    /// The sorter is more strict: Comparisons
    ///   that did return [`Ordering::Equal`][crate::Ordering::Equal] may not do so anymore.
    #[doc(alias = "GTK_SORTER_CHANGE_MORE_STRICT")]
    MoreStrict,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for SorterChange {
    type GlibType = ffi::GtkSorterChange;

    #[inline]
    fn into_glib(self) -> ffi::GtkSorterChange {
        match self {
            Self::Different => ffi::GTK_SORTER_CHANGE_DIFFERENT,
            Self::Inverted => ffi::GTK_SORTER_CHANGE_INVERTED,
            Self::LessStrict => ffi::GTK_SORTER_CHANGE_LESS_STRICT,
            Self::MoreStrict => ffi::GTK_SORTER_CHANGE_MORE_STRICT,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkSorterChange> for SorterChange {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkSorterChange) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_SORTER_CHANGE_DIFFERENT => Self::Different,
            ffi::GTK_SORTER_CHANGE_INVERTED => Self::Inverted,
            ffi::GTK_SORTER_CHANGE_LESS_STRICT => Self::LessStrict,
            ffi::GTK_SORTER_CHANGE_MORE_STRICT => Self::MoreStrict,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for SorterChange {
    #[inline]
    #[doc(alias = "gtk_sorter_change_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_sorter_change_get_type()) }
    }
}

impl glib::HasParamSpec for SorterChange {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for SorterChange {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for SorterChange {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for SorterChange {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<SorterChange> for glib::Value {
    #[inline]
    fn from(v: SorterChange) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Describes the type of order that a [`Sorter`][crate::Sorter] may produce.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkSorterOrder")]
pub enum SorterOrder {
    /// A partial order. Any [`Ordering`][crate::Ordering] is possible.
    #[doc(alias = "GTK_SORTER_ORDER_PARTIAL")]
    Partial,
    /// No order, all elements are considered equal.
    ///   gtk_sorter_compare() will only return [`Ordering::Equal`][crate::Ordering::Equal].
    #[doc(alias = "GTK_SORTER_ORDER_NONE")]
    None,
    /// A total order. gtk_sorter_compare() will only
    ///   return [`Ordering::Equal`][crate::Ordering::Equal] if an item is compared with itself. Two
    ///   different items will never cause this value to be returned.
    #[doc(alias = "GTK_SORTER_ORDER_TOTAL")]
    Total,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for SorterOrder {
    type GlibType = ffi::GtkSorterOrder;

    #[inline]
    fn into_glib(self) -> ffi::GtkSorterOrder {
        match self {
            Self::Partial => ffi::GTK_SORTER_ORDER_PARTIAL,
            Self::None => ffi::GTK_SORTER_ORDER_NONE,
            Self::Total => ffi::GTK_SORTER_ORDER_TOTAL,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkSorterOrder> for SorterOrder {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkSorterOrder) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_SORTER_ORDER_PARTIAL => Self::Partial,
            ffi::GTK_SORTER_ORDER_NONE => Self::None,
            ffi::GTK_SORTER_ORDER_TOTAL => Self::Total,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for SorterOrder {
    #[inline]
    #[doc(alias = "gtk_sorter_order_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_sorter_order_get_type()) }
    }
}

impl glib::HasParamSpec for SorterOrder {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for SorterOrder {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for SorterOrder {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for SorterOrder {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<SorterOrder> for glib::Value {
    #[inline]
    fn from(v: SorterOrder) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Determines whether the spin button displays values outside the adjustment
/// bounds.
///
/// See [`SpinButton::set_update_policy()`][crate::SpinButton::set_update_policy()].
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkSpinButtonUpdatePolicy")]
pub enum SpinButtonUpdatePolicy {
    /// When refreshing your [`SpinButton`][crate::SpinButton], the value is
    ///   always displayed
    #[doc(alias = "GTK_UPDATE_ALWAYS")]
    Always,
    /// When refreshing your [`SpinButton`][crate::SpinButton], the value is
    ///   only displayed if it is valid within the bounds of the spin button's
    ///   adjustment
    #[doc(alias = "GTK_UPDATE_IF_VALID")]
    IfValid,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for SpinButtonUpdatePolicy {
    type GlibType = ffi::GtkSpinButtonUpdatePolicy;

    #[inline]
    fn into_glib(self) -> ffi::GtkSpinButtonUpdatePolicy {
        match self {
            Self::Always => ffi::GTK_UPDATE_ALWAYS,
            Self::IfValid => ffi::GTK_UPDATE_IF_VALID,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkSpinButtonUpdatePolicy> for SpinButtonUpdatePolicy {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkSpinButtonUpdatePolicy) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_UPDATE_ALWAYS => Self::Always,
            ffi::GTK_UPDATE_IF_VALID => Self::IfValid,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for SpinButtonUpdatePolicy {
    #[inline]
    #[doc(alias = "gtk_spin_button_update_policy_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_spin_button_update_policy_get_type()) }
    }
}

impl glib::HasParamSpec for SpinButtonUpdatePolicy {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for SpinButtonUpdatePolicy {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for SpinButtonUpdatePolicy {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for SpinButtonUpdatePolicy {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<SpinButtonUpdatePolicy> for glib::Value {
    #[inline]
    fn from(v: SpinButtonUpdatePolicy) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// The values of the GtkSpinType enumeration are used to specify the
/// change to make in gtk_spin_button_spin().
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkSpinType")]
pub enum SpinType {
    /// Increment by the adjustments step increment.
    #[doc(alias = "GTK_SPIN_STEP_FORWARD")]
    StepForward,
    /// Decrement by the adjustments step increment.
    #[doc(alias = "GTK_SPIN_STEP_BACKWARD")]
    StepBackward,
    /// Increment by the adjustments page increment.
    #[doc(alias = "GTK_SPIN_PAGE_FORWARD")]
    PageForward,
    /// Decrement by the adjustments page increment.
    #[doc(alias = "GTK_SPIN_PAGE_BACKWARD")]
    PageBackward,
    /// Go to the adjustments lower bound.
    #[doc(alias = "GTK_SPIN_HOME")]
    Home,
    /// Go to the adjustments upper bound.
    #[doc(alias = "GTK_SPIN_END")]
    End,
    /// Change by a specified amount.
    #[doc(alias = "GTK_SPIN_USER_DEFINED")]
    UserDefined,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for SpinType {
    type GlibType = ffi::GtkSpinType;

    #[inline]
    fn into_glib(self) -> ffi::GtkSpinType {
        match self {
            Self::StepForward => ffi::GTK_SPIN_STEP_FORWARD,
            Self::StepBackward => ffi::GTK_SPIN_STEP_BACKWARD,
            Self::PageForward => ffi::GTK_SPIN_PAGE_FORWARD,
            Self::PageBackward => ffi::GTK_SPIN_PAGE_BACKWARD,
            Self::Home => ffi::GTK_SPIN_HOME,
            Self::End => ffi::GTK_SPIN_END,
            Self::UserDefined => ffi::GTK_SPIN_USER_DEFINED,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkSpinType> for SpinType {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkSpinType) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_SPIN_STEP_FORWARD => Self::StepForward,
            ffi::GTK_SPIN_STEP_BACKWARD => Self::StepBackward,
            ffi::GTK_SPIN_PAGE_FORWARD => Self::PageForward,
            ffi::GTK_SPIN_PAGE_BACKWARD => Self::PageBackward,
            ffi::GTK_SPIN_HOME => Self::Home,
            ffi::GTK_SPIN_END => Self::End,
            ffi::GTK_SPIN_USER_DEFINED => Self::UserDefined,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for SpinType {
    #[inline]
    #[doc(alias = "gtk_spin_type_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_spin_type_get_type()) }
    }
}

impl glib::HasParamSpec for SpinType {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for SpinType {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for SpinType {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for SpinType {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<SpinType> for glib::Value {
    #[inline]
    fn from(v: SpinType) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Possible transitions between pages in a [`Stack`][crate::Stack] widget.
///
/// New values may be added to this enumeration over time.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkStackTransitionType")]
pub enum StackTransitionType {
    /// No transition
    #[doc(alias = "GTK_STACK_TRANSITION_TYPE_NONE")]
    None,
    /// A cross-fade
    #[doc(alias = "GTK_STACK_TRANSITION_TYPE_CROSSFADE")]
    Crossfade,
    /// Slide from left to right
    #[doc(alias = "GTK_STACK_TRANSITION_TYPE_SLIDE_RIGHT")]
    SlideRight,
    /// Slide from right to left
    #[doc(alias = "GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT")]
    SlideLeft,
    /// Slide from bottom up
    #[doc(alias = "GTK_STACK_TRANSITION_TYPE_SLIDE_UP")]
    SlideUp,
    /// Slide from top down
    #[doc(alias = "GTK_STACK_TRANSITION_TYPE_SLIDE_DOWN")]
    SlideDown,
    /// Slide from left or right according to the children order
    #[doc(alias = "GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT")]
    SlideLeftRight,
    /// Slide from top down or bottom up according to the order
    #[doc(alias = "GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN")]
    SlideUpDown,
    /// Cover the old page by sliding up
    #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_UP")]
    OverUp,
    /// Cover the old page by sliding down
    #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_DOWN")]
    OverDown,
    /// Cover the old page by sliding to the left
    #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_LEFT")]
    OverLeft,
    /// Cover the old page by sliding to the right
    #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_RIGHT")]
    OverRight,
    /// Uncover the new page by sliding up
    #[doc(alias = "GTK_STACK_TRANSITION_TYPE_UNDER_UP")]
    UnderUp,
    /// Uncover the new page by sliding down
    #[doc(alias = "GTK_STACK_TRANSITION_TYPE_UNDER_DOWN")]
    UnderDown,
    /// Uncover the new page by sliding to the left
    #[doc(alias = "GTK_STACK_TRANSITION_TYPE_UNDER_LEFT")]
    UnderLeft,
    /// Uncover the new page by sliding to the right
    #[doc(alias = "GTK_STACK_TRANSITION_TYPE_UNDER_RIGHT")]
    UnderRight,
    /// Cover the old page sliding up or uncover the new page sliding down, according to order
    #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_UP_DOWN")]
    OverUpDown,
    /// Cover the old page sliding down or uncover the new page sliding up, according to order
    #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_DOWN_UP")]
    OverDownUp,
    /// Cover the old page sliding left or uncover the new page sliding right, according to order
    #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_LEFT_RIGHT")]
    OverLeftRight,
    /// Cover the old page sliding right or uncover the new page sliding left, according to order
    #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_RIGHT_LEFT")]
    OverRightLeft,
    /// Pretend the pages are sides of a cube and rotate that cube to the left
    #[doc(alias = "GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT")]
    RotateLeft,
    /// Pretend the pages are sides of a cube and rotate that cube to the right
    #[doc(alias = "GTK_STACK_TRANSITION_TYPE_ROTATE_RIGHT")]
    RotateRight,
    /// Pretend the pages are sides of a cube and rotate that cube to the left or right according to the children order
    #[doc(alias = "GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT_RIGHT")]
    RotateLeftRight,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for StackTransitionType {
    type GlibType = ffi::GtkStackTransitionType;

    fn into_glib(self) -> ffi::GtkStackTransitionType {
        match self {
            Self::None => ffi::GTK_STACK_TRANSITION_TYPE_NONE,
            Self::Crossfade => ffi::GTK_STACK_TRANSITION_TYPE_CROSSFADE,
            Self::SlideRight => ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_RIGHT,
            Self::SlideLeft => ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT,
            Self::SlideUp => ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_UP,
            Self::SlideDown => ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_DOWN,
            Self::SlideLeftRight => ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT,
            Self::SlideUpDown => ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN,
            Self::OverUp => ffi::GTK_STACK_TRANSITION_TYPE_OVER_UP,
            Self::OverDown => ffi::GTK_STACK_TRANSITION_TYPE_OVER_DOWN,
            Self::OverLeft => ffi::GTK_STACK_TRANSITION_TYPE_OVER_LEFT,
            Self::OverRight => ffi::GTK_STACK_TRANSITION_TYPE_OVER_RIGHT,
            Self::UnderUp => ffi::GTK_STACK_TRANSITION_TYPE_UNDER_UP,
            Self::UnderDown => ffi::GTK_STACK_TRANSITION_TYPE_UNDER_DOWN,
            Self::UnderLeft => ffi::GTK_STACK_TRANSITION_TYPE_UNDER_LEFT,
            Self::UnderRight => ffi::GTK_STACK_TRANSITION_TYPE_UNDER_RIGHT,
            Self::OverUpDown => ffi::GTK_STACK_TRANSITION_TYPE_OVER_UP_DOWN,
            Self::OverDownUp => ffi::GTK_STACK_TRANSITION_TYPE_OVER_DOWN_UP,
            Self::OverLeftRight => ffi::GTK_STACK_TRANSITION_TYPE_OVER_LEFT_RIGHT,
            Self::OverRightLeft => ffi::GTK_STACK_TRANSITION_TYPE_OVER_RIGHT_LEFT,
            Self::RotateLeft => ffi::GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT,
            Self::RotateRight => ffi::GTK_STACK_TRANSITION_TYPE_ROTATE_RIGHT,
            Self::RotateLeftRight => ffi::GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT_RIGHT,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkStackTransitionType> for StackTransitionType {
    unsafe fn from_glib(value: ffi::GtkStackTransitionType) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_STACK_TRANSITION_TYPE_NONE => Self::None,
            ffi::GTK_STACK_TRANSITION_TYPE_CROSSFADE => Self::Crossfade,
            ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_RIGHT => Self::SlideRight,
            ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT => Self::SlideLeft,
            ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_UP => Self::SlideUp,
            ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_DOWN => Self::SlideDown,
            ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT => Self::SlideLeftRight,
            ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN => Self::SlideUpDown,
            ffi::GTK_STACK_TRANSITION_TYPE_OVER_UP => Self::OverUp,
            ffi::GTK_STACK_TRANSITION_TYPE_OVER_DOWN => Self::OverDown,
            ffi::GTK_STACK_TRANSITION_TYPE_OVER_LEFT => Self::OverLeft,
            ffi::GTK_STACK_TRANSITION_TYPE_OVER_RIGHT => Self::OverRight,
            ffi::GTK_STACK_TRANSITION_TYPE_UNDER_UP => Self::UnderUp,
            ffi::GTK_STACK_TRANSITION_TYPE_UNDER_DOWN => Self::UnderDown,
            ffi::GTK_STACK_TRANSITION_TYPE_UNDER_LEFT => Self::UnderLeft,
            ffi::GTK_STACK_TRANSITION_TYPE_UNDER_RIGHT => Self::UnderRight,
            ffi::GTK_STACK_TRANSITION_TYPE_OVER_UP_DOWN => Self::OverUpDown,
            ffi::GTK_STACK_TRANSITION_TYPE_OVER_DOWN_UP => Self::OverDownUp,
            ffi::GTK_STACK_TRANSITION_TYPE_OVER_LEFT_RIGHT => Self::OverLeftRight,
            ffi::GTK_STACK_TRANSITION_TYPE_OVER_RIGHT_LEFT => Self::OverRightLeft,
            ffi::GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT => Self::RotateLeft,
            ffi::GTK_STACK_TRANSITION_TYPE_ROTATE_RIGHT => Self::RotateRight,
            ffi::GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT_RIGHT => Self::RotateLeftRight,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for StackTransitionType {
    #[inline]
    #[doc(alias = "gtk_stack_transition_type_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_stack_transition_type_get_type()) }
    }
}

impl glib::HasParamSpec for StackTransitionType {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for StackTransitionType {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for StackTransitionType {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for StackTransitionType {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<StackTransitionType> for glib::Value {
    #[inline]
    fn from(v: StackTransitionType) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Specifies how search strings are matched inside text.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkStringFilterMatchMode")]
pub enum StringFilterMatchMode {
    /// The search string and
    ///   text must match exactly
    #[doc(alias = "GTK_STRING_FILTER_MATCH_MODE_EXACT")]
    Exact,
    /// The search string
    ///   must be contained as a substring inside the text
    #[doc(alias = "GTK_STRING_FILTER_MATCH_MODE_SUBSTRING")]
    Substring,
    /// The text must begin
    ///   with the search string
    #[doc(alias = "GTK_STRING_FILTER_MATCH_MODE_PREFIX")]
    Prefix,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for StringFilterMatchMode {
    type GlibType = ffi::GtkStringFilterMatchMode;

    #[inline]
    fn into_glib(self) -> ffi::GtkStringFilterMatchMode {
        match self {
            Self::Exact => ffi::GTK_STRING_FILTER_MATCH_MODE_EXACT,
            Self::Substring => ffi::GTK_STRING_FILTER_MATCH_MODE_SUBSTRING,
            Self::Prefix => ffi::GTK_STRING_FILTER_MATCH_MODE_PREFIX,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkStringFilterMatchMode> for StringFilterMatchMode {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkStringFilterMatchMode) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_STRING_FILTER_MATCH_MODE_EXACT => Self::Exact,
            ffi::GTK_STRING_FILTER_MATCH_MODE_SUBSTRING => Self::Substring,
            ffi::GTK_STRING_FILTER_MATCH_MODE_PREFIX => Self::Prefix,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for StringFilterMatchMode {
    #[inline]
    #[doc(alias = "gtk_string_filter_match_mode_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_string_filter_match_mode_get_type()) }
    }
}

impl glib::HasParamSpec for StringFilterMatchMode {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for StringFilterMatchMode {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for StringFilterMatchMode {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for StringFilterMatchMode {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<StringFilterMatchMode> for glib::Value {
    #[inline]
    fn from(v: StringFilterMatchMode) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Error codes in the `GTK_SVG_ERROR` domain for errors
/// that happen during parsing or rendering of SVG.
#[cfg(feature = "v4_22")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkSvgError")]
pub enum SvgError {
    /// The XML syntax is broken
    ///   in some way
    #[doc(alias = "GTK_SVG_ERROR_INVALID_SYNTAX")]
    InvalidSyntax,
    /// An XML element is invalid
    ///   (either because it is not part of SVG, or because it is
    ///   in the wrong place, or because it not implemented in GTK)
    #[doc(alias = "GTK_SVG_ERROR_INVALID_ELEMENT")]
    InvalidElement,
    /// An attribute is invalid
    ///   (either because it is not part of SVG, or because it is
    ///   not implemented in GTK, or its value is problematic)
    #[doc(alias = "GTK_SVG_ERROR_INVALID_ATTRIBUTE")]
    InvalidAttribute,
    /// A required attribute is missing
    #[doc(alias = "GTK_SVG_ERROR_MISSING_ATTRIBUTE")]
    MissingAttribute,
    /// A reference does not point to
    ///   a suitable element
    #[doc(alias = "GTK_SVG_ERROR_INVALID_REFERENCE")]
    InvalidReference,
    /// An animation could not be updated
    #[doc(alias = "GTK_SVG_ERROR_FAILED_UPDATE")]
    FailedUpdate,
    /// Rendering is not according to
    ///   expecations
    #[doc(alias = "GTK_SVG_ERROR_FAILED_RENDERING")]
    FailedRendering,
    /// An XML element is ignored,
    ///   but it should not affect rendering (this error code is used
    ///   for metadata and exension elements)
    #[doc(alias = "GTK_SVG_ERROR_IGNORED_ELEMENT")]
    IgnoredElement,
    /// An implementation limit has
    ///   been hit, such as the number of loaded shapes.
    #[doc(alias = "GTK_SVG_ERROR_LIMITS_EXCEEDED")]
    LimitsExceeded,
    /// The SVG uses features that
    ///   are not supported by [`Svg`][crate::Svg]. It may be advisable to use
    ///   a different SVG renderer.
    #[doc(alias = "GTK_SVG_ERROR_NOT_IMPLEMENTED")]
    NotImplemented,
    #[doc(alias = "GTK_SVG_ERROR_FEATURE_DISABLED")]
    FeatureDisabled,
    #[doc(hidden)]
    __Unknown(i32),
}

#[cfg(feature = "v4_22")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
impl SvgError {
    #[doc(alias = "gtk_svg_error_get_attribute")]
    #[doc(alias = "get_attribute")]
    pub fn attribute(error: &glib::Error) -> Option<glib::GString> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::gtk_svg_error_get_attribute(error.to_glib_none().0)) }
    }

    #[doc(alias = "gtk_svg_error_get_element")]
    #[doc(alias = "get_element")]
    pub fn element(error: &glib::Error) -> Option<glib::GString> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::gtk_svg_error_get_element(error.to_glib_none().0)) }
    }

    //#[doc(alias = "gtk_svg_error_get_end")]
    //#[doc(alias = "get_end")]
    //pub fn end(error: &glib::Error) -> /*Ignored*/Option<SvgLocation> {
    //    unsafe { TODO: call ffi:gtk_svg_error_get_end() }
    //}

    #[cfg(feature = "v4_24")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_24")))]
    #[doc(alias = "gtk_svg_error_get_input")]
    #[doc(alias = "get_input")]
    pub fn input(error: &glib::Error) -> Option<glib::GString> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::gtk_svg_error_get_input(error.to_glib_none().0)) }
    }

    //#[doc(alias = "gtk_svg_error_get_start")]
    //#[doc(alias = "get_start")]
    //pub fn start(error: &glib::Error) -> /*Ignored*/Option<SvgLocation> {
    //    unsafe { TODO: call ffi:gtk_svg_error_get_start() }
    //}

    #[doc(alias = "gtk_svg_error_quark")]
    pub fn quark() -> glib::Quark {
        assert_initialized_main_thread!();
        unsafe { from_glib(ffi::gtk_svg_error_quark()) }
    }
}

#[cfg(feature = "v4_22")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
#[doc(hidden)]
impl IntoGlib for SvgError {
    type GlibType = ffi::GtkSvgError;

    #[inline]
    fn into_glib(self) -> ffi::GtkSvgError {
        match self {
            Self::InvalidSyntax => ffi::GTK_SVG_ERROR_INVALID_SYNTAX,
            Self::InvalidElement => ffi::GTK_SVG_ERROR_INVALID_ELEMENT,
            Self::InvalidAttribute => ffi::GTK_SVG_ERROR_INVALID_ATTRIBUTE,
            Self::MissingAttribute => ffi::GTK_SVG_ERROR_MISSING_ATTRIBUTE,
            Self::InvalidReference => ffi::GTK_SVG_ERROR_INVALID_REFERENCE,
            Self::FailedUpdate => ffi::GTK_SVG_ERROR_FAILED_UPDATE,
            Self::FailedRendering => ffi::GTK_SVG_ERROR_FAILED_RENDERING,
            Self::IgnoredElement => ffi::GTK_SVG_ERROR_IGNORED_ELEMENT,
            Self::LimitsExceeded => ffi::GTK_SVG_ERROR_LIMITS_EXCEEDED,
            Self::NotImplemented => ffi::GTK_SVG_ERROR_NOT_IMPLEMENTED,
            Self::FeatureDisabled => ffi::GTK_SVG_ERROR_FEATURE_DISABLED,
            Self::__Unknown(value) => value,
        }
    }
}

#[cfg(feature = "v4_22")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
#[doc(hidden)]
impl FromGlib<ffi::GtkSvgError> for SvgError {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkSvgError) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_SVG_ERROR_INVALID_SYNTAX => Self::InvalidSyntax,
            ffi::GTK_SVG_ERROR_INVALID_ELEMENT => Self::InvalidElement,
            ffi::GTK_SVG_ERROR_INVALID_ATTRIBUTE => Self::InvalidAttribute,
            ffi::GTK_SVG_ERROR_MISSING_ATTRIBUTE => Self::MissingAttribute,
            ffi::GTK_SVG_ERROR_INVALID_REFERENCE => Self::InvalidReference,
            ffi::GTK_SVG_ERROR_FAILED_UPDATE => Self::FailedUpdate,
            ffi::GTK_SVG_ERROR_FAILED_RENDERING => Self::FailedRendering,
            ffi::GTK_SVG_ERROR_IGNORED_ELEMENT => Self::IgnoredElement,
            ffi::GTK_SVG_ERROR_LIMITS_EXCEEDED => Self::LimitsExceeded,
            ffi::GTK_SVG_ERROR_NOT_IMPLEMENTED => Self::NotImplemented,
            ffi::GTK_SVG_ERROR_FEATURE_DISABLED => Self::FeatureDisabled,
            value => Self::__Unknown(value),
        }
    }
}

#[cfg(feature = "v4_22")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
impl glib::error::ErrorDomain for SvgError {
    #[inline]
    fn domain() -> glib::Quark {
        skip_assert_initialized!();

        static QUARK: ::std::sync::OnceLock<glib::ffi::GQuark> = ::std::sync::OnceLock::new();
        let quark = *QUARK.get_or_init(|| unsafe {
            glib::ffi::g_quark_from_static_string(c"GtkSvgError".as_ptr())
        });
        unsafe { from_glib(quark) }
    }

    #[inline]
    fn code(self) -> i32 {
        self.into_glib()
    }

    #[inline]
    #[allow(clippy::match_single_binding)]
    fn from(code: i32) -> Option<Self> {
        skip_assert_initialized!();
        match unsafe { from_glib(code) } {
            value => Some(value),
        }
    }
}

#[cfg(feature = "v4_22")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
impl StaticType for SvgError {
    #[inline]
    #[doc(alias = "gtk_svg_error_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_svg_error_get_type()) }
    }
}

#[cfg(feature = "v4_22")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
impl glib::HasParamSpec for SvgError {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

#[cfg(feature = "v4_22")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
impl glib::value::ValueType for SvgError {
    type Type = Self;
}

#[cfg(feature = "v4_22")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
unsafe impl<'a> glib::value::FromValue<'a> for SvgError {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

#[cfg(feature = "v4_22")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
impl ToValue for SvgError {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

#[cfg(feature = "v4_22")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
impl From<SvgError> for glib::Value {
    #[inline]
    fn from(v: SvgError) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// The indexes of colors passed to symbolic color rendering, such as
/// `vfunc::Gtk::SymbolicPaintable::snapshot_symbolic`.
///
/// More values may be added over time.
#[cfg(feature = "v4_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkSymbolicColor")]
pub enum SymbolicColor {
    /// The default foreground color
    #[doc(alias = "GTK_SYMBOLIC_COLOR_FOREGROUND")]
    Foreground,
    /// Indication color for errors
    #[doc(alias = "GTK_SYMBOLIC_COLOR_ERROR")]
    Error,
    /// Indication color for warnings
    #[doc(alias = "GTK_SYMBOLIC_COLOR_WARNING")]
    Warning,
    /// Indication color for success
    #[doc(alias = "GTK_SYMBOLIC_COLOR_SUCCESS")]
    Success,
    /// The system accent color.
    #[cfg(feature = "v4_22")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
    #[doc(alias = "GTK_SYMBOLIC_COLOR_ACCENT")]
    Accent,
    #[doc(hidden)]
    __Unknown(i32),
}

#[cfg(feature = "v4_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
#[doc(hidden)]
impl IntoGlib for SymbolicColor {
    type GlibType = ffi::GtkSymbolicColor;

    #[inline]
    fn into_glib(self) -> ffi::GtkSymbolicColor {
        match self {
            Self::Foreground => ffi::GTK_SYMBOLIC_COLOR_FOREGROUND,
            Self::Error => ffi::GTK_SYMBOLIC_COLOR_ERROR,
            Self::Warning => ffi::GTK_SYMBOLIC_COLOR_WARNING,
            Self::Success => ffi::GTK_SYMBOLIC_COLOR_SUCCESS,
            #[cfg(feature = "v4_22")]
            Self::Accent => ffi::GTK_SYMBOLIC_COLOR_ACCENT,
            Self::__Unknown(value) => value,
        }
    }
}

#[cfg(feature = "v4_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
#[doc(hidden)]
impl FromGlib<ffi::GtkSymbolicColor> for SymbolicColor {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkSymbolicColor) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_SYMBOLIC_COLOR_FOREGROUND => Self::Foreground,
            ffi::GTK_SYMBOLIC_COLOR_ERROR => Self::Error,
            ffi::GTK_SYMBOLIC_COLOR_WARNING => Self::Warning,
            ffi::GTK_SYMBOLIC_COLOR_SUCCESS => Self::Success,
            #[cfg(feature = "v4_22")]
            ffi::GTK_SYMBOLIC_COLOR_ACCENT => Self::Accent,
            value => Self::__Unknown(value),
        }
    }
}

#[cfg(feature = "v4_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
impl StaticType for SymbolicColor {
    #[inline]
    #[doc(alias = "gtk_symbolic_color_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_symbolic_color_get_type()) }
    }
}

#[cfg(feature = "v4_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
impl glib::HasParamSpec for SymbolicColor {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

#[cfg(feature = "v4_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
impl glib::value::ValueType for SymbolicColor {
    type Type = Self;
}

#[cfg(feature = "v4_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
unsafe impl<'a> glib::value::FromValue<'a> for SymbolicColor {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

#[cfg(feature = "v4_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
impl ToValue for SymbolicColor {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

#[cfg(feature = "v4_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
impl From<SymbolicColor> for glib::Value {
    #[inline]
    fn from(v: SymbolicColor) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Values that can be passed to the [`WidgetImpl::system_setting_changed()`][crate::subclass::prelude::WidgetImpl::system_setting_changed()]
/// vfunc.
///
/// The values indicate which system setting has changed.
/// Widgets may need to drop caches, or react otherwise.
///
/// Most of the values correspond to [`Settings`][crate::Settings] properties.
///
/// More values may be added over time.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkSystemSetting")]
pub enum SystemSetting {
    /// the [`gtk-xft-dpi`][struct@crate::Settings#gtk-xft-dpi] setting has changed
    #[doc(alias = "GTK_SYSTEM_SETTING_DPI")]
    Dpi,
    /// The [`gtk-font-name`][struct@crate::Settings#gtk-font-name] setting has changed
    #[doc(alias = "GTK_SYSTEM_SETTING_FONT_NAME")]
    FontName,
    /// The font configuration has changed in a way that
    ///   requires text to be redrawn. This can be any of the
    ///   [`gtk-xft-antialias`][struct@crate::Settings#gtk-xft-antialias],
    ///   [`gtk-xft-hinting`][struct@crate::Settings#gtk-xft-hinting],
    ///   [`gtk-xft-hintstyle`][struct@crate::Settings#gtk-xft-hintstyle],
    ///   [`gtk-xft-rgba`][struct@crate::Settings#gtk-xft-rgba] or
    ///   [`gtk-fontconfig-timestamp`][struct@crate::Settings#gtk-fontconfig-timestamp] settings
    #[doc(alias = "GTK_SYSTEM_SETTING_FONT_CONFIG")]
    FontConfig,
    /// The display has changed
    #[doc(alias = "GTK_SYSTEM_SETTING_DISPLAY")]
    Display,
    /// The icon theme has changed in a way that requires
    ///   icons to be looked up again
    #[doc(alias = "GTK_SYSTEM_SETTING_ICON_THEME")]
    IconTheme,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for SystemSetting {
    type GlibType = ffi::GtkSystemSetting;

    #[inline]
    fn into_glib(self) -> ffi::GtkSystemSetting {
        match self {
            Self::Dpi => ffi::GTK_SYSTEM_SETTING_DPI,
            Self::FontName => ffi::GTK_SYSTEM_SETTING_FONT_NAME,
            Self::FontConfig => ffi::GTK_SYSTEM_SETTING_FONT_CONFIG,
            Self::Display => ffi::GTK_SYSTEM_SETTING_DISPLAY,
            Self::IconTheme => ffi::GTK_SYSTEM_SETTING_ICON_THEME,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkSystemSetting> for SystemSetting {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkSystemSetting) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_SYSTEM_SETTING_DPI => Self::Dpi,
            ffi::GTK_SYSTEM_SETTING_FONT_NAME => Self::FontName,
            ffi::GTK_SYSTEM_SETTING_FONT_CONFIG => Self::FontConfig,
            ffi::GTK_SYSTEM_SETTING_DISPLAY => Self::Display,
            ffi::GTK_SYSTEM_SETTING_ICON_THEME => Self::IconTheme,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for SystemSetting {
    #[inline]
    #[doc(alias = "gtk_system_setting_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_system_setting_get_type()) }
    }
}

impl glib::HasParamSpec for SystemSetting {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for SystemSetting {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for SystemSetting {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for SystemSetting {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<SystemSetting> for glib::Value {
    #[inline]
    fn from(v: SystemSetting) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Reading directions for text.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkTextDirection")]
pub enum TextDirection {
    /// No direction.
    #[doc(alias = "GTK_TEXT_DIR_NONE")]
    None,
    /// Left to right text direction.
    #[doc(alias = "GTK_TEXT_DIR_LTR")]
    Ltr,
    /// Right to left text direction.
    #[doc(alias = "GTK_TEXT_DIR_RTL")]
    Rtl,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for TextDirection {
    type GlibType = ffi::GtkTextDirection;

    #[inline]
    fn into_glib(self) -> ffi::GtkTextDirection {
        match self {
            Self::None => ffi::GTK_TEXT_DIR_NONE,
            Self::Ltr => ffi::GTK_TEXT_DIR_LTR,
            Self::Rtl => ffi::GTK_TEXT_DIR_RTL,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkTextDirection> for TextDirection {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkTextDirection) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_TEXT_DIR_NONE => Self::None,
            ffi::GTK_TEXT_DIR_LTR => Self::Ltr,
            ffi::GTK_TEXT_DIR_RTL => Self::Rtl,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for TextDirection {
    #[inline]
    #[doc(alias = "gtk_text_direction_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_text_direction_get_type()) }
    }
}

impl glib::HasParamSpec for TextDirection {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for TextDirection {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for TextDirection {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for TextDirection {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<TextDirection> for glib::Value {
    #[inline]
    fn from(v: TextDirection) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Granularity types that extend the text selection. Use the
/// `GtkTextView::extend-selection` signal to customize the selection.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkTextExtendSelection")]
pub enum TextExtendSelection {
    /// Selects the current word. It is triggered by
    ///   a double-click for example.
    #[doc(alias = "GTK_TEXT_EXTEND_SELECTION_WORD")]
    Word,
    /// Selects the current line. It is triggered by
    ///   a triple-click for example.
    #[doc(alias = "GTK_TEXT_EXTEND_SELECTION_LINE")]
    Line,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for TextExtendSelection {
    type GlibType = ffi::GtkTextExtendSelection;

    #[inline]
    fn into_glib(self) -> ffi::GtkTextExtendSelection {
        match self {
            Self::Word => ffi::GTK_TEXT_EXTEND_SELECTION_WORD,
            Self::Line => ffi::GTK_TEXT_EXTEND_SELECTION_LINE,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkTextExtendSelection> for TextExtendSelection {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkTextExtendSelection) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_TEXT_EXTEND_SELECTION_WORD => Self::Word,
            ffi::GTK_TEXT_EXTEND_SELECTION_LINE => Self::Line,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for TextExtendSelection {
    #[inline]
    #[doc(alias = "gtk_text_extend_selection_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_text_extend_selection_get_type()) }
    }
}

impl glib::HasParamSpec for TextExtendSelection {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for TextExtendSelection {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for TextExtendSelection {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for TextExtendSelection {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<TextExtendSelection> for glib::Value {
    #[inline]
    fn from(v: TextExtendSelection) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Used to reference the layers of [`TextView`][crate::TextView] for the purpose of customized
/// drawing with the ::snapshot_layer vfunc.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkTextViewLayer")]
pub enum TextViewLayer {
    /// The layer rendered below the text (but above the background).
    #[doc(alias = "GTK_TEXT_VIEW_LAYER_BELOW_TEXT")]
    BelowText,
    /// The layer rendered above the text.
    #[doc(alias = "GTK_TEXT_VIEW_LAYER_ABOVE_TEXT")]
    AboveText,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for TextViewLayer {
    type GlibType = ffi::GtkTextViewLayer;

    #[inline]
    fn into_glib(self) -> ffi::GtkTextViewLayer {
        match self {
            Self::BelowText => ffi::GTK_TEXT_VIEW_LAYER_BELOW_TEXT,
            Self::AboveText => ffi::GTK_TEXT_VIEW_LAYER_ABOVE_TEXT,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkTextViewLayer> for TextViewLayer {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkTextViewLayer) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_TEXT_VIEW_LAYER_BELOW_TEXT => Self::BelowText,
            ffi::GTK_TEXT_VIEW_LAYER_ABOVE_TEXT => Self::AboveText,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for TextViewLayer {
    #[inline]
    #[doc(alias = "gtk_text_view_layer_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_text_view_layer_get_type()) }
    }
}

impl glib::HasParamSpec for TextViewLayer {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for TextViewLayer {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for TextViewLayer {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for TextViewLayer {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<TextViewLayer> for glib::Value {
    #[inline]
    fn from(v: TextViewLayer) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Used to reference the parts of [`TextView`][crate::TextView].
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkTextWindowType")]
pub enum TextWindowType {
    /// Window that floats over scrolling areas.
    #[doc(alias = "GTK_TEXT_WINDOW_WIDGET")]
    Widget,
    /// Scrollable text window.
    #[doc(alias = "GTK_TEXT_WINDOW_TEXT")]
    Text,
    /// Left side border window.
    #[doc(alias = "GTK_TEXT_WINDOW_LEFT")]
    Left,
    /// Right side border window.
    #[doc(alias = "GTK_TEXT_WINDOW_RIGHT")]
    Right,
    /// Top border window.
    #[doc(alias = "GTK_TEXT_WINDOW_TOP")]
    Top,
    /// Bottom border window.
    #[doc(alias = "GTK_TEXT_WINDOW_BOTTOM")]
    Bottom,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for TextWindowType {
    type GlibType = ffi::GtkTextWindowType;

    #[inline]
    fn into_glib(self) -> ffi::GtkTextWindowType {
        match self {
            Self::Widget => ffi::GTK_TEXT_WINDOW_WIDGET,
            Self::Text => ffi::GTK_TEXT_WINDOW_TEXT,
            Self::Left => ffi::GTK_TEXT_WINDOW_LEFT,
            Self::Right => ffi::GTK_TEXT_WINDOW_RIGHT,
            Self::Top => ffi::GTK_TEXT_WINDOW_TOP,
            Self::Bottom => ffi::GTK_TEXT_WINDOW_BOTTOM,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkTextWindowType> for TextWindowType {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkTextWindowType) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_TEXT_WINDOW_WIDGET => Self::Widget,
            ffi::GTK_TEXT_WINDOW_TEXT => Self::Text,
            ffi::GTK_TEXT_WINDOW_LEFT => Self::Left,
            ffi::GTK_TEXT_WINDOW_RIGHT => Self::Right,
            ffi::GTK_TEXT_WINDOW_TOP => Self::Top,
            ffi::GTK_TEXT_WINDOW_BOTTOM => Self::Bottom,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for TextWindowType {
    #[inline]
    #[doc(alias = "gtk_text_window_type_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_text_window_type_get_type()) }
    }
}

impl glib::HasParamSpec for TextWindowType {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for TextWindowType {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for TextWindowType {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for TextWindowType {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<TextWindowType> for glib::Value {
    #[inline]
    fn from(v: TextWindowType) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// The sizing method the column uses to determine its width.  Please note
/// that [`Autosize`][Self::Autosize] are inefficient for large views, and
/// can make columns appear choppy.
///
/// # Deprecated since 4.20
///
/// There is no replacement.
#[cfg_attr(feature = "v4_20", deprecated = "Since 4.20")]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkTreeViewColumnSizing")]
pub enum TreeViewColumnSizing {
    /// Columns only get bigger in reaction to changes in the model
    #[doc(alias = "GTK_TREE_VIEW_COLUMN_GROW_ONLY")]
    GrowOnly,
    /// Columns resize to be the optimal size every time the model changes.
    #[doc(alias = "GTK_TREE_VIEW_COLUMN_AUTOSIZE")]
    Autosize,
    /// Columns are a fixed numbers of pixels wide.
    #[doc(alias = "GTK_TREE_VIEW_COLUMN_FIXED")]
    Fixed,
    #[doc(hidden)]
    __Unknown(i32),
}

#[allow(deprecated)]
#[doc(hidden)]
impl IntoGlib for TreeViewColumnSizing {
    type GlibType = ffi::GtkTreeViewColumnSizing;

    #[inline]
    fn into_glib(self) -> ffi::GtkTreeViewColumnSizing {
        match self {
            Self::GrowOnly => ffi::GTK_TREE_VIEW_COLUMN_GROW_ONLY,
            Self::Autosize => ffi::GTK_TREE_VIEW_COLUMN_AUTOSIZE,
            Self::Fixed => ffi::GTK_TREE_VIEW_COLUMN_FIXED,
            Self::__Unknown(value) => value,
        }
    }
}

#[allow(deprecated)]
#[doc(hidden)]
impl FromGlib<ffi::GtkTreeViewColumnSizing> for TreeViewColumnSizing {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkTreeViewColumnSizing) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_TREE_VIEW_COLUMN_GROW_ONLY => Self::GrowOnly,
            ffi::GTK_TREE_VIEW_COLUMN_AUTOSIZE => Self::Autosize,
            ffi::GTK_TREE_VIEW_COLUMN_FIXED => Self::Fixed,
            value => Self::__Unknown(value),
        }
    }
}

#[allow(deprecated)]
impl StaticType for TreeViewColumnSizing {
    #[inline]
    #[doc(alias = "gtk_tree_view_column_sizing_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_tree_view_column_sizing_get_type()) }
    }
}

#[allow(deprecated)]
impl glib::HasParamSpec for TreeViewColumnSizing {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

#[allow(deprecated)]
impl glib::value::ValueType for TreeViewColumnSizing {
    type Type = Self;
}

#[allow(deprecated)]
unsafe impl<'a> glib::value::FromValue<'a> for TreeViewColumnSizing {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

#[allow(deprecated)]
impl ToValue for TreeViewColumnSizing {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

#[allow(deprecated)]
impl From<TreeViewColumnSizing> for glib::Value {
    #[inline]
    fn from(v: TreeViewColumnSizing) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// An enum for determining where a dropped row goes.
///
/// # Deprecated since 4.20
///
/// There is no replacement.
#[cfg_attr(feature = "v4_20", deprecated = "Since 4.20")]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkTreeViewDropPosition")]
pub enum TreeViewDropPosition {
    /// dropped row is inserted before
    #[doc(alias = "GTK_TREE_VIEW_DROP_BEFORE")]
    Before,
    /// dropped row is inserted after
    #[doc(alias = "GTK_TREE_VIEW_DROP_AFTER")]
    After,
    /// dropped row becomes a child or is inserted before
    #[doc(alias = "GTK_TREE_VIEW_DROP_INTO_OR_BEFORE")]
    IntoOrBefore,
    /// dropped row becomes a child or is inserted after
    #[doc(alias = "GTK_TREE_VIEW_DROP_INTO_OR_AFTER")]
    IntoOrAfter,
    #[doc(hidden)]
    __Unknown(i32),
}

#[allow(deprecated)]
#[doc(hidden)]
impl IntoGlib for TreeViewDropPosition {
    type GlibType = ffi::GtkTreeViewDropPosition;

    #[inline]
    fn into_glib(self) -> ffi::GtkTreeViewDropPosition {
        match self {
            Self::Before => ffi::GTK_TREE_VIEW_DROP_BEFORE,
            Self::After => ffi::GTK_TREE_VIEW_DROP_AFTER,
            Self::IntoOrBefore => ffi::GTK_TREE_VIEW_DROP_INTO_OR_BEFORE,
            Self::IntoOrAfter => ffi::GTK_TREE_VIEW_DROP_INTO_OR_AFTER,
            Self::__Unknown(value) => value,
        }
    }
}

#[allow(deprecated)]
#[doc(hidden)]
impl FromGlib<ffi::GtkTreeViewDropPosition> for TreeViewDropPosition {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkTreeViewDropPosition) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_TREE_VIEW_DROP_BEFORE => Self::Before,
            ffi::GTK_TREE_VIEW_DROP_AFTER => Self::After,
            ffi::GTK_TREE_VIEW_DROP_INTO_OR_BEFORE => Self::IntoOrBefore,
            ffi::GTK_TREE_VIEW_DROP_INTO_OR_AFTER => Self::IntoOrAfter,
            value => Self::__Unknown(value),
        }
    }
}

#[allow(deprecated)]
impl StaticType for TreeViewDropPosition {
    #[inline]
    #[doc(alias = "gtk_tree_view_drop_position_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_tree_view_drop_position_get_type()) }
    }
}

#[allow(deprecated)]
impl glib::HasParamSpec for TreeViewDropPosition {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

#[allow(deprecated)]
impl glib::value::ValueType for TreeViewDropPosition {
    type Type = Self;
}

#[allow(deprecated)]
unsafe impl<'a> glib::value::FromValue<'a> for TreeViewDropPosition {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

#[allow(deprecated)]
impl ToValue for TreeViewDropPosition {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

#[allow(deprecated)]
impl From<TreeViewDropPosition> for glib::Value {
    #[inline]
    fn from(v: TreeViewDropPosition) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Used to indicate which grid lines to draw in a tree view.
///
/// # Deprecated since 4.20
///
/// There is no replacement
#[cfg_attr(feature = "v4_20", deprecated = "Since 4.20")]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkTreeViewGridLines")]
pub enum TreeViewGridLines {
    /// No grid lines.
    #[doc(alias = "GTK_TREE_VIEW_GRID_LINES_NONE")]
    None,
    /// Horizontal grid lines.
    #[doc(alias = "GTK_TREE_VIEW_GRID_LINES_HORIZONTAL")]
    Horizontal,
    /// Vertical grid lines.
    #[doc(alias = "GTK_TREE_VIEW_GRID_LINES_VERTICAL")]
    Vertical,
    /// Horizontal and vertical grid lines.
    #[doc(alias = "GTK_TREE_VIEW_GRID_LINES_BOTH")]
    Both,
    #[doc(hidden)]
    __Unknown(i32),
}

#[allow(deprecated)]
#[doc(hidden)]
impl IntoGlib for TreeViewGridLines {
    type GlibType = ffi::GtkTreeViewGridLines;

    #[inline]
    fn into_glib(self) -> ffi::GtkTreeViewGridLines {
        match self {
            Self::None => ffi::GTK_TREE_VIEW_GRID_LINES_NONE,
            Self::Horizontal => ffi::GTK_TREE_VIEW_GRID_LINES_HORIZONTAL,
            Self::Vertical => ffi::GTK_TREE_VIEW_GRID_LINES_VERTICAL,
            Self::Both => ffi::GTK_TREE_VIEW_GRID_LINES_BOTH,
            Self::__Unknown(value) => value,
        }
    }
}

#[allow(deprecated)]
#[doc(hidden)]
impl FromGlib<ffi::GtkTreeViewGridLines> for TreeViewGridLines {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkTreeViewGridLines) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_TREE_VIEW_GRID_LINES_NONE => Self::None,
            ffi::GTK_TREE_VIEW_GRID_LINES_HORIZONTAL => Self::Horizontal,
            ffi::GTK_TREE_VIEW_GRID_LINES_VERTICAL => Self::Vertical,
            ffi::GTK_TREE_VIEW_GRID_LINES_BOTH => Self::Both,
            value => Self::__Unknown(value),
        }
    }
}

#[allow(deprecated)]
impl StaticType for TreeViewGridLines {
    #[inline]
    #[doc(alias = "gtk_tree_view_grid_lines_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_tree_view_grid_lines_get_type()) }
    }
}

#[allow(deprecated)]
impl glib::HasParamSpec for TreeViewGridLines {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

#[allow(deprecated)]
impl glib::value::ValueType for TreeViewGridLines {
    type Type = Self;
}

#[allow(deprecated)]
unsafe impl<'a> glib::value::FromValue<'a> for TreeViewGridLines {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

#[allow(deprecated)]
impl ToValue for TreeViewGridLines {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

#[allow(deprecated)]
impl From<TreeViewGridLines> for glib::Value {
    #[inline]
    fn from(v: TreeViewGridLines) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// See also gtk_print_settings_set_paper_width().
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkUnit")]
pub enum Unit {
    /// No units.
    #[doc(alias = "GTK_UNIT_NONE")]
    None,
    /// Dimensions in points.
    #[doc(alias = "GTK_UNIT_POINTS")]
    Points,
    /// Dimensions in inches.
    #[doc(alias = "GTK_UNIT_INCH")]
    Inch,
    /// Dimensions in millimeters
    #[doc(alias = "GTK_UNIT_MM")]
    Mm,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for Unit {
    type GlibType = ffi::GtkUnit;

    #[inline]
    fn into_glib(self) -> ffi::GtkUnit {
        match self {
            Self::None => ffi::GTK_UNIT_NONE,
            Self::Points => ffi::GTK_UNIT_POINTS,
            Self::Inch => ffi::GTK_UNIT_INCH,
            Self::Mm => ffi::GTK_UNIT_MM,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkUnit> for Unit {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkUnit) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_UNIT_NONE => Self::None,
            ffi::GTK_UNIT_POINTS => Self::Points,
            ffi::GTK_UNIT_INCH => Self::Inch,
            ffi::GTK_UNIT_MM => Self::Mm,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for Unit {
    #[inline]
    #[doc(alias = "gtk_unit_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_unit_get_type()) }
    }
}

impl glib::HasParamSpec for Unit {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for Unit {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for Unit {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for Unit {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<Unit> for glib::Value {
    #[inline]
    fn from(v: Unit) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Determines which point or edge of a window is meant to remain fixed
/// when a window changes size.
#[cfg(feature = "v4_20")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkWindowGravity")]
pub enum WindowGravity {
    /// The top left corner
    #[doc(alias = "GTK_WINDOW_GRAVITY_TOP_LEFT")]
    TopLeft,
    /// The top edge
    #[doc(alias = "GTK_WINDOW_GRAVITY_TOP")]
    Top,
    /// The top right corner
    #[doc(alias = "GTK_WINDOW_GRAVITY_TOP_RIGHT")]
    TopRight,
    /// The left edge
    #[doc(alias = "GTK_WINDOW_GRAVITY_LEFT")]
    Left,
    /// The center pointer
    #[doc(alias = "GTK_WINDOW_GRAVITY_CENTER")]
    Center,
    /// The right edge
    #[doc(alias = "GTK_WINDOW_GRAVITY_RIGHT")]
    Right,
    /// The bottom left corner
    #[doc(alias = "GTK_WINDOW_GRAVITY_BOTTOM_LEFT")]
    BottomLeft,
    /// the bottom edge
    #[doc(alias = "GTK_WINDOW_GRAVITY_BOTTOM")]
    Bottom,
    /// The bottom right corner
    #[doc(alias = "GTK_WINDOW_GRAVITY_BOTTOM_RIGHT")]
    BottomRight,
    /// The top left or top right corner,
    ///   depending on the text direction
    #[doc(alias = "GTK_WINDOW_GRAVITY_TOP_START")]
    TopStart,
    /// The top right or top left corner,
    ///   depending on the text direction
    #[doc(alias = "GTK_WINDOW_GRAVITY_TOP_END")]
    TopEnd,
    /// The left or right edge,
    ///   depending on the text direction
    #[doc(alias = "GTK_WINDOW_GRAVITY_START")]
    Start,
    /// The right or left edge,
    ///   depending on the text direction
    #[doc(alias = "GTK_WINDOW_GRAVITY_END")]
    End,
    /// The bottom left or top right corner,
    ///   depending on the text direction
    #[doc(alias = "GTK_WINDOW_GRAVITY_BOTTOM_START")]
    BottomStart,
    /// The bottom right or top left corner,
    ///   depending on the text direction
    #[doc(alias = "GTK_WINDOW_GRAVITY_BOTTOM_END")]
    BottomEnd,
    #[doc(hidden)]
    __Unknown(i32),
}

#[cfg(feature = "v4_20")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
#[doc(hidden)]
impl IntoGlib for WindowGravity {
    type GlibType = ffi::GtkWindowGravity;

    fn into_glib(self) -> ffi::GtkWindowGravity {
        match self {
            Self::TopLeft => ffi::GTK_WINDOW_GRAVITY_TOP_LEFT,
            Self::Top => ffi::GTK_WINDOW_GRAVITY_TOP,
            Self::TopRight => ffi::GTK_WINDOW_GRAVITY_TOP_RIGHT,
            Self::Left => ffi::GTK_WINDOW_GRAVITY_LEFT,
            Self::Center => ffi::GTK_WINDOW_GRAVITY_CENTER,
            Self::Right => ffi::GTK_WINDOW_GRAVITY_RIGHT,
            Self::BottomLeft => ffi::GTK_WINDOW_GRAVITY_BOTTOM_LEFT,
            Self::Bottom => ffi::GTK_WINDOW_GRAVITY_BOTTOM,
            Self::BottomRight => ffi::GTK_WINDOW_GRAVITY_BOTTOM_RIGHT,
            Self::TopStart => ffi::GTK_WINDOW_GRAVITY_TOP_START,
            Self::TopEnd => ffi::GTK_WINDOW_GRAVITY_TOP_END,
            Self::Start => ffi::GTK_WINDOW_GRAVITY_START,
            Self::End => ffi::GTK_WINDOW_GRAVITY_END,
            Self::BottomStart => ffi::GTK_WINDOW_GRAVITY_BOTTOM_START,
            Self::BottomEnd => ffi::GTK_WINDOW_GRAVITY_BOTTOM_END,
            Self::__Unknown(value) => value,
        }
    }
}

#[cfg(feature = "v4_20")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
#[doc(hidden)]
impl FromGlib<ffi::GtkWindowGravity> for WindowGravity {
    unsafe fn from_glib(value: ffi::GtkWindowGravity) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_WINDOW_GRAVITY_TOP_LEFT => Self::TopLeft,
            ffi::GTK_WINDOW_GRAVITY_TOP => Self::Top,
            ffi::GTK_WINDOW_GRAVITY_TOP_RIGHT => Self::TopRight,
            ffi::GTK_WINDOW_GRAVITY_LEFT => Self::Left,
            ffi::GTK_WINDOW_GRAVITY_CENTER => Self::Center,
            ffi::GTK_WINDOW_GRAVITY_RIGHT => Self::Right,
            ffi::GTK_WINDOW_GRAVITY_BOTTOM_LEFT => Self::BottomLeft,
            ffi::GTK_WINDOW_GRAVITY_BOTTOM => Self::Bottom,
            ffi::GTK_WINDOW_GRAVITY_BOTTOM_RIGHT => Self::BottomRight,
            ffi::GTK_WINDOW_GRAVITY_TOP_START => Self::TopStart,
            ffi::GTK_WINDOW_GRAVITY_TOP_END => Self::TopEnd,
            ffi::GTK_WINDOW_GRAVITY_START => Self::Start,
            ffi::GTK_WINDOW_GRAVITY_END => Self::End,
            ffi::GTK_WINDOW_GRAVITY_BOTTOM_START => Self::BottomStart,
            ffi::GTK_WINDOW_GRAVITY_BOTTOM_END => Self::BottomEnd,
            value => Self::__Unknown(value),
        }
    }
}

#[cfg(feature = "v4_20")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
impl StaticType for WindowGravity {
    #[inline]
    #[doc(alias = "gtk_window_gravity_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_window_gravity_get_type()) }
    }
}

#[cfg(feature = "v4_20")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
impl glib::HasParamSpec for WindowGravity {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

#[cfg(feature = "v4_20")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
impl glib::value::ValueType for WindowGravity {
    type Type = Self;
}

#[cfg(feature = "v4_20")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
unsafe impl<'a> glib::value::FromValue<'a> for WindowGravity {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

#[cfg(feature = "v4_20")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
impl ToValue for WindowGravity {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

#[cfg(feature = "v4_20")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
impl From<WindowGravity> for glib::Value {
    #[inline]
    fn from(v: WindowGravity) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Describes a type of line wrapping.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GtkWrapMode")]
pub enum WrapMode {
    /// do not wrap lines; just make the text area wider
    #[doc(alias = "GTK_WRAP_NONE")]
    None,
    /// wrap text, breaking lines anywhere the cursor can
    ///   appear (between characters, usually - if you want to be technical,
    ///   between graphemes, see pango_get_log_attrs())
    #[doc(alias = "GTK_WRAP_CHAR")]
    Char,
    /// wrap text, breaking lines in between words
    #[doc(alias = "GTK_WRAP_WORD")]
    Word,
    /// wrap text, breaking lines in between words, or if
    ///   that is not enough, also between graphemes
    #[doc(alias = "GTK_WRAP_WORD_CHAR")]
    WordChar,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl IntoGlib for WrapMode {
    type GlibType = ffi::GtkWrapMode;

    #[inline]
    fn into_glib(self) -> ffi::GtkWrapMode {
        match self {
            Self::None => ffi::GTK_WRAP_NONE,
            Self::Char => ffi::GTK_WRAP_CHAR,
            Self::Word => ffi::GTK_WRAP_WORD,
            Self::WordChar => ffi::GTK_WRAP_WORD_CHAR,
            Self::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GtkWrapMode> for WrapMode {
    #[inline]
    unsafe fn from_glib(value: ffi::GtkWrapMode) -> Self {
        skip_assert_initialized!();

        match value {
            ffi::GTK_WRAP_NONE => Self::None,
            ffi::GTK_WRAP_CHAR => Self::Char,
            ffi::GTK_WRAP_WORD => Self::Word,
            ffi::GTK_WRAP_WORD_CHAR => Self::WordChar,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for WrapMode {
    #[inline]
    #[doc(alias = "gtk_wrap_mode_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gtk_wrap_mode_get_type()) }
    }
}

impl glib::HasParamSpec for WrapMode {
    type ParamSpec = glib::ParamSpecEnum;
    type SetValue = Self;
    type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;

    fn param_spec_builder() -> Self::BuilderFn {
        Self::ParamSpec::builder_with_default
    }
}

impl glib::value::ValueType for WrapMode {
    type Type = Self;
}

unsafe impl<'a> glib::value::FromValue<'a> for WrapMode {
    type Checker = glib::value::GenericValueTypeChecker<Self>;

    #[inline]
    unsafe fn from_value(value: &'a glib::Value) -> Self {
        skip_assert_initialized!();
        unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
    }
}

impl ToValue for WrapMode {
    #[inline]
    fn to_value(&self) -> glib::Value {
        let mut value = glib::Value::for_value_type::<Self>();
        unsafe {
            glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
        }
        value
    }

    #[inline]
    fn value_type(&self) -> glib::Type {
        Self::static_type()
    }
}

impl From<WrapMode> for glib::Value {
    #[inline]
    fn from(v: WrapMode) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}