// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT

use glib;
use glib::object::Cast;
use glib::object::IsA;
use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*;
use glib::StaticType;
use glib::Value;
use glib_sys;
use gobject_sys;
use gst_sys;
use std::boxed::Box as Box_;
use std::mem::transmute;
use ChildProxy;
use Element;
#[cfg(any(feature = "v1_10", feature = "dox"))]
use ElementFlags;
use Object;
use Pad;
use PadDirection;

glib_wrapper! {
    /// `Bin` is an element that can contain other `Element`, allowing them to be
    /// managed as a group.
    /// Pads from the child elements can be ghosted to the bin, see `GhostPad`.
    /// This makes the bin look like any other elements and enables creation of
    /// higher-level abstraction elements.
    ///
    /// A new `Bin` is created with `Bin::new`. Use a `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`. You can remove elements with `GstBinExt::remove`.
    ///
    /// An element can be retrieved from a bin with `GstBinExt::get_by_name`, using the
    /// elements name. `GstBinExt::get_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
    /// `GstBinExt::iterate_elements`. Various other iterators exist to retrieve the
    /// elements in a bin.
    ///
    /// `GstObjectExt::unref` is used to drop your reference to the bin.
    ///
    /// The `Bin::element-added` signal is fired whenever a new element is added to
    /// the bin. Likewise the `Bin::element-removed` signal is fired whenever an
    /// element is removed from the bin.
    ///
    /// ## Notes
    ///
    /// A `Bin` internally intercepts every `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` 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 tot the application but is forwarded to
    /// the parent of the bin.
    ///
    /// * OTHERS: posted upwards.
    ///
    /// A `Bin` implements the following default behaviour for answering to a
    /// `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` will by default forward any event sent to it to all sink
    /// (`EventTypeFlags::Downstream`) or source (`EventTypeFlags::Upstream`) 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`.
    ///
    /// # Implements
    ///
    /// [`GstBinExt`](trait.GstBinExt.html), [`ElementExt`](trait.ElementExt.html), [`GstObjectExt`](trait.GstObjectExt.html), [`glib::object::ObjectExt`](../glib/object/trait.ObjectExt.html), [`ChildProxyExt`](trait.ChildProxyExt.html), [`ElementExtManual`](prelude/trait.ElementExtManual.html), [`ChildProxyExtManual`](prelude/trait.ChildProxyExtManual.html)
    pub struct Bin(Object<gst_sys::GstBin, gst_sys::GstBinClass, BinClass>) @extends Element, Object, @implements ChildProxy;

    match fn {
        get_type => || gst_sys::gst_bin_get_type(),
    }
}

impl Bin {
    /// Creates a new bin with the given name.
    /// ## `name`
    /// the name of the new bin
    ///
    /// # Returns
    ///
    /// a new `Bin`
    pub fn new(name: Option<&str>) -> Bin {
        assert_initialized_main_thread!();
        unsafe {
            Element::from_glib_none(gst_sys::gst_bin_new(name.to_glib_none().0)).unsafe_cast()
        }
    }
}

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

pub const NONE_BIN: Option<&Bin> = None;

