libadwaita/auto/

enums.rs

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

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

/// Describes the available system accent colors.
#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AdwAccentColor")]
pub enum AccentColor {
    /// Use a blue color (`#3584e4`). This is the default value.
    #[doc(alias = "ADW_ACCENT_COLOR_BLUE")]
    Blue,
    /// Use a teal color (`#2190a4`).
    #[doc(alias = "ADW_ACCENT_COLOR_TEAL")]
    Teal,
    /// Use a green color (`#3a944a`).
    #[doc(alias = "ADW_ACCENT_COLOR_GREEN")]
    Green,
    /// Use a yellow color (`#c88800`).
    #[doc(alias = "ADW_ACCENT_COLOR_YELLOW")]
    Yellow,
    /// Use a orange color (`#ed5b00`).
    #[doc(alias = "ADW_ACCENT_COLOR_ORANGE")]
    Orange,
    /// Use a red color (`#e62d42`).
    #[doc(alias = "ADW_ACCENT_COLOR_RED")]
    Red,
    /// Use a pink color (`#d56199`).
    #[doc(alias = "ADW_ACCENT_COLOR_PINK")]
    Pink,
    /// Use a purple color (`#9141ac`).
    #[doc(alias = "ADW_ACCENT_COLOR_PURPLE")]
    Purple,
    /// Use a slate color (`#6f8396`).
    #[doc(alias = "ADW_ACCENT_COLOR_SLATE")]
    Slate,
    #[doc(hidden)]
    __Unknown(i32),
}

#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
impl AccentColor {
    #[doc(alias = "adw_accent_color_to_rgba")]
    pub fn to_rgba(self) -> gdk::RGBA {
        assert_initialized_main_thread!();
        unsafe {
            let mut rgba = gdk::RGBA::uninitialized();
            ffi::adw_accent_color_to_rgba(self.into_glib(), rgba.to_glib_none_mut().0);
            rgba
        }
    }

    #[doc(alias = "adw_accent_color_to_standalone_rgba")]
    pub fn to_standalone_rgba(self, dark: bool) -> gdk::RGBA {
        assert_initialized_main_thread!();
        unsafe {
            let mut rgba = gdk::RGBA::uninitialized();
            ffi::adw_accent_color_to_standalone_rgba(
                self.into_glib(),
                dark.into_glib(),
                rgba.to_glib_none_mut().0,
            );
            rgba
        }
    }
}

#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
#[doc(hidden)]
impl IntoGlib for AccentColor {
    type GlibType = ffi::AdwAccentColor;

    #[inline]
    fn into_glib(self) -> ffi::AdwAccentColor {
        match self {
            Self::Blue => ffi::ADW_ACCENT_COLOR_BLUE,
            Self::Teal => ffi::ADW_ACCENT_COLOR_TEAL,
            Self::Green => ffi::ADW_ACCENT_COLOR_GREEN,
            Self::Yellow => ffi::ADW_ACCENT_COLOR_YELLOW,
            Self::Orange => ffi::ADW_ACCENT_COLOR_ORANGE,
            Self::Red => ffi::ADW_ACCENT_COLOR_RED,
            Self::Pink => ffi::ADW_ACCENT_COLOR_PINK,
            Self::Purple => ffi::ADW_ACCENT_COLOR_PURPLE,
            Self::Slate => ffi::ADW_ACCENT_COLOR_SLATE,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::ADW_ACCENT_COLOR_BLUE => Self::Blue,
            ffi::ADW_ACCENT_COLOR_TEAL => Self::Teal,
            ffi::ADW_ACCENT_COLOR_GREEN => Self::Green,
            ffi::ADW_ACCENT_COLOR_YELLOW => Self::Yellow,
            ffi::ADW_ACCENT_COLOR_ORANGE => Self::Orange,
            ffi::ADW_ACCENT_COLOR_RED => Self::Red,
            ffi::ADW_ACCENT_COLOR_PINK => Self::Pink,
            ffi::ADW_ACCENT_COLOR_PURPLE => Self::Purple,
            ffi::ADW_ACCENT_COLOR_SLATE => Self::Slate,
            value => Self::__Unknown(value),
        }
    }
}

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

#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
impl glib::HasParamSpec for AccentColor {
    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 = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
impl glib::value::ValueType for AccentColor {
    type Type = Self;
}

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

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

#[cfg(feature = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
impl ToValue for AccentColor {
    #[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 = "v1_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
impl From<AccentColor> for glib::Value {
    #[inline]
    fn from(v: AccentColor) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Describes the possible states of an [`Animation`][crate::Animation].
///
/// The state can be controlled with [`AnimationExt::play()`][crate::prelude::AnimationExt::play()],
/// [`AnimationExt::pause()`][crate::prelude::AnimationExt::pause()], [`AnimationExt::resume()`][crate::prelude::AnimationExt::resume()],
/// [`AnimationExt::reset()`][crate::prelude::AnimationExt::reset()] and [`AnimationExt::skip()`][crate::prelude::AnimationExt::skip()].
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AdwAnimationState")]
pub enum AnimationState {
    /// The animation hasn't started yet.
    #[doc(alias = "ADW_ANIMATION_IDLE")]
    Idle,
    /// The animation has been paused.
    #[doc(alias = "ADW_ANIMATION_PAUSED")]
    Paused,
    /// The animation is currently playing.
    #[doc(alias = "ADW_ANIMATION_PLAYING")]
    Playing,
    /// The animation has finished.
    #[doc(alias = "ADW_ANIMATION_FINISHED")]
    Finished,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::AdwAnimationState {
        match self {
            Self::Idle => ffi::ADW_ANIMATION_IDLE,
            Self::Paused => ffi::ADW_ANIMATION_PAUSED,
            Self::Playing => ffi::ADW_ANIMATION_PLAYING,
            Self::Finished => ffi::ADW_ANIMATION_FINISHED,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::ADW_ANIMATION_IDLE => Self::Idle,
            ffi::ADW_ANIMATION_PAUSED => Self::Paused,
            ffi::ADW_ANIMATION_PLAYING => Self::Playing,
            ffi::ADW_ANIMATION_FINISHED => Self::Finished,
            value => Self::__Unknown(value),
        }
    }
}

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

impl glib::HasParamSpec for AnimationState {
    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 AnimationState {
    type Type = Self;
}

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

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

impl ToValue for AnimationState {
    #[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<AnimationState> for glib::Value {
    #[inline]
    fn from(v: AnimationState) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Describes length types for [`BreakpointCondition`][crate::BreakpointCondition].
///
/// See `BreakpointCondition::new_length()`.
///
/// New values may be added to this enumeration over time.
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AdwBreakpointConditionLengthType")]
pub enum BreakpointConditionLengthType {
    /// true if the width is greater than or
    ///   equal to the condition value
    #[doc(alias = "ADW_BREAKPOINT_CONDITION_MIN_WIDTH")]
    MinWidth,
    /// true if the width is less than or
    ///   equal to the condition value
    #[doc(alias = "ADW_BREAKPOINT_CONDITION_MAX_WIDTH")]
    MaxWidth,
    /// true if the height is greater than or
    ///   equal to the condition value
    #[doc(alias = "ADW_BREAKPOINT_CONDITION_MIN_HEIGHT")]
    MinHeight,
    /// true if the height is less than or
    ///   equal to the condition value
    #[doc(alias = "ADW_BREAKPOINT_CONDITION_MAX_HEIGHT")]
    MaxHeight,
    #[doc(hidden)]
    __Unknown(i32),
}

#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
#[doc(hidden)]
impl IntoGlib for BreakpointConditionLengthType {
    type GlibType = ffi::AdwBreakpointConditionLengthType;

