gstreamer_editing_services/auto/

timeline_element.rs

// 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
#![allow(deprecated)]

#[cfg(feature = "v1_18")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
use crate::{Edge, EditMode, Layer};
use crate::{Extractable, MetaContainer, Timeline, TrackType, ffi};
use glib::{
    object::ObjectType as _,
    prelude::*,
    signal::{SignalHandlerId, connect_raw},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    /// A [`TimelineElement`][crate::TimelineElement] will have some temporal extent in its
    /// corresponding [`timeline`][struct@crate::TimelineElement#timeline], controlled by its
    /// [`start`][struct@crate::TimelineElement#start] and [`duration`][struct@crate::TimelineElement#duration]. This
    /// determines when its content will be displayed, or its effect applied,
    /// in the timeline. Several objects may overlap within a given
    /// [`Timeline`][crate::Timeline], in which case their [`priority`][struct@crate::TimelineElement#priority] is used
    /// to determine their ordering in the timeline. Priority is mostly handled
    /// internally by [`Layer`][crate::Layer]-s and [`Clip`][crate::Clip]-s.
    ///
    /// A timeline element can have a [`parent`][struct@crate::TimelineElement#parent],
    /// such as a [`Clip`][crate::Clip], which is responsible for controlling its timing.
    ///
    /// ## Editing
    ///
    /// Elements can be moved around in their [`timeline`][struct@crate::TimelineElement#timeline] by
    /// setting their [`start`][struct@crate::TimelineElement#start] and
    /// [`duration`][struct@crate::TimelineElement#duration] using [`TimelineElementExt::set_start()`][crate::prelude::TimelineElementExt::set_start()]
    /// and [`TimelineElementExt::set_duration()`][crate::prelude::TimelineElementExt::set_duration()]. Additionally, which parts of
    /// the underlying content are played in the timeline can be adjusted by
    /// setting the [`in-point`][struct@crate::TimelineElement#in-point] using
    /// [`TimelineElementExt::set_inpoint()`][crate::prelude::TimelineElementExt::set_inpoint()]. The library also provides
    /// [`TimelineElementExt::edit()`][crate::prelude::TimelineElementExt::edit()], with various [`EditMode`][crate::EditMode]-s, which can
    /// adjust these properties in a convenient way, as well as introduce
    /// similar changes in neighbouring or later elements in the timeline.
    ///
    /// However, a timeline may refuse a change in these properties if they
    /// would place the timeline in an unsupported configuration. See
    /// [`Timeline`][crate::Timeline] for its overlap rules.
    ///
    /// Additionally, an edit may be refused if it would place one of the
    /// timing properties out of bounds (such as a negative time value for
    /// [`start`][struct@crate::TimelineElement#start], or having insufficient internal
    /// content to last for the desired [`duration`][struct@crate::TimelineElement#duration]).
    ///
    /// ## Time Coordinates
    ///
    /// There are three main sets of time coordinates to consider when using
    /// timeline elements:
    ///
    /// + Timeline coordinates: these are the time coordinates used in the
    ///  output of the timeline in its [`Track`][crate::Track]-s. Each track share the same
    ///  coordinates, so there is only one set of coordinates for the
    ///  timeline. These extend indefinitely from 0. The times used for
    ///  editing (including setting [`start`][struct@crate::TimelineElement#start] and
    ///  [`duration`][struct@crate::TimelineElement#duration]) use these coordinates, since these
    ///  define when an element is present and for how long the element lasts
    ///  for in the timeline.
    /// + Internal source coordinates: these are the time coordinates used
    ///  internally at the element's output. This is only really defined for
    ///  [`TrackElement`][crate::TrackElement]-s, where it refers to time coordinates used at the
    ///  final source pad of the wrapped [`gst::Element`][crate::gst::Element]-s. However, these
    ///  coordinates may also be used in a [`Clip`][crate::Clip] in reference to its
    ///  children. In particular, these are the coordinates used for
    ///  [`in-point`][struct@crate::TimelineElement#in-point] and [`max-duration`][struct@crate::TimelineElement#max-duration].
    /// + Internal sink coordinates: these are the time coordinates used
    ///  internally at the element's input. A [`Source`][crate::Source] has no input, so
    ///  these would be undefined. Otherwise, for most [`TrackElement`][crate::TrackElement]-s
    ///  these will be the same set of coordinates as the internal source
    ///  coordinates because the element does not change the timing
    ///  internally. Only [`BaseEffect`][crate::BaseEffect] can support elements where these
    ///  are different. See [`BaseEffect`][crate::BaseEffect] for more information.
    ///
    /// You can determine the timeline time for a given internal source time
    /// in a [`Track`][crate::Track] in a [`Clip`][crate::Clip] using
    /// [`ClipExt::timeline_time_from_internal_time()`][crate::prelude::ClipExt::timeline_time_from_internal_time()], and vice versa using
    /// [`ClipExt::internal_time_from_timeline_time()`][crate::prelude::ClipExt::internal_time_from_timeline_time()], for the purposes of
    /// editing and setting timings properties.
    ///
    /// ## Children Properties
    ///
    /// If a timeline element owns another [`gst::Object`][crate::gst::Object] and wishes to expose
    /// some of its properties, it can do so by registering the property as one
    /// of the timeline element's children properties using
    /// [`TimelineElementExt::add_child_property()`][crate::prelude::TimelineElementExt::add_child_property()]. The registered property of
    /// the child can then be read and set using the
    /// [`TimelineElementExt::child_property()`][crate::prelude::TimelineElementExt::child_property()] and
    /// [`TimelineElementExtManual::set_child_property()`][crate::prelude::TimelineElementExtManual::set_child_property()] methods, respectively. Some
    /// sub-classed objects will be created with pre-registered children
    /// properties; for example, to expose part of an underlying [`gst::Element`][crate::gst::Element]
    /// that is used internally. The registered properties can be listed with
    /// [`TimelineElementExt::list_children_properties()`][crate::prelude::TimelineElementExt::list_children_properties()].
    ///
    /// This is an Abstract Base Class, you cannot instantiate it.
    ///
    /// ## Properties
    ///
    ///
    /// #### `duration`
    ///  The duration that the element is in effect for in the timeline (a
    /// time difference in nanoseconds using the time coordinates of the
    /// timeline). For example, for a source element, this would determine
    /// for how long it should output its internal content for. For an
    /// operation element, this would determine for how long its effect
    /// should be applied to any source content.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `in-point`
    ///  The initial offset to use internally when outputting content (in
    /// nanoseconds, but in the time coordinates of the internal content).
    ///
    /// For example, for a [`VideoUriSource`][crate::VideoUriSource] that references some media
    /// file, the "internal content" is the media file data, and the
    /// in-point would correspond to some timestamp in the media file.
    /// When playing the timeline, and when the element is first reached at
    /// timeline-time [`start`][struct@crate::TimelineElement#start], it will begin outputting the
    /// data from the timestamp in-point **onwards**, until it reaches the
    /// end of its [`duration`][struct@crate::TimelineElement#duration] in the timeline.
    ///
    /// For elements that have no internal content, this should be kept
    /// as 0.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `max-duration`
    ///  The full duration of internal content that is available (a time
    /// difference in nanoseconds using the time coordinates of the internal
    /// content).
    ///
    /// This will act as a cap on the [`in-point`][struct@crate::TimelineElement#in-point] of the
    /// element (which is in the same time coordinates), and will sometimes
    /// be used to limit the [`duration`][struct@crate::TimelineElement#duration] of the element in
    /// the timeline.
    ///
    /// For example, for a [`VideoUriSource`][crate::VideoUriSource] that references some media
    /// file, this would be the length of the media file.
    ///
    /// For elements that have no internal content, or whose content is
    /// indefinite, this should be kept as `GST_CLOCK_TIME_NONE`.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `name`
    ///  The name of the element. This should be unique within its timeline.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `parent`
    ///  The parent container of the element.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `priority`
    ///  The priority of the element.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `serialize`
    ///  Whether the element should be serialized.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `start`
    ///  The starting position of the element in the timeline (in nanoseconds
    /// and in the time coordinates of the timeline). For example, for a
    /// source element, this would determine the time at which it should
    /// start outputting its internal content. For an operation element, this
    /// would determine the time at which it should start applying its effect
    /// to any source content.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `timeline`
    ///  The timeline that the element lies within.
    ///
    /// Readable | Writeable
    ///
    /// ## Signals
    ///
    ///
    /// #### `child-property-added`
    ///  Emitted when the element has a new child property registered. See
    /// [`TimelineElementExt::add_child_property()`][crate::prelude::TimelineElementExt::add_child_property()].
    ///
    /// Note that some GES elements will be automatically created with
    /// pre-registered children properties. You can use
    /// [`TimelineElementExt::list_children_properties()`][crate::prelude::TimelineElementExt::list_children_properties()] to list these.
    ///
    ///
    ///
    ///
    /// #### `child-property-removed`
    ///  Emitted when the element has a child property unregistered. See
    /// [`TimelineElementExt::remove_child_property()`][crate::prelude::TimelineElementExt::remove_child_property()].
    ///
    ///
    ///
    ///
    /// #### `deep-notify`
    ///  Emitted when a child of the element has one of its registered
    /// properties set. See [`TimelineElementExt::add_child_property()`][crate::prelude::TimelineElementExt::add_child_property()].
    /// Note that unlike [`notify`][struct@crate::glib::Object#notify], a child property name can not be
    /// used as a signal detail.
    ///
    /// Detailed
    /// <details><summary><h4>MetaContainer</h4></summary>
    ///
    ///
    /// #### `notify-meta`
    ///  This is emitted for a meta container whenever the metadata under one
    /// of its fields changes, is set for the first time, or is removed. In
    /// the latter case, `value` will be [`None`].
    ///
    /// Detailed
    /// </details>
    ///
    /// # Implements
    ///
    /// [`TimelineElementExt`][trait@crate::prelude::TimelineElementExt], [`trait@glib::ObjectExt`], [`ExtractableExt`][trait@crate::prelude::ExtractableExt], [`MetaContainerExt`][trait@crate::prelude::MetaContainerExt], [`TimelineElementExtManual`][trait@crate::prelude::TimelineElementExtManual]
    #[doc(alias = "GESTimelineElement")]
    pub struct TimelineElement(Object<ffi::GESTimelineElement, ffi::GESTimelineElementClass>) @implements Extractable, MetaContainer;

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

impl TimelineElement {
    pub const NONE: Option<&'static TimelineElement> = None;
}

/// Trait containing all [`struct@TimelineElement`] methods.
///
/// # Implementors
///
/// [`Container`][struct@crate::Container], [`TimelineElement`][struct@crate::TimelineElement], [`TrackElement`][struct@crate::TrackElement]
pub trait TimelineElementExt: IsA<TimelineElement> + 'static {
    /// Register a property of a child of the element to allow it to be
    /// written with [`TimelineElementExtManual::set_child_property()`][crate::prelude::TimelineElementExtManual::set_child_property()] and read with
    /// [`child_property()`][Self::child_property()]. A change in the property
    /// will also appear in the [`deep-notify`][struct@crate::TimelineElement#deep-notify] signal.
    ///
    /// `pspec` should be unique from other children properties that have been
    /// registered on `self`.
    /// ## `pspec`
    /// The specification for the property to add
    /// ## `child`
    /// The [`gst::Object`][crate::gst::Object] who the property belongs to
    ///
    /// # Returns
    ///
    /// [`true`] if the property was successfully registered.
    #[doc(alias = "ges_timeline_element_add_child_property")]
    fn add_child_property(
        &self,
        pspec: impl AsRef<glib::ParamSpec>,
        child: &impl IsA<glib::Object>,
    ) -> Result<(), glib::error::BoolError> {
        unsafe {
            glib::result_from_gboolean!(
                ffi::ges_timeline_element_add_child_property(
                    self.as_ref().to_glib_none().0,
                    pspec.as_ref().to_glib_none().0,
                    child.as_ref().to_glib_none().0
                ),
                "Failed to add child property"
            )
        }
    }

    #[doc(alias = "ges_timeline_element_copy")]
    #[must_use]
    fn copy(&self, deep: bool) -> TimelineElement {
        unsafe {
            from_glib_none(ffi::ges_timeline_element_copy(
                self.as_ref().to_glib_none().0,
                deep.into_glib(),
            ))
        }
    }

    /// See [`edit_full()`][Self::edit_full()], which also gives an error.
    ///
    /// Note that the `layers` argument is currently ignored, so you should
    /// just pass [`None`].
    /// ## `layers`
    /// A whitelist of layers
    /// where the edit can be performed, [`None`] allows all layers in the
    /// timeline.
    /// ## `new_layer_priority`
    /// The priority/index of the layer `self` should be
    /// moved to. -1 means no move
    /// ## `mode`
    /// The edit mode
    /// ## `edge`
    /// The edge of `self` where the edit should occur
    /// ## `position`
    /// The edit position: a new location for the edge of `self`
    /// (in nanoseconds) in the timeline coordinates
    ///
    /// # Returns
    ///
    /// [`true`] if the edit of `self` completed, [`false`] on failure.
    #[cfg(feature = "v1_18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
    #[doc(alias = "ges_timeline_element_edit")]
    fn edit(
        &self,
        layers: &[Layer],
        new_layer_priority: i64,
        mode: EditMode,
        edge: Edge,
        position: u64,
    ) -> bool {
        unsafe {
            from_glib(ffi::ges_timeline_element_edit(
                self.as_ref().to_glib_none().0,
                layers.to_glib_none().0,
                new_layer_priority,
                mode.into_glib(),
                edge.into_glib(),
                position,
            ))
        }
    }

    /// Edits the element within its timeline by adjusting its
    /// [`start`][struct@crate::TimelineElement#start], [`duration`][struct@crate::TimelineElement#duration] or
    /// [`in-point`][struct@crate::TimelineElement#in-point], and potentially doing the same for
    /// other elements in the timeline. See [`EditMode`][crate::EditMode] for details about each
    /// edit mode. An edit may fail if it would place one of these properties
    /// out of bounds, or if it would place the timeline in an unsupported
    /// configuration.
    ///
    /// Note that if you act on a [`TrackElement`][crate::TrackElement], this will edit its parent
    /// [`Clip`][crate::Clip] instead. Moreover, for any [`TimelineElement`][crate::TimelineElement], if you select
    /// [`Edge::None`][crate::Edge::None] for [`EditMode::Normal`][crate::EditMode::Normal] or [`EditMode::Ripple`][crate::EditMode::Ripple], this
    /// will edit the toplevel instead, but still in such a way as to make the
    /// [`start`][struct@crate::TimelineElement#start] of `self` reach the edit `position`.
    ///
    /// Note that if the element's timeline has a
    /// [`snapping-distance`][struct@crate::Timeline#snapping-distance] set, then the edit position may be
    /// snapped to the edge of some element under the edited element.
    ///
    /// `new_layer_priority` can be used to switch `self`, and other elements
    /// moved by the edit, to a new layer. New layers may be be created if the
    /// the corresponding layer priority/index does not yet exist for the
    /// timeline.
    /// ## `new_layer_priority`
    /// The priority/index of the layer `self` should be
    /// moved to. -1 means no move
    /// ## `mode`
    /// The edit mode
    /// ## `edge`
    /// The edge of `self` where the edit should occur
    /// ## `position`
    /// The edit position: a new location for the edge of `self`
    /// (in nanoseconds) in the timeline coordinates
    ///
    /// # Returns
    ///
    /// [`true`] if the edit of `self` completed, [`false`] on failure.
    #[cfg(feature = "v1_18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
    #[doc(alias = "ges_timeline_element_edit_full")]
    fn edit_full(
        &self,
        new_layer_priority: i64,
        mode: EditMode,
        edge: Edge,
        position: u64,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::ges_timeline_element_edit_full(
                self.as_ref().to_glib_none().0,
                new_layer_priority,
                mode.into_glib(),
                edge.into_glib(),
                position,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    //#[doc(alias = "ges_timeline_element_get_child_properties")]
    //#[doc(alias = "get_child_properties")]
    //fn child_properties(&self, first_property_name: &str, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) {
    //    unsafe { TODO: call ffi:ges_timeline_element_get_child_properties() }
    //}

    /// Gets the property of a child of the element.
    ///
    /// `property_name` can either be in the format "prop-name" or
    /// "TypeName::prop-name", where "prop-name" is the name of the property
    /// to get (as used in [`ObjectExt::get()`][crate::glib::prelude::ObjectExt::get()]), and "TypeName" is the type name of
    /// the child (as returned by G_OBJECT_TYPE_NAME()). The latter format is
    /// useful when two children of different types share the same property
    /// name.
    ///
    /// The first child found with the given "prop-name" property that was
    /// registered with [`add_child_property()`][Self::add_child_property()] (and of the
    /// type "TypeName", if it was given) will have the corresponding
    /// property copied into `value`.
    ///
    /// Note that `ges_timeline_element_get_child_properties()` may be more
    /// convenient for C programming.
    /// ## `property_name`
    /// The name of the child property to get
    ///
    /// # Returns
    ///
    /// [`true`] if the property was found and copied to `value`.
    ///
    /// ## `value`
    /// The return location for the value
    #[doc(alias = "ges_timeline_element_get_child_property")]
    #[doc(alias = "get_child_property")]
    fn child_property(&self, property_name: &str) -> Option<glib::Value> {
        unsafe {
            let mut value = glib::Value::uninitialized();
            let ret = from_glib(ffi::ges_timeline_element_get_child_property(
                self.as_ref().to_glib_none().0,
                property_name.to_glib_none().0,
                value.to_glib_none_mut().0,
            ));
            if ret { Some(value) } else { None }
        }
    }

    /// Gets the property of a child of the element. Specifically, the property
    /// corresponding to the `pspec` used in
    /// [`add_child_property()`][Self::add_child_property()] is copied into `value`.
    /// ## `pspec`
    /// The specification of a registered child property to get
    ///
    /// # Returns
    ///
    ///
    /// ## `value`
    /// The return location for the value
    #[doc(alias = "ges_timeline_element_get_child_property_by_pspec")]
    #[doc(alias = "get_child_property_by_pspec")]
    fn child_property_by_pspec(&self, pspec: impl AsRef<glib::ParamSpec>) -> glib::Value {
        unsafe {
            let mut value = glib::Value::uninitialized();
            ffi::ges_timeline_element_get_child_property_by_pspec(
                self.as_ref().to_glib_none().0,
                pspec.as_ref().to_glib_none().0,
                value.to_glib_none_mut().0,
            );
            value
        }
    }

    //#[doc(alias = "ges_timeline_element_get_child_property_valist")]
    //#[doc(alias = "get_child_property_valist")]
    //fn child_property_valist(&self, first_property_name: &str, var_args: /*Unknown conversion*//*Unimplemented*/Unsupported) {
    //    unsafe { TODO: call ffi:ges_timeline_element_get_child_property_valist() }
    //}

    /// Gets the [`duration`][struct@crate::TimelineElement#duration] for the element.
    ///
    /// # Returns
    ///
    /// The duration of `self` (in nanoseconds).
    #[doc(alias = "ges_timeline_element_get_duration")]
    #[doc(alias = "get_duration")]
    fn duration(&self) -> gst::ClockTime {
        unsafe {
            try_from_glib(ffi::ges_timeline_element_get_duration(
                self.as_ref().to_glib_none().0,
            ))
            .expect("mandatory glib value is None")
        }
    }

    /// Gets the [`in-point`][struct@crate::TimelineElement#in-point] for the element.
    ///
    /// # Returns
    ///
    /// The in-point of `self` (in nanoseconds).
    #[doc(alias = "ges_timeline_element_get_inpoint")]
    #[doc(alias = "get_inpoint")]
    #[doc(alias = "in-point")]
    fn inpoint(&self) -> gst::ClockTime {
        unsafe {
            try_from_glib(ffi::ges_timeline_element_get_inpoint(
                self.as_ref().to_glib_none().0,
            ))
            .expect("mandatory glib value is None")
        }
    }

    /// Gets the priority of the layer the element is in. A [`Group`][crate::Group] may span
    /// several layers, so this would return the highest priority (numerically,
    /// the smallest) amongst them.
    ///
    /// # Returns
    ///
    /// The priority of the layer `self` is in, or
    /// `GES_TIMELINE_ELEMENT_NO_LAYER_PRIORITY` if `self` does not exist in a
    /// layer.
    #[cfg(feature = "v1_16")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_16")))]
    #[doc(alias = "ges_timeline_element_get_layer_priority")]
    #[doc(alias = "get_layer_priority")]
    fn layer_priority(&self) -> u32 {
        unsafe { ffi::ges_timeline_element_get_layer_priority(self.as_ref().to_glib_none().0) }
    }

    /// Gets the [`max-duration`][struct@crate::TimelineElement#max-duration] for the element.
    ///
    /// # Returns
    ///
    /// The max-duration of `self` (in nanoseconds).
    #[doc(alias = "ges_timeline_element_get_max_duration")]
    #[doc(alias = "get_max_duration")]
    #[doc(alias = "max-duration")]
    fn max_duration(&self) -> Option<gst::ClockTime> {
        unsafe {
            from_glib(ffi::ges_timeline_element_get_max_duration(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the [`name`][struct@crate::TimelineElement#name] for the element.
    ///
    /// # Returns
    ///
    /// The name of `self`.
    #[doc(alias = "ges_timeline_element_get_name")]
    #[doc(alias = "get_name")]
    fn name(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_full(ffi::ges_timeline_element_get_name(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Get the "natural" framerate of `self`. This is to say, for example
    /// for a [`VideoUriSource`][crate::VideoUriSource] the framerate of the source.
    ///
    /// Note that a [`AudioSource`][crate::AudioSource] may also have a natural framerate if it derives
    /// from the same [`SourceClip`][crate::SourceClip] asset as a [`VideoSource`][crate::VideoSource], and its value will
    /// be that of the video source. For example, if the uri of a [`UriClip`][crate::UriClip] points
    /// to a file that contains both a video and audio stream, then the corresponding
    /// [`AudioUriSource`][crate::AudioUriSource] will share the natural framerate of the corresponding
    /// [`VideoUriSource`][crate::VideoUriSource].
    ///
    /// # Returns
    ///
    /// Whether `self` has a natural framerate or not, `framerate_n`
    /// and `framerate_d` will be set to, respectively, 0 and -1 if it is
    /// not the case.
    ///
    /// ## `framerate_n`
    /// The framerate numerator
    ///
    /// ## `framerate_d`
    /// The framerate denominator
    #[cfg(feature = "v1_18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
    #[doc(alias = "ges_timeline_element_get_natural_framerate")]
    #[doc(alias = "get_natural_framerate")]
    fn natural_framerate(&self) -> Option<(i32, i32)> {
        unsafe {
            let mut framerate_n = std::mem::MaybeUninit::uninit();
            let mut framerate_d = std::mem::MaybeUninit::uninit();
            let ret = from_glib(ffi::ges_timeline_element_get_natural_framerate(
                self.as_ref().to_glib_none().0,
                framerate_n.as_mut_ptr(),
                framerate_d.as_mut_ptr(),
            ));
            if ret {
                Some((framerate_n.assume_init(), framerate_d.assume_init()))
            } else {
                None
            }
        }
    }

    /// Gets the [`parent`][struct@crate::TimelineElement#parent] for the element.
    ///
    /// # Returns
    ///
    /// The parent of `self`, or [`None`] if
    /// `self` has no parent.
    #[doc(alias = "ges_timeline_element_get_parent")]
    #[doc(alias = "get_parent")]
    #[must_use]
    fn parent(&self) -> Option<TimelineElement> {
        unsafe {
            from_glib_full(ffi::ges_timeline_element_get_parent(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the [`priority`][struct@crate::TimelineElement#priority] for the element.
    ///
    /// # Returns
    ///
    /// The priority of `self`.
    #[doc(alias = "ges_timeline_element_get_priority")]
    #[doc(alias = "get_priority")]
    fn priority(&self) -> u32 {
        unsafe { ffi::ges_timeline_element_get_priority(self.as_ref().to_glib_none().0) }
    }

    /// Gets the [`start`][struct@crate::TimelineElement#start] for the element.
    ///
    /// # Returns
    ///
    /// The start of `self` (in nanoseconds).
    #[doc(alias = "ges_timeline_element_get_start")]
    #[doc(alias = "get_start")]
    fn start(&self) -> gst::ClockTime {
        unsafe {
            try_from_glib(ffi::ges_timeline_element_get_start(
                self.as_ref().to_glib_none().0,
            ))
            .expect("mandatory glib value is None")
        }
    }

    /// Gets the [`timeline`][struct@crate::TimelineElement#timeline] for the element.
    ///
    /// # Returns
    ///
    /// The timeline of `self`, or [`None`]
    /// if `self` has no timeline.
    #[doc(alias = "ges_timeline_element_get_timeline")]
    #[doc(alias = "get_timeline")]
    fn timeline(&self) -> Option<Timeline> {
        unsafe {
            from_glib_full(ffi::ges_timeline_element_get_timeline(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the toplevel [`parent`][struct@crate::TimelineElement#parent] of the element.
    ///
    /// # Returns
    ///
    /// The toplevel parent of `self`.
    #[doc(alias = "ges_timeline_element_get_toplevel_parent")]
    #[doc(alias = "get_toplevel_parent")]
    #[must_use]
    fn toplevel_parent(&self) -> TimelineElement {
        unsafe {
            from_glib_full(ffi::ges_timeline_element_get_toplevel_parent(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the track types that the element can interact with, i.e. the type
    /// of [`Track`][crate::Track] it can exist in, or will create [`TrackElement`][crate::TrackElement]-s for.
    ///
    /// # Returns
    ///
    /// The track types that `self` supports.
    #[doc(alias = "ges_timeline_element_get_track_types")]
    #[doc(alias = "get_track_types")]
    fn track_types(&self) -> TrackType {
        unsafe {
            from_glib(ffi::ges_timeline_element_get_track_types(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Get a list of children properties of the element, which is a list of
    /// all the specifications passed to
    /// [`add_child_property()`][Self::add_child_property()].
    ///
    /// # Returns
    ///
    /// An array of
    /// [`glib::ParamSpec`][crate::glib::ParamSpec] corresponding to the child properties of `self`, or [`None`] if
    /// something went wrong.
    #[doc(alias = "ges_timeline_element_list_children_properties")]
    fn list_children_properties(&self) -> Vec<glib::ParamSpec> {
        unsafe {
            let mut n_properties = std::mem::MaybeUninit::uninit();
            let ret = FromGlibContainer::from_glib_full_num(
                ffi::ges_timeline_element_list_children_properties(
                    self.as_ref().to_glib_none().0,
                    n_properties.as_mut_ptr(),
                ),
                n_properties.assume_init() as _,
            );
            ret
        }
    }

    /// Looks up a child property of the element.
    ///
    /// `prop_name` can either be in the format "prop-name" or
    /// "TypeName::prop-name", where "prop-name" is the name of the property
    /// to look up (as used in [`ObjectExt::get()`][crate::glib::prelude::ObjectExt::get()]), and "TypeName" is the type name
    /// of the child (as returned by G_OBJECT_TYPE_NAME()). The latter format is
    /// useful when two children of different types share the same property
    /// name.
    ///
    /// The first child found with the given "prop-name" property that was
    /// registered with [`add_child_property()`][Self::add_child_property()] (and of the
    /// type "TypeName", if it was given) will be passed to `child`, and the
    /// registered specification of this property will be passed to `pspec`.
    /// ## `prop_name`
    /// The name of a child property
    ///
    /// # Returns
    ///
    /// [`true`] if a child corresponding to the property was found, in
    /// which case `child` and `pspec` are set.
    ///
    /// ## `child`
    /// The return location for the
    /// found child
    ///
    /// ## `pspec`
    /// The return location for the
    /// specification of the child property
    #[doc(alias = "ges_timeline_element_lookup_child")]
    fn lookup_child(&self, prop_name: &str) -> Option<(glib::Object, glib::ParamSpec)> {
        unsafe {
            let mut child = std::ptr::null_mut();
            let mut pspec = std::ptr::null_mut();
            let ret = from_glib(ffi::ges_timeline_element_lookup_child(
                self.as_ref().to_glib_none().0,
                prop_name.to_glib_none().0,
                &mut child,
                &mut pspec,
            ));
            if ret {
                Some((from_glib_full(child), from_glib_full(pspec)))
            } else {
                None
            }
        }
    }

    /// Paste an element inside the same timeline and layer as `self`. `self`
    /// **must** be the return of `ges_timeline_element_copy()` with `deep=TRUE`,
    /// and it should not be changed before pasting.
    /// `self` is not placed in the timeline, instead a new element is created,
    /// alike to the originally copied element. Note that the originally
    /// copied element must stay within the same timeline and layer, at both
    /// the point of copying and pasting.
    ///
    /// Pasting may fail if it would place the timeline in an unsupported
    /// configuration.
    ///
    /// After calling this function `element` should not be used. In particular,
    /// `element` can **not** be pasted again. Instead, you can copy the
    /// returned element and paste that copy (although, this is only possible
    /// if the paste was successful).
    ///
    /// See also [`TimelineExt::paste_element()`][crate::prelude::TimelineExt::paste_element()].
    /// ## `paste_position`
    /// The position in the timeline `element` should be pasted
    /// to, i.e. the [`start`][struct@crate::TimelineElement#start] value for the pasted element.
    ///
    /// # Returns
    ///
    /// The newly created element, or
    /// [`None`] if pasting fails.
    #[doc(alias = "ges_timeline_element_paste")]
    fn paste(&self, paste_position: gst::ClockTime) -> Result<TimelineElement, glib::BoolError> {
        unsafe {
            Option::<_>::from_glib_full(ffi::ges_timeline_element_paste(
                self.as_ref().to_glib_none().0,
                paste_position.into_glib(),
            ))
            .ok_or_else(|| glib::bool_error!("Failed to paste timeline element"))
        }
    }

    /// Remove a child property from the element. `pspec` should be a
    /// specification that was passed to
    /// [`add_child_property()`][Self::add_child_property()]. The corresponding property
    /// will no longer be registered as a child property for the element.
    /// ## `pspec`
    /// The specification for the property to remove
    ///
    /// # Returns
    ///
    /// [`true`] if the property was successfully un-registered for `self`.
    #[doc(alias = "ges_timeline_element_remove_child_property")]
    fn remove_child_property(
        &self,
        pspec: impl AsRef<glib::ParamSpec>,
    ) -> Result<(), glib::error::BoolError> {
        unsafe {
            glib::result_from_gboolean!(
                ffi::ges_timeline_element_remove_child_property(
                    self.as_ref().to_glib_none().0,
                    pspec.as_ref().to_glib_none().0
                ),
                "Failed to remove child property"
            )
        }
    }

    /// Edits the start time of an element within its timeline in ripple mode.
    /// See [`edit()`][Self::edit()] with [`EditMode::Ripple`][crate::EditMode::Ripple] and
    /// [`Edge::None`][crate::Edge::None].
    /// ## `start`
    /// The new start time of `self` in ripple mode
    ///
    /// # Returns
    ///
    /// [`true`] if the ripple edit of `self` completed, [`false`] on
    /// failure.
    #[doc(alias = "ges_timeline_element_ripple")]
    fn ripple(&self, start: gst::ClockTime) -> Result<(), glib::error::BoolError> {
        unsafe {
            glib::result_from_gboolean!(
                ffi::ges_timeline_element_ripple(self.as_ref().to_glib_none().0, start.into_glib()),
                "Failed to ripple"
            )
        }
    }

    /// Edits the end time of an element within its timeline in ripple mode.
    /// See [`edit()`][Self::edit()] with [`EditMode::Ripple`][crate::EditMode::Ripple] and
    /// [`Edge::End`][crate::Edge::End].
    /// ## `end`
    /// The new end time of `self` in ripple mode
    ///
    /// # Returns
    ///
    /// [`true`] if the ripple edit of `self` completed, [`false`] on
    /// failure.
    #[doc(alias = "ges_timeline_element_ripple_end")]
    fn ripple_end(&self, end: gst::ClockTime) -> Result<(), glib::error::BoolError> {
        unsafe {
            glib::result_from_gboolean!(
                ffi::ges_timeline_element_ripple_end(
                    self.as_ref().to_glib_none().0,
                    end.into_glib()
                ),
                "Failed to ripple"
            )
        }
    }

    /// Edits the end time of an element within its timeline in roll mode.
    /// See [`edit()`][Self::edit()] with [`EditMode::Roll`][crate::EditMode::Roll] and
    /// [`Edge::End`][crate::Edge::End].
    /// ## `end`
    /// The new end time of `self` in roll mode
    ///
    /// # Returns
    ///
    /// [`true`] if the roll edit of `self` completed, [`false`] on failure.
    #[doc(alias = "ges_timeline_element_roll_end")]
    fn roll_end(&self, end: gst::ClockTime) -> Result<(), glib::error::BoolError> {
        unsafe {
            glib::result_from_gboolean!(
                ffi::ges_timeline_element_roll_end(self.as_ref().to_glib_none().0, end.into_glib()),
                "Failed to roll"
            )
        }
    }

    /// Edits the start time of an element within its timeline in roll mode.
    /// See [`edit()`][Self::edit()] with [`EditMode::Roll`][crate::EditMode::Roll] and
    /// [`Edge::Start`][crate::Edge::Start].
    /// ## `start`
    /// The new start time of `self` in roll mode
    ///
    /// # Returns
    ///
    /// [`true`] if the roll edit of `self` completed, [`false`] on failure.
    #[doc(alias = "ges_timeline_element_roll_start")]
    fn roll_start(&self, start: gst::ClockTime) -> Result<(), glib::error::BoolError> {
        unsafe {
            glib::result_from_gboolean!(
                ffi::ges_timeline_element_roll_start(
                    self.as_ref().to_glib_none().0,
                    start.into_glib()
                ),
                "Failed to roll"
            )
        }
    }

    //#[doc(alias = "ges_timeline_element_set_child_properties")]
    //fn set_child_properties(&self, first_property_name: &str, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) {
    //    unsafe { TODO: call ffi:ges_timeline_element_set_child_properties() }
    //}

    /// Sets the property of a child of the element.
    ///
    /// `property_name` can either be in the format "prop-name" or
    /// "TypeName::prop-name", where "prop-name" is the name of the property
    /// to set (as used in [`ObjectExt::set()`][crate::glib::prelude::ObjectExt::set()]), and "TypeName" is the type name of
    /// the child (as returned by G_OBJECT_TYPE_NAME()). The latter format is
    /// useful when two children of different types share the same property
    /// name.
    ///
    /// The first child found with the given "prop-name" property that was
    /// registered with [`add_child_property()`][Self::add_child_property()] (and of the
    /// type "TypeName", if it was given) will have the corresponding
    /// property set to `value`. Other children that may have also matched the
    /// property name (and type name) are left unchanged!
    /// ## `property_name`
    /// The name of the child property to set
    /// ## `value`
    /// The value to set the property to
    ///
    /// # Returns
    ///
    /// [`true`] if the property was found and set.
    #[cfg(feature = "v1_18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
    #[doc(alias = "ges_timeline_element_set_child_property_full")]
    fn set_child_property_full(
        &self,
        property_name: &str,
        value: &glib::Value,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::ges_timeline_element_set_child_property_full(
                self.as_ref().to_glib_none().0,
                property_name.to_glib_none().0,
                value.to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    //#[doc(alias = "ges_timeline_element_set_child_property_valist")]
    //fn set_child_property_valist(&self, first_property_name: &str, var_args: /*Unknown conversion*//*Unimplemented*/Unsupported) {
    //    unsafe { TODO: call ffi:ges_timeline_element_set_child_property_valist() }
    //}

    /// Sets [`duration`][struct@crate::TimelineElement#duration] for the element.
    ///
    /// Whilst the element is part of a [`Timeline`][crate::Timeline], this is the same as
    /// editing the element with [`edit()`][Self::edit()] under
    /// [`EditMode::Trim`][crate::EditMode::Trim] with [`Edge::End`][crate::Edge::End]. In particular, the
    /// [`duration`][struct@crate::TimelineElement#duration] of the element may be snapped to a
    /// different timeline time difference from the one given. In addition,
    /// setting may fail if it would place the timeline in an unsupported
    /// configuration, or the element does not have enough internal content to
    /// last the desired duration.
    /// ## `duration`
    /// The desired duration in its timeline
    ///
    /// # Returns
    ///
    /// [`true`] if `duration` could be set for `self`.
    #[doc(alias = "ges_timeline_element_set_duration")]
    #[doc(alias = "duration")]
    fn set_duration(&self, duration: impl Into<Option<gst::ClockTime>>) -> bool {
        unsafe {
            from_glib(ffi::ges_timeline_element_set_duration(
                self.as_ref().to_glib_none().0,
                duration.into().into_glib(),
            ))
        }
    }

    /// Sets [`in-point`][struct@crate::TimelineElement#in-point] for the element. If the new in-point
    /// is above the current [`max-duration`][struct@crate::TimelineElement#max-duration] of the element,
    /// this method will fail.
    /// ## `inpoint`
    /// The in-point, in internal time coordinates
    ///
    /// # Returns
    ///
    /// [`true`] if `inpoint` could be set for `self`.
    #[doc(alias = "ges_timeline_element_set_inpoint")]
    #[doc(alias = "in-point")]
    fn set_inpoint(&self, inpoint: gst::ClockTime) -> bool {
        unsafe {
            from_glib(ffi::ges_timeline_element_set_inpoint(
                self.as_ref().to_glib_none().0,
                inpoint.into_glib(),
            ))
        }
    }

    /// Sets [`max-duration`][struct@crate::TimelineElement#max-duration] for the element. If the new
    /// maximum duration is below the current [`in-point`][struct@crate::TimelineElement#in-point] of
    /// the element, this method will fail.
    /// ## `maxduration`
    /// The maximum duration, in internal time coordinates
    ///
    /// # Returns
    ///
    /// [`true`] if `maxduration` could be set for `self`.
    #[doc(alias = "ges_timeline_element_set_max_duration")]
    #[doc(alias = "max-duration")]
    fn set_max_duration(&self, maxduration: impl Into<Option<gst::ClockTime>>) -> bool {
        unsafe {
            from_glib(ffi::ges_timeline_element_set_max_duration(
                self.as_ref().to_glib_none().0,
                maxduration.into().into_glib(),
            ))
        }
    }

    /// Sets the [`name`][struct@crate::TimelineElement#name] for the element. If [`None`] is given
    /// for `name`, then the library will instead generate a new name based on
    /// the type name of the element, such as the name "uriclip3" for a
    /// [`UriClip`][crate::UriClip], and will set that name instead.
    ///
    /// If `self` already has a [`timeline`][struct@crate::TimelineElement#timeline], you should not
    /// call this function with `name` set to [`None`].
    ///
    /// You should ensure that, within each [`Timeline`][crate::Timeline], every element has a
    /// unique name. If you call this function with `name` as [`None`], then
    /// the library should ensure that the set generated name is unique from
    /// previously **generated** names. However, if you choose a `name` that
    /// interferes with the naming conventions of the library, the library will
    /// attempt to ensure that the generated names will not conflict with the
    /// chosen name, which may lead to a different name being set instead, but
    /// the uniqueness between generated and user-chosen names is not
    /// guaranteed.
    /// ## `name`
    /// The name `self` should take
    ///
    /// # Returns
    ///
    /// [`true`] if `name` or a generated name for `self` could be set.
    #[doc(alias = "ges_timeline_element_set_name")]
    #[doc(alias = "name")]
    fn set_name(&self, name: Option<&str>) -> Result<(), glib::error::BoolError> {
        unsafe {
            glib::result_from_gboolean!(
                ffi::ges_timeline_element_set_name(
                    self.as_ref().to_glib_none().0,
                    name.to_glib_none().0
                ),
                "Failed to set name"
            )
        }
    }

    /// Sets the [`parent`][struct@crate::TimelineElement#parent] for the element.
    ///
    /// This is used internally and you should normally not call this. A
    /// [`Container`][crate::Container] will set the [`parent`][struct@crate::TimelineElement#parent] of its children
    /// in [`GESContainerExt::add()`][crate::prelude::GESContainerExt::add()] and [`GESContainerExt::remove()`][crate::prelude::GESContainerExt::remove()].
    ///
    /// Note, if `parent` is not [`None`], `self` must not already have a parent
    /// set. Therefore, if you wish to switch parents, you will need to call
    /// this function twice: first to set the parent to [`None`], and then to the
    /// new parent.
    ///
    /// If `parent` is not [`None`], you must ensure it already has a
    /// (non-floating) reference to `self` before calling this.
    ///
    /// # Returns
    ///
    /// [`true`] if `parent` could be set for `self`.
    #[doc(alias = "ges_timeline_element_set_parent")]
    #[doc(alias = "parent")]
    fn set_parent(&self, parent: &impl IsA<TimelineElement>) -> Result<(), glib::error::BoolError> {
        unsafe {
            glib::result_from_gboolean!(
                ffi::ges_timeline_element_set_parent(
                    self.as_ref().to_glib_none().0,
                    parent.as_ref().to_glib_none().0
                ),
                "`TimelineElement` already had a parent or its parent was the same as specified"
            )
        }
    }

    /// Sets the priority of the element within the containing layer.
    ///
    /// # Deprecated since 1.10
    ///
    /// All priority management is done by GES itself now.
    /// To set [`Effect`][crate::Effect] priorities `ges_clip_set_top_effect_index` should
    /// be used.
    /// ## `priority`
    /// The priority
    ///
    /// # Returns
    ///
    /// [`true`] if `priority` could be set for `self`.
    #[deprecated = "Since 1.10"]
    #[allow(deprecated)]
    #[doc(alias = "ges_timeline_element_set_priority")]
    #[doc(alias = "priority")]
    fn set_priority(&self, priority: u32) -> bool {
        unsafe {
            from_glib(ffi::ges_timeline_element_set_priority(
                self.as_ref().to_glib_none().0,
                priority,
            ))
        }
    }

    /// Sets [`start`][struct@crate::TimelineElement#start] for the element. If the element has a
    /// parent, this will also move its siblings with the same shift.
    ///
    /// Whilst the element is part of a [`Timeline`][crate::Timeline], this is the same as
    /// editing the element with [`edit()`][Self::edit()] under
    /// [`EditMode::Normal`][crate::EditMode::Normal] with [`Edge::None`][crate::Edge::None]. In particular, the
    /// [`start`][struct@crate::TimelineElement#start] of the element may be snapped to a different
    /// timeline time from the one given. In addition, setting may fail if it
    /// would place the timeline in an unsupported configuration.
    /// ## `start`
    /// The desired start position of the element in its timeline
    ///
    /// # Returns
    ///
    /// [`true`] if `start` could be set for `self`.
    #[doc(alias = "ges_timeline_element_set_start")]
    #[doc(alias = "start")]
    fn set_start(&self, start: gst::ClockTime) -> bool {
        unsafe {
            from_glib(ffi::ges_timeline_element_set_start(
                self.as_ref().to_glib_none().0,
                start.into_glib(),
            ))
        }
    }

    /// Sets the [`timeline`][struct@crate::TimelineElement#timeline] of the element.
    ///
    /// This is used internally and you should normally not call this. A
    /// [`Clip`][crate::Clip] will have its [`timeline`][struct@crate::TimelineElement#timeline] set through its
    /// [`Layer`][crate::Layer]. A [`Track`][crate::Track] will similarly take care of setting the
    /// [`timeline`][struct@crate::TimelineElement#timeline] of its [`TrackElement`][crate::TrackElement]-s. A [`Group`][crate::Group]
    /// will adopt the same [`timeline`][struct@crate::TimelineElement#timeline] as its children.
    ///
    /// If `timeline` is [`None`], this will stop its current
    /// [`timeline`][struct@crate::TimelineElement#timeline] from tracking it, otherwise `timeline` will
    /// start tracking `self`. Note, in the latter case, `self` must not already
    /// have a timeline set. Therefore, if you wish to switch timelines, you
    /// will need to call this function twice: first to set the timeline to
    /// [`None`], and then to the new timeline.
    ///
    /// # Returns
    ///
    /// [`true`] if `timeline` could be set for `self`.
    #[doc(alias = "ges_timeline_element_set_timeline")]
    #[doc(alias = "timeline")]
    fn set_timeline(&self, timeline: &impl IsA<Timeline>) -> Result<(), glib::error::BoolError> {
        unsafe {
            glib::result_from_gboolean!(
                ffi::ges_timeline_element_set_timeline(
                    self.as_ref().to_glib_none().0,
                    timeline.as_ref().to_glib_none().0
                ),
                "`Failed to set timeline"
            )
        }
    }

    /// Edits the start time of an element within its timeline in trim mode.
    /// See [`edit()`][Self::edit()] with [`EditMode::Trim`][crate::EditMode::Trim] and
    /// [`Edge::Start`][crate::Edge::Start].
    /// ## `start`
    /// The new start time of `self` in trim mode
    ///
    /// # Returns
    ///
    /// [`true`] if the trim edit of `self` completed, [`false`] on failure.
    #[doc(alias = "ges_timeline_element_trim")]
    fn trim(&self, start: gst::ClockTime) -> Result<(), glib::error::BoolError> {
        unsafe {
            glib::result_from_gboolean!(
                ffi::ges_timeline_element_trim(self.as_ref().to_glib_none().0, start.into_glib()),
                "Failed to trim"
            )
        }
    }

    /// Whether the element should be serialized.
    fn is_serialize(&self) -> bool {
        ObjectExt::property(self.as_ref(), "serialize")
    }

    /// Whether the element should be serialized.
    fn set_serialize(&self, serialize: bool) {
        ObjectExt::set_property(self.as_ref(), "serialize", serialize)
    }

    /// Emitted when the element has a new child property registered. See
    /// [`add_child_property()`][Self::add_child_property()].
    ///
    /// Note that some GES elements will be automatically created with
    /// pre-registered children properties. You can use
    /// [`list_children_properties()`][Self::list_children_properties()] to list these.
    /// ## `prop_object`
    /// The child whose property has been registered
    /// ## `prop`
    /// The specification for the property that has been registered
    #[cfg(feature = "v1_18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
    #[doc(alias = "child-property-added")]
    fn connect_child_property_added<F: Fn(&Self, &glib::Object, &glib::ParamSpec) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn child_property_added_trampoline<
            P: IsA<TimelineElement>,
            F: Fn(&P, &glib::Object, &glib::ParamSpec) + 'static,
        >(
            this: *mut ffi::GESTimelineElement,
            prop_object: *mut glib::gobject_ffi::GObject,
            prop: *mut glib::gobject_ffi::GParamSpec,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    TimelineElement::from_glib_borrow(this).unsafe_cast_ref(),
                    &from_glib_borrow(prop_object),
                    &from_glib_borrow(prop),
                )
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"child-property-added".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    child_property_added_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when the element has a child property unregistered. See
    /// [`remove_child_property()`][Self::remove_child_property()].
    /// ## `prop_object`
    /// The child whose property has been unregistered
    /// ## `prop`
    /// The specification for the property that has been unregistered
    #[cfg(feature = "v1_18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
    #[doc(alias = "child-property-removed")]
    fn connect_child_property_removed<F: Fn(&Self, &glib::Object, &glib::ParamSpec) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn child_property_removed_trampoline<
            P: IsA<TimelineElement>,
            F: Fn(&P, &glib::Object, &glib::ParamSpec) + 'static,
        >(
            this: *mut ffi::GESTimelineElement,
            prop_object: *mut glib::gobject_ffi::GObject,
            prop: *mut glib::gobject_ffi::GParamSpec,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    TimelineElement::from_glib_borrow(this).unsafe_cast_ref(),
                    &from_glib_borrow(prop_object),
                    &from_glib_borrow(prop),
                )
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"child-property-removed".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    child_property_removed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when a child of the element has one of its registered
    /// properties set. See [`add_child_property()`][Self::add_child_property()].
    /// Note that unlike [`notify`][struct@crate::glib::Object#notify], a child property name can not be
    /// used as a signal detail.
    /// ## `prop_object`
    /// The child whose property has been set
    /// ## `prop`
    /// The specification for the property that been set
    #[doc(alias = "deep-notify")]
    fn connect_deep_notify<F: Fn(&Self, &glib::Object, &glib::ParamSpec) + 'static>(
        &self,
        detail: Option<&str>,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn deep_notify_trampoline<
            P: IsA<TimelineElement>,
            F: Fn(&P, &glib::Object, &glib::ParamSpec) + 'static,
        >(
            this: *mut ffi::GESTimelineElement,
            prop_object: *mut glib::gobject_ffi::GObject,
            prop: *mut glib::gobject_ffi::GParamSpec,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    TimelineElement::from_glib_borrow(this).unsafe_cast_ref(),
                    &from_glib_borrow(prop_object),
                    &from_glib_borrow(prop),
                )
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            let detailed_signal_name = detail.map(|name| format!("deep-notify::{name}\0"));
            let signal_name = detailed_signal_name.as_ref().map_or(c"deep-notify", |n| {
                std::ffi::CStr::from_bytes_with_nul_unchecked(n.as_bytes())
            });
            connect_raw(
                self.as_ptr() as *mut _,
                signal_name.as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    deep_notify_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "duration")]
    fn connect_duration_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_duration_trampoline<
            P: IsA<TimelineElement>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GESTimelineElement,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(TimelineElement::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::duration".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_duration_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "in-point")]
    fn connect_in_point_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_in_point_trampoline<
            P: IsA<TimelineElement>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GESTimelineElement,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(TimelineElement::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::in-point".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_in_point_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "max-duration")]
    fn connect_max_duration_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_max_duration_trampoline<
            P: IsA<TimelineElement>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GESTimelineElement,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(TimelineElement::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::max-duration".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_max_duration_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "name")]
    fn connect_name_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_name_trampoline<
            P: IsA<TimelineElement>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GESTimelineElement,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(TimelineElement::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::name".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_name_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "parent")]
    fn connect_parent_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_parent_trampoline<
            P: IsA<TimelineElement>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GESTimelineElement,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(TimelineElement::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::parent".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_parent_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[deprecated = "Since 1.10"]
    #[doc(alias = "priority")]
    fn connect_priority_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_priority_trampoline<
            P: IsA<TimelineElement>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GESTimelineElement,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(TimelineElement::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::priority".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_priority_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "serialize")]
    fn connect_serialize_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_serialize_trampoline<
            P: IsA<TimelineElement>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GESTimelineElement,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(TimelineElement::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::serialize".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_serialize_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "start")]
    fn connect_start_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_start_trampoline<
            P: IsA<TimelineElement>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GESTimelineElement,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(TimelineElement::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::start".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_start_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "timeline")]
    fn connect_timeline_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_timeline_trampoline<
            P: IsA<TimelineElement>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GESTimelineElement,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(TimelineElement::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::timeline".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_timeline_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl<O: IsA<TimelineElement>> TimelineElementExt for O {}