// 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 possible transitions in a [`Album`][crate::Album] widget.
///
/// New values may be added to this enumeration over time.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "BisAlbumTransitionType")]
pub enum AlbumTransitionType {
    /// 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 = "BIS_ALBUM_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 = "BIS_ALBUM_TRANSITION_TYPE_UNDER")]
    Under,
    /// Slide from left, right, up or down according to the orientation, text direction and the children order
    #[doc(alias = "BIS_ALBUM_TRANSITION_TYPE_SLIDE")]
    Slide,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::BisAlbumTransitionType {
        match self {
            Self::Over => ffi::BIS_ALBUM_TRANSITION_TYPE_OVER,
            Self::Under => ffi::BIS_ALBUM_TRANSITION_TYPE_UNDER,
            Self::Slide => ffi::BIS_ALBUM_TRANSITION_TYPE_SLIDE,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::BIS_ALBUM_TRANSITION_TYPE_OVER => Self::Over,
            ffi::BIS_ALBUM_TRANSITION_TYPE_UNDER => Self::Under,
            ffi::BIS_ALBUM_TRANSITION_TYPE_SLIDE => Self::Slide,
            value => Self::__Unknown(value),
        }
    }
}

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

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

unsafe impl<'a> glib::value::FromValue<'a> for AlbumTransitionType {
    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 AlbumTransitionType {
    #[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<AlbumTransitionType> for glib::Value {
    #[inline]
    fn from(v: AlbumTransitionType) -> 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 = "BisAnimationState")]
