alsaseq/auto/

user_client.rs

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

use crate::{
    ffi, ClientInfo, ClientPool, Event, EventCntr, PortInfo, QueueInfo, QueueTempo, RemoveFilter,
    SubscribeData,
};
use glib::{
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    /// A GObject-derived object to express user client.
    ///
    /// A [`UserClient`][crate::UserClient] is a GObject-derived object to express user client. Any port can be added
    /// to the client as destination or source for any event.
    ///
    /// When the call of [`UserClientExt::open()`][crate::prelude::UserClientExt::open()] the object maintain file descriptor till object
    /// destruction. The call of [`UserClientExt::create_source()`][crate::prelude::UserClientExt::create_source()] returns the instance of
    /// [`glib::Source`][crate::glib::Source]. Once attached to the [`glib::Source`][crate::glib::Source],
    /// `GLib::MainContext` / `GLib::MainLoop` is available as event dispatcher. The
    /// [`handle-event`][struct@crate::UserClient#handle-event] signal is emitted in the event dispatcher to notify the
    /// event. The call of [`UserClientExt::schedule_event()`][crate::prelude::UserClientExt::schedule_event()] schedules event with given parameters.
    ///
    /// ## Properties
    ///
    ///
    /// #### `client-id`
    ///  The numeric ID of the client.
    ///
    /// Readable
    ///
    /// ## Signals
    ///
    ///
    /// #### `handle-event`
    ///  When event occurs, this signal is emit with the instance of object which includes batch of
    /// of events.
    ///
    ///
    ///
    /// # Implements
    ///
    /// [`UserClientExt`][trait@crate::prelude::UserClientExt], [`UserClientExtManual`][trait@crate::prelude::UserClientExtManual]
    #[doc(alias = "ALSASeqUserClient")]
    pub struct UserClient(Object<ffi::ALSASeqUserClient, ffi::ALSASeqUserClientClass>);

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

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

    /// Allocate and return an instance of [`UserClient`][crate::UserClient].
    ///
    /// # Returns
    ///
    /// An instance of [`UserClient`][crate::UserClient].
    #[doc(alias = "alsaseq_user_client_new")]
    pub fn new() -> UserClient {
        unsafe { from_glib_full(ffi::alsaseq_user_client_new()) }
    }
}

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

