// 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 ClockTime;
use Message;
use Object;
use ffi;
use glib;
use glib::signal::SignalHandlerId;
use glib::signal::connect;
use glib::translate::*;
use glib_ffi;
use gobject_ffi;
use std::boxed::Box as Box_;
use std::mem;
use std::mem::transmute;
use std::ptr;

glib_wrapper! {
    /// The `Bus` is an object responsible for delivering `Message` packets in
    /// a first-in first-out way from the streaming threads (see `Task`) to the
    /// application.
    ///
    /// Since the application typically only wants to deal with delivery of these
    /// messages from one thread, the GstBus will marshall the messages between
    /// different threads. This is important since the actual streaming of media
    /// is done in another thread than the application.
    ///
    /// The GstBus provides support for `glib::Source` based notifications. This makes it
    /// possible to handle the delivery in the glib mainloop.
    ///
    /// The `glib::Source` callback function `Bus::async_signal_func` can be used to
    /// convert all bus messages into signal emissions.
    ///
    /// A message is posted on the bus with the `Bus::post` method. With the
    /// `Bus::peek` and `Bus::pop` methods one can look at or retrieve a
    /// previously posted message.
    ///
    /// The bus can be polled with the `Bus::poll` method. This methods blocks
    /// up to the specified timeout value until one of the specified messages types
    /// is posted on the bus. The application can then `Bus::pop` the messages
    /// from the bus to handle them.
    /// Alternatively the application can register an asynchronous bus function
    /// using `Bus::add_watch_full` or `Bus::add_watch`. This function will
    /// install a `glib::Source` in the default glib main loop and will deliver messages
    /// a short while after they have been posted. Note that the main loop should
    /// be running for the asynchronous callbacks.
    ///
    /// It is also possible to get messages from the bus without any thread
    /// marshalling with the `Bus::set_sync_handler` method. This makes it
    /// possible to react to a message in the same thread that posted the
    /// message on the bus. This should only be used if the application is able
    /// to deal with messages from different threads.
    ///
    /// Every `Pipeline` has one bus.
    ///
    /// Note that a `Pipeline` will set its bus into flushing state when changing
    /// from READY to NULL state.
    ///
    /// # Implements
    ///
    /// [`GstObjectExt`](trait.GstObjectExt.html), [`glib::object::ObjectExt`](../glib/object/trait.ObjectExt.html)
    pub struct Bus(Object<ffi::GstBus, ffi::GstBusClass>): Object;

    match fn {
        get_type => || ffi::gst_bus_get_type(),
    }
}

impl Bus {
    /// Creates a new `Bus` instance.
    ///
    /// # Returns
    ///
    /// a new `Bus` instance
    pub fn new() -> Bus {
        assert_initialized_main_thread!();
        unsafe {
            from_glib_full(ffi::gst_bus_new())
        }
    }

    /// Adds a bus signal watch to the default main context with the default priority
    /// (`G_PRIORITY_DEFAULT`). It is also possible to use a non-default
    /// main context set up using `glib::MainContext::push_thread_default` (before
    /// one had to create a bus watch source and attach it to the desired main
    /// context 'manually').
    ///
    /// After calling this statement, the bus will emit the "message" signal for each
    /// message posted on the bus.
    ///
    /// This function may be called multiple times. To clean up, the caller is
    /// responsible for calling `Bus::remove_signal_watch` as many times as this
    /// function is called.
    ///
    /// MT safe.
    pub fn add_signal_watch(&self) {
        unsafe {
            ffi::gst_bus_add_signal_watch(self.to_glib_none().0);
        }
    }

    //pub fn add_watch<P: Into<Option</*Unimplemented*/Fundamental: Pointer>>>(&self, func: /*Unknown conversion*//*Unimplemented*/BusFunc, user_data: P) -> u32 {
    //    unsafe { TODO: call ffi::gst_bus_add_watch() }
    //}

    //pub fn add_watch_full(&self, priority: i32, func: /*Unknown conversion*//*Unimplemented*/BusFunc, notify: /*Unknown conversion*//*Unimplemented*/DestroyNotify) -> u32 {
    //    unsafe { TODO: call ffi::gst_bus_add_watch_full() }
    //}

    //pub fn async_signal_func<P: Into<Option</*Unimplemented*/Fundamental: Pointer>>>(&self, message: &Message, data: P) -> bool {
    //    unsafe { TODO: call ffi::gst_bus_async_signal_func() }
    //}

