gdk/auto/

seat.rs

// 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 crate::{Cursor, Device, DeviceTool, Display, Event, GrabStatus, SeatCapabilities, Window};
use glib::{
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::{boxed::Box as Box_, fmt, mem::transmute};

glib::wrapper! {
    /// The [`Seat`][crate::Seat] object represents a collection of input devices
    /// that belong to a user.
    ///
    /// This is an Abstract Base Class, you cannot instantiate it.
    ///
    /// ## Properties
    ///
    ///
    /// #### `display`
    ///  [`Display`][crate::Display] of this seat.
    ///
    /// Readable | Writeable | Construct Only
    ///
    /// ## Signals
    ///
    ///
    /// #### `device-added`
    ///  The ::device-added signal is emitted when a new input
    /// device is related to this seat.
    ///
    ///
    ///
    ///
    /// #### `device-removed`
    ///  The ::device-removed signal is emitted when an
    /// input device is removed (e.g. unplugged).
    ///
    ///
    ///
    ///
    /// #### `tool-added`
    ///  The ::tool-added signal is emitted whenever a new tool
    /// is made known to the seat. The tool may later be assigned
    /// to a device (i.e. on proximity with a tablet). The device
    /// will emit the [`tool-changed`][struct@crate::Device#tool-changed] signal accordingly.
    ///
    /// A same tool may be used by several devices.
    ///
    ///
    ///
    ///
    /// #### `tool-removed`
    ///  This signal is emitted whenever a tool is no longer known
    /// to this `seat`.
    ///
    ///
    ///
    /// # Implements
    ///
    /// [`SeatExt`][trait@crate::prelude::SeatExt]
    #[doc(alias = "GdkSeat")]
    pub struct Seat(Object<ffi::GdkSeat>);

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

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

mod sealed {
    pub trait Sealed {}
    impl<T: super::IsA<super::Seat>> Sealed for T {}
}

/// Trait containing all [`struct@Seat`] methods.
///
/// # Implementors
///
/// [`Seat`][struct@crate::Seat]
pub trait SeatExt: IsA<Seat> + sealed::Sealed + 'static {
    /// Returns the capabilities this [`Seat`][crate::Seat] currently has.
    ///
    /// # Returns
    ///
    /// the seat capabilities
    #[doc(alias = "gdk_seat_get_capabilities")]
    #[doc(alias = "get_capabilities")]
    fn capabilities(&self) -> SeatCapabilities {
        unsafe {
            from_glib(ffi::gdk_seat_get_capabilities(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns the [`Display`][crate::Display] this seat belongs to.
    ///
    /// # Returns
    ///
    /// a [`Display`][crate::Display]. This object is owned by GTK+
    ///  and must not be freed.
    #[doc(alias = "gdk_seat_get_display")]
    #[doc(alias = "get_display")]
    fn display(&self) -> Option<Display> {
        unsafe { from_glib_none(ffi::gdk_seat_get_display(self.as_ref().to_glib_none().0)) }
    }

    /// Returns the master device that routes keyboard events.
    ///
    /// # Returns
    ///
    /// a master [`Device`][crate::Device] with keyboard
    ///  capabilities. This object is owned by GTK+ and must not be freed.
    #[doc(alias = "gdk_seat_get_keyboard")]
    #[doc(alias = "get_keyboard")]
    fn keyboard(&self) -> Option<Device> {
        unsafe { from_glib_none(ffi::gdk_seat_get_keyboard(self.as_ref().to_glib_none().0)) }
    }

    /// Returns the master device that routes pointer events.
    ///
    /// # Returns
    ///
    /// a master [`Device`][crate::Device] with pointer
    ///  capabilities. This object is owned by GTK+ and must not be freed.
    #[doc(alias = "gdk_seat_get_pointer")]
    #[doc(alias = "get_pointer")]
    fn pointer(&self) -> Option<Device> {
        unsafe { from_glib_none(ffi::gdk_seat_get_pointer(self.as_ref().to_glib_none().0)) }
    }

    /// Returns the slave devices that match the given capabilities.
    /// ## `capabilities`
    /// capabilities to get devices for
    ///
    /// # Returns
    ///
    /// A list of `GdkDevices`.
    ///  The list must be freed with `g_list_free()`, the elements are owned
    ///  by GDK and must not be freed.
    #[doc(alias = "gdk_seat_get_slaves")]
    #[doc(alias = "get_slaves")]
    fn slaves(&self, capabilities: SeatCapabilities) -> Vec<Device> {
        unsafe {
            FromGlibPtrContainer::from_glib_container(ffi::gdk_seat_get_slaves(
                self.as_ref().to_glib_none().0,
                capabilities.into_glib(),
            ))
        }
    }

    /// Grabs the seat so that all events corresponding to the given `capabilities`
    /// are passed to this application until the seat is ungrabbed with [`ungrab()`][Self::ungrab()],
    /// or the window becomes hidden. This overrides any previous grab on the
    /// seat by this client.
    ///
    /// As a rule of thumb, if a grab is desired over [`SeatCapabilities::POINTER`][crate::SeatCapabilities::POINTER],
    /// all other "pointing" capabilities (eg. [`SeatCapabilities::TOUCH`][crate::SeatCapabilities::TOUCH]) should
    /// be grabbed too, so the user is able to interact with all of those while
    /// the grab holds, you should thus use [`SeatCapabilities::ALL_POINTING`][crate::SeatCapabilities::ALL_POINTING] most
    /// commonly.
    ///
    /// Grabs are used for operations which need complete control over the
    /// events corresponding to the given capabilities. For example in GTK+ this
    /// is used for Drag and Drop operations, popup menus and such.
    ///
    /// Note that if the event mask of a [`Window`][crate::Window] has selected both button press
    /// and button release events, or touch begin and touch end, then a press event
    /// will cause an automatic grab until the button is released, equivalent to a
    /// grab on the window with `owner_events` set to [`true`]. This is done because most
    /// applications expect to receive paired press and release events.
    ///
    /// If you set up anything at the time you take the grab that needs to be
    /// cleaned up when the grab ends, you should handle the [`EventGrabBroken`][crate::EventGrabBroken]
    /// events that are emitted when the grab ends unvoluntarily.
    /// ## `window`
    /// the [`Window`][crate::Window] which will own the grab
    /// ## `capabilities`
    /// capabilities that will be grabbed
    /// ## `owner_events`
    /// if [`false`] then all device events are reported with respect to
    ///  `window` and are only reported if selected by `event_mask`. If
    ///  [`true`] then pointer events for this application are reported
    ///  as normal, but pointer events outside this application are
    ///  reported with respect to `window` and only if selected by
    ///  `event_mask`. In either mode, unreported events are discarded.
    /// ## `cursor`
    /// the cursor to display while the grab is active. If
    ///  this is [`None`] then the normal cursors are used for
    ///  `window` and its descendants, and the cursor for `window` is used
    ///  elsewhere.
    /// ## `event`
    /// the event that is triggering the grab, or [`None`] if none
    ///  is available.
    /// ## `prepare_func`
    /// function to
    ///  prepare the window to be grabbed, it can be [`None`] if `window` is
    ///  visible before this call.
    /// ## `prepare_func_data`
    /// user data to pass to `prepare_func`
    ///
    /// # Returns
    ///
    /// [`GrabStatus::Success`][crate::GrabStatus::Success] if the grab was successful.
    #[doc(alias = "gdk_seat_grab")]
    fn grab(
        &self,
        window: &Window,
        capabilities: SeatCapabilities,
        owner_events: bool,
        cursor: Option<&Cursor>,
        event: Option<&Event>,
        prepare_func: Option<&mut dyn (FnMut(&Seat, &Window))>,
    ) -> GrabStatus {
        let prepare_func_data: Option<&mut dyn (FnMut(&Seat, &Window))> = prepare_func;
        unsafe extern "C" fn prepare_func_func(
            seat: *mut ffi::GdkSeat,
            window: *mut ffi::GdkWindow,
            user_data: glib::ffi::gpointer,
        ) {
            let seat = from_glib_borrow(seat);
            let window = from_glib_borrow(window);
            let callback: *mut Option<&mut dyn (FnMut(&Seat, &Window))> =
                user_data as *const _ as usize as *mut Option<&mut dyn (FnMut(&Seat, &Window))>;
            if let Some(ref mut callback) = *callback {
                callback(&seat, &window)
            } else {
                panic!("cannot get closure...")
            }
        }
        let prepare_func = if prepare_func_data.is_some() {
            Some(prepare_func_func as _)
        } else {
            None
        };
        let super_callback0: &Option<&mut dyn (FnMut(&Seat, &Window))> = &prepare_func_data;
        unsafe {
            from_glib(ffi::gdk_seat_grab(
                self.as_ref().to_glib_none().0,
                window.to_glib_none().0,
                capabilities.into_glib(),
                owner_events.into_glib(),
                cursor.to_glib_none().0,
                event.to_glib_none().0,
                prepare_func,
                super_callback0 as *const _ as usize as *mut _,
            ))
        }
    }

    /// Releases a grab added through [`grab()`][Self::grab()].
    #[doc(alias = "gdk_seat_ungrab")]
    fn ungrab(&self) {
        unsafe {
            ffi::gdk_seat_ungrab(self.as_ref().to_glib_none().0);
        }
    }

    /// The ::device-added signal is emitted when a new input
    /// device is related to this seat.
    /// ## `device`
    /// the newly added [`Device`][crate::Device].
    #[doc(alias = "device-added")]
    fn connect_device_added<F: Fn(&Self, &Device) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn device_added_trampoline<P: IsA<Seat>, F: Fn(&P, &Device) + 'static>(
            this: *mut ffi::GdkSeat,
            device: *mut ffi::GdkDevice,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                Seat::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(device),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"device-added\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    device_added_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The ::device-removed signal is emitted when an
    /// input device is removed (e.g. unplugged).
    /// ## `device`
    /// the just removed [`Device`][crate::Device].
    #[doc(alias = "device-removed")]
    fn connect_device_removed<F: Fn(&Self, &Device) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn device_removed_trampoline<
            P: IsA<Seat>,
            F: Fn(&P, &Device) + 'static,
        >(
            this: *mut ffi::GdkSeat,
            device: *mut ffi::GdkDevice,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                Seat::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(device),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"device-removed\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    device_removed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The ::tool-added signal is emitted whenever a new tool
    /// is made known to the seat. The tool may later be assigned
    /// to a device (i.e. on proximity with a tablet). The device
    /// will emit the [`tool-changed`][struct@crate::Device#tool-changed] signal accordingly.
    ///
    /// A same tool may be used by several devices.
    /// ## `tool`
    /// the new [`DeviceTool`][crate::DeviceTool] known to the seat
    #[doc(alias = "tool-added")]
    fn connect_tool_added<F: Fn(&Self, &DeviceTool) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn tool_added_trampoline<
            P: IsA<Seat>,
            F: Fn(&P, &DeviceTool) + 'static,
        >(
            this: *mut ffi::GdkSeat,
            tool: *mut ffi::GdkDeviceTool,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                Seat::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(tool),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"tool-added\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    tool_added_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// This signal is emitted whenever a tool is no longer known
    /// to this `seat`.
    /// ## `tool`
    /// the just removed [`DeviceTool`][crate::DeviceTool]
    #[doc(alias = "tool-removed")]
    fn connect_tool_removed<F: Fn(&Self, &DeviceTool) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn tool_removed_trampoline<
            P: IsA<Seat>,
            F: Fn(&P, &DeviceTool) + 'static,
        >(
            this: *mut ffi::GdkSeat,
            tool: *mut ffi::GdkDeviceTool,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                Seat::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(tool),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"tool-removed\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    tool_removed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl<O: IsA<Seat>> SeatExt for O {}

impl fmt::Display for Seat {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str("Seat")
    }
}