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

use crate::ffi;
#[cfg(feature = "v1_16")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
use glib::GStr;
use glib::{prelude::*, translate::*};

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GESAssetLoadingReturn")]
pub enum AssetLoadingReturn {
    /// Indicates that an error occurred
    #[doc(alias = "GES_ASSET_LOADING_ERROR")]
    Error,
    /// Indicates that the loading is being performed
    /// asynchronously
    #[doc(alias = "GES_ASSET_LOADING_ASYNC")]
    Async,
    /// Indicates that the loading is complete, without
    /// error
    #[doc(alias = "GES_ASSET_LOADING_OK")]
    Ok,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::GESAssetLoadingReturn {
        match self {
            Self::Error => ffi::GES_ASSET_LOADING_ERROR,
            Self::Async => ffi::GES_ASSET_LOADING_ASYNC,
            Self::Ok => ffi::GES_ASSET_LOADING_OK,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::GES_ASSET_LOADING_ERROR => Self::Error,
            ffi::GES_ASSET_LOADING_ASYNC => Self::Async,
            ffi::GES_ASSET_LOADING_OK => Self::Ok,
            value => Self::__Unknown(value),
        }
    }
}

/// To be used by subclasses only. This indicate how to handle a change in
/// a child.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GESChildrenControlMode")]
pub enum ChildrenControlMode {
    #[doc(alias = "GES_CHILDREN_UPDATE")]
    Update,
    #[doc(alias = "GES_CHILDREN_IGNORE_NOTIFIES")]
    IgnoreNotifies,
    #[doc(alias = "GES_CHILDREN_UPDATE_OFFSETS")]
    UpdateOffsets,
    #[doc(alias = "GES_CHILDREN_UPDATE_ALL_VALUES")]
    UpdateAllValues,
    #[doc(alias = "GES_CHILDREN_LAST")]
    Last,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::GESChildrenControlMode {
        match self {
            Self::Update => ffi::GES_CHILDREN_UPDATE,
            Self::IgnoreNotifies => ffi::GES_CHILDREN_IGNORE_NOTIFIES,
            Self::UpdateOffsets => ffi::GES_CHILDREN_UPDATE_OFFSETS,
            Self::UpdateAllValues => ffi::GES_CHILDREN_UPDATE_ALL_VALUES,
            Self::Last => ffi::GES_CHILDREN_LAST,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::GES_CHILDREN_UPDATE => Self::Update,
            ffi::GES_CHILDREN_IGNORE_NOTIFIES => Self::IgnoreNotifies,
            ffi::GES_CHILDREN_UPDATE_OFFSETS => Self::UpdateOffsets,
            ffi::GES_CHILDREN_UPDATE_ALL_VALUES => Self::UpdateAllValues,
            ffi::GES_CHILDREN_LAST => Self::Last,
            value => Self::__Unknown(value),
        }
    }
}

/// The edges of an object contain in a [`Timeline`][crate::Timeline] or [`Track`][crate::Track]
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GESEdge")]
pub enum Edge {
    /// Represents the start of an object.
    #[doc(alias = "GES_EDGE_START")]
    Start,
    /// Represents the end of an object.
    #[doc(alias = "GES_EDGE_END")]
    End,
    /// Represent the fact we are not working with any edge of an
    ///  object.
    #[doc(alias = "GES_EDGE_NONE")]
    None,
    #[doc(hidden)]
    __Unknown(i32),
}

impl Edge {
    #[cfg(feature = "v1_16")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
    pub fn name<'a>(self) -> &'a GStr {
        unsafe {
            GStr::from_ptr(
                ffi::ges_edge_name(self.into_glib())
                    .as_ref()
                    .expect("ges_edge_name returned NULL"),
            )
        }
    }
}

