// 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::GString;
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 Bus;
use Device;
use Object;

glib_wrapper! {
    /// Applications should create a `DeviceMonitor` when they want
    /// to probe, list and monitor devices of a specific type. The
    /// `DeviceMonitor` will create the appropriate
    /// `DeviceProvider` objects and manage them. It will then post
    /// messages on its `Bus` for devices that have been added and
    /// removed.
    ///
    /// The device monitor will monitor all devices matching the filters that
    /// the application has set.
    ///
    /// The basic use pattern of a device monitor is as follows:
    ///
    /// ```text
    ///   static gboolean
    ///   my_bus_func (GstBus * bus, GstMessage * message, gpointer user_data)
    ///   {
    ///      GstDevice *device;
    ///      gchar *name;
    ///
    ///      switch (GST_MESSAGE_TYPE (message)) {
    ///        case GST_MESSAGE_DEVICE_ADDED:
    ///          gst_message_parse_device_added (message, &device);
    ///          name = gst_device_get_display_name (device);
    ///          g_print("Device added: %s\n", name);
    ///          g_free (name);
    ///          gst_object_unref (device);
    ///          break;
    ///        case GST_MESSAGE_DEVICE_REMOVED:
    ///          gst_message_parse_device_removed (message, &device);
    ///          name = gst_device_get_display_name (device);
    ///          g_print("Device removed: %s\n", name);
    ///          g_free (name);
    ///          gst_object_unref (device);
    ///          break;
    ///        default:
    ///          break;
    ///      }
    ///
    ///      return G_SOURCE_CONTINUE;
    ///   }
    ///
    ///   GstDeviceMonitor *
    ///   setup_raw_video_source_device_monitor (void) {
    ///      GstDeviceMonitor *monitor;
    ///      GstBus *bus;
    ///      GstCaps *caps;
    ///
    ///      monitor = gst_device_monitor_new ();
    ///
    ///      bus = gst_device_monitor_get_bus (monitor);
    ///      gst_bus_add_watch (bus, my_bus_func, NULL);
    ///      gst_object_unref (bus);
    ///
    ///      caps = gst_caps_new_empty_simple ("video/x-raw");
    ///      gst_device_monitor_add_filter (monitor, "Video/Source", caps);
    ///      gst_caps_unref (caps);
    ///
    ///      gst_device_monitor_start (monitor);
    ///
    ///      return monitor;
    ///   }
    /// ```
    ///
    /// # Implements
    ///
    /// [`DeviceMonitorExt`](trait.DeviceMonitorExt.html), [`GstObjectExt`](trait.GstObjectExt.html), [`glib::object::ObjectExt`](../glib/object/trait.ObjectExt.html)
    pub struct DeviceMonitor(Object<gst_sys::GstDeviceMonitor, gst_sys::GstDeviceMonitorClass, DeviceMonitorClass>) @extends Object;

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

unsafe impl Send for DeviceMonitor {}
unsafe impl Sync for DeviceMonitor {}

pub const NONE_DEVICE_MONITOR: Option<&DeviceMonitor> = None;

/// Trait containing all `DeviceMonitor` methods.
///
/// # Implementors
///
/// [`DeviceMonitor`](struct.DeviceMonitor.html)
pub trait DeviceMonitorExt: 'static {
    /// Gets the `Bus` of this `DeviceMonitor`
    ///
    /// # Returns
    ///
    /// a `Bus`
    fn get_bus(&self) -> Bus;

    /// Gets a list of devices from all of the relevant monitors. This may actually
    /// probe the hardware if the monitor is not currently started.
    ///
    /// # Returns
    ///
    /// a `glib::List` of
    ///  `Device`
    fn get_devices(&self) -> Vec<Device>;

    /// Get a list of the currently selected device provider factories.
    ///
    /// This
    ///
    /// # Returns
    ///
    ///
    ///  A list of device provider factory names that are currently being
    ///  monitored by `self` or `None` when nothing is being monitored.
    fn get_providers(&self) -> Vec<GString>;

    /// Get if `self` is curretly showing all devices, even those from hidden
    /// providers.
    ///
    /// # Returns
    ///
    /// `true` when all devices will be shown.
    fn get_show_all_devices(&self) -> bool;

    /// Set if all devices should be visible, even those devices from hidden
    /// providers. Setting `show_all` to true might show some devices multiple times.
    /// ## `show_all`
    /// show all devices
    fn set_show_all_devices(&self, show_all: bool);

    /// Starts monitoring the devices, one this has succeeded, the
    /// `MessageType::DeviceAdded` and `MessageType::DeviceRemoved` messages
    /// will be emitted on the bus when the list of devices changes.
    ///
    /// # Returns
    ///
    /// `true` if the device monitoring could be started
    fn start(&self) -> Result<(), glib::error::BoolError>;

    /// Stops monitoring the devices.
    fn stop(&self);

    fn get_property_show_all(&self) -> bool;

    fn set_property_show_all(&self, show_all: bool);

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

impl<O: IsA<DeviceMonitor>> DeviceMonitorExt for O {
    fn get_bus(&self) -> Bus {
        unsafe {
            from_glib_full(gst_sys::gst_device_monitor_get_bus(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn get_devices(&self) -> Vec<Device> {
        unsafe {
            FromGlibPtrContainer::from_glib_full(gst_sys::gst_device_monitor_get_devices(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn get_providers(&self) -> Vec<GString> {
        unsafe {
            FromGlibPtrContainer::from_glib_full(gst_sys::gst_device_monitor_get_providers(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn get_show_all_devices(&self) -> bool {
        unsafe {
            from_glib(gst_sys::gst_device_monitor_get_show_all_devices(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn set_show_all_devices(&self, show_all: bool) {
        unsafe {
            gst_sys::gst_device_monitor_set_show_all_devices(
                self.as_ref().to_glib_none().0,
                show_all.to_glib(),
            );
        }
    }

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

    fn stop(&self) {
        unsafe {
            gst_sys::gst_device_monitor_stop(self.as_ref().to_glib_none().0);
        }
    }

    fn get_property_show_all(&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"show-all\0".as_ptr() as *const _,
                value.to_glib_none_mut().0,
            );
            value
                .get()
                .expect("Return Value for property `show-all` getter")
                .unwrap()
        }
    }

    fn set_property_show_all(&self, show_all: bool) {
        unsafe {
            gobject_sys::g_object_set_property(
                self.to_glib_none().0 as *mut gobject_sys::GObject,
                b"show-all\0".as_ptr() as *const _,
                Value::from(&show_all).to_glib_none().0,
            );
        }
    }

    fn connect_property_show_all_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_show_all_trampoline<P, F: Fn(&P) + Send + Sync + 'static>(
            this: *mut gst_sys::GstDeviceMonitor,
            _param_spec: glib_sys::gpointer,
            f: glib_sys::gpointer,
        ) where
            P: IsA<DeviceMonitor>,
        {
            let f: &F = &*(f as *const F);
            f(&DeviceMonitor::from_glib_borrow(this).unsafe_cast())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::show-all\0".as_ptr() as *const _,
                Some(transmute(notify_show_all_trampoline::<Self, F> as usize)),
                Box_::into_raw(f),
            )
        }
    }
}