/// Trait containing all `Bin` methods.
///
/// # Implementors
///
/// [`Bin`](struct.Bin.html), [`Pipeline`](struct.Pipeline.html)
pub trait GstBinExt: '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 `Element::set_state`, or use `ElementExt::sync_state_with_parent`.
    /// > The bin or pipeline will not take care of this for you.
    ///
    /// MT safe.
    /// ## `element`
    /// the `Element` to add
    ///
    /// # Returns
    ///
    /// `true` if the element could be added, `false` if
    /// the bin does not want to accept the element.
    fn add<P: IsA<Element>>(&self, element: &P) -> Result<(), glib::error::BoolError>;

    //fn add_many<P: IsA<Element>>(&self, element_1: &P, : /*Unknown conversion*//*Unimplemented*/Fundamental: VarArgs);

    /// 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 `GstObjectExt::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, `None`.
    fn find_unlinked_pad(&self, direction: PadDirection) -> Option<Pad>;

    /// 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
    /// `GstBinExt::iterate_all_by_interface`. This function recurses into child bins.
    ///
    /// MT safe. Caller owns returned reference.
    /// ## `iface`
    /// the `glib::Type` of an interface
    ///
    /// # Returns
    ///
    /// A `Element` inside the bin
    /// implementing the interface
    fn get_by_interface(&self, iface: glib::types::Type) -> Option<Element>;

    /// Gets the element with the given name from a bin. This
    /// function recurses into child bins.
    ///
    /// Returns `None` if no element with the given name is found in the bin.
    ///
    /// MT safe. Caller owns returned reference.
    /// ## `name`
    /// the element name to search for
    ///
    /// # Returns
    ///
    /// the `Element` with the given
    /// name, or `None`
    fn get_by_name(&self, name: &str) -> Option<Element>;

    /// Gets the element with the given name from this bin. If the
    /// element is not found, a recursion is performed on the parent bin.
    ///
    /// Returns `None` if:
    /// - no element with the given name is found in the bin
    ///
    /// MT safe. Caller owns returned reference.
    /// ## `name`
    /// the element name to search for
    ///
    /// # Returns
    ///
    /// the `Element` with the given
    /// name, or `None`
    fn get_by_name_recurse_up(&self, name: &str) -> Option<Element>;

    /// Return the suppressed flags of the bin.
    ///
    /// MT safe.
    ///
    /// Feature: `v1_10`
    ///
    ///
    /// # Returns
    ///
    /// the bin's suppressed `ElementFlags`.
    #[cfg(any(feature = "v1_10", feature = "dox"))]
    fn get_suppressed_flags(&self) -> ElementFlags;

    //#[cfg(any(feature = "v1_18", feature = "dox"))]
    //fn iterate_all_by_element_factory_name(&self, factory_name: &str) -> /*Ignored*/Option<Iterator>;

    //fn iterate_all_by_interface(&self, iface: glib::types::Type) -> /*Ignored*/Option<Iterator>;

    //fn iterate_elements(&self) -> /*Ignored*/Option<Iterator>;

    //fn iterate_recurse(&self) -> /*Ignored*/Option<Iterator>;

    //fn iterate_sinks(&self) -> /*Ignored*/Option<Iterator>;

    //fn iterate_sorted(&self) -> /*Ignored*/Option<Iterator>;

    //fn iterate_sources(&self) -> /*Ignored*/Option<Iterator>;

    /// Query `self` for the current latency using and reconfigures this latency to all the
    /// elements with a LATENCY event.
    ///
    /// This method is typically called on the pipeline when a `MessageType::Latency`
    /// is posted on the bus.
    ///
    /// This function simply emits the 'do-latency' signal so any custom latency
    /// calculations will be performed.
    ///
    /// # Returns
    ///
    /// `true` if the latency could be queried and reconfigured.
    fn recalculate_latency(&self) -> Result<(), glib::error::BoolError>;

    /// 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
    /// `GstObjectExt::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.
    ///
    /// MT safe.
    /// ## `element`
    /// the `Element` to remove
    ///
    /// # Returns
    ///
    /// `true` if the element could be removed, `false` if
    /// the bin does not want to remove the element.
    fn remove<P: IsA<Element>>(&self, element: &P) -> Result<(), glib::error::BoolError>;

    //fn remove_many<P: IsA<Element>>(&self, element_1: &P, : /*Unknown conversion*//*Unimplemented*/Fundamental: VarArgs);

    /// Suppress the given flags on the bin. `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.
    ///
    /// MT safe.
    ///
    /// Feature: `v1_10`
    ///
    /// ## `flags`
    /// the `ElementFlags` to suppress
    #[cfg(any(feature = "v1_10", feature = "dox"))]
    fn set_suppressed_flags(&self, flags: ElementFlags);

    /// Synchronizes the state of every child of `self` with the state
    /// of `self`. See also `ElementExt::sync_state_with_parent`.
    ///
    /// # Returns
    ///
    /// `true` if syncing the state was successful for all children,
    ///  otherwise `false`.
    fn sync_children_states(&self) -> Result<(), glib::error::BoolError>;

    /// 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.
    fn get_property_async_handling(&self) -> bool;

    /// 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.
    fn set_property_async_handling(&self, async_handling: bool);

    /// 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' of type GST_TYPE_MESSAGE that contains the original
    /// forwarded message.
    fn get_property_message_forward(&self) -> bool;

    /// 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' of type GST_TYPE_MESSAGE that contains the original
    /// forwarded message.
    fn set_property_message_forward(&self, message_forward: bool);

    /// Will be emitted after the element was added to sub_bin.
    ///
    /// Feature: `v1_10`
    ///
    /// ## `sub_bin`
    /// the `Bin` the element was added to
    /// ## `element`
    /// the `Element` that was added to `sub_bin`
    #[cfg(any(feature = "v1_10", feature = "dox"))]
    fn connect_deep_element_added<F: Fn(&Self, &Bin, &Element) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId;

    /// Will be emitted after the element was removed from sub_bin.
    ///
    /// Feature: `v1_10`
    ///
    /// ## `sub_bin`
    /// the `Bin` the element was removed from
    /// ## `element`
    /// the `Element` that was removed from `sub_bin`
    #[cfg(any(feature = "v1_10", feature = "dox"))]
    fn connect_deep_element_removed<F: Fn(&Self, &Bin, &Element) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId;

    /// Will be emitted after the element was added to the bin.
    /// ## `element`
    /// the `Element` that was added to the bin
    fn connect_element_added<F: Fn(&Self, &Element) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId;

    /// Will be emitted after the element was removed from the bin.
    /// ## `element`
    /// the `Element` that was removed from the bin
    fn connect_element_removed<F: Fn(&Self, &Element) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId;

    fn connect_property_async_handling_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId;

    fn connect_property_message_forward_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId;
}

