x11rb/protocol/
xinput.rs

Help
1// This file contains generated code. Do not edit directly.
2// To regenerate this, run 'make'.
3
4//! Bindings to the `Input` X11 extension.
5
6#![allow(clippy::too_many_arguments)]
7
8#[allow(unused_imports)]
9use std::borrow::Cow;
10#[allow(unused_imports)]
11use std::convert::TryInto;
12#[allow(unused_imports)]
13use crate::utils::RawFdContainer;
14#[allow(unused_imports)]
15use crate::x11_utils::{Request, RequestHeader, Serialize, TryParse, TryParseFd};
16use std::io::IoSlice;
17use crate::connection::RequestConnection;
18#[allow(unused_imports)]
19use crate::connection::Connection as X11Connection;
20#[allow(unused_imports)]
21use crate::cookie::{Cookie, CookieWithFds, VoidCookie};
22use crate::errors::ConnectionError;
23#[allow(unused_imports)]
24use crate::errors::ReplyOrIdError;
25#[allow(unused_imports)]
26use super::xfixes;
27#[allow(unused_imports)]
28use super::xproto;
29
30pub use x11rb_protocol::protocol::xinput::*;
31
32/// Get the major opcode of this extension
33fn major_opcode<Conn: RequestConnection + ?Sized>(conn: &Conn) -> Result<u8, ConnectionError> {
34    let info = conn.extension_information(X11_EXTENSION_NAME)?;
35    let info = info.ok_or(ConnectionError::UnsupportedExtension)?;
36    Ok(info.major_opcode)
37}
38
39pub fn get_extension_version<'c, 'input, Conn>(conn: &'c Conn, name: &'input [u8]) -> Result<Cookie<'c, Conn, GetExtensionVersionReply>, ConnectionError>
40where
41    Conn: RequestConnection + ?Sized,
42{
43    let request0 = GetExtensionVersionRequest {
44        name: Cow::Borrowed(name),
45    };
46    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
47    let slices = [IoSlice::new(&bytes[0]), IoSlice::new(&bytes[1]), IoSlice::new(&bytes[2])];
48    assert_eq!(slices.len(), bytes.len());
49    conn.send_request_with_reply(&slices, fds)
50}
51
52pub fn list_input_devices<Conn>(conn: &Conn) -> Result<Cookie<'_, Conn, ListInputDevicesReply>, ConnectionError>
53where
54    Conn: RequestConnection + ?Sized,
55{
56    let request0 = ListInputDevicesRequest;
57    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
58    let slices = [IoSlice::new(&bytes[0])];
59    assert_eq!(slices.len(), bytes.len());
60    conn.send_request_with_reply(&slices, fds)
61}
62
63pub fn open_device<Conn>(conn: &Conn, device_id: u8) -> Result<Cookie<'_, Conn, OpenDeviceReply>, ConnectionError>
64where
65    Conn: RequestConnection + ?Sized,
66{
67    let request0 = OpenDeviceRequest {
68        device_id,
69    };
70    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
71    let slices = [IoSlice::new(&bytes[0])];
72    assert_eq!(slices.len(), bytes.len());
73    conn.send_request_with_reply(&slices, fds)
74}
75
76pub fn close_device<Conn>(conn: &Conn, device_id: u8) -> Result<VoidCookie<'_, Conn>, ConnectionError>
77where
78    Conn: RequestConnection + ?Sized,
79{
80    let request0 = CloseDeviceRequest {
81        device_id,
82    };
83    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
84    let slices = [IoSlice::new(&bytes[0])];
85    assert_eq!(slices.len(), bytes.len());
86    conn.send_request_without_reply(&slices, fds)
87}
88
89pub fn set_device_mode<Conn>(conn: &Conn, device_id: u8, mode: ValuatorMode) -> Result<Cookie<'_, Conn, SetDeviceModeReply>, ConnectionError>
90where
91    Conn: RequestConnection + ?Sized,
92{
93    let request0 = SetDeviceModeRequest {
94        device_id,
95        mode,
96    };
97    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
98    let slices = [IoSlice::new(&bytes[0])];
99    assert_eq!(slices.len(), bytes.len());
100    conn.send_request_with_reply(&slices, fds)
101}
102
103pub fn select_extension_event<'c, 'input, Conn>(conn: &'c Conn, window: xproto::Window, classes: &'input [EventClass]) -> Result<VoidCookie<'c, Conn>, ConnectionError>
104where
105    Conn: RequestConnection + ?Sized,
106{
107    let request0 = SelectExtensionEventRequest {
108        window,
109        classes: Cow::Borrowed(classes),
110    };
111    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
112    let slices = [IoSlice::new(&bytes[0]), IoSlice::new(&bytes[1]), IoSlice::new(&bytes[2])];
113    assert_eq!(slices.len(), bytes.len());
114    conn.send_request_without_reply(&slices, fds)
115}
116
117pub fn get_selected_extension_events<Conn>(conn: &Conn, window: xproto::Window) -> Result<Cookie<'_, Conn, GetSelectedExtensionEventsReply>, ConnectionError>
118where
119    Conn: RequestConnection + ?Sized,
120{
121    let request0 = GetSelectedExtensionEventsRequest {
122        window,
123    };
124    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
125    let slices = [IoSlice::new(&bytes[0])];
126    assert_eq!(slices.len(), bytes.len());
127    conn.send_request_with_reply(&slices, fds)
128}
129
130pub fn change_device_dont_propagate_list<'c, 'input, Conn>(conn: &'c Conn, window: xproto::Window, mode: PropagateMode, classes: &'input [EventClass]) -> Result<VoidCookie<'c, Conn>, ConnectionError>
131where
132    Conn: RequestConnection + ?Sized,
133{
134    let request0 = ChangeDeviceDontPropagateListRequest {
135        window,
136        mode,
137        classes: Cow::Borrowed(classes),
138    };
139    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
140    let slices = [IoSlice::new(&bytes[0]), IoSlice::new(&bytes[1]), IoSlice::new(&bytes[2])];
141    assert_eq!(slices.len(), bytes.len());
142    conn.send_request_without_reply(&slices, fds)
143}
144
145pub fn get_device_dont_propagate_list<Conn>(conn: &Conn, window: xproto::Window) -> Result<Cookie<'_, Conn, GetDeviceDontPropagateListReply>, ConnectionError>
146where
147    Conn: RequestConnection + ?Sized,
148{
149    let request0 = GetDeviceDontPropagateListRequest {
150        window,
151    };
152    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
153    let slices = [IoSlice::new(&bytes[0])];
154    assert_eq!(slices.len(), bytes.len());
155    conn.send_request_with_reply(&slices, fds)
156}
157
158pub fn get_device_motion_events<Conn, A>(conn: &Conn, start: xproto::Timestamp, stop: A, device_id: u8) -> Result<Cookie<'_, Conn, GetDeviceMotionEventsReply>, ConnectionError>
159where
160    Conn: RequestConnection + ?Sized,
161    A: Into<xproto::Timestamp>,
162{
163    let stop: xproto::Timestamp = stop.into();
164    let request0 = GetDeviceMotionEventsRequest {
165        start,
166        stop,
167        device_id,
168    };
169    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
170    let slices = [IoSlice::new(&bytes[0])];
171    assert_eq!(slices.len(), bytes.len());
172    conn.send_request_with_reply(&slices, fds)
173}
174
175pub fn change_keyboard_device<Conn>(conn: &Conn, device_id: u8) -> Result<Cookie<'_, Conn, ChangeKeyboardDeviceReply>, ConnectionError>
176where
177    Conn: RequestConnection + ?Sized,
178{
179    let request0 = ChangeKeyboardDeviceRequest {
180        device_id,
181    };
182    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
183    let slices = [IoSlice::new(&bytes[0])];
184    assert_eq!(slices.len(), bytes.len());
185    conn.send_request_with_reply(&slices, fds)
186}
187
188pub fn change_pointer_device<Conn>(conn: &Conn, x_axis: u8, y_axis: u8, device_id: u8) -> Result<Cookie<'_, Conn, ChangePointerDeviceReply>, ConnectionError>
189where
190    Conn: RequestConnection + ?Sized,
191{
192    let request0 = ChangePointerDeviceRequest {
193        x_axis,
194        y_axis,
195        device_id,
196    };
197    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
198    let slices = [IoSlice::new(&bytes[0])];
199    assert_eq!(slices.len(), bytes.len());
200    conn.send_request_with_reply(&slices, fds)
201}
202
203pub fn grab_device<'c, 'input, Conn, A>(conn: &'c Conn, grab_window: xproto::Window, time: A, this_device_mode: xproto::GrabMode, other_device_mode: xproto::GrabMode, owner_events: bool, device_id: u8, classes: &'input [EventClass]) -> Result<Cookie<'c, Conn, GrabDeviceReply>, ConnectionError>
204where
205    Conn: RequestConnection + ?Sized,
206    A: Into<xproto::Timestamp>,
207{
208    let time: xproto::Timestamp = time.into();
209    let request0 = GrabDeviceRequest {
210        grab_window,
211        time,
212        this_device_mode,
213        other_device_mode,
214        owner_events,
215        device_id,
216        classes: Cow::Borrowed(classes),
217    };
218    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
219    let slices = [IoSlice::new(&bytes[0]), IoSlice::new(&bytes[1]), IoSlice::new(&bytes[2])];
220    assert_eq!(slices.len(), bytes.len());
221    conn.send_request_with_reply(&slices, fds)
222}
223
224pub fn ungrab_device<Conn, A>(conn: &Conn, time: A, device_id: u8) -> Result<VoidCookie<'_, Conn>, ConnectionError>
225where
226    Conn: RequestConnection + ?Sized,
227    A: Into<xproto::Timestamp>,
228{
229    let time: xproto::Timestamp = time.into();
230    let request0 = UngrabDeviceRequest {
231        time,
232        device_id,
233    };
234    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
235    let slices = [IoSlice::new(&bytes[0])];
236    assert_eq!(slices.len(), bytes.len());
237    conn.send_request_without_reply(&slices, fds)
238}
239
240pub fn grab_device_key<'c, 'input, Conn, A, B>(conn: &'c Conn, grab_window: xproto::Window, modifiers: xproto::ModMask, modifier_device: A, grabbed_device: u8, key: B, this_device_mode: xproto::GrabMode, other_device_mode: xproto::GrabMode, owner_events: bool, classes: &'input [EventClass]) -> Result<VoidCookie<'c, Conn>, ConnectionError>
241where
242    Conn: RequestConnection + ?Sized,
243    A: Into<u8>,
244    B: Into<u8>,
245{
246    let modifier_device: u8 = modifier_device.into();
247    let key: u8 = key.into();
248    let request0 = GrabDeviceKeyRequest {
249        grab_window,
250        modifiers,
251        modifier_device,
252        grabbed_device,
253        key,
254        this_device_mode,
255        other_device_mode,
256        owner_events,
257        classes: Cow::Borrowed(classes),
258    };
259    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
260    let slices = [IoSlice::new(&bytes[0]), IoSlice::new(&bytes[1]), IoSlice::new(&bytes[2])];
261    assert_eq!(slices.len(), bytes.len());
262    conn.send_request_without_reply(&slices, fds)
263}
264
265pub fn ungrab_device_key<Conn, A, B>(conn: &Conn, grab_window: xproto::Window, modifiers: xproto::ModMask, modifier_device: A, key: B, grabbed_device: u8) -> Result<VoidCookie<'_, Conn>, ConnectionError>
266where
267    Conn: RequestConnection + ?Sized,
268    A: Into<u8>,
269    B: Into<u8>,
270{
271    let modifier_device: u8 = modifier_device.into();
272    let key: u8 = key.into();
273    let request0 = UngrabDeviceKeyRequest {
274        grab_window,
275        modifiers,
276        modifier_device,
277        key,
278        grabbed_device,
279    };
280    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
281    let slices = [IoSlice::new(&bytes[0])];
282    assert_eq!(slices.len(), bytes.len());
283    conn.send_request_without_reply(&slices, fds)
284}
285
286pub fn grab_device_button<'c, 'input, Conn, A, B>(conn: &'c Conn, grab_window: xproto::Window, grabbed_device: u8, modifier_device: A, modifiers: xproto::ModMask, this_device_mode: xproto::GrabMode, other_device_mode: xproto::GrabMode, button: B, owner_events: bool, classes: &'input [EventClass]) -> Result<VoidCookie<'c, Conn>, ConnectionError>
287where
288    Conn: RequestConnection + ?Sized,
289    A: Into<u8>,
290    B: Into<u8>,
291{
292    let modifier_device: u8 = modifier_device.into();
293    let button: u8 = button.into();
294    let request0 = GrabDeviceButtonRequest {
295        grab_window,
296        grabbed_device,
297        modifier_device,
298        modifiers,
299        this_device_mode,
300        other_device_mode,
301        button,
302        owner_events,
303        classes: Cow::Borrowed(classes),
304    };
305    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
306    let slices = [IoSlice::new(&bytes[0]), IoSlice::new(&bytes[1]), IoSlice::new(&bytes[2])];
307    assert_eq!(slices.len(), bytes.len());
308    conn.send_request_without_reply(&slices, fds)
309}
310
311pub fn ungrab_device_button<Conn, A, B>(conn: &Conn, grab_window: xproto::Window, modifiers: xproto::ModMask, modifier_device: A, button: B, grabbed_device: u8) -> Result<VoidCookie<'_, Conn>, ConnectionError>
312where
313    Conn: RequestConnection + ?Sized,
314    A: Into<u8>,
315    B: Into<u8>,
316{
317    let modifier_device: u8 = modifier_device.into();
318    let button: u8 = button.into();
319    let request0 = UngrabDeviceButtonRequest {
320        grab_window,
321        modifiers,
322        modifier_device,
323        button,
324        grabbed_device,
325    };
326    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
327    let slices = [IoSlice::new(&bytes[0])];
328    assert_eq!(slices.len(), bytes.len());
329    conn.send_request_without_reply(&slices, fds)
330}
331
332pub fn allow_device_events<Conn, A>(conn: &Conn, time: A, mode: DeviceInputMode, device_id: u8) -> Result<VoidCookie<'_, Conn>, ConnectionError>
333where
334    Conn: RequestConnection + ?Sized,
335    A: Into<xproto::Timestamp>,
336{
337    let time: xproto::Timestamp = time.into();
338    let request0 = AllowDeviceEventsRequest {
339        time,
340        mode,
341        device_id,
342    };
343    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
344    let slices = [IoSlice::new(&bytes[0])];
345    assert_eq!(slices.len(), bytes.len());
346    conn.send_request_without_reply(&slices, fds)
347}
348
349pub fn get_device_focus<Conn>(conn: &Conn, device_id: u8) -> Result<Cookie<'_, Conn, GetDeviceFocusReply>, ConnectionError>
350where
351    Conn: RequestConnection + ?Sized,
352{
353    let request0 = GetDeviceFocusRequest {
354        device_id,
355    };
356    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
357    let slices = [IoSlice::new(&bytes[0])];
358    assert_eq!(slices.len(), bytes.len());
359    conn.send_request_with_reply(&slices, fds)
360}
361
362pub fn set_device_focus<Conn, A, B>(conn: &Conn, focus: A, time: B, revert_to: xproto::InputFocus, device_id: u8) -> Result<VoidCookie<'_, Conn>, ConnectionError>
363where
364    Conn: RequestConnection + ?Sized,
365    A: Into<xproto::Window>,
366    B: Into<xproto::Timestamp>,
367{
368    let focus: xproto::Window = focus.into();
369    let time: xproto::Timestamp = time.into();
370    let request0 = SetDeviceFocusRequest {
371        focus,
372        time,
373        revert_to,
374        device_id,
375    };
376    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
377    let slices = [IoSlice::new(&bytes[0])];
378    assert_eq!(slices.len(), bytes.len());
379    conn.send_request_without_reply(&slices, fds)
380}
381
382pub fn get_feedback_control<Conn>(conn: &Conn, device_id: u8) -> Result<Cookie<'_, Conn, GetFeedbackControlReply>, ConnectionError>
383where
384    Conn: RequestConnection + ?Sized,
385{
386    let request0 = GetFeedbackControlRequest {
387        device_id,
388    };
389    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
390    let slices = [IoSlice::new(&bytes[0])];
391    assert_eq!(slices.len(), bytes.len());
392    conn.send_request_with_reply(&slices, fds)
393}
394
395pub fn change_feedback_control<Conn>(conn: &Conn, mask: ChangeFeedbackControlMask, device_id: u8, feedback_id: u8, feedback: FeedbackCtl) -> Result<VoidCookie<'_, Conn>, ConnectionError>
396where
397    Conn: RequestConnection + ?Sized,
398{
399    let request0 = ChangeFeedbackControlRequest {
400        mask,
401        device_id,
402        feedback_id,
403        feedback,
404    };
405    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
406    let slices = [IoSlice::new(&bytes[0]), IoSlice::new(&bytes[1]), IoSlice::new(&bytes[2])];
407    assert_eq!(slices.len(), bytes.len());
408    conn.send_request_without_reply(&slices, fds)
409}
410
411pub fn get_device_key_mapping<Conn>(conn: &Conn, device_id: u8, first_keycode: KeyCode, count: u8) -> Result<Cookie<'_, Conn, GetDeviceKeyMappingReply>, ConnectionError>
412where
413    Conn: RequestConnection + ?Sized,
414{
415    let request0 = GetDeviceKeyMappingRequest {
416        device_id,
417        first_keycode,
418        count,
419    };
420    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
421    let slices = [IoSlice::new(&bytes[0])];
422    assert_eq!(slices.len(), bytes.len());
423    conn.send_request_with_reply(&slices, fds)
424}
425
426pub fn change_device_key_mapping<'c, 'input, Conn>(conn: &'c Conn, device_id: u8, first_keycode: KeyCode, keysyms_per_keycode: u8, keycode_count: u8, keysyms: &'input [xproto::Keysym]) -> Result<VoidCookie<'c, Conn>, ConnectionError>
427where
428    Conn: RequestConnection + ?Sized,
429{
430    let request0 = ChangeDeviceKeyMappingRequest {
431        device_id,
432        first_keycode,
433        keysyms_per_keycode,
434        keycode_count,
435        keysyms: Cow::Borrowed(keysyms),
436    };
437    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
438    let slices = [IoSlice::new(&bytes[0]), IoSlice::new(&bytes[1]), IoSlice::new(&bytes[2])];
439    assert_eq!(slices.len(), bytes.len());
440    conn.send_request_without_reply(&slices, fds)
441}
442
443pub fn get_device_modifier_mapping<Conn>(conn: &Conn, device_id: u8) -> Result<Cookie<'_, Conn, GetDeviceModifierMappingReply>, ConnectionError>
444where
445    Conn: RequestConnection + ?Sized,
446{
447    let request0 = GetDeviceModifierMappingRequest {
448        device_id,
449    };
450    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
451    let slices = [IoSlice::new(&bytes[0])];
452    assert_eq!(slices.len(), bytes.len());
453    conn.send_request_with_reply(&slices, fds)
454}
455
456pub fn set_device_modifier_mapping<'c, 'input, Conn>(conn: &'c Conn, device_id: u8, keymaps: &'input [u8]) -> Result<Cookie<'c, Conn, SetDeviceModifierMappingReply>, ConnectionError>
457where
458    Conn: RequestConnection + ?Sized,
459{
460    let request0 = SetDeviceModifierMappingRequest {
461        device_id,
462        keymaps: Cow::Borrowed(keymaps),
463    };
464    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
465    let slices = [IoSlice::new(&bytes[0]), IoSlice::new(&bytes[1]), IoSlice::new(&bytes[2])];
466    assert_eq!(slices.len(), bytes.len());
467    conn.send_request_with_reply(&slices, fds)
468}
469
470pub fn get_device_button_mapping<Conn>(conn: &Conn, device_id: u8) -> Result<Cookie<'_, Conn, GetDeviceButtonMappingReply>, ConnectionError>
471where
472    Conn: RequestConnection + ?Sized,
473{
474    let request0 = GetDeviceButtonMappingRequest {
475        device_id,
476    };
477    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
478    let slices = [IoSlice::new(&bytes[0])];
479    assert_eq!(slices.len(), bytes.len());
480    conn.send_request_with_reply(&slices, fds)
481}
482
483pub fn set_device_button_mapping<'c, 'input, Conn>(conn: &'c Conn, device_id: u8, map: &'input [u8]) -> Result<Cookie<'c, Conn, SetDeviceButtonMappingReply>, ConnectionError>
484where
485    Conn: RequestConnection + ?Sized,
486{
487    let request0 = SetDeviceButtonMappingRequest {
488        device_id,
489        map: Cow::Borrowed(map),
490    };
491    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
492    let slices = [IoSlice::new(&bytes[0]), IoSlice::new(&bytes[1]), IoSlice::new(&bytes[2])];
493    assert_eq!(slices.len(), bytes.len());
494    conn.send_request_with_reply(&slices, fds)
495}
496
497pub fn query_device_state<Conn>(conn: &Conn, device_id: u8) -> Result<Cookie<'_, Conn, QueryDeviceStateReply>, ConnectionError>
498where
499    Conn: RequestConnection + ?Sized,
500{
501    let request0 = QueryDeviceStateRequest {
502        device_id,
503    };
504    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
505    let slices = [IoSlice::new(&bytes[0])];
506    assert_eq!(slices.len(), bytes.len());
507    conn.send_request_with_reply(&slices, fds)
508}
509
510pub fn device_bell<Conn>(conn: &Conn, device_id: u8, feedback_id: u8, feedback_class: u8, percent: i8) -> Result<VoidCookie<'_, Conn>, ConnectionError>
511where
512    Conn: RequestConnection + ?Sized,
513{
514    let request0 = DeviceBellRequest {
515        device_id,
516        feedback_id,
517        feedback_class,
518        percent,
519    };
520    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
521    let slices = [IoSlice::new(&bytes[0])];
522    assert_eq!(slices.len(), bytes.len());
523    conn.send_request_without_reply(&slices, fds)
524}
525
526pub fn set_device_valuators<'c, 'input, Conn>(conn: &'c Conn, device_id: u8, first_valuator: u8, valuators: &'input [i32]) -> Result<Cookie<'c, Conn, SetDeviceValuatorsReply>, ConnectionError>
527where
528    Conn: RequestConnection + ?Sized,
529{
530    let request0 = SetDeviceValuatorsRequest {
531        device_id,
532        first_valuator,
533        valuators: Cow::Borrowed(valuators),
534    };
535    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
536    let slices = [IoSlice::new(&bytes[0]), IoSlice::new(&bytes[1]), IoSlice::new(&bytes[2])];
537    assert_eq!(slices.len(), bytes.len());
538    conn.send_request_with_reply(&slices, fds)
539}
540
541pub fn get_device_control<Conn>(conn: &Conn, control_id: DeviceControl, device_id: u8) -> Result<Cookie<'_, Conn, GetDeviceControlReply>, ConnectionError>
542where
543    Conn: RequestConnection + ?Sized,
544{
545    let request0 = GetDeviceControlRequest {
546        control_id,
547        device_id,
548    };
549    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
550    let slices = [IoSlice::new(&bytes[0])];
551    assert_eq!(slices.len(), bytes.len());
552    conn.send_request_with_reply(&slices, fds)
553}
554
555pub fn change_device_control<Conn>(conn: &Conn, control_id: DeviceControl, device_id: u8, control: DeviceCtl) -> Result<Cookie<'_, Conn, ChangeDeviceControlReply>, ConnectionError>
556where
557    Conn: RequestConnection + ?Sized,
558{
559    let request0 = ChangeDeviceControlRequest {
560        control_id,
561        device_id,
562        control,
563    };
564    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
565    let slices = [IoSlice::new(&bytes[0]), IoSlice::new(&bytes[1]), IoSlice::new(&bytes[2])];
566    assert_eq!(slices.len(), bytes.len());
567    conn.send_request_with_reply(&slices, fds)
568}
569
570pub fn list_device_properties<Conn>(conn: &Conn, device_id: u8) -> Result<Cookie<'_, Conn, ListDevicePropertiesReply>, ConnectionError>
571where
572    Conn: RequestConnection + ?Sized,
573{
574    let request0 = ListDevicePropertiesRequest {
575        device_id,
576    };
577    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
578    let slices = [IoSlice::new(&bytes[0])];
579    assert_eq!(slices.len(), bytes.len());
580    conn.send_request_with_reply(&slices, fds)
581}
582
583pub fn change_device_property<'c, 'input, Conn>(conn: &'c Conn, property: xproto::Atom, type_: xproto::Atom, device_id: u8, mode: xproto::PropMode, num_items: u32, items: &'input ChangeDevicePropertyAux) -> Result<VoidCookie<'c, Conn>, ConnectionError>
584where
585    Conn: RequestConnection + ?Sized,
586{
587    let request0 = ChangeDevicePropertyRequest {
588        property,
589        type_,
590        device_id,
591        mode,
592        num_items,
593        items: Cow::Borrowed(items),
594    };
595    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
596    let slices = [IoSlice::new(&bytes[0]), IoSlice::new(&bytes[1]), IoSlice::new(&bytes[2])];
597    assert_eq!(slices.len(), bytes.len());
598    conn.send_request_without_reply(&slices, fds)
599}
600
601pub fn delete_device_property<Conn>(conn: &Conn, property: xproto::Atom, device_id: u8) -> Result<VoidCookie<'_, Conn>, ConnectionError>
602where
603    Conn: RequestConnection + ?Sized,
604{
605    let request0 = DeleteDevicePropertyRequest {
606        property,
607        device_id,
608    };
609    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
610    let slices = [IoSlice::new(&bytes[0])];
611    assert_eq!(slices.len(), bytes.len());
612    conn.send_request_without_reply(&slices, fds)
613}
614
615pub fn get_device_property<Conn>(conn: &Conn, property: xproto::Atom, type_: xproto::Atom, offset: u32, len: u32, device_id: u8, delete: bool) -> Result<Cookie<'_, Conn, GetDevicePropertyReply>, ConnectionError>
616where
617    Conn: RequestConnection + ?Sized,
618{
619    let request0 = GetDevicePropertyRequest {
620        property,
621        type_,
622        offset,
623        len,
624        device_id,
625        delete,
626    };
627    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
628    let slices = [IoSlice::new(&bytes[0])];
629    assert_eq!(slices.len(), bytes.len());
630    conn.send_request_with_reply(&slices, fds)
631}
632
633pub fn xi_query_pointer<Conn, A>(conn: &Conn, window: xproto::Window, deviceid: A) -> Result<Cookie<'_, Conn, XIQueryPointerReply>, ConnectionError>
634where
635    Conn: RequestConnection + ?Sized,
636    A: Into<DeviceId>,
637{
638    let deviceid: DeviceId = deviceid.into();
639    let request0 = XIQueryPointerRequest {
640        window,
641        deviceid,
642    };
643    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
644    let slices = [IoSlice::new(&bytes[0])];
645    assert_eq!(slices.len(), bytes.len());
646    conn.send_request_with_reply(&slices, fds)
647}
648
649pub fn xi_warp_pointer<Conn, A>(conn: &Conn, src_win: xproto::Window, dst_win: xproto::Window, src_x: Fp1616, src_y: Fp1616, src_width: u16, src_height: u16, dst_x: Fp1616, dst_y: Fp1616, deviceid: A) -> Result<VoidCookie<'_, Conn>, ConnectionError>
650where
651    Conn: RequestConnection + ?Sized,
652    A: Into<DeviceId>,
653{
654    let deviceid: DeviceId = deviceid.into();
655    let request0 = XIWarpPointerRequest {
656        src_win,
657        dst_win,
658        src_x,
659        src_y,
660        src_width,
661        src_height,
662        dst_x,
663        dst_y,
664        deviceid,
665    };
666    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
667    let slices = [IoSlice::new(&bytes[0])];
668    assert_eq!(slices.len(), bytes.len());
669    conn.send_request_without_reply(&slices, fds)
670}
671
672pub fn xi_change_cursor<Conn, A>(conn: &Conn, window: xproto::Window, cursor: xproto::Cursor, deviceid: A) -> Result<VoidCookie<'_, Conn>, ConnectionError>
673where
674    Conn: RequestConnection + ?Sized,
675    A: Into<DeviceId>,
676{
677    let deviceid: DeviceId = deviceid.into();
678    let request0 = XIChangeCursorRequest {
679        window,
680        cursor,
681        deviceid,
682    };
683    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
684    let slices = [IoSlice::new(&bytes[0])];
685    assert_eq!(slices.len(), bytes.len());
686    conn.send_request_without_reply(&slices, fds)
687}
688
689pub fn xi_change_hierarchy<'c, 'input, Conn>(conn: &'c Conn, changes: &'input [HierarchyChange]) -> Result<VoidCookie<'c, Conn>, ConnectionError>
690where
691    Conn: RequestConnection + ?Sized,
692{
693    let request0 = XIChangeHierarchyRequest {
694        changes: Cow::Borrowed(changes),
695    };
696    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
697    let slices = [IoSlice::new(&bytes[0]), IoSlice::new(&bytes[1]), IoSlice::new(&bytes[2])];
698    assert_eq!(slices.len(), bytes.len());
699    conn.send_request_without_reply(&slices, fds)
700}
701
702pub fn xi_set_client_pointer<Conn, A>(conn: &Conn, window: xproto::Window, deviceid: A) -> Result<VoidCookie<'_, Conn>, ConnectionError>
703where
704    Conn: RequestConnection + ?Sized,
705    A: Into<DeviceId>,
706{
707    let deviceid: DeviceId = deviceid.into();
708    let request0 = XISetClientPointerRequest {
709        window,
710        deviceid,
711    };
712    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
713    let slices = [IoSlice::new(&bytes[0])];
714    assert_eq!(slices.len(), bytes.len());
715    conn.send_request_without_reply(&slices, fds)
716}
717
718pub fn xi_get_client_pointer<Conn>(conn: &Conn, window: xproto::Window) -> Result<Cookie<'_, Conn, XIGetClientPointerReply>, ConnectionError>
719where
720    Conn: RequestConnection + ?Sized,
721{
722    let request0 = XIGetClientPointerRequest {
723        window,
724    };
725    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
726    let slices = [IoSlice::new(&bytes[0])];
727    assert_eq!(slices.len(), bytes.len());
728    conn.send_request_with_reply(&slices, fds)
729}
730
731pub fn xi_select_events<'c, 'input, Conn>(conn: &'c Conn, window: xproto::Window, masks: &'input [EventMask]) -> Result<VoidCookie<'c, Conn>, ConnectionError>
732where
733    Conn: RequestConnection + ?Sized,
734{
735    let request0 = XISelectEventsRequest {
736        window,
737        masks: Cow::Borrowed(masks),
738    };
739    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
740    let slices = [IoSlice::new(&bytes[0]), IoSlice::new(&bytes[1]), IoSlice::new(&bytes[2])];
741    assert_eq!(slices.len(), bytes.len());
742    conn.send_request_without_reply(&slices, fds)
743}
744
745pub fn xi_query_version<Conn>(conn: &Conn, major_version: u16, minor_version: u16) -> Result<Cookie<'_, Conn, XIQueryVersionReply>, ConnectionError>
746where
747    Conn: RequestConnection + ?Sized,
748{
749    let request0 = XIQueryVersionRequest {
750        major_version,
751        minor_version,
752    };
753    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
754    let slices = [IoSlice::new(&bytes[0])];
755    assert_eq!(slices.len(), bytes.len());
756    conn.send_request_with_reply(&slices, fds)
757}
758
759pub fn xi_query_device<Conn, A>(conn: &Conn, deviceid: A) -> Result<Cookie<'_, Conn, XIQueryDeviceReply>, ConnectionError>
760where
761    Conn: RequestConnection + ?Sized,
762    A: Into<DeviceId>,
763{
764    let deviceid: DeviceId = deviceid.into();
765    let request0 = XIQueryDeviceRequest {
766        deviceid,
767    };
768    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
769    let slices = [IoSlice::new(&bytes[0])];
770    assert_eq!(slices.len(), bytes.len());
771    conn.send_request_with_reply(&slices, fds)
772}
773
774pub fn xi_set_focus<Conn, A, B>(conn: &Conn, window: xproto::Window, time: A, deviceid: B) -> Result<VoidCookie<'_, Conn>, ConnectionError>
775where
776    Conn: RequestConnection + ?Sized,
777    A: Into<xproto::Timestamp>,
778    B: Into<DeviceId>,
779{
780    let time: xproto::Timestamp = time.into();
781    let deviceid: DeviceId = deviceid.into();
782    let request0 = XISetFocusRequest {
783        window,
784        time,
785        deviceid,
786    };
787    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
788    let slices = [IoSlice::new(&bytes[0])];
789    assert_eq!(slices.len(), bytes.len());
790    conn.send_request_without_reply(&slices, fds)
791}
792
793pub fn xi_get_focus<Conn, A>(conn: &Conn, deviceid: A) -> Result<Cookie<'_, Conn, XIGetFocusReply>, ConnectionError>
794where
795    Conn: RequestConnection + ?Sized,
796    A: Into<DeviceId>,
797{
798    let deviceid: DeviceId = deviceid.into();
799    let request0 = XIGetFocusRequest {
800        deviceid,
801    };
802    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
803    let slices = [IoSlice::new(&bytes[0])];
804    assert_eq!(slices.len(), bytes.len());
805    conn.send_request_with_reply(&slices, fds)
806}
807
808pub fn xi_grab_device<'c, 'input, Conn, A, B>(conn: &'c Conn, window: xproto::Window, time: A, cursor: xproto::Cursor, deviceid: B, mode: xproto::GrabMode, paired_device_mode: xproto::GrabMode, owner_events: GrabOwner, mask: &'input [u32]) -> Result<Cookie<'c, Conn, XIGrabDeviceReply>, ConnectionError>
809where
810    Conn: RequestConnection + ?Sized,
811    A: Into<xproto::Timestamp>,
812    B: Into<DeviceId>,
813{
814    let time: xproto::Timestamp = time.into();
815    let deviceid: DeviceId = deviceid.into();
816    let request0 = XIGrabDeviceRequest {
817        window,
818        time,
819        cursor,
820        deviceid,
821        mode,
822        paired_device_mode,
823        owner_events,
824        mask: Cow::Borrowed(mask),
825    };
826    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
827    let slices = [IoSlice::new(&bytes[0]), IoSlice::new(&bytes[1]), IoSlice::new(&bytes[2])];
828    assert_eq!(slices.len(), bytes.len());
829    conn.send_request_with_reply(&slices, fds)
830}
831
832pub fn xi_ungrab_device<Conn, A, B>(conn: &Conn, time: A, deviceid: B) -> Result<VoidCookie<'_, Conn>, ConnectionError>
833where
834    Conn: RequestConnection + ?Sized,
835    A: Into<xproto::Timestamp>,
836    B: Into<DeviceId>,
837{
838    let time: xproto::Timestamp = time.into();
839    let deviceid: DeviceId = deviceid.into();
840    let request0 = XIUngrabDeviceRequest {
841        time,
842        deviceid,
843    };
844    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
845    let slices = [IoSlice::new(&bytes[0])];
846    assert_eq!(slices.len(), bytes.len());
847    conn.send_request_without_reply(&slices, fds)
848}
849
850pub fn xi_allow_events<Conn, A, B>(conn: &Conn, time: A, deviceid: B, event_mode: EventMode, touchid: u32, grab_window: xproto::Window) -> Result<VoidCookie<'_, Conn>, ConnectionError>
851where
852    Conn: RequestConnection + ?Sized,
853    A: Into<xproto::Timestamp>,
854    B: Into<DeviceId>,
855{
856    let time: xproto::Timestamp = time.into();
857    let deviceid: DeviceId = deviceid.into();
858    let request0 = XIAllowEventsRequest {
859        time,
860        deviceid,
861        event_mode,
862        touchid,
863        grab_window,
864    };
865    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
866    let slices = [IoSlice::new(&bytes[0])];
867    assert_eq!(slices.len(), bytes.len());
868    conn.send_request_without_reply(&slices, fds)
869}
870
871pub fn xi_passive_grab_device<'c, 'input, Conn, A, B>(conn: &'c Conn, time: A, grab_window: xproto::Window, cursor: xproto::Cursor, detail: u32, deviceid: B, grab_type: GrabType, grab_mode: GrabMode22, paired_device_mode: xproto::GrabMode, owner_events: GrabOwner, mask: &'input [u32], modifiers: &'input [u32]) -> Result<Cookie<'c, Conn, XIPassiveGrabDeviceReply>, ConnectionError>
872where
873    Conn: RequestConnection + ?Sized,
874    A: Into<xproto::Timestamp>,
875    B: Into<DeviceId>,
876{
877    let time: xproto::Timestamp = time.into();
878    let deviceid: DeviceId = deviceid.into();
879    let request0 = XIPassiveGrabDeviceRequest {
880        time,
881        grab_window,
882        cursor,
883        detail,
884        deviceid,
885        grab_type,
886        grab_mode,
887        paired_device_mode,
888        owner_events,
889        mask: Cow::Borrowed(mask),
890        modifiers: Cow::Borrowed(modifiers),
891    };
892    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
893    let slices = [IoSlice::new(&bytes[0]), IoSlice::new(&bytes[1]), IoSlice::new(&bytes[2]), IoSlice::new(&bytes[3])];
894    assert_eq!(slices.len(), bytes.len());
895    conn.send_request_with_reply(&slices, fds)
896}
897
898pub fn xi_passive_ungrab_device<'c, 'input, Conn, A>(conn: &'c Conn, grab_window: xproto::Window, detail: u32, deviceid: A, grab_type: GrabType, modifiers: &'input [u32]) -> Result<VoidCookie<'c, Conn>, ConnectionError>
899where
900    Conn: RequestConnection + ?Sized,
901    A: Into<DeviceId>,
902{
903    let deviceid: DeviceId = deviceid.into();
904    let request0 = XIPassiveUngrabDeviceRequest {
905        grab_window,
906        detail,
907        deviceid,
908        grab_type,
909        modifiers: Cow::Borrowed(modifiers),
910    };
911    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
912    let slices = [IoSlice::new(&bytes[0]), IoSlice::new(&bytes[1]), IoSlice::new(&bytes[2])];
913    assert_eq!(slices.len(), bytes.len());
914    conn.send_request_without_reply(&slices, fds)
915}
916
917pub fn xi_list_properties<Conn, A>(conn: &Conn, deviceid: A) -> Result<Cookie<'_, Conn, XIListPropertiesReply>, ConnectionError>
918where
919    Conn: RequestConnection + ?Sized,
920    A: Into<DeviceId>,
921{
922    let deviceid: DeviceId = deviceid.into();
923    let request0 = XIListPropertiesRequest {
924        deviceid,
925    };
926    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
927    let slices = [IoSlice::new(&bytes[0])];
928    assert_eq!(slices.len(), bytes.len());
929    conn.send_request_with_reply(&slices, fds)
930}
931
932pub fn xi_change_property<'c, 'input, Conn, A>(conn: &'c Conn, deviceid: A, mode: xproto::PropMode, property: xproto::Atom, type_: xproto::Atom, num_items: u32, items: &'input XIChangePropertyAux) -> Result<VoidCookie<'c, Conn>, ConnectionError>
933where
934    Conn: RequestConnection + ?Sized,
935    A: Into<DeviceId>,
936{
937    let deviceid: DeviceId = deviceid.into();
938    let request0 = XIChangePropertyRequest {
939        deviceid,
940        mode,
941        property,
942        type_,
943        num_items,
944        items: Cow::Borrowed(items),
945    };
946    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
947    let slices = [IoSlice::new(&bytes[0]), IoSlice::new(&bytes[1]), IoSlice::new(&bytes[2])];
948    assert_eq!(slices.len(), bytes.len());
949    conn.send_request_without_reply(&slices, fds)
950}
951
952pub fn xi_delete_property<Conn, A>(conn: &Conn, deviceid: A, property: xproto::Atom) -> Result<VoidCookie<'_, Conn>, ConnectionError>
953where
954    Conn: RequestConnection + ?Sized,
955    A: Into<DeviceId>,
956{
957    let deviceid: DeviceId = deviceid.into();
958    let request0 = XIDeletePropertyRequest {
959        deviceid,
960        property,
961    };
962    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
963    let slices = [IoSlice::new(&bytes[0])];
964    assert_eq!(slices.len(), bytes.len());
965    conn.send_request_without_reply(&slices, fds)
966}
967
968pub fn xi_get_property<Conn, A>(conn: &Conn, deviceid: A, delete: bool, property: xproto::Atom, type_: xproto::Atom, offset: u32, len: u32) -> Result<Cookie<'_, Conn, XIGetPropertyReply>, ConnectionError>
969where
970    Conn: RequestConnection + ?Sized,
971    A: Into<DeviceId>,
972{
973    let deviceid: DeviceId = deviceid.into();
974    let request0 = XIGetPropertyRequest {
975        deviceid,
976        delete,
977        property,
978        type_,
979        offset,
980        len,
981    };
982    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
983    let slices = [IoSlice::new(&bytes[0])];
984    assert_eq!(slices.len(), bytes.len());
985    conn.send_request_with_reply(&slices, fds)
986}
987
988pub fn xi_get_selected_events<Conn>(conn: &Conn, window: xproto::Window) -> Result<Cookie<'_, Conn, XIGetSelectedEventsReply>, ConnectionError>
989where
990    Conn: RequestConnection + ?Sized,
991{
992    let request0 = XIGetSelectedEventsRequest {
993        window,
994    };
995    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
996    let slices = [IoSlice::new(&bytes[0])];
997    assert_eq!(slices.len(), bytes.len());
998    conn.send_request_with_reply(&slices, fds)
999}
1000
1001pub fn xi_barrier_release_pointer<'c, 'input, Conn>(conn: &'c Conn, barriers: &'input [BarrierReleasePointerInfo]) -> Result<VoidCookie<'c, Conn>, ConnectionError>
1002where
1003    Conn: RequestConnection + ?Sized,
1004{
1005    let request0 = XIBarrierReleasePointerRequest {
1006        barriers: Cow::Borrowed(barriers),
1007    };
1008    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
1009    let slices = [IoSlice::new(&bytes[0]), IoSlice::new(&bytes[1]), IoSlice::new(&bytes[2])];
1010    assert_eq!(slices.len(), bytes.len());
1011    conn.send_request_without_reply(&slices, fds)
1012}
1013
1014pub fn send_extension_event<'c, 'input, Conn>(conn: &'c Conn, destination: xproto::Window, device_id: u8, propagate: bool, events: &'input [EventForSend], classes: &'input [EventClass]) -> Result<VoidCookie<'c, Conn>, ConnectionError>
1015where
1016    Conn: RequestConnection + ?Sized,
1017{
1018    let request0 = SendExtensionEventRequest {
1019        destination,
1020        device_id,
1021        propagate,
1022        events: Cow::Borrowed(events),
1023        classes: Cow::Borrowed(classes),
1024    };
1025    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
1026    let slices = [IoSlice::new(&bytes[0]), IoSlice::new(&bytes[1]), IoSlice::new(&bytes[2]), IoSlice::new(&bytes[3])];
1027    assert_eq!(slices.len(), bytes.len());
1028    conn.send_request_without_reply(&slices, fds)
1029}
1030
1031/// Extension trait defining the requests of this extension.
1032pub trait ConnectionExt: RequestConnection {
1033    fn xinput_get_extension_version<'c, 'input>(&'c self, name: &'input [u8]) -> Result<Cookie<'c, Self, GetExtensionVersionReply>, ConnectionError>
1034    {
1035        get_extension_version(self, name)
1036    }
1037    fn xinput_list_input_devices(&self) -> Result<Cookie<'_, Self, ListInputDevicesReply>, ConnectionError>
1038    {
1039        list_input_devices(self)
1040    }
1041    fn xinput_open_device(&self, device_id: u8) -> Result<Cookie<'_, Self, OpenDeviceReply>, ConnectionError>
1042    {
1043        open_device(self, device_id)
1044    }
1045    fn xinput_close_device(&self, device_id: u8) -> Result<VoidCookie<'_, Self>, ConnectionError>
1046    {
1047        close_device(self, device_id)
1048    }
1049    fn xinput_set_device_mode(&self, device_id: u8, mode: ValuatorMode) -> Result<Cookie<'_, Self, SetDeviceModeReply>, ConnectionError>
1050    {
1051        set_device_mode(self, device_id, mode)
1052    }
1053    fn xinput_select_extension_event<'c, 'input>(&'c self, window: xproto::Window, classes: &'input [EventClass]) -> Result<VoidCookie<'c, Self>, ConnectionError>
1054    {
1055        select_extension_event(self, window, classes)
1056    }
1057    fn xinput_get_selected_extension_events(&self, window: xproto::Window) -> Result<Cookie<'_, Self, GetSelectedExtensionEventsReply>, ConnectionError>
1058    {
1059        get_selected_extension_events(self, window)
1060    }
1061    fn xinput_change_device_dont_propagate_list<'c, 'input>(&'c self, window: xproto::Window, mode: PropagateMode, classes: &'input [EventClass]) -> Result<VoidCookie<'c, Self>, ConnectionError>
1062    {
1063        change_device_dont_propagate_list(self, window, mode, classes)
1064    }
1065    fn xinput_get_device_dont_propagate_list(&self, window: xproto::Window) -> Result<Cookie<'_, Self, GetDeviceDontPropagateListReply>, ConnectionError>
1066    {
1067        get_device_dont_propagate_list(self, window)
1068    }
1069    fn xinput_get_device_motion_events<A>(&self, start: xproto::Timestamp, stop: A, device_id: u8) -> Result<Cookie<'_, Self, GetDeviceMotionEventsReply>, ConnectionError>
1070    where
1071        A: Into<xproto::Timestamp>,
1072    {
1073        get_device_motion_events(self, start, stop, device_id)
1074    }
1075    fn xinput_change_keyboard_device(&self, device_id: u8) -> Result<Cookie<'_, Self, ChangeKeyboardDeviceReply>, ConnectionError>
1076    {
1077        change_keyboard_device(self, device_id)
1078    }
1079    fn xinput_change_pointer_device(&self, x_axis: u8, y_axis: u8, device_id: u8) -> Result<Cookie<'_, Self, ChangePointerDeviceReply>, ConnectionError>
1080    {
1081        change_pointer_device(self, x_axis, y_axis, device_id)
1082    }
1083    fn xinput_grab_device<'c, 'input, A>(&'c self, grab_window: xproto::Window, time: A, this_device_mode: xproto::GrabMode, other_device_mode: xproto::GrabMode, owner_events: bool, device_id: u8, classes: &'input [EventClass]) -> Result<Cookie<'c, Self, GrabDeviceReply>, ConnectionError>
1084    where
1085        A: Into<xproto::Timestamp>,
1086    {
1087        grab_device(self, grab_window, time, this_device_mode, other_device_mode, owner_events, device_id, classes)
1088    }
1089    fn xinput_ungrab_device<A>(&self, time: A, device_id: u8) -> Result<VoidCookie<'_, Self>, ConnectionError>
1090    where
1091        A: Into<xproto::Timestamp>,
1092    {
1093        ungrab_device(self, time, device_id)
1094    }
1095    fn xinput_grab_device_key<'c, 'input, A, B>(&'c self, grab_window: xproto::Window, modifiers: xproto::ModMask, modifier_device: A, grabbed_device: u8, key: B, this_device_mode: xproto::GrabMode, other_device_mode: xproto::GrabMode, owner_events: bool, classes: &'input [EventClass]) -> Result<VoidCookie<'c, Self>, ConnectionError>
1096    where
1097        A: Into<u8>,
1098        B: Into<u8>,
1099    {
1100        grab_device_key(self, grab_window, modifiers, modifier_device, grabbed_device, key, this_device_mode, other_device_mode, owner_events, classes)
1101    }
1102    fn xinput_ungrab_device_key<A, B>(&self, grab_window: xproto::Window, modifiers: xproto::ModMask, modifier_device: A, key: B, grabbed_device: u8) -> Result<VoidCookie<'_, Self>, ConnectionError>
1103    where
1104        A: Into<u8>,
1105        B: Into<u8>,
1106    {
1107        ungrab_device_key(self, grab_window, modifiers, modifier_device, key, grabbed_device)
1108    }
1109    fn xinput_grab_device_button<'c, 'input, A, B>(&'c self, grab_window: xproto::Window, grabbed_device: u8, modifier_device: A, modifiers: xproto::ModMask, this_device_mode: xproto::GrabMode, other_device_mode: xproto::GrabMode, button: B, owner_events: bool, classes: &'input [EventClass]) -> Result<VoidCookie<'c, Self>, ConnectionError>
1110    where
1111        A: Into<u8>,
1112        B: Into<u8>,
1113    {
1114        grab_device_button(self, grab_window, grabbed_device, modifier_device, modifiers, this_device_mode, other_device_mode, button, owner_events, classes)
1115    }
1116    fn xinput_ungrab_device_button<A, B>(&self, grab_window: xproto::Window, modifiers: xproto::ModMask, modifier_device: A, button: B, grabbed_device: u8) -> Result<VoidCookie<'_, Self>, ConnectionError>
1117    where
1118        A: Into<u8>,
1119        B: Into<u8>,
1120    {
1121        ungrab_device_button(self, grab_window, modifiers, modifier_device, button, grabbed_device)
1122    }
1123    fn xinput_allow_device_events<A>(&self, time: A, mode: DeviceInputMode, device_id: u8) -> Result<VoidCookie<'_, Self>, ConnectionError>
1124    where
1125        A: Into<xproto::Timestamp>,
1126    {
1127        allow_device_events(self, time, mode, device_id)
1128    }
1129    fn xinput_get_device_focus(&self, device_id: u8) -> Result<Cookie<'_, Self, GetDeviceFocusReply>, ConnectionError>
1130    {
1131        get_device_focus(self, device_id)
1132    }
1133    fn xinput_set_device_focus<A, B>(&self, focus: A, time: B, revert_to: xproto::InputFocus, device_id: u8) -> Result<VoidCookie<'_, Self>, ConnectionError>
1134    where
1135        A: Into<xproto::Window>,
1136        B: Into<xproto::Timestamp>,
1137    {
1138        set_device_focus(self, focus, time, revert_to, device_id)
1139    }
1140    fn xinput_get_feedback_control(&self, device_id: u8) -> Result<Cookie<'_, Self, GetFeedbackControlReply>, ConnectionError>
1141    {
1142        get_feedback_control(self, device_id)
1143    }
1144    fn xinput_change_feedback_control(&self, mask: ChangeFeedbackControlMask, device_id: u8, feedback_id: u8, feedback: FeedbackCtl) -> Result<VoidCookie<'_, Self>, ConnectionError>
1145    {
1146        change_feedback_control(self, mask, device_id, feedback_id, feedback)
1147    }
1148    fn xinput_get_device_key_mapping(&self, device_id: u8, first_keycode: KeyCode, count: u8) -> Result<Cookie<'_, Self, GetDeviceKeyMappingReply>, ConnectionError>
1149    {
1150        get_device_key_mapping(self, device_id, first_keycode, count)
1151    }
1152    fn xinput_change_device_key_mapping<'c, 'input>(&'c self, device_id: u8, first_keycode: KeyCode, keysyms_per_keycode: u8, keycode_count: u8, keysyms: &'input [xproto::Keysym]) -> Result<VoidCookie<'c, Self>, ConnectionError>
1153    {
1154        change_device_key_mapping(self, device_id, first_keycode, keysyms_per_keycode, keycode_count, keysyms)
1155    }
1156    fn xinput_get_device_modifier_mapping(&self, device_id: u8) -> Result<Cookie<'_, Self, GetDeviceModifierMappingReply>, ConnectionError>
1157    {
1158        get_device_modifier_mapping(self, device_id)
1159    }
1160    fn xinput_set_device_modifier_mapping<'c, 'input>(&'c self, device_id: u8, keymaps: &'input [u8]) -> Result<Cookie<'c, Self, SetDeviceModifierMappingReply>, ConnectionError>
1161    {
1162        set_device_modifier_mapping(self, device_id, keymaps)
1163    }
1164    fn xinput_get_device_button_mapping(&self, device_id: u8) -> Result<Cookie<'_, Self, GetDeviceButtonMappingReply>, ConnectionError>
1165    {
1166        get_device_button_mapping(self, device_id)
1167    }
1168    fn xinput_set_device_button_mapping<'c, 'input>(&'c self, device_id: u8, map: &'input [u8]) -> Result<Cookie<'c, Self, SetDeviceButtonMappingReply>, ConnectionError>
1169    {
1170        set_device_button_mapping(self, device_id, map)
1171    }
1172    fn xinput_query_device_state(&self, device_id: u8) -> Result<Cookie<'_, Self, QueryDeviceStateReply>, ConnectionError>
1173    {
1174        query_device_state(self, device_id)
1175    }
1176    fn xinput_device_bell(&self, device_id: u8, feedback_id: u8, feedback_class: u8, percent: i8) -> Result<VoidCookie<'_, Self>, ConnectionError>
1177    {
1178        device_bell(self, device_id, feedback_id, feedback_class, percent)
1179    }
1180    fn xinput_set_device_valuators<'c, 'input>(&'c self, device_id: u8, first_valuator: u8, valuators: &'input [i32]) -> Result<Cookie<'c, Self, SetDeviceValuatorsReply>, ConnectionError>
1181    {
1182        set_device_valuators(self, device_id, first_valuator, valuators)
1183    }
1184    fn xinput_get_device_control(&self, control_id: DeviceControl, device_id: u8) -> Result<Cookie<'_, Self, GetDeviceControlReply>, ConnectionError>
1185    {
1186        get_device_control(self, control_id, device_id)
1187    }
1188    fn xinput_change_device_control(&self, control_id: DeviceControl, device_id: u8, control: DeviceCtl) -> Result<Cookie<'_, Self, ChangeDeviceControlReply>, ConnectionError>
1189    {
1190        change_device_control(self, control_id, device_id, control)
1191    }
1192    fn xinput_list_device_properties(&self, device_id: u8) -> Result<Cookie<'_, Self, ListDevicePropertiesReply>, ConnectionError>
1193    {
1194        list_device_properties(self, device_id)
1195    }
1196    fn xinput_change_device_property<'c, 'input>(&'c self, property: xproto::Atom, type_: xproto::Atom, device_id: u8, mode: xproto::PropMode, num_items: u32, items: &'input ChangeDevicePropertyAux) -> Result<VoidCookie<'c, Self>, ConnectionError>
1197    {
1198        change_device_property(self, property, type_, device_id, mode, num_items, items)
1199    }
1200    fn xinput_delete_device_property(&self, property: xproto::Atom, device_id: u8) -> Result<VoidCookie<'_, Self>, ConnectionError>
1201    {
1202        delete_device_property(self, property, device_id)
1203    }
1204    fn xinput_get_device_property(&self, property: xproto::Atom, type_: xproto::Atom, offset: u32, len: u32, device_id: u8, delete: bool) -> Result<Cookie<'_, Self, GetDevicePropertyReply>, ConnectionError>
1205    {
1206        get_device_property(self, property, type_, offset, len, device_id, delete)
1207    }
1208    fn xinput_xi_query_pointer<A>(&self, window: xproto::Window, deviceid: A) -> Result<Cookie<'_, Self, XIQueryPointerReply>, ConnectionError>
1209    where
1210        A: Into<DeviceId>,
1211    {
1212        xi_query_pointer(self, window, deviceid)
1213    }
1214    fn xinput_xi_warp_pointer<A>(&self, src_win: xproto::Window, dst_win: xproto::Window, src_x: Fp1616, src_y: Fp1616, src_width: u16, src_height: u16, dst_x: Fp1616, dst_y: Fp1616, deviceid: A) -> Result<VoidCookie<'_, Self>, ConnectionError>
1215    where
1216        A: Into<DeviceId>,
1217    {
1218        xi_warp_pointer(self, src_win, dst_win, src_x, src_y, src_width, src_height, dst_x, dst_y, deviceid)
1219    }
1220    fn xinput_xi_change_cursor<A>(&self, window: xproto::Window, cursor: xproto::Cursor, deviceid: A) -> Result<VoidCookie<'_, Self>, ConnectionError>
1221    where
1222        A: Into<DeviceId>,
1223    {
1224        xi_change_cursor(self, window, cursor, deviceid)
1225    }
1226    fn xinput_xi_change_hierarchy<'c, 'input>(&'c self, changes: &'input [HierarchyChange]) -> Result<VoidCookie<'c, Self>, ConnectionError>
1227    {
1228        xi_change_hierarchy(self, changes)
1229    }
1230    fn xinput_xi_set_client_pointer<A>(&self, window: xproto::Window, deviceid: A) -> Result<VoidCookie<'_, Self>, ConnectionError>
1231    where
1232        A: Into<DeviceId>,
1233    {
1234        xi_set_client_pointer(self, window, deviceid)
1235    }
1236    fn xinput_xi_get_client_pointer(&self, window: xproto::Window) -> Result<Cookie<'_, Self, XIGetClientPointerReply>, ConnectionError>
1237    {
1238        xi_get_client_pointer(self, window)
1239    }
1240    fn xinput_xi_select_events<'c, 'input>(&'c self, window: xproto::Window, masks: &'input [EventMask]) -> Result<VoidCookie<'c, Self>, ConnectionError>
1241    {
1242        xi_select_events(self, window, masks)
1243    }
1244    fn xinput_xi_query_version(&self, major_version: u16, minor_version: u16) -> Result<Cookie<'_, Self, XIQueryVersionReply>, ConnectionError>
1245    {
1246        xi_query_version(self, major_version, minor_version)
1247    }
1248    fn xinput_xi_query_device<A>(&self, deviceid: A) -> Result<Cookie<'_, Self, XIQueryDeviceReply>, ConnectionError>
1249    where
1250        A: Into<DeviceId>,
1251    {
1252        xi_query_device(self, deviceid)
1253    }
1254    fn xinput_xi_set_focus<A, B>(&self, window: xproto::Window, time: A, deviceid: B) -> Result<VoidCookie<'_, Self>, ConnectionError>
1255    where
1256        A: Into<xproto::Timestamp>,
1257        B: Into<DeviceId>,
1258    {
1259        xi_set_focus(self, window, time, deviceid)
1260    }
1261    fn xinput_xi_get_focus<A>(&self, deviceid: A) -> Result<Cookie<'_, Self, XIGetFocusReply>, ConnectionError>
1262    where
1263        A: Into<DeviceId>,
1264    {
1265        xi_get_focus(self, deviceid)
1266    }
1267    fn xinput_xi_grab_device<'c, 'input, A, B>(&'c self, window: xproto::Window, time: A, cursor: xproto::Cursor, deviceid: B, mode: xproto::GrabMode, paired_device_mode: xproto::GrabMode, owner_events: GrabOwner, mask: &'input [u32]) -> Result<Cookie<'c, Self, XIGrabDeviceReply>, ConnectionError>
1268    where
1269        A: Into<xproto::Timestamp>,
1270        B: Into<DeviceId>,
1271    {
1272        xi_grab_device(self, window, time, cursor, deviceid, mode, paired_device_mode, owner_events, mask)
1273    }
1274    fn xinput_xi_ungrab_device<A, B>(&self, time: A, deviceid: B) -> Result<VoidCookie<'_, Self>, ConnectionError>
1275    where
1276        A: Into<xproto::Timestamp>,
1277        B: Into<DeviceId>,
1278    {
1279        xi_ungrab_device(self, time, deviceid)
1280    }
1281    fn xinput_xi_allow_events<A, B>(&self, time: A, deviceid: B, event_mode: EventMode, touchid: u32, grab_window: xproto::Window) -> Result<VoidCookie<'_, Self>, ConnectionError>
1282    where
1283        A: Into<xproto::Timestamp>,
1284        B: Into<DeviceId>,
1285    {
1286        xi_allow_events(self, time, deviceid, event_mode, touchid, grab_window)
1287    }
1288    fn xinput_xi_passive_grab_device<'c, 'input, A, B>(&'c self, time: A, grab_window: xproto::Window, cursor: xproto::Cursor, detail: u32, deviceid: B, grab_type: GrabType, grab_mode: GrabMode22, paired_device_mode: xproto::GrabMode, owner_events: GrabOwner, mask: &'input [u32], modifiers: &'input [u32]) -> Result<Cookie<'c, Self, XIPassiveGrabDeviceReply>, ConnectionError>
1289    where
1290        A: Into<xproto::Timestamp>,
1291        B: Into<DeviceId>,
1292    {
1293        xi_passive_grab_device(self, time, grab_window, cursor, detail, deviceid, grab_type, grab_mode, paired_device_mode, owner_events, mask, modifiers)
1294    }
1295    fn xinput_xi_passive_ungrab_device<'c, 'input, A>(&'c self, grab_window: xproto::Window, detail: u32, deviceid: A, grab_type: GrabType, modifiers: &'input [u32]) -> Result<VoidCookie<'c, Self>, ConnectionError>
1296    where
1297        A: Into<DeviceId>,
1298    {
1299        xi_passive_ungrab_device(self, grab_window, detail, deviceid, grab_type, modifiers)
1300    }
1301    fn xinput_xi_list_properties<A>(&self, deviceid: A) -> Result<Cookie<'_, Self, XIListPropertiesReply>, ConnectionError>
1302    where
1303        A: Into<DeviceId>,
1304    {
1305        xi_list_properties(self, deviceid)
1306    }
1307    fn xinput_xi_change_property<'c, 'input, A>(&'c self, deviceid: A, mode: xproto::PropMode, property: xproto::Atom, type_: xproto::Atom, num_items: u32, items: &'input XIChangePropertyAux) -> Result<VoidCookie<'c, Self>, ConnectionError>
1308    where
1309        A: Into<DeviceId>,
1310    {
1311        xi_change_property(self, deviceid, mode, property, type_, num_items, items)
1312    }
1313    fn xinput_xi_delete_property<A>(&self, deviceid: A, property: xproto::Atom) -> Result<VoidCookie<'_, Self>, ConnectionError>
1314    where
1315        A: Into<DeviceId>,
1316    {
1317        xi_delete_property(self, deviceid, property)
1318    }
1319    fn xinput_xi_get_property<A>(&self, deviceid: A, delete: bool, property: xproto::Atom, type_: xproto::Atom, offset: u32, len: u32) -> Result<Cookie<'_, Self, XIGetPropertyReply>, ConnectionError>
1320    where
1321        A: Into<DeviceId>,
1322    {
1323        xi_get_property(self, deviceid, delete, property, type_, offset, len)
1324    }
1325    fn xinput_xi_get_selected_events(&self, window: xproto::Window) -> Result<Cookie<'_, Self, XIGetSelectedEventsReply>, ConnectionError>
1326    {
1327        xi_get_selected_events(self, window)
1328    }
1329    fn xinput_xi_barrier_release_pointer<'c, 'input>(&'c self, barriers: &'input [BarrierReleasePointerInfo]) -> Result<VoidCookie<'c, Self>, ConnectionError>
1330    {
1331        xi_barrier_release_pointer(self, barriers)
1332    }
1333    fn xinput_send_extension_event<'c, 'input>(&'c self, destination: xproto::Window, device_id: u8, propagate: bool, events: &'input [EventForSend], classes: &'input [EventClass]) -> Result<VoidCookie<'c, Self>, ConnectionError>
1334    {
1335        send_extension_event(self, destination, device_id, propagate, events, classes)
1336    }
1337}
1338
1339impl<C: RequestConnection + ?Sized> ConnectionExt for C {}
x11rb/protocol/xinput.rs

x11rb/protocol/
xinput.rs
