x11rb/protocol/
xfixes.rs

Help
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;
25#[allow(unused_imports)]
26use super::render;
27#[allow(unused_imports)]
28use super::shape;
29#[allow(unused_imports)]
30use super::xproto;
31
32pub use x11rb_protocol::protocol::xfixes::*;
33
34/// Get the major opcode of this extension
35fn major_opcode<Conn: RequestConnection + ?Sized>(conn: &Conn) -> Result<u8, ConnectionError> {
36    let info = conn.extension_information(X11_EXTENSION_NAME)?;
37    let info = info.ok_or(ConnectionError::UnsupportedExtension)?;
38    Ok(info.major_opcode)
39}
40
41pub fn query_version<Conn>(conn: &Conn, client_major_version: u32, client_minor_version: u32) -> Result<Cookie<'_, Conn, QueryVersionReply>, ConnectionError>
42where
43    Conn: RequestConnection + ?Sized,
44{
45    let request0 = QueryVersionRequest {
46        client_major_version,
47        client_minor_version,
48    };
49    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
50    let slices = [IoSlice::new(&bytes[0])];
51    assert_eq!(slices.len(), bytes.len());
52    conn.send_request_with_reply(&slices, fds)
53}
54
55pub fn change_save_set<Conn>(conn: &Conn, mode: SaveSetMode, target: SaveSetTarget, map: SaveSetMapping, window: xproto::Window) -> Result<VoidCookie<'_, Conn>, ConnectionError>
56where
57    Conn: RequestConnection + ?Sized,
58{
59    let request0 = ChangeSaveSetRequest {
60        mode,
61        target,
62        map,
63        window,
64    };
65    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
66    let slices = [IoSlice::new(&bytes[0])];
67    assert_eq!(slices.len(), bytes.len());
68    conn.send_request_without_reply(&slices, fds)
69}
70
71pub 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)?);
81    let slices = [IoSlice::new(&bytes[0])];
82    assert_eq!(slices.len(), bytes.len());
83    conn.send_request_without_reply(&slices, fds)
84}
85
86pub fn select_cursor_input<Conn>(conn: &Conn, window: xproto::Window, event_mask: CursorNotifyMask) -> Result<VoidCookie<'_, Conn>, ConnectionError>
87where
88    Conn: RequestConnection + ?Sized,
89{
90    let request0 = SelectCursorInputRequest {
91        window,
92        event_mask,
93    };
94    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
95    let slices = [IoSlice::new(&bytes[0])];
96    assert_eq!(slices.len(), bytes.len());
97    conn.send_request_without_reply(&slices, fds)
98}
99
100pub fn get_cursor_image<Conn>(conn: &Conn) -> Result<Cookie<'_, Conn, GetCursorImageReply>, ConnectionError>
101where
102    Conn: RequestConnection + ?Sized,
103{
104    let request0 = GetCursorImageRequest;
105    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
106    let slices = [IoSlice::new(&bytes[0])];
107    assert_eq!(slices.len(), bytes.len());
108    conn.send_request_with_reply(&slices, fds)
109}
110
111pub fn create_region<'c, 'input, Conn>(conn: &'c Conn, region: Region, rectangles: &'input [xproto::Rectangle]) -> Result<VoidCookie<'c, Conn>, ConnectionError>
112where
113    Conn: RequestConnection + ?Sized,
114{
115    let request0 = CreateRegionRequest {
116        region,
117        rectangles: Cow::Borrowed(rectangles),
118    };
119    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
120    let slices = [IoSlice::new(&bytes[0]), IoSlice::new(&bytes[1]), IoSlice::new(&bytes[2])];
121    assert_eq!(slices.len(), bytes.len());
122    conn.send_request_without_reply(&slices, fds)
123}
124
125pub fn create_region_from_bitmap<Conn>(conn: &Conn, region: Region, bitmap: xproto::Pixmap) -> Result<VoidCookie<'_, Conn>, ConnectionError>
126where
127    Conn: RequestConnection + ?Sized,
128{
129    let request0 = CreateRegionFromBitmapRequest {
130        region,
131        bitmap,
132    };
133    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
134    let slices = [IoSlice::new(&bytes[0])];
135    assert_eq!(slices.len(), bytes.len());
136    conn.send_request_without_reply(&slices, fds)
137}
138
139pub fn create_region_from_window<Conn>(conn: &Conn, region: Region, window: xproto::Window, kind: shape::SK) -> Result<VoidCookie<'_, Conn>, ConnectionError>
140where
141    Conn: RequestConnection + ?Sized,
142{
143    let request0 = CreateRegionFromWindowRequest {
144        region,
145        window,
146        kind,
147    };
148    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
149    let slices = [IoSlice::new(&bytes[0])];
150    assert_eq!(slices.len(), bytes.len());
151    conn.send_request_without_reply(&slices, fds)
152}
153
154pub fn create_region_from_gc<Conn>(conn: &Conn, region: Region, gc: xproto::Gcontext) -> Result<VoidCookie<'_, Conn>, ConnectionError>
155where
156    Conn: RequestConnection + ?Sized,
157{
158    let request0 = CreateRegionFromGCRequest {
159        region,
160        gc,
161    };
162    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
163    let slices = [IoSlice::new(&bytes[0])];
164    assert_eq!(slices.len(), bytes.len());
165    conn.send_request_without_reply(&slices, fds)
166}
167
168pub fn create_region_from_picture<Conn>(conn: &Conn, region: Region, picture: render::Picture) -> Result<VoidCookie<'_, Conn>, ConnectionError>
169where
170    Conn: RequestConnection + ?Sized,
171{
172    let request0 = CreateRegionFromPictureRequest {
173        region,
174        picture,
175    };
176    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
177    let slices = [IoSlice::new(&bytes[0])];
178    assert_eq!(slices.len(), bytes.len());
179    conn.send_request_without_reply(&slices, fds)
180}
181
182pub fn destroy_region<Conn>(conn: &Conn, region: Region) -> Result<VoidCookie<'_, Conn>, ConnectionError>
183where
184    Conn: RequestConnection + ?Sized,
185{
186    let request0 = DestroyRegionRequest {
187        region,
188    };
189    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
190    let slices = [IoSlice::new(&bytes[0])];
191    assert_eq!(slices.len(), bytes.len());
192    conn.send_request_without_reply(&slices, fds)
193}
194
195pub fn set_region<'c, 'input, Conn>(conn: &'c Conn, region: Region, rectangles: &'input [xproto::Rectangle]) -> Result<VoidCookie<'c, Conn>, ConnectionError>
196where
197    Conn: RequestConnection + ?Sized,
198{
199    let request0 = SetRegionRequest {
200        region,
201        rectangles: Cow::Borrowed(rectangles),
202    };
203    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
204    let slices = [IoSlice::new(&bytes[0]), IoSlice::new(&bytes[1]), IoSlice::new(&bytes[2])];
205    assert_eq!(slices.len(), bytes.len());
206    conn.send_request_without_reply(&slices, fds)
207}
208
209pub fn copy_region<Conn>(conn: &Conn, source: Region, destination: Region) -> Result<VoidCookie<'_, Conn>, ConnectionError>
210where
211    Conn: RequestConnection + ?Sized,
212{
213    let request0 = CopyRegionRequest {
214        source,
215        destination,
216    };
217    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
218    let slices = [IoSlice::new(&bytes[0])];
219    assert_eq!(slices.len(), bytes.len());
220    conn.send_request_without_reply(&slices, fds)
221}
222
223pub fn union_region<Conn>(conn: &Conn, source1: Region, source2: Region, destination: Region) -> Result<VoidCookie<'_, Conn>, ConnectionError>
224where
225    Conn: RequestConnection + ?Sized,
226{
227    let request0 = UnionRegionRequest {
228        source1,
229        source2,
230        destination,
231    };
232    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
233    let slices = [IoSlice::new(&bytes[0])];
234    assert_eq!(slices.len(), bytes.len());
235    conn.send_request_without_reply(&slices, fds)
236}
237
238pub fn intersect_region<Conn>(conn: &Conn, source1: Region, source2: Region, destination: Region) -> Result<VoidCookie<'_, Conn>, ConnectionError>
239where
240    Conn: RequestConnection + ?Sized,
241{
242    let request0 = IntersectRegionRequest {
243        source1,
244        source2,
245        destination,
246    };
247    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
248    let slices = [IoSlice::new(&bytes[0])];
249    assert_eq!(slices.len(), bytes.len());
250    conn.send_request_without_reply(&slices, fds)
251}
252
253pub fn subtract_region<Conn>(conn: &Conn, source1: Region, source2: Region, destination: Region) -> Result<VoidCookie<'_, Conn>, ConnectionError>
254where
255    Conn: RequestConnection + ?Sized,
256{
257    let request0 = SubtractRegionRequest {
258        source1,
259        source2,
260        destination,
261    };
262    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
263    let slices = [IoSlice::new(&bytes[0])];
264    assert_eq!(slices.len(), bytes.len());
265    conn.send_request_without_reply(&slices, fds)
266}
267
268pub fn invert_region<Conn>(conn: &Conn, source: Region, bounds: xproto::Rectangle, destination: Region) -> Result<VoidCookie<'_, Conn>, ConnectionError>
269where
270    Conn: RequestConnection + ?Sized,
271{
272    let request0 = InvertRegionRequest {
273        source,
274        bounds,
275        destination,
276    };
277    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
278    let slices = [IoSlice::new(&bytes[0])];
279    assert_eq!(slices.len(), bytes.len());
280    conn.send_request_without_reply(&slices, fds)
281}
282
283pub fn translate_region<Conn>(conn: &Conn, region: Region, dx: i16, dy: i16) -> Result<VoidCookie<'_, Conn>, ConnectionError>
284where
285    Conn: RequestConnection + ?Sized,
286{
287    let request0 = TranslateRegionRequest {
288        region,
289        dx,
290        dy,
291    };
292    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
293    let slices = [IoSlice::new(&bytes[0])];
294    assert_eq!(slices.len(), bytes.len());
295    conn.send_request_without_reply(&slices, fds)
296}
297
298pub fn region_extents<Conn>(conn: &Conn, source: Region, destination: Region) -> Result<VoidCookie<'_, Conn>, ConnectionError>
299where
300    Conn: RequestConnection + ?Sized,
301{
302    let request0 = RegionExtentsRequest {
303        source,
304        destination,
305    };
306    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
307    let slices = [IoSlice::new(&bytes[0])];
308    assert_eq!(slices.len(), bytes.len());
309    conn.send_request_without_reply(&slices, fds)
310}
311
312pub fn fetch_region<Conn>(conn: &Conn, region: Region) -> Result<Cookie<'_, Conn, FetchRegionReply>, ConnectionError>
313where
314    Conn: RequestConnection + ?Sized,
315{
316    let request0 = FetchRegionRequest {
317        region,
318    };
319    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
320    let slices = [IoSlice::new(&bytes[0])];
321    assert_eq!(slices.len(), bytes.len());
322    conn.send_request_with_reply(&slices, fds)
323}
324
325pub fn set_gc_clip_region<Conn, A>(conn: &Conn, gc: xproto::Gcontext, region: A, x_origin: i16, y_origin: i16) -> Result<VoidCookie<'_, Conn>, ConnectionError>
326where
327    Conn: RequestConnection + ?Sized,
328    A: Into<Region>,
329{
330    let region: Region = region.into();
331    let request0 = SetGCClipRegionRequest {
332        gc,
333        region,
334        x_origin,
335        y_origin,
336    };
337    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
338    let slices = [IoSlice::new(&bytes[0])];
339    assert_eq!(slices.len(), bytes.len());
340    conn.send_request_without_reply(&slices, fds)
341}
342
343pub 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>
344where
345    Conn: RequestConnection + ?Sized,
346    A: Into<Region>,
347{
348    let region: Region = region.into();
349    let request0 = SetWindowShapeRegionRequest {
350        dest,
351        dest_kind,
352        x_offset,
353        y_offset,
354        region,
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_without_reply(&slices, fds)
360}
361
362pub fn set_picture_clip_region<Conn, A>(conn: &Conn, picture: render::Picture, region: A, x_origin: i16, y_origin: i16) -> Result<VoidCookie<'_, Conn>, ConnectionError>
363where
364    Conn: RequestConnection + ?Sized,
365    A: Into<Region>,
366{
367    let region: Region = region.into();
368    let request0 = SetPictureClipRegionRequest {
369        picture,
370        region,
371        x_origin,
372        y_origin,
373    };
374    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
375    let slices = [IoSlice::new(&bytes[0])];
376    assert_eq!(slices.len(), bytes.len());
377    conn.send_request_without_reply(&slices, fds)
378}
379
380pub fn set_cursor_name<'c, 'input, Conn>(conn: &'c Conn, cursor: xproto::Cursor, name: &'input [u8]) -> Result<VoidCookie<'c, Conn>, ConnectionError>
381where
382    Conn: RequestConnection + ?Sized,
383{
384    let request0 = SetCursorNameRequest {
385        cursor,
386        name: Cow::Borrowed(name),
387    };
388    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
389    let slices = [IoSlice::new(&bytes[0]), IoSlice::new(&bytes[1]), IoSlice::new(&bytes[2])];
390    assert_eq!(slices.len(), bytes.len());
391    conn.send_request_without_reply(&slices, fds)
392}
393
394pub fn get_cursor_name<Conn>(conn: &Conn, cursor: xproto::Cursor) -> Result<Cookie<'_, Conn, GetCursorNameReply>, ConnectionError>
395where
396    Conn: RequestConnection + ?Sized,
397{
398    let request0 = GetCursorNameRequest {
399        cursor,
400    };
401    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
402    let slices = [IoSlice::new(&bytes[0])];
403    assert_eq!(slices.len(), bytes.len());
404    conn.send_request_with_reply(&slices, fds)
405}
406
407pub fn get_cursor_image_and_name<Conn>(conn: &Conn) -> Result<Cookie<'_, Conn, GetCursorImageAndNameReply>, ConnectionError>
408where
409    Conn: RequestConnection + ?Sized,
410{
411    let request0 = GetCursorImageAndNameRequest;
412    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
413    let slices = [IoSlice::new(&bytes[0])];
414    assert_eq!(slices.len(), bytes.len());
415    conn.send_request_with_reply(&slices, fds)
416}
417
418pub fn change_cursor<Conn>(conn: &Conn, source: xproto::Cursor, destination: xproto::Cursor) -> Result<VoidCookie<'_, Conn>, ConnectionError>
419where
420    Conn: RequestConnection + ?Sized,
421{
422    let request0 = ChangeCursorRequest {
423        source,
424        destination,
425    };
426    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
427    let slices = [IoSlice::new(&bytes[0])];
428    assert_eq!(slices.len(), bytes.len());
429    conn.send_request_without_reply(&slices, fds)
430}
431
432pub fn change_cursor_by_name<'c, 'input, Conn>(conn: &'c Conn, src: xproto::Cursor, name: &'input [u8]) -> Result<VoidCookie<'c, Conn>, ConnectionError>
433where
434    Conn: RequestConnection + ?Sized,
435{
436    let request0 = ChangeCursorByNameRequest {
437        src,
438        name: Cow::Borrowed(name),
439    };
440    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
441    let slices = [IoSlice::new(&bytes[0]), IoSlice::new(&bytes[1]), IoSlice::new(&bytes[2])];
442    assert_eq!(slices.len(), bytes.len());
443    conn.send_request_without_reply(&slices, fds)
444}
445
446pub fn expand_region<Conn>(conn: &Conn, source: Region, destination: Region, left: u16, right: u16, top: u16, bottom: u16) -> Result<VoidCookie<'_, Conn>, ConnectionError>
447where
448    Conn: RequestConnection + ?Sized,
449{
450    let request0 = ExpandRegionRequest {
451        source,
452        destination,
453        left,
454        right,
455        top,
456        bottom,
457    };
458    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
459    let slices = [IoSlice::new(&bytes[0])];
460    assert_eq!(slices.len(), bytes.len());
461    conn.send_request_without_reply(&slices, fds)
462}
463
464pub fn hide_cursor<Conn>(conn: &Conn, window: xproto::Window) -> Result<VoidCookie<'_, Conn>, ConnectionError>
465where
466    Conn: RequestConnection + ?Sized,
467{
468    let request0 = HideCursorRequest {
469        window,
470    };
471    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
472    let slices = [IoSlice::new(&bytes[0])];
473    assert_eq!(slices.len(), bytes.len());
474    conn.send_request_without_reply(&slices, fds)
475}
476
477pub fn show_cursor<Conn>(conn: &Conn, window: xproto::Window) -> Result<VoidCookie<'_, Conn>, ConnectionError>
478where
479    Conn: RequestConnection + ?Sized,
480{
481    let request0 = ShowCursorRequest {
482        window,
483    };
484    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
485    let slices = [IoSlice::new(&bytes[0])];
486    assert_eq!(slices.len(), bytes.len());
487    conn.send_request_without_reply(&slices, fds)
488}
489
490pub 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>
491where
492    Conn: RequestConnection + ?Sized,
493{
494    let request0 = CreatePointerBarrierRequest {
495        barrier,
496        window,
497        x1,
498        y1,
499        x2,
500        y2,
501        directions,
502        devices: Cow::Borrowed(devices),
503    };
504    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
505    let slices = [IoSlice::new(&bytes[0]), IoSlice::new(&bytes[1]), IoSlice::new(&bytes[2])];
506    assert_eq!(slices.len(), bytes.len());
507    conn.send_request_without_reply(&slices, fds)
508}
509
510pub fn delete_pointer_barrier<Conn>(conn: &Conn, barrier: Barrier) -> Result<VoidCookie<'_, Conn>, ConnectionError>
511where
512    Conn: RequestConnection + ?Sized,
513{
514    let request0 = DeletePointerBarrierRequest {
515        barrier,
516    };
517    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
518    let slices = [IoSlice::new(&bytes[0])];
519    assert_eq!(slices.len(), bytes.len());
520    conn.send_request_without_reply(&slices, fds)
521}
522
523/// Sets the disconnect mode for the client..
524///
525/// # Fields
526///
527/// * `disconnect_mode` - The new disconnect mode.
528pub fn set_client_disconnect_mode<Conn>(conn: &Conn, disconnect_mode: ClientDisconnectFlags) -> Result<VoidCookie<'_, Conn>, ConnectionError>
529where
530    Conn: RequestConnection + ?Sized,
531{
532    let request0 = SetClientDisconnectModeRequest {
533        disconnect_mode,
534    };
535    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
536    let slices = [IoSlice::new(&bytes[0])];
537    assert_eq!(slices.len(), bytes.len());
538    conn.send_request_without_reply(&slices, fds)
539}
540
541pub fn get_client_disconnect_mode<Conn>(conn: &Conn) -> Result<Cookie<'_, Conn, GetClientDisconnectModeReply>, ConnectionError>
542where
543    Conn: RequestConnection + ?Sized,
544{
545    let request0 = GetClientDisconnectModeRequest;
546    let (bytes, fds) = request0.serialize(major_opcode(conn)?);
547    let slices = [IoSlice::new(&bytes[0])];
548    assert_eq!(slices.len(), bytes.len());
549    conn.send_request_with_reply(&slices, fds)
550}
551
552/// Extension trait defining the requests of this extension.
553pub trait ConnectionExt: RequestConnection {
554    fn xfixes_query_version(&self, client_major_version: u32, client_minor_version: u32) -> Result<Cookie<'_, Self, QueryVersionReply>, ConnectionError>
555    {
556        query_version(self, client_major_version, client_minor_version)
557    }
558    fn xfixes_change_save_set(&self, mode: SaveSetMode, target: SaveSetTarget, map: SaveSetMapping, window: xproto::Window) -> Result<VoidCookie<'_, Self>, ConnectionError>
559    {
560        change_save_set(self, mode, target, map, window)
561    }
562    fn xfixes_select_selection_input(&self, window: xproto::Window, selection: xproto::Atom, event_mask: SelectionEventMask) -> Result<VoidCookie<'_, Self>, ConnectionError>
563    {
564        select_selection_input(self, window, selection, event_mask)
565    }
566    fn xfixes_select_cursor_input(&self, window: xproto::Window, event_mask: CursorNotifyMask) -> Result<VoidCookie<'_, Self>, ConnectionError>
567    {
568        select_cursor_input(self, window, event_mask)
569    }
570    fn xfixes_get_cursor_image(&self) -> Result<Cookie<'_, Self, GetCursorImageReply>, ConnectionError>
571    {
572        get_cursor_image(self)
573    }
574    fn xfixes_create_region<'c, 'input>(&'c self, region: Region, rectangles: &'input [xproto::Rectangle]) -> Result<VoidCookie<'c, Self>, ConnectionError>
575    {
576        create_region(self, region, rectangles)
577    }
578    fn xfixes_create_region_from_bitmap(&self, region: Region, bitmap: xproto::Pixmap) -> Result<VoidCookie<'_, Self>, ConnectionError>
579    {
580        create_region_from_bitmap(self, region, bitmap)
581    }
582    fn xfixes_create_region_from_window(&self, region: Region, window: xproto::Window, kind: shape::SK) -> Result<VoidCookie<'_, Self>, ConnectionError>
583    {
584        create_region_from_window(self, region, window, kind)
585    }
586    fn xfixes_create_region_from_gc(&self, region: Region, gc: xproto::Gcontext) -> Result<VoidCookie<'_, Self>, ConnectionError>
587    {
588        create_region_from_gc(self, region, gc)
589    }
590    fn xfixes_create_region_from_picture(&self, region: Region, picture: render::Picture) -> Result<VoidCookie<'_, Self>, ConnectionError>
591    {
592        create_region_from_picture(self, region, picture)
593    }
594    fn xfixes_destroy_region(&self, region: Region) -> Result<VoidCookie<'_, Self>, ConnectionError>
595    {
596        destroy_region(self, region)
597    }
598    fn xfixes_set_region<'c, 'input>(&'c self, region: Region, rectangles: &'input [xproto::Rectangle]) -> Result<VoidCookie<'c, Self>, ConnectionError>
599    {
600        set_region(self, region, rectangles)
601    }
602    fn xfixes_copy_region(&self, source: Region, destination: Region) -> Result<VoidCookie<'_, Self>, ConnectionError>
603    {
604        copy_region(self, source, destination)
605    }
606    fn xfixes_union_region(&self, source1: Region, source2: Region, destination: Region) -> Result<VoidCookie<'_, Self>, ConnectionError>
607    {
608        union_region(self, source1, source2, destination)
609    }
610    fn xfixes_intersect_region(&self, source1: Region, source2: Region, destination: Region) -> Result<VoidCookie<'_, Self>, ConnectionError>
611    {
612        intersect_region(self, source1, source2, destination)
613    }
614    fn xfixes_subtract_region(&self, source1: Region, source2: Region, destination: Region) -> Result<VoidCookie<'_, Self>, ConnectionError>
615    {
616        subtract_region(self, source1, source2, destination)
617    }
618    fn xfixes_invert_region(&self, source: Region, bounds: xproto::Rectangle, destination: Region) -> Result<VoidCookie<'_, Self>, ConnectionError>
619    {
620        invert_region(self, source, bounds, destination)
621    }
622    fn xfixes_translate_region(&self, region: Region, dx: i16, dy: i16) -> Result<VoidCookie<'_, Self>, ConnectionError>
623    {
624        translate_region(self, region, dx, dy)
625    }
626    fn xfixes_region_extents(&self, source: Region, destination: Region) -> Result<VoidCookie<'_, Self>, ConnectionError>
627    {
628        region_extents(self, source, destination)
629    }
630    fn xfixes_fetch_region(&self, region: Region) -> Result<Cookie<'_, Self, FetchRegionReply>, ConnectionError>
631    {
632        fetch_region(self, region)
633    }
634    fn xfixes_set_gc_clip_region<A>(&self, gc: xproto::Gcontext, region: A, x_origin: i16, y_origin: i16) -> Result<VoidCookie<'_, Self>, ConnectionError>
635    where
636        A: Into<Region>,
637    {
638        set_gc_clip_region(self, gc, region, x_origin, y_origin)
639    }
640    fn xfixes_set_window_shape_region<A>(&self, dest: xproto::Window, dest_kind: shape::SK, x_offset: i16, y_offset: i16, region: A) -> Result<VoidCookie<'_, Self>, ConnectionError>
641    where
642        A: Into<Region>,
643    {
644        set_window_shape_region(self, dest, dest_kind, x_offset, y_offset, region)
645    }
646    fn xfixes_set_picture_clip_region<A>(&self, picture: render::Picture, region: A, x_origin: i16, y_origin: i16) -> Result<VoidCookie<'_, Self>, ConnectionError>
647    where
648        A: Into<Region>,
649    {
650        set_picture_clip_region(self, picture, region, x_origin, y_origin)
651    }
652    fn xfixes_set_cursor_name<'c, 'input>(&'c self, cursor: xproto::Cursor, name: &'input [u8]) -> Result<VoidCookie<'c, Self>, ConnectionError>
653    {
654        set_cursor_name(self, cursor, name)
655    }
656    fn xfixes_get_cursor_name(&self, cursor: xproto::Cursor) -> Result<Cookie<'_, Self, GetCursorNameReply>, ConnectionError>
657    {
658        get_cursor_name(self, cursor)
659    }
660    fn xfixes_get_cursor_image_and_name(&self) -> Result<Cookie<'_, Self, GetCursorImageAndNameReply>, ConnectionError>
661    {
662        get_cursor_image_and_name(self)
663    }
664    fn xfixes_change_cursor(&self, source: xproto::Cursor, destination: xproto::Cursor) -> Result<VoidCookie<'_, Self>, ConnectionError>
665    {
666        change_cursor(self, source, destination)
667    }
668    fn xfixes_change_cursor_by_name<'c, 'input>(&'c self, src: xproto::Cursor, name: &'input [u8]) -> Result<VoidCookie<'c, Self>, ConnectionError>
669    {
670        change_cursor_by_name(self, src, name)
671    }
672    fn xfixes_expand_region(&self, source: Region, destination: Region, left: u16, right: u16, top: u16, bottom: u16) -> Result<VoidCookie<'_, Self>, ConnectionError>
673    {
674        expand_region(self, source, destination, left, right, top, bottom)
675    }
676    fn xfixes_hide_cursor(&self, window: xproto::Window) -> Result<VoidCookie<'_, Self>, ConnectionError>
677    {
678        hide_cursor(self, window)
679    }
680    fn xfixes_show_cursor(&self, window: xproto::Window) -> Result<VoidCookie<'_, Self>, ConnectionError>
681    {
682        show_cursor(self, window)
683    }
684    fn xfixes_create_pointer_barrier<'c, 'input>(&'c self, barrier: Barrier, window: xproto::Window, x1: u16, y1: u16, x2: u16, y2: u16, directions: BarrierDirections, devices: &'input [u16]) -> Result<VoidCookie<'c, Self>, ConnectionError>
685    {
686        create_pointer_barrier(self, barrier, window, x1, y1, x2, y2, directions, devices)
687    }
688    fn xfixes_delete_pointer_barrier(&self, barrier: Barrier) -> Result<VoidCookie<'_, Self>, ConnectionError>
689    {
690        delete_pointer_barrier(self, barrier)
691    }
692    /// Sets the disconnect mode for the client..
693    ///
694    /// # Fields
695    ///
696    /// * `disconnect_mode` - The new disconnect mode.
697    fn xfixes_set_client_disconnect_mode(&self, disconnect_mode: ClientDisconnectFlags) -> Result<VoidCookie<'_, Self>, ConnectionError>
698    {
699        set_client_disconnect_mode(self, disconnect_mode)
700    }
701    fn xfixes_get_client_disconnect_mode(&self) -> Result<Cookie<'_, Self, GetClientDisconnectModeReply>, ConnectionError>
702    {
703        get_client_disconnect_mode(self)
704    }
705}
706
707impl<C: RequestConnection + ?Sized> ConnectionExt for C {}
708
709/// A RAII-like wrapper around a [Region].
710///
711/// Instances of this struct represent a Region that is freed in `Drop`.
712///
713/// Any errors during `Drop` are silently ignored. Most likely an error here means that your
714/// X11 connection is broken and later requests will also fail.
715#[derive(Debug)]
716pub struct RegionWrapper<C: RequestConnection>(C, Region);
717
718impl<C: RequestConnection> RegionWrapper<C>
719{
720    /// Assume ownership of the given resource and destroy it in `Drop`.
721    pub fn for_region(conn: C, id: Region) -> Self {
722        RegionWrapper(conn, id)
723    }
724
725    /// Get the XID of the wrapped resource
726    pub fn region(&self) -> Region {
727        self.1
728    }
729
730    /// Assume ownership of the XID of the wrapped resource
731    ///
732    /// This function destroys this wrapper without freeing the underlying resource.
733    pub fn into_region(self) -> Region {
734        let id = self.1;
735        std::mem::forget(self);
736        id
737    }
738}
739
740impl<'c, C: X11Connection> RegionWrapper<&'c C>
741{
742    /// Create a new Region and return a Region wrapper and a cookie.
743    ///
744    /// This is a thin wrapper around [create_region] that allocates an id for the Region.
745    /// This function returns the resulting `RegionWrapper` that owns the created Region and frees
746    /// it in `Drop`. This also returns a `VoidCookie` that comes from the call to
747    /// [create_region].
748    ///
749    /// Errors can come from the call to [X11Connection::generate_id] or [create_region].
750    pub fn create_region_and_get_cookie(conn: &'c C, rectangles: &[xproto::Rectangle]) -> Result<(Self, VoidCookie<'c, C>), ReplyOrIdError>
751    {
752        let region = conn.generate_id()?;
753        let cookie = create_region(conn, region, rectangles)?;
754        Ok((Self::for_region(conn, region), cookie))
755    }
756}
757impl<C: X11Connection> RegionWrapper<C>
758{
759    /// Create a new Region and return a Region wrapper
760    ///
761    /// This is a thin wrapper around [create_region] that allocates an id for the Region.
762    /// This function returns the resulting `RegionWrapper` that owns the created Region and frees
763    /// it in `Drop`.
764    ///
765    /// Errors can come from the call to [X11Connection::generate_id] or [create_region].
766    pub fn create_region(conn: C, rectangles: &[xproto::Rectangle]) -> Result<Self, ReplyOrIdError>
767    {
768        let region = conn.generate_id()?;
769        let _ = create_region(&conn, region, rectangles)?;
770        Ok(Self::for_region(conn, region))
771    }
772}
773
774impl<'c, C: X11Connection> RegionWrapper<&'c C>
775{
776    /// Create a new Region and return a Region wrapper and a cookie.
777    ///
778    /// This is a thin wrapper around [create_region_from_bitmap] that allocates an id for the Region.
779    /// This function returns the resulting `RegionWrapper` that owns the created Region and frees
780    /// it in `Drop`. This also returns a `VoidCookie` that comes from the call to
781    /// [create_region_from_bitmap].
782    ///
783    /// Errors can come from the call to [X11Connection::generate_id] or [create_region_from_bitmap].
784    pub fn create_region_from_bitmap_and_get_cookie(conn: &'c C, bitmap: xproto::Pixmap) -> Result<(Self, VoidCookie<'c, C>), ReplyOrIdError>
785    {
786        let region = conn.generate_id()?;
787        let cookie = create_region_from_bitmap(conn, region, bitmap)?;
788        Ok((Self::for_region(conn, region), cookie))
789    }
790}
791impl<C: X11Connection> RegionWrapper<C>
792{
793    /// Create a new Region and return a Region wrapper
794    ///
795    /// This is a thin wrapper around [create_region_from_bitmap] that allocates an id for the Region.
796    /// This function returns the resulting `RegionWrapper` that owns the created Region and frees
797    /// it in `Drop`.
798    ///
799    /// Errors can come from the call to [X11Connection::generate_id] or [create_region_from_bitmap].
800    pub fn create_region_from_bitmap(conn: C, bitmap: xproto::Pixmap) -> Result<Self, ReplyOrIdError>
801    {
802        let region = conn.generate_id()?;
803        let _ = create_region_from_bitmap(&conn, region, bitmap)?;
804        Ok(Self::for_region(conn, region))
805    }
806}
807
808impl<'c, C: X11Connection> RegionWrapper<&'c C>
809{
810    /// Create a new Region and return a Region wrapper and a cookie.
811    ///
812    /// This is a thin wrapper around [create_region_from_window] that allocates an id for the Region.
813    /// This function returns the resulting `RegionWrapper` that owns the created Region and frees
814    /// it in `Drop`. This also returns a `VoidCookie` that comes from the call to
815    /// [create_region_from_window].
816    ///
817    /// Errors can come from the call to [X11Connection::generate_id] or [create_region_from_window].
818    pub fn create_region_from_window_and_get_cookie(conn: &'c C, window: xproto::Window, kind: shape::SK) -> Result<(Self, VoidCookie<'c, C>), ReplyOrIdError>
819    {
820        let region = conn.generate_id()?;
821        let cookie = create_region_from_window(conn, region, window, kind)?;
822        Ok((Self::for_region(conn, region), cookie))
823    }
824}
825impl<C: X11Connection> RegionWrapper<C>
826{
827    /// Create a new Region and return a Region wrapper
828    ///
829    /// This is a thin wrapper around [create_region_from_window] that allocates an id for the Region.
830    /// This function returns the resulting `RegionWrapper` that owns the created Region and frees
831    /// it in `Drop`.
832    ///
833    /// Errors can come from the call to [X11Connection::generate_id] or [create_region_from_window].
834    pub fn create_region_from_window(conn: C, window: xproto::Window, kind: shape::SK) -> Result<Self, ReplyOrIdError>
835    {
836        let region = conn.generate_id()?;
837        let _ = create_region_from_window(&conn, region, window, kind)?;
838        Ok(Self::for_region(conn, region))
839    }
840}
841
842impl<'c, C: X11Connection> RegionWrapper<&'c C>
843{
844    /// Create a new Region and return a Region wrapper and a cookie.
845    ///
846    /// This is a thin wrapper around [create_region_from_gc] that allocates an id for the Region.
847    /// This function returns the resulting `RegionWrapper` that owns the created Region and frees
848    /// it in `Drop`. This also returns a `VoidCookie` that comes from the call to
849    /// [create_region_from_gc].
850    ///
851    /// Errors can come from the call to [X11Connection::generate_id] or [create_region_from_gc].
852    pub fn create_region_from_gc_and_get_cookie(conn: &'c C, gc: xproto::Gcontext) -> Result<(Self, VoidCookie<'c, C>), ReplyOrIdError>
853    {
854        let region = conn.generate_id()?;
855        let cookie = create_region_from_gc(conn, region, gc)?;
856        Ok((Self::for_region(conn, region), cookie))
857    }
858}
859impl<C: X11Connection> RegionWrapper<C>
860{
861    /// Create a new Region and return a Region wrapper
862    ///
863    /// This is a thin wrapper around [create_region_from_gc] that allocates an id for the Region.
864    /// This function returns the resulting `RegionWrapper` that owns the created Region and frees
865    /// it in `Drop`.
866    ///
867    /// Errors can come from the call to [X11Connection::generate_id] or [create_region_from_gc].
868    pub fn create_region_from_gc(conn: C, gc: xproto::Gcontext) -> Result<Self, ReplyOrIdError>
869    {
870        let region = conn.generate_id()?;
871        let _ = create_region_from_gc(&conn, region, gc)?;
872        Ok(Self::for_region(conn, region))
873    }
874}
875
876impl<'c, C: X11Connection> RegionWrapper<&'c C>
877{
878    /// Create a new Region and return a Region wrapper and a cookie.
879    ///
880    /// This is a thin wrapper around [create_region_from_picture] that allocates an id for the Region.
881    /// This function returns the resulting `RegionWrapper` that owns the created Region and frees
882    /// it in `Drop`. This also returns a `VoidCookie` that comes from the call to
883    /// [create_region_from_picture].
884    ///
885    /// Errors can come from the call to [X11Connection::generate_id] or [create_region_from_picture].
886    pub fn create_region_from_picture_and_get_cookie(conn: &'c C, picture: render::Picture) -> Result<(Self, VoidCookie<'c, C>), ReplyOrIdError>
887    {
888        let region = conn.generate_id()?;
889        let cookie = create_region_from_picture(conn, region, picture)?;
890        Ok((Self::for_region(conn, region), cookie))
891    }
892}
893impl<C: X11Connection> RegionWrapper<C>
894{
895    /// Create a new Region and return a Region wrapper
896    ///
897    /// This is a thin wrapper around [create_region_from_picture] that allocates an id for the Region.
898    /// This function returns the resulting `RegionWrapper` that owns the created Region and frees
899    /// it in `Drop`.
900    ///
901    /// Errors can come from the call to [X11Connection::generate_id] or [create_region_from_picture].
902    pub fn create_region_from_picture(conn: C, picture: render::Picture) -> Result<Self, ReplyOrIdError>
903    {
904        let region = conn.generate_id()?;
905        let _ = create_region_from_picture(&conn, region, picture)?;
906        Ok(Self::for_region(conn, region))
907    }
908}
909
910impl<'c, C: X11Connection> RegionWrapper<&'c C>
911{
912    /// Create a new Region and return a Region wrapper and a cookie.
913    ///
914    /// This is a thin wrapper around [super::composite::create_region_from_border_clip] that allocates an id for the Region.
915    /// This function returns the resulting `RegionWrapper` that owns the created Region and frees
916    /// it in `Drop`. This also returns a `VoidCookie` that comes from the call to
917    /// [super::composite::create_region_from_border_clip].
918    ///
919    /// Errors can come from the call to [X11Connection::generate_id] or [super::composite::create_region_from_border_clip].
920    #[cfg(feature = "composite")]
921    pub fn composite_create_region_from_border_clip_and_get_cookie(conn: &'c C, window: xproto::Window) -> Result<(Self, VoidCookie<'c, C>), ReplyOrIdError>
922    {
923        let region = conn.generate_id()?;
924        let cookie = super::composite::create_region_from_border_clip(conn, region, window)?;
925        Ok((Self::for_region(conn, region), cookie))
926    }
927}
928impl<C: X11Connection> RegionWrapper<C>
929{
930    /// Create a new Region and return a Region wrapper
931    ///
932    /// This is a thin wrapper around [super::composite::create_region_from_border_clip] that allocates an id for the Region.
933    /// This function returns the resulting `RegionWrapper` that owns the created Region and frees
934    /// it in `Drop`.
935    ///
936    /// Errors can come from the call to [X11Connection::generate_id] or [super::composite::create_region_from_border_clip].
937    #[cfg(feature = "composite")]
938    pub fn composite_create_region_from_border_clip(conn: C, window: xproto::Window) -> Result<Self, ReplyOrIdError>
939    {
940        let region = conn.generate_id()?;
941        let _ = super::composite::create_region_from_border_clip(&conn, region, window)?;
942        Ok(Self::for_region(conn, region))
943    }
944}
945
946#[cfg(feature = "composite")]
947#[allow(unused_imports)]
948use super::composite;
949impl<C: RequestConnection> From<&RegionWrapper<C>> for Region {
950    fn from(from: &RegionWrapper<C>) -> Self {
951        from.1
952    }
953}
954
955impl<C: RequestConnection> Drop for RegionWrapper<C> {
956    fn drop(&mut self) {
957        let _ = destroy_region(&self.0, self.1);
958    }
959}
x11rb/protocol/xfixes.rs

x11rb/protocol/
xfixes.rs