impl<O: IsA<Bin>> GstBinExt for O {
    fn add<P: IsA<Element>>(&self, element: &P) -> Result<(), glib::error::BoolError> {
        unsafe {
            glib_result_from_gboolean!(
                gst_sys::gst_bin_add(
                    self.as_ref().to_glib_none().0,
                    element.as_ref().to_glib_none().0
                ),
                "Failed to add element"
            )
        }
    }

    //fn add_many<P: IsA<Element>>(&self, element_1: &P, : /*Unknown conversion*//*Unimplemented*/Fundamental: VarArgs) {
    //    unsafe { TODO: call gst_sys:gst_bin_add_many() }
    //}

    fn find_unlinked_pad(&self, direction: PadDirection) -> Option<Pad> {
        unsafe {
            from_glib_full(gst_sys::gst_bin_find_unlinked_pad(
                self.as_ref().to_glib_none().0,
                direction.to_glib(),
            ))
        }
    }

    fn get_by_interface(&self, iface: glib::types::Type) -> Option<Element> {
        unsafe {
            from_glib_full(gst_sys::gst_bin_get_by_interface(
                self.as_ref().to_glib_none().0,
                iface.to_glib(),
            ))
        }
    }

    fn get_by_name(&self, name: &str) -> Option<Element> {
        unsafe {
            from_glib_full(gst_sys::gst_bin_get_by_name(
                self.as_ref().to_glib_none().0,
                name.to_glib_none().0,
            ))
        }
    }

    fn get_by_name_recurse_up(&self, name: &str) -> Option<Element> {
        unsafe {
            from_glib_full(gst_sys::gst_bin_get_by_name_recurse_up(
                self.as_ref().to_glib_none().0,
                name.to_glib_none().0,
            ))
        }
    }