    #[inline]
    fn into_glib(self) -> ffi::AdwBreakpointConditionLengthType {
        match self {
            Self::MinWidth => ffi::ADW_BREAKPOINT_CONDITION_MIN_WIDTH,
            Self::MaxWidth => ffi::ADW_BREAKPOINT_CONDITION_MAX_WIDTH,
            Self::MinHeight => ffi::ADW_BREAKPOINT_CONDITION_MIN_HEIGHT,
            Self::MaxHeight => ffi::ADW_BREAKPOINT_CONDITION_MAX_HEIGHT,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::ADW_BREAKPOINT_CONDITION_MIN_WIDTH => Self::MinWidth,
            ffi::ADW_BREAKPOINT_CONDITION_MAX_WIDTH => Self::MaxWidth,
            ffi::ADW_BREAKPOINT_CONDITION_MIN_HEIGHT => Self::MinHeight,
            ffi::ADW_BREAKPOINT_CONDITION_MAX_HEIGHT => Self::MaxHeight,
            value => Self::__Unknown(value),
        }
    }
}

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

#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
impl glib::HasParamSpec for BreakpointConditionLengthType {
    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 = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
impl glib::value::ValueType for BreakpointConditionLengthType {
    type Type = Self;
}

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

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

#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
impl ToValue for BreakpointConditionLengthType {
    #[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 = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
impl From<BreakpointConditionLengthType> for glib::Value {
    #[inline]
    fn from(v: BreakpointConditionLengthType) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Describes ratio types for [`BreakpointCondition`][crate::BreakpointCondition].
///
/// See `BreakpointCondition::new_ratio()`.
///
/// New values may be added to this enumeration over time.
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AdwBreakpointConditionRatioType")]
pub enum BreakpointConditionRatioType {
    /// true if the aspect ratio is
    ///   greater than or equal to the condition value
    #[doc(alias = "ADW_BREAKPOINT_CONDITION_MIN_ASPECT_RATIO")]
    MinAspectRatio,
    /// true if the aspect ratio is
    ///   less than or equal to the condition value
    #[doc(alias = "ADW_BREAKPOINT_CONDITION_MAX_ASPECT_RATIO")]
    MaxAspectRatio,
    #[doc(hidden)]
    __Unknown(i32),
}

#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
#[doc(hidden)]
impl IntoGlib for BreakpointConditionRatioType {
    type GlibType = ffi::AdwBreakpointConditionRatioType;