/// Trait containing the part of [`struct@UserClient`] methods.
///
/// # Implementors
///
/// [`UserClient`][struct@crate::UserClient]
pub trait UserClientExt: IsA<UserClient> + 'static {
    /// Allocate [`glib::Source`][crate::glib::Source] structure to handle events from ALSA seq character device. In each
    /// iteration of `GLib::MainContext`, the `read(2)` system call is exected to dispatch
    /// sequencer event for [`handle-event`][struct@crate::UserClient#handle-event] signal, according to the result of
    /// `poll(2)` system call.
    ///
    /// # Returns
    ///
    /// [`true`] when the overall operation finishes successfully, else [`false`].
    ///
    /// ## `gsrc`
    /// A #GSource to handle events from ALSA seq character device.
    #[doc(alias = "alsaseq_user_client_create_source")]
    fn create_source(&self) -> Result<glib::Source, glib::Error> {
        unsafe {
            let mut gsrc = std::ptr::null_mut();
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::alsaseq_user_client_create_source(
                self.as_ref().to_glib_none().0,
                &mut gsrc,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(from_glib_full(gsrc))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Delete a port from the client.
    ///
    /// The call of function executes `ioctl(2)` system call with `SNDRV_SEQ_IOCTL_DELETE_PORT` command
    /// for ALSA sequencer character device.
    /// ## `port_id`
    /// The numeric ID of port.
    ///
    /// # Returns
    ///
    /// [`true`] when the overall operation finishes successfully, else [`false`].
    #[doc(alias = "alsaseq_user_client_delete_port")]
    fn delete_port(&self, port_id: u8) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::alsaseq_user_client_delete_port(
                self.as_ref().to_glib_none().0,
                port_id,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Delete the queue owned by the client.
    ///
    /// The call of function executes `ioctl(2)` system call with `SNDRV_SEQ_IOCTL_DELETE_QUEUE` command
    /// for ALSA sequencer character device.
    /// ## `queue_id`
    /// The numeric ID of queue. An entry of [`SpecificQueueId`][crate::SpecificQueueId] is available as well.
    ///
    /// # Returns
    ///
    /// [`true`] when the overall operation finishes successfully, else [`false`].
    #[doc(alias = "alsaseq_user_client_delete_queue")]
    fn delete_queue(&self, queue_id: u8) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::alsaseq_user_client_delete_queue(
                self.as_ref().to_glib_none().0,
                queue_id,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Get the data of tempo for the queue.
    ///
    /// The call of function executes `ioctl(2)` system call with `SNDRV_SEQ_IOCTL_GET_QUEUE_TEMPO`
    /// command for ALSA sequencer character device.
    /// ## `queue_id`
    /// The numeric ID of queue. An entry of [`SpecificQueueId`][crate::SpecificQueueId] is available as well.
    ///
    /// # Returns
    ///
    /// [`true`] when the overall operation finishes successfully, else [`false`].
    ///
    /// ## `queue_tempo`
    /// The data of tempo for queue.
    #[doc(alias = "alsaseq_user_client_get_queue_tempo")]
    #[doc(alias = "get_queue_tempo")]
    fn queue_tempo(&self, queue_id: u8) -> Result<QueueTempo, glib::Error> {
        unsafe {
            let mut queue_tempo = std::ptr::null_mut();
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::alsaseq_user_client_get_queue_tempo(
                self.as_ref().to_glib_none().0,
                queue_id,
                &mut queue_tempo,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(from_glib_full(queue_tempo))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Get usage of the queue by the client.
    ///
    /// The call of function executes `ioctl(2)` system call with `SNDRV_SEQ_IOCTL_GET_QUEUE_CLIENT`
    /// command for ALSA sequencer character device.
    /// ## `queue_id`
    /// The numeric ID of queue. An entry of [`SpecificQueueId`][crate::SpecificQueueId] is available as well.
    ///
    /// # Returns
    ///
    /// [`true`] when the overall operation finishes successfully, else [`false`].
    ///
    /// ## `use_`
    /// Whether the client uses the queue or not.
    #[doc(alias = "alsaseq_user_client_get_queue_usage")]
    #[doc(alias = "get_queue_usage")]
    fn queue_usage(&self, queue_id: u8) -> Result<bool, glib::Error> {
        unsafe {
            let mut use_ = std::mem::MaybeUninit::uninit();
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::alsaseq_user_client_get_queue_usage(
                self.as_ref().to_glib_none().0,
                queue_id,
                use_.as_mut_ptr(),
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(from_glib(use_.assume_init()))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Open ALSA sequencer character device.
    ///
    /// The call of function executes `open(2)` system call, then executes `ioctl(2)` system call with
    /// `SNDRV_SEQ_IOCTL_CLIENT_ID` command for ALSA sequencer character device.
    /// ## `open_flag`
    /// The flag of `open(2)` system call. `O_RDWR` is forced to fulfil internally.
    ///
    /// # Returns
    ///
    /// [`true`] when the overall operation finishes successfully, else [`false`].
    #[doc(alias = "alsaseq_user_client_open")]
    fn open(&self, open_flag: i32) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::alsaseq_user_client_open(
                self.as_ref().to_glib_none().0,
                open_flag,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Operate subscription between two ports pointed by the data.
    ///
    /// The call of function executes `ioctl(2)` system call with `SNDRV_SEQ_IOCTL_SUBSCRIBE_PORT` and
    /// `SNDRV_SEQ_IOCTL_UNSUBSCRIBE_PORT` commands for ALSA sequencer character device.
    /// ## `subs_data`
    /// A [`SubscribeData`][crate::SubscribeData].
    /// ## `establish`
    /// Whether to establish subscription between two ports, or break it.
    ///
    /// # Returns
    ///
    /// [`true`] when the overall operation finishes successfully, else [`false`].
    #[doc(alias = "alsaseq_user_client_operate_subscription")]
    fn operate_subscription(
        &self,
        subs_data: &impl IsA<SubscribeData>,
        establish: bool,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::alsaseq_user_client_operate_subscription(
                self.as_ref().to_glib_none().0,
                subs_data.as_ref().to_glib_none().0,
                establish.into_glib(),
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Remove queued events according to the filter.
    ///
    /// The call of function executes `ioctl(2)` system call with `SNDRV_SEQ_IOCTL_REMOVE_EVENTS`
    /// command for ALSA sequencer character device.
    /// ## `filter`
    /// A [`RemoveFilter`][crate::RemoveFilter].
    ///
    /// # Returns
    ///
    /// [`true`] when the overall operation finishes successfully, else [`false`].
    #[doc(alias = "alsaseq_user_client_remove_events")]
    fn remove_events(&self, filter: &impl IsA<RemoveFilter>) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::alsaseq_user_client_remove_events(
                self.as_ref().to_glib_none().0,
                filter.as_ref().to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Deliver the event immediately, or schedule it into memory pool of the client.
    ///
    /// The call of function executes `write(2)` system call for ALSA sequencer character device. When
    /// [`output-free`][struct@crate::ClientPool#output-free] is less than [`Event::calculate_pool_consumption()`][crate::Event::calculate_pool_consumption()] and
    /// [`open()`][Self::open()] is called without non-blocking flag, the user process can be blocked
    /// untill enough number of cells becomes available.
    /// ## `event`
    /// An instance of [`Event`][crate::Event].
    ///
    /// # Returns
    ///
    /// [`true`] when the overall operation finishes successfully, else [`false`].
    #[doc(alias = "alsaseq_user_client_schedule_event")]
    fn schedule_event(&self, event: &Event) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::alsaseq_user_client_schedule_event(
                self.as_ref().to_glib_none().0,
                event.to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Get client information.
    ///
    /// The call of function executes `ioctl(2)` system call with `SNDRV_SEQ_IOCTL_SET_CLIENT_INFO`
    /// command for ALSA sequencer character device.
    /// ## `client_info`
    /// A [`ClientInfo`][crate::ClientInfo].
    ///
    /// # Returns
    ///
    /// [`true`] when the overall operation finishes successfully, else [`false`].
    #[doc(alias = "alsaseq_user_client_set_info")]
    fn set_info(&self, client_info: &impl IsA<ClientInfo>) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::alsaseq_user_client_set_info(
                self.as_ref().to_glib_none().0,
                client_info.as_ref().to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Configure memory pool in the client.
    ///
    /// The call of function executes `ioctl(2)` system call with `SNDRV_SEQ_IOCTL_SET_CLIENT_POOL`
    /// command for ALSA sequencer character device.
    /// ## `client_pool`
    /// A [`ClientPool`][crate::ClientPool] to be configured for the client.
    ///
    /// # Returns
    ///
    /// [`true`] when the overall operation finishes successfully, else [`false`].
    #[doc(alias = "alsaseq_user_client_set_pool")]
    fn set_pool(&self, client_pool: &impl IsA<ClientPool>) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::alsaseq_user_client_set_pool(
                self.as_ref().to_glib_none().0,
                client_pool.as_ref().to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Set the data of tempo to the queue.
    ///
    /// The call of function executes `ioctl(2)` system call with `SNDRV_SEQ_IOCTL_SET_QUEUE_TEMPO`
    /// command for ALSA sequencer character device.
    /// ## `queue_id`
    /// The numeric ID of queue. An entry of [`SpecificQueueId`][crate::SpecificQueueId] is available as well.
    /// ## `queue_tempo`
    /// The data of tempo for queue.
    ///
    /// # Returns
    ///
    /// [`true`] when the overall operation finishes successfully, else [`false`].
    #[doc(alias = "alsaseq_user_client_set_queue_tempo")]
    fn set_queue_tempo(
        &self,
        queue_id: u8,
        queue_tempo: &impl IsA<QueueTempo>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::alsaseq_user_client_set_queue_tempo(
                self.as_ref().to_glib_none().0,
                queue_id,
                queue_tempo.as_ref().to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Start the queue to use or not.
    ///
    /// The call of function executes `ioctl(2)` system call with `SNDRV_SEQ_IOCTL_SET_QUEUE_CLIENT`
    /// command for ALSA sequencer character device.
    /// ## `queue_id`
    /// The numeric ID of queue. An entry of [`SpecificQueueId`][crate::SpecificQueueId] is available as well.
    /// ## `use_`
    /// Whether to use the queue or not.
    ///
    /// # Returns
    ///
    /// [`true`] when the overall operation finishes successfully, else [`false`].
    #[doc(alias = "alsaseq_user_client_set_queue_usage")]
    fn set_queue_usage(&self, queue_id: u8, use_: bool) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::alsaseq_user_client_set_queue_usage(
                self.as_ref().to_glib_none().0,
                queue_id,
                use_.into_glib(),
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Update port information.
    ///
    /// The call of function executes `ioctl(2)` system call with `SNDRV_SEQ_IOCTL_SET_PORT_INFO` command
    /// for ALSA sequencer character device.
    /// ## `port_info`
    /// A [`PortInfo`][crate::PortInfo].
    /// ## `port_id`
    /// The numeric ID of port.
    ///
    /// # Returns
    ///
    /// [`true`] when the overall operation finishes successfully, else [`false`].
    #[doc(alias = "alsaseq_user_client_update_port")]
    fn update_port(&self, port_info: &impl IsA<PortInfo>, port_id: u8) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::alsaseq_user_client_update_port(
                self.as_ref().to_glib_none().0,
                port_info.as_ref().to_glib_none().0,
                port_id,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Update owned queue according to the information.
    ///
    /// The call of function executes `ioctl(2)` system call with `SNDRV_SEQ_IOCTL_SET_QUEUE_INFO`
    /// command for ALSA sequencer character device.
    /// ## `queue_info`
    /// The information of queue to add.
    ///
    /// # Returns
    ///
    /// [`true`] when the overall operation finishes successfully, else [`false`].
    #[doc(alias = "alsaseq_user_client_update_queue")]
    fn update_queue(&self, queue_info: &impl IsA<QueueInfo>) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::alsaseq_user_client_update_queue(
                self.as_ref().to_glib_none().0,
                queue_info.as_ref().to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// The numeric ID of the client.
    #[doc(alias = "client-id")]
    fn client_id(&self) -> u8 {
        ObjectExt::property(self.as_ref(), "client-id")
    }

    /// When event occurs, this signal is emit with the instance of object which includes batch of
    /// of events.
    /// ## `ev_cntr`
    /// The instance of [`EventCntr`][crate::EventCntr] which includes batch of events.
    #[doc(alias = "handle-event")]
    fn connect_handle_event<F: Fn(&Self, &EventCntr) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn handle_event_trampoline<
            P: IsA<UserClient>,
            F: Fn(&P, &EventCntr) + 'static,
        >(
            this: *mut ffi::ALSASeqUserClient,
            ev_cntr: *mut ffi::ALSASeqEventCntr,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                UserClient::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(ev_cntr),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"handle-event".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    handle_event_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "client-id")]
    fn connect_client_id_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_client_id_trampoline<
            P: IsA<UserClient>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::ALSASeqUserClient,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(UserClient::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::client-id".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_client_id_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl<O: IsA<UserClient>> UserClientExt for O {}