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

use ges_sys;
use glib::translate::*;
use glib::value::FromValue;
use glib::value::FromValueOptional;
use glib::value::SetValue;
use glib::value::Value;
use glib::StaticType;
use glib::Type;
use gobject_sys;

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

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

    fn to_glib(&self) -> ges_sys::GESEdge {
        match *self {
            Edge::Start => ges_sys::GES_EDGE_START,
            Edge::End => ges_sys::GES_EDGE_END,
            Edge::None => ges_sys::GES_EDGE_NONE,
            Edge::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ges_sys::GESEdge> for Edge {
    fn from_glib(value: ges_sys::GESEdge) -> Self {
        skip_assert_initialized!();
        match value {
            0 => Edge::Start,
            1 => Edge::End,
            2 => Edge::None,
            value => Edge::__Unknown(value),
        }
    }
}

impl StaticType for Edge {
    fn static_type() -> Type {
        unsafe { from_glib(ges_sys::ges_edge_get_type()) }
    }
}

impl<'a> FromValueOptional<'a> for Edge {
    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
        Some(FromValue::from_value(value))
    }
}

impl<'a> FromValue<'a> for Edge {
    unsafe fn from_value(value: &Value) -> Self {
        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
    }
}

impl SetValue for Edge {
    unsafe fn set_value(value: &mut Value, this: &Self) {
        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
    }
}

/// When a single timeline element is edited within its timeline at some
/// position, using `TimelineElementExt::edit`, depending on the edit
/// mode, its `TimelineElement:start`, `TimelineElement:duration` or
/// `TimelineElement:in-point` will be adjusted accordingly. In addition,
/// any clips may change `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`:
///
/// + MOVE: This will set the `TimelineElement:start` of the clip to the
///  edit position.
/// + START-TRIM: This will set the `TimelineElement:start` of the clip
///  to the edit position. To keep the end time the same, the
///  `TimelineElement:duration` of the clip will be adjusted in the
///  opposite direction. In addition, the `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 `TimelineElement:duration` of the clip
///  such that its end time will match the edit position.
///
/// When editing a `Group`:
///
/// + MOVE: This will set the `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`, if it has a `Clip` parent, this
/// will be edited instead. Otherwise it is edited in the same way as a
/// `Clip`.
///
/// The layer priority of a `Group` is the lowest layer priority of any
/// `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` has a `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` under the element may
///  be snapped.
/// + START-TRIM: The start edge of a `Source` whose start edge touches
///  the start edge of the element may snap.
/// + END-TRIM: The end edge of a `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` in the timeline that is not also being moved by the element,
/// including those in different layers, if they are within the
/// `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 `EditMode::Ripple` acting on `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]
pub enum EditMode {
    /// The element is edited the normal way (default).
    ///  If acting on the element as a whole (`Edge::None`), this will MOVE
    ///  the element by MOVING its toplevel. When acting on the start of the
    ///  element (`Edge::Start`), this will only MOVE the element, but not
    ///  its toplevel parent. This can allow you to move a `Clip` or
    ///  `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`), this will END-TRIM the element,
    ///  leaving its toplevel unchanged.
    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 `EditMode::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.
    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 `EditMode::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` at its
    ///  end/start edge that shares a track with a `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`) is not defined. The element can not shift
    ///  layers under this mode.
    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`) is not defined.
    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 `EditMode::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` and `Edge::End`) is not defined. The element can
    ///  not shift layers under this mode.
    Slide,
    #[doc(hidden)]
    __Unknown(i32),
}

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

    fn to_glib(&self) -> ges_sys::GESEditMode {
        match *self {
            EditMode::Normal => ges_sys::GES_EDIT_MODE_NORMAL,
            EditMode::Ripple => ges_sys::GES_EDIT_MODE_RIPPLE,
            EditMode::Roll => ges_sys::GES_EDIT_MODE_ROLL,
            EditMode::Trim => ges_sys::GES_EDIT_MODE_TRIM,
            EditMode::Slide => ges_sys::GES_EDIT_MODE_SLIDE,
            EditMode::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<ges_sys::GESEditMode> for EditMode {
    fn from_glib(value: ges_sys::GESEditMode) -> Self {
        skip_assert_initialized!();
        match value {
            0 => EditMode::Normal,
            1 => EditMode::Ripple,
            2 => EditMode::Roll,
            3 => EditMode::Trim,
            4 => EditMode::Slide,
            value => EditMode::__Unknown(value),
        }
    }
}

impl StaticType for EditMode {
    fn static_type() -> Type {
        unsafe { from_glib(ges_sys::ges_edit_mode_get_type()) }
    }
}

impl<'a> FromValueOptional<'a> for EditMode {
    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
        Some(FromValue::from_value(value))
    }
}

impl<'a> FromValue<'a> for EditMode {
    unsafe fn from_value(value: &Value) -> Self {
        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
    }
}

impl SetValue for EditMode {
    unsafe fn set_value(value: &mut Value, this: &Self) {
        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
    }
}

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
pub enum VideoStandardTransitionType {
    /// Transition type has not been set,
    None,
    /// A bar moves from left to right,
    BarWipeLr,
    /// A bar moves from top to bottom,
    BarWipeTb,
    /// A box expands from the upper-left corner to the lower-right corner,
    BoxWipeTl,
    /// A box expands from the upper-right corner to the lower-left corner,
    BoxWipeTr,
    /// A box expands from the lower-right corner to the upper-left corner,
    BoxWipeBr,
    /// A box expands from the lower-left corner to the upper-right corner,
    BoxWipeBl,
    /// A box shape expands from each of the four corners toward the center,
    FourBoxWipeCi,
    /// A box shape expands from the center of each quadrant toward the corners of each quadrant,
    FourBoxWipeCo,
    /// A central, vertical line splits and expands toward the left and right edges,
    BarndoorV,
    /// A central, horizontal line splits and expands toward the top and bottom edges,
    BarndoorH,
    /// A box expands from the top edge's midpoint to the bottom corners,
    BoxWipeTc,
    /// A box expands from the right edge's midpoint to the left corners,
    BoxWipeRc,
    /// A box expands from the bottom edge's midpoint to the top corners,
    BoxWipeBc,
    /// A box expands from the left edge's midpoint to the right corners,
    BoxWipeLc,
    /// A diagonal line moves from the upper-left corner to the lower-right corner,
    DiagonalTl,
    /// A diagonal line moves from the upper right corner to the lower-left corner,
    DiagonalTr,
    /// Two wedge shapes slide in from the top and bottom edges toward the center,
    BowtieV,
    /// Two wedge shapes slide in from the left and right edges toward the center,
    BowtieH,
    /// A diagonal line from the lower-left to upper-right corners splits and expands toward the opposite corners,
    BarndoorDbl,
    /// A diagonal line from upper-left to lower-right corners splits and expands toward the opposite corners,
    BarndoorDtl,
    /// Four wedge shapes split from the center and retract toward the four edges,
    MiscDiagonalDbd,
    /// A diamond connecting the four edge midpoints simultaneously contracts toward the center and expands toward the edges,
    MiscDiagonalDd,
    /// A wedge shape moves from top to bottom,
    VeeD,
    /// A wedge shape moves from right to left,
    VeeL,
    /// A wedge shape moves from bottom to top,
    VeeU,
    /// A wedge shape moves from left to right,
    VeeR,
    /// A 'V' shape extending from the bottom edge's midpoint to the opposite corners contracts toward the center and expands toward the edges,
    BarnveeD,
    /// A 'V' shape extending from the left edge's midpoint to the opposite corners contracts toward the center and expands toward the edges,
    BarnveeL,
    /// A 'V' shape extending from the top edge's midpoint to the opposite corners contracts toward the center and expands toward the edges,
    BarnveeU,
    /// A 'V' shape extending from the right edge's midpoint to the opposite corners contracts toward the center and expands toward the edges,
    BarnveeR,
    /// A rectangle expands from the center.,
    IrisRect,
    /// A radial hand sweeps clockwise from the twelve o'clock position,
    ClockCw12,
    /// A radial hand sweeps clockwise from the three o'clock position,
    ClockCw3,
    /// A radial hand sweeps clockwise from the six o'clock position,
    ClockCw6,
    /// A radial hand sweeps clockwise from the nine o'clock position,
    ClockCw9,
    /// Two radial hands sweep clockwise from the twelve and six o'clock positions,
    PinwheelTbv,
    /// Two radial hands sweep clockwise from the nine and three o'clock positions,
    PinwheelTbh,
    /// Four radial hands sweep clockwise,
    PinwheelFb,
    /// A fan unfolds from the top edge, the fan axis at the center,
    FanCt,
    /// A fan unfolds from the right edge, the fan axis at the center,
    FanCr,
    /// Two fans, their axes at the center, unfold from the top and bottom,
    DoublefanFov,
    /// Two fans, their axes at the center, unfold from the left and right,
    DoublefanFoh,
    /// A radial hand sweeps clockwise from the top edge's midpoint,
    SinglesweepCwt,
    /// A radial hand sweeps clockwise from the right edge's midpoint,
    SinglesweepCwr,
    /// A radial hand sweeps clockwise from the bottom edge's midpoint,
    SinglesweepCwb,
    /// A radial hand sweeps clockwise from the left edge's midpoint,
    SinglesweepCwl,
    /// Two radial hands sweep clockwise and counter-clockwise from the top and bottom edges' midpoints,
    DoublesweepPv,
    /// Two radial hands sweep clockwise and counter-clockwise from the left and right edges' midpoints,
    DoublesweepPd,
    /// Two radial hands attached at the top and bottom edges' midpoints sweep from right to left,
    DoublesweepOv,
    /// Two radial hands attached at the left and right edges' midpoints sweep from top to bottom,
    DoublesweepOh,
    /// A fan unfolds from the bottom, the fan axis at the top edge's midpoint,
    FanT,
    /// A fan unfolds from the left, the fan axis at the right edge's midpoint,
    FanR,
    /// A fan unfolds from the top, the fan axis at the bottom edge's midpoint,
    FanB,
    /// A fan unfolds from the right, the fan axis at the left edge's midpoint,
    FanL,
    /// Two fans, their axes at the top and bottom, unfold from the center,
    DoublefanFiv,
    /// Two fans, their axes at the left and right, unfold from the center,
    DoublefanFih,
    /// A radial hand sweeps clockwise from the upper-left corner,
    SinglesweepCwtl,
    /// A radial hand sweeps counter-clockwise from the lower-left corner.,
    SinglesweepCwbl,
    /// A radial hand sweeps clockwise from the lower-right corner,
    SinglesweepCwbr,
    /// A radial hand sweeps counter-clockwise from the upper-right corner,
    SinglesweepCwtr,
    /// Two radial hands attached at the upper-left and lower-right corners sweep down and up,
    DoublesweepPdtl,
    /// Two radial hands attached at the lower-left and upper-right corners sweep down and up,
    DoublesweepPdbl,
    /// Two radial hands attached at the upper-left and upper-right corners sweep down,
    SaloondoorT,
    /// Two radial hands attached at the upper-left and lower-left corners sweep to the right,
    SaloondoorL,
    /// Two radial hands attached at the lower-left and lower-right corners sweep up,
    SaloondoorB,
    /// Two radial hands attached at the upper-right and lower-right corners sweep to the left,
    SaloondoorR,
    /// Two radial hands attached at the midpoints of the top and bottom halves sweep from right to left,
    WindshieldR,
    /// Two radial hands attached at the midpoints of the left and right halves sweep from top to bottom,
    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,
    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,
    WindshieldH,
    /// Crossfade
    Crossfade,
    #[doc(hidden)]
    __Unknown(i32),
}

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

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

#[doc(hidden)]
impl FromGlib<ges_sys::GESVideoStandardTransitionType> for VideoStandardTransitionType {
    fn from_glib(value: ges_sys::GESVideoStandardTransitionType) -> Self {
        skip_assert_initialized!();
        match value {
            0 => VideoStandardTransitionType::None,
            1 => VideoStandardTransitionType::BarWipeLr,
            2 => VideoStandardTransitionType::BarWipeTb,
            3 => VideoStandardTransitionType::BoxWipeTl,
            4 => VideoStandardTransitionType::BoxWipeTr,
            5 => VideoStandardTransitionType::BoxWipeBr,
            6 => VideoStandardTransitionType::BoxWipeBl,
            7 => VideoStandardTransitionType::FourBoxWipeCi,
            8 => VideoStandardTransitionType::FourBoxWipeCo,
            21 => VideoStandardTransitionType::BarndoorV,
            22 => VideoStandardTransitionType::BarndoorH,
            23 => VideoStandardTransitionType::BoxWipeTc,
            24 => VideoStandardTransitionType::BoxWipeRc,
            25 => VideoStandardTransitionType::BoxWipeBc,
            26 => VideoStandardTransitionType::BoxWipeLc,
            41 => VideoStandardTransitionType::DiagonalTl,
            42 => VideoStandardTransitionType::DiagonalTr,
            43 => VideoStandardTransitionType::BowtieV,
            44 => VideoStandardTransitionType::BowtieH,
            45 => VideoStandardTransitionType::BarndoorDbl,
            46 => VideoStandardTransitionType::BarndoorDtl,
            47 => VideoStandardTransitionType::MiscDiagonalDbd,
            48 => VideoStandardTransitionType::MiscDiagonalDd,
            61 => VideoStandardTransitionType::VeeD,
            62 => VideoStandardTransitionType::VeeL,
            63 => VideoStandardTransitionType::VeeU,
            64 => VideoStandardTransitionType::VeeR,
            65 => VideoStandardTransitionType::BarnveeD,
            66 => VideoStandardTransitionType::BarnveeL,
            67 => VideoStandardTransitionType::BarnveeU,
            68 => VideoStandardTransitionType::BarnveeR,
            101 => VideoStandardTransitionType::IrisRect,
            201 => VideoStandardTransitionType::ClockCw12,
            202 => VideoStandardTransitionType::ClockCw3,
            203 => VideoStandardTransitionType::ClockCw6,
            204 => VideoStandardTransitionType::ClockCw9,
            205 => VideoStandardTransitionType::PinwheelTbv,
            206 => VideoStandardTransitionType::PinwheelTbh,
            207 => VideoStandardTransitionType::PinwheelFb,
            211 => VideoStandardTransitionType::FanCt,
            212 => VideoStandardTransitionType::FanCr,
            213 => VideoStandardTransitionType::DoublefanFov,
            214 => VideoStandardTransitionType::DoublefanFoh,
            221 => VideoStandardTransitionType::SinglesweepCwt,
            222 => VideoStandardTransitionType::SinglesweepCwr,
            223 => VideoStandardTransitionType::SinglesweepCwb,
            224 => VideoStandardTransitionType::SinglesweepCwl,
            225 => VideoStandardTransitionType::DoublesweepPv,
            226 => VideoStandardTransitionType::DoublesweepPd,
            227 => VideoStandardTransitionType::DoublesweepOv,
            228 => VideoStandardTransitionType::DoublesweepOh,
            231 => VideoStandardTransitionType::FanT,
            232 => VideoStandardTransitionType::FanR,
            233 => VideoStandardTransitionType::FanB,
            234 => VideoStandardTransitionType::FanL,
            235 => VideoStandardTransitionType::DoublefanFiv,
            236 => VideoStandardTransitionType::DoublefanFih,
            241 => VideoStandardTransitionType::SinglesweepCwtl,
            242 => VideoStandardTransitionType::SinglesweepCwbl,
            243 => VideoStandardTransitionType::SinglesweepCwbr,
            244 => VideoStandardTransitionType::SinglesweepCwtr,
            245 => VideoStandardTransitionType::DoublesweepPdtl,
            246 => VideoStandardTransitionType::DoublesweepPdbl,
            251 => VideoStandardTransitionType::SaloondoorT,
            252 => VideoStandardTransitionType::SaloondoorL,
            253 => VideoStandardTransitionType::SaloondoorB,
            254 => VideoStandardTransitionType::SaloondoorR,
            261 => VideoStandardTransitionType::WindshieldR,
            262 => VideoStandardTransitionType::WindshieldU,
            263 => VideoStandardTransitionType::WindshieldV,
            264 => VideoStandardTransitionType::WindshieldH,
            512 => VideoStandardTransitionType::Crossfade,
            value => VideoStandardTransitionType::__Unknown(value),
        }
    }
}

impl StaticType for VideoStandardTransitionType {
    fn static_type() -> Type {
        unsafe { from_glib(ges_sys::ges_video_standard_transition_type_get_type()) }
    }
}

impl<'a> FromValueOptional<'a> for VideoStandardTransitionType {
    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
        Some(FromValue::from_value(value))
    }
}

impl<'a> FromValue<'a> for VideoStandardTransitionType {
    unsafe fn from_value(value: &Value) -> Self {
        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
    }
}

impl SetValue for VideoStandardTransitionType {
    unsafe fn set_value(value: &mut Value, this: &Self) {
        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
    }
}