// 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::Asset;
use crate::BaseEffect;
use crate::Container;
use crate::Extractable;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
use crate::FrameNumber;
use crate::Layer;
use crate::TimelineElement;
use crate::Track;
use crate::TrackElement;
use crate::TrackType;
use glib::object::Cast;
use glib::object::IsA;
use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*;
use std::boxed::Box as Box_;
use std::mem::transmute;
#[cfg(any(feature = "v1_18", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
use std::ptr;

glib::wrapper! {
    /// [`crate::Clip`]-s are the core objects of a [`crate::Layer`]. Each clip may exist in
    /// a single layer but may control several [`crate::TrackElement`]-s that span
    /// several [`crate::Track`]-s. A clip will ensure that all its children share the
    /// same [`crate::TimelineElement:start`] and [`crate::TimelineElement:duration`] in
    /// their tracks, which will match the [`crate::TimelineElement:start`] and
    /// [`crate::TimelineElement:duration`] of the clip itself. Therefore, changing
    /// the timing of the clip will change the timing of the children, and a
    /// change in the timing of a child will change the timing of the clip and
    /// subsequently all its siblings. As such, a clip can be treated as a
    /// singular object in its layer.
    ///
    /// For most uses of a [`crate::Timeline`], it is often sufficient to only
    /// interact with [`crate::Clip`]-s directly, which will take care of creating and
    /// organising the elements of the timeline's tracks.
    ///
    /// ## Core Children
    ///
    /// In more detail, clips will usually have some *core* [`crate::TrackElement`]
    /// children, which are created by the clip when it is added to a layer in
    /// a timeline. The type and form of these core children will depend on the
    /// clip's subclass. You can use [`crate::prelude::TrackElementExt::is_core()`] to determine
    /// whether a track element is considered such a core track element. Note,
    /// if a core track element is part of a clip, it will always be treated as
    /// a core *child* of the clip. You can connect to the
    /// [`crate::Container::child-added`] signal to be notified of their creation.
    ///
    /// When a child is added to a clip, the timeline will select its tracks
    /// using [`crate::Timeline::select-tracks-for-object`]. Note that it may be the
    /// case that the child will still have no set [`crate::TrackElement:track`]
    /// after this process. For example, if the timeline does not have a track
    /// of the corresponding [`crate::Track:track-type`]. A clip can safely contain
    /// such children, which may have their track set later, although they will
    /// play no functioning role in the timeline in the meantime.
    ///
    /// If a clip may create track elements with various
    /// [`crate::TrackElement:track-type`](s), such as a [`crate::UriClip`], but you only
    /// want it to create a subset of these types, you should set the
    /// [`crate::Clip:supported-formats`] of the clip to the subset of types. This
    /// should be done *before* adding the clip to a layer.
    ///
    /// If a clip will produce several core elements of the same
    /// [`crate::TrackElement:track-type`], you should connect to the timeline's
    /// [`crate::Timeline::select-tracks-for-object`] signal to coordinate which
    /// tracks each element should land in. Note, no two core children within a
    /// clip can share the same [`crate::Track`], so you should not select the same
    /// track for two separate core children. Provided you stick to this rule,
    /// it is still safe to select several tracks for the same core child, the
    /// core child will be copied into the additional tracks. You can manually
    /// add the child to more tracks later using [`crate::prelude::ClipExt::add_child_to_track()`].
    /// If you do not wish to use a core child, you can always select no track.
    ///
    /// The [`crate::TimelineElement:in-point`] of the clip will control the
    /// [`crate::TimelineElement:in-point`] of its core children to be the same
    /// value if their [`crate::TrackElement:has-internal-source`] is set to [`true`].
    ///
    /// The [`crate::TimelineElement:max-duration`] of the clip is the minimum
    /// [`crate::TimelineElement:max-duration`] of its core children. If you set its
    /// value to anything other than its current value, this will also set the
    /// [`crate::TimelineElement:max-duration`] of all its core children to the same
    /// value if their [`crate::TrackElement:has-internal-source`] is set to [`true`].
    /// As a special case, whilst a clip does not yet have any core children,
    /// its [`crate::TimelineElement:max-duration`] may be set to indicate what its
    /// value will be once they are created.
    ///
    /// ## Effects
    ///
    /// Some subclasses ([`crate::SourceClip`] and [`crate::BaseEffectClip`]) may also allow
    /// their objects to have additional non-core [`crate::BaseEffect`]-s elements as
    /// children. These are additional effects that are applied to the output
    /// data of the core elements. They can be added to the clip using
    /// [`crate::prelude::ClipExt::add_top_effect()`], which will take care of adding the effect to
    /// the timeline's tracks. The new effect will be placed between the clip's
    /// core track elements and its other effects. As such, the newly added
    /// effect will be applied to any source data **before** the other existing
    /// effects. You can change the ordering of effects using
    /// [`crate::prelude::ClipExt::set_top_effect_index()`].
    ///
    /// Tracks are selected for top effects in the same way as core children.
    /// If you add a top effect to a clip before it is part of a timeline, and
    /// later add the clip to a timeline, the track selection for the top
    /// effects will occur just after the track selection for the core
    /// children. If you add a top effect to a clip that is already part of a
    /// timeline, the track selection will occur immediately. Since a top
    /// effect must be applied on top of a core child, if you use
    /// [`crate::Timeline::select-tracks-for-object`], you should ensure that the
    /// added effects are destined for a [`crate::Track`] that already contains a core
    /// child.
    ///
    /// In addition, if the core child in the track is not
    /// [`crate::TrackElement:active`], then neither can any of its effects be
    /// [`crate::TrackElement:active`]. Therefore, if a core child is made in-active,
    /// all of the additional effects in the same track will also become
    /// in-active. Similarly, if an effect is set to be active, then the core
    /// child will also become active, but other effects will be left alone.
    /// Finally, if an active effect is added to the track of an in-active core
    /// child, it will become in-active as well. Note, in contrast, setting a
    /// core child to be active, or an effect to be in-active will *not* change
    /// the other children in the same track.
    ///
    /// ### Time Effects
    ///
    /// Some effects also change the timing of their data (see [`crate::BaseEffect`]
    /// for what counts as a time effect). Note that a [`crate::BaseEffectClip`] will
    /// refuse time effects, but a [`crate::Source`] will allow them.
    ///
    /// When added to a clip, time effects may adjust the timing of other
    /// children in the same track. Similarly, when changing the order of
    /// effects, making them (in)-active, setting their time property values
    /// or removing time effects. These can cause the [`crate::Clip:duration-limit`]
    /// to change in value. However, if such an operation would ever cause the
    /// [`crate::TimelineElement:duration`] to shrink such that a clip's [`crate::Source`] is
    /// totally overlapped in the timeline, the operation would be prevented.
    /// Note that the same can happen when adding non-time effects with a
    /// finite [`crate::TimelineElement:max-duration`].
    ///
    /// Therefore, when working with time effects, you should -- more so than
    /// usual -- not assume that setting the properties of the clip's children
    /// will succeed. In particular, you should use
    /// [`crate::prelude::TimelineElementExt::set_child_property_full()`] when setting the time
    /// properties.
    ///
    /// If you wish to preserve the *internal* duration of a source in a clip
    /// during these time effect operations, you can do something like the
    /// following.
    ///
    /// ```c
    /// void
    /// do_time_effect_change (GESClip * clip)
    /// {
    ///   GList *tmp, *children;
    ///   GESTrackElement *source;
    ///   GstClockTime source_outpoint;
    ///   GstClockTime new_end;
    ///   GError *error = NULL;
    ///
    ///   // choose some active source in a track to preserve the internal
    ///   // duration of
    ///   source = ges_clip_get_track_element (clip, NULL, GES_TYPE_SOURCE);
    ///
    ///   // note its current internal end time
    ///   source_outpoint = ges_clip_get_internal_time_from_timeline_time (
    ///         clip, source, GES_TIMELINE_ELEMENT_END (clip), NULL);
    ///
    ///   // handle invalid out-point
    ///
    ///   // stop the children's control sources from clamping when their
    ///   // out-point changes with a change in the time effects
    ///   children = ges_container_get_children (GES_CONTAINER (clip), FALSE);
    ///
    ///   for (tmp = children; tmp; tmp = tmp->next)
    ///     ges_track_element_set_auto_clamp_control_source (tmp->data, FALSE);
    ///
    ///   // add time effect, or set their children properties, or move them around
    ///   ...
    ///   // user can make sure that if a time effect changes one source, we should
    ///   // also change the time effect for another source. E.g. if
    ///   // "GstVideorate::rate" is set to 2.0, we also set "GstPitch::rate" to
    ///   // 2.0
    ///
    ///   // Note the duration of the clip may have already changed if the
    ///   // duration-limit of the clip dropped below its current value
    ///
    ///   new_end = ges_clip_get_timeline_time_from_internal_time (
    ///         clip, source, source_outpoint, &error);
    ///   // handle error
    ///
    ///   if (!ges_timeline_elemnet_edit_full (GES_TIMELINE_ELEMENT (clip),
    ///         -1, GES_EDIT_MODE_TRIM, GES_EDGE_END, new_end, &error))
    ///     // handle error
    ///
    ///   for (tmp = children; tmp; tmp = tmp->next)
    ///     ges_track_element_set_auto_clamp_control_source (tmp->data, TRUE);
    ///
    ///   g_list_free_full (children, gst_object_unref);
    ///   gst_object_unref (source);
    /// }
    /// ```
    ///
    /// This is an Abstract Base Class, you cannot instantiate it.
    ///
    /// # Implements
    ///
    /// [`trait@crate::prelude::ClipExt`], [`trait@crate::prelude::GESContainerExt`], [`trait@crate::prelude::TimelineElementExt`], [`trait@glib::object::ObjectExt`], [`trait@crate::prelude::ExtractableExt`], [`trait@crate::prelude::TimelineElementExtManual`]
    pub struct Clip(Object<ffi::GESClip, ffi::GESClipClass>) @extends Container, TimelineElement, @implements Extractable;

    match fn {
        type_ => || ffi::ges_clip_get_type(),
    }
}