    #[cfg(any(feature = "v1_10", feature = "dox"))]
    fn get_suppressed_flags(&self) -> ElementFlags {
        unsafe {
            from_glib(gst_sys::gst_bin_get_suppressed_flags(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    //#[cfg(any(feature = "v1_18", feature = "dox"))]
    //fn iterate_all_by_element_factory_name(&self, factory_name: &str) -> /*Ignored*/Option<Iterator> {
    //    unsafe { TODO: call gst_sys:gst_bin_iterate_all_by_element_factory_name() }
    //}

    //fn iterate_all_by_interface(&self, iface: glib::types::Type) -> /*Ignored*/Option<Iterator> {
    //    unsafe { TODO: call gst_sys:gst_bin_iterate_all_by_interface() }
    //}

    //fn iterate_elements(&self) -> /*Ignored*/Option<Iterator> {
    //    unsafe { TODO: call gst_sys:gst_bin_iterate_elements() }
    //}

    //fn iterate_recurse(&self) -> /*Ignored*/Option<Iterator> {
    //    unsafe { TODO: call gst_sys:gst_bin_iterate_recurse() }
    //}

    //fn iterate_sinks(&self) -> /*Ignored*/Option<Iterator> {
    //    unsafe { TODO: call gst_sys:gst_bin_iterate_sinks() }
    //}

    //fn iterate_sorted(&self) -> /*Ignored*/Option<Iterator> {
    //    unsafe { TODO: call gst_sys:gst_bin_iterate_sorted() }
    //}

    //fn iterate_sources(&self) -> /*Ignored*/Option<Iterator> {
    //    unsafe { TODO: call gst_sys:gst_bin_iterate_sources() }
    //}

    fn recalculate_latency(&self) -> Result<(), glib::error::BoolError> {
        unsafe {
            glib_result_from_gboolean!(
                gst_sys::gst_bin_recalculate_latency(self.as_ref().to_glib_none().0),
                "Failed to recalculate latency"
            )
        }
    }

    fn remove<P: IsA<Element>>(&self, element: &P) -> Result<(), glib::error::BoolError> {
        unsafe {
            glib_result_from_gboolean!(
                gst_sys::gst_bin_remove(
                    self.as_ref().to_glib_none().0,
                    element.as_ref().to_glib_none().0
                ),
                "Failed to remove element"
            )
        }
    }

    //fn remove_many<P: IsA<Element>>(&self, element_1: &P, : /*Unknown conversion*//*Unimplemented*/Fundamental: VarArgs) {
    //    unsafe { TODO: call gst_sys:gst_bin_remove_many() }
    //}

    #[cfg(any(feature = "v1_10", feature = "dox"))]
    fn set_suppressed_flags(&self, flags: ElementFlags) {
        unsafe {
            gst_sys::gst_bin_set_suppressed_flags(self.as_ref().to_glib_none().0, flags.to_glib());
        }
    }

    fn sync_children_states(&self) -> Result<(), glib::error::BoolError> {
        unsafe {
            glib_result_from_gboolean!(
                gst_sys::gst_bin_sync_children_states(self.as_ref().to_glib_none().0),
                "Failed to sync children states"
            )
        }
    }

    fn get_property_async_handling(&self) -> bool {
        unsafe {
            let mut value = Value::from_type(<bool as StaticType>::static_type());
            gobject_sys::g_object_get_property(
                self.to_glib_none().0 as *mut gobject_sys::GObject,
                b"async-handling\0".as_ptr() as *const _,
                value.to_glib_none_mut().0,
            );
            value
                .get()
                .expect("Return Value for property `async-handling` getter")
                .unwrap()
        }
    }

    fn set_property_async_handling(&self, async_handling: bool) {
        unsafe {
            gobject_sys::g_object_set_property(
                self.to_glib_none().0 as *mut gobject_sys::GObject,
                b"async-handling\0".as_ptr() as *const _,
                Value::from(&async_handling).to_glib_none().0,
            );
        }
    }

    fn get_property_message_forward(&self) -> bool {
        unsafe {
            let mut value = Value::from_type(<bool as StaticType>::static_type());
            gobject_sys::g_object_get_property(
                self.to_glib_none().0 as *mut gobject_sys::GObject,
                b"message-forward\0".as_ptr() as *const _,
                value.to_glib_none_mut().0,
            );
            value
                .get()
                .expect("Return Value for property `message-forward` getter")
                .unwrap()
        }
    }

    fn set_property_message_forward(&self, message_forward: bool) {
        unsafe {
            gobject_sys::g_object_set_property(
                self.to_glib_none().0 as *mut gobject_sys::GObject,
                b"message-forward\0".as_ptr() as *const _,
                Value::from(&message_forward).to_glib_none().0,
            );
        }
    }

    #[cfg(any(feature = "v1_10", feature = "dox"))]
    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,
            F: Fn(&P, &Bin, &Element) + Send + Sync + 'static,
        >(
            this: *mut gst_sys::GstBin,
            sub_bin: *mut gst_sys::GstBin,
            element: *mut gst_sys::GstElement,
            f: glib_sys::gpointer,
        ) where
            P: IsA<Bin>,
        {
            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(transmute::<_, unsafe extern "C" fn()>(
                    deep_element_added_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(any(feature = "v1_10", feature = "dox"))]
    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,
            F: Fn(&P, &Bin, &Element) + Send + Sync + 'static,
        >(
            this: *mut gst_sys::GstBin,
            sub_bin: *mut gst_sys::GstBin,
            element: *mut gst_sys::GstElement,
            f: glib_sys::gpointer,
        ) where
            P: IsA<Bin>,
        {
            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(transmute::<_, unsafe extern "C" fn()>(
                    deep_element_removed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_element_added<F: Fn(&Self, &Element) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn element_added_trampoline<
            P,
            F: Fn(&P, &Element) + Send + Sync + 'static,
        >(
            this: *mut gst_sys::GstBin,
            element: *mut gst_sys::GstElement,
            f: glib_sys::gpointer,
        ) where
            P: IsA<Bin>,
        {
            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(transmute::<_, unsafe extern "C" fn()>(
                    element_added_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_element_removed<F: Fn(&Self, &Element) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn element_removed_trampoline<
            P,
            F: Fn(&P, &Element) + Send + Sync + 'static,
        >(
            this: *mut gst_sys::GstBin,
            element: *mut gst_sys::GstElement,
            f: glib_sys::gpointer,
        ) where
            P: IsA<Bin>,
        {
            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(transmute::<_, unsafe extern "C" fn()>(
                    element_removed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_property_async_handling_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_async_handling_trampoline<
            P,
            F: Fn(&P) + Send + Sync + 'static,
        >(
            this: *mut gst_sys::GstBin,
            _param_spec: glib_sys::gpointer,
            f: glib_sys::gpointer,
        ) where
            P: IsA<Bin>,
        {
            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(transmute::<_, unsafe extern "C" fn()>(
                    notify_async_handling_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_property_message_forward_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_message_forward_trampoline<
            P,
            F: Fn(&P) + Send + Sync + 'static,
        >(
            this: *mut gst_sys::GstBin,
            _param_spec: glib_sys::gpointer,
            f: glib_sys::gpointer,
        ) where
            P: IsA<Bin>,
        {
            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(transmute::<_, unsafe extern "C" fn()>(
                    notify_message_forward_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}