pub enum AnimationState {
    /// The animation hasn't started yet.
    #[doc(alias = "BIS_ANIMATION_IDLE")]
    Idle,
    /// The animation has been paused.
    #[doc(alias = "BIS_ANIMATION_PAUSED")]
    Paused,
    /// The animation is currently playing.
    #[doc(alias = "BIS_ANIMATION_PLAYING")]
    Playing,
    /// The animation has finished.
    #[doc(alias = "BIS_ANIMATION_FINISHED")]
    Finished,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::BisAnimationState {
        match self {
            Self::Idle => ffi::BIS_ANIMATION_IDLE,
            Self::Paused => ffi::BIS_ANIMATION_PAUSED,
            Self::Playing => ffi::BIS_ANIMATION_PLAYING,
            Self::Finished => ffi::BIS_ANIMATION_FINISHED,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::BIS_ANIMATION_IDLE => Self::Idle,
            ffi::BIS_ANIMATION_PAUSED => Self::Paused,
            ffi::BIS_ANIMATION_PLAYING => Self::Playing,
            ffi::BIS_ANIMATION_FINISHED => Self::Finished,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for AnimationState {
    #[inline]
    #[doc(alias = "bis_animation_state_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::bis_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 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 = "BisEasing")]
pub enum Easing {
    /// Linear tweening.
    #[doc(alias = "BIS_LINEAR")]
    Linear,
    /// Quadratic tweening.
    #[doc(alias = "BIS_EASE_IN_QUAD")]
    EaseInQuad,
    /// Quadratic tweening, inverse of `BIS_EASE_IN_QUAD`.
    #[doc(alias = "BIS_EASE_OUT_QUAD")]
    EaseOutQuad,
    /// Quadratic tweening, combining `BIS_EASE_IN_QUAD` and
    ///   `BIS_EASE_OUT_QUAD`.
    #[doc(alias = "BIS_EASE_IN_OUT_QUAD")]
    EaseInOutQuad,
    /// Cubic tweening.
    #[doc(alias = "BIS_EASE_IN_CUBIC")]
    EaseInCubic,
    /// Cubic tweening, inverse of `BIS_EASE_IN_CUBIC`.
    #[doc(alias = "BIS_EASE_OUT_CUBIC")]
    EaseOutCubic,
    /// Cubic tweening, combining `BIS_EASE_IN_CUBIC` and
    ///   `BIS_EASE_OUT_CUBIC`.
    #[doc(alias = "BIS_EASE_IN_OUT_CUBIC")]
    EaseInOutCubic,
    /// Quartic tweening.
    #[doc(alias = "BIS_EASE_IN_QUART")]
    EaseInQuart,
    /// Quartic tweening, inverse of `BIS_EASE_IN_QUART`.
    #[doc(alias = "BIS_EASE_OUT_QUART")]
    EaseOutQuart,
    /// Quartic tweening, combining `BIS_EASE_IN_QUART` and
    ///   `BIS_EASE_OUT_QUART`.
    #[doc(alias = "BIS_EASE_IN_OUT_QUART")]
    EaseInOutQuart,
    /// Quintic tweening.
    #[doc(alias = "BIS_EASE_IN_QUINT")]
    EaseInQuint,
    /// Quintic tweening, inverse of `BIS_EASE_IN_QUINT`.
    #[doc(alias = "BIS_EASE_OUT_QUINT")]
    EaseOutQuint,
    /// Quintic tweening, combining `BIS_EASE_IN_QUINT` and
    ///   `BIS_EASE_OUT_QUINT`.
    #[doc(alias = "BIS_EASE_IN_OUT_QUINT")]
    EaseInOutQuint,
    /// Sine wave tweening.
    #[doc(alias = "BIS_EASE_IN_SINE")]
    EaseInSine,
    /// Sine wave tweening, inverse of `BIS_EASE_IN_SINE`.
    #[doc(alias = "BIS_EASE_OUT_SINE")]
    EaseOutSine,
    /// Sine wave tweening, combining `BIS_EASE_IN_SINE` and
    ///   `BIS_EASE_OUT_SINE`.
    #[doc(alias = "BIS_EASE_IN_OUT_SINE")]
    EaseInOutSine,
    /// Exponential tweening.
    #[doc(alias = "BIS_EASE_IN_EXPO")]
    EaseInExpo,
    /// Exponential tweening, inverse of `BIS_EASE_IN_EXPO`.
    #[doc(alias = "BIS_EASE_OUT_EXPO")]
    EaseOutExpo,
    /// Exponential tweening, combining `BIS_EASE_IN_EXPO` and
    ///   `BIS_EASE_OUT_EXPO`.
    #[doc(alias = "BIS_EASE_IN_OUT_EXPO")]
    EaseInOutExpo,
    /// Circular tweening.
    #[doc(alias = "BIS_EASE_IN_CIRC")]
    EaseInCirc,
    /// Circular tweening, inverse of `BIS_EASE_IN_CIRC`.
    #[doc(alias = "BIS_EASE_OUT_CIRC")]
    EaseOutCirc,
    /// Circular tweening, combining `BIS_EASE_IN_CIRC` and
    ///   `BIS_EASE_OUT_CIRC`.
    #[doc(alias = "BIS_EASE_IN_OUT_CIRC")]
    EaseInOutCirc,
    /// Elastic tweening, with offshoot on start.
    #[doc(alias = "BIS_EASE_IN_ELASTIC")]
    EaseInElastic,
    /// Elastic tweening, with offshoot on end, inverse of
    ///   `BIS_EASE_IN_ELASTIC`.
    #[doc(alias = "BIS_EASE_OUT_ELASTIC")]
    EaseOutElastic,
    /// Elastic tweening, with offshoot on both ends,
    ///   combining `BIS_EASE_IN_ELASTIC` and `BIS_EASE_OUT_ELASTIC`.
    #[doc(alias = "BIS_EASE_IN_OUT_ELASTIC")]
    EaseInOutElastic,
    /// Overshooting cubic tweening, with backtracking on start.
    #[doc(alias = "BIS_EASE_IN_BACK")]
    EaseInBack,
    /// Overshooting cubic tweening, with backtracking on end,
    ///   inverse of `BIS_EASE_IN_BACK`.
    #[doc(alias = "BIS_EASE_OUT_BACK")]
    EaseOutBack,
    /// Overshooting cubic tweening, with backtracking on both
    ///   ends, combining `BIS_EASE_IN_BACK` and `BIS_EASE_OUT_BACK`.
    #[doc(alias = "BIS_EASE_IN_OUT_BACK")]
    EaseInOutBack,
    /// Exponentially decaying parabolic (bounce) tweening,
    ///   on start.
    #[doc(alias = "BIS_EASE_IN_BOUNCE")]
    EaseInBounce,
    /// Exponentially decaying parabolic (bounce) tweening,
    ///   with bounce on end, inverse of `BIS_EASE_IN_BOUNCE`.
    #[doc(alias = "BIS_EASE_OUT_BOUNCE")]
    EaseOutBounce,
    /// Exponentially decaying parabolic (bounce) tweening,
    ///   with bounce on both ends, combining `BIS_EASE_IN_BOUNCE` and
    ///   `BIS_EASE_OUT_BOUNCE`.
    #[doc(alias = "BIS_EASE_IN_OUT_BOUNCE")]
    EaseInOutBounce,
    #[doc(hidden)]
    __Unknown(i32),
}

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

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

    fn into_glib(self) -> ffi::BisEasing {
        match self {
            Self::Linear => ffi::BIS_LINEAR,
            Self::EaseInQuad => ffi::BIS_EASE_IN_QUAD,
            Self::EaseOutQuad => ffi::BIS_EASE_OUT_QUAD,
            Self::EaseInOutQuad => ffi::BIS_EASE_IN_OUT_QUAD,
            Self::EaseInCubic => ffi::BIS_EASE_IN_CUBIC,
            Self::EaseOutCubic => ffi::BIS_EASE_OUT_CUBIC,
            Self::EaseInOutCubic => ffi::BIS_EASE_IN_OUT_CUBIC,
            Self::EaseInQuart => ffi::BIS_EASE_IN_QUART,
            Self::EaseOutQuart => ffi::BIS_EASE_OUT_QUART,
            Self::EaseInOutQuart => ffi::BIS_EASE_IN_OUT_QUART,
            Self::EaseInQuint => ffi::BIS_EASE_IN_QUINT,
            Self::EaseOutQuint => ffi::BIS_EASE_OUT_QUINT,
            Self::EaseInOutQuint => ffi::BIS_EASE_IN_OUT_QUINT,
            Self::EaseInSine => ffi::BIS_EASE_IN_SINE,
            Self::EaseOutSine => ffi::BIS_EASE_OUT_SINE,
            Self::EaseInOutSine => ffi::BIS_EASE_IN_OUT_SINE,
            Self::EaseInExpo => ffi::BIS_EASE_IN_EXPO,
            Self::EaseOutExpo => ffi::BIS_EASE_OUT_EXPO,
            Self::EaseInOutExpo => ffi::BIS_EASE_IN_OUT_EXPO,
            Self::EaseInCirc => ffi::BIS_EASE_IN_CIRC,
            Self::EaseOutCirc => ffi::BIS_EASE_OUT_CIRC,
            Self::EaseInOutCirc => ffi::BIS_EASE_IN_OUT_CIRC,
            Self::EaseInElastic => ffi::BIS_EASE_IN_ELASTIC,
            Self::EaseOutElastic => ffi::BIS_EASE_OUT_ELASTIC,
            Self::EaseInOutElastic => ffi::BIS_EASE_IN_OUT_ELASTIC,
            Self::EaseInBack => ffi::BIS_EASE_IN_BACK,
            Self::EaseOutBack => ffi::BIS_EASE_OUT_BACK,
            Self::EaseInOutBack => ffi::BIS_EASE_IN_OUT_BACK,
            Self::EaseInBounce => ffi::BIS_EASE_IN_BOUNCE,
            Self::EaseOutBounce => ffi::BIS_EASE_OUT_BOUNCE,
            Self::EaseInOutBounce => ffi::BIS_EASE_IN_OUT_BOUNCE,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::BIS_LINEAR => Self::Linear,
            ffi::BIS_EASE_IN_QUAD => Self::EaseInQuad,
            ffi::BIS_EASE_OUT_QUAD => Self::EaseOutQuad,
            ffi::BIS_EASE_IN_OUT_QUAD => Self::EaseInOutQuad,
            ffi::BIS_EASE_IN_CUBIC => Self::EaseInCubic,
            ffi::BIS_EASE_OUT_CUBIC => Self::EaseOutCubic,
            ffi::BIS_EASE_IN_OUT_CUBIC => Self::EaseInOutCubic,
            ffi::BIS_EASE_IN_QUART => Self::EaseInQuart,
            ffi::BIS_EASE_OUT_QUART => Self::EaseOutQuart,
            ffi::BIS_EASE_IN_OUT_QUART => Self::EaseInOutQuart,
            ffi::BIS_EASE_IN_QUINT => Self::EaseInQuint,
            ffi::BIS_EASE_OUT_QUINT => Self::EaseOutQuint,
            ffi::BIS_EASE_IN_OUT_QUINT => Self::EaseInOutQuint,
            ffi::BIS_EASE_IN_SINE => Self::EaseInSine,
            ffi::BIS_EASE_OUT_SINE => Self::EaseOutSine,
            ffi::BIS_EASE_IN_OUT_SINE => Self::EaseInOutSine,
            ffi::BIS_EASE_IN_EXPO => Self::EaseInExpo,
            ffi::BIS_EASE_OUT_EXPO => Self::EaseOutExpo,
            ffi::BIS_EASE_IN_OUT_EXPO => Self::EaseInOutExpo,
            ffi::BIS_EASE_IN_CIRC => Self::EaseInCirc,
            ffi::BIS_EASE_OUT_CIRC => Self::EaseOutCirc,
            ffi::BIS_EASE_IN_OUT_CIRC => Self::EaseInOutCirc,
            ffi::BIS_EASE_IN_ELASTIC => Self::EaseInElastic,
            ffi::BIS_EASE_OUT_ELASTIC => Self::EaseOutElastic,
            ffi::BIS_EASE_IN_OUT_ELASTIC => Self::EaseInOutElastic,
            ffi::BIS_EASE_IN_BACK => Self::EaseInBack,
            ffi::BIS_EASE_OUT_BACK => Self::EaseOutBack,
            ffi::BIS_EASE_IN_OUT_BACK => Self::EaseInOutBack,
            ffi::BIS_EASE_IN_BOUNCE => Self::EaseInBounce,
            ffi::BIS_EASE_OUT_BOUNCE => Self::EaseOutBounce,
            ffi::BIS_EASE_IN_OUT_BOUNCE => Self::EaseInOutBounce,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for Easing {
    #[inline]
    #[doc(alias = "bis_easing_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::bis_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)
    }
}

/// Determines when [`Lapel`][crate::Lapel] and [`Album`][crate::Album] will fold.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "BisFoldThresholdPolicy")]
pub enum FoldThresholdPolicy {
    /// Folding is based on the minimum size
    #[doc(alias = "BIS_FOLD_THRESHOLD_POLICY_MINIMUM")]
    Minimum,
    /// Folding is based on the natural size
    #[doc(alias = "BIS_FOLD_THRESHOLD_POLICY_NATURAL")]
    Natural,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::BisFoldThresholdPolicy {
        match self {
            Self::Minimum => ffi::BIS_FOLD_THRESHOLD_POLICY_MINIMUM,
            Self::Natural => ffi::BIS_FOLD_THRESHOLD_POLICY_NATURAL,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::BIS_FOLD_THRESHOLD_POLICY_MINIMUM => Self::Minimum,
            ffi::BIS_FOLD_THRESHOLD_POLICY_NATURAL => Self::Natural,
            value => Self::__Unknown(value),
        }
    }
}

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

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
    }
}

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

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))
    }
}

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()
    }
}

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