    /// Instructs GStreamer to stop emitting the "sync-message" signal for this bus.
    /// See `Bus::enable_sync_message_emission` for more information.
    ///
    /// In the event that multiple pieces of code have called
    /// `Bus::enable_sync_message_emission`, the sync-message emissions will only
    /// be stopped after all calls to `Bus::enable_sync_message_emission` were
    /// "cancelled" by calling this function. In this way the semantics are exactly
    /// the same as `GstObjectExt::ref` that which calls enable should also call
    /// disable.
    ///
    /// MT safe.
    pub fn disable_sync_message_emission(&self) {
        unsafe {
            ffi::gst_bus_disable_sync_message_emission(self.to_glib_none().0);
        }
    }

    /// Instructs GStreamer to emit the "sync-message" signal after running the bus's
    /// sync handler. This function is here so that code can ensure that they can
    /// synchronously receive messages without having to affect what the bin's sync
    /// handler is.
    ///
    /// This function may be called multiple times. To clean up, the caller is
    /// responsible for calling `Bus::disable_sync_message_emission` as many times
    /// as this function is called.
    ///
    /// While this function looks similar to `Bus::add_signal_watch`, it is not
    /// exactly the same -- this function enables `<emphasis>`synchronous`</emphasis>` emission of
    /// signals when messages arrive; `Bus::add_signal_watch` adds an idle callback
    /// to pop messages off the bus `<emphasis>`asynchronously`</emphasis>`. The sync-message signal
    /// comes from the thread of whatever object posted the message; the "message"
    /// signal is marshalled to the main thread via the main loop.
    ///
    /// MT safe.
    pub fn enable_sync_message_emission(&self) {
        unsafe {
            ffi::gst_bus_enable_sync_message_emission(self.to_glib_none().0);
        }
    }

    //#[cfg(any(feature = "v1_14", feature = "dox"))]
    //pub fn get_pollfd(&self, fd: /*Ignored*/&mut glib::PollFD) {
    //    unsafe { TODO: call ffi::gst_bus_get_pollfd() }
    //}

    /// Check if there are pending messages on the bus that
    /// should be handled.
    ///
    /// # Returns
    ///
    /// `true` if there are messages on the bus to be handled, `false`
    /// otherwise.
    ///
    /// MT safe.
    pub fn have_pending(&self) -> bool {
        unsafe {
            from_glib(ffi::gst_bus_have_pending(self.to_glib_none().0))
        }
    }

    /// Peek the message on the top of the bus' queue. The message will remain
    /// on the bus' message queue. A reference is returned, and needs to be unreffed
    /// by the caller.
    ///
    /// # Returns
    ///
    /// the `Message` that is on the
    ///  bus, or `None` if the bus is empty.
    ///
    /// MT safe.
    pub fn peek(&self) -> Option<Message> {
        unsafe {
            from_glib_full(ffi::gst_bus_peek(self.to_glib_none().0))
        }
    }

    /// Get a message from the bus.
    ///
    /// # Returns
    ///
    /// the `Message` that is on the
    ///  bus, or `None` if the bus is empty. The message is taken from
    ///  the bus and needs to be unreffed with `gst_message_unref` after
    ///  usage.
    ///
    /// MT safe.
    pub fn pop(&self) -> Option<Message> {
        unsafe {
            from_glib_full(ffi::gst_bus_pop(self.to_glib_none().0))
        }
    }

    /// Post a message on the given bus. Ownership of the message
    /// is taken by the bus.
    /// ## `message`
    /// the `Message` to post
    ///
    /// # Returns
    ///
    /// `true` if the message could be posted, `false` if the bus is flushing.
    ///
    /// MT safe.
    pub fn post(&self, message: &Message) -> Result<(), glib::error::BoolError> {
        unsafe {
            glib::error::BoolError::from_glib(ffi::gst_bus_post(self.to_glib_none().0, message.to_glib_full()), "Failed to post message")
        }
    }

    /// Removes a signal watch previously added with `Bus::add_signal_watch`.
    ///
    /// MT safe.
    pub fn remove_signal_watch(&self) {
        unsafe {
            ffi::gst_bus_remove_signal_watch(self.to_glib_none().0);
        }
    }

