gstreamer_editing_services/auto/

text_overlay_clip.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

use crate::{
    Clip, Container, Extractable, MetaContainer, OperationClip, OverlayClip, TextHAlign,
    TextVAlign, TimelineElement, ffi,
};
use glib::{
    prelude::*,
    signal::{SignalHandlerId, connect_raw},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    /// Renders text onto the next lower priority stream using textrender.
    ///
    /// ## Properties
    ///
    ///
    /// #### `color`
    ///  The color of the text
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `font-desc`
    ///  Pango font description string
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `halignment`
    ///  Horizontal alignment of the text
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `text`
    ///  The text to diplay
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `valignment`
    ///  Vertical alignent of the text
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `xpos`
    ///  The horizontal position of the text
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `ypos`
    ///  The vertical position of the text
    ///
    /// Readable | Writeable | Construct
    /// <details><summary><h4>Clip</h4></summary>
    ///
    ///
    /// #### `duration-limit`
    ///  The maximum [`duration`][struct@crate::TimelineElement#duration] that can be *currently* set
    /// for the clip, taking into account the [`in-point`][struct@crate::TimelineElement#in-point],
    /// [`max-duration`][struct@crate::TimelineElement#max-duration], [`active`][struct@crate::TrackElement#active], and
    /// [`track`][struct@crate::TrackElement#track] properties of its children, as well as any
    /// time effects. If there is no limit, this will be set to
    /// `GST_CLOCK_TIME_NONE`.
    ///
    /// Note that whilst a clip has no children in any tracks, the limit will
    /// be unknown, and similarly set to `GST_CLOCK_TIME_NONE`.
    ///
    /// If the duration-limit would ever go below the current
    /// [`duration`][struct@crate::TimelineElement#duration] of the clip due to a change in the above
    /// variables, its [`duration`][struct@crate::TimelineElement#duration] will be set to the new
    /// limit.
    ///
    /// Readable
    ///
    ///
    /// #### `layer`
    ///  The layer this clip lies in.
    ///
    /// If you want to connect to this property's [`notify`][struct@crate::glib::Object#notify] signal,
    /// you should connect to it with `g_signal_connect_after()` since the
    /// signal emission may be stopped internally.
    ///
    /// Readable
    ///
    ///
    /// #### `supported-formats`
    ///  The [`TrackType`][crate::TrackType]-s that the clip supports, which it can create
    /// [`TrackElement`][crate::TrackElement]-s for. Note that this can be a combination of
    /// [`TrackType`][crate::TrackType] flags to indicate support for several
    /// [`track-type`][struct@crate::TrackElement#track-type] elements.
    ///
    /// Readable | Writeable | Construct
    /// </details>
    /// <details><summary><h4>Container</h4></summary>
    ///
    ///
    /// #### `height`
    ///  The span of the container's children's [`priority`][struct@crate::TimelineElement#priority]
    /// values, which is the number of integers that lie between (inclusive)
    /// the minimum and maximum priorities found amongst the container's
    /// children (maximum - minimum + 1).
    ///
    /// Readable
    /// </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
    ///
    /// [`TextOverlayClipExt`][trait@crate::prelude::TextOverlayClipExt], [`OverlayClipExt`][trait@crate::prelude::OverlayClipExt], [`OperationClipExt`][trait@crate::prelude::OperationClipExt], [`ClipExt`][trait@crate::prelude::ClipExt], [`GESContainerExt`][trait@crate::prelude::GESContainerExt], [`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 = "GESTextOverlayClip")]
    pub struct TextOverlayClip(Object<ffi::GESTextOverlayClip, ffi::GESTextOverlayClipClass>) @extends OverlayClip, OperationClip, Clip, Container, TimelineElement, @implements Extractable, MetaContainer;

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

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

    /// Creates a new [`TextOverlayClip`][crate::TextOverlayClip]
    ///
    /// # Returns
    ///
    /// The newly created
    /// [`TextOverlayClip`][crate::TextOverlayClip], or [`None`] if there was an error.
    #[doc(alias = "ges_text_overlay_clip_new")]
    pub fn new() -> Option<TextOverlayClip> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::ges_text_overlay_clip_new()) }
    }
}