#[cfg(feature = "v1_16")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
impl std::fmt::Display for Edge {
    #[inline]
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.write_str(&self.name())
    }
}

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

    #[inline]
    fn into_glib(self) -> ffi::GESEdge {
        match self {
            Self::Start => ffi::GES_EDGE_START,
            Self::End => ffi::GES_EDGE_END,
            Self::None => ffi::GES_EDGE_NONE,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::GES_EDGE_START => Self::Start,
            ffi::GES_EDGE_END => Self::End,
            ffi::GES_EDGE_NONE => Self::None,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

/// When a single timeline element is edited within its timeline at some
/// position, using [`TimelineElementExt::edit()`][crate::prelude::TimelineElementExt::edit()], depending on the edit
/// mode, its [`start`][struct@crate::TimelineElement#start], [`duration`][struct@crate::TimelineElement#duration] or
/// [`in-point`][struct@crate::TimelineElement#in-point] will be adjusted accordingly. In addition,
/// any clips may change [`layer`][struct@crate::Clip#layer].
///
/// Each edit can be broken down into a combination of three basic edits:
///
/// + MOVE: This moves the start of the element to the edit position.
/// + START-TRIM: This cuts or grows the start of the element, whilst
///  maintaining the time at which its internal content appears in the
///  timeline data output. If the element is made shorter, the data that
///  appeared at the edit position will still appear in the timeline at
///  the same time. If the element is made longer, the data that appeared
///  at the previous start of the element will still appear in the
///  timeline at the same time.
/// + END-TRIM: Similar to START-TRIM, but the end of the element is cut or
///  grown.
///
/// In particular, when editing a [`Clip`][crate::Clip]:
///
/// + MOVE: This will set the [`start`][struct@crate::TimelineElement#start] of the clip to the
///  edit position.
/// + START-TRIM: This will set the [`start`][struct@crate::TimelineElement#start] of the clip
///  to the edit position. To keep the end time the same, the
///  [`duration`][struct@crate::TimelineElement#duration] of the clip will be adjusted in the
///  opposite direction. In addition, the [`in-point`][struct@crate::TimelineElement#in-point] of
///  the clip will be shifted such that the content that appeared at the
///  new or previous start time, whichever is latest, still appears at the
///  same timeline time. For example, if a frame appeared at the start of
///  the clip, and the start of the clip is reduced, the in-point of the
///  clip will also reduce such that the frame will appear later within
///  the clip, but at the same timeline position.
/// + END-TRIM: This will set the [`duration`][struct@crate::TimelineElement#duration] of the clip
///  such that its end time will match the edit position.
///
/// When editing a [`Group`][crate::Group]:
///
/// + MOVE: This will set the [`start`][struct@crate::Group#start] of the clip to the edit
///  position by shifting all of its children by the same amount. So each
///  child will maintain their relative positions.
/// + START-TRIM: If the group is made shorter, this will START-TRIM any
///  clips under the group that start after the edit position to the same
///  edit position. If the group is made longer, this will START-TRIM any
///  clip under the group whose start matches the start of the group to
///  the same edit position.
/// + END-TRIM: If the group is made shorter, this will END-TRIM any clips
///  under the group that end after the edit position to the same edit
///  position. If the group is made longer, this will END-TRIM any clip
///  under the group whose end matches the end of the group to the same
///  edit position.
///
/// When editing a [`TrackElement`][crate::TrackElement], if it has a [`Clip`][crate::Clip] parent, this
/// will be edited instead. Otherwise it is edited in the same way as a
/// [`Clip`][crate::Clip].
///
/// The layer priority of a [`Group`][crate::Group] is the lowest layer priority of any
/// [`Clip`][crate::Clip] underneath it. When a group is edited to a new layer
/// priority, it will shift all clips underneath it by the same amount,
/// such that their relative layers stay the same.
///
/// If the [`Timeline`][crate::Timeline] has a [`snapping-distance`][struct@crate::Timeline#snapping-distance], then snapping
/// may occur for some of the edges of the **main** edited element:
///
/// + MOVE: The start or end edge of *any* [`Source`][crate::Source] under the element may
///  be snapped.
/// + START-TRIM: The start edge of a [`Source`][crate::Source] whose start edge touches
///  the start edge of the element may snap.
/// + END-TRIM: The end edge of a [`Source`][crate::Source] whose end edge touches the end
///  edge of the element may snap.
///
/// These edges may snap with either the start or end edge of *any* other
/// [`Source`][crate::Source] in the timeline that is not also being moved by the element,
/// including those in different layers, if they are within the
/// [`snapping-distance`][struct@crate::Timeline#snapping-distance]. During an edit, only up to one snap can
/// occur. This will shift the edit position such that the snapped edges
/// will touch once the edit has completed.
///
/// Note that snapping can cause an edit to fail where it would have
/// otherwise succeeded because it may push the edit position such that the
/// edit would result in an unsupported timeline configuration. Similarly,
/// snapping can cause an edit to succeed where it would have otherwise
/// failed.
///
/// For example, in [`Ripple`][Self::Ripple] acting on [`Edge::None`][crate::Edge::None], the
/// main element is the MOVED toplevel of the edited element. Any source
/// under the main MOVED toplevel may have its start or end edge snapped.
/// Note, these sources cannot snap with each other. The edit may also
/// push other elements, but any sources under these elements cannot snap,
/// nor can they be snapped with. If a snap does occur, the MOVE of the
/// toplevel *and* all other elements pushed by the ripple will be shifted
/// by the same amount such that the snapped edges will touch.
///
/// You can also find more explanation about the behaviour of those modes at:
/// [trim, ripple and roll](http://pitivi.org/manual/trimming.html)
/// and [clip management](http://pitivi.org/manual/usingclips.html).
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GESEditMode")]
pub enum EditMode {
    /// The element is edited the normal way (default).
    ///  If acting on the element as a whole ([`Edge::None`][crate::Edge::None]), this will MOVE
    ///  the element by MOVING its toplevel. When acting on the start of the
    ///  element ([`Edge::Start`][crate::Edge::Start]), this will only MOVE the element, but not
    ///  its toplevel parent. This can allow you to move a [`Clip`][crate::Clip] or
    ///  [`Group`][crate::Group] to a new start time or layer within its container group,
    ///  without effecting other members of the group. When acting on the end
    ///  of the element ([`Edge::End`][crate::Edge::End]), this will END-TRIM the element,
    ///  leaving its toplevel unchanged.
    #[doc(alias = "GES_EDIT_MODE_NORMAL")]
    Normal,
    /// The element is edited in ripple mode: moving
    ///  itself as well as later elements, keeping their relative times. This
    ///  edits the element the same as [`Normal`][Self::Normal]. In addition, if
    ///  acting on the element as a whole, or the start of the element, any
    ///  toplevel element in the same timeline (including different layers)
    ///  whose start time is later than the *current* start time of the MOVED
    ///  element will also be MOVED by the same shift as the edited element.
    ///  If acting on the end of the element, any toplevel element whose start
    ///  time is later than the *current* end time of the edited element will
    ///  also be MOVED by the same shift as the change in the end of the
    ///  edited element. These additional elements will also be shifted by
    ///  the same shift in layers as the edited element.
    #[doc(alias = "GES_EDIT_MODE_RIPPLE")]
    Ripple,
    /// The element is edited in roll mode: swapping its
    ///  content for its neighbour's, or vis versa, in the timeline output.
    ///  This edits the element the same as [`Trim`][Self::Trim]. In addition,
    ///  any neighbours are also TRIMMED at their opposite edge to the same
    ///  timeline position. When acting on the start of the element, a
    ///  neighbour is any earlier element in the timeline whose end time
    ///  matches the *current* start time of the edited element. When acting on
    ///  the end of the element, a neighbour is any later element in the
    ///  timeline whose start time matches the *current* start time of the
    ///  edited element. In addition, a neighbour have a [`Source`][crate::Source] at its
    ///  end/start edge that shares a track with a [`Source`][crate::Source] at the start/end
    ///  edge of the edited element. Basically, a neighbour is an element that
    ///  can be extended, or cut, to have its content replace, or be replaced
    ///  by, the content of the edited element. Acting on the element as a
    ///  whole ([`Edge::None`][crate::Edge::None]) is not defined. The element can not shift
    ///  layers under this mode.
    #[doc(alias = "GES_EDIT_MODE_ROLL")]
    Roll,
    /// The element is edited in trim mode. When acting
    ///  on the start of the element, this will START-TRIM it. When acting on
    ///  the end of the element, this will END-TRIM it. Acting on the element
    ///  as a whole ([`Edge::None`][crate::Edge::None]) is not defined.
    #[doc(alias = "GES_EDIT_MODE_TRIM")]
    Trim,
    /// The element is edited in slide mode (not yet
    ///  implemented): moving the element replacing or consuming content on
    ///  each end. When acting on the element as a whole, this will MOVE the
    ///  element, and TRIM any neighbours on either side. A neighbour is
    ///  defined in the same way as in [`Roll`][Self::Roll], but they may be on
    ///  either side of the edited elements. Elements at the end with be
    ///  START-TRIMMED to the new end position of the edited element. Elements
    ///  at the start will be END-TRIMMED to the new start position of the
    ///  edited element. Acting on the start or end of the element
    ///  ([`Edge::Start`][crate::Edge::Start] and [`Edge::End`][crate::Edge::End]) is not defined. The element can
    ///  not shift layers under this mode.
    #[doc(alias = "GES_EDIT_MODE_SLIDE")]
    Slide,
    #[doc(hidden)]
    __Unknown(i32),
}

impl EditMode {
    #[cfg(feature = "v1_18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
    pub fn name<'a>(self) -> &'a GStr {
        unsafe {
            GStr::from_ptr(
                ffi::ges_edit_mode_name(self.into_glib())
                    .as_ref()
                    .expect("ges_edit_mode_name returned NULL"),
            )
        }
    }
}

#[cfg(feature = "v1_18")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
impl std::fmt::Display for EditMode {
    #[inline]
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.write_str(&self.name())
    }
}

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

    #[inline]
    fn into_glib(self) -> ffi::GESEditMode {
        match self {
            Self::Normal => ffi::GES_EDIT_MODE_NORMAL,
            Self::Ripple => ffi::GES_EDIT_MODE_RIPPLE,
            Self::Roll => ffi::GES_EDIT_MODE_ROLL,
            Self::Trim => ffi::GES_EDIT_MODE_TRIM,
            Self::Slide => ffi::GES_EDIT_MODE_SLIDE,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::GES_EDIT_MODE_NORMAL => Self::Normal,
            ffi::GES_EDIT_MODE_RIPPLE => Self::Ripple,
            ffi::GES_EDIT_MODE_ROLL => Self::Roll,
            ffi::GES_EDIT_MODE_TRIM => Self::Trim,
            ffi::GES_EDIT_MODE_SLIDE => Self::Slide,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GESError")]
pub enum Error {
    /// The ID passed is malformed
    #[doc(alias = "GES_ERROR_ASSET_WRONG_ID")]
    AssetWrongId,
    /// An error happened while loading the asset
    #[doc(alias = "GES_ERROR_ASSET_LOADING")]
    AssetLoading,
    /// The formatted files was malformed
    #[doc(alias = "GES_ERROR_FORMATTER_MALFORMED_INPUT_FILE")]
    FormatterMalformedInputFile,
    /// The frame number is invalid
    #[doc(alias = "GES_ERROR_INVALID_FRAME_NUMBER")]
    InvalidFrameNumber,
    /// The operation would lead to a negative
    /// `GES_TIMELINE_ELEMENT_LAYER_PRIORITY`. (Since: 1.18)
    #[doc(alias = "GES_ERROR_NEGATIVE_LAYER")]
    NegativeLayer,
    /// The operation would lead to a negative time.
    /// E.g. for the [`start`][struct@crate::TimelineElement#start] [`duration`][struct@crate::TimelineElement#duration] or
    /// [`in-point`][struct@crate::TimelineElement#in-point]. (Since: 1.18)
    #[doc(alias = "GES_ERROR_NEGATIVE_TIME")]
    NegativeTime,
    /// Some [`TimelineElement`][crate::TimelineElement] does
    /// not have a large enough [`max-duration`][struct@crate::TimelineElement#max-duration] to cover the
    /// desired operation. (Since: 1.18)
    #[doc(alias = "GES_ERROR_NOT_ENOUGH_INTERNAL_CONTENT")]
    NotEnoughInternalContent,
    /// The operation would break one of
    /// the overlap conditions for the [`Timeline`][crate::Timeline]. (Since: 1.18)
    #[doc(alias = "GES_ERROR_INVALID_OVERLAP_IN_TRACK")]
    InvalidOverlapInTrack,
    #[doc(alias = "GES_ERROR_INVALID_EFFECT_BIN_DESCRIPTION")]
    InvalidEffectBinDescription,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::GESError {
        match self {
            Self::AssetWrongId => ffi::GES_ERROR_ASSET_WRONG_ID,
            Self::AssetLoading => ffi::GES_ERROR_ASSET_LOADING,
            Self::FormatterMalformedInputFile => ffi::GES_ERROR_FORMATTER_MALFORMED_INPUT_FILE,
            Self::InvalidFrameNumber => ffi::GES_ERROR_INVALID_FRAME_NUMBER,
            Self::NegativeLayer => ffi::GES_ERROR_NEGATIVE_LAYER,
            Self::NegativeTime => ffi::GES_ERROR_NEGATIVE_TIME,
            Self::NotEnoughInternalContent => ffi::GES_ERROR_NOT_ENOUGH_INTERNAL_CONTENT,
            Self::InvalidOverlapInTrack => ffi::GES_ERROR_INVALID_OVERLAP_IN_TRACK,
            Self::InvalidEffectBinDescription => ffi::GES_ERROR_INVALID_EFFECT_BIN_DESCRIPTION,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::GES_ERROR_ASSET_WRONG_ID => Self::AssetWrongId,
            ffi::GES_ERROR_ASSET_LOADING => Self::AssetLoading,
            ffi::GES_ERROR_FORMATTER_MALFORMED_INPUT_FILE => Self::FormatterMalformedInputFile,
            ffi::GES_ERROR_INVALID_FRAME_NUMBER => Self::InvalidFrameNumber,
            ffi::GES_ERROR_NEGATIVE_LAYER => Self::NegativeLayer,
            ffi::GES_ERROR_NEGATIVE_TIME => Self::NegativeTime,
            ffi::GES_ERROR_NOT_ENOUGH_INTERNAL_CONTENT => Self::NotEnoughInternalContent,
            ffi::GES_ERROR_INVALID_OVERLAP_IN_TRACK => Self::InvalidOverlapInTrack,
            ffi::GES_ERROR_INVALID_EFFECT_BIN_DESCRIPTION => Self::InvalidEffectBinDescription,
            value => Self::__Unknown(value),
        }
    }
}

/// Horizontal alignment of the text.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GESTextHAlign")]
pub enum TextHAlign {
    /// align text left
    #[doc(alias = "GES_TEXT_HALIGN_LEFT")]
    Left,
    /// align text center
    #[doc(alias = "GES_TEXT_HALIGN_CENTER")]
    Center,
    /// align text right
    #[doc(alias = "GES_TEXT_HALIGN_RIGHT")]
    Right,
    /// align text on xpos position
    #[doc(alias = "GES_TEXT_HALIGN_POSITION")]
    Position,
    #[doc(alias = "GES_TEXT_HALIGN_ABSOLUTE")]
    Absolute,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::GESTextHAlign {
        match self {
            Self::Left => ffi::GES_TEXT_HALIGN_LEFT,
            Self::Center => ffi::GES_TEXT_HALIGN_CENTER,
            Self::Right => ffi::GES_TEXT_HALIGN_RIGHT,
            Self::Position => ffi::GES_TEXT_HALIGN_POSITION,
            Self::Absolute => ffi::GES_TEXT_HALIGN_ABSOLUTE,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::GES_TEXT_HALIGN_LEFT => Self::Left,
            ffi::GES_TEXT_HALIGN_CENTER => Self::Center,
            ffi::GES_TEXT_HALIGN_RIGHT => Self::Right,
            ffi::GES_TEXT_HALIGN_POSITION => Self::Position,
            ffi::GES_TEXT_HALIGN_ABSOLUTE => Self::Absolute,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

/// Vertical alignment of the text.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GESTextVAlign")]
pub enum TextVAlign {
    /// draw text on the baseline
    #[doc(alias = "GES_TEXT_VALIGN_BASELINE")]
    Baseline,
    /// draw text on the bottom
    #[doc(alias = "GES_TEXT_VALIGN_BOTTOM")]
    Bottom,
    /// draw text on top
    #[doc(alias = "GES_TEXT_VALIGN_TOP")]
    Top,
    /// draw text on ypos position
    #[doc(alias = "GES_TEXT_VALIGN_POSITION")]
    Position,
    /// draw text on the center
    #[doc(alias = "GES_TEXT_VALIGN_CENTER")]
    Center,
    #[doc(alias = "GES_TEXT_VALIGN_ABSOLUTE")]
    Absolute,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    #[inline]
    fn into_glib(self) -> ffi::GESTextVAlign {
        match self {
            Self::Baseline => ffi::GES_TEXT_VALIGN_BASELINE,
            Self::Bottom => ffi::GES_TEXT_VALIGN_BOTTOM,
            Self::Top => ffi::GES_TEXT_VALIGN_TOP,
            Self::Position => ffi::GES_TEXT_VALIGN_POSITION,
            Self::Center => ffi::GES_TEXT_VALIGN_CENTER,
            Self::Absolute => ffi::GES_TEXT_VALIGN_ABSOLUTE,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::GES_TEXT_VALIGN_BASELINE => Self::Baseline,
            ffi::GES_TEXT_VALIGN_BOTTOM => Self::Bottom,
            ffi::GES_TEXT_VALIGN_TOP => Self::Top,
            ffi::GES_TEXT_VALIGN_POSITION => Self::Position,
            ffi::GES_TEXT_VALIGN_CENTER => Self::Center,
            ffi::GES_TEXT_VALIGN_ABSOLUTE => Self::Absolute,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GESVideoStandardTransitionType")]
pub enum VideoStandardTransitionType {
    /// Transition type has not been set,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_NONE")]
    None,
    /// A bar moves from left to right,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_BAR_WIPE_LR")]
    BarWipeLr,
    /// A bar moves from top to bottom,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_BAR_WIPE_TB")]
    BarWipeTb,
    /// A box expands from the upper-left corner to the lower-right corner,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_TL")]
    BoxWipeTl,
    /// A box expands from the upper-right corner to the lower-left corner,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_TR")]
    BoxWipeTr,
    /// A box expands from the lower-right corner to the upper-left corner,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_BR")]
    BoxWipeBr,
    /// A box expands from the lower-left corner to the upper-right corner,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_BL")]
    BoxWipeBl,
    /// A box shape expands from each of the four corners toward the center,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_FOUR_BOX_WIPE_CI")]
    FourBoxWipeCi,
    /// A box shape expands from the center of each quadrant toward the corners of each quadrant,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_FOUR_BOX_WIPE_CO")]
    FourBoxWipeCo,
    /// A central, vertical line splits and expands toward the left and right edges,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNDOOR_V")]
    BarndoorV,
    /// A central, horizontal line splits and expands toward the top and bottom edges,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNDOOR_H")]
    BarndoorH,
    /// A box expands from the top edge's midpoint to the bottom corners,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_TC")]
    BoxWipeTc,
    /// A box expands from the right edge's midpoint to the left corners,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_RC")]
    BoxWipeRc,
    /// A box expands from the bottom edge's midpoint to the top corners,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_BC")]
    BoxWipeBc,
    /// A box expands from the left edge's midpoint to the right corners,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_LC")]
    BoxWipeLc,
    /// A diagonal line moves from the upper-left corner to the lower-right corner,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_DIAGONAL_TL")]
    DiagonalTl,
    /// A diagonal line moves from the upper right corner to the lower-left corner,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_DIAGONAL_TR")]
    DiagonalTr,
    /// Two wedge shapes slide in from the top and bottom edges toward the center,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_BOWTIE_V")]
    BowtieV,
    /// Two wedge shapes slide in from the left and right edges toward the center,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_BOWTIE_H")]
    BowtieH,
    /// A diagonal line from the lower-left to upper-right corners splits and expands toward the opposite corners,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNDOOR_DBL")]
    BarndoorDbl,
    /// A diagonal line from upper-left to lower-right corners splits and expands toward the opposite corners,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNDOOR_DTL")]
    BarndoorDtl,
    /// Four wedge shapes split from the center and retract toward the four edges,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_MISC_DIAGONAL_DBD")]
    MiscDiagonalDbd,
    /// A diamond connecting the four edge midpoints simultaneously contracts toward the center and expands toward the edges,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_MISC_DIAGONAL_DD")]
    MiscDiagonalDd,
    /// A wedge shape moves from top to bottom,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_VEE_D")]
    VeeD,
    /// A wedge shape moves from right to left,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_VEE_L")]
    VeeL,
    /// A wedge shape moves from bottom to top,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_VEE_U")]
    VeeU,
    /// A wedge shape moves from left to right,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_VEE_R")]
    VeeR,
    /// A 'V' shape extending from the bottom edge's midpoint to the opposite corners contracts toward the center and expands toward the edges,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNVEE_D")]
    BarnveeD,
    /// A 'V' shape extending from the left edge's midpoint to the opposite corners contracts toward the center and expands toward the edges,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNVEE_L")]
    BarnveeL,
    /// A 'V' shape extending from the top edge's midpoint to the opposite corners contracts toward the center and expands toward the edges,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNVEE_U")]
    BarnveeU,
    /// A 'V' shape extending from the right edge's midpoint to the opposite corners contracts toward the center and expands toward the edges,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNVEE_R")]
    BarnveeR,
    /// A rectangle expands from the center.,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_IRIS_RECT")]
    IrisRect,
    /// A radial hand sweeps clockwise from the twelve o'clock position,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_CLOCK_CW12")]
    ClockCw12,
    /// A radial hand sweeps clockwise from the three o'clock position,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_CLOCK_CW3")]
    ClockCw3,
    /// A radial hand sweeps clockwise from the six o'clock position,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_CLOCK_CW6")]
    ClockCw6,
    /// A radial hand sweeps clockwise from the nine o'clock position,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_CLOCK_CW9")]
    ClockCw9,
    /// Two radial hands sweep clockwise from the twelve and six o'clock positions,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_PINWHEEL_TBV")]
    PinwheelTbv,
    /// Two radial hands sweep clockwise from the nine and three o'clock positions,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_PINWHEEL_TBH")]
    PinwheelTbh,
    /// Four radial hands sweep clockwise,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_PINWHEEL_FB")]
    PinwheelFb,
    /// A fan unfolds from the top edge, the fan axis at the center,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_FAN_CT")]
    FanCt,
    /// A fan unfolds from the right edge, the fan axis at the center,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_FAN_CR")]
    FanCr,
    /// Two fans, their axes at the center, unfold from the top and bottom,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLEFAN_FOV")]
    DoublefanFov,
    /// Two fans, their axes at the center, unfold from the left and right,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLEFAN_FOH")]
    DoublefanFoh,
    /// A radial hand sweeps clockwise from the top edge's midpoint,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWT")]
    SinglesweepCwt,
    /// A radial hand sweeps clockwise from the right edge's midpoint,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWR")]
    SinglesweepCwr,
    /// A radial hand sweeps clockwise from the bottom edge's midpoint,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWB")]
    SinglesweepCwb,
    /// A radial hand sweeps clockwise from the left edge's midpoint,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWL")]
    SinglesweepCwl,
    /// Two radial hands sweep clockwise and counter-clockwise from the top and bottom edges' midpoints,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLESWEEP_PV")]
    DoublesweepPv,
    /// Two radial hands sweep clockwise and counter-clockwise from the left and right edges' midpoints,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLESWEEP_PD")]
    DoublesweepPd,
    /// Two radial hands attached at the top and bottom edges' midpoints sweep from right to left,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLESWEEP_OV")]
    DoublesweepOv,
    /// Two radial hands attached at the left and right edges' midpoints sweep from top to bottom,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLESWEEP_OH")]
    DoublesweepOh,
    /// A fan unfolds from the bottom, the fan axis at the top edge's midpoint,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_FAN_T")]
    FanT,
    /// A fan unfolds from the left, the fan axis at the right edge's midpoint,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_FAN_R")]
    FanR,
    /// A fan unfolds from the top, the fan axis at the bottom edge's midpoint,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_FAN_B")]
    FanB,
    /// A fan unfolds from the right, the fan axis at the left edge's midpoint,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_FAN_L")]
    FanL,
    /// Two fans, their axes at the top and bottom, unfold from the center,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLEFAN_FIV")]
    DoublefanFiv,
    /// Two fans, their axes at the left and right, unfold from the center,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLEFAN_FIH")]
    DoublefanFih,
    /// A radial hand sweeps clockwise from the upper-left corner,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWTL")]
    SinglesweepCwtl,
    /// A radial hand sweeps counter-clockwise from the lower-left corner.,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWBL")]
    SinglesweepCwbl,
    /// A radial hand sweeps clockwise from the lower-right corner,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWBR")]
    SinglesweepCwbr,
    /// A radial hand sweeps counter-clockwise from the upper-right corner,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWTR")]
    SinglesweepCwtr,
    /// Two radial hands attached at the upper-left and lower-right corners sweep down and up,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLESWEEP_PDTL")]
    DoublesweepPdtl,
    /// Two radial hands attached at the lower-left and upper-right corners sweep down and up,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLESWEEP_PDBL")]
    DoublesweepPdbl,
    /// Two radial hands attached at the upper-left and upper-right corners sweep down,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_SALOONDOOR_T")]
    SaloondoorT,
    /// Two radial hands attached at the upper-left and lower-left corners sweep to the right,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_SALOONDOOR_L")]
    SaloondoorL,
    /// Two radial hands attached at the lower-left and lower-right corners sweep up,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_SALOONDOOR_B")]
    SaloondoorB,
    /// Two radial hands attached at the upper-right and lower-right corners sweep to the left,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_SALOONDOOR_R")]
    SaloondoorR,
    /// Two radial hands attached at the midpoints of the top and bottom halves sweep from right to left,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_WINDSHIELD_R")]
    WindshieldR,
    /// Two radial hands attached at the midpoints of the left and right halves sweep from top to bottom,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_WINDSHIELD_U")]
    WindshieldU,
    /// Two sets of radial hands attached at the midpoints of the top and bottom halves sweep from top to bottom and bottom to top,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_WINDSHIELD_V")]
    WindshieldV,
    /// Two sets of radial hands attached at the midpoints of the left and right halves sweep from left to right and right to left,
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_WINDSHIELD_H")]
    WindshieldH,
    /// Crossfade
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_CROSSFADE")]
    Crossfade,
    /// Similar to crossfade, but fade in the front video without fading out
    /// the background one
    #[cfg(feature = "v1_22")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_22")))]
    #[doc(alias = "GES_VIDEO_STANDARD_TRANSITION_TYPE_FADE_IN")]
    FadeIn,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    fn into_glib(self) -> ffi::GESVideoStandardTransitionType {
        match self {
            Self::None => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_NONE,
            Self::BarWipeLr => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_BAR_WIPE_LR,
            Self::BarWipeTb => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_BAR_WIPE_TB,
            Self::BoxWipeTl => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_TL,
            Self::BoxWipeTr => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_TR,
            Self::BoxWipeBr => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_BR,
            Self::BoxWipeBl => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_BL,
            Self::FourBoxWipeCi => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_FOUR_BOX_WIPE_CI,
            Self::FourBoxWipeCo => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_FOUR_BOX_WIPE_CO,
            Self::BarndoorV => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNDOOR_V,
            Self::BarndoorH => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNDOOR_H,
            Self::BoxWipeTc => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_TC,
            Self::BoxWipeRc => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_RC,
            Self::BoxWipeBc => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_BC,
            Self::BoxWipeLc => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_LC,
            Self::DiagonalTl => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_DIAGONAL_TL,
            Self::DiagonalTr => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_DIAGONAL_TR,
            Self::BowtieV => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_BOWTIE_V,
            Self::BowtieH => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_BOWTIE_H,
            Self::BarndoorDbl => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNDOOR_DBL,
            Self::BarndoorDtl => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNDOOR_DTL,
            Self::MiscDiagonalDbd => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_MISC_DIAGONAL_DBD,
            Self::MiscDiagonalDd => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_MISC_DIAGONAL_DD,
            Self::VeeD => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_VEE_D,
            Self::VeeL => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_VEE_L,
            Self::VeeU => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_VEE_U,
            Self::VeeR => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_VEE_R,
            Self::BarnveeD => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNVEE_D,
            Self::BarnveeL => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNVEE_L,
            Self::BarnveeU => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNVEE_U,
            Self::BarnveeR => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNVEE_R,
            Self::IrisRect => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_IRIS_RECT,
            Self::ClockCw12 => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_CLOCK_CW12,
            Self::ClockCw3 => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_CLOCK_CW3,
            Self::ClockCw6 => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_CLOCK_CW6,
            Self::ClockCw9 => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_CLOCK_CW9,
            Self::PinwheelTbv => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_PINWHEEL_TBV,
            Self::PinwheelTbh => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_PINWHEEL_TBH,
            Self::PinwheelFb => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_PINWHEEL_FB,
            Self::FanCt => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_FAN_CT,
            Self::FanCr => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_FAN_CR,
            Self::DoublefanFov => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLEFAN_FOV,
            Self::DoublefanFoh => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLEFAN_FOH,
            Self::SinglesweepCwt => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWT,
            Self::SinglesweepCwr => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWR,
            Self::SinglesweepCwb => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWB,
            Self::SinglesweepCwl => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWL,
            Self::DoublesweepPv => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLESWEEP_PV,
            Self::DoublesweepPd => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLESWEEP_PD,
            Self::DoublesweepOv => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLESWEEP_OV,
            Self::DoublesweepOh => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLESWEEP_OH,
            Self::FanT => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_FAN_T,
            Self::FanR => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_FAN_R,
            Self::FanB => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_FAN_B,
            Self::FanL => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_FAN_L,
            Self::DoublefanFiv => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLEFAN_FIV,
            Self::DoublefanFih => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLEFAN_FIH,
            Self::SinglesweepCwtl => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWTL,
            Self::SinglesweepCwbl => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWBL,
            Self::SinglesweepCwbr => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWBR,
            Self::SinglesweepCwtr => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWTR,
            Self::DoublesweepPdtl => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLESWEEP_PDTL,
            Self::DoublesweepPdbl => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLESWEEP_PDBL,
            Self::SaloondoorT => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_SALOONDOOR_T,
            Self::SaloondoorL => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_SALOONDOOR_L,
            Self::SaloondoorB => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_SALOONDOOR_B,
            Self::SaloondoorR => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_SALOONDOOR_R,
            Self::WindshieldR => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_WINDSHIELD_R,
            Self::WindshieldU => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_WINDSHIELD_U,
            Self::WindshieldV => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_WINDSHIELD_V,
            Self::WindshieldH => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_WINDSHIELD_H,
            Self::Crossfade => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_CROSSFADE,
            #[cfg(feature = "v1_22")]
            Self::FadeIn => ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_FADE_IN,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_NONE => Self::None,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_BAR_WIPE_LR => Self::BarWipeLr,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_BAR_WIPE_TB => Self::BarWipeTb,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_TL => Self::BoxWipeTl,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_TR => Self::BoxWipeTr,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_BR => Self::BoxWipeBr,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_BL => Self::BoxWipeBl,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_FOUR_BOX_WIPE_CI => Self::FourBoxWipeCi,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_FOUR_BOX_WIPE_CO => Self::FourBoxWipeCo,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNDOOR_V => Self::BarndoorV,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNDOOR_H => Self::BarndoorH,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_TC => Self::BoxWipeTc,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_RC => Self::BoxWipeRc,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_BC => Self::BoxWipeBc,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_BOX_WIPE_LC => Self::BoxWipeLc,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_DIAGONAL_TL => Self::DiagonalTl,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_DIAGONAL_TR => Self::DiagonalTr,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_BOWTIE_V => Self::BowtieV,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_BOWTIE_H => Self::BowtieH,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNDOOR_DBL => Self::BarndoorDbl,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNDOOR_DTL => Self::BarndoorDtl,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_MISC_DIAGONAL_DBD => Self::MiscDiagonalDbd,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_MISC_DIAGONAL_DD => Self::MiscDiagonalDd,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_VEE_D => Self::VeeD,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_VEE_L => Self::VeeL,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_VEE_U => Self::VeeU,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_VEE_R => Self::VeeR,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNVEE_D => Self::BarnveeD,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNVEE_L => Self::BarnveeL,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNVEE_U => Self::BarnveeU,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_BARNVEE_R => Self::BarnveeR,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_IRIS_RECT => Self::IrisRect,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_CLOCK_CW12 => Self::ClockCw12,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_CLOCK_CW3 => Self::ClockCw3,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_CLOCK_CW6 => Self::ClockCw6,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_CLOCK_CW9 => Self::ClockCw9,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_PINWHEEL_TBV => Self::PinwheelTbv,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_PINWHEEL_TBH => Self::PinwheelTbh,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_PINWHEEL_FB => Self::PinwheelFb,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_FAN_CT => Self::FanCt,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_FAN_CR => Self::FanCr,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLEFAN_FOV => Self::DoublefanFov,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLEFAN_FOH => Self::DoublefanFoh,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWT => Self::SinglesweepCwt,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWR => Self::SinglesweepCwr,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWB => Self::SinglesweepCwb,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWL => Self::SinglesweepCwl,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLESWEEP_PV => Self::DoublesweepPv,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLESWEEP_PD => Self::DoublesweepPd,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLESWEEP_OV => Self::DoublesweepOv,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLESWEEP_OH => Self::DoublesweepOh,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_FAN_T => Self::FanT,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_FAN_R => Self::FanR,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_FAN_B => Self::FanB,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_FAN_L => Self::FanL,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLEFAN_FIV => Self::DoublefanFiv,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLEFAN_FIH => Self::DoublefanFih,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWTL => Self::SinglesweepCwtl,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWBL => Self::SinglesweepCwbl,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWBR => Self::SinglesweepCwbr,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_SINGLESWEEP_CWTR => Self::SinglesweepCwtr,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLESWEEP_PDTL => Self::DoublesweepPdtl,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_DOUBLESWEEP_PDBL => Self::DoublesweepPdbl,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_SALOONDOOR_T => Self::SaloondoorT,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_SALOONDOOR_L => Self::SaloondoorL,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_SALOONDOOR_B => Self::SaloondoorB,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_SALOONDOOR_R => Self::SaloondoorR,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_WINDSHIELD_R => Self::WindshieldR,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_WINDSHIELD_U => Self::WindshieldU,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_WINDSHIELD_V => Self::WindshieldV,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_WINDSHIELD_H => Self::WindshieldH,
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_CROSSFADE => Self::Crossfade,
            #[cfg(feature = "v1_22")]
            ffi::GES_VIDEO_STANDARD_TRANSITION_TYPE_FADE_IN => Self::FadeIn,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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

/// The test pattern to produce
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
#[doc(alias = "GESVideoTestPattern")]
pub enum VideoTestPattern {
    /// A standard SMPTE test pattern
    #[doc(alias = "GES_VIDEO_TEST_PATTERN_SMPTE")]
    Smpte,
    /// Random noise
    #[doc(alias = "GES_VIDEO_TEST_PATTERN_SNOW")]
    Snow,
    /// A black image
    #[doc(alias = "GES_VIDEO_TEST_PATTERN_BLACK")]
    Black,
    /// A white image
    #[doc(alias = "GES_VIDEO_TEST_PATTERN_WHITE")]
    White,
    /// A red image
    #[doc(alias = "GES_VIDEO_TEST_PATTERN_RED")]
    Red,
    /// A green image
    #[doc(alias = "GES_VIDEO_TEST_PATTERN_GREEN")]
    Green,
    /// A blue image
    #[doc(alias = "GES_VIDEO_TEST_PATTERN_BLUE")]
    Blue,
    /// Checkers pattern (1px)
    #[doc(alias = "GES_VIDEO_TEST_PATTERN_CHECKERS1")]
    Checkers1,
    /// Checkers pattern (2px)
    #[doc(alias = "GES_VIDEO_TEST_PATTERN_CHECKERS2")]
    Checkers2,
    /// Checkers pattern (4px)
    #[doc(alias = "GES_VIDEO_TEST_PATTERN_CHECKERS4")]
    Checkers4,
    /// Checkers pattern (8px)
    #[doc(alias = "GES_VIDEO_TEST_PATTERN_CHECKERS8")]
    Checkers8,
    /// Circular pattern
    #[doc(alias = "GES_VIDEO_TEST_PATTERN_CIRCULAR")]
    Circular,
    /// Alternate between black and white
    #[doc(alias = "GES_VIDEO_TEST_PATTERN_BLINK")]
    Blink,
    /// SMPTE test pattern (75% color bars)
    #[doc(alias = "GES_VIDEO_TEST_PATTERN_SMPTE75")]
    Smpte75,
    /// Zone plate
    #[doc(alias = "GES_VIDEO_TEST_ZONE_PLATE")]
    ZonePlate,
    /// Gamut checkers
    #[doc(alias = "GES_VIDEO_TEST_GAMUT")]
    Gamut,
    /// Chroma zone plate
    #[doc(alias = "GES_VIDEO_TEST_CHROMA_ZONE_PLATE")]
    ChromaZonePlate,
    /// Solid color
    #[doc(alias = "GES_VIDEO_TEST_PATTERN_SOLID")]
    SolidColor,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    fn into_glib(self) -> ffi::GESVideoTestPattern {
        match self {
            Self::Smpte => ffi::GES_VIDEO_TEST_PATTERN_SMPTE,
            Self::Snow => ffi::GES_VIDEO_TEST_PATTERN_SNOW,
            Self::Black => ffi::GES_VIDEO_TEST_PATTERN_BLACK,
            Self::White => ffi::GES_VIDEO_TEST_PATTERN_WHITE,
            Self::Red => ffi::GES_VIDEO_TEST_PATTERN_RED,
            Self::Green => ffi::GES_VIDEO_TEST_PATTERN_GREEN,
            Self::Blue => ffi::GES_VIDEO_TEST_PATTERN_BLUE,
            Self::Checkers1 => ffi::GES_VIDEO_TEST_PATTERN_CHECKERS1,
            Self::Checkers2 => ffi::GES_VIDEO_TEST_PATTERN_CHECKERS2,
            Self::Checkers4 => ffi::GES_VIDEO_TEST_PATTERN_CHECKERS4,
            Self::Checkers8 => ffi::GES_VIDEO_TEST_PATTERN_CHECKERS8,
            Self::Circular => ffi::GES_VIDEO_TEST_PATTERN_CIRCULAR,
            Self::Blink => ffi::GES_VIDEO_TEST_PATTERN_BLINK,
            Self::Smpte75 => ffi::GES_VIDEO_TEST_PATTERN_SMPTE75,
            Self::ZonePlate => ffi::GES_VIDEO_TEST_ZONE_PLATE,
            Self::Gamut => ffi::GES_VIDEO_TEST_GAMUT,
            Self::ChromaZonePlate => ffi::GES_VIDEO_TEST_CHROMA_ZONE_PLATE,
            Self::SolidColor => ffi::GES_VIDEO_TEST_PATTERN_SOLID,
            Self::__Unknown(value) => value,
        }
    }
}

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

        match value {
            ffi::GES_VIDEO_TEST_PATTERN_SMPTE => Self::Smpte,
            ffi::GES_VIDEO_TEST_PATTERN_SNOW => Self::Snow,
            ffi::GES_VIDEO_TEST_PATTERN_BLACK => Self::Black,
            ffi::GES_VIDEO_TEST_PATTERN_WHITE => Self::White,
            ffi::GES_VIDEO_TEST_PATTERN_RED => Self::Red,
            ffi::GES_VIDEO_TEST_PATTERN_GREEN => Self::Green,
            ffi::GES_VIDEO_TEST_PATTERN_BLUE => Self::Blue,
            ffi::GES_VIDEO_TEST_PATTERN_CHECKERS1 => Self::Checkers1,
            ffi::GES_VIDEO_TEST_PATTERN_CHECKERS2 => Self::Checkers2,
            ffi::GES_VIDEO_TEST_PATTERN_CHECKERS4 => Self::Checkers4,
            ffi::GES_VIDEO_TEST_PATTERN_CHECKERS8 => Self::Checkers8,
            ffi::GES_VIDEO_TEST_PATTERN_CIRCULAR => Self::Circular,
            ffi::GES_VIDEO_TEST_PATTERN_BLINK => Self::Blink,
            ffi::GES_VIDEO_TEST_PATTERN_SMPTE75 => Self::Smpte75,
            ffi::GES_VIDEO_TEST_ZONE_PLATE => Self::ZonePlate,
            ffi::GES_VIDEO_TEST_GAMUT => Self::Gamut,
            ffi::GES_VIDEO_TEST_CHROMA_ZONE_PLATE => Self::ChromaZonePlate,
            ffi::GES_VIDEO_TEST_PATTERN_SOLID => Self::SolidColor,
            value => Self::__Unknown(value),
        }
    }
}

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

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

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