/// Describes the possible transitions in a [`Hugger`][crate::Hugger] widget.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "BisHuggerTransitionType")]
pub enum HuggerTransitionType {
    /// No transition
    #[doc(alias = "BIS_HUGGER_TRANSITION_TYPE_NONE")]
    None,
    /// A cross-fade
    #[doc(alias = "BIS_HUGGER_TRANSITION_TYPE_CROSSFADE")]
    Crossfade,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::BisHuggerTransitionType {
        match self {
            Self::None => ffi::BIS_HUGGER_TRANSITION_TYPE_NONE,
            Self::Crossfade => ffi::BIS_HUGGER_TRANSITION_TYPE_CROSSFADE,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::BIS_HUGGER_TRANSITION_TYPE_NONE => Self::None,
            ffi::BIS_HUGGER_TRANSITION_TYPE_CROSSFADE => Self::Crossfade,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

/// Describes the possible folding behavior of a [`Lapel`][crate::Lapel] widget.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "BisLapelFoldPolicy")]
pub enum LapelFoldPolicy {
    /// Disable folding, the lapel cannot reach narrow
    ///   sizes.
    #[doc(alias = "BIS_LAPEL_FOLD_POLICY_NEVER")]
    Never,
    /// Keep the lapel always folded.
    #[doc(alias = "BIS_LAPEL_FOLD_POLICY_ALWAYS")]
    Always,
    /// Fold and unfold the lapel based on available
    ///   space.
    #[doc(alias = "BIS_LAPEL_FOLD_POLICY_AUTO")]
    Auto,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::BisLapelFoldPolicy {
        match self {
            Self::Never => ffi::BIS_LAPEL_FOLD_POLICY_NEVER,
            Self::Always => ffi::BIS_LAPEL_FOLD_POLICY_ALWAYS,
            Self::Auto => ffi::BIS_LAPEL_FOLD_POLICY_AUTO,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::BIS_LAPEL_FOLD_POLICY_NEVER => Self::Never,
            ffi::BIS_LAPEL_FOLD_POLICY_ALWAYS => Self::Always,
            ffi::BIS_LAPEL_FOLD_POLICY_AUTO => Self::Auto,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

/// Describes transitions types of a [`Lapel`][crate::Lapel] widget.
///
/// It determines the type of animation when transitioning between children in a
/// [`Lapel`][crate::Lapel] widget, as well as which areas can be swiped via
/// [`swipe-to-open`][struct@crate::Lapel#swipe-to-open] and [`swipe-to-close`][struct@crate::Lapel#swipe-to-close].
///
/// New values may be added to this enum over time.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "BisLapelTransitionType")]
pub enum LapelTransitionType {
    /// The lapel slides over the content, which is
    ///   dimmed. When folded, only the lapel can be swiped.
    #[doc(alias = "BIS_LAPEL_TRANSITION_TYPE_OVER")]
    Over,
    /// The content slides over the lapel. Only the
    ///   content can be swiped.
    #[doc(alias = "BIS_LAPEL_TRANSITION_TYPE_UNDER")]
    Under,
    /// The lapel slides offscreen when hidden,
    ///   neither the lapel nor content overlap each other. Both widgets can be
    ///   swiped.
    #[doc(alias = "BIS_LAPEL_TRANSITION_TYPE_SLIDE")]
    Slide,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::BisLapelTransitionType {
        match self {
            Self::Over => ffi::BIS_LAPEL_TRANSITION_TYPE_OVER,
            Self::Under => ffi::BIS_LAPEL_TRANSITION_TYPE_UNDER,
            Self::Slide => ffi::BIS_LAPEL_TRANSITION_TYPE_SLIDE,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::BIS_LAPEL_TRANSITION_TYPE_OVER => Self::Over,
            ffi::BIS_LAPEL_TRANSITION_TYPE_UNDER => Self::Under,
            ffi::BIS_LAPEL_TRANSITION_TYPE_SLIDE => Self::Slide,
            value => Self::__Unknown(value),
        }
    }
}

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

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

unsafe impl<'a> glib::value::FromValue<'a> for LapelTransitionType {
    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 LapelTransitionType {
    #[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<LapelTransitionType> for glib::Value {
    #[inline]
    fn from(v: LapelTransitionType) -> 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 = "BisNavigationDirection")]
pub enum NavigationDirection {
    /// Corresponds to start or top, depending on orientation and text direction
    #[doc(alias = "BIS_NAVIGATION_DIRECTION_BACK")]
    Back,
    /// Corresponds to end or bottom, depending on orientation and text direction
    #[doc(alias = "BIS_NAVIGATION_DIRECTION_FORWARD")]
    Forward,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::BisNavigationDirection {
        match self {
            Self::Back => ffi::BIS_NAVIGATION_DIRECTION_BACK,
            Self::Forward => ffi::BIS_NAVIGATION_DIRECTION_FORWARD,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::BIS_NAVIGATION_DIRECTION_BACK => Self::Back,
            ffi::BIS_NAVIGATION_DIRECTION_FORWARD => Self::Forward,
            value => Self::__Unknown(value),
        }
    }
}

impl StaticType for NavigationDirection {
    #[inline]
    #[doc(alias = "bis_navigation_direction_get_type")]
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::bis_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)
    }
}