    #[inline]
    fn into_glib(self) -> ffi::AdwBreakpointConditionRatioType {
        match self {
            Self::MinAspectRatio => ffi::ADW_BREAKPOINT_CONDITION_MIN_ASPECT_RATIO,
            Self::MaxAspectRatio => ffi::ADW_BREAKPOINT_CONDITION_MAX_ASPECT_RATIO,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::ADW_BREAKPOINT_CONDITION_MIN_ASPECT_RATIO => Self::MinAspectRatio,
            ffi::ADW_BREAKPOINT_CONDITION_MAX_ASPECT_RATIO => Self::MaxAspectRatio,
            value => Self::__Unknown(value),
        }
    }
}

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

#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
impl glib::HasParamSpec for BreakpointConditionRatioType {
    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 = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
impl glib::value::ValueType for BreakpointConditionRatioType {
    type Type = Self;
}

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

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

#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
impl ToValue for BreakpointConditionRatioType {
    #[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 = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
impl From<BreakpointConditionRatioType> for glib::Value {
    #[inline]
    fn from(v: BreakpointConditionRatioType) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Describes title centering behavior of a [`HeaderBar`][crate::HeaderBar] widget.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AdwCenteringPolicy")]
pub enum CenteringPolicy {
    /// Keep the title centered when possible
    #[doc(alias = "ADW_CENTERING_POLICY_LOOSE")]
    Loose,
    /// Keep the title centered at all cost
    #[doc(alias = "ADW_CENTERING_POLICY_STRICT")]
    Strict,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::AdwCenteringPolicy {
        match self {
            Self::Loose => ffi::ADW_CENTERING_POLICY_LOOSE,
            Self::Strict => ffi::ADW_CENTERING_POLICY_STRICT,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::ADW_CENTERING_POLICY_LOOSE => Self::Loose,
            ffi::ADW_CENTERING_POLICY_STRICT => Self::Strict,
            value => Self::__Unknown(value),
        }
    }
}

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

impl glib::HasParamSpec for CenteringPolicy {
    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 CenteringPolicy {
    type Type = Self;
}

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

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

impl ToValue for CenteringPolicy {
    #[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<CenteringPolicy> for glib::Value {
    #[inline]
    fn from(v: CenteringPolicy) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Application color schemes for [`color-scheme`][struct@crate::StyleManager#color-scheme].
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AdwColorScheme")]
pub enum ColorScheme {
    /// Inherit the parent color-scheme. When set on the
    ///   [`StyleManager`][crate::StyleManager] returned by `get_default()`, it's
    ///   equivalent to `ADW_COLOR_SCHEME_PREFER_LIGHT`.
    #[doc(alias = "ADW_COLOR_SCHEME_DEFAULT")]
    Default,
    /// Always use light appearance.
    #[doc(alias = "ADW_COLOR_SCHEME_FORCE_LIGHT")]
    ForceLight,
    /// Use light appearance unless the system
    ///   prefers dark colors.
    #[doc(alias = "ADW_COLOR_SCHEME_PREFER_LIGHT")]
    PreferLight,
    /// Use dark appearance unless the system prefers
    ///   prefers light colors.
    #[doc(alias = "ADW_COLOR_SCHEME_PREFER_DARK")]
    PreferDark,
    /// Always use dark appearance.
    #[doc(alias = "ADW_COLOR_SCHEME_FORCE_DARK")]
    ForceDark,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::AdwColorScheme {
        match self {
            Self::Default => ffi::ADW_COLOR_SCHEME_DEFAULT,
            Self::ForceLight => ffi::ADW_COLOR_SCHEME_FORCE_LIGHT,
            Self::PreferLight => ffi::ADW_COLOR_SCHEME_PREFER_LIGHT,
            Self::PreferDark => ffi::ADW_COLOR_SCHEME_PREFER_DARK,
            Self::ForceDark => ffi::ADW_COLOR_SCHEME_FORCE_DARK,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::ADW_COLOR_SCHEME_DEFAULT => Self::Default,
            ffi::ADW_COLOR_SCHEME_FORCE_LIGHT => Self::ForceLight,
            ffi::ADW_COLOR_SCHEME_PREFER_LIGHT => Self::PreferLight,
            ffi::ADW_COLOR_SCHEME_PREFER_DARK => Self::PreferDark,
            ffi::ADW_COLOR_SCHEME_FORCE_DARK => Self::ForceDark,
            value => Self::__Unknown(value),
        }
    }
}

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

impl glib::HasParamSpec for ColorScheme {
    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 ColorScheme {
    type Type = Self;
}

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

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

impl ToValue for ColorScheme {
    #[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<ColorScheme> for glib::Value {
    #[inline]
    fn from(v: ColorScheme) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Describes the available presentation modes for [`Dialog`][crate::Dialog].
///
/// New values may be added to this enumeration over time.
///
/// See [`presentation-mode`][struct@crate::Dialog#presentation-mode].
#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AdwDialogPresentationMode")]
pub enum DialogPresentationMode {
    /// Switch between `ADW_DIALOG_FLOATING` and
    ///   `ADW_DIALOG_BOTTOM_SHEET` depending on available size.
    #[doc(alias = "ADW_DIALOG_AUTO")]
    Auto,
    /// Present dialog as a centered floating window.
    #[doc(alias = "ADW_DIALOG_FLOATING")]
    Floating,
    /// Present dialog as a bottom sheet.
    #[doc(alias = "ADW_DIALOG_BOTTOM_SHEET")]
    BottomSheet,
    #[doc(hidden)]
    __Unknown(i32),
}

#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
#[doc(hidden)]
impl IntoGlib for DialogPresentationMode {
    type GlibType = ffi::AdwDialogPresentationMode;

    #[inline]
    fn into_glib(self) -> ffi::AdwDialogPresentationMode {
        match self {
            Self::Auto => ffi::ADW_DIALOG_AUTO,
            Self::Floating => ffi::ADW_DIALOG_FLOATING,
            Self::BottomSheet => ffi::ADW_DIALOG_BOTTOM_SHEET,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::ADW_DIALOG_AUTO => Self::Auto,
            ffi::ADW_DIALOG_FLOATING => Self::Floating,
            ffi::ADW_DIALOG_BOTTOM_SHEET => Self::BottomSheet,
            value => Self::__Unknown(value),
        }
    }
}

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

#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
impl glib::HasParamSpec for DialogPresentationMode {
    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 = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
impl glib::value::ValueType for DialogPresentationMode {
    type Type = Self;
}

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

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

#[cfg(feature = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
impl ToValue for DialogPresentationMode {
    #[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 = "v1_5")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_5")))]
impl From<DialogPresentationMode> for glib::Value {
    #[inline]
    fn from(v: DialogPresentationMode) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Describes the available easing functions for use with
/// [`TimedAnimation`][crate::TimedAnimation].
///
/// New values may be added to this enumeration over time.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AdwEasing")]
pub enum Easing {
    /// Linear tweening.
    #[doc(alias = "ADW_LINEAR")]
    Linear,
    /// Quadratic tweening.
    #[doc(alias = "ADW_EASE_IN_QUAD")]
    EaseInQuad,
    /// Quadratic tweening, inverse of `ADW_EASE_IN_QUAD`.
    #[doc(alias = "ADW_EASE_OUT_QUAD")]
    EaseOutQuad,
    /// Quadratic tweening, combining `ADW_EASE_IN_QUAD` and
    ///   `ADW_EASE_OUT_QUAD`.
    #[doc(alias = "ADW_EASE_IN_OUT_QUAD")]
    EaseInOutQuad,
    /// Cubic tweening.
    #[doc(alias = "ADW_EASE_IN_CUBIC")]
    EaseInCubic,
    /// Cubic tweening, inverse of `ADW_EASE_IN_CUBIC`.
    #[doc(alias = "ADW_EASE_OUT_CUBIC")]
    EaseOutCubic,
    /// Cubic tweening, combining `ADW_EASE_IN_CUBIC` and
    ///   `ADW_EASE_OUT_CUBIC`.
    #[doc(alias = "ADW_EASE_IN_OUT_CUBIC")]
    EaseInOutCubic,
    /// Quartic tweening.
    #[doc(alias = "ADW_EASE_IN_QUART")]
    EaseInQuart,
    /// Quartic tweening, inverse of `ADW_EASE_IN_QUART`.
    #[doc(alias = "ADW_EASE_OUT_QUART")]
    EaseOutQuart,
    /// Quartic tweening, combining `ADW_EASE_IN_QUART` and
    ///   `ADW_EASE_OUT_QUART`.
    #[doc(alias = "ADW_EASE_IN_OUT_QUART")]
    EaseInOutQuart,
    /// Quintic tweening.
    #[doc(alias = "ADW_EASE_IN_QUINT")]
    EaseInQuint,
    /// Quintic tweening, inverse of `ADW_EASE_IN_QUINT`.
    #[doc(alias = "ADW_EASE_OUT_QUINT")]
    EaseOutQuint,
    /// Quintic tweening, combining `ADW_EASE_IN_QUINT` and
    ///   `ADW_EASE_OUT_QUINT`.
    #[doc(alias = "ADW_EASE_IN_OUT_QUINT")]
    EaseInOutQuint,
    /// Sine wave tweening.
    #[doc(alias = "ADW_EASE_IN_SINE")]
    EaseInSine,
    /// Sine wave tweening, inverse of `ADW_EASE_IN_SINE`.
    #[doc(alias = "ADW_EASE_OUT_SINE")]
    EaseOutSine,
    /// Sine wave tweening, combining `ADW_EASE_IN_SINE` and
    ///   `ADW_EASE_OUT_SINE`.
    #[doc(alias = "ADW_EASE_IN_OUT_SINE")]
    EaseInOutSine,
    /// Exponential tweening.
    #[doc(alias = "ADW_EASE_IN_EXPO")]
    EaseInExpo,
    /// Exponential tweening, inverse of `ADW_EASE_IN_EXPO`.
    #[doc(alias = "ADW_EASE_OUT_EXPO")]
    EaseOutExpo,
    /// Exponential tweening, combining `ADW_EASE_IN_EXPO` and
    ///   `ADW_EASE_OUT_EXPO`.
    #[doc(alias = "ADW_EASE_IN_OUT_EXPO")]
    EaseInOutExpo,
    /// Circular tweening.
    #[doc(alias = "ADW_EASE_IN_CIRC")]
    EaseInCirc,
    /// Circular tweening, inverse of `ADW_EASE_IN_CIRC`.
    #[doc(alias = "ADW_EASE_OUT_CIRC")]
    EaseOutCirc,
    /// Circular tweening, combining `ADW_EASE_IN_CIRC` and
    ///   `ADW_EASE_OUT_CIRC`.
    #[doc(alias = "ADW_EASE_IN_OUT_CIRC")]
    EaseInOutCirc,
    /// Elastic tweening, with offshoot on start.
    #[doc(alias = "ADW_EASE_IN_ELASTIC")]
    EaseInElastic,
    /// Elastic tweening, with offshoot on end, inverse of
    ///   `ADW_EASE_IN_ELASTIC`.
    #[doc(alias = "ADW_EASE_OUT_ELASTIC")]
    EaseOutElastic,
    /// Elastic tweening, with offshoot on both ends,
    ///   combining `ADW_EASE_IN_ELASTIC` and `ADW_EASE_OUT_ELASTIC`.
    #[doc(alias = "ADW_EASE_IN_OUT_ELASTIC")]
    EaseInOutElastic,
    /// Overshooting cubic tweening, with backtracking on start.
    #[doc(alias = "ADW_EASE_IN_BACK")]
    EaseInBack,
    /// Overshooting cubic tweening, with backtracking on end,
    ///   inverse of `ADW_EASE_IN_BACK`.
    #[doc(alias = "ADW_EASE_OUT_BACK")]
    EaseOutBack,
    /// Overshooting cubic tweening, with backtracking on both
    ///   ends, combining `ADW_EASE_IN_BACK` and `ADW_EASE_OUT_BACK`.
    #[doc(alias = "ADW_EASE_IN_OUT_BACK")]
    EaseInOutBack,
    /// Exponentially decaying parabolic (bounce) tweening,
    ///   on start.
    #[doc(alias = "ADW_EASE_IN_BOUNCE")]
    EaseInBounce,
    /// Exponentially decaying parabolic (bounce) tweening,
    ///   with bounce on end, inverse of `ADW_EASE_IN_BOUNCE`.
    #[doc(alias = "ADW_EASE_OUT_BOUNCE")]
    EaseOutBounce,
    /// Exponentially decaying parabolic (bounce) tweening,
    ///   with bounce on both ends, combining `ADW_EASE_IN_BOUNCE` and
    ///   `ADW_EASE_OUT_BOUNCE`.
    #[doc(alias = "ADW_EASE_IN_OUT_BOUNCE")]
    EaseInOutBounce,
    /// Cubic bezier tweening, with control points in (0.25, 0.1) and (0.25, 1.0).
    ///
    /// Increases in velocity towards the middle of the animation, slowing back down
    /// at the end.
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    #[doc(alias = "ADW_EASE")]
    Ease,
    /// Cubic bezier tweening, with control points in (0.42, 0.0) and (1.0, 1.0).
    ///
    /// Starts off slowly, with the speed of the animation increasing until complete.
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    #[doc(alias = "ADW_EASE_IN")]
    EaseIn,
    /// Cubic bezier tweening, with control points in (0.0, 0.0) and (0.58, 1.0).
    ///
    /// Starts quickly, slowing down the animation until complete.
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    #[doc(alias = "ADW_EASE_OUT")]
    EaseOut,
    /// Cubic bezier tweening, with control points in (0.42, 0.0) and (0.58, 1.0).
    ///
    /// Starts off slowly, speeds up in the middle, and then slows down again.
    #[cfg(feature = "v1_7")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
    #[doc(alias = "ADW_EASE_IN_OUT")]
    EaseInOut,
    #[doc(hidden)]
    __Unknown(i32),
}

impl Easing {
    #[doc(alias = "adw_easing_ease")]
    pub fn ease(self, value: f64) -> f64 {
        assert_initialized_main_thread!();
        unsafe { ffi::adw_easing_ease(self.into_glib(), value) }
    }
}

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

    fn into_glib(self) -> ffi::AdwEasing {
        match self {
            Self::Linear => ffi::ADW_LINEAR,
            Self::EaseInQuad => ffi::ADW_EASE_IN_QUAD,
            Self::EaseOutQuad => ffi::ADW_EASE_OUT_QUAD,
            Self::EaseInOutQuad => ffi::ADW_EASE_IN_OUT_QUAD,
            Self::EaseInCubic => ffi::ADW_EASE_IN_CUBIC,
            Self::EaseOutCubic => ffi::ADW_EASE_OUT_CUBIC,
            Self::EaseInOutCubic => ffi::ADW_EASE_IN_OUT_CUBIC,
            Self::EaseInQuart => ffi::ADW_EASE_IN_QUART,
            Self::EaseOutQuart => ffi::ADW_EASE_OUT_QUART,
            Self::EaseInOutQuart => ffi::ADW_EASE_IN_OUT_QUART,
            Self::EaseInQuint => ffi::ADW_EASE_IN_QUINT,
            Self::EaseOutQuint => ffi::ADW_EASE_OUT_QUINT,
            Self::EaseInOutQuint => ffi::ADW_EASE_IN_OUT_QUINT,
            Self::EaseInSine => ffi::ADW_EASE_IN_SINE,
            Self::EaseOutSine => ffi::ADW_EASE_OUT_SINE,
            Self::EaseInOutSine => ffi::ADW_EASE_IN_OUT_SINE,
            Self::EaseInExpo => ffi::ADW_EASE_IN_EXPO,
            Self::EaseOutExpo => ffi::ADW_EASE_OUT_EXPO,
            Self::EaseInOutExpo => ffi::ADW_EASE_IN_OUT_EXPO,
            Self::EaseInCirc => ffi::ADW_EASE_IN_CIRC,
            Self::EaseOutCirc => ffi::ADW_EASE_OUT_CIRC,
            Self::EaseInOutCirc => ffi::ADW_EASE_IN_OUT_CIRC,
            Self::EaseInElastic => ffi::ADW_EASE_IN_ELASTIC,
            Self::EaseOutElastic => ffi::ADW_EASE_OUT_ELASTIC,
            Self::EaseInOutElastic => ffi::ADW_EASE_IN_OUT_ELASTIC,
            Self::EaseInBack => ffi::ADW_EASE_IN_BACK,
            Self::EaseOutBack => ffi::ADW_EASE_OUT_BACK,
            Self::EaseInOutBack => ffi::ADW_EASE_IN_OUT_BACK,
            Self::EaseInBounce => ffi::ADW_EASE_IN_BOUNCE,
            Self::EaseOutBounce => ffi::ADW_EASE_OUT_BOUNCE,
            Self::EaseInOutBounce => ffi::ADW_EASE_IN_OUT_BOUNCE,
            #[cfg(feature = "v1_7")]
            Self::Ease => ffi::ADW_EASE,
            #[cfg(feature = "v1_7")]
            Self::EaseIn => ffi::ADW_EASE_IN,
            #[cfg(feature = "v1_7")]
            Self::EaseOut => ffi::ADW_EASE_OUT,
            #[cfg(feature = "v1_7")]
            Self::EaseInOut => ffi::ADW_EASE_IN_OUT,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::ADW_LINEAR => Self::Linear,
            ffi::ADW_EASE_IN_QUAD => Self::EaseInQuad,
            ffi::ADW_EASE_OUT_QUAD => Self::EaseOutQuad,
            ffi::ADW_EASE_IN_OUT_QUAD => Self::EaseInOutQuad,
            ffi::ADW_EASE_IN_CUBIC => Self::EaseInCubic,
            ffi::ADW_EASE_OUT_CUBIC => Self::EaseOutCubic,
            ffi::ADW_EASE_IN_OUT_CUBIC => Self::EaseInOutCubic,
            ffi::ADW_EASE_IN_QUART => Self::EaseInQuart,
            ffi::ADW_EASE_OUT_QUART => Self::EaseOutQuart,
            ffi::ADW_EASE_IN_OUT_QUART => Self::EaseInOutQuart,
            ffi::ADW_EASE_IN_QUINT => Self::EaseInQuint,
            ffi::ADW_EASE_OUT_QUINT => Self::EaseOutQuint,
            ffi::ADW_EASE_IN_OUT_QUINT => Self::EaseInOutQuint,
            ffi::ADW_EASE_IN_SINE => Self::EaseInSine,
            ffi::ADW_EASE_OUT_SINE => Self::EaseOutSine,
            ffi::ADW_EASE_IN_OUT_SINE => Self::EaseInOutSine,
            ffi::ADW_EASE_IN_EXPO => Self::EaseInExpo,
            ffi::ADW_EASE_OUT_EXPO => Self::EaseOutExpo,
            ffi::ADW_EASE_IN_OUT_EXPO => Self::EaseInOutExpo,
            ffi::ADW_EASE_IN_CIRC => Self::EaseInCirc,
            ffi::ADW_EASE_OUT_CIRC => Self::EaseOutCirc,
            ffi::ADW_EASE_IN_OUT_CIRC => Self::EaseInOutCirc,
            ffi::ADW_EASE_IN_ELASTIC => Self::EaseInElastic,
            ffi::ADW_EASE_OUT_ELASTIC => Self::EaseOutElastic,
            ffi::ADW_EASE_IN_OUT_ELASTIC => Self::EaseInOutElastic,
            ffi::ADW_EASE_IN_BACK => Self::EaseInBack,
            ffi::ADW_EASE_OUT_BACK => Self::EaseOutBack,
            ffi::ADW_EASE_IN_OUT_BACK => Self::EaseInOutBack,
            ffi::ADW_EASE_IN_BOUNCE => Self::EaseInBounce,
            ffi::ADW_EASE_OUT_BOUNCE => Self::EaseOutBounce,
            ffi::ADW_EASE_IN_OUT_BOUNCE => Self::EaseInOutBounce,
            #[cfg(feature = "v1_7")]
            ffi::ADW_EASE => Self::Ease,
            #[cfg(feature = "v1_7")]
            ffi::ADW_EASE_IN => Self::EaseIn,
            #[cfg(feature = "v1_7")]
            ffi::ADW_EASE_OUT => Self::EaseOut,
            #[cfg(feature = "v1_7")]
            ffi::ADW_EASE_IN_OUT => Self::EaseInOut,
            value => Self::__Unknown(value),
        }
    }
}

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

impl glib::HasParamSpec for Easing {
    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 Easing {
    type Type = Self;
}

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

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

impl ToValue for Easing {
    #[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<Easing> for glib::Value {
    #[inline]
    fn from(v: Easing) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Describes the possible folding behavior of a [`Flap`][crate::Flap] widget.
///
/// # Deprecated since 1.4
///
/// See [the migration guide](migrating-to-breakpoints.html#replace-adwflap)
#[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AdwFlapFoldPolicy")]
pub enum FlapFoldPolicy {
    /// Disable folding, the flap cannot reach narrow
    ///   sizes.
    #[doc(alias = "ADW_FLAP_FOLD_POLICY_NEVER")]
    Never,
    /// Keep the flap always folded.
    #[doc(alias = "ADW_FLAP_FOLD_POLICY_ALWAYS")]
    Always,
    /// Fold and unfold the flap based on available
    ///   space.
    #[doc(alias = "ADW_FLAP_FOLD_POLICY_AUTO")]
    Auto,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::AdwFlapFoldPolicy {
        match self {
            Self::Never => ffi::ADW_FLAP_FOLD_POLICY_NEVER,
            Self::Always => ffi::ADW_FLAP_FOLD_POLICY_ALWAYS,
            Self::Auto => ffi::ADW_FLAP_FOLD_POLICY_AUTO,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::ADW_FLAP_FOLD_POLICY_NEVER => Self::Never,
            ffi::ADW_FLAP_FOLD_POLICY_ALWAYS => Self::Always,
            ffi::ADW_FLAP_FOLD_POLICY_AUTO => Self::Auto,
            value => Self::__Unknown(value),
        }
    }
}

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

#[allow(deprecated)]
impl glib::HasParamSpec for FlapFoldPolicy {
    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 FlapFoldPolicy {
    type Type = Self;
}

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

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

#[allow(deprecated)]
impl ToValue for FlapFoldPolicy {
    #[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<FlapFoldPolicy> for glib::Value {
    #[inline]
    fn from(v: FlapFoldPolicy) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Describes transitions types of a [`Flap`][crate::Flap] widget.
///
/// It determines the type of animation when transitioning between children in a
/// [`Flap`][crate::Flap] widget, as well as which areas can be swiped via
/// [`swipe-to-open`][struct@crate::Flap#swipe-to-open] and [`swipe-to-close`][struct@crate::Flap#swipe-to-close].
///
/// # Deprecated since 1.4
///
/// See [the migration guide](migrating-to-breakpoints.html#replace-adwflap)
#[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AdwFlapTransitionType")]
pub enum FlapTransitionType {
    /// The flap slides over the content, which is
    ///   dimmed. When folded, only the flap can be swiped.
    #[doc(alias = "ADW_FLAP_TRANSITION_TYPE_OVER")]
    Over,
    /// The content slides over the flap. Only the
    ///   content can be swiped.
    #[doc(alias = "ADW_FLAP_TRANSITION_TYPE_UNDER")]
    Under,
    /// The flap slides offscreen when hidden,
    ///   neither the flap nor content overlap each other. Both widgets can be
    ///   swiped.
    #[doc(alias = "ADW_FLAP_TRANSITION_TYPE_SLIDE")]
    Slide,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::AdwFlapTransitionType {
        match self {
            Self::Over => ffi::ADW_FLAP_TRANSITION_TYPE_OVER,
            Self::Under => ffi::ADW_FLAP_TRANSITION_TYPE_UNDER,
            Self::Slide => ffi::ADW_FLAP_TRANSITION_TYPE_SLIDE,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::ADW_FLAP_TRANSITION_TYPE_OVER => Self::Over,
            ffi::ADW_FLAP_TRANSITION_TYPE_UNDER => Self::Under,
            ffi::ADW_FLAP_TRANSITION_TYPE_SLIDE => Self::Slide,
            value => Self::__Unknown(value),
        }
    }
}

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

#[allow(deprecated)]
impl glib::HasParamSpec for FlapTransitionType {
    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 FlapTransitionType {
    type Type = Self;
}

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

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

#[allow(deprecated)]
impl ToValue for FlapTransitionType {
    #[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<FlapTransitionType> for glib::Value {
    #[inline]
    fn from(v: FlapTransitionType) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Determines when [`Flap`][crate::Flap] and [`Leaflet`][crate::Leaflet] will fold.
///
/// # Deprecated since 1.4
///
/// Stop using [`Leaflet`][crate::Leaflet] and [`Flap`][crate::Flap]
#[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AdwFoldThresholdPolicy")]
pub enum FoldThresholdPolicy {
    /// Folding is based on the minimum size
    #[doc(alias = "ADW_FOLD_THRESHOLD_POLICY_MINIMUM")]
    Minimum,
    /// Folding is based on the natural size
    #[doc(alias = "ADW_FOLD_THRESHOLD_POLICY_NATURAL")]
    Natural,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::AdwFoldThresholdPolicy {
        match self {
            Self::Minimum => ffi::ADW_FOLD_THRESHOLD_POLICY_MINIMUM,
            Self::Natural => ffi::ADW_FOLD_THRESHOLD_POLICY_NATURAL,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::ADW_FOLD_THRESHOLD_POLICY_MINIMUM => Self::Minimum,
            ffi::ADW_FOLD_THRESHOLD_POLICY_NATURAL => Self::Natural,
            value => Self::__Unknown(value),
        }
    }
}

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

#[allow(deprecated)]
impl glib::HasParamSpec for FoldThresholdPolicy {
    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 FoldThresholdPolicy {
    type Type = Self;
}

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

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

#[allow(deprecated)]
impl ToValue for FoldThresholdPolicy {
    #[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<FoldThresholdPolicy> for glib::Value {
    #[inline]
    fn from(v: FoldThresholdPolicy) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Describes what [`InlineViewSwitcher`][crate::InlineViewSwitcher] toggles display.
///
/// <picture>
///   <source srcset="inline-view-switcher-display-modes-dark.png" media="(prefers-color-scheme: dark)">
///   <img src="inline-view-switcher-display-modes.png" alt="inline-view-switcher-display-modes">
/// </picture>
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AdwInlineViewSwitcherDisplayMode")]
pub enum InlineViewSwitcherDisplayMode {
    /// Toggles only display labels.
    #[doc(alias = "ADW_INLINE_VIEW_SWITCHER_LABELS")]
    Labels,
    /// Toggles only display icons.
    #[doc(alias = "ADW_INLINE_VIEW_SWITCHER_ICONS")]
    Icons,
    /// Toggles display both icons and labels.
    #[doc(alias = "ADW_INLINE_VIEW_SWITCHER_BOTH")]
    Both,
    #[doc(hidden)]
    __Unknown(i32),
}

#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
#[doc(hidden)]
impl IntoGlib for InlineViewSwitcherDisplayMode {
    type GlibType = ffi::AdwInlineViewSwitcherDisplayMode;

    #[inline]
    fn into_glib(self) -> ffi::AdwInlineViewSwitcherDisplayMode {
        match self {
            Self::Labels => ffi::ADW_INLINE_VIEW_SWITCHER_LABELS,
            Self::Icons => ffi::ADW_INLINE_VIEW_SWITCHER_ICONS,
            Self::Both => ffi::ADW_INLINE_VIEW_SWITCHER_BOTH,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::ADW_INLINE_VIEW_SWITCHER_LABELS => Self::Labels,
            ffi::ADW_INLINE_VIEW_SWITCHER_ICONS => Self::Icons,
            ffi::ADW_INLINE_VIEW_SWITCHER_BOTH => Self::Both,
            value => Self::__Unknown(value),
        }
    }
}

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

#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
impl glib::HasParamSpec for InlineViewSwitcherDisplayMode {
    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 = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
impl glib::value::ValueType for InlineViewSwitcherDisplayMode {
    type Type = Self;
}

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

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

#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
impl ToValue for InlineViewSwitcherDisplayMode {
    #[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 = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
impl From<InlineViewSwitcherDisplayMode> for glib::Value {
    #[inline]
    fn from(v: InlineViewSwitcherDisplayMode) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Describes line justify behaviors in a [`WrapLayout`][crate::WrapLayout] or [`WrapBox`][crate::WrapBox].
///
/// See [`justify`][struct@crate::WrapLayout#justify] and [`justify`][struct@crate::WrapBox#justify].
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AdwJustifyMode")]
pub enum JustifyMode {
    /// Don't justify children within a line.
    #[doc(alias = "ADW_JUSTIFY_NONE")]
    None,
    /// Stretch each child within the line, keeping consistent
    ///     spacing, so that the line fills the entire length.
    #[doc(alias = "ADW_JUSTIFY_FILL")]
    Fill,
    /// Increase spacing between children, moving the children
    ///     so that the first and last child are aligned with the beginning and end
    ///     of the line. If the line only contains a single widget, it will be
    ///     stretched regardless.
    #[doc(alias = "ADW_JUSTIFY_SPREAD")]
    Spread,
    #[doc(hidden)]
    __Unknown(i32),
}

#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
#[doc(hidden)]
impl IntoGlib for JustifyMode {
    type GlibType = ffi::AdwJustifyMode;

    #[inline]
    fn into_glib(self) -> ffi::AdwJustifyMode {
        match self {
            Self::None => ffi::ADW_JUSTIFY_NONE,
            Self::Fill => ffi::ADW_JUSTIFY_FILL,
            Self::Spread => ffi::ADW_JUSTIFY_SPREAD,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::ADW_JUSTIFY_NONE => Self::None,
            ffi::ADW_JUSTIFY_FILL => Self::Fill,
            ffi::ADW_JUSTIFY_SPREAD => Self::Spread,
            value => Self::__Unknown(value),
        }
    }
}

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

#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
impl glib::HasParamSpec for JustifyMode {
    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 = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
impl glib::value::ValueType for JustifyMode {
    type Type = Self;
}

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

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

#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
impl ToValue for JustifyMode {
    #[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 = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
impl From<JustifyMode> for glib::Value {
    #[inline]
    fn from(v: JustifyMode) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Describes the possible transitions in a [`Leaflet`][crate::Leaflet] widget.
///
/// New values may be added to this enumeration over time.
///
/// # Deprecated since 1.4
///
/// See [the migration guide](migrating-to-breakpoints.html#replace-adwleaflet)
#[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AdwLeafletTransitionType")]
pub enum LeafletTransitionType {
    /// Cover the old page or uncover the new page, sliding from or towards the end according to orientation, text direction and children order
    #[doc(alias = "ADW_LEAFLET_TRANSITION_TYPE_OVER")]
    Over,
    /// Uncover the new page or cover the old page, sliding from or towards the start according to orientation, text direction and children order
    #[doc(alias = "ADW_LEAFLET_TRANSITION_TYPE_UNDER")]
    Under,
    /// Slide from left, right, up or down according to the orientation, text direction and the children order
    #[doc(alias = "ADW_LEAFLET_TRANSITION_TYPE_SLIDE")]
    Slide,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::AdwLeafletTransitionType {
        match self {
            Self::Over => ffi::ADW_LEAFLET_TRANSITION_TYPE_OVER,
            Self::Under => ffi::ADW_LEAFLET_TRANSITION_TYPE_UNDER,
            Self::Slide => ffi::ADW_LEAFLET_TRANSITION_TYPE_SLIDE,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::ADW_LEAFLET_TRANSITION_TYPE_OVER => Self::Over,
            ffi::ADW_LEAFLET_TRANSITION_TYPE_UNDER => Self::Under,
            ffi::ADW_LEAFLET_TRANSITION_TYPE_SLIDE => Self::Slide,
            value => Self::__Unknown(value),
        }
    }
}

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

#[allow(deprecated)]
impl glib::HasParamSpec for LeafletTransitionType {
    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 LeafletTransitionType {
    type Type = Self;
}

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

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

#[allow(deprecated)]
impl ToValue for LeafletTransitionType {
    #[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<LeafletTransitionType> for glib::Value {
    #[inline]
    fn from(v: LeafletTransitionType) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Describes length units.
///
/// | Unit | Regular Text | Large Text |
/// | ---- | ------------ | ---------- |
/// | 1px  | 1px          | 1px        |
/// | 1pt  | 1.333333px   | 1.666667px |
/// | 1sp  | 1px          | 1.25px     |
///
/// New values may be added to this enumeration over time.
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AdwLengthUnit")]
pub enum LengthUnit {
    /// pixels
    #[doc(alias = "ADW_LENGTH_UNIT_PX")]
    Px,
    /// points, changes with text scale factor
    #[doc(alias = "ADW_LENGTH_UNIT_PT")]
    Pt,
    /// scale independent pixels, changes with text scale factor
    #[doc(alias = "ADW_LENGTH_UNIT_SP")]
    Sp,
    #[doc(hidden)]
    __Unknown(i32),
}

#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
impl LengthUnit {
    #[doc(alias = "adw_length_unit_from_px")]
    pub fn from_px(self, value: f64, settings: Option<&gtk::Settings>) -> f64 {
        assert_initialized_main_thread!();
        unsafe { ffi::adw_length_unit_from_px(self.into_glib(), value, settings.to_glib_none().0) }
    }

    #[doc(alias = "adw_length_unit_to_px")]
    pub fn to_px(self, value: f64, settings: Option<&gtk::Settings>) -> f64 {
        assert_initialized_main_thread!();
        unsafe { ffi::adw_length_unit_to_px(self.into_glib(), value, settings.to_glib_none().0) }
    }
}

#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
#[doc(hidden)]
impl IntoGlib for LengthUnit {
    type GlibType = ffi::AdwLengthUnit;

    #[inline]
    fn into_glib(self) -> ffi::AdwLengthUnit {
        match self {
            Self::Px => ffi::ADW_LENGTH_UNIT_PX,
            Self::Pt => ffi::ADW_LENGTH_UNIT_PT,
            Self::Sp => ffi::ADW_LENGTH_UNIT_SP,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::ADW_LENGTH_UNIT_PX => Self::Px,
            ffi::ADW_LENGTH_UNIT_PT => Self::Pt,
            ffi::ADW_LENGTH_UNIT_SP => Self::Sp,
            value => Self::__Unknown(value),
        }
    }
}

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

#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
impl glib::HasParamSpec for LengthUnit {
    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 = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
impl glib::value::ValueType for LengthUnit {
    type Type = Self;
}

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

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

#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
impl ToValue for LengthUnit {
    #[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 = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
impl From<LengthUnit> for glib::Value {
    #[inline]
    fn from(v: LengthUnit) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Describes the direction of a swipe navigation gesture.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AdwNavigationDirection")]
pub enum NavigationDirection {
    /// Corresponds to start or top, depending on orientation and text direction
    #[doc(alias = "ADW_NAVIGATION_DIRECTION_BACK")]
    Back,
    /// Corresponds to end or bottom, depending on orientation and text direction
    #[doc(alias = "ADW_NAVIGATION_DIRECTION_FORWARD")]
    Forward,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::AdwNavigationDirection {
        match self {
            Self::Back => ffi::ADW_NAVIGATION_DIRECTION_BACK,
            Self::Forward => ffi::ADW_NAVIGATION_DIRECTION_FORWARD,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::ADW_NAVIGATION_DIRECTION_BACK => Self::Back,
            ffi::ADW_NAVIGATION_DIRECTION_FORWARD => Self::Forward,
            value => Self::__Unknown(value),
        }
    }
}

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

impl glib::HasParamSpec for NavigationDirection {
    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 NavigationDirection {
    type Type = Self;
}

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

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

impl ToValue for NavigationDirection {
    #[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<NavigationDirection> for glib::Value {
    #[inline]
    fn from(v: NavigationDirection) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Describes child packing behavior in a [`WrapLayout`][crate::WrapLayout] or [`WrapBox`][crate::WrapBox].
///
/// See [`pack-direction`][struct@crate::WrapLayout#pack-direction] and
/// [`pack-direction`][struct@crate::WrapBox#pack-direction].
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AdwPackDirection")]
pub enum PackDirection {
    /// Pack children from left to right for LTR languages,
    ///     or top to bottom vertically.
    #[doc(alias = "ADW_PACK_START_TO_END")]
    StartToEnd,
    /// Pack children from right to left for LTR languages,
    ///     or bottom to top vertically.
    #[doc(alias = "ADW_PACK_END_TO_START")]
    EndToStart,
    #[doc(hidden)]
    __Unknown(i32),
}

#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
#[doc(hidden)]
impl IntoGlib for PackDirection {
    type GlibType = ffi::AdwPackDirection;

    #[inline]
    fn into_glib(self) -> ffi::AdwPackDirection {
        match self {
            Self::StartToEnd => ffi::ADW_PACK_START_TO_END,
            Self::EndToStart => ffi::ADW_PACK_END_TO_START,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::ADW_PACK_START_TO_END => Self::StartToEnd,
            ffi::ADW_PACK_END_TO_START => Self::EndToStart,
            value => Self::__Unknown(value),
        }
    }
}

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

#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
impl glib::HasParamSpec for PackDirection {
    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 = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
impl glib::value::ValueType for PackDirection {
    type Type = Self;
}

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

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

#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
impl ToValue for PackDirection {
    #[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 = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
impl From<PackDirection> for glib::Value {
    #[inline]
    fn from(v: PackDirection) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Describes the possible styles of [`AlertDialog`][crate::AlertDialog] response buttons.
///
/// See [`AlertDialogExt::set_response_appearance()`][crate::prelude::AlertDialogExt::set_response_appearance()].
#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AdwResponseAppearance")]
pub enum ResponseAppearance {
    /// the default appearance.
    #[doc(alias = "ADW_RESPONSE_DEFAULT")]
    Default,
    /// used to denote important responses such as the
    ///     affirmative action.
    #[doc(alias = "ADW_RESPONSE_SUGGESTED")]
    Suggested,
    /// used to draw attention to the potentially damaging
    ///     consequences of using the response. This appearance acts as a warning to
    ///     the user.
    #[doc(alias = "ADW_RESPONSE_DESTRUCTIVE")]
    Destructive,
    #[doc(hidden)]
    __Unknown(i32),
}

#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
#[doc(hidden)]
impl IntoGlib for ResponseAppearance {
    type GlibType = ffi::AdwResponseAppearance;

    #[inline]
    fn into_glib(self) -> ffi::AdwResponseAppearance {
        match self {
            Self::Default => ffi::ADW_RESPONSE_DEFAULT,
            Self::Suggested => ffi::ADW_RESPONSE_SUGGESTED,
            Self::Destructive => ffi::ADW_RESPONSE_DESTRUCTIVE,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::ADW_RESPONSE_DEFAULT => Self::Default,
            ffi::ADW_RESPONSE_SUGGESTED => Self::Suggested,
            ffi::ADW_RESPONSE_DESTRUCTIVE => Self::Destructive,
            value => Self::__Unknown(value),
        }
    }
}

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

#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
impl glib::HasParamSpec for ResponseAppearance {
    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 = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
impl glib::value::ValueType for ResponseAppearance {
    type Type = Self;
}

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

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

#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
impl ToValue for ResponseAppearance {
    #[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 = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
impl From<ResponseAppearance> for glib::Value {
    #[inline]
    fn from(v: ResponseAppearance) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Describes the possible transitions in a [`Squeezer`][crate::Squeezer] widget.
///
/// # Deprecated since 1.4
///
/// See [the migration guide](migrating-to-breakpoints.html#replace-adwsqueezer)
#[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AdwSqueezerTransitionType")]
pub enum SqueezerTransitionType {
    /// No transition
    #[doc(alias = "ADW_SQUEEZER_TRANSITION_TYPE_NONE")]
    None,
    /// A cross-fade
    #[doc(alias = "ADW_SQUEEZER_TRANSITION_TYPE_CROSSFADE")]
    Crossfade,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::AdwSqueezerTransitionType {
        match self {
            Self::None => ffi::ADW_SQUEEZER_TRANSITION_TYPE_NONE,
            Self::Crossfade => ffi::ADW_SQUEEZER_TRANSITION_TYPE_CROSSFADE,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::ADW_SQUEEZER_TRANSITION_TYPE_NONE => Self::None,
            ffi::ADW_SQUEEZER_TRANSITION_TYPE_CROSSFADE => Self::Crossfade,
            value => Self::__Unknown(value),
        }
    }
}

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

#[allow(deprecated)]
impl glib::HasParamSpec for SqueezerTransitionType {
    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 SqueezerTransitionType {
    type Type = Self;
}

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

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

#[allow(deprecated)]
impl ToValue for SqueezerTransitionType {
    #[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<SqueezerTransitionType> for glib::Value {
    #[inline]
    fn from(v: SqueezerTransitionType) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// [`Toast`][crate::Toast] behavior when another toast is already displayed.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AdwToastPriority")]
pub enum ToastPriority {
    /// the toast will be queued if another toast is
    ///   already displayed.
    #[doc(alias = "ADW_TOAST_PRIORITY_NORMAL")]
    Normal,
    /// the toast will be displayed immediately, pushing
    ///   the previous toast into the queue instead.
    #[doc(alias = "ADW_TOAST_PRIORITY_HIGH")]
    High,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::AdwToastPriority {
        match self {
            Self::Normal => ffi::ADW_TOAST_PRIORITY_NORMAL,
            Self::High => ffi::ADW_TOAST_PRIORITY_HIGH,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::ADW_TOAST_PRIORITY_NORMAL => Self::Normal,
            ffi::ADW_TOAST_PRIORITY_HIGH => Self::High,
            value => Self::__Unknown(value),
        }
    }
}

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

impl glib::HasParamSpec for ToastPriority {
    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 ToastPriority {
    type Type = Self;
}

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

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

impl ToValue for ToastPriority {
    #[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<ToastPriority> for glib::Value {
    #[inline]
    fn from(v: ToastPriority) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Describes the possible top or bottom bar styles in an [`ToolbarView`][crate::ToolbarView]
/// widget.
///
/// `ADW_TOOLBAR_FLAT` is suitable for simple content, such as
/// [`StatusPage`][crate::StatusPage] or [`PreferencesPage`][crate::PreferencesPage], where the background at the
/// top and bottom parts of the page is uniform. Additionally, windows with
/// sidebars should always use this style.
///
/// <picture style="min-width: 33%; display: inline-block;">
///   <source srcset="toolbar-view-flat-1-dark.png" media="(prefers-color-scheme: dark)">
///   <img src="toolbar-view-flat-1.png" alt="toolbar-view-flat-1">
/// </picture>
/// <picture style="min-width: 33%; display: inline-block;">
///   <source srcset="toolbar-view-flat-2-dark.png" media="(prefers-color-scheme: dark)">
///   <img src="toolbar-view-flat-2.png" alt="toolbar-view-flat-2">
/// </picture>
///
/// `ADW_TOOLBAR_RAISED` style is suitable for content such as
/// [utility panes](https://developer.gnome.org/hig/patterns/containers/utility-panes.html),
/// where some elements are directly adjacent to the top/bottom bars, or
/// [`TabView`][crate::TabView], where each page can have a different background.
///
/// `ADW_TOOLBAR_RAISED_BORDER` style is similar to `ADW_TOOLBAR_RAISED`, but
/// with the shadow replaced with a more subtle border. It's intended to be used
/// in applications like image viewers, where a shadow over the content might be
/// undesired.
///
/// <picture style="min-width: 33%; display: inline-block;">
///   <source srcset="toolbar-view-raised-dark.png" media="(prefers-color-scheme: dark)">
///   <img src="toolbar-view-raised.png" alt="toolbar-view-raised">
/// </picture>
/// <picture style="min-width: 33%; display: inline-block;">
///   <source srcset="toolbar-view-raised-border-dark.png" media="(prefers-color-scheme: dark)">
///   <img src="toolbar-view-raised-border.png" alt="toolbar-view-raised-border">
/// </picture>
///
/// See [`top-bar-style`][struct@crate::ToolbarView#top-bar-style] and
/// [`bottom-bar-style`][struct@crate::ToolbarView#bottom-bar-style].
///
/// New values may be added to this enumeration over time.
#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AdwToolbarStyle")]
pub enum ToolbarStyle {
    /// No background, shadow only for scrolled content
    #[doc(alias = "ADW_TOOLBAR_FLAT")]
    Flat,
    /// Opaque background with a persistent shadow
    #[doc(alias = "ADW_TOOLBAR_RAISED")]
    Raised,
    /// Opaque background with a persistent border
    #[doc(alias = "ADW_TOOLBAR_RAISED_BORDER")]
    RaisedBorder,
    #[doc(hidden)]
    __Unknown(i32),
}

#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
#[doc(hidden)]
impl IntoGlib for ToolbarStyle {
    type GlibType = ffi::AdwToolbarStyle;

    #[inline]
    fn into_glib(self) -> ffi::AdwToolbarStyle {
        match self {
            Self::Flat => ffi::ADW_TOOLBAR_FLAT,
            Self::Raised => ffi::ADW_TOOLBAR_RAISED,
            Self::RaisedBorder => ffi::ADW_TOOLBAR_RAISED_BORDER,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::ADW_TOOLBAR_FLAT => Self::Flat,
            ffi::ADW_TOOLBAR_RAISED => Self::Raised,
            ffi::ADW_TOOLBAR_RAISED_BORDER => Self::RaisedBorder,
            value => Self::__Unknown(value),
        }
    }
}

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

#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
impl glib::HasParamSpec for ToolbarStyle {
    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 = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
impl glib::value::ValueType for ToolbarStyle {
    type Type = Self;
}

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

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

#[cfg(feature = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
impl ToValue for ToolbarStyle {
    #[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 = "v1_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_4")))]
impl From<ToolbarStyle> for glib::Value {
    #[inline]
    fn from(v: ToolbarStyle) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Describes the adaptive modes of [`ViewSwitcher`][crate::ViewSwitcher].
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AdwViewSwitcherPolicy")]
pub enum ViewSwitcherPolicy {
    /// Force the narrow mode
    #[doc(alias = "ADW_VIEW_SWITCHER_POLICY_NARROW")]
    Narrow,
    /// Force the wide mode
    #[doc(alias = "ADW_VIEW_SWITCHER_POLICY_WIDE")]
    Wide,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::AdwViewSwitcherPolicy {
        match self {
            Self::Narrow => ffi::ADW_VIEW_SWITCHER_POLICY_NARROW,
            Self::Wide => ffi::ADW_VIEW_SWITCHER_POLICY_WIDE,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::ADW_VIEW_SWITCHER_POLICY_NARROW => Self::Narrow,
            ffi::ADW_VIEW_SWITCHER_POLICY_WIDE => Self::Wide,
            value => Self::__Unknown(value),
        }
    }
}

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

impl glib::HasParamSpec for ViewSwitcherPolicy {
    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 ViewSwitcherPolicy {
    type Type = Self;
}

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

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

impl ToValue for ViewSwitcherPolicy {
    #[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<ViewSwitcherPolicy> for glib::Value {
    #[inline]
    fn from(v: ViewSwitcherPolicy) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}

/// Describes line wrapping behavior in a [`WrapLayout`][crate::WrapLayout] or [`WrapBox`][crate::WrapBox].
///
/// See [`wrap-policy`][struct@crate::WrapLayout#wrap-policy] and [`wrap-policy`][struct@crate::WrapBox#wrap-policy].
#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "AdwWrapPolicy")]
pub enum WrapPolicy {
    /// Fit as many children into each line as possible, shrinking
    ///     them down to their minimum size before wrapping to the next line.
    #[doc(alias = "ADW_WRAP_MINIMUM")]
    Minimum,
    /// Wrap to the next line as soon as the previous line cannot
    ///     fit any more children without shrinking them past their natural size.
    #[doc(alias = "ADW_WRAP_NATURAL")]
    Natural,
    #[doc(hidden)]
    __Unknown(i32),
}

#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
#[doc(hidden)]
impl IntoGlib for WrapPolicy {
    type GlibType = ffi::AdwWrapPolicy;

    #[inline]
    fn into_glib(self) -> ffi::AdwWrapPolicy {
        match self {
            Self::Minimum => ffi::ADW_WRAP_MINIMUM,
            Self::Natural => ffi::ADW_WRAP_NATURAL,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::ADW_WRAP_MINIMUM => Self::Minimum,
            ffi::ADW_WRAP_NATURAL => Self::Natural,
            value => Self::__Unknown(value),
        }
    }
}

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

#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
impl glib::HasParamSpec for WrapPolicy {
    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 = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
impl glib::value::ValueType for WrapPolicy {
    type Type = Self;
}

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

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

#[cfg(feature = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
impl ToValue for WrapPolicy {
    #[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 = "v1_7")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_7")))]
impl From<WrapPolicy> for glib::Value {
    #[inline]
    fn from(v: WrapPolicy) -> Self {
        skip_assert_initialized!();
        ToValue::to_value(&v)
    }
}