gstreamer_editing_services/auto/

video_transition.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)]

use crate::{
    ffi, Extractable, MetaContainer, Operation, TimelineElement, TrackElement, Transition,
    VideoStandardTransitionType,
};
use glib::{
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    ///
    ///
    /// ## Properties
    ///
    ///
    /// #### `border`
    ///  This value represents the border width of the transition.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `invert`
    ///  This value represents the direction of the transition.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `transition-type`
    ///  Readable | Writeable
    /// <details><summary><h4>TrackElement</h4></summary>
    ///
    ///
    /// #### `active`
    ///  Whether the effect of the element should be applied in its
    /// [`track`][struct@crate::TrackElement#track]. If set to [`false`], it will not be used in
    /// the output of the track.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `auto-clamp-control-sources`
    ///  Whether the control sources on the element (see
    /// [`TrackElementExt::set_control_source()`][crate::prelude::TrackElementExt::set_control_source()]) will be automatically
    /// updated whenever the [`in-point`][struct@crate::TimelineElement#in-point] or out-point of the
    /// element change in value.
    ///
    /// See [`TrackElementExt::clamp_control_source()`][crate::prelude::TrackElementExt::clamp_control_source()] for how this is done
    /// per control source.
    ///
    /// Default value: [`true`]
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `has-internal-source`
    ///  This property is used to determine whether the 'internal time'
    /// properties of the element have any meaning. In particular, unless
    /// this is set to [`true`], the [`in-point`][struct@crate::TimelineElement#in-point] and
    /// [`max-duration`][struct@crate::TimelineElement#max-duration] can not be set to any value other
    /// than the default 0 and `GST_CLOCK_TIME_NONE`, respectively.
    ///
    /// If an element has some *internal* *timed* source [`gst::Element`][crate::gst::Element] that it
    /// reads stream data from as part of its function in a [`Track`][crate::Track], then
    /// you'll likely want to set this to [`true`] to allow the
    /// [`in-point`][struct@crate::TimelineElement#in-point] and [`max-duration`][struct@crate::TimelineElement#max-duration] to
    /// be set.
    ///
    /// The default value is determined by the `GESTrackElementClass`
    /// `default_has_internal_source` class property. For most
    /// `GESSourceClass`-es, this will be [`true`], with the exception of those
    /// that have a potentially *static* source, such as `GESImageSourceClass`
    /// and `GESTitleSourceClass`. Otherwise, this will usually be [`false`].
    ///
    /// For most [`Operation`][crate::Operation]-s you will likely want to leave this set to
    /// [`false`]. The exception may be for an operation that reads some stream
    /// data from some private internal source as part of manipulating the
    /// input data from the usual linked upstream [`TrackElement`][crate::TrackElement].
    ///
    /// For example, you may want to set this to [`true`] for a
    /// [`TrackType::VIDEO`][crate::TrackType::VIDEO] operation that wraps a `textoverlay` that reads
    /// from a subtitle file and places its text on top of the received video
    /// data. The [`in-point`][struct@crate::TimelineElement#in-point] of the element would be used
    /// to shift the initial seek time on the `textoverlay` away from 0, and
    /// the [`max-duration`][struct@crate::TimelineElement#max-duration] could be set to reflect the
    /// time at which the subtitle file runs out of data.
    ///
    /// Note that GES can not support track elements that have both internal
    /// content and manipulate the timing of their data streams (time
    /// effects).
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `track`
    ///  The track that this element belongs to, or [`None`] if it does not
    /// belong to a track.
    ///
    /// Readable
    ///
    ///
    /// #### `track-type`
    ///  The track type of the element, which determines the type of track the
    /// element can be added to (see [`track-type`][struct@crate::Track#track-type]). This should
    /// correspond to the type of data that the element can produce or
    /// process.
    ///
    /// Readable | Writeable | Construct
    /// </details>
    /// <details><summary><h4>TimelineElement</h4></summary>
    ///
    ///
    /// #### `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
    /// </details>
    ///
    /// # Implements
    ///
    /// [`VideoTransitionExt`][trait@crate::prelude::VideoTransitionExt], [`TransitionExt`][trait@crate::prelude::TransitionExt], [`OperationExt`][trait@crate::prelude::OperationExt], [`TrackElementExt`][trait@crate::prelude::TrackElementExt], [`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 = "GESVideoTransition")]
    pub struct VideoTransition(Object<ffi::GESVideoTransition, ffi::GESVideoTransitionClass>) @extends Transition, Operation, TrackElement, TimelineElement, @implements Extractable, MetaContainer;

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

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

    #[doc(alias = "ges_video_transition_new")]
    pub fn new() -> VideoTransition {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::ges_video_transition_new()) }
    }
}

impl Default for VideoTransition {
    fn default() -> Self {
        Self::new()
    }
}

