1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
// 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::Device;
use crate::DeviceType;
use crate::Display;
use glib::object::ObjectType as ObjectType_;
use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*;
use std::boxed::Box as Box_;
use std::fmt;
use std::mem::transmute;

glib::wrapper! {
    /// In addition to a single pointer and keyboard for user interface input,
    /// GDK contains support for a variety of input devices, including graphics
    /// tablets, touchscreens and multiple pointers/keyboards interacting
    /// simultaneously with the user interface. Such input devices often have
    /// additional features, such as sub-pixel positioning information and
    /// additional device-dependent information.
    ///
    /// In order to query the device hierarchy and be aware of changes in the
    /// device hierarchy (such as virtual devices being created or removed, or
    /// physical devices being plugged or unplugged), GDK provides
    /// [`DeviceManager`][crate::DeviceManager].
    ///
    /// By default, and if the platform supports it, GDK is aware of multiple
    /// keyboard/pointer pairs and multitouch devices. This behavior can be
    /// changed by calling `gdk_disable_multidevice()` before [`Display::open()`][crate::Display::open()].
    /// There should rarely be a need to do that though, since GDK defaults
    /// to a compatibility mode in which it will emit just one enter/leave
    /// event pair for all devices on a window. To enable per-device
    /// enter/leave events and other multi-pointer interaction features,
    /// [`Window::set_support_multidevice()`][crate::Window::set_support_multidevice()] must be called on
    /// `GdkWindows` (or `gtk_widget_set_support_multidevice()` on widgets).
    /// window. See the [`Window::set_support_multidevice()`][crate::Window::set_support_multidevice()] documentation
    /// for more information.
    ///
    /// On X11, multi-device support is implemented through XInput 2.
    /// Unless `gdk_disable_multidevice()` is called, the XInput 2
    /// [`DeviceManager`][crate::DeviceManager] implementation will be used as the input source.
    /// Otherwise either the core or XInput 1 implementations will be used.
    ///
    /// For simple applications that don’t have any special interest in
    /// input devices, the so-called “client pointer”
    /// provides a reasonable approximation to a simple setup with a single
    /// pointer and keyboard. The device that has been set as the client
    /// pointer can be accessed via [`client_pointer()`][Self::client_pointer()].
    ///
    /// Conceptually, in multidevice mode there are 2 device types. Virtual
    /// devices (or master devices) are represented by the pointer cursors
    /// and keyboard foci that are seen on the screen. Physical devices (or
    /// slave devices) represent the hardware that is controlling the virtual
    /// devices, and thus have no visible cursor on the screen.
    ///
    /// Virtual devices are always paired, so there is a keyboard device for every
    /// pointer device. Associations between devices may be inspected through
    /// [`Device::associated_device()`][crate::Device::associated_device()].
    ///
    /// There may be several virtual devices, and several physical devices could
    /// be controlling each of these virtual devices. Physical devices may also
    /// be “floating”, which means they are not attached to any virtual device.
    ///
    /// # Master and slave devices
    ///
    ///
    /// ```text
    /// carlos@sacarino:~$ xinput list
    /// ⎡ Virtual core pointer                          id=2    [master pointer  (3)]
    /// ⎜   ↳ Virtual core XTEST pointer                id=4    [slave  pointer  (2)]
    /// ⎜   ↳ Wacom ISDv4 E6 Pen stylus                 id=10   [slave  pointer  (2)]
    /// ⎜   ↳ Wacom ISDv4 E6 Finger touch               id=11   [slave  pointer  (2)]
    /// ⎜   ↳ SynPS/2 Synaptics TouchPad                id=13   [slave  pointer  (2)]
    /// ⎜   ↳ TPPS/2 IBM TrackPoint                     id=14   [slave  pointer  (2)]
    /// ⎜   ↳ Wacom ISDv4 E6 Pen eraser                 id=16   [slave  pointer  (2)]
    /// ⎣ Virtual core keyboard                         id=3    [master keyboard (2)]
    ///     ↳ Virtual core XTEST keyboard               id=5    [slave  keyboard (3)]
    ///     ↳ Power Button                              id=6    [slave  keyboard (3)]
    ///     ↳ Video Bus                                 id=7    [slave  keyboard (3)]
    ///     ↳ Sleep Button                              id=8    [slave  keyboard (3)]
    ///     ↳ Integrated Camera                         id=9    [slave  keyboard (3)]
    ///     ↳ AT Translated Set 2 keyboard              id=12   [slave  keyboard (3)]
    ///     ↳ ThinkPad Extra Buttons                    id=15   [slave  keyboard (3)]
    /// ```
    ///
    /// By default, GDK will automatically listen for events coming from all
    /// master devices, setting the [`Device`][crate::Device] for all events coming from input
    /// devices. Events containing device information are [`EventType::MotionNotify`][crate::EventType::MotionNotify],
    /// [`EventType::ButtonPress`][crate::EventType::ButtonPress], [`EventType::_2buttonPress`][crate::EventType::_2buttonPress], [`EventType::_3buttonPress`][crate::EventType::_3buttonPress],
    /// [`EventType::ButtonRelease`][crate::EventType::ButtonRelease], [`EventType::Scroll`][crate::EventType::Scroll], [`EventType::KeyPress`][crate::EventType::KeyPress], [`EventType::KeyRelease`][crate::EventType::KeyRelease],
    /// [`EventType::EnterNotify`][crate::EventType::EnterNotify], [`EventType::LeaveNotify`][crate::EventType::LeaveNotify], [`EventType::FocusChange`][crate::EventType::FocusChange],
    /// [`EventType::ProximityIn`][crate::EventType::ProximityIn], [`EventType::ProximityOut`][crate::EventType::ProximityOut], [`EventType::DragEnter`][crate::EventType::DragEnter], [`EventType::DragLeave`][crate::EventType::DragLeave],
    /// [`EventType::DragMotion`][crate::EventType::DragMotion], [`EventType::DragStatus`][crate::EventType::DragStatus], [`EventType::DropStart`][crate::EventType::DropStart], [`EventType::DropFinished`][crate::EventType::DropFinished]
    /// and [`EventType::GrabBroken`][crate::EventType::GrabBroken]. When dealing with an event on a master device,
    /// it is possible to get the source (slave) device that the event originated
    /// from via `gdk_event_get_source_device()`.
    ///
    /// On a standard session, all physical devices are connected by default to
    /// the "Virtual Core Pointer/Keyboard" master devices, hence routing all events
    /// through these. This behavior is only modified by device grabs, where the
    /// slave device is temporarily detached for as long as the grab is held, and
    /// more permanently by user modifications to the device hierarchy.
    ///
    /// On certain application specific setups, it may make sense
    /// to detach a physical device from its master pointer, and mapping it to
    /// an specific window. This can be achieved by the combination of
    /// [`Device::grab()`][crate::Device::grab()] and [`Device::set_mode()`][crate::Device::set_mode()].
    ///
    /// In order to listen for events coming from devices
    /// other than a virtual device, [`Window::set_device_events()`][crate::Window::set_device_events()] must be
    /// called. Generally, this function can be used to modify the event mask
    /// for any given device.
    ///
    /// Input devices may also provide additional information besides X/Y.
    /// For example, graphics tablets may also provide pressure and X/Y tilt
    /// information. This information is device-dependent, and may be
    /// queried through `gdk_device_get_axis()`. In multidevice mode, virtual
    /// devices will change axes in order to always represent the physical
    /// device that is routing events through it. Whenever the physical device
    /// changes, the `property::Device::n-axes` property will be notified, and
    /// [`Device::list_axes()`][crate::Device::list_axes()] will return the new device axes.
    ///
    /// Devices may also have associated “keys” or
    /// macro buttons. Such keys can be globally set to map into normal X
    /// keyboard events. The mapping is set using [`Device::set_key()`][crate::Device::set_key()].
    ///
    /// In GTK+ 3.20, a new [`Seat`][crate::Seat] object has been introduced that
    /// supersedes [`DeviceManager`][crate::DeviceManager] and should be preferred in newly
    /// written code.
    ///
    /// This is an Abstract Base Class, you cannot instantiate it.
    #[doc(alias = "GdkDeviceManager")]
    pub struct DeviceManager(Object<ffi::GdkDeviceManager>);

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

impl DeviceManager {
    /// Returns the client pointer, that is, the master pointer that acts as the core pointer
    /// for this application. In X11, window managers may change this depending on the interaction
    /// pattern under the presence of several pointers.
    ///
    /// You should use this function seldomly, only in code that isn’t triggered by a `GdkEvent`
    /// and there aren’t other means to get a meaningful [`Device`][crate::Device] to operate on.
    ///
    /// # Deprecated since 3.20
    ///
    /// Use [`Seat::pointer()`][crate::Seat::pointer()] instead.
    ///
    /// # Returns
    ///
    /// The client pointer. This memory is
    ///  owned by GDK and must not be freed or unreferenced.
    #[cfg_attr(feature = "v3_20", deprecated = "Since 3.20")]
    #[doc(alias = "gdk_device_manager_get_client_pointer")]
    #[doc(alias = "get_client_pointer")]
    pub fn client_pointer(&self) -> Option<Device> {
        unsafe {
            from_glib_none(ffi::gdk_device_manager_get_client_pointer(
                self.to_glib_none().0,
            ))
        }
    }

    /// Gets the [`Display`][crate::Display] associated to `self`.
    ///
    /// # Returns
    ///
    /// the [`Display`][crate::Display] to which
    ///  `self` is associated to, or [`None`]. This memory is
    ///  owned by GDK and must not be freed or unreferenced.
    #[doc(alias = "gdk_device_manager_get_display")]
    #[doc(alias = "get_display")]
    pub fn display(&self) -> Option<Display> {
        unsafe { from_glib_none(ffi::gdk_device_manager_get_display(self.to_glib_none().0)) }
    }

    /// Returns the list of devices of type `type_` currently attached to
    /// `self`.
    ///
    /// # Deprecated since 3.20
    ///
    /// , use [`Seat::pointer()`][crate::Seat::pointer()], [`Seat::keyboard()`][crate::Seat::keyboard()]
    ///  and [`Seat::slaves()`][crate::Seat::slaves()] instead.
    /// ## `type_`
    /// device type to get.
    ///
    /// # Returns
    ///
    /// a list of
    ///  `GdkDevices`. The returned list must be
    ///  freed with g_list_free (). The list elements are owned by
    ///  GTK+ and must not be freed or unreffed.
    #[cfg_attr(feature = "v3_20", deprecated = "Since 3.20")]
    #[doc(alias = "gdk_device_manager_list_devices")]
    pub fn list_devices(&self, type_: DeviceType) -> Vec<Device> {
        unsafe {
            FromGlibPtrContainer::from_glib_container(ffi::gdk_device_manager_list_devices(
                self.to_glib_none().0,
                type_.into_glib(),
            ))
        }
    }

    /// The ::device-added signal is emitted either when a new master
    /// pointer is created, or when a slave (Hardware) input device
    /// is plugged in.
    /// ## `device`
    /// the newly added [`Device`][crate::Device].
    #[doc(alias = "device-added")]
    pub fn connect_device_added<F: Fn(&Self, &Device) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn device_added_trampoline<F: Fn(&DeviceManager, &Device) + 'static>(
            this: *mut ffi::GdkDeviceManager,
            device: *mut ffi::GdkDevice,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this), &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::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The ::device-changed signal is emitted whenever a device
    /// has changed in the hierarchy, either slave devices being
    /// disconnected from their master device or connected to
    /// another one, or master devices being added or removed
    /// a slave device.
    ///
    /// If a slave device is detached from all master devices
    /// ([`Device::associated_device()`][crate::Device::associated_device()] returns [`None`]), its
    /// [`DeviceType`][crate::DeviceType] will change to [`DeviceType::Floating`][crate::DeviceType::Floating],
    /// if it's attached, it will change to [`DeviceType::Slave`][crate::DeviceType::Slave].
    /// ## `device`
    /// the [`Device`][crate::Device] that changed.
    #[doc(alias = "device-changed")]
    pub fn connect_device_changed<F: Fn(&Self, &Device) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn device_changed_trampoline<F: Fn(&DeviceManager, &Device) + 'static>(
            this: *mut ffi::GdkDeviceManager,
            device: *mut ffi::GdkDevice,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this), &from_glib_borrow(device))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"device-changed\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    device_changed_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The ::device-removed signal is emitted either when a master
    /// pointer is removed, or when a slave (Hardware) input device
    /// is unplugged.
    /// ## `device`
    /// the just removed [`Device`][crate::Device].
    #[doc(alias = "device-removed")]
    pub fn connect_device_removed<F: Fn(&Self, &Device) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn device_removed_trampoline<F: Fn(&DeviceManager, &Device) + 'static>(
            this: *mut ffi::GdkDeviceManager,
            device: *mut ffi::GdkDevice,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this), &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::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

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