/// Trait containing all [`struct@TextOverlayClip`] methods.
///
/// # Implementors
///
/// [`TextOverlayClip`][struct@crate::TextOverlayClip]
pub trait TextOverlayClipExt: IsA<TextOverlayClip> + 'static {
    /// Get the color used by `source`.
    ///
    /// # Returns
    ///
    /// The color used by `source`.
    #[doc(alias = "ges_text_overlay_clip_get_color")]
    #[doc(alias = "get_color")]
    fn color(&self) -> u32 {
        unsafe { ffi::ges_text_overlay_clip_get_color(self.as_ref().to_glib_none().0) }
    }

    /// Get the pango font description used by `self`.
    ///
    /// # Returns
    ///
    /// The pango font description used by `self`.
    #[doc(alias = "ges_text_overlay_clip_get_font_desc")]
    #[doc(alias = "get_font_desc")]
    #[doc(alias = "font-desc")]
    fn font_desc(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::ges_text_overlay_clip_get_font_desc(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Get the horizontal aligment used by `self`.
    ///
    /// # Returns
    ///
    /// The horizontal aligment used by `self`.
    #[doc(alias = "ges_text_overlay_clip_get_halignment")]
    #[doc(alias = "get_halignment")]
    fn halignment(&self) -> TextHAlign {
        unsafe {
            from_glib(ffi::ges_text_overlay_clip_get_halignment(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Get the text currently set on `self`.
    ///
    /// # Returns
    ///
    /// The text currently set on `self`.
    #[doc(alias = "ges_text_overlay_clip_get_text")]
    #[doc(alias = "get_text")]
    fn text(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::ges_text_overlay_clip_get_text(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Get the vertical aligment used by `self`.
    ///
    /// # Returns
    ///
    /// The vertical aligment used by `self`.
    #[doc(alias = "ges_text_overlay_clip_get_valignment")]
    #[doc(alias = "get_valignment")]
    fn valignment(&self) -> TextVAlign {
        unsafe {
            from_glib(ffi::ges_text_overlay_clip_get_valignment(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Get the horizontal position used by `source`.
    ///
    /// # Returns
    ///
    /// The horizontal position used by `source`.
    #[doc(alias = "ges_text_overlay_clip_get_xpos")]
    #[doc(alias = "get_xpos")]
    fn xpos(&self) -> f64 {
        unsafe { ffi::ges_text_overlay_clip_get_xpos(self.as_ref().to_glib_none().0) }
    }

    /// Get the vertical position used by `source`.
    ///
    /// # Returns
    ///
    /// The vertical position used by `source`.
    #[doc(alias = "ges_text_overlay_clip_get_ypos")]
    #[doc(alias = "get_ypos")]
    fn ypos(&self) -> f64 {
        unsafe { ffi::ges_text_overlay_clip_get_ypos(self.as_ref().to_glib_none().0) }
    }

    /// Sets the color of the text.
    /// ## `color`
    /// The color `self` is being set to
    #[doc(alias = "ges_text_overlay_clip_set_color")]
    #[doc(alias = "color")]
    fn set_color(&self, color: u32) {
        unsafe {
            ffi::ges_text_overlay_clip_set_color(self.as_ref().to_glib_none().0, color);
        }
    }

    /// Sets the pango font description of the text
    /// ## `font_desc`
    /// the pango font description
    #[doc(alias = "ges_text_overlay_clip_set_font_desc")]
    #[doc(alias = "font-desc")]
    fn set_font_desc(&self, font_desc: Option<&str>) {
        unsafe {
            ffi::ges_text_overlay_clip_set_font_desc(
                self.as_ref().to_glib_none().0,
                font_desc.to_glib_none().0,
            );
        }
    }

    /// Sets the horizontal aligment of the text.
    /// ## `halign`
    /// [`TextHAlign`][crate::TextHAlign]
    #[doc(alias = "ges_text_overlay_clip_set_halign")]
    fn set_halign(&self, halign: TextHAlign) {
        unsafe {
            ffi::ges_text_overlay_clip_set_halign(
                self.as_ref().to_glib_none().0,
                halign.into_glib(),
            );
        }
    }

    /// Sets the text this clip will render.
    /// ## `text`
    /// the text to render. an internal copy of this text will be
    /// made.
    #[doc(alias = "ges_text_overlay_clip_set_text")]
    #[doc(alias = "text")]
    fn set_text(&self, text: Option<&str>) {
        unsafe {
            ffi::ges_text_overlay_clip_set_text(
                self.as_ref().to_glib_none().0,
                text.to_glib_none().0,
            );
        }
    }

    /// Sets the vertical aligment of the text.
    /// ## `valign`
    /// [`TextVAlign`][crate::TextVAlign]
    #[doc(alias = "ges_text_overlay_clip_set_valign")]
    fn set_valign(&self, valign: TextVAlign) {
        unsafe {
            ffi::ges_text_overlay_clip_set_valign(
                self.as_ref().to_glib_none().0,
                valign.into_glib(),
            );
        }
    }

    /// Sets the horizontal position of the text.
    /// ## `position`
    /// The horizontal position `self` is being set to
    #[doc(alias = "ges_text_overlay_clip_set_xpos")]
    #[doc(alias = "xpos")]
    fn set_xpos(&self, position: f64) {
        unsafe {
            ffi::ges_text_overlay_clip_set_xpos(self.as_ref().to_glib_none().0, position);
        }
    }

    /// Sets the vertical position of the text.
    /// ## `position`
    /// The vertical position `self` is being set to
    #[doc(alias = "ges_text_overlay_clip_set_ypos")]
    #[doc(alias = "ypos")]
    fn set_ypos(&self, position: f64) {
        unsafe {
            ffi::ges_text_overlay_clip_set_ypos(self.as_ref().to_glib_none().0, position);
        }
    }

    /// Horizontal alignment of the text
    fn set_halignment(&self, halignment: TextHAlign) {
        ObjectExt::set_property(self.as_ref(), "halignment", halignment)
    }

    /// Vertical alignent of the text
    fn set_valignment(&self, valignment: TextVAlign) {
        ObjectExt::set_property(self.as_ref(), "valignment", valignment)
    }

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

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

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

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

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

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

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

impl<O: IsA<TextOverlayClip>> TextOverlayClipExt for O {}