// 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::Bus;
use crate::Device;
use crate::Object;
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::ToValue;
use std::boxed::Box as Box_;
use std::mem::transmute;

glib::wrapper! {
    /// Applications should create a [`crate::DeviceMonitor`] when they want
    /// to probe, list and monitor devices of a specific type. The
    /// [`crate::DeviceMonitor`] will create the appropriate
    /// [`crate::DeviceProvider`] objects and manage them. It will then post
    /// messages on its [`crate::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
    ///
    /// [`trait@crate::prelude::DeviceMonitorExt`], [`trait@crate::prelude::GstObjectExt`], [`trait@glib::object::ObjectExt`], [`trait@crate::prelude::DeviceMonitorExtManual`]
    pub struct DeviceMonitor(Object<ffi::GstDeviceMonitor, ffi::GstDeviceMonitorClass>) @extends Object;

    match fn {
        type_ => || ffi::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
///
/// [`struct@crate::DeviceMonitor`]
pub trait DeviceMonitorExt: 'static {
    /// Gets the [`crate::Bus`] of this [`crate::DeviceMonitor`]
    ///
    /// # Returns
    ///
    /// a [`crate::Bus`]
    #[doc(alias = "gst_device_monitor_get_bus")]
    #[doc(alias = "get_bus")]
    fn 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 [`crate::glib::List`] of
    ///  [`crate::Device`]
    #[doc(alias = "gst_device_monitor_get_devices")]
    #[doc(alias = "get_devices")]
    fn 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.
    #[doc(alias = "gst_device_monitor_get_providers")]
    #[doc(alias = "get_providers")]
    fn providers(&self) -> Vec<glib::GString>;

    /// Get if `self` is currently showing all devices, even those from hidden
    /// providers.
    ///
    /// # Returns
    ///
    /// [`true`] when all devices will be shown.
    #[doc(alias = "gst_device_monitor_get_show_all_devices")]
    #[doc(alias = "get_show_all_devices")]
    fn shows_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
    #[doc(alias = "gst_device_monitor_set_show_all_devices")]
    fn set_show_all_devices(&self, show_all: bool);

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

    /// Stops monitoring the devices.
    #[doc(alias = "gst_device_monitor_stop")]
    fn stop(&self);

    #[doc(alias = "show-all")]
    fn shows_all(&self) -> bool;

    #[doc(alias = "show-all")]
    fn set_show_all(&self, show_all: bool);

    #[doc(alias = "show-all")]
    fn connect_show_all_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId;
}

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

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

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

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

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

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

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

    fn shows_all(&self) -> bool {
        unsafe {
            let mut value = glib::Value::from_type(<bool as StaticType>::static_type());
            glib::gobject_ffi::g_object_get_property(
                self.to_glib_none().0 as *mut glib::gobject_ffi::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")
        }
    }

    fn set_show_all(&self, show_all: bool) {
        unsafe {
            glib::gobject_ffi::g_object_set_property(
                self.to_glib_none().0 as *mut glib::gobject_ffi::GObject,
                b"show-all\0".as_ptr() as *const _,
                show_all.to_value().to_glib_none().0,
            );
        }
    }

    #[doc(alias = "show-all")]
    fn connect_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 ffi::GstDeviceMonitor,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) where
            P: IsA<DeviceMonitor>,
        {
            let f: &F = &*(f as *const F);
            f(&DeviceMonitor::from_glib_borrow(this).unsafe_cast_ref())
        }
        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::<_, unsafe extern "C" fn()>(
                    notify_show_all_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}