// 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::{Caps, Object, Pad, PadDirection, PadPresence};
use glib::{
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    /// Padtemplates describe the possible media types a pad or an elementfactory can
    /// handle. This allows for both inspection of handled types before loading the
    /// element plugin as well as identifying pads on elements that are not yet
    /// created (request or sometimes pads).
    ///
    /// Pad and PadTemplates have [`Caps`][crate::Caps] attached to it to describe the media type
    /// they are capable of dealing with. [`caps()`][Self::caps()] or
    /// GST_PAD_TEMPLATE_CAPS() are used to get the caps of a padtemplate. It's not
    /// possible to modify the caps of a padtemplate after creation.
    ///
    /// PadTemplates have a [`PadPresence`][crate::PadPresence] property which identifies the lifetime
    /// of the pad and that can be retrieved with GST_PAD_TEMPLATE_PRESENCE(). Also
    /// the direction of the pad can be retrieved from the [`PadTemplate`][crate::PadTemplate] with
    /// GST_PAD_TEMPLATE_DIRECTION().
    ///
    /// The GST_PAD_TEMPLATE_NAME_TEMPLATE () is important for GST_PAD_REQUEST pads
    /// because it has to be used as the name in the [`ElementExtManual::request_pad_simple()`][crate::prelude::ElementExtManual::request_pad_simple()]
    /// call to instantiate a pad from this template.
    ///
    /// Padtemplates can be created with [`new()`][Self::new()] or with
    /// gst_static_pad_template_get (), which creates a [`PadTemplate`][crate::PadTemplate] from a
    /// [`StaticPadTemplate`][crate::StaticPadTemplate] that can be filled with the
    /// convenient GST_STATIC_PAD_TEMPLATE() macro.
    ///
    /// A padtemplate can be used to create a pad (see [`Pad::from_template()`][crate::Pad::from_template()]
    /// or gst_pad_new_from_static_template ()) or to add to an element class
    /// (see gst_element_class_add_static_pad_template ()).
    ///
    /// The following code example shows the code to create a pad from a padtemplate.
    ///
    ///
    /// **⚠️ The following code is in C ⚠️**
    ///
    /// ```C
    ///   GstStaticPadTemplate my_template =
    ///   GST_STATIC_PAD_TEMPLATE (
    ///     "sink",          // the name of the pad
    ///     GST_PAD_SINK,    // the direction of the pad
    ///     GST_PAD_ALWAYS,  // when this pad will be present
    ///     GST_STATIC_CAPS (        // the capabilities of the padtemplate
    ///       "audio/x-raw, "
    ///         "channels = (int) [ 1, 6 ]"
    ///     )
    ///   );
    ///   void
    ///   my_method (void)
    ///   {
    ///     GstPad *pad;
    ///     pad = gst_pad_new_from_static_template (&my_template, "sink");
    ///     ...
    ///   }
    /// ```
    ///
    /// The following example shows you how to add the padtemplate to an
    /// element class, this is usually done in the class_init of the class:
    ///
    ///
    /// **⚠️ The following code is in C ⚠️**
    ///
    /// ```C
    ///   static void
    ///   my_element_class_init (GstMyElementClass *klass)
    ///   {
    ///     GstElementClass *gstelement_class = GST_ELEMENT_CLASS (klass);
    ///
    ///     gst_element_class_add_static_pad_template (gstelement_class, &my_template);
    ///   }
    /// ```
    ///
    /// ## Properties
    ///
    ///
    /// #### `caps`
    ///  The capabilities of the pad described by the pad template.
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `direction`
    ///  The direction of the pad described by the pad template.
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `gtype`
    ///  The type of the pad described by the pad template.
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `name-template`
    ///  The name template of the pad template.
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `presence`
    ///  When the pad described by the pad template will become available.
    ///
    /// Readable | Writeable | Construct Only
    /// <details><summary><h4>Object</h4></summary>
    ///
    ///
    /// #### `name`
    ///  Readable | Writeable | Construct
    ///
    ///
    /// #### `parent`
    ///  The parent of the object. Please note, that when changing the 'parent'
    /// property, we don't emit [`notify`][struct@crate::glib::Object#notify] and [`deep-notify`][struct@crate::Object#deep-notify]
    /// signals due to locking issues. In some cases one can use
    /// [`element-added`][struct@crate::Bin#element-added] or [`element-removed`][struct@crate::Bin#element-removed] signals on the parent to
    /// achieve a similar effect.
    ///
    /// Readable | Writeable
    /// </details>
    ///
    /// ## Signals
    ///
    ///
    /// #### `pad-created`
    ///  This signal is fired when an element creates a pad from this template.
    ///
    ///
    /// <details><summary><h4>Object</h4></summary>
    ///
    ///
    /// #### `deep-notify`
    ///  The deep notify signal is used to be notified of property changes. It is
    /// typically attached to the toplevel bin to receive notifications from all
    /// the elements contained in that bin.
    ///
    /// Detailed
    /// </details>
    ///
    /// # Implements
    ///
    /// [`GstObjectExt`][trait@crate::prelude::GstObjectExt], [`trait@glib::ObjectExt`]
    #[doc(alias = "GstPadTemplate")]
    pub struct PadTemplate(Object<ffi::GstPadTemplate, ffi::GstPadTemplateClass>) @extends Object;

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

impl PadTemplate {
    /// Creates a new pad template with a name according to the given template
    /// and with the given arguments.
    /// ## `name_template`
    /// the name template.
    /// ## `direction`
    /// the [`PadDirection`][crate::PadDirection] of the template.
    /// ## `presence`
    /// the [`PadPresence`][crate::PadPresence] of the pad.
    /// ## `caps`
    /// a [`Caps`][crate::Caps] set for the template.
    ///
    /// # Returns
    ///
    /// a new [`PadTemplate`][crate::PadTemplate].
    #[doc(alias = "gst_pad_template_new")]
    pub fn new(
        name_template: &str,
        direction: PadDirection,
        presence: PadPresence,
        caps: &Caps,
    ) -> Result<PadTemplate, glib::BoolError> {
        assert_initialized_main_thread!();
        unsafe {
            Option::<_>::from_glib_none(ffi::gst_pad_template_new(
                name_template.to_glib_none().0,
                direction.into_glib(),
                presence.into_glib(),
                caps.to_glib_none().0,
            ))
            .ok_or_else(|| glib::bool_error!("Failed to create pad template"))
        }
    }

    /// Creates a new pad template with a name according to the given template
    /// and with the given arguments.
    /// ## `name_template`
    /// the name template.
    /// ## `direction`
    /// the [`PadDirection`][crate::PadDirection] of the template.
    /// ## `presence`
    /// the [`PadPresence`][crate::PadPresence] of the pad.
    /// ## `caps`
    /// a [`Caps`][crate::Caps] set for the template.
    /// ## `pad_type`
    /// The `GType` of the pad to create
    ///
    /// # Returns
    ///
    /// a new [`PadTemplate`][crate::PadTemplate].
    #[doc(alias = "gst_pad_template_new_with_gtype")]
    #[doc(alias = "new_with_gtype")]
    pub fn with_gtype(
        name_template: &str,
        direction: PadDirection,
        presence: PadPresence,
        caps: &Caps,
        pad_type: glib::types::Type,
    ) -> Result<PadTemplate, glib::BoolError> {
        assert_initialized_main_thread!();
        unsafe {
            Option::<_>::from_glib_none(ffi::gst_pad_template_new_with_gtype(
                name_template.to_glib_none().0,
                direction.into_glib(),
                presence.into_glib(),
                caps.to_glib_none().0,
                pad_type.into_glib(),
            ))
            .ok_or_else(|| glib::bool_error!("Failed to create pad template"))
        }
    }

    /// Emit the pad-created signal for this template when created by this pad.
    /// ## `pad`
    /// the [`Pad`][crate::Pad] that created it
    #[doc(alias = "gst_pad_template_pad_created")]
    pub fn pad_created(&self, pad: &impl IsA<Pad>) {
        unsafe {
            ffi::gst_pad_template_pad_created(self.to_glib_none().0, pad.as_ref().to_glib_none().0);
        }
    }

    /// This signal is fired when an element creates a pad from this template.
    /// ## `pad`
    /// the pad that was created.
    #[doc(alias = "pad-created")]
    pub fn connect_pad_created<F: Fn(&Self, &Pad) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn pad_created_trampoline<
            F: Fn(&PadTemplate, &Pad) + Send + Sync + 'static,
        >(
            this: *mut ffi::GstPadTemplate,
            pad: *mut ffi::GstPad,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this), &from_glib_borrow(pad))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"pad-created\0".as_ptr() as *const _,
                Some(std::mem::transmute::<_, unsafe extern "C" fn()>(
                    pad_created_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

unsafe impl Send for PadTemplate {}
unsafe impl Sync for PadTemplate {}