    /// Removes an installed bus watch from `self`.
    ///
    /// # Returns
    ///
    /// `true` on success or `false` if `self` has no event source.
    pub fn remove_watch(&self) -> bool {
        unsafe {
            from_glib(ffi::gst_bus_remove_watch(self.to_glib_none().0))
        }
    }

    /// If `flushing`, flush out and unref any messages queued in the bus. Releases
    /// references to the message origin objects. Will flush future messages until
    /// `Bus::set_flushing` sets `flushing` to `false`.
    ///
    /// MT safe.
    /// ## `flushing`
    /// whether or not to flush the bus
    pub fn set_flushing(&self, flushing: bool) {
        unsafe {
            ffi::gst_bus_set_flushing(self.to_glib_none().0, flushing.to_glib());
        }
    }

    //pub fn set_sync_handler<'a, P: Into<Option<&'a /*Unimplemented*/BusSyncHandler>>>(&self, func: P, notify: /*Unknown conversion*//*Unimplemented*/DestroyNotify) {
    //    unsafe { TODO: call ffi::gst_bus_set_sync_handler() }
    //}

    //pub fn sync_signal_handler<P: Into<Option</*Unimplemented*/Fundamental: Pointer>>>(&self, message: &Message, data: P) -> BusSyncReply {
    //    unsafe { TODO: call ffi::gst_bus_sync_signal_handler() }
    //}

    /// Get a message from the bus, waiting up to the specified timeout.
    ///
    /// If `timeout` is 0, this function behaves like `Bus::pop`. If `timeout` is
    /// `GST_CLOCK_TIME_NONE`, this function will block forever until a message was
    /// posted on the bus.
    /// ## `timeout`
    /// a timeout
    ///
    /// # Returns
    ///
    /// the `Message` that is on the
    ///  bus after the specified timeout or `None` if the bus is empty
    ///  after the timeout expired. The message is taken from the bus
    ///  and needs to be unreffed with `gst_message_unref` after usage.
    ///
    /// MT safe.
    pub fn timed_pop(&self, timeout: ClockTime) -> Option<Message> {
        unsafe {
            from_glib_full(ffi::gst_bus_timed_pop(self.to_glib_none().0, timeout.to_glib()))
        }
    }

    pub fn connect_message<F: Fn(&Bus, &Message) + Send + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe {
            let f: Box_<Box_<Fn(&Bus, &Message) + Send + 'static>> = Box_::new(Box_::new(f));
            connect(self.to_glib_none().0, "message",
                transmute(message_trampoline as usize), Box_::into_raw(f) as *mut _)
        }
    }

    pub fn connect_sync_message<F: Fn(&Bus, &Message) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe {
            let f: Box_<Box_<Fn(&Bus, &Message) + Send + Sync + 'static>> = Box_::new(Box_::new(f));
            connect(self.to_glib_none().0, "sync-message",
                transmute(sync_message_trampoline as usize), Box_::into_raw(f) as *mut _)
        }
    }

    pub fn connect_property_enable_async_notify<F: Fn(&Bus) + Send + Sync + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe {
            let f: Box_<Box_<Fn(&Bus) + Send + Sync + 'static>> = Box_::new(Box_::new(f));
            connect(self.to_glib_none().0, "notify::enable-async",
                transmute(notify_enable_async_trampoline as usize), Box_::into_raw(f) as *mut _)
        }
    }
}

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

unsafe impl Send for Bus {}
unsafe impl Sync for Bus {}

unsafe extern "C" fn message_trampoline(this: *mut ffi::GstBus, message: *mut ffi::GstMessage, f: glib_ffi::gpointer) {
    let f: &&(Fn(&Bus, &Message) + Send + 'static) = transmute(f);
    f(&from_glib_borrow(this), &from_glib_borrow(message))
}

unsafe extern "C" fn sync_message_trampoline(this: *mut ffi::GstBus, message: *mut ffi::GstMessage, f: glib_ffi::gpointer) {
    let f: &&(Fn(&Bus, &Message) + Send + Sync + 'static) = transmute(f);
    f(&from_glib_borrow(this), &from_glib_borrow(message))
}

unsafe extern "C" fn notify_enable_async_trampoline(this: *mut ffi::GstBus, _param_spec: glib_ffi::gpointer, f: glib_ffi::gpointer) {
    let f: &&(Fn(&Bus) + Send + Sync + 'static) = transmute(f);
    f(&from_glib_borrow(this))
}