pub const NONE_CLIP: Option<&Clip> = None;

/// Trait containing all `Clip` methods.
///
/// # Implementors
///
/// [`struct@crate::Clip`], [`struct@crate::OperationClip`]
pub trait ClipExt: 'static {
    /// Extracts a [`crate::TrackElement`] from an asset and adds it to the clip.
    /// This can be used to add effects that derive from the asset to the
    /// clip, but this method is not intended to be used to create the core
    /// elements of the clip.
    /// ## `asset`
    /// An asset with `GES_TYPE_TRACK_ELEMENT` as its
    /// [`crate::Asset:extractable-type`]
    ///
    /// # Returns
    ///
    /// The newly created element, or
    /// [`None`] if an error occurred.
    #[doc(alias = "ges_clip_add_asset")]
    fn add_asset<P: IsA<Asset>>(&self, asset: &P) -> Result<TrackElement, glib::BoolError>;

    /// Adds the track element child of the clip to a specific track.
    ///
    /// If the given child is already in another track, this will create a copy
    /// of the child, add it to the clip, and add this copy to the track.
    ///
    /// You should only call this whilst a clip is part of a [`crate::Timeline`], and
    /// for tracks that are in the same timeline.
    ///
    /// This method is an alternative to using the
    /// [`crate::Timeline::select-tracks-for-object`] signal, but can be used to
    /// complement it when, say, you wish to copy a clip's children from one
    /// track into a new one.
    ///
    /// When the child is a core child, it must be added to a track that does
    /// not already contain another core child of the same clip. If it is not a
    /// core child (an additional effect), then it must be added to a track
    /// that already contains one of the core children of the same clip.
    ///
    /// This method can also fail if the adding the track element to the track
    /// would break a configuration rule of the corresponding [`crate::Timeline`],
    /// such as causing three sources to overlap at a single time, or causing
    /// a source to completely overlap another in the same track.
    /// ## `child`
    /// A child of `self`
    /// ## `track`
    /// The track to add `child` to
    ///
    /// # Returns
    ///
    /// The element that was added to `track`, either
    /// `child` or a copy of child, or [`None`] if the element could not be added.
    #[cfg(any(feature = "v1_18", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
    #[doc(alias = "ges_clip_add_child_to_track")]
    fn add_child_to_track<P: IsA<TrackElement>, Q: IsA<Track>>(
        &self,
        child: &P,
        track: &Q,
    ) -> Result<TrackElement, glib::Error>;

    /// Add a top effect to a clip at the given index.
    ///
    /// Unlike using [`crate::prelude::GESContainerExt::add()`], this allows you to set the index
    /// in advance. It will also check that no error occurred during the track
    /// selection for the effect.
    ///
    /// Note, only subclasses of [`crate::ClipClass`] that have
    /// `GES_CLIP_CLASS_CAN_ADD_EFFECTS` set to [`true`] (such as [`crate::SourceClip`]
    /// and [`crate::BaseEffectClip`]) can have additional top effects added.
    ///
    /// Note, if the effect is a time effect, this may be refused if the clip
    /// would not be able to adapt itself once the effect is added.
    /// ## `effect`
    /// A top effect to add
    /// ## `index`
    /// The index to add `effect` at, or -1 to add at the highest
    ///
    /// # Returns
    ///
    /// [`true`] if `effect` was successfully added to `self` at `index`.
    #[cfg(any(feature = "v1_18", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
    #[doc(alias = "ges_clip_add_top_effect")]
    fn add_top_effect<P: IsA<BaseEffect>>(&self, effect: &P, index: i32)
        -> Result<(), glib::Error>;

    /// Finds an element controlled by the clip. If `track` is given,
    /// then only the track elements in `track` are searched for. If `type_` is
    /// given, then this function searches for a track element of the given
    /// `type_`.
    ///
    /// Note, if multiple track elements in the clip match the given criteria,
    /// this will return the element amongst them with the highest
    /// [`crate::TimelineElement:priority`] (numerically, the smallest). See
    /// [`Self::find_track_elements()`] if you wish to find all such elements.
    /// ## `track`
    /// The track to search in, or [`None`] to search in
    /// all tracks
    /// ## `type_`
    /// The type of track element to search for, or `G_TYPE_NONE` to
    /// match any type
    ///
    /// # Returns
    ///
    /// The element controlled by
    /// `self`, in `track`, and of the given `type_`, or [`None`] if no such element
    /// could be found.
    #[doc(alias = "ges_clip_find_track_element")]
    fn find_track_element<P: IsA<Track>>(
        &self,
        track: Option<&P>,
        type_: glib::types::Type,
    ) -> Option<TrackElement>;

    /// Finds the [`crate::TrackElement`]-s controlled by the clip that match the
    /// given criteria. If `track` is given as [`None`] and `track_type` is given as
    /// [`crate::TrackType::Unknown`], then the search will match all elements in any
    /// track, including those with no track, and of any
    /// [`crate::TrackElement:track-type`]. Otherwise, if `track` is not [`None`], but
    /// `track_type` is [`crate::TrackType::Unknown`], then only the track elements in
    /// `track` are searched for. Otherwise, if `track_type` is not
    /// [`crate::TrackType::Unknown`], but `track` is [`None`], then only the track
    /// elements whose [`crate::TrackElement:track-type`] matches `track_type` are
    /// searched for. Otherwise, when both are given, the track elements that
    /// match **either** criteria are searched for. Therefore, if you wish to
    /// only find elements in a specific track, you should give the track as
    /// `track`, but you should not give the track's [`crate::Track:track-type`] as
    /// `track_type` because this would also select elements from other tracks
    /// of the same type.
    ///
    /// You may also give `type_` to _further_ restrict the search to track
    /// elements of the given `type_`.
    /// ## `track`
    /// The track to search in, or [`None`] to search in
    /// all tracks
    /// ## `track_type`
    /// The track-type of the track element to search for, or
    /// [`crate::TrackType::Unknown`] to match any track type
    /// ## `type_`
    /// The type of track element to search for, or `G_TYPE_NONE` to
    /// match any type
    ///
    /// # Returns
    ///
    /// A list of all
    /// the [`crate::TrackElement`]-s controlled by `self`, in `track` or of the given
    /// `track_type`, and of the given `type_`.
    #[doc(alias = "ges_clip_find_track_elements")]
    fn find_track_elements<P: IsA<Track>>(
        &self,
        track: Option<&P>,
        track_type: TrackType,
        type_: glib::types::Type,
    ) -> Vec<TrackElement>;

    /// Gets the [`crate::Clip:duration-limit`] of the clip.
    ///
    /// # Returns
    ///
    /// The duration-limit of `self`.
    #[cfg(any(feature = "v1_18", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
    #[doc(alias = "ges_clip_get_duration_limit")]
    #[doc(alias = "get_duration_limit")]
    fn duration_limit(&self) -> gst::ClockTime;

    /// Convert the timeline time to an internal source time of the child.
    /// This will take any time effects placed on the clip into account (see
    /// [`crate::BaseEffect`] for what time effects are supported, and how to
    /// declare them in GES).
    ///
    /// When `timeline_time` is above the [`crate::TimelineElement:start`] of `self`,
    /// this will return the internal time at which the content that appears at
    /// `timeline_time` in the output of the timeline is created in `child`. For
    /// example, if `timeline_time` corresponds to the current seek position,
    /// this would let you know which part of a media file is being read.
    ///
    /// This will be done assuming the clip has an indefinite end, so the
    /// internal time may be beyond the current out-point of the child, or even
    /// its [`crate::TimelineElement:max-duration`].
    ///
    /// If, instead, `timeline_time` is below the current
    /// [`crate::TimelineElement:start`] of `self`, this will return what you would
    /// need to set the [`crate::TimelineElement:in-point`] of `child` to if you set
    /// the [`crate::TimelineElement:start`] of `self` to `timeline_time` and wanted
    /// to keep the content of `child` currently found at the current
    /// [`crate::TimelineElement:start`] of `self` at the same timeline position. If
    /// this would be negative, the conversion fails. This is useful for
    /// determining what [`crate::TimelineElement:in-point`] would result from a
    /// [`crate::EditMode::Trim`] to `timeline_time`.
    ///
    /// Note that whilst a clip has no time effects, this second return is
    /// equivalent to finding the internal time at which the content that
    /// appears at `timeline_time` in the timeline can be found in `child` if it
    /// had indefinite extent in both directions. However, with non-linear time
    /// effects this second return will be more distinct.
    ///
    /// In either case, the returned time would be appropriate to use for the
    /// [`crate::TimelineElement:in-point`] or [`crate::TimelineElement:max-duration`] of the
    /// child.
    ///
    /// See [`Self::get_timeline_time_from_internal_time()`], which performs the
    /// reverse.
    /// ## `child`
    /// An [`crate::TrackElement:active`] child of `self` with a
    /// [`crate::TrackElement:track`]
    /// ## `timeline_time`
    /// A time in the timeline time coordinates
    ///
    /// # Returns
    ///
    /// The time in the internal coordinates of `child` corresponding
    /// to `timeline_time`, or `GST_CLOCK_TIME_NONE` if the conversion could not
    /// be performed.
    #[cfg(any(feature = "v1_18", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
    #[doc(alias = "ges_clip_get_internal_time_from_timeline_time")]
    #[doc(alias = "get_internal_time_from_timeline_time")]
    fn internal_time_from_timeline_time<P: IsA<TrackElement>>(
        &self,
        child: &P,
        timeline_time: gst::ClockTime,
    ) -> Result<gst::ClockTime, glib::Error>;

    /// Gets the [`crate::Clip:layer`] of the clip.
    ///
    /// # Returns
    ///
    /// The layer `self` is in, or [`None`] if
    /// `self` is not in any layer.
    #[doc(alias = "ges_clip_get_layer")]
    #[doc(alias = "get_layer")]
    fn layer(&self) -> Option<Layer>;

    /// Gets the [`crate::Clip:supported-formats`] of the clip.
    ///
    /// # Returns
    ///
    /// The [`crate::TrackType`]-s supported by `self`.
    #[doc(alias = "ges_clip_get_supported_formats")]
    #[doc(alias = "get_supported_formats")]
    fn supported_formats(&self) -> TrackType;

    /// Convert the internal source time from the child to a timeline time.
    /// This will take any time effects placed on the clip into account (see
    /// [`crate::BaseEffect`] for what time effects are supported, and how to
    /// declare them in GES).
    ///
    /// When `internal_time` is above the [`crate::TimelineElement:in-point`] of
    /// `child`, this will return the timeline time at which the internal
    /// content found at `internal_time` appears in the output of the timeline's
    /// track. For example, this would let you know where in the timeline a
    /// particular scene in a media file would appear.
    ///
    /// This will be done assuming the clip has an indefinite end, so the
    /// timeline time may be beyond the end of the clip, or even breaking its
    /// [`crate::Clip:duration-limit`].
    ///
    /// If, instead, `internal_time` is below the current
    /// [`crate::TimelineElement:in-point`] of `child`, this will return what you would
    /// need to set the [`crate::TimelineElement:start`] of `self` to if you set the
    /// [`crate::TimelineElement:in-point`] of `child` to `internal_time` and wanted to
    /// keep the content of `child` currently found at the current
    /// [`crate::TimelineElement:start`] of `self` at the same timeline position. If
    /// this would be negative, the conversion fails. This is useful for
    /// determining what position to use in a [`crate::EditMode::Trim`] if you wish
    /// to trim to a specific point in the internal content, such as a
    /// particular scene in a media file.
    ///
    /// Note that whilst a clip has no time effects, this second return is
    /// equivalent to finding the timeline time at which the content of `child`
    /// at `internal_time` would be found in the timeline if it had indefinite
    /// extent in both directions. However, with non-linear time effects this
    /// second return will be more distinct.
    ///
    /// In either case, the returned time would be appropriate to use in
    /// [`crate::prelude::TimelineElementExt::edit()`] for [`crate::EditMode::Trim`], and similar, if
    /// you wish to use a particular internal point as a reference. For
    /// example, you could choose to end a clip at a certain internal
    /// 'out-point', similar to the [`crate::TimelineElement:in-point`], by
    /// translating the desired end time into the timeline coordinates, and
    /// using this position to trim the end of a clip.
    ///
    /// See [`Self::get_internal_time_from_timeline_time()`], which performs the
    /// reverse, or [`Self::get_timeline_time_from_source_frame()`] which does
    /// the same conversion, but using frame numbers.
    /// ## `child`
    /// An [`crate::TrackElement:active`] child of `self` with a
    /// [`crate::TrackElement:track`]
    /// ## `internal_time`
    /// A time in the internal time coordinates of `child`
    ///
    /// # Returns
    ///
    /// The time in the timeline coordinates corresponding to
    /// `internal_time`, or `GST_CLOCK_TIME_NONE` if the conversion could not be
    /// performed.
    #[cfg(any(feature = "v1_18", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
    #[doc(alias = "ges_clip_get_timeline_time_from_internal_time")]
    #[doc(alias = "get_timeline_time_from_internal_time")]
    fn timeline_time_from_internal_time<P: IsA<TrackElement>>(
        &self,
        child: &P,
        internal_time: gst::ClockTime,
    ) -> Result<gst::ClockTime, glib::Error>;

    /// Convert the source frame number to a timeline time. This acts the same
    /// as [`Self::get_timeline_time_from_internal_time()`] using the core
    /// children of the clip and using the frame number to specify the internal
    /// position, rather than a timestamp.
    ///
    /// The returned timeline time can be used to seek or edit to a specific
    /// frame.
    ///
    /// Note that you can get the frame timestamp of a particular clip asset
    /// with [`crate::ClipAsset::get_frame_time()`].
    /// ## `frame_number`
    /// The frame number to get the corresponding timestamp of
    /// in the timeline coordinates
    ///
    /// # Returns
    ///
    /// The timestamp corresponding to `frame_number` in the core
    /// children of `self`, in the timeline coordinates, or `GST_CLOCK_TIME_NONE`
    /// if the conversion could not be performed.
    #[cfg(any(feature = "v1_18", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
    #[doc(alias = "ges_clip_get_timeline_time_from_source_frame")]
    #[doc(alias = "get_timeline_time_from_source_frame")]
    fn timeline_time_from_source_frame(
        &self,
        frame_number: FrameNumber,
    ) -> Result<gst::ClockTime, glib::Error>;

    /// Gets the internal index of an effect in the clip. The index of effects
    /// in a clip will run from 0 to n-1, where n is the total number of
    /// effects. If two effects share the same [`crate::TrackElement:track`], the
    /// effect with the numerically lower index will be applied to the source
    /// data **after** the other effect, i.e. output data will always flow from
    /// a higher index effect to a lower index effect.
    /// ## `effect`
    /// The effect we want to get the index of
    ///
    /// # Returns
    ///
    /// The index of `effect` in `self`, or -1 if something went wrong.
    #[doc(alias = "ges_clip_get_top_effect_index")]
    #[doc(alias = "get_top_effect_index")]
    fn top_effect_index<P: IsA<BaseEffect>>(&self, effect: &P) -> i32;

    #[doc(alias = "ges_clip_get_top_effect_position")]
    #[doc(alias = "get_top_effect_position")]
    fn top_effect_position<P: IsA<BaseEffect>>(&self, effect: &P) -> i32;

    /// Gets the [`crate::BaseEffect`]-s that have been added to the clip. The
    /// returned list is ordered by their internal index in the clip. See
    /// [`Self::get_top_effect_index()`].
    ///
    /// # Returns
    ///
    /// A list of all
    /// [`crate::BaseEffect`]-s that have been added to `self`.
    #[doc(alias = "ges_clip_get_top_effects")]
    #[doc(alias = "get_top_effects")]
    fn top_effects(&self) -> Vec<TrackElement>;

    /// See [`Self::move_to_layer_full()`], which also gives an error.
    /// ## `layer`
    /// The new layer
    ///
    /// # Returns
    ///
    /// [`true`] if `self` was successfully moved to `layer`.
    #[doc(alias = "ges_clip_move_to_layer")]
    fn move_to_layer<P: IsA<Layer>>(&self, layer: &P) -> Result<(), glib::error::BoolError>;

    /// Moves a clip to a new layer. If the clip already exists in a layer, it
    /// is first removed from its current layer before being added to the new
    /// layer.
    /// ## `layer`
    /// The new layer
    ///
    /// # Returns
    ///
    /// [`true`] if `self` was successfully moved to `layer`.
    #[cfg(any(feature = "v1_18", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
    #[doc(alias = "ges_clip_move_to_layer_full")]
    fn move_to_layer_full<P: IsA<Layer>>(&self, layer: &P) -> Result<(), glib::Error>;

    /// Remove a top effect from the clip.
    ///
    /// Note, if the effect is a time effect, this may be refused if the clip
    /// would not be able to adapt itself once the effect is removed.
    /// ## `effect`
    /// The top effect to remove
    ///
    /// # Returns
    ///
    /// [`true`] if `effect` was successfully added to `self` at `index`.
    #[cfg(any(feature = "v1_18", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
    #[doc(alias = "ges_clip_remove_top_effect")]
    fn remove_top_effect<P: IsA<BaseEffect>>(&self, effect: &P) -> Result<(), glib::Error>;

    /// Sets the [`crate::Clip:supported-formats`] of the clip. This should normally
    /// only be called by subclasses, which should be responsible for updating
    /// its value, rather than the user.
    /// ## `supportedformats`
    /// The [`crate::TrackType`]-s supported by `self`
    #[doc(alias = "ges_clip_set_supported_formats")]
    fn set_supported_formats(&self, supportedformats: TrackType);

    /// See [`Self::set_top_effect_index_full()`], which also gives an error.
    /// ## `effect`
    /// An effect within `self` to move
    /// ## `newindex`
    /// The index for `effect` in `self`
    ///
    /// # Returns
    ///
    /// [`true`] if `effect` was successfully moved to `newindex`.
    #[doc(alias = "ges_clip_set_top_effect_index")]
    fn set_top_effect_index<P: IsA<BaseEffect>>(
        &self,
        effect: &P,
        newindex: u32,
    ) -> Result<(), glib::error::BoolError>;

    /// Set the index of an effect within the clip. See
    /// [`Self::get_top_effect_index()`]. The new index must be an existing
    /// index of the clip. The effect is moved to the new index, and the other
    /// effects may be shifted in index accordingly to otherwise maintain the
    /// ordering.
    /// ## `effect`
    /// An effect within `self` to move
    /// ## `newindex`
    /// The index for `effect` in `self`
    ///
    /// # Returns
    ///
    /// [`true`] if `effect` was successfully moved to `newindex`.
    #[cfg(any(feature = "v1_18", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
    #[doc(alias = "ges_clip_set_top_effect_index_full")]
    fn set_top_effect_index_full<P: IsA<BaseEffect>>(
        &self,
        effect: &P,
        newindex: u32,
    ) -> Result<(), glib::Error>;

    #[doc(alias = "ges_clip_set_top_effect_priority")]
    fn set_top_effect_priority<P: IsA<BaseEffect>>(
        &self,
        effect: &P,
        newpriority: u32,
    ) -> Result<(), glib::error::BoolError>;

    /// See [`Self::split_full()`], which also gives an error.
    /// ## `position`
    /// The timeline position at which to perform the split
    ///
    /// # Returns
    ///
    /// The newly created clip resulting
    /// from the splitting `self`, or [`None`] if `self` can't be split.
    #[doc(alias = "ges_clip_split")]
    fn split(&self, position: u64) -> Result<Clip, glib::BoolError>;

    /// Splits a clip at the given timeline position into two clips. The clip
    /// must already have a [`crate::Clip:layer`].
    ///
    /// The original clip's [`crate::TimelineElement:duration`] is reduced such that
    /// its end point matches the split position. Then a new clip is created in
    /// the same layer, whose [`crate::TimelineElement:start`] matches the split
    /// position and [`crate::TimelineElement:duration`] will be set such that its end
    /// point matches the old end point of the original clip. Thus, the two
    /// clips together will occupy the same positions in the timeline as the
    /// original clip did.
    ///
    /// The children of the new clip will be new copies of the original clip's
    /// children, so it will share the same sources and use the same
    /// operations.
    ///
    /// The new clip will also have its [`crate::TimelineElement:in-point`] set so
    /// that any internal data will appear in the timeline at the same time.
    /// Thus, when the timeline is played, the playback of data should
    /// appear the same. This may be complicated by any additional
    /// [`crate::Effect`]-s that have been placed on the original clip that depend on
    /// the playback time or change the data consumption rate of sources. This
    /// method will attempt to translate these effects such that the playback
    /// appears the same. In such complex situations, you may get a better
    /// result if you place the clip in a separate sub [`crate::Project`], which only
    /// contains this clip (and its effects), and in the original layer
    /// create two neighbouring [`crate::UriClip`]-s that reference this sub-project,
    /// but at a different [`crate::TimelineElement:in-point`].
    /// ## `position`
    /// The timeline position at which to perform the split, between
    /// the start and end of the clip
    ///
    /// # Returns
    ///
    /// The newly created clip resulting
    /// from the splitting `self`, or [`None`] if `self` can't be split.
    #[cfg(any(feature = "v1_18", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
    #[doc(alias = "ges_clip_split_full")]
    fn split_full(&self, position: u64) -> Result<Option<Clip>, glib::Error>;

    #[cfg(any(feature = "v1_18", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
    #[doc(alias = "duration-limit")]
    fn connect_duration_limit_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;

    #[doc(alias = "layer")]
    fn connect_layer_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;

    #[doc(alias = "supported-formats")]
    fn connect_supported_formats_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
}

