x11rb_async/protocol/
xfixes.rs

1// This file contains generated code. Do not edit directly.
2// To regenerate this, run 'make'.
3
4//! Bindings to the `XFixes` 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;
25use std::future::Future;
26use std::pin::Pin;
27#[allow(unused_imports)]
28use super::render;
29#[allow(unused_imports)]
30use super::shape;
31#[allow(unused_imports)]
32use super::xproto;
33
34pub use x11rb_protocol::protocol::xfixes::*;
35
36/// Get the major opcode of this extension
37async fn major_opcode<Conn: RequestConnection + ?Sized>(conn: &Conn) -> Result<u8, ConnectionError> {
38    let info = conn.extension_information(X11_EXTENSION_NAME).await?;
39    let info = info.ok_or(ConnectionError::UnsupportedExtension)?;
40    Ok(info.major_opcode)
41}
42
43pub async fn query_version<Conn>(conn: &Conn, client_major_version: u32, client_minor_version: u32) -> Result<Cookie<'_, Conn, QueryVersionReply>, ConnectionError>
44where
45    Conn: RequestConnection + ?Sized,
46{
47    let request0 = QueryVersionRequest {
48        client_major_version,
49        client_minor_version,
50    };
51    let (bytes, fds) = request0.serialize(major_opcode(conn).await?);
52    let slices = [IoSlice::new(&bytes[0])];
53    assert_eq!(slices.len(), bytes.len());
54    conn.send_request_with_reply(&slices, fds).await
55}
56pub async fn change_save_set<Conn>(conn: &Conn, mode: SaveSetMode, target: SaveSetTarget, map: SaveSetMapping, window: xproto::Window) -> Result<VoidCookie<'_, Conn>, ConnectionError>
57where
58    Conn: RequestConnection + ?Sized,
59{
60    let request0 = ChangeSaveSetRequest {
61        mode,
62        target,
63        map,
64        window,
65    };
66    let (bytes, fds) = request0.serialize(major_opcode(conn).await?);
67    let slices = [IoSlice::new(&bytes[0])];
68    assert_eq!(slices.len(), bytes.len());
69    conn.send_request_without_reply(&slices, fds).await
70}
71pub async fn select_selection_input<Conn>(conn: &Conn, window: xproto::Window, selection: xproto::Atom, event_mask: SelectionEventMask) -> Result<VoidCookie<'_, Conn>, ConnectionError>
72where
73    Conn: RequestConnection + ?Sized,
74{
75    let request0 = SelectSelectionInputRequest {
76        window,
77        selection,
78        event_mask,
79    };
80    let (bytes, fds) = request0.serialize(major_opcode(conn).await?);
81    let slices = [IoSlice::new(&bytes[0])];
82    assert_eq!(slices.len(), bytes.len());
83    conn.send_request_without_reply(&slices, fds).await
84}
85pub async fn select_cursor_input<Conn>(conn: &Conn, window: xproto::Window, event_mask: CursorNotifyMask) -> Result<VoidCookie<'_, Conn>, ConnectionError>
86where
87    Conn: RequestConnection + ?Sized,
88{
89    let request0 = SelectCursorInputRequest {
90        window,
91        event_mask,
92    };
93    let (bytes, fds) = request0.serialize(major_opcode(conn).await?);
94    let slices = [IoSlice::new(&bytes[0])];
95    assert_eq!(slices.len(), bytes.len());
96    conn.send_request_without_reply(&slices, fds).await
97}
98pub async fn get_cursor_image<Conn>(conn: &Conn) -> Result<Cookie<'_, Conn, GetCursorImageReply>, ConnectionError>
99where
100    Conn: RequestConnection + ?Sized,
101{
102    let request0 = GetCursorImageRequest;
103    let (bytes, fds) = request0.serialize(major_opcode(conn).await?);
104    let slices = [IoSlice::new(&bytes[0])];
105    assert_eq!(slices.len(), bytes.len());
106    conn.send_request_with_reply(&slices, fds).await
107}
108pub async fn create_region<'c, 'input, Conn>(conn: &'c Conn, region: Region, rectangles: &'input [xproto::Rectangle]) -> Result<VoidCookie<'c, Conn>, ConnectionError>
109where
110    Conn: RequestConnection + ?Sized,
111{
112    let request0 = CreateRegionRequest {
113        region,
114        rectangles: Cow::Borrowed(rectangles),
115    };
116    let (bytes, fds) = request0.serialize(major_opcode(conn).await?);
117    let slices = [IoSlice::new(&bytes[0]), IoSlice::new(&bytes[1]), IoSlice::new(&bytes[2])];
118    assert_eq!(slices.len(), bytes.len());
119    conn.send_request_without_reply(&slices, fds).await
120}
121pub async fn create_region_from_bitmap<Conn>(conn: &Conn, region: Region, bitmap: xproto::Pixmap) -> Result<VoidCookie<'_, Conn>, ConnectionError>
122where
123    Conn: RequestConnection + ?Sized,
124{
125    let request0 = CreateRegionFromBitmapRequest {
126        region,
127        bitmap,
128    };
129    let (bytes, fds) = request0.serialize(major_opcode(conn).await?);
130    let slices = [IoSlice::new(&bytes[0])];
131    assert_eq!(slices.len(), bytes.len());
132    conn.send_request_without_reply(&slices, fds).await
133}
134pub async fn create_region_from_window<Conn>(conn: &Conn, region: Region, window: xproto::Window, kind: shape::SK) -> Result<VoidCookie<'_, Conn>, ConnectionError>
135where
136    Conn: RequestConnection + ?Sized,
137{
138    let request0 = CreateRegionFromWindowRequest {
139        region,
140        window,
141        kind,
142    };
143    let (bytes, fds) = request0.serialize(major_opcode(conn).await?);
144    let slices = [IoSlice::new(&bytes[0])];
145    assert_eq!(slices.len(), bytes.len());
146    conn.send_request_without_reply(&slices, fds).await
147}
148pub async fn create_region_from_gc<Conn>(conn: &Conn, region: Region, gc: xproto::Gcontext) -> Result<VoidCookie<'_, Conn>, ConnectionError>
149where
150    Conn: RequestConnection + ?Sized,
151{
152    let request0 = CreateRegionFromGCRequest {
153        region,
154        gc,
155    };
156    let (bytes, fds) = request0.serialize(major_opcode(conn).await?);
157    let slices = [IoSlice::new(&bytes[0])];
158    assert_eq!(slices.len(), bytes.len());
159    conn.send_request_without_reply(&slices, fds).await
160}
161pub async fn create_region_from_picture<Conn>(conn: &Conn, region: Region, picture: render::Picture) -> Result<VoidCookie<'_, Conn>, ConnectionError>
162where
163    Conn: RequestConnection + ?Sized,
164{
165    let request0 = CreateRegionFromPictureRequest {
166        region,
167        picture,
168    };
169    let (bytes, fds) = request0.serialize(major_opcode(conn).await?);
170    let slices = [IoSlice::new(&bytes[0])];
171    assert_eq!(slices.len(), bytes.len());
172    conn.send_request_without_reply(&slices, fds).await
173}
174pub async fn destroy_region<Conn>(conn: &Conn, region: Region) -> Result<VoidCookie<'_, Conn>, ConnectionError>
175where
176    Conn: RequestConnection + ?Sized,
177{
178    let request0 = DestroyRegionRequest {
179        region,
180    };
181    let (bytes, fds) = request0.serialize(major_opcode(conn).await?);
182    let slices = [IoSlice::new(&bytes[0])];
183    assert_eq!(slices.len(), bytes.len());
184    conn.send_request_without_reply(&slices, fds).await
185}
186pub async fn set_region<'c, 'input, Conn>(conn: &'c Conn, region: Region, rectangles: &'input [xproto::Rectangle]) -> Result<VoidCookie<'c, Conn>, ConnectionError>
187where
188    Conn: RequestConnection + ?Sized,
189{
190    let request0 = SetRegionRequest {
191        region,
192        rectangles: Cow::Borrowed(rectangles),
193    };
194    let (bytes, fds) = request0.serialize(major_opcode(conn).await?);
195    let slices = [IoSlice::new(&bytes[0]), IoSlice::new(&bytes[1]), IoSlice::new(&bytes[2])];
196    assert_eq!(slices.len(), bytes.len());
197    conn.send_request_without_reply(&slices, fds).await
198}
199pub async fn copy_region<Conn>(conn: &Conn, source: Region, destination: Region) -> Result<VoidCookie<'_, Conn>, ConnectionError>
200where
201    Conn: RequestConnection + ?Sized,
202{
203    let request0 = CopyRegionRequest {
204        source,
205        destination,
206    };
207    let (bytes, fds) = request0.serialize(major_opcode(conn).await?);
208    let slices = [IoSlice::new(&bytes[0])];
209    assert_eq!(slices.len(), bytes.len());
210    conn.send_request_without_reply(&slices, fds).await
211}
212pub async fn union_region<Conn>(conn: &Conn, source1: Region, source2: Region, destination: Region) -> Result<VoidCookie<'_, Conn>, ConnectionError>
213where
214    Conn: RequestConnection + ?Sized,
215{
216    let request0 = UnionRegionRequest {
217        source1,
218        source2,
219        destination,
220    };
221    let (bytes, fds) = request0.serialize(major_opcode(conn).await?);
222    let slices = [IoSlice::new(&bytes[0])];
223    assert_eq!(slices.len(), bytes.len());
224    conn.send_request_without_reply(&slices, fds).await
225}
226pub async fn intersect_region<Conn>(conn: &Conn, source1: Region, source2: Region, destination: Region) -> Result<VoidCookie<'_, Conn>, ConnectionError>
227where
228    Conn: RequestConnection + ?Sized,
229{
230    let request0 = IntersectRegionRequest {
231        source1,
232        source2,
233        destination,
234    };
235    let (bytes, fds) = request0.serialize(major_opcode(conn).await?);
236    let slices = [IoSlice::new(&bytes[0])];
237    assert_eq!(slices.len(), bytes.len());
238    conn.send_request_without_reply(&slices, fds).await
239}
240pub async fn subtract_region<Conn>(conn: &Conn, source1: Region, source2: Region, destination: Region) -> Result<VoidCookie<'_, Conn>, ConnectionError>
241where
242    Conn: RequestConnection + ?Sized,
243{
244    let request0 = SubtractRegionRequest {
245        source1,
246        source2,
247        destination,
248    };
249    let (bytes, fds) = request0.serialize(major_opcode(conn).await?);
250    let slices = [IoSlice::new(&bytes[0])];
251    assert_eq!(slices.len(), bytes.len());
252    conn.send_request_without_reply(&slices, fds).await
253}
254pub async fn invert_region<Conn>(conn: &Conn, source: Region, bounds: xproto::Rectangle, destination: Region) -> Result<VoidCookie<'_, Conn>, ConnectionError>
255where
256    Conn: RequestConnection + ?Sized,
257{
258    let request0 = InvertRegionRequest {
259        source,
260        bounds,
261        destination,
262    };
263    let (bytes, fds) = request0.serialize(major_opcode(conn).await?);
264    let slices = [IoSlice::new(&bytes[0])];
265    assert_eq!(slices.len(), bytes.len());
266    conn.send_request_without_reply(&slices, fds).await
267}
268pub async fn translate_region<Conn>(conn: &Conn, region: Region, dx: i16, dy: i16) -> Result<VoidCookie<'_, Conn>, ConnectionError>
269where
270    Conn: RequestConnection + ?Sized,
271{
272    let request0 = TranslateRegionRequest {
273        region,
274        dx,
275        dy,
276    };
277    let (bytes, fds) = request0.serialize(major_opcode(conn).await?);
278    let slices = [IoSlice::new(&bytes[0])];
279    assert_eq!(slices.len(), bytes.len());
280    conn.send_request_without_reply(&slices, fds).await
281}
282pub async fn region_extents<Conn>(conn: &Conn, source: Region, destination: Region) -> Result<VoidCookie<'_, Conn>, ConnectionError>
283where
284    Conn: RequestConnection + ?Sized,
285{
286    let request0 = RegionExtentsRequest {
287        source,
288        destination,
289    };
290    let (bytes, fds) = request0.serialize(major_opcode(conn).await?);
291    let slices = [IoSlice::new(&bytes[0])];
292    assert_eq!(slices.len(), bytes.len());
293    conn.send_request_without_reply(&slices, fds).await
294}
295pub async fn fetch_region<Conn>(conn: &Conn, region: Region) -> Result<Cookie<'_, Conn, FetchRegionReply>, ConnectionError>
296where
297    Conn: RequestConnection + ?Sized,
298{
299    let request0 = FetchRegionRequest {
300        region,
301    };
302    let (bytes, fds) = request0.serialize(major_opcode(conn).await?);
303    let slices = [IoSlice::new(&bytes[0])];
304    assert_eq!(slices.len(), bytes.len());
305    conn.send_request_with_reply(&slices, fds).await
306}
307pub async fn set_gc_clip_region<Conn, A>(conn: &Conn, gc: xproto::Gcontext, region: A, x_origin: i16, y_origin: i16) -> Result<VoidCookie<'_, Conn>, ConnectionError>
308where
309    Conn: RequestConnection + ?Sized,
310    A: Into<Region> + Send,
311{
312    let region: Region = region.into();
313    let request0 = SetGCClipRegionRequest {
314        gc,
315        region,
316        x_origin,
317        y_origin,
318    };
319    let (bytes, fds) = request0.serialize(major_opcode(conn).await?);
320    let slices = [IoSlice::new(&bytes[0])];
321    assert_eq!(slices.len(), bytes.len());
322    conn.send_request_without_reply(&slices, fds).await
323}
324pub async fn set_window_shape_region<Conn, A>(conn: &Conn, dest: xproto::Window, dest_kind: shape::SK, x_offset: i16, y_offset: i16, region: A) -> Result<VoidCookie<'_, Conn>, ConnectionError>
325where
326    Conn: RequestConnection + ?Sized,
327    A: Into<Region> + Send,
328{
329    let region: Region = region.into();
330    let request0 = SetWindowShapeRegionRequest {
331        dest,
332        dest_kind,
333        x_offset,
334        y_offset,
335        region,
336    };
337    let (bytes, fds) = request0.serialize(major_opcode(conn).await?);
338    let slices = [IoSlice::new(&bytes[0])];
339    assert_eq!(slices.len(), bytes.len());
340    conn.send_request_without_reply(&slices, fds).await
341}
342pub async fn set_picture_clip_region<Conn, A>(conn: &Conn, picture: render::Picture, region: A, x_origin: i16, y_origin: i16) -> Result<VoidCookie<'_, Conn>, ConnectionError>
343where
344    Conn: RequestConnection + ?Sized,
345    A: Into<Region> + Send,
346{
347    let region: Region = region.into();
348    let request0 = SetPictureClipRegionRequest {
349        picture,
350        region,
351        x_origin,
352        y_origin,
353    };
354    let (bytes, fds) = request0.serialize(major_opcode(conn).await?);
355    let slices = [IoSlice::new(&bytes[0])];
356    assert_eq!(slices.len(), bytes.len());
357    conn.send_request_without_reply(&slices, fds).await
358}
359pub async fn set_cursor_name<'c, 'input, Conn>(conn: &'c Conn, cursor: xproto::Cursor, name: &'input [u8]) -> Result<VoidCookie<'c, Conn>, ConnectionError>
360where
361    Conn: RequestConnection + ?Sized,
362{
363    let request0 = SetCursorNameRequest {
364        cursor,
365        name: Cow::Borrowed(name),
366    };
367    let (bytes, fds) = request0.serialize(major_opcode(conn).await?);
368    let slices = [IoSlice::new(&bytes[0]), IoSlice::new(&bytes[1]), IoSlice::new(&bytes[2])];
369    assert_eq!(slices.len(), bytes.len());
370    conn.send_request_without_reply(&slices, fds).await
371}
372pub async fn get_cursor_name<Conn>(conn: &Conn, cursor: xproto::Cursor) -> Result<Cookie<'_, Conn, GetCursorNameReply>, ConnectionError>
373where
374    Conn: RequestConnection + ?Sized,
375{
376    let request0 = GetCursorNameRequest {
377        cursor,
378    };
379    let (bytes, fds) = request0.serialize(major_opcode(conn).await?);
380    let slices = [IoSlice::new(&bytes[0])];
381    assert_eq!(slices.len(), bytes.len());
382    conn.send_request_with_reply(&slices, fds).await
383}
384pub async fn get_cursor_image_and_name<Conn>(conn: &Conn) -> Result<Cookie<'_, Conn, GetCursorImageAndNameReply>, ConnectionError>
385where
386    Conn: RequestConnection + ?Sized,
387{
388    let request0 = GetCursorImageAndNameRequest;
389    let (bytes, fds) = request0.serialize(major_opcode(conn).await?);
390    let slices = [IoSlice::new(&bytes[0])];
391    assert_eq!(slices.len(), bytes.len());
392    conn.send_request_with_reply(&slices, fds).await
393}
394pub async fn change_cursor<Conn>(conn: &Conn, source: xproto::Cursor, destination: xproto::Cursor) -> Result<VoidCookie<'_, Conn>, ConnectionError>
395where
396    Conn: RequestConnection + ?Sized,
397{
398    let request0 = ChangeCursorRequest {
399        source,
400        destination,
401    };
402    let (bytes, fds) = request0.serialize(major_opcode(conn).await?);
403    let slices = [IoSlice::new(&bytes[0])];
404    assert_eq!(slices.len(), bytes.len());
405    conn.send_request_without_reply(&slices, fds).await
406}
407pub async fn change_cursor_by_name<'c, 'input, Conn>(conn: &'c Conn, src: xproto::Cursor, name: &'input [u8]) -> Result<VoidCookie<'c, Conn>, ConnectionError>
408where
409    Conn: RequestConnection + ?Sized,
410{
411    let request0 = ChangeCursorByNameRequest {
412        src,
413        name: Cow::Borrowed(name),
414    };
415    let (bytes, fds) = request0.serialize(major_opcode(conn).await?);
416    let slices = [IoSlice::new(&bytes[0]), IoSlice::new(&bytes[1]), IoSlice::new(&bytes[2])];
417    assert_eq!(slices.len(), bytes.len());
418    conn.send_request_without_reply(&slices, fds).await
419}
420pub async fn expand_region<Conn>(conn: &Conn, source: Region, destination: Region, left: u16, right: u16, top: u16, bottom: u16) -> Result<VoidCookie<'_, Conn>, ConnectionError>
421where
422    Conn: RequestConnection + ?Sized,
423{
424    let request0 = ExpandRegionRequest {
425        source,
426        destination,
427        left,
428        right,
429        top,
430        bottom,
431    };
432    let (bytes, fds) = request0.serialize(major_opcode(conn).await?);
433    let slices = [IoSlice::new(&bytes[0])];
434    assert_eq!(slices.len(), bytes.len());
435    conn.send_request_without_reply(&slices, fds).await
436}
437pub async fn hide_cursor<Conn>(conn: &Conn, window: xproto::Window) -> Result<VoidCookie<'_, Conn>, ConnectionError>
438where
439    Conn: RequestConnection + ?Sized,
440{
441    let request0 = HideCursorRequest {
442        window,
443    };
444    let (bytes, fds) = request0.serialize(major_opcode(conn).await?);
445    let slices = [IoSlice::new(&bytes[0])];
446    assert_eq!(slices.len(), bytes.len());
447    conn.send_request_without_reply(&slices, fds).await
448}
449pub async fn show_cursor<Conn>(conn: &Conn, window: xproto::Window) -> Result<VoidCookie<'_, Conn>, ConnectionError>
450where
451    Conn: RequestConnection + ?Sized,
452{
453    let request0 = ShowCursorRequest {
454        window,
455    };
456    let (bytes, fds) = request0.serialize(major_opcode(conn).await?);
457    let slices = [IoSlice::new(&bytes[0])];
458    assert_eq!(slices.len(), bytes.len());
459    conn.send_request_without_reply(&slices, fds).await
460}
461pub async fn create_pointer_barrier<'c, 'input, Conn>(conn: &'c Conn, barrier: Barrier, window: xproto::Window, x1: u16, y1: u16, x2: u16, y2: u16, directions: BarrierDirections, devices: &'input [u16]) -> Result<VoidCookie<'c, Conn>, ConnectionError>
462where
463    Conn: RequestConnection + ?Sized,
464{
465    let request0 = CreatePointerBarrierRequest {
466        barrier,
467        window,
468        x1,
469        y1,
470        x2,
471        y2,
472        directions,
473        devices: Cow::Borrowed(devices),
474    };
475    let (bytes, fds) = request0.serialize(major_opcode(conn).await?);
476    let slices = [IoSlice::new(&bytes[0]), IoSlice::new(&bytes[1]), IoSlice::new(&bytes[2])];
477    assert_eq!(slices.len(), bytes.len());
478    conn.send_request_without_reply(&slices, fds).await
479}
480pub async fn delete_pointer_barrier<Conn>(conn: &Conn, barrier: Barrier) -> Result<VoidCookie<'_, Conn>, ConnectionError>
481where
482    Conn: RequestConnection + ?Sized,
483{
484    let request0 = DeletePointerBarrierRequest {
485        barrier,
486    };
487    let (bytes, fds) = request0.serialize(major_opcode(conn).await?);
488    let slices = [IoSlice::new(&bytes[0])];
489    assert_eq!(slices.len(), bytes.len());
490    conn.send_request_without_reply(&slices, fds).await
491}
492/// Sets the disconnect mode for the client..
493///
494/// # Fields
495///
496/// * `disconnect_mode` - The new disconnect mode.
497pub async fn set_client_disconnect_mode<Conn>(conn: &Conn, disconnect_mode: ClientDisconnectFlags) -> Result<VoidCookie<'_, Conn>, ConnectionError>
498where
499    Conn: RequestConnection + ?Sized,
500{
501    let request0 = SetClientDisconnectModeRequest {
502        disconnect_mode,
503    };
504    let (bytes, fds) = request0.serialize(major_opcode(conn).await?);
505    let slices = [IoSlice::new(&bytes[0])];
506    assert_eq!(slices.len(), bytes.len());
507    conn.send_request_without_reply(&slices, fds).await
508}
509pub async fn get_client_disconnect_mode<Conn>(conn: &Conn) -> Result<Cookie<'_, Conn, GetClientDisconnectModeReply>, ConnectionError>
510where
511    Conn: RequestConnection + ?Sized,
512{
513    let request0 = GetClientDisconnectModeRequest;
514    let (bytes, fds) = request0.serialize(major_opcode(conn).await?);
515    let slices = [IoSlice::new(&bytes[0])];
516    assert_eq!(slices.len(), bytes.len());
517    conn.send_request_with_reply(&slices, fds).await
518}
519/// Extension trait defining the requests of this extension.
520pub trait ConnectionExt: RequestConnection {
521    fn xfixes_query_version(&self, client_major_version: u32, client_minor_version: u32) -> Pin<Box<dyn Future<Output = Result<Cookie<'_, Self, QueryVersionReply>, ConnectionError>> + Send + '_>>
522    {
523        Box::pin(query_version(self, client_major_version, client_minor_version))
524    }
525    fn xfixes_change_save_set(&self, mode: SaveSetMode, target: SaveSetTarget, map: SaveSetMapping, window: xproto::Window) -> Pin<Box<dyn Future<Output = Result<VoidCookie<'_, Self>, ConnectionError>> + Send + '_>>
526    {
527        Box::pin(change_save_set(self, mode, target, map, window))
528    }
529    fn xfixes_select_selection_input(&self, window: xproto::Window, selection: xproto::Atom, event_mask: SelectionEventMask) -> Pin<Box<dyn Future<Output = Result<VoidCookie<'_, Self>, ConnectionError>> + Send + '_>>
530    {
531        Box::pin(select_selection_input(self, window, selection, event_mask))
532    }
533    fn xfixes_select_cursor_input(&self, window: xproto::Window, event_mask: CursorNotifyMask) -> Pin<Box<dyn Future<Output = Result<VoidCookie<'_, Self>, ConnectionError>> + Send + '_>>
534    {
535        Box::pin(select_cursor_input(self, window, event_mask))
536    }
537    fn xfixes_get_cursor_image(&self) -> Pin<Box<dyn Future<Output = Result<Cookie<'_, Self, GetCursorImageReply>, ConnectionError>> + Send + '_>>
538    {
539        Box::pin(get_cursor_image(self))
540    }
541    fn xfixes_create_region<'c, 'input, 'future>(&'c self, region: Region, rectangles: &'input [xproto::Rectangle]) -> Pin<Box<dyn Future<Output = Result<VoidCookie<'c, Self>, ConnectionError>> + Send + 'future>>
542    where
543        'c: 'future,
544        'input: 'future,
545    {
546        Box::pin(create_region(self, region, rectangles))
547    }
548    fn xfixes_create_region_from_bitmap(&self, region: Region, bitmap: xproto::Pixmap) -> Pin<Box<dyn Future<Output = Result<VoidCookie<'_, Self>, ConnectionError>> + Send + '_>>
549    {
550        Box::pin(create_region_from_bitmap(self, region, bitmap))
551    }
552    fn xfixes_create_region_from_window(&self, region: Region, window: xproto::Window, kind: shape::SK) -> Pin<Box<dyn Future<Output = Result<VoidCookie<'_, Self>, ConnectionError>> + Send + '_>>
553    {
554        Box::pin(create_region_from_window(self, region, window, kind))
555    }
556    fn xfixes_create_region_from_gc(&self, region: Region, gc: xproto::Gcontext) -> Pin<Box<dyn Future<Output = Result<VoidCookie<'_, Self>, ConnectionError>> + Send + '_>>
557    {
558        Box::pin(create_region_from_gc(self, region, gc))
559    }
560    fn xfixes_create_region_from_picture(&self, region: Region, picture: render::Picture) -> Pin<Box<dyn Future<Output = Result<VoidCookie<'_, Self>, ConnectionError>> + Send + '_>>
561    {
562        Box::pin(create_region_from_picture(self, region, picture))
563    }
564    fn xfixes_destroy_region(&self, region: Region) -> Pin<Box<dyn Future<Output = Result<VoidCookie<'_, Self>, ConnectionError>> + Send + '_>>
565    {
566        Box::pin(destroy_region(self, region))
567    }
568    fn xfixes_set_region<'c, 'input, 'future>(&'c self, region: Region, rectangles: &'input [xproto::Rectangle]) -> Pin<Box<dyn Future<Output = Result<VoidCookie<'c, Self>, ConnectionError>> + Send + 'future>>
569    where
570        'c: 'future,
571        'input: 'future,
572    {
573        Box::pin(set_region(self, region, rectangles))
574    }
575    fn xfixes_copy_region(&self, source: Region, destination: Region) -> Pin<Box<dyn Future<Output = Result<VoidCookie<'_, Self>, ConnectionError>> + Send + '_>>
576    {
577        Box::pin(copy_region(self, source, destination))
578    }
579    fn xfixes_union_region(&self, source1: Region, source2: Region, destination: Region) -> Pin<Box<dyn Future<Output = Result<VoidCookie<'_, Self>, ConnectionError>> + Send + '_>>
580    {
581        Box::pin(union_region(self, source1, source2, destination))
582    }
583    fn xfixes_intersect_region(&self, source1: Region, source2: Region, destination: Region) -> Pin<Box<dyn Future<Output = Result<VoidCookie<'_, Self>, ConnectionError>> + Send + '_>>
584    {
585        Box::pin(intersect_region(self, source1, source2, destination))
586    }
587    fn xfixes_subtract_region(&self, source1: Region, source2: Region, destination: Region) -> Pin<Box<dyn Future<Output = Result<VoidCookie<'_, Self>, ConnectionError>> + Send + '_>>
588    {
589        Box::pin(subtract_region(self, source1, source2, destination))
590    }
591    fn xfixes_invert_region(&self, source: Region, bounds: xproto::Rectangle, destination: Region) -> Pin<Box<dyn Future<Output = Result<VoidCookie<'_, Self>, ConnectionError>> + Send + '_>>
592    {
593        Box::pin(invert_region(self, source, bounds, destination))
594    }
595    fn xfixes_translate_region(&self, region: Region, dx: i16, dy: i16) -> Pin<Box<dyn Future<Output = Result<VoidCookie<'_, Self>, ConnectionError>> + Send + '_>>
596    {
597        Box::pin(translate_region(self, region, dx, dy))
598    }
599    fn xfixes_region_extents(&self, source: Region, destination: Region) -> Pin<Box<dyn Future<Output = Result<VoidCookie<'_, Self>, ConnectionError>> + Send + '_>>
600    {
601        Box::pin(region_extents(self, source, destination))
602    }
603    fn xfixes_fetch_region(&self, region: Region) -> Pin<Box<dyn Future<Output = Result<Cookie<'_, Self, FetchRegionReply>, ConnectionError>> + Send + '_>>
604    {
605        Box::pin(fetch_region(self, region))
606    }
607    fn xfixes_set_gc_clip_region<A>(&self, gc: xproto::Gcontext, region: A, x_origin: i16, y_origin: i16) -> Pin<Box<dyn Future<Output = Result<VoidCookie<'_, Self>, ConnectionError>> + Send + '_>>
608    where
609        A: Into<Region> + Send + 'static,
610    {
611        Box::pin(set_gc_clip_region(self, gc, region, x_origin, y_origin))
612    }
613    fn xfixes_set_window_shape_region<A>(&self, dest: xproto::Window, dest_kind: shape::SK, x_offset: i16, y_offset: i16, region: A) -> Pin<Box<dyn Future<Output = Result<VoidCookie<'_, Self>, ConnectionError>> + Send + '_>>
614    where
615        A: Into<Region> + Send + 'static,
616    {
617        Box::pin(set_window_shape_region(self, dest, dest_kind, x_offset, y_offset, region))
618    }
619    fn xfixes_set_picture_clip_region<A>(&self, picture: render::Picture, region: A, x_origin: i16, y_origin: i16) -> Pin<Box<dyn Future<Output = Result<VoidCookie<'_, Self>, ConnectionError>> + Send + '_>>
620    where
621        A: Into<Region> + Send + 'static,
622    {
623        Box::pin(set_picture_clip_region(self, picture, region, x_origin, y_origin))
624    }
625    fn xfixes_set_cursor_name<'c, 'input, 'future>(&'c self, cursor: xproto::Cursor, name: &'input [u8]) -> Pin<Box<dyn Future<Output = Result<VoidCookie<'c, Self>, ConnectionError>> + Send + 'future>>
626    where
627        'c: 'future,
628        'input: 'future,
629    {
630        Box::pin(set_cursor_name(self, cursor, name))
631    }
632    fn xfixes_get_cursor_name(&self, cursor: xproto::Cursor) -> Pin<Box<dyn Future<Output = Result<Cookie<'_, Self, GetCursorNameReply>, ConnectionError>> + Send + '_>>
633    {
634        Box::pin(get_cursor_name(self, cursor))
635    }
636    fn xfixes_get_cursor_image_and_name(&self) -> Pin<Box<dyn Future<Output = Result<Cookie<'_, Self, GetCursorImageAndNameReply>, ConnectionError>> + Send + '_>>
637    {
638        Box::pin(get_cursor_image_and_name(self))
639    }
640    fn xfixes_change_cursor(&self, source: xproto::Cursor, destination: xproto::Cursor) -> Pin<Box<dyn Future<Output = Result<VoidCookie<'_, Self>, ConnectionError>> + Send + '_>>
641    {
642        Box::pin(change_cursor(self, source, destination))
643    }
644    fn xfixes_change_cursor_by_name<'c, 'input, 'future>(&'c self, src: xproto::Cursor, name: &'input [u8]) -> Pin<Box<dyn Future<Output = Result<VoidCookie<'c, Self>, ConnectionError>> + Send + 'future>>
645    where
646        'c: 'future,
647        'input: 'future,
648    {
649        Box::pin(change_cursor_by_name(self, src, name))
650    }
651    fn xfixes_expand_region(&self, source: Region, destination: Region, left: u16, right: u16, top: u16, bottom: u16) -> Pin<Box<dyn Future<Output = Result<VoidCookie<'_, Self>, ConnectionError>> + Send + '_>>
652    {
653        Box::pin(expand_region(self, source, destination, left, right, top, bottom))
654    }
655    fn xfixes_hide_cursor(&self, window: xproto::Window) -> Pin<Box<dyn Future<Output = Result<VoidCookie<'_, Self>, ConnectionError>> + Send + '_>>
656    {
657        Box::pin(hide_cursor(self, window))
658    }
659    fn xfixes_show_cursor(&self, window: xproto::Window) -> Pin<Box<dyn Future<Output = Result<VoidCookie<'_, Self>, ConnectionError>> + Send + '_>>
660    {
661        Box::pin(show_cursor(self, window))
662    }
663    fn xfixes_create_pointer_barrier<'c, 'input, 'future>(&'c self, barrier: Barrier, window: xproto::Window, x1: u16, y1: u16, x2: u16, y2: u16, directions: BarrierDirections, devices: &'input [u16]) -> Pin<Box<dyn Future<Output = Result<VoidCookie<'c, Self>, ConnectionError>> + Send + 'future>>
664    where
665        'c: 'future,
666        'input: 'future,
667    {
668        Box::pin(create_pointer_barrier(self, barrier, window, x1, y1, x2, y2, directions, devices))
669    }
670    fn xfixes_delete_pointer_barrier(&self, barrier: Barrier) -> Pin<Box<dyn Future<Output = Result<VoidCookie<'_, Self>, ConnectionError>> + Send + '_>>
671    {
672        Box::pin(delete_pointer_barrier(self, barrier))
673    }
674    /// Sets the disconnect mode for the client..
675    ///
676    /// # Fields
677    ///
678    /// * `disconnect_mode` - The new disconnect mode.
679    fn xfixes_set_client_disconnect_mode(&self, disconnect_mode: ClientDisconnectFlags) -> Pin<Box<dyn Future<Output = Result<VoidCookie<'_, Self>, ConnectionError>> + Send + '_>>
680    {
681        Box::pin(set_client_disconnect_mode(self, disconnect_mode))
682    }
683    fn xfixes_get_client_disconnect_mode(&self) -> Pin<Box<dyn Future<Output = Result<Cookie<'_, Self, GetClientDisconnectModeReply>, ConnectionError>> + Send + '_>>
684    {
685        Box::pin(get_client_disconnect_mode(self))
686    }
687}
688
689impl<C: RequestConnection + ?Sized> ConnectionExt for C {}
x11rb_async/protocol/xfixes.rs

x11rb_async/protocol/
xfixes.rs
