gstreamer/auto/

device_monitor.rs

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

glib::wrapper! {
    /// 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;
    ///  }
    /// ]|
    ///
    /// ## Properties
    ///
    ///
    /// #### `show-all`
    ///  Readable | Writable
    /// <details><summary><h4>Object</h4></summary>
    ///
    ///
    /// #### `name`
    ///  Readable | Writable | 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 | Writable
    /// </details>
    ///
    /// # Implements
    ///
    /// [`DeviceMonitorExt`][trait@crate::prelude::DeviceMonitorExt], [`GstObjectExt`][trait@crate::prelude::GstObjectExt], [`trait@glib::ObjectExt`], [`DeviceMonitorExtManual`][trait@crate::prelude::DeviceMonitorExtManual], [`GstObjectExtManual`][trait@crate::prelude::GstObjectExtManual]
    #[doc(alias = "GstDeviceMonitor")]
    pub struct DeviceMonitor(Object<ffi::GstDeviceMonitor, ffi::GstDeviceMonitorClass>) @extends Object;

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

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

    /// Create a new [`DeviceMonitor`][crate::DeviceMonitor]
    ///
    /// # Returns
    ///
    /// a new device monitor.
    #[doc(alias = "gst_device_monitor_new")]
    pub fn new() -> DeviceMonitor {
        assert_initialized_main_thread!();
        unsafe { from_glib_full(ffi::gst_device_monitor_new()) }
    }
}

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

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

/// Trait containing all [`struct@DeviceMonitor`] methods.
///
/// # Implementors
///
/// [`DeviceMonitor`][struct@crate::DeviceMonitor]
pub trait DeviceMonitorExt: IsA<DeviceMonitor> + 'static {
    /// Gets the [`Bus`][crate::Bus] of this [`DeviceMonitor`][crate::DeviceMonitor]
    ///
    /// # Returns
    ///
    /// a [`Bus`][crate::Bus]
    #[doc(alias = "gst_device_monitor_get_bus")]
    #[doc(alias = "get_bus")]
    fn bus(&self) -> Bus {
        unsafe {
            from_glib_full(ffi::gst_device_monitor_get_bus(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// 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> {
        unsafe {
            FromGlibPtrContainer::from_glib_full(ffi::gst_device_monitor_get_providers(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// 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 {
        unsafe {
            from_glib(ffi::gst_device_monitor_get_show_all_devices(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// 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) {
        unsafe {
            ffi::gst_device_monitor_set_show_all_devices(
                self.as_ref().to_glib_none().0,
                show_all.into_glib(),
            );
        }
    }

    /// Starts monitoring the devices, once this has succeeded, the
    /// `GST_MESSAGE_DEVICE_ADDED` and `GST_MESSAGE_DEVICE_REMOVED` messages
    /// will be emitted on the bus when the list of devices changes.
    ///
    /// Since 1.28, device providers are started asynchronously and
    /// `GST_MESSAGE_DEVICE_MONITOR_STARTED` will be emitted once the initial list
    /// of devices has been populated, signalling that monitor startup has
    /// completed.
    ///
    /// The monitor will hold a strong reference to itself while it is populating
    /// devices asynchronously, so you must call [`stop()`][Self::stop()] before
    /// unreffing if you want monitoring to stop immediately.
    ///
    /// # Returns
    ///
    /// [`true`] if the device monitoring could be started, i.e. at least a
    ///  single device provider was started successfully.
    #[doc(alias = "gst_device_monitor_start")]
    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"
            )
        }
    }

    /// Stops monitoring the devices.
    #[doc(alias = "gst_device_monitor_stop")]
    fn stop(&self) {
        unsafe {
            ffi::gst_device_monitor_stop(self.as_ref().to_glib_none().0);
        }
    }

    #[doc(alias = "show-all")]
    fn shows_all(&self) -> bool {
        ObjectExt::property(self.as_ref(), "show-all")
    }

    #[doc(alias = "show-all")]
    fn set_show_all(&self, show_all: bool) {
        ObjectExt::set_property(self.as_ref(), "show-all", show_all)
    }

    #[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: IsA<DeviceMonitor>,
            F: Fn(&P) + Send + Sync + 'static,
        >(
            this: *mut ffi::GstDeviceMonitor,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                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 _,
                c"notify::show-all".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_show_all_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl<O: IsA<DeviceMonitor>> DeviceMonitorExt for O {}