impl<O: IsA<Clip>> ClipExt for O {
    fn add_asset<P: IsA<Asset>>(&self, asset: &P) -> Result<TrackElement, glib::BoolError> {
        unsafe {
            Option::<_>::from_glib_none(ffi::ges_clip_add_asset(
                self.as_ref().to_glib_none().0,
                asset.as_ref().to_glib_none().0,
            ))
            .ok_or_else(|| glib::bool_error!("Failed to add asset"))
        }
    }

    #[cfg(any(feature = "v1_18", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
    fn add_child_to_track<P: IsA<TrackElement>, Q: IsA<Track>>(
        &self,
        child: &P,
        track: &Q,
    ) -> Result<TrackElement, glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let ret = ffi::ges_clip_add_child_to_track(
                self.as_ref().to_glib_none().0,
                child.as_ref().to_glib_none().0,
                track.as_ref().to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_none(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    #[cfg(any(feature = "v1_18", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
    fn add_top_effect<P: IsA<BaseEffect>>(
        &self,
        effect: &P,
        index: i32,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let _ = ffi::ges_clip_add_top_effect(
                self.as_ref().to_glib_none().0,
                effect.as_ref().to_glib_none().0,
                index,
                &mut error,
            );
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    fn find_track_element<P: IsA<Track>>(
        &self,
        track: Option<&P>,
        type_: glib::types::Type,
    ) -> Option<TrackElement> {
        unsafe {
            from_glib_full(ffi::ges_clip_find_track_element(
                self.as_ref().to_glib_none().0,
                track.map(|p| p.as_ref()).to_glib_none().0,
                type_.into_glib(),
            ))
        }
    }

    fn find_track_elements<P: IsA<Track>>(
        &self,
        track: Option<&P>,
        track_type: TrackType,
        type_: glib::types::Type,
    ) -> Vec<TrackElement> {
        unsafe {
            FromGlibPtrContainer::from_glib_full(ffi::ges_clip_find_track_elements(
                self.as_ref().to_glib_none().0,
                track.map(|p| p.as_ref()).to_glib_none().0,
                track_type.into_glib(),
                type_.into_glib(),
            ))
        }
    }

    #[cfg(any(feature = "v1_18", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
    fn duration_limit(&self) -> gst::ClockTime {
        unsafe {
            from_glib(ffi::ges_clip_get_duration_limit(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[cfg(any(feature = "v1_18", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
    fn internal_time_from_timeline_time<P: IsA<TrackElement>>(
        &self,
        child: &P,
        timeline_time: gst::ClockTime,
    ) -> Result<gst::ClockTime, glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let ret = ffi::ges_clip_get_internal_time_from_timeline_time(
                self.as_ref().to_glib_none().0,
                child.as_ref().to_glib_none().0,
                timeline_time.into_glib(),
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    fn layer(&self) -> Option<Layer> {
        unsafe { from_glib_full(ffi::ges_clip_get_layer(self.as_ref().to_glib_none().0)) }
    }

    fn supported_formats(&self) -> TrackType {
        unsafe {
            from_glib(ffi::ges_clip_get_supported_formats(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[cfg(any(feature = "v1_18", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
    fn timeline_time_from_internal_time<P: IsA<TrackElement>>(
        &self,
        child: &P,
        internal_time: gst::ClockTime,
    ) -> Result<gst::ClockTime, glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let ret = ffi::ges_clip_get_timeline_time_from_internal_time(
                self.as_ref().to_glib_none().0,
                child.as_ref().to_glib_none().0,
                internal_time.into_glib(),
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    #[cfg(any(feature = "v1_18", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
    fn timeline_time_from_source_frame(
        &self,
        frame_number: FrameNumber,
    ) -> Result<gst::ClockTime, glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let ret = ffi::ges_clip_get_timeline_time_from_source_frame(
                self.as_ref().to_glib_none().0,
                frame_number,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    fn top_effect_index<P: IsA<BaseEffect>>(&self, effect: &P) -> i32 {
        unsafe {
            ffi::ges_clip_get_top_effect_index(
                self.as_ref().to_glib_none().0,
                effect.as_ref().to_glib_none().0,
            )
        }
    }

    fn top_effect_position<P: IsA<BaseEffect>>(&self, effect: &P) -> i32 {
        unsafe {
            ffi::ges_clip_get_top_effect_position(
                self.as_ref().to_glib_none().0,
                effect.as_ref().to_glib_none().0,
            )
        }
    }

    fn top_effects(&self) -> Vec<TrackElement> {
        unsafe {
            FromGlibPtrContainer::from_glib_full(ffi::ges_clip_get_top_effects(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn move_to_layer<P: IsA<Layer>>(&self, layer: &P) -> Result<(), glib::error::BoolError> {
        unsafe {
            glib::result_from_gboolean!(
                ffi::ges_clip_move_to_layer(
                    self.as_ref().to_glib_none().0,
                    layer.as_ref().to_glib_none().0
                ),
                "Failed to move clip to specified layer"
            )
        }
    }

    #[cfg(any(feature = "v1_18", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
    fn move_to_layer_full<P: IsA<Layer>>(&self, layer: &P) -> Result<(), glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let _ = ffi::ges_clip_move_to_layer_full(
                self.as_ref().to_glib_none().0,
                layer.as_ref().to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    #[cfg(any(feature = "v1_18", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
    fn remove_top_effect<P: IsA<BaseEffect>>(&self, effect: &P) -> Result<(), glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let _ = ffi::ges_clip_remove_top_effect(
                self.as_ref().to_glib_none().0,
                effect.as_ref().to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    fn set_supported_formats(&self, supportedformats: TrackType) {
        unsafe {
            ffi::ges_clip_set_supported_formats(
                self.as_ref().to_glib_none().0,
                supportedformats.into_glib(),
            );
        }
    }

    fn set_top_effect_index<P: IsA<BaseEffect>>(
        &self,
        effect: &P,
        newindex: u32,
    ) -> Result<(), glib::error::BoolError> {
        unsafe {
            glib::result_from_gboolean!(
                ffi::ges_clip_set_top_effect_index(
                    self.as_ref().to_glib_none().0,
                    effect.as_ref().to_glib_none().0,
                    newindex
                ),
                "Failed to move effect"
            )
        }
    }

    #[cfg(any(feature = "v1_18", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
    fn set_top_effect_index_full<P: IsA<BaseEffect>>(
        &self,
        effect: &P,
        newindex: u32,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let _ = ffi::ges_clip_set_top_effect_index_full(
                self.as_ref().to_glib_none().0,
                effect.as_ref().to_glib_none().0,
                newindex,
                &mut error,
            );
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    fn set_top_effect_priority<P: IsA<BaseEffect>>(
        &self,
        effect: &P,
        newpriority: u32,
    ) -> Result<(), glib::error::BoolError> {
        unsafe {
            glib::result_from_gboolean!(
                ffi::ges_clip_set_top_effect_priority(
                    self.as_ref().to_glib_none().0,
                    effect.as_ref().to_glib_none().0,
                    newpriority
                ),
                "Failed to the set top effect priority"
            )
        }
    }

    fn split(&self, position: u64) -> Result<Clip, glib::BoolError> {
        unsafe {
            Option::<_>::from_glib_none(ffi::ges_clip_split(
                self.as_ref().to_glib_none().0,
                position,
            ))
            .ok_or_else(|| glib::bool_error!("Failed to split clip"))
        }
    }

    #[cfg(any(feature = "v1_18", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
    fn split_full(&self, position: u64) -> Result<Option<Clip>, glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let ret =
                ffi::ges_clip_split_full(self.as_ref().to_glib_none().0, position, &mut error);
            if error.is_null() {
                Ok(from_glib_none(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    #[cfg(any(feature = "v1_18", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_18")))]
    #[doc(alias = "duration-limit")]
    fn connect_duration_limit_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_duration_limit_trampoline<P, F: Fn(&P) + 'static>(
            this: *mut ffi::GESClip,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) where
            P: IsA<Clip>,
        {
            let f: &F = &*(f as *const F);
            f(&Clip::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::duration-limit\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_duration_limit_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "layer")]
    fn connect_layer_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_layer_trampoline<P, F: Fn(&P) + 'static>(
            this: *mut ffi::GESClip,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) where
            P: IsA<Clip>,
        {
            let f: &F = &*(f as *const F);
            f(&Clip::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::layer\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_layer_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "supported-formats")]
    fn connect_supported_formats_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_supported_formats_trampoline<P, F: Fn(&P) + 'static>(
            this: *mut ffi::GESClip,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) where
            P: IsA<Clip>,
        {
            let f: &F = &*(f as *const F);
            f(&Clip::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::supported-formats\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_supported_formats_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}