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

glib::wrapper! {
    /// [`Bin`][crate::Bin] is an element that can contain other [`Element`][crate::Element], allowing them to be
    /// managed as a group.
    /// Pads from the child elements can be ghosted to the bin, see [`GhostPad`][crate::GhostPad].
    /// This makes the bin look like any other elements and enables creation of
    /// higher-level abstraction elements.
    ///
    /// A new [`Bin`][crate::Bin] is created with [`new()`][Self::new()]. Use a [`Pipeline`][crate::Pipeline] instead if you
    /// want to create a toplevel bin because a normal bin doesn't have a bus or
    /// handle clock distribution of its own.
    ///
    /// After the bin has been created you will typically add elements to it with
    /// [`GstBinExt::add()`][crate::prelude::GstBinExt::add()]. You can remove elements with [`GstBinExt::remove()`][crate::prelude::GstBinExt::remove()].
    ///
    /// An element can be retrieved from a bin with [`GstBinExt::by_name()`][crate::prelude::GstBinExt::by_name()], using the
    /// elements name. [`GstBinExt::by_name_recurse_up()`][crate::prelude::GstBinExt::by_name_recurse_up()] is mainly used for internal
    /// purposes and will query the parent bins when the element is not found in the
    /// current bin.
    ///
    /// An iterator of elements in a bin can be retrieved with
    /// [`GstBinExtManual::iterate_elements()`][crate::prelude::GstBinExtManual::iterate_elements()]. Various other iterators exist to retrieve the
    /// elements in a bin.
    ///
    /// `gst_object_unref()` is used to drop your reference to the bin.
    ///
    /// The [`element-added`][struct@crate::Bin#element-added] signal is fired whenever a new element is added to
    /// the bin. Likewise the [`element-removed`][struct@crate::Bin#element-removed] signal is fired whenever an
    /// element is removed from the bin.
    ///
    /// A [`Bin`][crate::Bin] internally intercepts every [`Message`][crate::Message] posted by its children and
    /// implements the following default behaviour for each of them:
    ///
    /// * `GST_MESSAGE_EOS`: This message is only posted by sinks in the PLAYING
    /// state. If all sinks posted the EOS message, this bin will post and EOS
    /// message upwards.
    ///
    /// * `GST_MESSAGE_SEGMENT_START`: Just collected and never forwarded upwards.
    ///  The messages are used to decide when all elements have completed playback
    ///  of their segment.
    ///
    /// * `GST_MESSAGE_SEGMENT_DONE`: Is posted by [`Bin`][crate::Bin] when all elements that posted
    ///  a SEGMENT_START have posted a SEGMENT_DONE.
    ///
    /// * `GST_MESSAGE_DURATION_CHANGED`: Is posted by an element that detected a change
    ///  in the stream duration. The duration change is posted to the
    ///  application so that it can refetch the new duration with a duration
    ///  query.
    ///
    ///  Note that these messages can be posted before the bin is prerolled, in which
    ///  case the duration query might fail.
    ///
    ///  Note also that there might be a discrepancy (due to internal buffering/queueing)
    ///  between the stream being currently displayed and the returned duration query.
    ///
    ///  Applications might want to also query for duration (and changes) by
    ///  listening to the `GST_MESSAGE_STREAM_START` message, signaling the active start
    ///  of a (new) stream.
    ///
    /// * `GST_MESSAGE_CLOCK_LOST`: This message is posted by an element when it
    ///  can no longer provide a clock.
    ///
    ///  The default bin behaviour is to check if the lost clock was the one provided
    ///  by the bin. If so and the bin is currently in the PLAYING state, the message
    ///  is forwarded to the bin parent.
    ///
    ///  This message is also generated when a clock provider is removed from
    ///  the bin. If this message is received by the application, it should
    ///  PAUSE the pipeline and set it back to PLAYING to force a new clock
    ///  distribution.
    ///
    /// * `GST_MESSAGE_CLOCK_PROVIDE`: This message is generated when an element
    ///  can provide a clock. This mostly happens when a new clock
    ///  provider is added to the bin.
    ///
    ///  The default behaviour of the bin is to mark the currently selected clock as
    ///  dirty, which will perform a clock recalculation the next time the bin is
    ///  asked to provide a clock.
    ///
    ///  This message is never sent to the application but is forwarded to
    ///  the parent of the bin.
    ///
    /// * OTHERS: posted upwards.
    ///
    /// A [`Bin`][crate::Bin] implements the following default behaviour for answering to a
    /// [`Query`][crate::Query]:
    ///
    /// * `GST_QUERY_DURATION`: The bin will forward the query to all sink
    ///  elements contained within and will return the maximum value.
    ///  If no sinks are available in the bin, the query fails.
    ///
    /// * `GST_QUERY_POSITION`: The query is sent to all sink elements in the bin and the
    ///  MAXIMUM of all values is returned. If no sinks are available in the bin,
    ///  the query fails.
    ///
    /// * OTHERS: the query is forwarded to all sink elements, the result
    ///  of the first sink that answers the query successfully is returned. If no
    ///  sink is in the bin, the query fails.
    ///
    /// A [`Bin`][crate::Bin] will by default forward any event sent to it to all sink
    /// ( [`EventTypeFlags::UPSTREAM`][crate::EventTypeFlags::UPSTREAM] ) or source ( [`EventTypeFlags::DOWNSTREAM`][crate::EventTypeFlags::DOWNSTREAM] ) elements
    /// depending on the event type.
    ///
    /// If all the elements return [`true`], the bin will also return [`true`], else [`false`]
    /// is returned. If no elements of the required type are in the bin, the event
    /// handler will return [`true`].
    ///
    /// ## Properties
    ///
    ///
    /// #### `async-handling`
    ///  If set to [`true`], the bin will handle asynchronous state changes.
    /// This should be used only if the bin subclass is modifying the state
    /// of its children on its own.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `message-forward`
    ///  Forward all children messages, even those that would normally be filtered by
    /// the bin. This can be interesting when one wants to be notified of the EOS
    /// state of individual elements, for example.
    ///
    /// The messages are converted to an ELEMENT message with the bin as the
    /// source. The structure of the message is named `GstBinForwarded` and contains
    /// a field named `message` that contains the original forwarded [`Message`][crate::Message].
    ///
    /// Readable | Writeable
    /// <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
    ///
    ///
    /// #### `deep-element-added`
    ///  Will be emitted after the element was added to `sub_bin`.
    ///
    ///
    ///
    ///
    /// #### `deep-element-removed`
    ///  Will be emitted after the element was removed from `sub_bin`.
    ///
    ///
    ///
    ///
    /// #### `do-latency`
    ///  Will be emitted when the bin needs to perform latency calculations. This
    /// signal is only emitted for toplevel bins or when [`async-handling`][struct@crate::Bin#async-handling] is
    /// enabled.
    ///
    /// Only one signal handler is invoked. If no signals are connected, the
    /// default handler is invoked, which will query and distribute the lowest
    /// possible latency to all sinks.
    ///
    /// Connect to this signal if the default latency calculations are not
    /// sufficient, like when you need different latencies for different sinks in
    /// the same pipeline.
    ///
    ///
    ///
    ///
    /// #### `element-added`
    ///  Will be emitted after the element was added to the bin.
    ///
    ///
    ///
    ///
    /// #### `element-removed`
    ///  Will be emitted after the element was removed from the bin.
    ///
    ///
    /// <details><summary><h4>Element</h4></summary>
    ///
    ///
    /// #### `no-more-pads`
    ///  This signals that the element will not generate more dynamic pads.
    /// Note that this signal will usually be emitted from the context of
    /// the streaming thread.
    ///
    ///
    ///
    ///
    /// #### `pad-added`
    ///  a new [`Pad`][crate::Pad] has been added to the element. Note that this signal will
    /// usually be emitted from the context of the streaming thread. Also keep in
    /// mind that if you add new elements to the pipeline in the signal handler
    /// you will need to set them to the desired target state with
    /// [`ElementExt::set_state()`][crate::prelude::ElementExt::set_state()] or [`ElementExt::sync_state_with_parent()`][crate::prelude::ElementExt::sync_state_with_parent()].
    ///
    ///
    ///
    ///
    /// #### `pad-removed`
    ///  a [`Pad`][crate::Pad] has been removed from the element
    ///
    ///
    /// </details>
    /// <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>
    /// <details><summary><h4>ChildProxy</h4></summary>
    ///
    ///
    /// #### `child-added`
    ///  Will be emitted after the `object` was added to the `child_proxy`.
    ///
    ///
    ///
    ///
    /// #### `child-removed`
    ///  Will be emitted after the `object` was removed from the `child_proxy`.
    ///
    ///
    /// </details>
    ///
    /// # Implements
    ///
    /// [`GstBinExt`][trait@crate::prelude::GstBinExt], [`ElementExt`][trait@crate::prelude::ElementExt], [`GstObjectExt`][trait@crate::prelude::GstObjectExt], [`trait@glib::ObjectExt`], [`ChildProxyExt`][trait@crate::prelude::ChildProxyExt], [`ElementExtManual`][trait@crate::prelude::ElementExtManual], [`ChildProxyExtManual`][trait@crate::prelude::ChildProxyExtManual]
    #[doc(alias = "GstBin")]
    pub struct Bin(Object<ffi::GstBin, ffi::GstBinClass>) @extends Element, Object, @implements ChildProxy;

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

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

unsafe impl Send for Bin {}
unsafe impl Sync for Bin {}

mod sealed {
    pub trait Sealed {}
    impl<T: super::IsA<super::Bin>> Sealed for T {}
}

/// Trait containing all [`struct@Bin`] methods.
///
/// # Implementors
///
/// [`Bin`][struct@crate::Bin], [`Pipeline`][struct@crate::Pipeline]
pub trait GstBinExt: IsA<Bin> + sealed::Sealed + 'static {
    /// Adds the given element to the bin. Sets the element's parent, and thus
    /// takes ownership of the element. An element can only be added to one bin.
    ///
    /// If the element's pads are linked to other pads, the pads will be unlinked
    /// before the element is added to the bin.
    ///
    /// > When you add an element to an already-running pipeline, you will have to
    /// > take care to set the state of the newly-added element to the desired
    /// > state (usually PLAYING or PAUSED, same you set the pipeline to originally)
    /// > with [`ElementExt::set_state()`][crate::prelude::ElementExt::set_state()], or use [`ElementExt::sync_state_with_parent()`][crate::prelude::ElementExt::sync_state_with_parent()].
    /// > The bin or pipeline will not take care of this for you.
    /// ## `element`
    /// the [`Element`][crate::Element] to add
    ///
    /// # Returns
    ///
    /// [`true`] if the element could be added, [`false`] if
    /// the bin does not want to accept the element.
    #[doc(alias = "gst_bin_add")]
    fn add(&self, element: &impl IsA<Element>) -> Result<(), glib::error::BoolError> {
        unsafe {
            glib::result_from_gboolean!(
                ffi::gst_bin_add(
                    self.as_ref().to_glib_none().0,
                    element.as_ref().to_glib_none().0
                ),
                "Failed to add element"
            )
        }
    }

    /// Recursively looks for elements with an unlinked pad of the given
    /// direction within the specified bin and returns an unlinked pad
    /// if one is found, or [`None`] otherwise. If a pad is found, the caller
    /// owns a reference to it and should use `gst_object_unref()` on the
    /// pad when it is not needed any longer.
    /// ## `direction`
    /// whether to look for an unlinked source or sink pad
    ///
    /// # Returns
    ///
    /// unlinked pad of the given
    /// direction.
    #[doc(alias = "gst_bin_find_unlinked_pad")]
    fn find_unlinked_pad(&self, direction: PadDirection) -> Option<Pad> {
        unsafe {
            from_glib_full(ffi::gst_bin_find_unlinked_pad(
                self.as_ref().to_glib_none().0,
                direction.into_glib(),
            ))
        }
    }

    /// Looks for an element inside the bin that implements the given
    /// interface. If such an element is found, it returns the element.
    /// You can cast this element to the given interface afterwards. If you want
    /// all elements that implement the interface, use
    /// [`GstBinExtManual::iterate_all_by_interface()`][crate::prelude::GstBinExtManual::iterate_all_by_interface()]. This function recurses into child bins.
    /// ## `iface`
    /// the `GType` of an interface
    ///
    /// # Returns
    ///
    /// A [`Element`][crate::Element] inside the bin
    /// implementing the interface
    #[doc(alias = "gst_bin_get_by_interface")]
    #[doc(alias = "get_by_interface")]
    fn by_interface(&self, iface: glib::types::Type) -> Option<Element> {
        unsafe {
            from_glib_full(ffi::gst_bin_get_by_interface(
                self.as_ref().to_glib_none().0,
                iface.into_glib(),
            ))
        }
    }

    /// Gets the element with the given name from a bin. This
    /// function recurses into child bins.
    /// ## `name`
    /// the element name to search for
    ///
    /// # Returns
    ///
    /// the [`Element`][crate::Element] with the given
    /// name
    #[doc(alias = "gst_bin_get_by_name")]
    #[doc(alias = "get_by_name")]
    fn by_name(&self, name: &str) -> Option<Element> {
        unsafe {
            from_glib_full(ffi::gst_bin_get_by_name(
                self.as_ref().to_glib_none().0,
                name.to_glib_none().0,
            ))
        }
    }

    /// Gets the element with the given name from this bin. If the
    /// element is not found, a recursion is performed on the parent bin.
    /// ## `name`
    /// the element name to search for
    ///
    /// # Returns
    ///
    /// the [`Element`][crate::Element] with the given
    /// name
    #[doc(alias = "gst_bin_get_by_name_recurse_up")]
    #[doc(alias = "get_by_name_recurse_up")]
    fn by_name_recurse_up(&self, name: &str) -> Option<Element> {
        unsafe {
            from_glib_full(ffi::gst_bin_get_by_name_recurse_up(
                self.as_ref().to_glib_none().0,
                name.to_glib_none().0,
            ))
        }
    }

    ///
    /// # Returns
    ///
    /// the bin's suppressed [`ElementFlags`][crate::ElementFlags].
    #[doc(alias = "gst_bin_get_suppressed_flags")]
    #[doc(alias = "get_suppressed_flags")]
    fn suppressed_flags(&self) -> ElementFlags {
        unsafe {
            from_glib(ffi::gst_bin_get_suppressed_flags(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Queries `self` for the current latency and reconfigures this latency on all the
    /// elements using a LATENCY event.
    ///
    /// This method is typically called on the pipeline when a `GST_MESSAGE_LATENCY`
    /// is posted on the bus.
    ///
    /// This function simply emits the [`do-latency`][struct@crate::Bin#do-latency] signal so any custom latency
    /// calculations will be performed.
    ///
    /// # Returns
    ///
    /// [`true`] if the latency could be queried and reconfigured.
    #[doc(alias = "gst_bin_recalculate_latency")]
    fn recalculate_latency(&self) -> Result<(), glib::error::BoolError> {
        unsafe {
            glib::result_from_gboolean!(
                ffi::gst_bin_recalculate_latency(self.as_ref().to_glib_none().0),
                "Failed to recalculate latency"
            )
        }
    }

    /// Removes the element from the bin, unparenting it as well.
    /// Unparenting the element means that the element will be dereferenced,
    /// so if the bin holds the only reference to the element, the element
    /// will be freed in the process of removing it from the bin. If you
    /// want the element to still exist after removing, you need to call
    /// `gst_object_ref()` before removing it from the bin.
    ///
    /// If the element's pads are linked to other pads, the pads will be unlinked
    /// before the element is removed from the bin.
    /// ## `element`
    /// the [`Element`][crate::Element] to remove
    ///
    /// # Returns
    ///
    /// [`true`] if the element could be removed, [`false`] if
    /// the bin does not want to remove the element.
    #[doc(alias = "gst_bin_remove")]
    fn remove(&self, element: &impl IsA<Element>) -> Result<(), glib::error::BoolError> {
        unsafe {
            glib::result_from_gboolean!(
                ffi::gst_bin_remove(
                    self.as_ref().to_glib_none().0,
                    element.as_ref().to_glib_none().0
                ),
                "Failed to remove element"
            )
        }
    }

    /// Suppresses the given flags on the bin. [`ElementFlags`][crate::ElementFlags] of a
    /// child element are propagated when it is added to the bin.
    /// When suppressed flags are set, those specified flags will
    /// not be propagated to the bin.
    /// ## `flags`
    /// the [`ElementFlags`][crate::ElementFlags] to suppress
    #[doc(alias = "gst_bin_set_suppressed_flags")]
    fn set_suppressed_flags(&self, flags: ElementFlags) {
        unsafe {
            ffi::gst_bin_set_suppressed_flags(self.as_ref().to_glib_none().0, flags.into_glib());
        }
    }

    /// Synchronizes the state of every child of `self` with the state
    /// of `self`. See also [`ElementExt::sync_state_with_parent()`][crate::prelude::ElementExt::sync_state_with_parent()].
    ///
    /// # Returns
    ///
    /// [`true`] if syncing the state was successful for all children,
    ///  otherwise [`false`].
    #[doc(alias = "gst_bin_sync_children_states")]
    fn sync_children_states(&self) -> Result<(), glib::error::BoolError> {
        unsafe {
            glib::result_from_gboolean!(
                ffi::gst_bin_sync_children_states(self.as_ref().to_glib_none().0),
                "Failed to sync children states"
            )
        }
    }

    /// If set to [`true`], the bin will handle asynchronous state changes.
    /// This should be used only if the bin subclass is modifying the state
    /// of its children on its own.
    #[doc(alias = "async-handling")]
    fn is_async_handling(&self) -> bool {
        ObjectExt::property(self.as_ref(), "async-handling")
    }

    /// If set to [`true`], the bin will handle asynchronous state changes.
    /// This should be used only if the bin subclass is modifying the state
    /// of its children on its own.
    #[doc(alias = "async-handling")]
    fn set_async_handling(&self, async_handling: bool) {
        ObjectExt::set_property(self.as_ref(), "async-handling", async_handling)
    }

    /// Forward all children messages, even those that would normally be filtered by
    /// the bin. This can be interesting when one wants to be notified of the EOS
    /// state of individual elements, for example.
    ///
    /// The messages are converted to an ELEMENT message with the bin as the
    /// source. The structure of the message is named `GstBinForwarded` and contains
    /// a field named `message` that contains the original forwarded [`Message`][crate::Message].
    #[doc(alias = "message-forward")]
    fn is_message_forward(&self) -> bool {
        ObjectExt::property(self.as_ref(), "message-forward")
    }

    /// Forward all children messages, even those that would normally be filtered by
    /// the bin. This can be interesting when one wants to be notified of the EOS
    /// state of individual elements, for example.
    ///
    /// The messages are converted to an ELEMENT message with the bin as the
    /// source. The structure of the message is named `GstBinForwarded` and contains
    /// a field named `message` that contains the original forwarded [`Message`][crate::Message].
    #[doc(alias = "message-forward")]
    fn set_message_forward(&self, message_forward: bool) {
        ObjectExt::set_property(self.as_ref(), "message-forward", message_forward)
    }

    /// Will be emitted after the element was added to `sub_bin`.
    /// ## `sub_bin`
    /// the [`Bin`][crate::Bin] the element was added to
    /// ## `element`
    /// the [`Element`][crate::Element] that was added to `sub_bin`
    #[doc(alias = "deep-element-added")]
    fn connect_deep_element_added<F: Fn(&Self, &Bin, &Element) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn deep_element_added_trampoline<
            P: IsA<Bin>,
            F: Fn(&P, &Bin, &Element) + Send + Sync + 'static,
        >(
            this: *mut ffi::GstBin,
            sub_bin: *mut ffi::GstBin,
            element: *mut ffi::GstElement,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                Bin::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(sub_bin),
                &from_glib_borrow(element),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"deep-element-added\0".as_ptr() as *const _,
                Some(std::mem::transmute::<_, unsafe extern "C" fn()>(
                    deep_element_added_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Will be emitted after the element was removed from `sub_bin`.
    /// ## `sub_bin`
    /// the [`Bin`][crate::Bin] the element was removed from
    /// ## `element`
    /// the [`Element`][crate::Element] that was removed from `sub_bin`
    #[doc(alias = "deep-element-removed")]
    fn connect_deep_element_removed<F: Fn(&Self, &Bin, &Element) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn deep_element_removed_trampoline<
            P: IsA<Bin>,
            F: Fn(&P, &Bin, &Element) + Send + Sync + 'static,
        >(
            this: *mut ffi::GstBin,
            sub_bin: *mut ffi::GstBin,
            element: *mut ffi::GstElement,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                Bin::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(sub_bin),
                &from_glib_borrow(element),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"deep-element-removed\0".as_ptr() as *const _,
                Some(std::mem::transmute::<_, unsafe extern "C" fn()>(
                    deep_element_removed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Will be emitted after the element was added to the bin.
    /// ## `element`
    /// the [`Element`][crate::Element] that was added to the bin
    #[doc(alias = "element-added")]
    fn connect_element_added<F: Fn(&Self, &Element) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn element_added_trampoline<
            P: IsA<Bin>,
            F: Fn(&P, &Element) + Send + Sync + 'static,
        >(
            this: *mut ffi::GstBin,
            element: *mut ffi::GstElement,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                Bin::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(element),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"element-added\0".as_ptr() as *const _,
                Some(std::mem::transmute::<_, unsafe extern "C" fn()>(
                    element_added_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Will be emitted after the element was removed from the bin.
    /// ## `element`
    /// the [`Element`][crate::Element] that was removed from the bin
    #[doc(alias = "element-removed")]
    fn connect_element_removed<F: Fn(&Self, &Element) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn element_removed_trampoline<
            P: IsA<Bin>,
            F: Fn(&P, &Element) + Send + Sync + 'static,
        >(
            this: *mut ffi::GstBin,
            element: *mut ffi::GstElement,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                Bin::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(element),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"element-removed\0".as_ptr() as *const _,
                Some(std::mem::transmute::<_, unsafe extern "C" fn()>(
                    element_removed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "async-handling")]
    fn connect_async_handling_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_async_handling_trampoline<
            P: IsA<Bin>,
            F: Fn(&P) + Send + Sync + 'static,
        >(
            this: *mut ffi::GstBin,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Bin::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::async-handling\0".as_ptr() as *const _,
                Some(std::mem::transmute::<_, unsafe extern "C" fn()>(
                    notify_async_handling_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "message-forward")]
    fn connect_message_forward_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_message_forward_trampoline<
            P: IsA<Bin>,
            F: Fn(&P) + Send + Sync + 'static,
        >(
            this: *mut ffi::GstBin,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Bin::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::message-forward\0".as_ptr() as *const _,
                Some(std::mem::transmute::<_, unsafe extern "C" fn()>(
                    notify_message_forward_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl<O: IsA<Bin>> GstBinExt for O {}