/// Trait containing all [`struct@VideoTransition`] methods.
///
/// # Implementors
///
/// [`VideoTransition`][struct@crate::VideoTransition]
pub trait VideoTransitionExt: IsA<VideoTransition> + 'static {
    /// Get the border property of `self`, this value represents
    /// the border width of the transition.
    ///
    /// # Deprecated since 1.20
    ///
    /// Use ges_timeline_element_get_child_property instead.
    ///
    /// # Returns
    ///
    /// The border values of `self` or -1 if not meaningful
    /// (this will happen when not using a smpte transition).
    #[cfg_attr(feature = "v1_20", deprecated = "Since 1.20")]
    #[allow(deprecated)]
    #[doc(alias = "ges_video_transition_get_border")]
    #[doc(alias = "get_border")]
    fn border(&self) -> i32 {
        unsafe { ffi::ges_video_transition_get_border(self.as_ref().to_glib_none().0) }
    }

    /// Get the transition type used by `self`.
    ///
    /// # Returns
    ///
    /// The transition type used by `self`.
    #[doc(alias = "ges_video_transition_get_transition_type")]
    #[doc(alias = "get_transition_type")]
    #[doc(alias = "transition-type")]
    fn transition_type(&self) -> VideoStandardTransitionType {
        unsafe {
            from_glib(ffi::ges_video_transition_get_transition_type(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Get the invert property of `self`, this value represents
    /// the direction of the transition.
    ///
    /// # Deprecated since 1.20
    ///
    /// Use ges_timeline_element_get_child_property instead.
    ///
    /// # Returns
    ///
    /// The invert value of `self`
    #[cfg_attr(feature = "v1_20", deprecated = "Since 1.20")]
    #[allow(deprecated)]
    #[doc(alias = "ges_video_transition_is_inverted")]
    fn is_inverted(&self) -> bool {
        unsafe {
            from_glib(ffi::ges_video_transition_is_inverted(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Set the border property of `self`, this value represents
    /// the border width of the transition. In case this value does
    /// not make sense for the current transition type, it is cached
    /// for later use.
    ///
    /// # Deprecated since 1.20
    ///
    /// Use ges_timeline_element_set_child_property instead.
    /// ## `value`
    /// The value of the border to set on `object`
    #[cfg_attr(feature = "v1_20", deprecated = "Since 1.20")]
    #[allow(deprecated)]
    #[doc(alias = "ges_video_transition_set_border")]
    #[doc(alias = "border")]
    fn set_border(&self, value: u32) {
        unsafe {
            ffi::ges_video_transition_set_border(self.as_ref().to_glib_none().0, value);
        }
    }

    /// Set the invert property of `self`, this value represents
    /// the direction of the transition. In case this value does
    /// not make sense for the current transition type, it is cached
    /// for later use.
    ///
    /// # Deprecated since 1.20
    ///
    /// Use ges_timeline_element_set_child_property instead.
    /// ## `inverted`
    /// [`true`] if the transition should be inverted [`false`] otherwise
    #[cfg_attr(feature = "v1_20", deprecated = "Since 1.20")]
    #[allow(deprecated)]
    #[doc(alias = "ges_video_transition_set_inverted")]
    fn set_inverted(&self, inverted: bool) {
        unsafe {
            ffi::ges_video_transition_set_inverted(
                self.as_ref().to_glib_none().0,
                inverted.into_glib(),
            );
        }
    }

    /// Sets the transition being used to `type_`.
    /// ## `type_`
    /// a [`VideoStandardTransitionType`][crate::VideoStandardTransitionType]
    ///
    /// # Returns
    ///
    /// [`true`] if the transition type was properly changed, else [`false`].
    #[doc(alias = "ges_video_transition_set_transition_type")]
    #[doc(alias = "transition-type")]
    fn set_transition_type(&self, type_: VideoStandardTransitionType) -> bool {
        unsafe {
            from_glib(ffi::ges_video_transition_set_transition_type(
                self.as_ref().to_glib_none().0,
                type_.into_glib(),
            ))
        }
    }

    /// This value represents the direction of the transition.
    ///
    /// # Deprecated since 1.20
    ///
    /// Use ges_timeline_element_[sg]et_child_property instead.
    #[cfg_attr(feature = "v1_20", deprecated = "Since 1.20")]
    fn inverts(&self) -> bool {
        ObjectExt::property(self.as_ref(), "invert")
    }

    /// This value represents the direction of the transition.
    ///
    /// # Deprecated since 1.20
    ///
    /// Use ges_timeline_element_[sg]et_child_property instead.
    #[cfg_attr(feature = "v1_20", deprecated = "Since 1.20")]
    fn set_invert(&self, invert: bool) {
        ObjectExt::set_property(self.as_ref(), "invert", invert)
    }

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

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

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

impl<O: IsA<VideoTransition>> VideoTransitionExt for O {}