xproto.rs source code [crates/x11rb-0.13.0/src/protocol/xproto.rs]

1	// This file contains generated code. Do not edit directly.
2	// To regenerate this, run 'make'.
3
4	//! Bindings to the core X11 protocol.
5	//!
6	//! For more documentation on the X11 protocol, see the
7	//! [protocol reference manual](https://www.x.org/releases/X11R7.6/doc/xproto/x11protocol.html).
8	//! This is especially recommended for looking up the exact semantics of
9	//! specific errors, events, or requests.
10
11	#![allow(clippy::too_many_arguments)]
12
13	#[allow(unused_imports)]
14	use std::borrow::Cow;
15	#[allow(unused_imports)]
16	use std::convert::TryInto;
17	#[allow(unused_imports)]
18	use crate::utils::RawFdContainer;
19	#[allow(unused_imports)]
20	use crate::x11_utils::{Request, RequestHeader, Serialize, TryParse, TryParseFd};
21	use std::io::IoSlice;
22	use crate::connection::RequestConnection;
23	#[allow(unused_imports)]
24	use crate::connection::Connection as X11Connection;
25	#[allow(unused_imports)]
26	use crate::cookie::{Cookie, CookieWithFds, VoidCookie};
27	use crate::cookie::ListFontsWithInfoCookie;
28	use crate::errors::ConnectionError;
29	#[allow(unused_imports)]
30	use crate::errors::ReplyOrIdError;
31
32	pub use x11rb_protocol::protocol::xproto::*;
33
34	/// Creates a window.
35	///
36	/// Creates an unmapped window as child of the specified `parent` window. A
37	/// CreateNotify event will be generated. The new window is placed on top in the
38	/// stacking order with respect to siblings.
39	///
40	/// The coordinate system has the X axis horizontal and the Y axis vertical with
41	/// the origin [0, 0] at the upper-left corner. Coordinates are integral, in terms
42	/// of pixels, and coincide with pixel centers. Each window and pixmap has its own
43	/// coordinate system. For a window, the origin is inside the border at the inside,
44	/// upper-left corner.
45	///
46	/// The created window is not yet displayed (mapped), call `xcb_map_window` to
47	/// display it.
48	///
49	/// The created window will initially use the same cursor as its parent.
50	///
51	/// # Fields
52	///
53	/// `wid` - The ID with which you will refer to the new window, created by*
54	/// `xcb_generate_id`.
55	/// `depth` - Specifies the new window's depth (TODO: what unit?).*
56	///
57	/// The special value `XCB_COPY_FROM_PARENT` means the depth is taken from the
58	/// `parent` window.
59	/// `visual` - Specifies the id for the new window's visual.*
60	///
61	/// The special value `XCB_COPY_FROM_PARENT` means the visual is taken from the
62	/// `parent` window.
63	/// `class` -*
64	/// `parent` - The parent window of the new window.*
65	/// `border_width` - TODO:*
66	///
67	/// Must be zero if the `class` is `InputOnly` or a `xcb_match_error_t` occurs.
68	/// `x` - The X coordinate of the new window.*
69	/// `y` - The Y coordinate of the new window.*
70	/// `width` - The width of the new window.*
71	/// `height` - The height of the new window.*
72	///
73	/// # Errors
74	///
75	/// `Colormap` - TODO: reasons?*
76	/// `Match` - TODO: reasons?*
77	/// `Cursor` - TODO: reasons?*
78	/// `Pixmap` - TODO: reasons?*
79	/// `Value` - TODO: reasons?*
80	/// `Window` - TODO: reasons?*
81	/// `Alloc` - The X server could not allocate the requested resources (no memory?).*
82	///
83	/// # See
84	///
85	/// `xcb_generate_id`: function*
86	/// `MapWindow`: request*
87	/// `CreateNotify`: event*
88	pub fn create_window<'c, 'input, Conn>(conn: &'c Conn, depth: u8, wid: Window, parent: Window, x: i16, y: i16, width: u16, height: u16, border_width: u16, class: WindowClass, visual: Visualid, value_list: &'input CreateWindowAux) -> Result<VoidCookie<'c, Conn>, ConnectionError>
89	where
90	Conn: RequestConnection + ?Sized,
91	{
92	let request0: CreateWindowRequest<'_> = CreateWindowRequest {
93	depth,
94	wid,
95	parent,
96	x,
97	y,
98	width,
99	height,
100	border_width,
101	class,
102	visual,
103	value_list: Cow::Borrowed(value_list),
104	};
105	let (bytes: [Cow<'_, [u8]>; 3], fds: Vec) = request0.serialize();
106	let slices: [IoSlice<'_>; 3] = [IoSlice::new(&bytes[`0`]), IoSlice::new(&bytes[`1`]), IoSlice::new(&bytes[`2`])];
107	assert_eq!(slices.len(), bytes.len());
108	conn.send_request_without_reply(&slices, fds)
109	}
110
111	/// change window attributes.
112	///
113	/// Changes the attributes specified by `value_mask` for the specified `window`.
114	///
115	/// # Fields
116	///
117	/// `window` - The window to change.*
118	/// `value_mask` -*
119	/// `value_list` - Values for each of the attributes specified in the bitmask `value_mask`. The*
120	/// order has to correspond to the order of possible `value_mask` bits. See the
121	/// example.
122	///
123	/// # Errors
124	///
125	/// `Access` - TODO: reasons?*
126	/// `Colormap` - TODO: reasons?*
127	/// `Cursor` - TODO: reasons?*
128	/// `Match` - TODO: reasons?*
129	/// `Pixmap` - TODO: reasons?*
130	/// `Value` - TODO: reasons?*
131	/// `Window` - The specified `window` does not exist.*
132	pub fn change_window_attributes<'c, 'input, Conn>(conn: &'c Conn, window: Window, value_list: &'input ChangeWindowAttributesAux) -> Result<VoidCookie<'c, Conn>, ConnectionError>
133	where
134	Conn: RequestConnection + ?Sized,
135	{
136	let request0: ChangeWindowAttributesRequest<'_> = ChangeWindowAttributesRequest {
137	window,
138	value_list: Cow::Borrowed(value_list),
139	};
140	let (bytes: [Cow<'_, [u8]>; 3], fds: Vec) = request0.serialize();
141	let slices: [IoSlice<'_>; 3] = [IoSlice::new(&bytes[`0`]), IoSlice::new(&bytes[`1`]), IoSlice::new(&bytes[`2`])];
142	assert_eq!(slices.len(), bytes.len());
143	conn.send_request_without_reply(&slices, fds)
144	}
145
146	/// Gets window attributes.
147	///
148	/// Gets the current attributes for the specified `window`.
149	///
150	/// # Fields
151	///
152	/// `window` - The window to get the attributes from.*
153	///
154	/// # Errors
155	///
156	/// `Window` - The specified `window` does not exist.*
157	/// `Drawable` - TODO: reasons?*
158	pub fn get_window_attributes<Conn>(conn: &Conn, window: Window) -> Result<Cookie<'_, Conn, GetWindowAttributesReply>, ConnectionError>
159	where
160	Conn: RequestConnection + ?Sized,
161	{
162	let request0: GetWindowAttributesRequest = GetWindowAttributesRequest {
163	window,
164	};
165	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
166	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
167	assert_eq!(slices.len(), bytes.len());
168	conn.send_request_with_reply(&slices, fds)
169	}
170
171	/// Destroys a window.
172	///
173	/// Destroys the specified window and all of its subwindows. A DestroyNotify event
174	/// is generated for each destroyed window (a DestroyNotify event is first generated
175	/// for any given window's inferiors). If the window was mapped, it will be
176	/// automatically unmapped before destroying.
177	///
178	/// Calling DestroyWindow on the root window will do nothing.
179	///
180	/// # Fields
181	///
182	/// `window` - The window to destroy.*
183	///
184	/// # Errors
185	///
186	/// `Window` - The specified window does not exist.*
187	///
188	/// # See
189	///
190	/// `DestroyNotify`: event*
191	/// `MapWindow`: request*
192	/// `UnmapWindow`: request*
193	pub fn destroy_window<Conn>(conn: &Conn, window: Window) -> Result<VoidCookie<'_, Conn>, ConnectionError>
194	where
195	Conn: RequestConnection + ?Sized,
196	{
197	let request0: DestroyWindowRequest = DestroyWindowRequest {
198	window,
199	};
200	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
201	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
202	assert_eq!(slices.len(), bytes.len());
203	conn.send_request_without_reply(&slices, fds)
204	}
205
206	pub fn destroy_subwindows<Conn>(conn: &Conn, window: Window) -> Result<VoidCookie<'_, Conn>, ConnectionError>
207	where
208	Conn: RequestConnection + ?Sized,
209	{
210	let request0: DestroySubwindowsRequest = DestroySubwindowsRequest {
211	window,
212	};
213	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
214	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
215	assert_eq!(slices.len(), bytes.len());
216	conn.send_request_without_reply(&slices, fds)
217	}
218
219	/// Changes a client's save set.
220	///
221	/// TODO: explain what the save set is for.
222	///
223	/// This function either adds or removes the specified window to the client's (your
224	/// application's) save set.
225	///
226	/// # Fields
227	///
228	/// `mode` - Insert to add the specified window to the save set or Delete to delete it from the save set.*
229	/// `window` - The window to add or delete to/from your save set.*
230	///
231	/// # Errors
232	///
233	/// `Match` - You created the specified window. This does not make sense, you can only add*
234	/// windows created by other clients to your save set.
235	/// `Value` - You specified an invalid mode.*
236	/// `Window` - The specified window does not exist.*
237	///
238	/// # See
239	///
240	/// `ReparentWindow`: request*
241	pub fn change_save_set<Conn>(conn: &Conn, mode: SetMode, window: Window) -> Result<VoidCookie<'_, Conn>, ConnectionError>
242	where
243	Conn: RequestConnection + ?Sized,
244	{
245	let request0: ChangeSaveSetRequest = ChangeSaveSetRequest {
246	mode,
247	window,
248	};
249	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
250	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
251	assert_eq!(slices.len(), bytes.len());
252	conn.send_request_without_reply(&slices, fds)
253	}
254
255	/// Reparents a window.
256	///
257	/// Makes the specified window a child of the specified parent window. If the
258	/// window is mapped, it will automatically be unmapped before reparenting and
259	/// re-mapped after reparenting. The window is placed in the stacking order on top
260	/// with respect to sibling windows.
261	///
262	/// After reparenting, a ReparentNotify event is generated.
263	///
264	/// # Fields
265	///
266	/// `window` - The window to reparent.*
267	/// `parent` - The new parent of the window.*
268	/// `x` - The X position of the window within its new parent.*
269	/// `y` - The Y position of the window within its new parent.*
270	///
271	/// # Errors
272	///
273	/// `Match` - The new parent window is not on the same screen as the old parent window.*
274	///
275	/// The new parent window is the specified window or an inferior of the specified window.
276	///
277	/// The new parent is InputOnly and the window is not.
278	///
279	/// The specified window has a ParentRelative background and the new parent window is not the same depth as the specified window.
280	/// `Window` - The specified window does not exist.*
281	///
282	/// # See
283	///
284	/// `ReparentNotify`: event*
285	/// `MapWindow`: request*
286	/// `UnmapWindow`: request*
287	pub fn reparent_window<Conn>(conn: &Conn, window: Window, parent: Window, x: i16, y: i16) -> Result<VoidCookie<'_, Conn>, ConnectionError>
288	where
289	Conn: RequestConnection + ?Sized,
290	{
291	let request0: ReparentWindowRequest = ReparentWindowRequest {
292	window,
293	parent,
294	x,
295	y,
296	};
297	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
298	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
299	assert_eq!(slices.len(), bytes.len());
300	conn.send_request_without_reply(&slices, fds)
301	}
302
303	/// Makes a window visible.
304	///
305	/// Maps the specified window. This means making the window visible (as long as its
306	/// parent is visible).
307	///
308	/// This MapWindow request will be translated to a MapRequest request if a window
309	/// manager is running. The window manager then decides to either map the window or
310	/// not. Set the override-redirect window attribute to true if you want to bypass
311	/// this mechanism.
312	///
313	/// If the window manager decides to map the window (or if no window manager is
314	/// running), a MapNotify event is generated.
315	///
316	/// If the window becomes viewable and no earlier contents for it are remembered,
317	/// the X server tiles the window with its background. If the window's background
318	/// is undefined, the existing screen contents are not altered, and the X server
319	/// generates zero or more Expose events.
320	///
321	/// If the window type is InputOutput, an Expose event will be generated when the
322	/// window becomes visible. The normal response to an Expose event should be to
323	/// repaint the window.
324	///
325	/// # Fields
326	///
327	/// `window` - The window to make visible.*
328	///
329	/// # Errors
330	///
331	/// `Match` - The specified window does not exist.*
332	///
333	/// # See
334	///
335	/// `MapNotify`: event*
336	/// `Expose`: event*
337	/// `UnmapWindow`: request*
338	pub fn map_window<Conn>(conn: &Conn, window: Window) -> Result<VoidCookie<'_, Conn>, ConnectionError>
339	where
340	Conn: RequestConnection + ?Sized,
341	{
342	let request0: MapWindowRequest = MapWindowRequest {
343	window,
344	};
345	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
346	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
347	assert_eq!(slices.len(), bytes.len());
348	conn.send_request_without_reply(&slices, fds)
349	}
350
351	pub fn map_subwindows<Conn>(conn: &Conn, window: Window) -> Result<VoidCookie<'_, Conn>, ConnectionError>
352	where
353	Conn: RequestConnection + ?Sized,
354	{
355	let request0: MapSubwindowsRequest = MapSubwindowsRequest {
356	window,
357	};
358	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
359	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
360	assert_eq!(slices.len(), bytes.len());
361	conn.send_request_without_reply(&slices, fds)
362	}
363
364	/// Makes a window invisible.
365	///
366	/// Unmaps the specified window. This means making the window invisible (and all
367	/// its child windows).
368	///
369	/// Unmapping a window leads to the `UnmapNotify` event being generated. Also,
370	/// `Expose` events are generated for formerly obscured windows.
371	///
372	/// # Fields
373	///
374	/// `window` - The window to make invisible.*
375	///
376	/// # Errors
377	///
378	/// `Window` - The specified window does not exist.*
379	///
380	/// # See
381	///
382	/// `UnmapNotify`: event*
383	/// `Expose`: event*
384	/// `MapWindow`: request*
385	pub fn unmap_window<Conn>(conn: &Conn, window: Window) -> Result<VoidCookie<'_, Conn>, ConnectionError>
386	where
387	Conn: RequestConnection + ?Sized,
388	{
389	let request0: UnmapWindowRequest = UnmapWindowRequest {
390	window,
391	};
392	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
393	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
394	assert_eq!(slices.len(), bytes.len());
395	conn.send_request_without_reply(&slices, fds)
396	}
397
398	pub fn unmap_subwindows<Conn>(conn: &Conn, window: Window) -> Result<VoidCookie<'_, Conn>, ConnectionError>
399	where
400	Conn: RequestConnection + ?Sized,
401	{
402	let request0: UnmapSubwindowsRequest = UnmapSubwindowsRequest {
403	window,
404	};
405	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
406	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
407	assert_eq!(slices.len(), bytes.len());
408	conn.send_request_without_reply(&slices, fds)
409	}
410
411	/// Configures window attributes.
412	///
413	/// Configures a window's size, position, border width and stacking order.
414	///
415	/// # Fields
416	///
417	/// `window` - The window to configure.*
418	/// `value_mask` - Bitmask of attributes to change.*
419	/// `value_list` - New values, corresponding to the attributes in value_mask. The order has to*
420	/// correspond to the order of possible `value_mask` bits. See the example.
421	///
422	/// # Errors
423	///
424	/// `Match` - You specified a Sibling without also specifying StackMode or the window is not*
425	/// actually a Sibling.
426	/// `Window` - The specified window does not exist. TODO: any other reason?*
427	/// `Value` - TODO: reasons?*
428	///
429	/// # See
430	///
431	/// `MapNotify`: event*
432	/// `Expose`: event*
433	///
434	/// # Example
435	///
436	/// ```text
437	/// /*
438	/// Configures the given window to the left upper corner*
439	/// with a size of 1024x768 pixels.*
440	/// *
441	/// /*
442	/// void my_example(xcb_connection_t c, xcb_window_t window) {*
443	/// uint16_t mask = 0;
444	///
445	/// mask \|= XCB_CONFIG_WINDOW_X;
446	/// mask \|= XCB_CONFIG_WINDOW_Y;
447	/// mask \|= XCB_CONFIG_WINDOW_WIDTH;
448	/// mask \|= XCB_CONFIG_WINDOW_HEIGHT;
449	///
450	/// const uint32_t values[] = {
451	/// 0, / x /
452	/// 0, / y /
453	/// 1024, / width /
454	/// 768 / height /
455	/// };
456	///
457	/// xcb_configure_window(c, window, mask, values);
458	/// xcb_flush(c);
459	/// }
460	/// ```
461	pub fn configure_window<'c, 'input, Conn>(conn: &'c Conn, window: Window, value_list: &'input ConfigureWindowAux) -> Result<VoidCookie<'c, Conn>, ConnectionError>
462	where
463	Conn: RequestConnection + ?Sized,
464	{
465	let request0: ConfigureWindowRequest<'_> = ConfigureWindowRequest {
466	window,
467	value_list: Cow::Borrowed(value_list),
468	};
469	let (bytes: [Cow<'_, [u8]>; 3], fds: Vec) = request0.serialize();
470	let slices: [IoSlice<'_>; 3] = [IoSlice::new(&bytes[`0`]), IoSlice::new(&bytes[`1`]), IoSlice::new(&bytes[`2`])];
471	assert_eq!(slices.len(), bytes.len());
472	conn.send_request_without_reply(&slices, fds)
473	}
474
475	/// Change window stacking order.
476	///
477	/// If `direction` is `XCB_CIRCULATE_RAISE_LOWEST`, the lowest mapped child (if
478	/// any) will be raised to the top of the stack.
479	///
480	/// If `direction` is `XCB_CIRCULATE_LOWER_HIGHEST`, the highest mapped child will
481	/// be lowered to the bottom of the stack.
482	///
483	/// # Fields
484	///
485	/// `direction` -*
486	/// `window` - The window to raise/lower (depending on `direction`).*
487	///
488	/// # Errors
489	///
490	/// `Window` - The specified `window` does not exist.*
491	/// `Value` - The specified `direction` is invalid.*
492	pub fn circulate_window<Conn>(conn: &Conn, direction: Circulate, window: Window) -> Result<VoidCookie<'_, Conn>, ConnectionError>
493	where
494	Conn: RequestConnection + ?Sized,
495	{
496	let request0: CirculateWindowRequest = CirculateWindowRequest {
497	direction,
498	window,
499	};
500	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
501	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
502	assert_eq!(slices.len(), bytes.len());
503	conn.send_request_without_reply(&slices, fds)
504	}
505
506	/// Get current window geometry.
507	///
508	/// Gets the current geometry of the specified drawable (either `Window` or `Pixmap`).
509	///
510	/// # Fields
511	///
512	/// `drawable` - The drawable (`Window` or `Pixmap`) of which the geometry will be received.*
513	///
514	/// # Errors
515	///
516	/// `Drawable` - TODO: reasons?*
517	/// `Window` - TODO: reasons?*
518	///
519	/// # See
520	///
521	/// `xwininfo`: program*
522	///
523	/// # Example
524	///
525	/// ```text
526	/// /*
527	/// Displays the x and y position of the given window.*
528	/// *
529	/// /*
530	/// void my_example(xcb_connection_t c, xcb_window_t window) {*
531	/// xcb_get_geometry_cookie_t cookie;
532	/// xcb_get_geometry_reply_t reply;*
533	///
534	/// cookie = xcb_get_geometry(c, window);
535	/// / ... do other work here if possible ... /
536	/// if ((reply = xcb_get_geometry_reply(c, cookie, NULL))) {
537	/// printf("This window is at %d, %d\\n", reply->x, reply->y);
538	/// }
539	/// free(reply);
540	/// }
541	/// ```
542	pub fn get_geometry<Conn>(conn: &Conn, drawable: Drawable) -> Result<Cookie<'_, Conn, GetGeometryReply>, ConnectionError>
543	where
544	Conn: RequestConnection + ?Sized,
545	{
546	let request0: GetGeometryRequest = GetGeometryRequest {
547	drawable,
548	};
549	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
550	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
551	assert_eq!(slices.len(), bytes.len());
552	conn.send_request_with_reply(&slices, fds)
553	}
554
555	/// query the window tree.
556	///
557	/// Gets the root window ID, parent window ID and list of children windows for the
558	/// specified `window`. The children are listed in bottom-to-top stacking order.
559	///
560	/// # Fields
561	///
562	/// `window` - The `window` to query.*
563	///
564	/// # See
565	///
566	/// `xwininfo`: program*
567	///
568	/// # Example
569	///
570	/// ```text
571	/// /*
572	/// Displays the root, parent and children of the specified window.*
573	/// *
574	/// /*
575	/// void my_example(xcb_connection_t conn, xcb_window_t window) {*
576	/// xcb_query_tree_cookie_t cookie;
577	/// xcb_query_tree_reply_t reply;*
578	///
579	/// cookie = xcb_query_tree(conn, window);
580	/// if ((reply = xcb_query_tree_reply(conn, cookie, NULL))) {
581	/// printf("root = 0x%08x\\n", reply->root);
582	/// printf("parent = 0x%08x\\n", reply->parent);
583	///
584	/// xcb_window_t children = xcb_query_tree_children(reply);*
585	/// for (int i = 0; i < xcb_query_tree_children_length(reply); i++)
586	/// printf("child window = 0x%08x\\n", children[i]);
587	///
588	/// free(reply);
589	/// }
590	/// }
591	/// ```
592	pub fn query_tree<Conn>(conn: &Conn, window: Window) -> Result<Cookie<'_, Conn, QueryTreeReply>, ConnectionError>
593	where
594	Conn: RequestConnection + ?Sized,
595	{
596	let request0: QueryTreeRequest = QueryTreeRequest {
597	window,
598	};
599	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
600	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
601	assert_eq!(slices.len(), bytes.len());
602	conn.send_request_with_reply(&slices, fds)
603	}
604
605	/// Get atom identifier by name.
606	///
607	/// Retrieves the identifier (xcb_atom_t TODO) for the atom with the specified
608	/// name. Atoms are used in protocols like EWMH, for example to store window titles
609	/// (`_NET_WM_NAME` atom) as property of a window.
610	///
611	/// If `only_if_exists` is 0, the atom will be created if it does not already exist.
612	/// If `only_if_exists` is 1, `XCB_ATOM_NONE` will be returned if the atom does
613	/// not yet exist.
614	///
615	/// # Fields
616	///
617	/// `name_len` - The length of the following `name`.*
618	/// `name` - The name of the atom.*
619	/// `only_if_exists` - Return a valid atom id only if the atom already exists.*
620	///
621	/// # Errors
622	///
623	/// `Alloc` - TODO: reasons?*
624	/// `Value` - A value other than 0 or 1 was specified for `only_if_exists`.*
625	///
626	/// # See
627	///
628	/// `xlsatoms`: program*
629	/// `GetAtomName`: request*
630	///
631	/// # Example
632	///
633	/// ```text
634	/// /*
635	/// Resolves the _NET_WM_NAME atom.*
636	/// *
637	/// /*
638	/// void my_example(xcb_connection_t c) {*
639	/// xcb_intern_atom_cookie_t cookie;
640	/// xcb_intern_atom_reply_t reply;*
641	///
642	/// cookie = xcb_intern_atom(c, 0, strlen("_NET_WM_NAME"), "_NET_WM_NAME");
643	/// / ... do other work here if possible ... /
644	/// if ((reply = xcb_intern_atom_reply(c, cookie, NULL))) {
645	/// printf("The _NET_WM_NAME atom has ID %u\n", reply->atom);
646	/// free(reply);
647	/// }
648	/// }
649	/// ```
650	pub fn intern_atom<'c, 'input, Conn>(conn: &'c Conn, only_if_exists: bool, name: &'input [u8]) -> Result<Cookie<'c, Conn, InternAtomReply>, ConnectionError>
651	where
652	Conn: RequestConnection + ?Sized,
653	{
654	let request0: InternAtomRequest<'_> = InternAtomRequest {
655	only_if_exists,
656	name: Cow::Borrowed(name),
657	};
658	let (bytes: [Cow<'_, [u8]>; 3], fds: Vec) = request0.serialize();
659	let slices: [IoSlice<'_>; 3] = [IoSlice::new(&bytes[`0`]), IoSlice::new(&bytes[`1`]), IoSlice::new(&bytes[`2`])];
660	assert_eq!(slices.len(), bytes.len());
661	conn.send_request_with_reply(&slices, fds)
662	}
663
664	pub fn get_atom_name<Conn>(conn: &Conn, atom: Atom) -> Result<Cookie<'_, Conn, GetAtomNameReply>, ConnectionError>
665	where
666	Conn: RequestConnection + ?Sized,
667	{
668	let request0: GetAtomNameRequest = GetAtomNameRequest {
669	atom,
670	};
671	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
672	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
673	assert_eq!(slices.len(), bytes.len());
674	conn.send_request_with_reply(&slices, fds)
675	}
676
677	/// Changes a window property.
678	///
679	/// Sets or updates a property on the specified `window`. Properties are for
680	/// example the window title (`WM_NAME`) or its minimum size (`WM_NORMAL_HINTS`).
681	/// Protocols such as EWMH also use properties - for example EWMH defines the
682	/// window title, encoded as UTF-8 string, in the `_NET_WM_NAME` property.
683	///
684	/// # Fields
685	///
686	/// `window` - The window whose property you want to change.*
687	/// `mode` -*
688	/// `property` - The property you want to change (an atom).*
689	/// `type` - The type of the property you want to change (an atom).*
690	/// `format` - Specifies whether the data should be viewed as a list of 8-bit, 16-bit or*
691	/// 32-bit quantities. Possible values are 8, 16 and 32. This information allows
692	/// the X server to correctly perform byte-swap operations as necessary.
693	/// `data_len` - Specifies the number of elements (see `format`).*
694	/// `data` - The property data.*
695	///
696	/// # Errors
697	///
698	/// `Match` - TODO: reasons?*
699	/// `Value` - TODO: reasons?*
700	/// `Window` - The specified `window` does not exist.*
701	/// `Atom` - `property` or `type` do not refer to a valid atom.*
702	/// `Alloc` - The X server could not store the property (no memory?).*
703	///
704	/// # See
705	///
706	/// `InternAtom`: request*
707	/// `xprop`: program*
708	///
709	/// # Example
710	///
711	/// ```text
712	/// /*
713	/// Sets the WM_NAME property of the window to "XCB Example".*
714	/// *
715	/// /*
716	/// void my_example(xcb_connection_t conn, xcb_window_t window) {*
717	/// xcb_change_property(conn,
718	/// XCB_PROP_MODE_REPLACE,
719	/// window,
720	/// XCB_ATOM_WM_NAME,
721	/// XCB_ATOM_STRING,
722	/// 8,
723	/// strlen("XCB Example"),
724	/// "XCB Example");
725	/// xcb_flush(conn);
726	/// }
727	/// ```
728	pub fn change_property<'c, 'input, Conn, A, B>(conn: &'c Conn, mode: PropMode, window: Window, property: A, type_: B, format: u8, data_len: u32, data: &'input [u8]) -> Result<VoidCookie<'c, Conn>, ConnectionError>
729	where
730	Conn: RequestConnection + ?Sized,
731	A: Into<Atom>,
732	B: Into<Atom>,
733	{
734	let property: Atom = property.into();
735	let type_: Atom = type_.into();
736	let request0: ChangePropertyRequest<'_> = ChangePropertyRequest {
737	mode,
738	window,
739	property,
740	type_,
741	format,
742	data_len,
743	data: Cow::Borrowed(data),
744	};
745	let (bytes: [Cow<'_, [u8]>; 3], fds: Vec) = request0.serialize();
746	let slices: [IoSlice<'_>; 3] = [IoSlice::new(&bytes[`0`]), IoSlice::new(&bytes[`1`]), IoSlice::new(&bytes[`2`])];
747	assert_eq!(slices.len(), bytes.len());
748	conn.send_request_without_reply(&slices, fds)
749	}
750
751	pub fn delete_property<Conn>(conn: &Conn, window: Window, property: Atom) -> Result<VoidCookie<'_, Conn>, ConnectionError>
752	where
753	Conn: RequestConnection + ?Sized,
754	{
755	let request0: DeletePropertyRequest = DeletePropertyRequest {
756	window,
757	property,
758	};
759	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
760	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
761	assert_eq!(slices.len(), bytes.len());
762	conn.send_request_without_reply(&slices, fds)
763	}
764
765	/// Gets a window property.
766	///
767	/// Gets the specified `property` from the specified `window`. Properties are for
768	/// example the window title (`WM_NAME`) or its minimum size (`WM_NORMAL_HINTS`).
769	/// Protocols such as EWMH also use properties - for example EWMH defines the
770	/// window title, encoded as UTF-8 string, in the `_NET_WM_NAME` property.
771	///
772	/// TODO: talk about `type`
773	///
774	/// TODO: talk about `delete`
775	///
776	/// TODO: talk about the offset/length thing. what's a valid use case?
777	///
778	/// # Fields
779	///
780	/// `window` - The window whose property you want to get.*
781	/// `delete` - Whether the property should actually be deleted. For deleting a property, the*
782	/// specified `type` has to match the actual property type.
783	/// `property` - The property you want to get (an atom).*
784	/// `type` - The type of the property you want to get (an atom).*
785	/// `long_offset` - Specifies the offset (in 32-bit multiples) in the specified property where the*
786	/// data is to be retrieved.
787	/// `long_length` - Specifies how many 32-bit multiples of data should be retrieved (e.g. if you*
788	/// set `long_length` to 4, you will receive 16 bytes of data).
789	///
790	/// # Errors
791	///
792	/// `Window` - The specified `window` does not exist.*
793	/// `Atom` - `property` or `type` do not refer to a valid atom.*
794	/// `Value` - The specified `long_offset` is beyond the actual property length (e.g. the*
795	/// property has a length of 3 bytes and you are setting `long_offset` to 1,
796	/// resulting in a byte offset of 4).
797	///
798	/// # See
799	///
800	/// `InternAtom`: request*
801	/// `xprop`: program*
802	///
803	/// # Example
804	///
805	/// ```text
806	/// /*
807	/// Prints the WM_NAME property of the window.*
808	/// *
809	/// /*
810	/// void my_example(xcb_connection_t c, xcb_window_t window) {*
811	/// xcb_get_property_cookie_t cookie;
812	/// xcb_get_property_reply_t reply;*
813	///
814	/// / These atoms are predefined in the X11 protocol. /
815	/// xcb_atom_t property = XCB_ATOM_WM_NAME;
816	/// xcb_atom_t type = XCB_ATOM_STRING;
817	///
818	/// // TODO: a reasonable long_length for WM_NAME?
819	/// cookie = xcb_get_property(c, 0, window, property, type, 0, 0);
820	/// if ((reply = xcb_get_property_reply(c, cookie, NULL))) {
821	/// int len = xcb_get_property_value_length(reply);
822	/// if (len == 0) {
823	/// printf("TODO\\n");
824	/// free(reply);
825	/// return;
826	/// }
827	/// printf("WM_NAME is %.s\\n", len,*
828	/// (char)xcb_get_property_value(reply));*
829	/// }
830	/// free(reply);
831	/// }
832	/// ```
833	pub fn get_property<Conn, A, B>(conn: &Conn, delete: bool, window: Window, property: A, type_: B, long_offset: u32, long_length: u32) -> Result<Cookie<'_, Conn, GetPropertyReply>, ConnectionError>
834	where
835	Conn: RequestConnection + ?Sized,
836	A: Into<Atom>,
837	B: Into<Atom>,
838	{
839	let property: Atom = property.into();
840	let type_: Atom = type_.into();
841	let request0: GetPropertyRequest = GetPropertyRequest {
842	delete,
843	window,
844	property,
845	type_,
846	long_offset,
847	long_length,
848	};
849	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
850	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
851	assert_eq!(slices.len(), bytes.len());
852	conn.send_request_with_reply(&slices, fds)
853	}
854
855	pub fn list_properties<Conn>(conn: &Conn, window: Window) -> Result<Cookie<'_, Conn, ListPropertiesReply>, ConnectionError>
856	where
857	Conn: RequestConnection + ?Sized,
858	{
859	let request0: ListPropertiesRequest = ListPropertiesRequest {
860	window,
861	};
862	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
863	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
864	assert_eq!(slices.len(), bytes.len());
865	conn.send_request_with_reply(&slices, fds)
866	}
867
868	/// Sets the owner of a selection.
869	///
870	/// Makes `window` the owner of the selection `selection` and updates the
871	/// last-change time of the specified selection.
872	///
873	/// TODO: briefly explain what a selection is.
874	///
875	/// # Fields
876	///
877	/// `selection` - The selection.*
878	/// `owner` - The new owner of the selection.*
879	///
880	/// The special value `XCB_NONE` means that the selection will have no owner.
881	/// `time` - Timestamp to avoid race conditions when running X over the network.*
882	///
883	/// The selection will not be changed if `time` is earlier than the current
884	/// last-change time of the `selection` or is later than the current X server time.
885	/// Otherwise, the last-change time is set to the specified time.
886	///
887	/// The special value `XCB_CURRENT_TIME` will be replaced with the current server
888	/// time.
889	///
890	/// # Errors
891	///
892	/// `Atom` - `selection` does not refer to a valid atom.*
893	///
894	/// # See
895	///
896	/// `SetSelectionOwner`: request*
897	pub fn set_selection_owner<Conn, A, B>(conn: &Conn, owner: A, selection: Atom, time: B) -> Result<VoidCookie<'_, Conn>, ConnectionError>
898	where
899	Conn: RequestConnection + ?Sized,
900	A: Into<Window>,
901	B: Into<Timestamp>,
902	{
903	let owner: Window = owner.into();
904	let time: Timestamp = time.into();
905	let request0: SetSelectionOwnerRequest = SetSelectionOwnerRequest {
906	owner,
907	selection,
908	time,
909	};
910	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
911	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
912	assert_eq!(slices.len(), bytes.len());
913	conn.send_request_without_reply(&slices, fds)
914	}
915
916	/// Gets the owner of a selection.
917	///
918	/// Gets the owner of the specified selection.
919	///
920	/// TODO: briefly explain what a selection is.
921	///
922	/// # Fields
923	///
924	/// `selection` - The selection.*
925	///
926	/// # Errors
927	///
928	/// `Atom` - `selection` does not refer to a valid atom.*
929	///
930	/// # See
931	///
932	/// `SetSelectionOwner`: request*
933	pub fn get_selection_owner<Conn>(conn: &Conn, selection: Atom) -> Result<Cookie<'_, Conn, GetSelectionOwnerReply>, ConnectionError>
934	where
935	Conn: RequestConnection + ?Sized,
936	{
937	let request0: GetSelectionOwnerRequest = GetSelectionOwnerRequest {
938	selection,
939	};
940	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
941	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
942	assert_eq!(slices.len(), bytes.len());
943	conn.send_request_with_reply(&slices, fds)
944	}
945
946	pub fn convert_selection<Conn, A, B>(conn: &Conn, requestor: Window, selection: Atom, target: Atom, property: A, time: B) -> Result<VoidCookie<'_, Conn>, ConnectionError>
947	where
948	Conn: RequestConnection + ?Sized,
949	A: Into<Atom>,
950	B: Into<Timestamp>,
951	{
952	let property: Atom = property.into();
953	let time: Timestamp = time.into();
954	let request0: ConvertSelectionRequest = ConvertSelectionRequest {
955	requestor,
956	selection,
957	target,
958	property,
959	time,
960	};
961	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
962	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
963	assert_eq!(slices.len(), bytes.len());
964	conn.send_request_without_reply(&slices, fds)
965	}
966
967	/// send an event.
968	///
969	/// Identifies the `destination` window, determines which clients should receive
970	/// the specified event and ignores any active grabs.
971	///
972	/// The `event` must be one of the core events or an event defined by an extension,
973	/// so that the X server can correctly byte-swap the contents as necessary. The
974	/// contents of `event` are otherwise unaltered and unchecked except for the
975	/// `send_event` field which is forced to 'true'.
976	///
977	/// # Fields
978	///
979	/// `destination` - The window to send this event to. Every client which selects any event within*
980	/// `event_mask` on `destination` will get the event.
981	///
982	/// The special value `XCB_SEND_EVENT_DEST_POINTER_WINDOW` refers to the window
983	/// that contains the mouse pointer.
984	///
985	/// The special value `XCB_SEND_EVENT_DEST_ITEM_FOCUS` refers to the window which
986	/// has the keyboard focus.
987	/// `event_mask` - Event_mask for determining which clients should receive the specified event.*
988	/// See `destination` and `propagate`.
989	/// `propagate` - If `propagate` is true and no clients have selected any event on `destination`,*
990	/// the destination is replaced with the closest ancestor of `destination` for
991	/// which some client has selected a type in `event_mask` and for which no
992	/// intervening window has that type in its do-not-propagate-mask. If no such
993	/// window exists or if the window is an ancestor of the focus window and
994	/// `InputFocus` was originally specified as the destination, the event is not sent
995	/// to any clients. Otherwise, the event is reported to every client selecting on
996	/// the final destination any of the types specified in `event_mask`.
997	/// `event` - The event to send to the specified `destination`.*
998	///
999	/// # Errors
1000	///
1001	/// `Window` - The specified `destination` window does not exist.*
1002	/// `Value` - The given `event` is neither a core event nor an event defined by an extension.*
1003	///
1004	/// # See
1005	///
1006	/// `ConfigureNotify`: event*
1007	///
1008	/// # Example
1009	///
1010	/// ```text
1011	/// /*
1012	/// Tell the given window that it was configured to a size of 800x600 pixels.*
1013	/// *
1014	/// /*
1015	/// void my_example(xcb_connection_t conn, xcb_window_t window) {*
1016	/// / Every X11 event is 32 bytes long. Therefore, XCB will copy 32 bytes.*
1017	/// In order to properly initialize these bytes, we allocate 32 bytes even*
1018	/// though we only need less for an xcb_configure_notify_event_t /
1019	/// xcb_configure_notify_event_t event = calloc(32, 1);*
1020	///
1021	/// event->event = window;
1022	/// event->window = window;
1023	/// event->response_type = XCB_CONFIGURE_NOTIFY;
1024	///
1025	/// event->x = 0;
1026	/// event->y = 0;
1027	/// event->width = 800;
1028	/// event->height = 600;
1029	///
1030	/// event->border_width = 0;
1031	/// event->above_sibling = XCB_NONE;
1032	/// event->override_redirect = false;
1033	///
1034	/// xcb_send_event(conn, false, window, XCB_EVENT_MASK_STRUCTURE_NOTIFY,
1035	/// (char)event);*
1036	/// xcb_flush(conn);
1037	/// free(event);
1038	/// }
1039	/// ```
1040	pub fn send_event<Conn, A, B>(conn: &Conn, propagate: bool, destination: A, event_mask: EventMask, event: B) -> Result<VoidCookie<'_, Conn>, ConnectionError>
1041	where
1042	Conn: RequestConnection + ?Sized,
1043	A: Into<Window>,
1044	B: Into<[u8; `32`]>,
1045	{
1046	let destination: Window = destination.into();
1047	let event: Cow<'_, [u8; 32]> = Cow::Owned(event.into());
1048	let request0: SendEventRequest<'_> = SendEventRequest {
1049	propagate,
1050	destination,
1051	event_mask,
1052	event,
1053	};
1054	let (bytes: [Cow<'_, [u8]>; 2], fds: Vec) = request0.serialize();
1055	let slices: [IoSlice<'_>; 2] = [IoSlice::new(&bytes[`0`]), IoSlice::new(&bytes[`1`])];
1056	assert_eq!(slices.len(), bytes.len());
1057	conn.send_request_without_reply(&slices, fds)
1058	}
1059
1060	/// Grab the pointer.
1061	///
1062	/// Actively grabs control of the pointer. Further pointer events are reported only to the grabbing client. Overrides any active pointer grab by this client.
1063	///
1064	/// # Fields
1065	///
1066	/// `event_mask` - Specifies which pointer events are reported to the client.*
1067	///
1068	/// TODO: which values?
1069	/// `confine_to` - Specifies the window to confine the pointer in (the user will not be able to*
1070	/// move the pointer out of that window).
1071	///
1072	/// The special value `XCB_NONE` means don't confine the pointer.
1073	/// `cursor` - Specifies the cursor that should be displayed or `XCB_NONE` to not change the*
1074	/// cursor.
1075	/// `owner_events` - If 1, the `grab_window` will still get the pointer events. If 0, events are not*
1076	/// reported to the `grab_window`.
1077	/// `grab_window` - Specifies the window on which the pointer should be grabbed.*
1078	/// `time` - The time argument allows you to avoid certain circumstances that come up if*
1079	/// applications take a long time to respond or if there are long network delays.
1080	/// Consider a situation where you have two applications, both of which normally
1081	/// grab the pointer when clicked on. If both applications specify the timestamp
1082	/// from the event, the second application may wake up faster and successfully grab
1083	/// the pointer before the first application. The first application then will get
1084	/// an indication that the other application grabbed the pointer before its request
1085	/// was processed.
1086	///
1087	/// The special value `XCB_CURRENT_TIME` will be replaced with the current server
1088	/// time.
1089	/// `pointer_mode` -*
1090	/// `keyboard_mode` -*
1091	///
1092	/// # Errors
1093	///
1094	/// `Value` - TODO: reasons?*
1095	/// `Window` - The specified `window` does not exist.*
1096	///
1097	/// # See
1098	///
1099	/// `GrabKeyboard`: request*
1100	///
1101	/// # Example
1102	///
1103	/// ```text
1104	/// /*
1105	/// Grabs the pointer actively*
1106	/// *
1107	/// /*
1108	/// void my_example(xcb_connection_t conn, xcb_screen_t screen, xcb_cursor_t cursor) {
1109	/// xcb_grab_pointer_cookie_t cookie;
1110	/// xcb_grab_pointer_reply_t reply;*
1111	///
1112	/// cookie = xcb_grab_pointer(
1113	/// conn,
1114	/// false, / get all pointer events specified by the following mask /
1115	/// screen->root, / grab the root window /
1116	/// XCB_NONE, / which events to let through /
1117	/// XCB_GRAB_MODE_ASYNC, / pointer events should continue as normal /
1118	/// XCB_GRAB_MODE_ASYNC, / keyboard mode /
1119	/// XCB_NONE, / confine_to = in which window should the cursor stay /
1120	/// cursor, / we change the cursor to whatever the user wanted /
1121	/// XCB_CURRENT_TIME
1122	/// );
1123	///
1124	/// if ((reply = xcb_grab_pointer_reply(conn, cookie, NULL))) {
1125	/// if (reply->status == XCB_GRAB_STATUS_SUCCESS)
1126	/// printf("successfully grabbed the pointer\\n");
1127	/// free(reply);
1128	/// }
1129	/// }
1130	/// ```
1131	pub fn grab_pointer<Conn, A, B, C>(conn: &Conn, owner_events: bool, grab_window: Window, event_mask: EventMask, pointer_mode: GrabMode, keyboard_mode: GrabMode, confine_to: A, cursor: B, time: C) -> Result<Cookie<'_, Conn, GrabPointerReply>, ConnectionError>
1132	where
1133	Conn: RequestConnection + ?Sized,
1134	A: Into<Window>,
1135	B: Into<Cursor>,
1136	C: Into<Timestamp>,
1137	{
1138	let confine_to: Window = confine_to.into();
1139	let cursor: Cursor = cursor.into();
1140	let time: Timestamp = time.into();
1141	let request0: GrabPointerRequest = GrabPointerRequest {
1142	owner_events,
1143	grab_window,
1144	event_mask,
1145	pointer_mode,
1146	keyboard_mode,
1147	confine_to,
1148	cursor,
1149	time,
1150	};
1151	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
1152	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
1153	assert_eq!(slices.len(), bytes.len());
1154	conn.send_request_with_reply(&slices, fds)
1155	}
1156
1157	/// release the pointer.
1158	///
1159	/// Releases the pointer and any queued events if you actively grabbed the pointer
1160	/// before using `xcb_grab_pointer`, `xcb_grab_button` or within a normal button
1161	/// press.
1162	///
1163	/// EnterNotify and LeaveNotify events are generated.
1164	///
1165	/// # Fields
1166	///
1167	/// `time` - Timestamp to avoid race conditions when running X over the network.*
1168	///
1169	/// The pointer will not be released if `time` is earlier than the
1170	/// last-pointer-grab time or later than the current X server time.
1171	/// `name_len` - Length (in bytes) of `name`.*
1172	/// `name` - A pattern describing an X core font.*
1173	///
1174	/// # See
1175	///
1176	/// `GrabPointer`: request*
1177	/// `GrabButton`: request*
1178	/// `EnterNotify`: event*
1179	/// `LeaveNotify`: event*
1180	pub fn ungrab_pointer<Conn, A>(conn: &Conn, time: A) -> Result<VoidCookie<'_, Conn>, ConnectionError>
1181	where
1182	Conn: RequestConnection + ?Sized,
1183	A: Into<Timestamp>,
1184	{
1185	let time: Timestamp = time.into();
1186	let request0: UngrabPointerRequest = UngrabPointerRequest {
1187	time,
1188	};
1189	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
1190	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
1191	assert_eq!(slices.len(), bytes.len());
1192	conn.send_request_without_reply(&slices, fds)
1193	}
1194
1195	/// Grab pointer button(s).
1196	///
1197	/// This request establishes a passive grab. The pointer is actively grabbed as
1198	/// described in GrabPointer, the last-pointer-grab time is set to the time at
1199	/// which the button was pressed (as transmitted in the ButtonPress event), and the
1200	/// ButtonPress event is reported if all of the following conditions are true:
1201	///
1202	/// The pointer is not grabbed and the specified button is logically pressed when
1203	/// the specified modifier keys are logically down, and no other buttons or
1204	/// modifier keys are logically down.
1205	///
1206	/// The grab-window contains the pointer.
1207	///
1208	/// The confine-to window (if any) is viewable.
1209	///
1210	/// A passive grab on the same button/key combination does not exist on any
1211	/// ancestor of grab-window.
1212	///
1213	/// The interpretation of the remaining arguments is the same as for GrabPointer.
1214	/// The active grab is terminated automatically when the logical state of the
1215	/// pointer has all buttons released, independent of the logical state of modifier
1216	/// keys. Note that the logical state of a device (as seen by means of the
1217	/// protocol) may lag the physical state if device event processing is frozen. This
1218	/// request overrides all previous passive grabs by the same client on the same
1219	/// button/key combinations on the same window. A modifier of AnyModifier is
1220	/// equivalent to issuing the request for all possible modifier combinations
1221	/// (including the combination of no modifiers). It is not required that all
1222	/// specified modifiers have currently assigned keycodes. A button of AnyButton is
1223	/// equivalent to issuing the request for all possible buttons. Otherwise, it is
1224	/// not required that the button specified currently be assigned to a physical
1225	/// button.
1226	///
1227	/// An Access error is generated if some other client has already issued a
1228	/// GrabButton request with the same button/key combination on the same window.
1229	/// When using AnyModifier or AnyButton, the request fails completely (no grabs are
1230	/// established), and an Access error is generated if there is a conflicting grab
1231	/// for any combination. The request has no effect on an active grab.
1232	///
1233	/// # Fields
1234	///
1235	/// `owner_events` - If 1, the `grab_window` will still get the pointer events. If 0, events are not*
1236	/// reported to the `grab_window`.
1237	/// `grab_window` - Specifies the window on which the pointer should be grabbed.*
1238	/// `event_mask` - Specifies which pointer events are reported to the client.*
1239	///
1240	/// TODO: which values?
1241	/// `confine_to` - Specifies the window to confine the pointer in (the user will not be able to*
1242	/// move the pointer out of that window).
1243	///
1244	/// The special value `XCB_NONE` means don't confine the pointer.
1245	/// `cursor` - Specifies the cursor that should be displayed or `XCB_NONE` to not change the*
1246	/// cursor.
1247	/// `modifiers` - The modifiers to grab.*
1248	///
1249	/// Using the special value `XCB_MOD_MASK_ANY` means grab the pointer with all
1250	/// possible modifier combinations.
1251	/// `pointer_mode` -*
1252	/// `keyboard_mode` -*
1253	/// `button` -*
1254	///
1255	/// # Errors
1256	///
1257	/// `Access` - Another client has already issued a GrabButton with the same button/key*
1258	/// combination on the same window.
1259	/// `Value` - TODO: reasons?*
1260	/// `Cursor` - The specified `cursor` does not exist.*
1261	/// `Window` - The specified `window` does not exist.*
1262	pub fn grab_button<Conn, A, B>(conn: &Conn, owner_events: bool, grab_window: Window, event_mask: EventMask, pointer_mode: GrabMode, keyboard_mode: GrabMode, confine_to: A, cursor: B, button: ButtonIndex, modifiers: ModMask) -> Result<VoidCookie<'_, Conn>, ConnectionError>
1263	where
1264	Conn: RequestConnection + ?Sized,
1265	A: Into<Window>,
1266	B: Into<Cursor>,
1267	{
1268	let confine_to: Window = confine_to.into();
1269	let cursor: Cursor = cursor.into();
1270	let request0: GrabButtonRequest = GrabButtonRequest {
1271	owner_events,
1272	grab_window,
1273	event_mask,
1274	pointer_mode,
1275	keyboard_mode,
1276	confine_to,
1277	cursor,
1278	button,
1279	modifiers,
1280	};
1281	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
1282	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
1283	assert_eq!(slices.len(), bytes.len());
1284	conn.send_request_without_reply(&slices, fds)
1285	}
1286
1287	pub fn ungrab_button<Conn>(conn: &Conn, button: ButtonIndex, grab_window: Window, modifiers: ModMask) -> Result<VoidCookie<'_, Conn>, ConnectionError>
1288	where
1289	Conn: RequestConnection + ?Sized,
1290	{
1291	let request0: UngrabButtonRequest = UngrabButtonRequest {
1292	button,
1293	grab_window,
1294	modifiers,
1295	};
1296	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
1297	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
1298	assert_eq!(slices.len(), bytes.len());
1299	conn.send_request_without_reply(&slices, fds)
1300	}
1301
1302	pub fn change_active_pointer_grab<Conn, A, B>(conn: &Conn, cursor: A, time: B, event_mask: EventMask) -> Result<VoidCookie<'_, Conn>, ConnectionError>
1303	where
1304	Conn: RequestConnection + ?Sized,
1305	A: Into<Cursor>,
1306	B: Into<Timestamp>,
1307	{
1308	let cursor: Cursor = cursor.into();
1309	let time: Timestamp = time.into();
1310	let request0: ChangeActivePointerGrabRequest = ChangeActivePointerGrabRequest {
1311	cursor,
1312	time,
1313	event_mask,
1314	};
1315	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
1316	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
1317	assert_eq!(slices.len(), bytes.len());
1318	conn.send_request_without_reply(&slices, fds)
1319	}
1320
1321	/// Grab the keyboard.
1322	///
1323	/// Actively grabs control of the keyboard and generates FocusIn and FocusOut
1324	/// events. Further key events are reported only to the grabbing client.
1325	///
1326	/// Any active keyboard grab by this client is overridden. If the keyboard is
1327	/// actively grabbed by some other client, `AlreadyGrabbed` is returned. If
1328	/// `grab_window` is not viewable, `GrabNotViewable` is returned. If the keyboard
1329	/// is frozen by an active grab of another client, `GrabFrozen` is returned. If the
1330	/// specified `time` is earlier than the last-keyboard-grab time or later than the
1331	/// current X server time, `GrabInvalidTime` is returned. Otherwise, the
1332	/// last-keyboard-grab time is set to the specified time.
1333	///
1334	/// # Fields
1335	///
1336	/// `owner_events` - If 1, the `grab_window` will still get the pointer events. If 0, events are not*
1337	/// reported to the `grab_window`.
1338	/// `grab_window` - Specifies the window on which the pointer should be grabbed.*
1339	/// `time` - Timestamp to avoid race conditions when running X over the network.*
1340	///
1341	/// The special value `XCB_CURRENT_TIME` will be replaced with the current server
1342	/// time.
1343	/// `pointer_mode` -*
1344	/// `keyboard_mode` -*
1345	///
1346	/// # Errors
1347	///
1348	/// `Value` - TODO: reasons?*
1349	/// `Window` - The specified `window` does not exist.*
1350	///
1351	/// # See
1352	///
1353	/// `GrabPointer`: request*
1354	///
1355	/// # Example
1356	///
1357	/// ```text
1358	/// /*
1359	/// Grabs the keyboard actively*
1360	/// *
1361	/// /*
1362	/// void my_example(xcb_connection_t conn, xcb_screen_t screen) {
1363	/// xcb_grab_keyboard_cookie_t cookie;
1364	/// xcb_grab_keyboard_reply_t reply;*
1365	///
1366	/// cookie = xcb_grab_keyboard(
1367	/// conn,
1368	/// true, / report events /
1369	/// screen->root, / grab the root window /
1370	/// XCB_CURRENT_TIME,
1371	/// XCB_GRAB_MODE_ASYNC, / process events as normal, do not require sync /
1372	/// XCB_GRAB_MODE_ASYNC
1373	/// );
1374	///
1375	/// if ((reply = xcb_grab_keyboard_reply(conn, cookie, NULL))) {
1376	/// if (reply->status == XCB_GRAB_STATUS_SUCCESS)
1377	/// printf("successfully grabbed the keyboard\\n");
1378	///
1379	/// free(reply);
1380	/// }
1381	/// }
1382	/// ```
1383	pub fn grab_keyboard<Conn, A>(conn: &Conn, owner_events: bool, grab_window: Window, time: A, pointer_mode: GrabMode, keyboard_mode: GrabMode) -> Result<Cookie<'_, Conn, GrabKeyboardReply>, ConnectionError>
1384	where
1385	Conn: RequestConnection + ?Sized,
1386	A: Into<Timestamp>,
1387	{
1388	let time: Timestamp = time.into();
1389	let request0: GrabKeyboardRequest = GrabKeyboardRequest {
1390	owner_events,
1391	grab_window,
1392	time,
1393	pointer_mode,
1394	keyboard_mode,
1395	};
1396	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
1397	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
1398	assert_eq!(slices.len(), bytes.len());
1399	conn.send_request_with_reply(&slices, fds)
1400	}
1401
1402	pub fn ungrab_keyboard<Conn, A>(conn: &Conn, time: A) -> Result<VoidCookie<'_, Conn>, ConnectionError>
1403	where
1404	Conn: RequestConnection + ?Sized,
1405	A: Into<Timestamp>,
1406	{
1407	let time: Timestamp = time.into();
1408	let request0: UngrabKeyboardRequest = UngrabKeyboardRequest {
1409	time,
1410	};
1411	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
1412	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
1413	assert_eq!(slices.len(), bytes.len());
1414	conn.send_request_without_reply(&slices, fds)
1415	}
1416
1417	/// Grab keyboard key(s).
1418	///
1419	/// Establishes a passive grab on the keyboard. In the future, the keyboard is
1420	/// actively grabbed (as for `GrabKeyboard`), the last-keyboard-grab time is set to
1421	/// the time at which the key was pressed (as transmitted in the KeyPress event),
1422	/// and the KeyPress event is reported if all of the following conditions are true:
1423	///
1424	/// The keyboard is not grabbed and the specified key (which can itself be a
1425	/// modifier key) is logically pressed when the specified modifier keys are
1426	/// logically down, and no other modifier keys are logically down.
1427	///
1428	/// Either the grab_window is an ancestor of (or is) the focus window, or the
1429	/// grab_window is a descendant of the focus window and contains the pointer.
1430	///
1431	/// A passive grab on the same key combination does not exist on any ancestor of
1432	/// grab_window.
1433	///
1434	/// The interpretation of the remaining arguments is as for XGrabKeyboard. The active grab is terminated
1435	/// automatically when the logical state of the keyboard has the specified key released (independent of the
1436	/// logical state of the modifier keys), at which point a KeyRelease event is reported to the grabbing window.
1437	///
1438	/// Note that the logical state of a device (as seen by client applications) may lag the physical state if
1439	/// device event processing is frozen.
1440	///
1441	/// A modifiers argument of AnyModifier is equivalent to issuing the request for all possible modifier combinations (including the combination of no modifiers). It is not required that all modifiers specified
1442	/// have currently assigned KeyCodes. A keycode argument of AnyKey is equivalent to issuing the request for
1443	/// all possible KeyCodes. Otherwise, the specified keycode must be in the range specified by min_keycode
1444	/// and max_keycode in the connection setup, or a BadValue error results.
1445	///
1446	/// If some other client has issued a XGrabKey with the same key combination on the same window, a BadAccess
1447	/// error results. When using AnyModifier or AnyKey, the request fails completely, and a BadAccess error
1448	/// results (no grabs are established) if there is a conflicting grab for any combination.
1449	///
1450	/// # Fields
1451	///
1452	/// `owner_events` - If 1, the `grab_window` will still get the key events. If 0, events are not*
1453	/// reported to the `grab_window`.
1454	/// `grab_window` - Specifies the window on which the key should be grabbed.*
1455	/// `key` - The keycode of the key to grab.*
1456	///
1457	/// The special value `XCB_GRAB_ANY` means grab any key.
1458	/// `modifiers` - The modifiers to grab.*
1459	///
1460	/// Using the special value `XCB_MOD_MASK_ANY` means grab the key with all
1461	/// possible modifier combinations.
1462	/// `pointer_mode` -*
1463	/// `keyboard_mode` -*
1464	///
1465	/// # Errors
1466	///
1467	/// `Access` - Another client has already issued a GrabKey with the same button/key*
1468	/// combination on the same window.
1469	/// `Value` - The key is not `XCB_GRAB_ANY` and not in the range specified by `min_keycode`*
1470	/// and `max_keycode` in the connection setup.
1471	/// `Window` - The specified `window` does not exist.*
1472	///
1473	/// # See
1474	///
1475	/// `GrabKeyboard`: request*
1476	pub fn grab_key<Conn, A>(conn: &Conn, owner_events: bool, grab_window: Window, modifiers: ModMask, key: A, pointer_mode: GrabMode, keyboard_mode: GrabMode) -> Result<VoidCookie<'_, Conn>, ConnectionError>
1477	where
1478	Conn: RequestConnection + ?Sized,
1479	A: Into<Keycode>,
1480	{
1481	let key: Keycode = key.into();
1482	let request0: GrabKeyRequest = GrabKeyRequest {
1483	owner_events,
1484	grab_window,
1485	modifiers,
1486	key,
1487	pointer_mode,
1488	keyboard_mode,
1489	};
1490	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
1491	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
1492	assert_eq!(slices.len(), bytes.len());
1493	conn.send_request_without_reply(&slices, fds)
1494	}
1495
1496	/// release a key combination.
1497	///
1498	/// Releases the key combination on `grab_window` if you grabbed it using
1499	/// `xcb_grab_key` before.
1500	///
1501	/// # Fields
1502	///
1503	/// `key` - The keycode of the specified key combination.*
1504	///
1505	/// Using the special value `XCB_GRAB_ANY` means releasing all possible key codes.
1506	/// `grab_window` - The window on which the grabbed key combination will be released.*
1507	/// `modifiers` - The modifiers of the specified key combination.*
1508	///
1509	/// Using the special value `XCB_MOD_MASK_ANY` means releasing the key combination
1510	/// with every possible modifier combination.
1511	///
1512	/// # Errors
1513	///
1514	/// `Window` - The specified `grab_window` does not exist.*
1515	/// `Value` - TODO: reasons?*
1516	///
1517	/// # See
1518	///
1519	/// `GrabKey`: request*
1520	/// `xev`: program*
1521	pub fn ungrab_key<Conn, A>(conn: &Conn, key: A, grab_window: Window, modifiers: ModMask) -> Result<VoidCookie<'_, Conn>, ConnectionError>
1522	where
1523	Conn: RequestConnection + ?Sized,
1524	A: Into<Keycode>,
1525	{
1526	let key: Keycode = key.into();
1527	let request0: UngrabKeyRequest = UngrabKeyRequest {
1528	key,
1529	grab_window,
1530	modifiers,
1531	};
1532	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
1533	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
1534	assert_eq!(slices.len(), bytes.len());
1535	conn.send_request_without_reply(&slices, fds)
1536	}
1537
1538	/// release queued events.
1539	///
1540	/// Releases queued events if the client has caused a device (pointer/keyboard) to
1541	/// freeze due to grabbing it actively. This request has no effect if `time` is
1542	/// earlier than the last-grab time of the most recent active grab for this client
1543	/// or if `time` is later than the current X server time.
1544	///
1545	/// # Fields
1546	///
1547	/// `mode` -*
1548	/// `time` - Timestamp to avoid race conditions when running X over the network.*
1549	///
1550	/// The special value `XCB_CURRENT_TIME` will be replaced with the current server
1551	/// time.
1552	///
1553	/// # Errors
1554	///
1555	/// `Value` - You specified an invalid `mode`.*
1556	pub fn allow_events<Conn, A>(conn: &Conn, mode: Allow, time: A) -> Result<VoidCookie<'_, Conn>, ConnectionError>
1557	where
1558	Conn: RequestConnection + ?Sized,
1559	A: Into<Timestamp>,
1560	{
1561	let time: Timestamp = time.into();
1562	let request0: AllowEventsRequest = AllowEventsRequest {
1563	mode,
1564	time,
1565	};
1566	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
1567	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
1568	assert_eq!(slices.len(), bytes.len());
1569	conn.send_request_without_reply(&slices, fds)
1570	}
1571
1572	pub fn grab_server<Conn>(conn: &Conn) -> Result<VoidCookie<'_, Conn>, ConnectionError>
1573	where
1574	Conn: RequestConnection + ?Sized,
1575	{
1576	let request0: GrabServerRequest = GrabServerRequest;
1577	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
1578	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
1579	assert_eq!(slices.len(), bytes.len());
1580	conn.send_request_without_reply(&slices, fds)
1581	}
1582
1583	pub fn ungrab_server<Conn>(conn: &Conn) -> Result<VoidCookie<'_, Conn>, ConnectionError>
1584	where
1585	Conn: RequestConnection + ?Sized,
1586	{
1587	let request0: UngrabServerRequest = UngrabServerRequest;
1588	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
1589	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
1590	assert_eq!(slices.len(), bytes.len());
1591	conn.send_request_without_reply(&slices, fds)
1592	}
1593
1594	/// get pointer coordinates.
1595	///
1596	/// Gets the root window the pointer is logically on and the pointer coordinates
1597	/// relative to the root window's origin.
1598	///
1599	/// # Fields
1600	///
1601	/// `window` - A window to check if the pointer is on the same screen as `window` (see the*
1602	/// `same_screen` field in the reply).
1603	///
1604	/// # Errors
1605	///
1606	/// `Window` - The specified `window` does not exist.*
1607	pub fn query_pointer<Conn>(conn: &Conn, window: Window) -> Result<Cookie<'_, Conn, QueryPointerReply>, ConnectionError>
1608	where
1609	Conn: RequestConnection + ?Sized,
1610	{
1611	let request0: QueryPointerRequest = QueryPointerRequest {
1612	window,
1613	};
1614	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
1615	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
1616	assert_eq!(slices.len(), bytes.len());
1617	conn.send_request_with_reply(&slices, fds)
1618	}
1619
1620	pub fn get_motion_events<Conn, A, B>(conn: &Conn, window: Window, start: A, stop: B) -> Result<Cookie<'_, Conn, GetMotionEventsReply>, ConnectionError>
1621	where
1622	Conn: RequestConnection + ?Sized,
1623	A: Into<Timestamp>,
1624	B: Into<Timestamp>,
1625	{
1626	let start: Timestamp = start.into();
1627	let stop: Timestamp = stop.into();
1628	let request0: GetMotionEventsRequest = GetMotionEventsRequest {
1629	window,
1630	start,
1631	stop,
1632	};
1633	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
1634	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
1635	assert_eq!(slices.len(), bytes.len());
1636	conn.send_request_with_reply(&slices, fds)
1637	}
1638
1639	pub fn translate_coordinates<Conn>(conn: &Conn, src_window: Window, dst_window: Window, src_x: i16, src_y: i16) -> Result<Cookie<'_, Conn, TranslateCoordinatesReply>, ConnectionError>
1640	where
1641	Conn: RequestConnection + ?Sized,
1642	{
1643	let request0: TranslateCoordinatesRequest = TranslateCoordinatesRequest {
1644	src_window,
1645	dst_window,
1646	src_x,
1647	src_y,
1648	};
1649	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
1650	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
1651	assert_eq!(slices.len(), bytes.len());
1652	conn.send_request_with_reply(&slices, fds)
1653	}
1654
1655	/// move mouse pointer.
1656	///
1657	/// Moves the mouse pointer to the specified position.
1658	///
1659	/// If `src_window` is not `XCB_NONE` (TODO), the move will only take place if the
1660	/// pointer is inside `src_window` and within the rectangle specified by (`src_x`,
1661	/// `src_y`, `src_width`, `src_height`). The rectangle coordinates are relative to
1662	/// `src_window`.
1663	///
1664	/// If `dst_window` is not `XCB_NONE` (TODO), the pointer will be moved to the
1665	/// offsets (`dst_x`, `dst_y`) relative to `dst_window`. If `dst_window` is
1666	/// `XCB_NONE` (TODO), the pointer will be moved by the offsets (`dst_x`, `dst_y`)
1667	/// relative to the current position of the pointer.
1668	///
1669	/// # Fields
1670	///
1671	/// `src_window` - If `src_window` is not `XCB_NONE` (TODO), the move will only take place if the*
1672	/// pointer is inside `src_window` and within the rectangle specified by (`src_x`,
1673	/// `src_y`, `src_width`, `src_height`). The rectangle coordinates are relative to
1674	/// `src_window`.
1675	/// `dst_window` - If `dst_window` is not `XCB_NONE` (TODO), the pointer will be moved to the*
1676	/// offsets (`dst_x`, `dst_y`) relative to `dst_window`. If `dst_window` is
1677	/// `XCB_NONE` (TODO), the pointer will be moved by the offsets (`dst_x`, `dst_y`)
1678	/// relative to the current position of the pointer.
1679	///
1680	/// # Errors
1681	///
1682	/// `Window` - TODO: reasons?*
1683	///
1684	/// # See
1685	///
1686	/// `SetInputFocus`: request*
1687	pub fn warp_pointer<Conn, A, B>(conn: &Conn, src_window: A, dst_window: B, src_x: i16, src_y: i16, src_width: u16, src_height: u16, dst_x: i16, dst_y: i16) -> Result<VoidCookie<'_, Conn>, ConnectionError>
1688	where
1689	Conn: RequestConnection + ?Sized,
1690	A: Into<Window>,
1691	B: Into<Window>,
1692	{
1693	let src_window: Window = src_window.into();
1694	let dst_window: Window = dst_window.into();
1695	let request0: WarpPointerRequest = WarpPointerRequest {
1696	src_window,
1697	dst_window,
1698	src_x,
1699	src_y,
1700	src_width,
1701	src_height,
1702	dst_x,
1703	dst_y,
1704	};
1705	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
1706	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
1707	assert_eq!(slices.len(), bytes.len());
1708	conn.send_request_without_reply(&slices, fds)
1709	}
1710
1711	/// Sets input focus.
1712	///
1713	/// Changes the input focus and the last-focus-change time. If the specified `time`
1714	/// is earlier than the current last-focus-change time, the request is ignored (to
1715	/// avoid race conditions when running X over the network).
1716	///
1717	/// A FocusIn and FocusOut event is generated when focus is changed.
1718	///
1719	/// # Fields
1720	///
1721	/// `focus` - The window to focus. All keyboard events will be reported to this window. The*
1722	/// window must be viewable (TODO), or a `xcb_match_error_t` occurs (TODO).
1723	///
1724	/// If `focus` is `XCB_NONE` (TODO), all keyboard events are
1725	/// discarded until a new focus window is set.
1726	///
1727	/// If `focus` is `XCB_POINTER_ROOT` (TODO), focus is on the root window of the
1728	/// screen on which the pointer is on currently.
1729	/// `time` - Timestamp to avoid race conditions when running X over the network.*
1730	///
1731	/// The special value `XCB_CURRENT_TIME` will be replaced with the current server
1732	/// time.
1733	/// `revert_to` - Specifies what happens when the `focus` window becomes unviewable (if `focus`*
1734	/// is neither `XCB_NONE` nor `XCB_POINTER_ROOT`).
1735	///
1736	/// # Errors
1737	///
1738	/// `Window` - The specified `focus` window does not exist.*
1739	/// `Match` - The specified `focus` window is not viewable.*
1740	/// `Value` - TODO: Reasons?*
1741	///
1742	/// # See
1743	///
1744	/// `FocusIn`: event*
1745	/// `FocusOut`: event*
1746	pub fn set_input_focus<Conn, A, B>(conn: &Conn, revert_to: InputFocus, focus: A, time: B) -> Result<VoidCookie<'_, Conn>, ConnectionError>
1747	where
1748	Conn: RequestConnection + ?Sized,
1749	A: Into<Window>,
1750	B: Into<Timestamp>,
1751	{
1752	let focus: Window = focus.into();
1753	let time: Timestamp = time.into();
1754	let request0: SetInputFocusRequest = SetInputFocusRequest {
1755	revert_to,
1756	focus,
1757	time,
1758	};
1759	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
1760	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
1761	assert_eq!(slices.len(), bytes.len());
1762	conn.send_request_without_reply(&slices, fds)
1763	}
1764
1765	pub fn get_input_focus<Conn>(conn: &Conn) -> Result<Cookie<'_, Conn, GetInputFocusReply>, ConnectionError>
1766	where
1767	Conn: RequestConnection + ?Sized,
1768	{
1769	let request0: GetInputFocusRequest = GetInputFocusRequest;
1770	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
1771	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
1772	assert_eq!(slices.len(), bytes.len());
1773	conn.send_request_with_reply(&slices, fds)
1774	}
1775
1776	pub fn query_keymap<Conn>(conn: &Conn) -> Result<Cookie<'_, Conn, QueryKeymapReply>, ConnectionError>
1777	where
1778	Conn: RequestConnection + ?Sized,
1779	{
1780	let request0: QueryKeymapRequest = QueryKeymapRequest;
1781	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
1782	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
1783	assert_eq!(slices.len(), bytes.len());
1784	conn.send_request_with_reply(&slices, fds)
1785	}
1786
1787	/// opens a font.
1788	///
1789	/// Opens any X core font matching the given `name` (for example "-misc-fixed-").*
1790	///
1791	/// Note that X core fonts are deprecated (but still supported) in favor of
1792	/// client-side rendering using Xft.
1793	///
1794	/// # Fields
1795	///
1796	/// `fid` - The ID with which you will refer to the font, created by `xcb_generate_id`.*
1797	/// `name_len` - Length (in bytes) of `name`.*
1798	/// `name` - A pattern describing an X core font.*
1799	///
1800	/// # Errors
1801	///
1802	/// `Name` - No font matches the given `name`.*
1803	///
1804	/// # See
1805	///
1806	/// `xcb_generate_id`: function*
1807	pub fn open_font<'c, 'input, Conn>(conn: &'c Conn, fid: Font, name: &'input [u8]) -> Result<VoidCookie<'c, Conn>, ConnectionError>
1808	where
1809	Conn: RequestConnection + ?Sized,
1810	{
1811	let request0: OpenFontRequest<'_> = OpenFontRequest {
1812	fid,
1813	name: Cow::Borrowed(name),
1814	};
1815	let (bytes: [Cow<'_, [u8]>; 3], fds: Vec) = request0.serialize();
1816	let slices: [IoSlice<'_>; 3] = [IoSlice::new(&bytes[`0`]), IoSlice::new(&bytes[`1`]), IoSlice::new(&bytes[`2`])];
1817	assert_eq!(slices.len(), bytes.len());
1818	conn.send_request_without_reply(&slices, fds)
1819	}
1820
1821	pub fn close_font<Conn>(conn: &Conn, font: Font) -> Result<VoidCookie<'_, Conn>, ConnectionError>
1822	where
1823	Conn: RequestConnection + ?Sized,
1824	{
1825	let request0: CloseFontRequest = CloseFontRequest {
1826	font,
1827	};
1828	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
1829	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
1830	assert_eq!(slices.len(), bytes.len());
1831	conn.send_request_without_reply(&slices, fds)
1832	}
1833
1834	/// query font metrics.
1835	///
1836	/// Queries information associated with the font.
1837	///
1838	/// # Fields
1839	///
1840	/// `font` - The fontable (Font or Graphics Context) to query.*
1841	pub fn query_font<Conn>(conn: &Conn, font: Fontable) -> Result<Cookie<'_, Conn, QueryFontReply>, ConnectionError>
1842	where
1843	Conn: RequestConnection + ?Sized,
1844	{
1845	let request0: QueryFontRequest = QueryFontRequest {
1846	font,
1847	};
1848	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
1849	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
1850	assert_eq!(slices.len(), bytes.len());
1851	conn.send_request_with_reply(&slices, fds)
1852	}
1853
1854	/// get text extents.
1855	///
1856	/// Query text extents from the X11 server. This request returns the bounding box
1857	/// of the specified 16-bit character string in the specified `font` or the font
1858	/// contained in the specified graphics context.
1859	///
1860	/// `font_ascent` is set to the maximum of the ascent metrics of all characters in
1861	/// the string. `font_descent` is set to the maximum of the descent metrics.
1862	/// `overall_width` is set to the sum of the character-width metrics of all
1863	/// characters in the string. For each character in the string, let W be the sum of
1864	/// the character-width metrics of all characters preceding it in the string. Let L
1865	/// be the left-side-bearing metric of the character plus W. Let R be the
1866	/// right-side-bearing metric of the character plus W. The lbearing member is set
1867	/// to the minimum L of all characters in the string. The rbearing member is set to
1868	/// the maximum R.
1869	///
1870	/// For fonts defined with linear indexing rather than 2-byte matrix indexing, each
1871	/// `xcb_char2b_t` structure is interpreted as a 16-bit number with byte1 as the
1872	/// most significant byte. If the font has no defined default character, undefined
1873	/// characters in the string are taken to have all zero metrics.
1874	///
1875	/// Characters with all zero metrics are ignored. If the font has no defined
1876	/// default_char, the undefined characters in the string are also ignored.
1877	///
1878	/// # Fields
1879	///
1880	/// `font` - The `font` to calculate text extents in. You can also pass a graphics context.*
1881	/// `string_len` - The number of characters in `string`.*
1882	/// `string` - The text to get text extents for.*
1883	///
1884	/// # Errors
1885	///
1886	/// `GContext` - The specified graphics context does not exist.*
1887	/// `Font` - The specified `font` does not exist.*
1888	pub fn query_text_extents<'c, 'input, Conn>(conn: &'c Conn, font: Fontable, string: &'input [Char2b]) -> Result<Cookie<'c, Conn, QueryTextExtentsReply>, ConnectionError>
1889	where
1890	Conn: RequestConnection + ?Sized,
1891	{
1892	let request0: QueryTextExtentsRequest<'_> = QueryTextExtentsRequest {
1893	font,
1894	string: Cow::Borrowed(string),
1895	};
1896	let (bytes: [Cow<'_, [u8]>; 3], fds: Vec) = request0.serialize();
1897	let slices: [IoSlice<'_>; 3] = [IoSlice::new(&bytes[`0`]), IoSlice::new(&bytes[`1`]), IoSlice::new(&bytes[`2`])];
1898	assert_eq!(slices.len(), bytes.len());
1899	conn.send_request_with_reply(&slices, fds)
1900	}
1901
1902	/// get matching font names.
1903	///
1904	/// Gets a list of available font names which match the given `pattern`.
1905	///
1906	/// # Fields
1907	///
1908	/// `pattern_len` - The length (in bytes) of `pattern`.*
1909	/// `pattern` - A font pattern, for example "-misc-fixed-".
1910	///
1911	/// The asterisk () is a wildcard for any number of characters. The question mark*
1912	/// (?) is a wildcard for a single character. Use of uppercase or lowercase does
1913	/// not matter.
1914	/// `max_names` - The maximum number of fonts to be returned.*
1915	pub fn list_fonts<'c, 'input, Conn>(conn: &'c Conn, max_names: u16, pattern: &'input [u8]) -> Result<Cookie<'c, Conn, ListFontsReply>, ConnectionError>
1916	where
1917	Conn: RequestConnection + ?Sized,
1918	{
1919	let request0: ListFontsRequest<'_> = ListFontsRequest {
1920	max_names,
1921	pattern: Cow::Borrowed(pattern),
1922	};
1923	let (bytes: [Cow<'_, [u8]>; 3], fds: Vec) = request0.serialize();
1924	let slices: [IoSlice<'_>; 3] = [IoSlice::new(&bytes[`0`]), IoSlice::new(&bytes[`1`]), IoSlice::new(&bytes[`2`])];
1925	assert_eq!(slices.len(), bytes.len());
1926	conn.send_request_with_reply(&slices, fds)
1927	}
1928
1929	/// get matching font names and information.
1930	///
1931	/// Gets a list of available font names which match the given `pattern`.
1932	///
1933	/// # Fields
1934	///
1935	/// `pattern_len` - The length (in bytes) of `pattern`.*
1936	/// `pattern` - A font pattern, for example "-misc-fixed-".
1937	///
1938	/// The asterisk () is a wildcard for any number of characters. The question mark*
1939	/// (?) is a wildcard for a single character. Use of uppercase or lowercase does
1940	/// not matter.
1941	/// `max_names` - The maximum number of fonts to be returned.*
1942	pub fn list_fonts_with_info<'c, 'input, Conn>(conn: &'c Conn, max_names: u16, pattern: &'input [u8]) -> Result<ListFontsWithInfoCookie<'c, Conn>, ConnectionError>
1943	where
1944	Conn: RequestConnection + ?Sized,
1945	{
1946	let request0: ListFontsWithInfoRequest<'_> = ListFontsWithInfoRequest {
1947	max_names,
1948	pattern: Cow::Borrowed(pattern),
1949	};
1950	let (bytes: [Cow<'_, [u8]>; 3], fds: Vec) = request0.serialize();
1951	let slices: [IoSlice<'_>; 3] = [IoSlice::new(&bytes[`0`]), IoSlice::new(&bytes[`1`]), IoSlice::new(&bytes[`2`])];
1952	assert_eq!(slices.len(), bytes.len());
1953	Ok(ListFontsWithInfoCookie::new(cookie:conn.send_request_with_reply(&slices, fds)?))
1954	}
1955
1956	pub fn set_font_path<'c, 'input, Conn>(conn: &'c Conn, font: &'input [Str]) -> Result<VoidCookie<'c, Conn>, ConnectionError>
1957	where
1958	Conn: RequestConnection + ?Sized,
1959	{
1960	let request0: SetFontPathRequest<'_> = SetFontPathRequest {
1961	font: Cow::Borrowed(font),
1962	};
1963	let (bytes: [Cow<'_, [u8]>; 3], fds: Vec) = request0.serialize();
1964	let slices: [IoSlice<'_>; 3] = [IoSlice::new(&bytes[`0`]), IoSlice::new(&bytes[`1`]), IoSlice::new(&bytes[`2`])];
1965	assert_eq!(slices.len(), bytes.len());
1966	conn.send_request_without_reply(&slices, fds)
1967	}
1968
1969	pub fn get_font_path<Conn>(conn: &Conn) -> Result<Cookie<'_, Conn, GetFontPathReply>, ConnectionError>
1970	where
1971	Conn: RequestConnection + ?Sized,
1972	{
1973	let request0: GetFontPathRequest = GetFontPathRequest;
1974	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
1975	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
1976	assert_eq!(slices.len(), bytes.len());
1977	conn.send_request_with_reply(&slices, fds)
1978	}
1979
1980	/// Creates a pixmap.
1981	///
1982	/// Creates a pixmap. The pixmap can only be used on the same screen as `drawable`
1983	/// is on and only with drawables of the same `depth`.
1984	///
1985	/// # Fields
1986	///
1987	/// `depth` - TODO*
1988	/// `pid` - The ID with which you will refer to the new pixmap, created by*
1989	/// `xcb_generate_id`.
1990	/// `drawable` - Drawable to get the screen from.*
1991	/// `width` - The width of the new pixmap.*
1992	/// `height` - The height of the new pixmap.*
1993	///
1994	/// # Errors
1995	///
1996	/// `Value` - TODO: reasons?*
1997	/// `Drawable` - The specified `drawable` (Window or Pixmap) does not exist.*
1998	/// `Alloc` - The X server could not allocate the requested resources (no memory?).*
1999	///
2000	/// # See
2001	///
2002	/// `xcb_generate_id`: function*
2003	pub fn create_pixmap<Conn>(conn: &Conn, depth: u8, pid: Pixmap, drawable: Drawable, width: u16, height: u16) -> Result<VoidCookie<'_, Conn>, ConnectionError>
2004	where
2005	Conn: RequestConnection + ?Sized,
2006	{
2007	let request0: CreatePixmapRequest = CreatePixmapRequest {
2008	depth,
2009	pid,
2010	drawable,
2011	width,
2012	height,
2013	};
2014	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
2015	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
2016	assert_eq!(slices.len(), bytes.len());
2017	conn.send_request_without_reply(&slices, fds)
2018	}
2019
2020	/// Destroys a pixmap.
2021	///
2022	/// Deletes the association between the pixmap ID and the pixmap. The pixmap
2023	/// storage will be freed when there are no more references to it.
2024	///
2025	/// # Fields
2026	///
2027	/// `pixmap` - The pixmap to destroy.*
2028	///
2029	/// # Errors
2030	///
2031	/// `Pixmap` - The specified pixmap does not exist.*
2032	pub fn free_pixmap<Conn>(conn: &Conn, pixmap: Pixmap) -> Result<VoidCookie<'_, Conn>, ConnectionError>
2033	where
2034	Conn: RequestConnection + ?Sized,
2035	{
2036	let request0: FreePixmapRequest = FreePixmapRequest {
2037	pixmap,
2038	};
2039	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
2040	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
2041	assert_eq!(slices.len(), bytes.len());
2042	conn.send_request_without_reply(&slices, fds)
2043	}
2044
2045	/// Creates a graphics context.
2046	///
2047	/// Creates a graphics context. The graphics context can be used with any drawable
2048	/// that has the same root and depth as the specified drawable.
2049	///
2050	/// # Fields
2051	///
2052	/// `cid` - The ID with which you will refer to the graphics context, created by*
2053	/// `xcb_generate_id`.
2054	/// `drawable` - Drawable to get the root/depth from.*
2055	///
2056	/// # Errors
2057	///
2058	/// `Drawable` - The specified `drawable` (Window or Pixmap) does not exist.*
2059	/// `Match` - TODO: reasons?*
2060	/// `Font` - TODO: reasons?*
2061	/// `Pixmap` - TODO: reasons?*
2062	/// `Value` - TODO: reasons?*
2063	/// `Alloc` - The X server could not allocate the requested resources (no memory?).*
2064	///
2065	/// # See
2066	///
2067	/// `xcb_generate_id`: function*
2068	pub fn create_gc<'c, 'input, Conn>(conn: &'c Conn, cid: Gcontext, drawable: Drawable, value_list: &'input CreateGCAux) -> Result<VoidCookie<'c, Conn>, ConnectionError>
2069	where
2070	Conn: RequestConnection + ?Sized,
2071	{
2072	let request0: CreateGCRequest<'_> = CreateGCRequest {
2073	cid,
2074	drawable,
2075	value_list: Cow::Borrowed(value_list),
2076	};
2077	let (bytes: [Cow<'_, [u8]>; 3], fds: Vec) = request0.serialize();
2078	let slices: [IoSlice<'_>; 3] = [IoSlice::new(&bytes[`0`]), IoSlice::new(&bytes[`1`]), IoSlice::new(&bytes[`2`])];
2079	assert_eq!(slices.len(), bytes.len());
2080	conn.send_request_without_reply(&slices, fds)
2081	}
2082
2083	/// change graphics context components.
2084	///
2085	/// Changes the components specified by `value_mask` for the specified graphics context.
2086	///
2087	/// # Fields
2088	///
2089	/// `gc` - The graphics context to change.*
2090	/// `value_mask` -*
2091	/// `value_list` - Values for each of the components specified in the bitmask `value_mask`. The*
2092	/// order has to correspond to the order of possible `value_mask` bits. See the
2093	/// example.
2094	///
2095	/// # Errors
2096	///
2097	/// `Font` - TODO: reasons?*
2098	/// `GContext` - TODO: reasons?*
2099	/// `Match` - TODO: reasons?*
2100	/// `Pixmap` - TODO: reasons?*
2101	/// `Value` - TODO: reasons?*
2102	/// `Alloc` - The X server could not allocate the requested resources (no memory?).*
2103	///
2104	/// # Example
2105	///
2106	/// ```text
2107	/// /*
2108	/// Changes the foreground color component of the specified graphics context.*
2109	/// *
2110	/// /*
2111	/// void my_example(xcb_connection_t conn, xcb_gcontext_t gc, uint32_t fg, uint32_t bg) {*
2112	/// / C99 allows us to use a compact way of changing a single component: /
2113	/// xcb_change_gc(conn, gc, XCB_GC_FOREGROUND, (uint32_t[]){ fg });
2114	///
2115	/// / The more explicit way. Beware that the order of values is important! /
2116	/// uint32_t mask = 0;
2117	/// mask \|= XCB_GC_FOREGROUND;
2118	/// mask \|= XCB_GC_BACKGROUND;
2119	///
2120	/// uint32_t values[] = {
2121	/// fg,
2122	/// bg
2123	/// };
2124	/// xcb_change_gc(conn, gc, mask, values);
2125	/// xcb_flush(conn);
2126	/// }
2127	/// ```
2128	pub fn change_gc<'c, 'input, Conn>(conn: &'c Conn, gc: Gcontext, value_list: &'input ChangeGCAux) -> Result<VoidCookie<'c, Conn>, ConnectionError>
2129	where
2130	Conn: RequestConnection + ?Sized,
2131	{
2132	let request0: ChangeGCRequest<'_> = ChangeGCRequest {
2133	gc,
2134	value_list: Cow::Borrowed(value_list),
2135	};
2136	let (bytes: [Cow<'_, [u8]>; 3], fds: Vec) = request0.serialize();
2137	let slices: [IoSlice<'_>; 3] = [IoSlice::new(&bytes[`0`]), IoSlice::new(&bytes[`1`]), IoSlice::new(&bytes[`2`])];
2138	assert_eq!(slices.len(), bytes.len());
2139	conn.send_request_without_reply(&slices, fds)
2140	}
2141
2142	pub fn copy_gc<Conn>(conn: &Conn, src_gc: Gcontext, dst_gc: Gcontext, value_mask: GC) -> Result<VoidCookie<'_, Conn>, ConnectionError>
2143	where
2144	Conn: RequestConnection + ?Sized,
2145	{
2146	let request0: CopyGCRequest = CopyGCRequest {
2147	src_gc,
2148	dst_gc,
2149	value_mask,
2150	};
2151	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
2152	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
2153	assert_eq!(slices.len(), bytes.len());
2154	conn.send_request_without_reply(&slices, fds)
2155	}
2156
2157	pub fn set_dashes<'c, 'input, Conn>(conn: &'c Conn, gc: Gcontext, dash_offset: u16, dashes: &'input [u8]) -> Result<VoidCookie<'c, Conn>, ConnectionError>
2158	where
2159	Conn: RequestConnection + ?Sized,
2160	{
2161	let request0: SetDashesRequest<'_> = SetDashesRequest {
2162	gc,
2163	dash_offset,
2164	dashes: Cow::Borrowed(dashes),
2165	};
2166	let (bytes: [Cow<'_, [u8]>; 3], fds: Vec) = request0.serialize();
2167	let slices: [IoSlice<'_>; 3] = [IoSlice::new(&bytes[`0`]), IoSlice::new(&bytes[`1`]), IoSlice::new(&bytes[`2`])];
2168	assert_eq!(slices.len(), bytes.len());
2169	conn.send_request_without_reply(&slices, fds)
2170	}
2171
2172	pub fn set_clip_rectangles<'c, 'input, Conn>(conn: &'c Conn, ordering: ClipOrdering, gc: Gcontext, clip_x_origin: i16, clip_y_origin: i16, rectangles: &'input [Rectangle]) -> Result<VoidCookie<'c, Conn>, ConnectionError>
2173	where
2174	Conn: RequestConnection + ?Sized,
2175	{
2176	let request0: SetClipRectanglesRequest<'_> = SetClipRectanglesRequest {
2177	ordering,
2178	gc,
2179	clip_x_origin,
2180	clip_y_origin,
2181	rectangles: Cow::Borrowed(rectangles),
2182	};
2183	let (bytes: [Cow<'_, [u8]>; 3], fds: Vec) = request0.serialize();
2184	let slices: [IoSlice<'_>; 3] = [IoSlice::new(&bytes[`0`]), IoSlice::new(&bytes[`1`]), IoSlice::new(&bytes[`2`])];
2185	assert_eq!(slices.len(), bytes.len());
2186	conn.send_request_without_reply(&slices, fds)
2187	}
2188
2189	/// Destroys a graphics context.
2190	///
2191	/// Destroys the specified `gc` and all associated storage.
2192	///
2193	/// # Fields
2194	///
2195	/// `gc` - The graphics context to destroy.*
2196	///
2197	/// # Errors
2198	///
2199	/// `GContext` - The specified graphics context does not exist.*
2200	pub fn free_gc<Conn>(conn: &Conn, gc: Gcontext) -> Result<VoidCookie<'_, Conn>, ConnectionError>
2201	where
2202	Conn: RequestConnection + ?Sized,
2203	{
2204	let request0: FreeGCRequest = FreeGCRequest {
2205	gc,
2206	};
2207	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
2208	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
2209	assert_eq!(slices.len(), bytes.len());
2210	conn.send_request_without_reply(&slices, fds)
2211	}
2212
2213	pub fn clear_area<Conn>(conn: &Conn, exposures: bool, window: Window, x: i16, y: i16, width: u16, height: u16) -> Result<VoidCookie<'_, Conn>, ConnectionError>
2214	where
2215	Conn: RequestConnection + ?Sized,
2216	{
2217	let request0: ClearAreaRequest = ClearAreaRequest {
2218	exposures,
2219	window,
2220	x,
2221	y,
2222	width,
2223	height,
2224	};
2225	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
2226	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
2227	assert_eq!(slices.len(), bytes.len());
2228	conn.send_request_without_reply(&slices, fds)
2229	}
2230
2231	/// copy areas.
2232	///
2233	/// Copies the specified rectangle from `src_drawable` to `dst_drawable`.
2234	///
2235	/// # Fields
2236	///
2237	/// `dst_drawable` - The destination drawable (Window or Pixmap).*
2238	/// `src_drawable` - The source drawable (Window or Pixmap).*
2239	/// `gc` - The graphics context to use.*
2240	/// `src_x` - The source X coordinate.*
2241	/// `src_y` - The source Y coordinate.*
2242	/// `dst_x` - The destination X coordinate.*
2243	/// `dst_y` - The destination Y coordinate.*
2244	/// `width` - The width of the area to copy (in pixels).*
2245	/// `height` - The height of the area to copy (in pixels).*
2246	///
2247	/// # Errors
2248	///
2249	/// `Drawable` - The specified `drawable` (Window or Pixmap) does not exist.*
2250	/// `GContext` - The specified graphics context does not exist.*
2251	/// `Match` - `src_drawable` has a different root or depth than `dst_drawable`.*
2252	pub fn copy_area<Conn>(conn: &Conn, src_drawable: Drawable, dst_drawable: Drawable, gc: Gcontext, src_x: i16, src_y: i16, dst_x: i16, dst_y: i16, width: u16, height: u16) -> Result<VoidCookie<'_, Conn>, ConnectionError>
2253	where
2254	Conn: RequestConnection + ?Sized,
2255	{
2256	let request0: CopyAreaRequest = CopyAreaRequest {
2257	src_drawable,
2258	dst_drawable,
2259	gc,
2260	src_x,
2261	src_y,
2262	dst_x,
2263	dst_y,
2264	width,
2265	height,
2266	};
2267	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
2268	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
2269	assert_eq!(slices.len(), bytes.len());
2270	conn.send_request_without_reply(&slices, fds)
2271	}
2272
2273	pub fn copy_plane<Conn>(conn: &Conn, src_drawable: Drawable, dst_drawable: Drawable, gc: Gcontext, src_x: i16, src_y: i16, dst_x: i16, dst_y: i16, width: u16, height: u16, bit_plane: u32) -> Result<VoidCookie<'_, Conn>, ConnectionError>
2274	where
2275	Conn: RequestConnection + ?Sized,
2276	{
2277	let request0: CopyPlaneRequest = CopyPlaneRequest {
2278	src_drawable,
2279	dst_drawable,
2280	gc,
2281	src_x,
2282	src_y,
2283	dst_x,
2284	dst_y,
2285	width,
2286	height,
2287	bit_plane,
2288	};
2289	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
2290	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
2291	assert_eq!(slices.len(), bytes.len());
2292	conn.send_request_without_reply(&slices, fds)
2293	}
2294
2295	pub fn poly_point<'c, 'input, Conn>(conn: &'c Conn, coordinate_mode: CoordMode, drawable: Drawable, gc: Gcontext, points: &'input [Point]) -> Result<VoidCookie<'c, Conn>, ConnectionError>
2296	where
2297	Conn: RequestConnection + ?Sized,
2298	{
2299	let request0: PolyPointRequest<'_> = PolyPointRequest {
2300	coordinate_mode,
2301	drawable,
2302	gc,
2303	points: Cow::Borrowed(points),
2304	};
2305	let (bytes: [Cow<'_, [u8]>; 3], fds: Vec) = request0.serialize();
2306	let slices: [IoSlice<'_>; 3] = [IoSlice::new(&bytes[`0`]), IoSlice::new(&bytes[`1`]), IoSlice::new(&bytes[`2`])];
2307	assert_eq!(slices.len(), bytes.len());
2308	conn.send_request_without_reply(&slices, fds)
2309	}
2310
2311	/// draw lines.
2312	///
2313	/// Draws `points_len`-1 lines between each pair of points (point[i], point[i+1])
2314	/// in the `points` array. The lines are drawn in the order listed in the array.
2315	/// They join correctly at all intermediate points, and if the first and last
2316	/// points coincide, the first and last lines also join correctly. For any given
2317	/// line, a pixel is not drawn more than once. If thin (zero line-width) lines
2318	/// intersect, the intersecting pixels are drawn multiple times. If wide lines
2319	/// intersect, the intersecting pixels are drawn only once, as though the entire
2320	/// request were a single, filled shape.
2321	///
2322	/// # Fields
2323	///
2324	/// `drawable` - The drawable to draw the line(s) on.*
2325	/// `gc` - The graphics context to use.*
2326	/// `points_len` - The number of `xcb_point_t` structures in `points`.*
2327	/// `points` - An array of points.*
2328	/// `coordinate_mode` -*
2329	///
2330	/// # Errors
2331	///
2332	/// `Drawable` - TODO: reasons?*
2333	/// `GContext` - TODO: reasons?*
2334	/// `Match` - TODO: reasons?*
2335	/// `Value` - TODO: reasons?*
2336	///
2337	/// # Example
2338	///
2339	/// ```text
2340	/// /*
2341	/// Draw a straight line.*
2342	/// *
2343	/// /*
2344	/// void my_example(xcb_connection_t conn, xcb_drawable_t drawable, xcb_gcontext_t gc) {*
2345	/// xcb_poly_line(conn, XCB_COORD_MODE_ORIGIN, drawable, gc, 2,
2346	/// (xcb_point_t[]) { {10, 10}, {100, 10} });
2347	/// xcb_flush(conn);
2348	/// }
2349	/// ```
2350	pub fn poly_line<'c, 'input, Conn>(conn: &'c Conn, coordinate_mode: CoordMode, drawable: Drawable, gc: Gcontext, points: &'input [Point]) -> Result<VoidCookie<'c, Conn>, ConnectionError>
2351	where
2352	Conn: RequestConnection + ?Sized,
2353	{
2354	let request0: PolyLineRequest<'_> = PolyLineRequest {
2355	coordinate_mode,
2356	drawable,
2357	gc,
2358	points: Cow::Borrowed(points),
2359	};
2360	let (bytes: [Cow<'_, [u8]>; 3], fds: Vec) = request0.serialize();
2361	let slices: [IoSlice<'_>; 3] = [IoSlice::new(&bytes[`0`]), IoSlice::new(&bytes[`1`]), IoSlice::new(&bytes[`2`])];
2362	assert_eq!(slices.len(), bytes.len());
2363	conn.send_request_without_reply(&slices, fds)
2364	}
2365
2366	/// draw lines.
2367	///
2368	/// Draws multiple, unconnected lines. For each segment, a line is drawn between
2369	/// (x1, y1) and (x2, y2). The lines are drawn in the order listed in the array of
2370	/// `xcb_segment_t` structures and does not perform joining at coincident
2371	/// endpoints. For any given line, a pixel is not drawn more than once. If lines
2372	/// intersect, the intersecting pixels are drawn multiple times.
2373	///
2374	/// TODO: include the xcb_segment_t data structure
2375	///
2376	/// TODO: an example
2377	///
2378	/// # Fields
2379	///
2380	/// `drawable` - A drawable (Window or Pixmap) to draw on.*
2381	/// `gc` - The graphics context to use.*
2382	///
2383	/// TODO: document which attributes of a gc are used
2384	/// `segments_len` - The number of `xcb_segment_t` structures in `segments`.*
2385	/// `segments` - An array of `xcb_segment_t` structures.*
2386	///
2387	/// # Errors
2388	///
2389	/// `Drawable` - The specified `drawable` does not exist.*
2390	/// `GContext` - The specified `gc` does not exist.*
2391	/// `Match` - TODO: reasons?*
2392	pub fn poly_segment<'c, 'input, Conn>(conn: &'c Conn, drawable: Drawable, gc: Gcontext, segments: &'input [Segment]) -> Result<VoidCookie<'c, Conn>, ConnectionError>
2393	where
2394	Conn: RequestConnection + ?Sized,
2395	{
2396	let request0: PolySegmentRequest<'_> = PolySegmentRequest {
2397	drawable,
2398	gc,
2399	segments: Cow::Borrowed(segments),
2400	};
2401	let (bytes: [Cow<'_, [u8]>; 3], fds: Vec) = request0.serialize();
2402	let slices: [IoSlice<'_>; 3] = [IoSlice::new(&bytes[`0`]), IoSlice::new(&bytes[`1`]), IoSlice::new(&bytes[`2`])];
2403	assert_eq!(slices.len(), bytes.len());
2404	conn.send_request_without_reply(&slices, fds)
2405	}
2406
2407	pub fn poly_rectangle<'c, 'input, Conn>(conn: &'c Conn, drawable: Drawable, gc: Gcontext, rectangles: &'input [Rectangle]) -> Result<VoidCookie<'c, Conn>, ConnectionError>
2408	where
2409	Conn: RequestConnection + ?Sized,
2410	{
2411	let request0: PolyRectangleRequest<'_> = PolyRectangleRequest {
2412	drawable,
2413	gc,
2414	rectangles: Cow::Borrowed(rectangles),
2415	};
2416	let (bytes: [Cow<'_, [u8]>; 3], fds: Vec) = request0.serialize();
2417	let slices: [IoSlice<'_>; 3] = [IoSlice::new(&bytes[`0`]), IoSlice::new(&bytes[`1`]), IoSlice::new(&bytes[`2`])];
2418	assert_eq!(slices.len(), bytes.len());
2419	conn.send_request_without_reply(&slices, fds)
2420	}
2421
2422	pub fn poly_arc<'c, 'input, Conn>(conn: &'c Conn, drawable: Drawable, gc: Gcontext, arcs: &'input [Arc]) -> Result<VoidCookie<'c, Conn>, ConnectionError>
2423	where
2424	Conn: RequestConnection + ?Sized,
2425	{
2426	let request0: PolyArcRequest<'_> = PolyArcRequest {
2427	drawable,
2428	gc,
2429	arcs: Cow::Borrowed(arcs),
2430	};
2431	let (bytes: [Cow<'_, [u8]>; 3], fds: Vec) = request0.serialize();
2432	let slices: [IoSlice<'_>; 3] = [IoSlice::new(&bytes[`0`]), IoSlice::new(&bytes[`1`]), IoSlice::new(&bytes[`2`])];
2433	assert_eq!(slices.len(), bytes.len());
2434	conn.send_request_without_reply(&slices, fds)
2435	}
2436
2437	pub fn fill_poly<'c, 'input, Conn>(conn: &'c Conn, drawable: Drawable, gc: Gcontext, shape: PolyShape, coordinate_mode: CoordMode, points: &'input [Point]) -> Result<VoidCookie<'c, Conn>, ConnectionError>
2438	where
2439	Conn: RequestConnection + ?Sized,
2440	{
2441	let request0: FillPolyRequest<'_> = FillPolyRequest {
2442	drawable,
2443	gc,
2444	shape,
2445	coordinate_mode,
2446	points: Cow::Borrowed(points),
2447	};
2448	let (bytes: [Cow<'_, [u8]>; 3], fds: Vec) = request0.serialize();
2449	let slices: [IoSlice<'_>; 3] = [IoSlice::new(&bytes[`0`]), IoSlice::new(&bytes[`1`]), IoSlice::new(&bytes[`2`])];
2450	assert_eq!(slices.len(), bytes.len());
2451	conn.send_request_without_reply(&slices, fds)
2452	}
2453
2454	/// Fills rectangles.
2455	///
2456	/// Fills the specified rectangle(s) in the order listed in the array. For any
2457	/// given rectangle, each pixel is not drawn more than once. If rectangles
2458	/// intersect, the intersecting pixels are drawn multiple times.
2459	///
2460	/// # Fields
2461	///
2462	/// `drawable` - The drawable (Window or Pixmap) to draw on.*
2463	/// `gc` - The graphics context to use.*
2464	///
2465	/// The following graphics context components are used: function, plane-mask,
2466	/// fill-style, subwindow-mode, clip-x-origin, clip-y-origin, and clip-mask.
2467	///
2468	/// The following graphics context mode-dependent components are used:
2469	/// foreground, background, tile, stipple, tile-stipple-x-origin, and
2470	/// tile-stipple-y-origin.
2471	/// `rectangles_len` - The number of `xcb_rectangle_t` structures in `rectangles`.*
2472	/// `rectangles` - The rectangles to fill.*
2473	///
2474	/// # Errors
2475	///
2476	/// `Drawable` - The specified `drawable` (Window or Pixmap) does not exist.*
2477	/// `GContext` - The specified graphics context does not exist.*
2478	/// `Match` - TODO: reasons?*
2479	pub fn poly_fill_rectangle<'c, 'input, Conn>(conn: &'c Conn, drawable: Drawable, gc: Gcontext, rectangles: &'input [Rectangle]) -> Result<VoidCookie<'c, Conn>, ConnectionError>
2480	where
2481	Conn: RequestConnection + ?Sized,
2482	{
2483	let request0: PolyFillRectangleRequest<'_> = PolyFillRectangleRequest {
2484	drawable,
2485	gc,
2486	rectangles: Cow::Borrowed(rectangles),
2487	};
2488	let (bytes: [Cow<'_, [u8]>; 3], fds: Vec) = request0.serialize();
2489	let slices: [IoSlice<'_>; 3] = [IoSlice::new(&bytes[`0`]), IoSlice::new(&bytes[`1`]), IoSlice::new(&bytes[`2`])];
2490	assert_eq!(slices.len(), bytes.len());
2491	conn.send_request_without_reply(&slices, fds)
2492	}
2493
2494	pub fn poly_fill_arc<'c, 'input, Conn>(conn: &'c Conn, drawable: Drawable, gc: Gcontext, arcs: &'input [Arc]) -> Result<VoidCookie<'c, Conn>, ConnectionError>
2495	where
2496	Conn: RequestConnection + ?Sized,
2497	{
2498	let request0: PolyFillArcRequest<'_> = PolyFillArcRequest {
2499	drawable,
2500	gc,
2501	arcs: Cow::Borrowed(arcs),
2502	};
2503	let (bytes: [Cow<'_, [u8]>; 3], fds: Vec) = request0.serialize();
2504	let slices: [IoSlice<'_>; 3] = [IoSlice::new(&bytes[`0`]), IoSlice::new(&bytes[`1`]), IoSlice::new(&bytes[`2`])];
2505	assert_eq!(slices.len(), bytes.len());
2506	conn.send_request_without_reply(&slices, fds)
2507	}
2508
2509	pub fn put_image<'c, 'input, Conn>(conn: &'c Conn, format: ImageFormat, drawable: Drawable, gc: Gcontext, width: u16, height: u16, dst_x: i16, dst_y: i16, left_pad: u8, depth: u8, data: &'input [u8]) -> Result<VoidCookie<'c, Conn>, ConnectionError>
2510	where
2511	Conn: RequestConnection + ?Sized,
2512	{
2513	let request0: PutImageRequest<'_> = PutImageRequest {
2514	format,
2515	drawable,
2516	gc,
2517	width,
2518	height,
2519	dst_x,
2520	dst_y,
2521	left_pad,
2522	depth,
2523	data: Cow::Borrowed(data),
2524	};
2525	let (bytes: [Cow<'_, [u8]>; 3], fds: Vec) = request0.serialize();
2526	let slices: [IoSlice<'_>; 3] = [IoSlice::new(&bytes[`0`]), IoSlice::new(&bytes[`1`]), IoSlice::new(&bytes[`2`])];
2527	assert_eq!(slices.len(), bytes.len());
2528	conn.send_request_without_reply(&slices, fds)
2529	}
2530
2531	pub fn get_image<Conn>(conn: &Conn, format: ImageFormat, drawable: Drawable, x: i16, y: i16, width: u16, height: u16, plane_mask: u32) -> Result<Cookie<'_, Conn, GetImageReply>, ConnectionError>
2532	where
2533	Conn: RequestConnection + ?Sized,
2534	{
2535	let request0: GetImageRequest = GetImageRequest {
2536	format,
2537	drawable,
2538	x,
2539	y,
2540	width,
2541	height,
2542	plane_mask,
2543	};
2544	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
2545	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
2546	assert_eq!(slices.len(), bytes.len());
2547	conn.send_request_with_reply(&slices, fds)
2548	}
2549
2550	pub fn poly_text8<'c, 'input, Conn>(conn: &'c Conn, drawable: Drawable, gc: Gcontext, x: i16, y: i16, items: &'input [u8]) -> Result<VoidCookie<'c, Conn>, ConnectionError>
2551	where
2552	Conn: RequestConnection + ?Sized,
2553	{
2554	let request0: PolyText8Request<'_> = PolyText8Request {
2555	drawable,
2556	gc,
2557	x,
2558	y,
2559	items: Cow::Borrowed(items),
2560	};
2561	let (bytes: [Cow<'_, [u8]>; 3], fds: Vec) = request0.serialize();
2562	let slices: [IoSlice<'_>; 3] = [IoSlice::new(&bytes[`0`]), IoSlice::new(&bytes[`1`]), IoSlice::new(&bytes[`2`])];
2563	assert_eq!(slices.len(), bytes.len());
2564	conn.send_request_without_reply(&slices, fds)
2565	}
2566
2567	pub fn poly_text16<'c, 'input, Conn>(conn: &'c Conn, drawable: Drawable, gc: Gcontext, x: i16, y: i16, items: &'input [u8]) -> Result<VoidCookie<'c, Conn>, ConnectionError>
2568	where
2569	Conn: RequestConnection + ?Sized,
2570	{
2571	let request0: PolyText16Request<'_> = PolyText16Request {
2572	drawable,
2573	gc,
2574	x,
2575	y,
2576	items: Cow::Borrowed(items),
2577	};
2578	let (bytes: [Cow<'_, [u8]>; 3], fds: Vec) = request0.serialize();
2579	let slices: [IoSlice<'_>; 3] = [IoSlice::new(&bytes[`0`]), IoSlice::new(&bytes[`1`]), IoSlice::new(&bytes[`2`])];
2580	assert_eq!(slices.len(), bytes.len());
2581	conn.send_request_without_reply(&slices, fds)
2582	}
2583
2584	/// Draws text.
2585	///
2586	/// Fills the destination rectangle with the background pixel from `gc`, then
2587	/// paints the text with the foreground pixel from `gc`. The upper-left corner of
2588	/// the filled rectangle is at [x, y - font-ascent]. The width is overall-width,
2589	/// the height is font-ascent + font-descent. The overall-width, font-ascent and
2590	/// font-descent are as returned by `xcb_query_text_extents` (TODO).
2591	///
2592	/// Note that using X core fonts is deprecated (but still supported) in favor of
2593	/// client-side rendering using Xft.
2594	///
2595	/// # Fields
2596	///
2597	/// `drawable` - The drawable (Window or Pixmap) to draw text on.*
2598	/// `string_len` - The length of the `string`. Note that this parameter limited by 255 due to*
2599	/// using 8 bits!
2600	/// `string` - The string to draw. Only the first 255 characters are relevant due to the data*
2601	/// type of `string_len`.
2602	/// `x` - The x coordinate of the first character, relative to the origin of `drawable`.*
2603	/// `y` - The y coordinate of the first character, relative to the origin of `drawable`.*
2604	/// `gc` - The graphics context to use.*
2605	///
2606	/// The following graphics context components are used: plane-mask, foreground,
2607	/// background, font, subwindow-mode, clip-x-origin, clip-y-origin, and clip-mask.
2608	///
2609	/// # Errors
2610	///
2611	/// `Drawable` - The specified `drawable` (Window or Pixmap) does not exist.*
2612	/// `GContext` - The specified graphics context does not exist.*
2613	/// `Match` - TODO: reasons?*
2614	///
2615	/// # See
2616	///
2617	/// `ImageText16`: request*
2618	pub fn image_text8<'c, 'input, Conn>(conn: &'c Conn, drawable: Drawable, gc: Gcontext, x: i16, y: i16, string: &'input [u8]) -> Result<VoidCookie<'c, Conn>, ConnectionError>
2619	where
2620	Conn: RequestConnection + ?Sized,
2621	{
2622	let request0: ImageText8Request<'_> = ImageText8Request {
2623	drawable,
2624	gc,
2625	x,
2626	y,
2627	string: Cow::Borrowed(string),
2628	};
2629	let (bytes: [Cow<'_, [u8]>; 3], fds: Vec) = request0.serialize();
2630	let slices: [IoSlice<'_>; 3] = [IoSlice::new(&bytes[`0`]), IoSlice::new(&bytes[`1`]), IoSlice::new(&bytes[`2`])];
2631	assert_eq!(slices.len(), bytes.len());
2632	conn.send_request_without_reply(&slices, fds)
2633	}
2634
2635	/// Draws text.
2636	///
2637	/// Fills the destination rectangle with the background pixel from `gc`, then
2638	/// paints the text with the foreground pixel from `gc`. The upper-left corner of
2639	/// the filled rectangle is at [x, y - font-ascent]. The width is overall-width,
2640	/// the height is font-ascent + font-descent. The overall-width, font-ascent and
2641	/// font-descent are as returned by `xcb_query_text_extents` (TODO).
2642	///
2643	/// Note that using X core fonts is deprecated (but still supported) in favor of
2644	/// client-side rendering using Xft.
2645	///
2646	/// # Fields
2647	///
2648	/// `drawable` - The drawable (Window or Pixmap) to draw text on.*
2649	/// `string_len` - The length of the `string` in characters. Note that this parameter limited by*
2650	/// 255 due to using 8 bits!
2651	/// `string` - The string to draw. Only the first 255 characters are relevant due to the data*
2652	/// type of `string_len`. Every character uses 2 bytes (hence the 16 in this
2653	/// request's name).
2654	/// `x` - The x coordinate of the first character, relative to the origin of `drawable`.*
2655	/// `y` - The y coordinate of the first character, relative to the origin of `drawable`.*
2656	/// `gc` - The graphics context to use.*
2657	///
2658	/// The following graphics context components are used: plane-mask, foreground,
2659	/// background, font, subwindow-mode, clip-x-origin, clip-y-origin, and clip-mask.
2660	///
2661	/// # Errors
2662	///
2663	/// `Drawable` - The specified `drawable` (Window or Pixmap) does not exist.*
2664	/// `GContext` - The specified graphics context does not exist.*
2665	/// `Match` - TODO: reasons?*
2666	///
2667	/// # See
2668	///
2669	/// `ImageText8`: request*
2670	pub fn image_text16<'c, 'input, Conn>(conn: &'c Conn, drawable: Drawable, gc: Gcontext, x: i16, y: i16, string: &'input [Char2b]) -> Result<VoidCookie<'c, Conn>, ConnectionError>
2671	where
2672	Conn: RequestConnection + ?Sized,
2673	{
2674	let request0: ImageText16Request<'_> = ImageText16Request {
2675	drawable,
2676	gc,
2677	x,
2678	y,
2679	string: Cow::Borrowed(string),
2680	};
2681	let (bytes: [Cow<'_, [u8]>; 3], fds: Vec) = request0.serialize();
2682	let slices: [IoSlice<'_>; 3] = [IoSlice::new(&bytes[`0`]), IoSlice::new(&bytes[`1`]), IoSlice::new(&bytes[`2`])];
2683	assert_eq!(slices.len(), bytes.len());
2684	conn.send_request_without_reply(&slices, fds)
2685	}
2686
2687	pub fn create_colormap<Conn>(conn: &Conn, alloc: ColormapAlloc, mid: Colormap, window: Window, visual: Visualid) -> Result<VoidCookie<'_, Conn>, ConnectionError>
2688	where
2689	Conn: RequestConnection + ?Sized,
2690	{
2691	let request0: CreateColormapRequest = CreateColormapRequest {
2692	alloc,
2693	mid,
2694	window,
2695	visual,
2696	};
2697	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
2698	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
2699	assert_eq!(slices.len(), bytes.len());
2700	conn.send_request_without_reply(&slices, fds)
2701	}
2702
2703	pub fn free_colormap<Conn>(conn: &Conn, cmap: Colormap) -> Result<VoidCookie<'_, Conn>, ConnectionError>
2704	where
2705	Conn: RequestConnection + ?Sized,
2706	{
2707	let request0: FreeColormapRequest = FreeColormapRequest {
2708	cmap,
2709	};
2710	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
2711	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
2712	assert_eq!(slices.len(), bytes.len());
2713	conn.send_request_without_reply(&slices, fds)
2714	}
2715
2716	pub fn copy_colormap_and_free<Conn>(conn: &Conn, mid: Colormap, src_cmap: Colormap) -> Result<VoidCookie<'_, Conn>, ConnectionError>
2717	where
2718	Conn: RequestConnection + ?Sized,
2719	{
2720	let request0: CopyColormapAndFreeRequest = CopyColormapAndFreeRequest {
2721	mid,
2722	src_cmap,
2723	};
2724	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
2725	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
2726	assert_eq!(slices.len(), bytes.len());
2727	conn.send_request_without_reply(&slices, fds)
2728	}
2729
2730	pub fn install_colormap<Conn>(conn: &Conn, cmap: Colormap) -> Result<VoidCookie<'_, Conn>, ConnectionError>
2731	where
2732	Conn: RequestConnection + ?Sized,
2733	{
2734	let request0: InstallColormapRequest = InstallColormapRequest {
2735	cmap,
2736	};
2737	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
2738	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
2739	assert_eq!(slices.len(), bytes.len());
2740	conn.send_request_without_reply(&slices, fds)
2741	}
2742
2743	pub fn uninstall_colormap<Conn>(conn: &Conn, cmap: Colormap) -> Result<VoidCookie<'_, Conn>, ConnectionError>
2744	where
2745	Conn: RequestConnection + ?Sized,
2746	{
2747	let request0: UninstallColormapRequest = UninstallColormapRequest {
2748	cmap,
2749	};
2750	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
2751	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
2752	assert_eq!(slices.len(), bytes.len());
2753	conn.send_request_without_reply(&slices, fds)
2754	}
2755
2756	pub fn list_installed_colormaps<Conn>(conn: &Conn, window: Window) -> Result<Cookie<'_, Conn, ListInstalledColormapsReply>, ConnectionError>
2757	where
2758	Conn: RequestConnection + ?Sized,
2759	{
2760	let request0: ListInstalledColormapsRequest = ListInstalledColormapsRequest {
2761	window,
2762	};
2763	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
2764	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
2765	assert_eq!(slices.len(), bytes.len());
2766	conn.send_request_with_reply(&slices, fds)
2767	}
2768
2769	/// Allocate a color.
2770	///
2771	/// Allocates a read-only colormap entry corresponding to the closest RGB value
2772	/// supported by the hardware. If you are using TrueColor, you can take a shortcut
2773	/// and directly calculate the color pixel value to avoid the round trip. But, for
2774	/// example, on 16-bit color setups (VNC), you can easily get the closest supported
2775	/// RGB value to the RGB value you are specifying.
2776	///
2777	/// # Fields
2778	///
2779	/// `cmap` - TODO*
2780	/// `red` - The red value of your color.*
2781	/// `green` - The green value of your color.*
2782	/// `blue` - The blue value of your color.*
2783	///
2784	/// # Errors
2785	///
2786	/// `Colormap` - The specified colormap `cmap` does not exist.*
2787	pub fn alloc_color<Conn>(conn: &Conn, cmap: Colormap, red: u16, green: u16, blue: u16) -> Result<Cookie<'_, Conn, AllocColorReply>, ConnectionError>
2788	where
2789	Conn: RequestConnection + ?Sized,
2790	{
2791	let request0: AllocColorRequest = AllocColorRequest {
2792	cmap,
2793	red,
2794	green,
2795	blue,
2796	};
2797	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
2798	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
2799	assert_eq!(slices.len(), bytes.len());
2800	conn.send_request_with_reply(&slices, fds)
2801	}
2802
2803	pub fn alloc_named_color<'c, 'input, Conn>(conn: &'c Conn, cmap: Colormap, name: &'input [u8]) -> Result<Cookie<'c, Conn, AllocNamedColorReply>, ConnectionError>
2804	where
2805	Conn: RequestConnection + ?Sized,
2806	{
2807	let request0: AllocNamedColorRequest<'_> = AllocNamedColorRequest {
2808	cmap,
2809	name: Cow::Borrowed(name),
2810	};
2811	let (bytes: [Cow<'_, [u8]>; 3], fds: Vec) = request0.serialize();
2812	let slices: [IoSlice<'_>; 3] = [IoSlice::new(&bytes[`0`]), IoSlice::new(&bytes[`1`]), IoSlice::new(&bytes[`2`])];
2813	assert_eq!(slices.len(), bytes.len());
2814	conn.send_request_with_reply(&slices, fds)
2815	}
2816
2817	pub fn alloc_color_cells<Conn>(conn: &Conn, contiguous: bool, cmap: Colormap, colors: u16, planes: u16) -> Result<Cookie<'_, Conn, AllocColorCellsReply>, ConnectionError>
2818	where
2819	Conn: RequestConnection + ?Sized,
2820	{
2821	let request0: AllocColorCellsRequest = AllocColorCellsRequest {
2822	contiguous,
2823	cmap,
2824	colors,
2825	planes,
2826	};
2827	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
2828	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
2829	assert_eq!(slices.len(), bytes.len());
2830	conn.send_request_with_reply(&slices, fds)
2831	}
2832
2833	pub fn alloc_color_planes<Conn>(conn: &Conn, contiguous: bool, cmap: Colormap, colors: u16, reds: u16, greens: u16, blues: u16) -> Result<Cookie<'_, Conn, AllocColorPlanesReply>, ConnectionError>
2834	where
2835	Conn: RequestConnection + ?Sized,
2836	{
2837	let request0: AllocColorPlanesRequest = AllocColorPlanesRequest {
2838	contiguous,
2839	cmap,
2840	colors,
2841	reds,
2842	greens,
2843	blues,
2844	};
2845	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
2846	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
2847	assert_eq!(slices.len(), bytes.len());
2848	conn.send_request_with_reply(&slices, fds)
2849	}
2850
2851	pub fn free_colors<'c, 'input, Conn>(conn: &'c Conn, cmap: Colormap, plane_mask: u32, pixels: &'input [u32]) -> Result<VoidCookie<'c, Conn>, ConnectionError>
2852	where
2853	Conn: RequestConnection + ?Sized,
2854	{
2855	let request0: FreeColorsRequest<'_> = FreeColorsRequest {
2856	cmap,
2857	plane_mask,
2858	pixels: Cow::Borrowed(pixels),
2859	};
2860	let (bytes: [Cow<'_, [u8]>; 3], fds: Vec) = request0.serialize();
2861	let slices: [IoSlice<'_>; 3] = [IoSlice::new(&bytes[`0`]), IoSlice::new(&bytes[`1`]), IoSlice::new(&bytes[`2`])];
2862	assert_eq!(slices.len(), bytes.len());
2863	conn.send_request_without_reply(&slices, fds)
2864	}
2865
2866	pub fn store_colors<'c, 'input, Conn>(conn: &'c Conn, cmap: Colormap, items: &'input [Coloritem]) -> Result<VoidCookie<'c, Conn>, ConnectionError>
2867	where
2868	Conn: RequestConnection + ?Sized,
2869	{
2870	let request0: StoreColorsRequest<'_> = StoreColorsRequest {
2871	cmap,
2872	items: Cow::Borrowed(items),
2873	};
2874	let (bytes: [Cow<'_, [u8]>; 3], fds: Vec) = request0.serialize();
2875	let slices: [IoSlice<'_>; 3] = [IoSlice::new(&bytes[`0`]), IoSlice::new(&bytes[`1`]), IoSlice::new(&bytes[`2`])];
2876	assert_eq!(slices.len(), bytes.len());
2877	conn.send_request_without_reply(&slices, fds)
2878	}
2879
2880	pub fn store_named_color<'c, 'input, Conn>(conn: &'c Conn, flags: ColorFlag, cmap: Colormap, pixel: u32, name: &'input [u8]) -> Result<VoidCookie<'c, Conn>, ConnectionError>
2881	where
2882	Conn: RequestConnection + ?Sized,
2883	{
2884	let request0: StoreNamedColorRequest<'_> = StoreNamedColorRequest {
2885	flags,
2886	cmap,
2887	pixel,
2888	name: Cow::Borrowed(name),
2889	};
2890	let (bytes: [Cow<'_, [u8]>; 3], fds: Vec) = request0.serialize();
2891	let slices: [IoSlice<'_>; 3] = [IoSlice::new(&bytes[`0`]), IoSlice::new(&bytes[`1`]), IoSlice::new(&bytes[`2`])];
2892	assert_eq!(slices.len(), bytes.len());
2893	conn.send_request_without_reply(&slices, fds)
2894	}
2895
2896	pub fn query_colors<'c, 'input, Conn>(conn: &'c Conn, cmap: Colormap, pixels: &'input [u32]) -> Result<Cookie<'c, Conn, QueryColorsReply>, ConnectionError>
2897	where
2898	Conn: RequestConnection + ?Sized,
2899	{
2900	let request0: QueryColorsRequest<'_> = QueryColorsRequest {
2901	cmap,
2902	pixels: Cow::Borrowed(pixels),
2903	};
2904	let (bytes: [Cow<'_, [u8]>; 3], fds: Vec) = request0.serialize();
2905	let slices: [IoSlice<'_>; 3] = [IoSlice::new(&bytes[`0`]), IoSlice::new(&bytes[`1`]), IoSlice::new(&bytes[`2`])];
2906	assert_eq!(slices.len(), bytes.len());
2907	conn.send_request_with_reply(&slices, fds)
2908	}
2909
2910	pub fn lookup_color<'c, 'input, Conn>(conn: &'c Conn, cmap: Colormap, name: &'input [u8]) -> Result<Cookie<'c, Conn, LookupColorReply>, ConnectionError>
2911	where
2912	Conn: RequestConnection + ?Sized,
2913	{
2914	let request0: LookupColorRequest<'_> = LookupColorRequest {
2915	cmap,
2916	name: Cow::Borrowed(name),
2917	};
2918	let (bytes: [Cow<'_, [u8]>; 3], fds: Vec) = request0.serialize();
2919	let slices: [IoSlice<'_>; 3] = [IoSlice::new(&bytes[`0`]), IoSlice::new(&bytes[`1`]), IoSlice::new(&bytes[`2`])];
2920	assert_eq!(slices.len(), bytes.len());
2921	conn.send_request_with_reply(&slices, fds)
2922	}
2923
2924	pub fn create_cursor<Conn, A>(conn: &Conn, cid: Cursor, source: Pixmap, mask: A, fore_red: u16, fore_green: u16, fore_blue: u16, back_red: u16, back_green: u16, back_blue: u16, x: u16, y: u16) -> Result<VoidCookie<'_, Conn>, ConnectionError>
2925	where
2926	Conn: RequestConnection + ?Sized,
2927	A: Into<Pixmap>,
2928	{
2929	let mask: Pixmap = mask.into();
2930	let request0: CreateCursorRequest = CreateCursorRequest {
2931	cid,
2932	source,
2933	mask,
2934	fore_red,
2935	fore_green,
2936	fore_blue,
2937	back_red,
2938	back_green,
2939	back_blue,
2940	x,
2941	y,
2942	};
2943	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
2944	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
2945	assert_eq!(slices.len(), bytes.len());
2946	conn.send_request_without_reply(&slices, fds)
2947	}
2948
2949	/// create cursor.
2950	///
2951	/// Creates a cursor from a font glyph. X provides a set of standard cursor shapes
2952	/// in a special font named cursor. Applications are encouraged to use this
2953	/// interface for their cursors because the font can be customized for the
2954	/// individual display type.
2955	///
2956	/// All pixels which are set to 1 in the source will use the foreground color (as
2957	/// specified by `fore_red`, `fore_green` and `fore_blue`). All pixels set to 0
2958	/// will use the background color (as specified by `back_red`, `back_green` and
2959	/// `back_blue`).
2960	///
2961	/// # Fields
2962	///
2963	/// `cid` - The ID with which you will refer to the cursor, created by `xcb_generate_id`.*
2964	/// `source_font` - In which font to look for the cursor glyph.*
2965	/// `mask_font` - In which font to look for the mask glyph.*
2966	/// `source_char` - The glyph of `source_font` to use.*
2967	/// `mask_char` - The glyph of `mask_font` to use as a mask: Pixels which are set to 1 define*
2968	/// which source pixels are displayed. All pixels which are set to 0 are not
2969	/// displayed.
2970	/// `fore_red` - The red value of the foreground color.*
2971	/// `fore_green` - The green value of the foreground color.*
2972	/// `fore_blue` - The blue value of the foreground color.*
2973	/// `back_red` - The red value of the background color.*
2974	/// `back_green` - The green value of the background color.*
2975	/// `back_blue` - The blue value of the background color.*
2976	///
2977	/// # Errors
2978	///
2979	/// `Alloc` - The X server could not allocate the requested resources (no memory?).*
2980	/// `Font` - The specified `source_font` or `mask_font` does not exist.*
2981	/// `Value` - Either `source_char` or `mask_char` are not defined in `source_font` or `mask_font`, respectively.*
2982	pub fn create_glyph_cursor<Conn, A>(conn: &Conn, cid: Cursor, source_font: Font, mask_font: A, source_char: u16, mask_char: u16, fore_red: u16, fore_green: u16, fore_blue: u16, back_red: u16, back_green: u16, back_blue: u16) -> Result<VoidCookie<'_, Conn>, ConnectionError>
2983	where
2984	Conn: RequestConnection + ?Sized,
2985	A: Into<Font>,
2986	{
2987	let mask_font: Font = mask_font.into();
2988	let request0: CreateGlyphCursorRequest = CreateGlyphCursorRequest {
2989	cid,
2990	source_font,
2991	mask_font,
2992	source_char,
2993	mask_char,
2994	fore_red,
2995	fore_green,
2996	fore_blue,
2997	back_red,
2998	back_green,
2999	back_blue,
3000	};
3001	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
3002	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
3003	assert_eq!(slices.len(), bytes.len());
3004	conn.send_request_without_reply(&slices, fds)
3005	}
3006
3007	/// Deletes a cursor.
3008	///
3009	/// Deletes the association between the cursor resource ID and the specified
3010	/// cursor. The cursor is freed when no other resource references it.
3011	///
3012	/// # Fields
3013	///
3014	/// `cursor` - The cursor to destroy.*
3015	///
3016	/// # Errors
3017	///
3018	/// `Cursor` - The specified cursor does not exist.*
3019	pub fn free_cursor<Conn>(conn: &Conn, cursor: Cursor) -> Result<VoidCookie<'_, Conn>, ConnectionError>
3020	where
3021	Conn: RequestConnection + ?Sized,
3022	{
3023	let request0: FreeCursorRequest = FreeCursorRequest {
3024	cursor,
3025	};
3026	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
3027	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
3028	assert_eq!(slices.len(), bytes.len());
3029	conn.send_request_without_reply(&slices, fds)
3030	}
3031
3032	pub fn recolor_cursor<Conn>(conn: &Conn, cursor: Cursor, fore_red: u16, fore_green: u16, fore_blue: u16, back_red: u16, back_green: u16, back_blue: u16) -> Result<VoidCookie<'_, Conn>, ConnectionError>
3033	where
3034	Conn: RequestConnection + ?Sized,
3035	{
3036	let request0: RecolorCursorRequest = RecolorCursorRequest {
3037	cursor,
3038	fore_red,
3039	fore_green,
3040	fore_blue,
3041	back_red,
3042	back_green,
3043	back_blue,
3044	};
3045	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
3046	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
3047	assert_eq!(slices.len(), bytes.len());
3048	conn.send_request_without_reply(&slices, fds)
3049	}
3050
3051	pub fn query_best_size<Conn>(conn: &Conn, class: QueryShapeOf, drawable: Drawable, width: u16, height: u16) -> Result<Cookie<'_, Conn, QueryBestSizeReply>, ConnectionError>
3052	where
3053	Conn: RequestConnection + ?Sized,
3054	{
3055	let request0: QueryBestSizeRequest = QueryBestSizeRequest {
3056	class,
3057	drawable,
3058	width,
3059	height,
3060	};
3061	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
3062	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
3063	assert_eq!(slices.len(), bytes.len());
3064	conn.send_request_with_reply(&slices, fds)
3065	}
3066
3067	/// check if extension is present.
3068	///
3069	/// Determines if the specified extension is present on this X11 server.
3070	///
3071	/// Every extension has a unique `major_opcode` to identify requests, the minor
3072	/// opcodes and request formats are extension-specific. If the extension provides
3073	/// events and errors, the `first_event` and `first_error` fields in the reply are
3074	/// set accordingly.
3075	///
3076	/// There should rarely be a need to use this request directly, XCB provides the
3077	/// `xcb_get_extension_data` function instead.
3078	///
3079	/// # Fields
3080	///
3081	/// `name_len` - The length of `name` in bytes.*
3082	/// `name` - The name of the extension to query, for example "RANDR". This is case*
3083	/// sensitive!
3084	///
3085	/// # See
3086	///
3087	/// `xdpyinfo`: program*
3088	/// `xcb_get_extension_data`: function*
3089	pub fn query_extension<'c, 'input, Conn>(conn: &'c Conn, name: &'input [u8]) -> Result<Cookie<'c, Conn, QueryExtensionReply>, ConnectionError>
3090	where
3091	Conn: RequestConnection + ?Sized,
3092	{
3093	let request0: QueryExtensionRequest<'_> = QueryExtensionRequest {
3094	name: Cow::Borrowed(name),
3095	};
3096	let (bytes: [Cow<'_, [u8]>; 3], fds: Vec) = request0.serialize();
3097	let slices: [IoSlice<'_>; 3] = [IoSlice::new(&bytes[`0`]), IoSlice::new(&bytes[`1`]), IoSlice::new(&bytes[`2`])];
3098	assert_eq!(slices.len(), bytes.len());
3099	conn.send_request_with_reply(&slices, fds)
3100	}
3101
3102	pub fn list_extensions<Conn>(conn: &Conn) -> Result<Cookie<'_, Conn, ListExtensionsReply>, ConnectionError>
3103	where
3104	Conn: RequestConnection + ?Sized,
3105	{
3106	let request0: ListExtensionsRequest = ListExtensionsRequest;
3107	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
3108	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
3109	assert_eq!(slices.len(), bytes.len());
3110	conn.send_request_with_reply(&slices, fds)
3111	}
3112
3113	pub fn change_keyboard_mapping<'c, 'input, Conn>(conn: &'c Conn, keycode_count: u8, first_keycode: Keycode, keysyms_per_keycode: u8, keysyms: &'input [Keysym]) -> Result<VoidCookie<'c, Conn>, ConnectionError>
3114	where
3115	Conn: RequestConnection + ?Sized,
3116	{
3117	let request0: ChangeKeyboardMappingRequest<'_> = ChangeKeyboardMappingRequest {
3118	keycode_count,
3119	first_keycode,
3120	keysyms_per_keycode,
3121	keysyms: Cow::Borrowed(keysyms),
3122	};
3123	let (bytes: [Cow<'_, [u8]>; 3], fds: Vec) = request0.serialize();
3124	let slices: [IoSlice<'_>; 3] = [IoSlice::new(&bytes[`0`]), IoSlice::new(&bytes[`1`]), IoSlice::new(&bytes[`2`])];
3125	assert_eq!(slices.len(), bytes.len());
3126	conn.send_request_without_reply(&slices, fds)
3127	}
3128
3129	pub fn get_keyboard_mapping<Conn>(conn: &Conn, first_keycode: Keycode, count: u8) -> Result<Cookie<'_, Conn, GetKeyboardMappingReply>, ConnectionError>
3130	where
3131	Conn: RequestConnection + ?Sized,
3132	{
3133	let request0: GetKeyboardMappingRequest = GetKeyboardMappingRequest {
3134	first_keycode,
3135	count,
3136	};
3137	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
3138	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
3139	assert_eq!(slices.len(), bytes.len());
3140	conn.send_request_with_reply(&slices, fds)
3141	}
3142
3143	pub fn change_keyboard_control<'c, 'input, Conn>(conn: &'c Conn, value_list: &'input ChangeKeyboardControlAux) -> Result<VoidCookie<'c, Conn>, ConnectionError>
3144	where
3145	Conn: RequestConnection + ?Sized,
3146	{
3147	let request0: ChangeKeyboardControlRequest<'_> = ChangeKeyboardControlRequest {
3148	value_list: Cow::Borrowed(value_list),
3149	};
3150	let (bytes: [Cow<'_, [u8]>; 3], fds: Vec) = request0.serialize();
3151	let slices: [IoSlice<'_>; 3] = [IoSlice::new(&bytes[`0`]), IoSlice::new(&bytes[`1`]), IoSlice::new(&bytes[`2`])];
3152	assert_eq!(slices.len(), bytes.len());
3153	conn.send_request_without_reply(&slices, fds)
3154	}
3155
3156	pub fn get_keyboard_control<Conn>(conn: &Conn) -> Result<Cookie<'_, Conn, GetKeyboardControlReply>, ConnectionError>
3157	where
3158	Conn: RequestConnection + ?Sized,
3159	{
3160	let request0: GetKeyboardControlRequest = GetKeyboardControlRequest;
3161	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
3162	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
3163	assert_eq!(slices.len(), bytes.len());
3164	conn.send_request_with_reply(&slices, fds)
3165	}
3166
3167	pub fn bell<Conn>(conn: &Conn, percent: i8) -> Result<VoidCookie<'_, Conn>, ConnectionError>
3168	where
3169	Conn: RequestConnection + ?Sized,
3170	{
3171	let request0: BellRequest = BellRequest {
3172	percent,
3173	};
3174	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
3175	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
3176	assert_eq!(slices.len(), bytes.len());
3177	conn.send_request_without_reply(&slices, fds)
3178	}
3179
3180	pub fn change_pointer_control<Conn>(conn: &Conn, acceleration_numerator: i16, acceleration_denominator: i16, threshold: i16, do_acceleration: bool, do_threshold: bool) -> Result<VoidCookie<'_, Conn>, ConnectionError>
3181	where
3182	Conn: RequestConnection + ?Sized,
3183	{
3184	let request0: ChangePointerControlRequest = ChangePointerControlRequest {
3185	acceleration_numerator,
3186	acceleration_denominator,
3187	threshold,
3188	do_acceleration,
3189	do_threshold,
3190	};
3191	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
3192	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
3193	assert_eq!(slices.len(), bytes.len());
3194	conn.send_request_without_reply(&slices, fds)
3195	}
3196
3197	pub fn get_pointer_control<Conn>(conn: &Conn) -> Result<Cookie<'_, Conn, GetPointerControlReply>, ConnectionError>
3198	where
3199	Conn: RequestConnection + ?Sized,
3200	{
3201	let request0: GetPointerControlRequest = GetPointerControlRequest;
3202	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
3203	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
3204	assert_eq!(slices.len(), bytes.len());
3205	conn.send_request_with_reply(&slices, fds)
3206	}
3207
3208	pub fn set_screen_saver<Conn>(conn: &Conn, timeout: i16, interval: i16, prefer_blanking: Blanking, allow_exposures: Exposures) -> Result<VoidCookie<'_, Conn>, ConnectionError>
3209	where
3210	Conn: RequestConnection + ?Sized,
3211	{
3212	let request0: SetScreenSaverRequest = SetScreenSaverRequest {
3213	timeout,
3214	interval,
3215	prefer_blanking,
3216	allow_exposures,
3217	};
3218	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
3219	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
3220	assert_eq!(slices.len(), bytes.len());
3221	conn.send_request_without_reply(&slices, fds)
3222	}
3223
3224	pub fn get_screen_saver<Conn>(conn: &Conn) -> Result<Cookie<'_, Conn, GetScreenSaverReply>, ConnectionError>
3225	where
3226	Conn: RequestConnection + ?Sized,
3227	{
3228	let request0: GetScreenSaverRequest = GetScreenSaverRequest;
3229	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
3230	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
3231	assert_eq!(slices.len(), bytes.len());
3232	conn.send_request_with_reply(&slices, fds)
3233	}
3234
3235	pub fn change_hosts<'c, 'input, Conn>(conn: &'c Conn, mode: HostMode, family: Family, address: &'input [u8]) -> Result<VoidCookie<'c, Conn>, ConnectionError>
3236	where
3237	Conn: RequestConnection + ?Sized,
3238	{
3239	let request0: ChangeHostsRequest<'_> = ChangeHostsRequest {
3240	mode,
3241	family,
3242	address: Cow::Borrowed(address),
3243	};
3244	let (bytes: [Cow<'_, [u8]>; 3], fds: Vec) = request0.serialize();
3245	let slices: [IoSlice<'_>; 3] = [IoSlice::new(&bytes[`0`]), IoSlice::new(&bytes[`1`]), IoSlice::new(&bytes[`2`])];
3246	assert_eq!(slices.len(), bytes.len());
3247	conn.send_request_without_reply(&slices, fds)
3248	}
3249
3250	pub fn list_hosts<Conn>(conn: &Conn) -> Result<Cookie<'_, Conn, ListHostsReply>, ConnectionError>
3251	where
3252	Conn: RequestConnection + ?Sized,
3253	{
3254	let request0: ListHostsRequest = ListHostsRequest;
3255	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
3256	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
3257	assert_eq!(slices.len(), bytes.len());
3258	conn.send_request_with_reply(&slices, fds)
3259	}
3260
3261	pub fn set_access_control<Conn>(conn: &Conn, mode: AccessControl) -> Result<VoidCookie<'_, Conn>, ConnectionError>
3262	where
3263	Conn: RequestConnection + ?Sized,
3264	{
3265	let request0: SetAccessControlRequest = SetAccessControlRequest {
3266	mode,
3267	};
3268	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
3269	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
3270	assert_eq!(slices.len(), bytes.len());
3271	conn.send_request_without_reply(&slices, fds)
3272	}
3273
3274	pub fn set_close_down_mode<Conn>(conn: &Conn, mode: CloseDown) -> Result<VoidCookie<'_, Conn>, ConnectionError>
3275	where
3276	Conn: RequestConnection + ?Sized,
3277	{
3278	let request0: SetCloseDownModeRequest = SetCloseDownModeRequest {
3279	mode,
3280	};
3281	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
3282	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
3283	assert_eq!(slices.len(), bytes.len());
3284	conn.send_request_without_reply(&slices, fds)
3285	}
3286
3287	/// kills a client.
3288	///
3289	/// Forces a close down of the client that created the specified `resource`.
3290	///
3291	/// # Fields
3292	///
3293	/// `resource` - Any resource belonging to the client (for example a Window), used to identify*
3294	/// the client connection.
3295	///
3296	/// The special value of `XCB_KILL_ALL_TEMPORARY`, the resources of all clients
3297	/// that have terminated in `RetainTemporary` (TODO) are destroyed.
3298	///
3299	/// # Errors
3300	///
3301	/// `Value` - The specified `resource` does not exist.*
3302	///
3303	/// # See
3304	///
3305	/// `xkill`: program*
3306	pub fn kill_client<Conn, A>(conn: &Conn, resource: A) -> Result<VoidCookie<'_, Conn>, ConnectionError>
3307	where
3308	Conn: RequestConnection + ?Sized,
3309	A: Into<u32>,
3310	{
3311	let resource: u32 = resource.into();
3312	let request0: KillClientRequest = KillClientRequest {
3313	resource,
3314	};
3315	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
3316	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
3317	assert_eq!(slices.len(), bytes.len());
3318	conn.send_request_without_reply(&slices, fds)
3319	}
3320
3321	pub fn rotate_properties<'c, 'input, Conn>(conn: &'c Conn, window: Window, delta: i16, atoms: &'input [Atom]) -> Result<VoidCookie<'c, Conn>, ConnectionError>
3322	where
3323	Conn: RequestConnection + ?Sized,
3324	{
3325	let request0: RotatePropertiesRequest<'_> = RotatePropertiesRequest {
3326	window,
3327	delta,
3328	atoms: Cow::Borrowed(atoms),
3329	};
3330	let (bytes: [Cow<'_, [u8]>; 3], fds: Vec) = request0.serialize();
3331	let slices: [IoSlice<'_>; 3] = [IoSlice::new(&bytes[`0`]), IoSlice::new(&bytes[`1`]), IoSlice::new(&bytes[`2`])];
3332	assert_eq!(slices.len(), bytes.len());
3333	conn.send_request_without_reply(&slices, fds)
3334	}
3335
3336	pub fn force_screen_saver<Conn>(conn: &Conn, mode: ScreenSaver) -> Result<VoidCookie<'_, Conn>, ConnectionError>
3337	where
3338	Conn: RequestConnection + ?Sized,
3339	{
3340	let request0: ForceScreenSaverRequest = ForceScreenSaverRequest {
3341	mode,
3342	};
3343	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
3344	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
3345	assert_eq!(slices.len(), bytes.len());
3346	conn.send_request_without_reply(&slices, fds)
3347	}
3348
3349	pub fn set_pointer_mapping<'c, 'input, Conn>(conn: &'c Conn, map: &'input [u8]) -> Result<Cookie<'c, Conn, SetPointerMappingReply>, ConnectionError>
3350	where
3351	Conn: RequestConnection + ?Sized,
3352	{
3353	let request0: SetPointerMappingRequest<'_> = SetPointerMappingRequest {
3354	map: Cow::Borrowed(map),
3355	};
3356	let (bytes: [Cow<'_, [u8]>; 3], fds: Vec) = request0.serialize();
3357	let slices: [IoSlice<'_>; 3] = [IoSlice::new(&bytes[`0`]), IoSlice::new(&bytes[`1`]), IoSlice::new(&bytes[`2`])];
3358	assert_eq!(slices.len(), bytes.len());
3359	conn.send_request_with_reply(&slices, fds)
3360	}
3361
3362	pub fn get_pointer_mapping<Conn>(conn: &Conn) -> Result<Cookie<'_, Conn, GetPointerMappingReply>, ConnectionError>
3363	where
3364	Conn: RequestConnection + ?Sized,
3365	{
3366	let request0: GetPointerMappingRequest = GetPointerMappingRequest;
3367	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
3368	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
3369	assert_eq!(slices.len(), bytes.len());
3370	conn.send_request_with_reply(&slices, fds)
3371	}
3372
3373	pub fn set_modifier_mapping<'c, 'input, Conn>(conn: &'c Conn, keycodes: &'input [Keycode]) -> Result<Cookie<'c, Conn, SetModifierMappingReply>, ConnectionError>
3374	where
3375	Conn: RequestConnection + ?Sized,
3376	{
3377	let request0: SetModifierMappingRequest<'_> = SetModifierMappingRequest {
3378	keycodes: Cow::Borrowed(keycodes),
3379	};
3380	let (bytes: [Cow<'_, [u8]>; 3], fds: Vec) = request0.serialize();
3381	let slices: [IoSlice<'_>; 3] = [IoSlice::new(&bytes[`0`]), IoSlice::new(&bytes[`1`]), IoSlice::new(&bytes[`2`])];
3382	assert_eq!(slices.len(), bytes.len());
3383	conn.send_request_with_reply(&slices, fds)
3384	}
3385
3386	pub fn get_modifier_mapping<Conn>(conn: &Conn) -> Result<Cookie<'_, Conn, GetModifierMappingReply>, ConnectionError>
3387	where
3388	Conn: RequestConnection + ?Sized,
3389	{
3390	let request0: GetModifierMappingRequest = GetModifierMappingRequest;
3391	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
3392	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
3393	assert_eq!(slices.len(), bytes.len());
3394	conn.send_request_with_reply(&slices, fds)
3395	}
3396
3397	pub fn no_operation<Conn>(conn: &Conn) -> Result<VoidCookie<'_, Conn>, ConnectionError>
3398	where
3399	Conn: RequestConnection + ?Sized,
3400	{
3401	let request0: NoOperationRequest = NoOperationRequest;
3402	let (bytes: [Cow<'_, [u8]>; 1], fds: Vec) = request0.serialize();
3403	let slices: [IoSlice<'_>; 1] = [IoSlice::new(&bytes[`0`])];
3404	assert_eq!(slices.len(), bytes.len());
3405	conn.send_request_without_reply(&slices, fds)
3406	}
3407
3408	/// Extension trait defining the requests of this extension.
3409	pub trait ConnectionExt: RequestConnection {
3410	/// Creates a window.
3411	///
3412	/// Creates an unmapped window as child of the specified `parent` window. A
3413	/// CreateNotify event will be generated. The new window is placed on top in the
3414	/// stacking order with respect to siblings.
3415	///
3416	/// The coordinate system has the X axis horizontal and the Y axis vertical with
3417	/// the origin [0, 0] at the upper-left corner. Coordinates are integral, in terms
3418	/// of pixels, and coincide with pixel centers. Each window and pixmap has its own
3419	/// coordinate system. For a window, the origin is inside the border at the inside,
3420	/// upper-left corner.
3421	///
3422	/// The created window is not yet displayed (mapped), call `xcb_map_window` to
3423	/// display it.
3424	///
3425	/// The created window will initially use the same cursor as its parent.
3426	///
3427	/// # Fields
3428	///
3429	/// `wid` - The ID with which you will refer to the new window, created by*
3430	/// `xcb_generate_id`.
3431	/// `depth` - Specifies the new window's depth (TODO: what unit?).*
3432	///
3433	/// The special value `XCB_COPY_FROM_PARENT` means the depth is taken from the
3434	/// `parent` window.
3435	/// `visual` - Specifies the id for the new window's visual.*
3436	///
3437	/// The special value `XCB_COPY_FROM_PARENT` means the visual is taken from the
3438	/// `parent` window.
3439	/// `class` -*
3440	/// `parent` - The parent window of the new window.*
3441	/// `border_width` - TODO:*
3442	///
3443	/// Must be zero if the `class` is `InputOnly` or a `xcb_match_error_t` occurs.
3444	/// `x` - The X coordinate of the new window.*
3445	/// `y` - The Y coordinate of the new window.*
3446	/// `width` - The width of the new window.*
3447	/// `height` - The height of the new window.*
3448	///
3449	/// # Errors
3450	///
3451	/// `Colormap` - TODO: reasons?*
3452	/// `Match` - TODO: reasons?*
3453	/// `Cursor` - TODO: reasons?*
3454	/// `Pixmap` - TODO: reasons?*
3455	/// `Value` - TODO: reasons?*
3456	/// `Window` - TODO: reasons?*
3457	/// `Alloc` - The X server could not allocate the requested resources (no memory?).*
3458	///
3459	/// # See
3460	///
3461	/// `xcb_generate_id`: function*
3462	/// `MapWindow`: request*
3463	/// `CreateNotify`: event*
3464	fn create_window<'c, 'input>(&'c self, depth: u8, wid: Window, parent: Window, x: i16, y: i16, width: u16, height: u16, border_width: u16, class: WindowClass, visual: Visualid, value_list: &'input CreateWindowAux) -> Result<VoidCookie<'c, Self>, ConnectionError>
3465	{
3466	create_window(self, depth, wid, parent, x, y, width, height, border_width, class, visual, value_list)
3467	}
3468	/// change window attributes.
3469	///
3470	/// Changes the attributes specified by `value_mask` for the specified `window`.
3471	///
3472	/// # Fields
3473	///
3474	/// `window` - The window to change.*
3475	/// `value_mask` -*
3476	/// `value_list` - Values for each of the attributes specified in the bitmask `value_mask`. The*
3477	/// order has to correspond to the order of possible `value_mask` bits. See the
3478	/// example.
3479	///
3480	/// # Errors
3481	///
3482	/// `Access` - TODO: reasons?*
3483	/// `Colormap` - TODO: reasons?*
3484	/// `Cursor` - TODO: reasons?*
3485	/// `Match` - TODO: reasons?*
3486	/// `Pixmap` - TODO: reasons?*
3487	/// `Value` - TODO: reasons?*
3488	/// `Window` - The specified `window` does not exist.*
3489	fn change_window_attributes<'c, 'input>(&'c self, window: Window, value_list: &'input ChangeWindowAttributesAux) -> Result<VoidCookie<'c, Self>, ConnectionError>
3490	{
3491	change_window_attributes(self, window, value_list)
3492	}
3493	/// Gets window attributes.
3494	///
3495	/// Gets the current attributes for the specified `window`.
3496	///
3497	/// # Fields
3498	///
3499	/// `window` - The window to get the attributes from.*
3500	///
3501	/// # Errors
3502	///
3503	/// `Window` - The specified `window` does not exist.*
3504	/// `Drawable` - TODO: reasons?*
3505	fn get_window_attributes(&self, window: Window) -> Result<Cookie<'_, Self, GetWindowAttributesReply>, ConnectionError>
3506	{
3507	get_window_attributes(self, window)
3508	}
3509	/// Destroys a window.
3510	///
3511	/// Destroys the specified window and all of its subwindows. A DestroyNotify event
3512	/// is generated for each destroyed window (a DestroyNotify event is first generated
3513	/// for any given window's inferiors). If the window was mapped, it will be
3514	/// automatically unmapped before destroying.
3515	///
3516	/// Calling DestroyWindow on the root window will do nothing.
3517	///
3518	/// # Fields
3519	///
3520	/// `window` - The window to destroy.*
3521	///
3522	/// # Errors
3523	///
3524	/// `Window` - The specified window does not exist.*
3525	///
3526	/// # See
3527	///
3528	/// `DestroyNotify`: event*
3529	/// `MapWindow`: request*
3530	/// `UnmapWindow`: request*
3531	fn destroy_window(&self, window: Window) -> Result<VoidCookie<'_, Self>, ConnectionError>
3532	{
3533	destroy_window(self, window)
3534	}
3535	fn destroy_subwindows(&self, window: Window) -> Result<VoidCookie<'_, Self>, ConnectionError>
3536	{
3537	destroy_subwindows(self, window)
3538	}
3539	/// Changes a client's save set.
3540	///
3541	/// TODO: explain what the save set is for.
3542	///
3543	/// This function either adds or removes the specified window to the client's (your
3544	/// application's) save set.
3545	///
3546	/// # Fields
3547	///
3548	/// `mode` - Insert to add the specified window to the save set or Delete to delete it from the save set.*
3549	/// `window` - The window to add or delete to/from your save set.*
3550	///
3551	/// # Errors
3552	///
3553	/// `Match` - You created the specified window. This does not make sense, you can only add*
3554	/// windows created by other clients to your save set.
3555	/// `Value` - You specified an invalid mode.*
3556	/// `Window` - The specified window does not exist.*
3557	///
3558	/// # See
3559	///
3560	/// `ReparentWindow`: request*
3561	fn change_save_set(&self, mode: SetMode, window: Window) -> Result<VoidCookie<'_, Self>, ConnectionError>
3562	{
3563	change_save_set(self, mode, window)
3564	}
3565	/// Reparents a window.
3566	///
3567	/// Makes the specified window a child of the specified parent window. If the
3568	/// window is mapped, it will automatically be unmapped before reparenting and
3569	/// re-mapped after reparenting. The window is placed in the stacking order on top
3570	/// with respect to sibling windows.
3571	///
3572	/// After reparenting, a ReparentNotify event is generated.
3573	///
3574	/// # Fields
3575	///
3576	/// `window` - The window to reparent.*
3577	/// `parent` - The new parent of the window.*
3578	/// `x` - The X position of the window within its new parent.*
3579	/// `y` - The Y position of the window within its new parent.*
3580	///
3581	/// # Errors
3582	///
3583	/// `Match` - The new parent window is not on the same screen as the old parent window.*
3584	///
3585	/// The new parent window is the specified window or an inferior of the specified window.
3586	///
3587	/// The new parent is InputOnly and the window is not.
3588	///
3589	/// The specified window has a ParentRelative background and the new parent window is not the same depth as the specified window.
3590	/// `Window` - The specified window does not exist.*
3591	///
3592	/// # See
3593	///
3594	/// `ReparentNotify`: event*
3595	/// `MapWindow`: request*
3596	/// `UnmapWindow`: request*
3597	fn reparent_window(&self, window: Window, parent: Window, x: i16, y: i16) -> Result<VoidCookie<'_, Self>, ConnectionError>
3598	{
3599	reparent_window(self, window, parent, x, y)
3600	}
3601	/// Makes a window visible.
3602	///
3603	/// Maps the specified window. This means making the window visible (as long as its
3604	/// parent is visible).
3605	///
3606	/// This MapWindow request will be translated to a MapRequest request if a window
3607	/// manager is running. The window manager then decides to either map the window or
3608	/// not. Set the override-redirect window attribute to true if you want to bypass
3609	/// this mechanism.
3610	///
3611	/// If the window manager decides to map the window (or if no window manager is
3612	/// running), a MapNotify event is generated.
3613	///
3614	/// If the window becomes viewable and no earlier contents for it are remembered,
3615	/// the X server tiles the window with its background. If the window's background
3616	/// is undefined, the existing screen contents are not altered, and the X server
3617	/// generates zero or more Expose events.
3618	///
3619	/// If the window type is InputOutput, an Expose event will be generated when the
3620	/// window becomes visible. The normal response to an Expose event should be to
3621	/// repaint the window.
3622	///
3623	/// # Fields
3624	///
3625	/// `window` - The window to make visible.*
3626	///
3627	/// # Errors
3628	///
3629	/// `Match` - The specified window does not exist.*
3630	///
3631	/// # See
3632	///
3633	/// `MapNotify`: event*
3634	/// `Expose`: event*
3635	/// `UnmapWindow`: request*
3636	fn map_window(&self, window: Window) -> Result<VoidCookie<'_, Self>, ConnectionError>
3637	{
3638	map_window(self, window)
3639	}
3640	fn map_subwindows(&self, window: Window) -> Result<VoidCookie<'_, Self>, ConnectionError>
3641	{
3642	map_subwindows(self, window)
3643	}
3644	/// Makes a window invisible.
3645	///
3646	/// Unmaps the specified window. This means making the window invisible (and all
3647	/// its child windows).
3648	///
3649	/// Unmapping a window leads to the `UnmapNotify` event being generated. Also,
3650	/// `Expose` events are generated for formerly obscured windows.
3651	///
3652	/// # Fields
3653	///
3654	/// `window` - The window to make invisible.*
3655	///
3656	/// # Errors
3657	///
3658	/// `Window` - The specified window does not exist.*
3659	///
3660	/// # See
3661	///
3662	/// `UnmapNotify`: event*
3663	/// `Expose`: event*
3664	/// `MapWindow`: request*
3665	fn unmap_window(&self, window: Window) -> Result<VoidCookie<'_, Self>, ConnectionError>
3666	{
3667	unmap_window(self, window)
3668	}
3669	fn unmap_subwindows(&self, window: Window) -> Result<VoidCookie<'_, Self>, ConnectionError>
3670	{
3671	unmap_subwindows(self, window)
3672	}
3673	/// Configures window attributes.
3674	///
3675	/// Configures a window's size, position, border width and stacking order.
3676	///
3677	/// # Fields
3678	///
3679	/// `window` - The window to configure.*
3680	/// `value_mask` - Bitmask of attributes to change.*
3681	/// `value_list` - New values, corresponding to the attributes in value_mask. The order has to*
3682	/// correspond to the order of possible `value_mask` bits. See the example.
3683	///
3684	/// # Errors
3685	///
3686	/// `Match` - You specified a Sibling without also specifying StackMode or the window is not*
3687	/// actually a Sibling.
3688	/// `Window` - The specified window does not exist. TODO: any other reason?*
3689	/// `Value` - TODO: reasons?*
3690	///
3691	/// # See
3692	///
3693	/// `MapNotify`: event*
3694	/// `Expose`: event*
3695	///
3696	/// # Example
3697	///
3698	/// ```text
3699	/// /*
3700	/// Configures the given window to the left upper corner*
3701	/// with a size of 1024x768 pixels.*
3702	/// *
3703	/// /*
3704	/// void my_example(xcb_connection_t c, xcb_window_t window) {*
3705	/// uint16_t mask = 0;
3706	///
3707	/// mask \|= XCB_CONFIG_WINDOW_X;
3708	/// mask \|= XCB_CONFIG_WINDOW_Y;
3709	/// mask \|= XCB_CONFIG_WINDOW_WIDTH;
3710	/// mask \|= XCB_CONFIG_WINDOW_HEIGHT;
3711	///
3712	/// const uint32_t values[] = {
3713	/// 0, / x /
3714	/// 0, / y /
3715	/// 1024, / width /
3716	/// 768 / height /
3717	/// };
3718	///
3719	/// xcb_configure_window(c, window, mask, values);
3720	/// xcb_flush(c);
3721	/// }
3722	/// ```
3723	fn configure_window<'c, 'input>(&'c self, window: Window, value_list: &'input ConfigureWindowAux) -> Result<VoidCookie<'c, Self>, ConnectionError>
3724	{
3725	configure_window(self, window, value_list)
3726	}
3727	/// Change window stacking order.
3728	///
3729	/// If `direction` is `XCB_CIRCULATE_RAISE_LOWEST`, the lowest mapped child (if
3730	/// any) will be raised to the top of the stack.
3731	///
3732	/// If `direction` is `XCB_CIRCULATE_LOWER_HIGHEST`, the highest mapped child will
3733	/// be lowered to the bottom of the stack.
3734	///
3735	/// # Fields
3736	///
3737	/// `direction` -*
3738	/// `window` - The window to raise/lower (depending on `direction`).*
3739	///
3740	/// # Errors
3741	///
3742	/// `Window` - The specified `window` does not exist.*
3743	/// `Value` - The specified `direction` is invalid.*
3744	fn circulate_window(&self, direction: Circulate, window: Window) -> Result<VoidCookie<'_, Self>, ConnectionError>
3745	{
3746	circulate_window(self, direction, window)
3747	}
3748	/// Get current window geometry.
3749	///
3750	/// Gets the current geometry of the specified drawable (either `Window` or `Pixmap`).
3751	///
3752	/// # Fields
3753	///
3754	/// `drawable` - The drawable (`Window` or `Pixmap`) of which the geometry will be received.*
3755	///
3756	/// # Errors
3757	///
3758	/// `Drawable` - TODO: reasons?*
3759	/// `Window` - TODO: reasons?*
3760	///
3761	/// # See
3762	///
3763	/// `xwininfo`: program*
3764	///
3765	/// # Example
3766	///
3767	/// ```text
3768	/// /*
3769	/// Displays the x and y position of the given window.*
3770	/// *
3771	/// /*
3772	/// void my_example(xcb_connection_t c, xcb_window_t window) {*
3773	/// xcb_get_geometry_cookie_t cookie;
3774	/// xcb_get_geometry_reply_t reply;*
3775	///
3776	/// cookie = xcb_get_geometry(c, window);
3777	/// / ... do other work here if possible ... /
3778	/// if ((reply = xcb_get_geometry_reply(c, cookie, NULL))) {
3779	/// printf("This window is at %d, %d\\n", reply->x, reply->y);
3780	/// }
3781	/// free(reply);
3782	/// }
3783	/// ```
3784	fn get_geometry(&self, drawable: Drawable) -> Result<Cookie<'_, Self, GetGeometryReply>, ConnectionError>
3785	{
3786	get_geometry(self, drawable)
3787	}
3788	/// query the window tree.
3789	///
3790	/// Gets the root window ID, parent window ID and list of children windows for the
3791	/// specified `window`. The children are listed in bottom-to-top stacking order.
3792	///
3793	/// # Fields
3794	///
3795	/// `window` - The `window` to query.*
3796	///
3797	/// # See
3798	///
3799	/// `xwininfo`: program*
3800	///
3801	/// # Example
3802	///
3803	/// ```text
3804	/// /*
3805	/// Displays the root, parent and children of the specified window.*
3806	/// *
3807	/// /*
3808	/// void my_example(xcb_connection_t conn, xcb_window_t window) {*
3809	/// xcb_query_tree_cookie_t cookie;
3810	/// xcb_query_tree_reply_t reply;*
3811	///
3812	/// cookie = xcb_query_tree(conn, window);
3813	/// if ((reply = xcb_query_tree_reply(conn, cookie, NULL))) {
3814	/// printf("root = 0x%08x\\n", reply->root);
3815	/// printf("parent = 0x%08x\\n", reply->parent);
3816	///
3817	/// xcb_window_t children = xcb_query_tree_children(reply);*
3818	/// for (int i = 0; i < xcb_query_tree_children_length(reply); i++)
3819	/// printf("child window = 0x%08x\\n", children[i]);
3820	///
3821	/// free(reply);
3822	/// }
3823	/// }
3824	/// ```
3825	fn query_tree(&self, window: Window) -> Result<Cookie<'_, Self, QueryTreeReply>, ConnectionError>
3826	{
3827	query_tree(self, window)
3828	}
3829	/// Get atom identifier by name.
3830	///
3831	/// Retrieves the identifier (xcb_atom_t TODO) for the atom with the specified
3832	/// name. Atoms are used in protocols like EWMH, for example to store window titles
3833	/// (`_NET_WM_NAME` atom) as property of a window.
3834	///
3835	/// If `only_if_exists` is 0, the atom will be created if it does not already exist.
3836	/// If `only_if_exists` is 1, `XCB_ATOM_NONE` will be returned if the atom does
3837	/// not yet exist.
3838	///
3839	/// # Fields
3840	///
3841	/// `name_len` - The length of the following `name`.*
3842	/// `name` - The name of the atom.*
3843	/// `only_if_exists` - Return a valid atom id only if the atom already exists.*
3844	///
3845	/// # Errors
3846	///
3847	/// `Alloc` - TODO: reasons?*
3848	/// `Value` - A value other than 0 or 1 was specified for `only_if_exists`.*
3849	///
3850	/// # See
3851	///
3852	/// `xlsatoms`: program*
3853	/// `GetAtomName`: request*
3854	///
3855	/// # Example
3856	///
3857	/// ```text
3858	/// /*
3859	/// Resolves the _NET_WM_NAME atom.*
3860	/// *
3861	/// /*
3862	/// void my_example(xcb_connection_t c) {*
3863	/// xcb_intern_atom_cookie_t cookie;
3864	/// xcb_intern_atom_reply_t reply;*
3865	///
3866	/// cookie = xcb_intern_atom(c, 0, strlen("_NET_WM_NAME"), "_NET_WM_NAME");
3867	/// / ... do other work here if possible ... /
3868	/// if ((reply = xcb_intern_atom_reply(c, cookie, NULL))) {
3869	/// printf("The _NET_WM_NAME atom has ID %u\n", reply->atom);
3870	/// free(reply);
3871	/// }
3872	/// }
3873	/// ```
3874	fn intern_atom<'c, 'input>(&'c self, only_if_exists: bool, name: &'input [u8]) -> Result<Cookie<'c, Self, InternAtomReply>, ConnectionError>
3875	{
3876	intern_atom(self, only_if_exists, name)
3877	}
3878	fn get_atom_name(&self, atom: Atom) -> Result<Cookie<'_, Self, GetAtomNameReply>, ConnectionError>
3879	{
3880	get_atom_name(self, atom)
3881	}
3882	/// Changes a window property.
3883	///
3884	/// Sets or updates a property on the specified `window`. Properties are for
3885	/// example the window title (`WM_NAME`) or its minimum size (`WM_NORMAL_HINTS`).
3886	/// Protocols such as EWMH also use properties - for example EWMH defines the
3887	/// window title, encoded as UTF-8 string, in the `_NET_WM_NAME` property.
3888	///
3889	/// # Fields
3890	///
3891	/// `window` - The window whose property you want to change.*
3892	/// `mode` -*
3893	/// `property` - The property you want to change (an atom).*
3894	/// `type` - The type of the property you want to change (an atom).*
3895	/// `format` - Specifies whether the data should be viewed as a list of 8-bit, 16-bit or*
3896	/// 32-bit quantities. Possible values are 8, 16 and 32. This information allows
3897	/// the X server to correctly perform byte-swap operations as necessary.
3898	/// `data_len` - Specifies the number of elements (see `format`).*
3899	/// `data` - The property data.*
3900	///
3901	/// # Errors
3902	///
3903	/// `Match` - TODO: reasons?*
3904	/// `Value` - TODO: reasons?*
3905	/// `Window` - The specified `window` does not exist.*
3906	/// `Atom` - `property` or `type` do not refer to a valid atom.*
3907	/// `Alloc` - The X server could not store the property (no memory?).*
3908	///
3909	/// # See
3910	///
3911	/// `InternAtom`: request*
3912	/// `xprop`: program*
3913	///
3914	/// # Example
3915	///
3916	/// ```text
3917	/// /*
3918	/// Sets the WM_NAME property of the window to "XCB Example".*
3919	/// *
3920	/// /*
3921	/// void my_example(xcb_connection_t conn, xcb_window_t window) {*
3922	/// xcb_change_property(conn,
3923	/// XCB_PROP_MODE_REPLACE,
3924	/// window,
3925	/// XCB_ATOM_WM_NAME,
3926	/// XCB_ATOM_STRING,
3927	/// 8,
3928	/// strlen("XCB Example"),
3929	/// "XCB Example");
3930	/// xcb_flush(conn);
3931	/// }
3932	/// ```
3933	fn change_property<'c, 'input, A, B>(&'c self, mode: PropMode, window: Window, property: A, type_: B, format: u8, data_len: u32, data: &'input [u8]) -> Result<VoidCookie<'c, Self>, ConnectionError>
3934	where
3935	A: Into<Atom>,
3936	B: Into<Atom>,
3937	{
3938	change_property(self, mode, window, property, type_, format, data_len, data)
3939	}
3940	fn delete_property(&self, window: Window, property: Atom) -> Result<VoidCookie<'_, Self>, ConnectionError>
3941	{
3942	delete_property(self, window, property)
3943	}
3944	/// Gets a window property.
3945	///
3946	/// Gets the specified `property` from the specified `window`. Properties are for
3947	/// example the window title (`WM_NAME`) or its minimum size (`WM_NORMAL_HINTS`).
3948	/// Protocols such as EWMH also use properties - for example EWMH defines the
3949	/// window title, encoded as UTF-8 string, in the `_NET_WM_NAME` property.
3950	///
3951	/// TODO: talk about `type`
3952	///
3953	/// TODO: talk about `delete`
3954	///
3955	/// TODO: talk about the offset/length thing. what's a valid use case?
3956	///
3957	/// # Fields
3958	///
3959	/// `window` - The window whose property you want to get.*
3960	/// `delete` - Whether the property should actually be deleted. For deleting a property, the*
3961	/// specified `type` has to match the actual property type.
3962	/// `property` - The property you want to get (an atom).*
3963	/// `type` - The type of the property you want to get (an atom).*
3964	/// `long_offset` - Specifies the offset (in 32-bit multiples) in the specified property where the*
3965	/// data is to be retrieved.
3966	/// `long_length` - Specifies how many 32-bit multiples of data should be retrieved (e.g. if you*
3967	/// set `long_length` to 4, you will receive 16 bytes of data).
3968	///
3969	/// # Errors
3970	///
3971	/// `Window` - The specified `window` does not exist.*
3972	/// `Atom` - `property` or `type` do not refer to a valid atom.*
3973	/// `Value` - The specified `long_offset` is beyond the actual property length (e.g. the*
3974	/// property has a length of 3 bytes and you are setting `long_offset` to 1,
3975	/// resulting in a byte offset of 4).
3976	///
3977	/// # See
3978	///
3979	/// `InternAtom`: request*
3980	/// `xprop`: program*
3981	///
3982	/// # Example
3983	///
3984	/// ```text
3985	/// /*
3986	/// Prints the WM_NAME property of the window.*
3987	/// *
3988	/// /*
3989	/// void my_example(xcb_connection_t c, xcb_window_t window) {*
3990	/// xcb_get_property_cookie_t cookie;
3991	/// xcb_get_property_reply_t reply;*
3992	///
3993	/// / These atoms are predefined in the X11 protocol. /
3994	/// xcb_atom_t property = XCB_ATOM_WM_NAME;
3995	/// xcb_atom_t type = XCB_ATOM_STRING;
3996	///
3997	/// // TODO: a reasonable long_length for WM_NAME?
3998	/// cookie = xcb_get_property(c, 0, window, property, type, 0, 0);
3999	/// if ((reply = xcb_get_property_reply(c, cookie, NULL))) {
4000	/// int len = xcb_get_property_value_length(reply);
4001	/// if (len == 0) {
4002	/// printf("TODO\\n");
4003	/// free(reply);
4004	/// return;
4005	/// }
4006	/// printf("WM_NAME is %.s\\n", len,*
4007	/// (char)xcb_get_property_value(reply));*
4008	/// }
4009	/// free(reply);
4010	/// }
4011	/// ```
4012	fn get_property<A, B>(&self, delete: bool, window: Window, property: A, type_: B, long_offset: u32, long_length: u32) -> Result<Cookie<'_, Self, GetPropertyReply>, ConnectionError>
4013	where
4014	A: Into<Atom>,
4015	B: Into<Atom>,
4016	{
4017	get_property(self, delete, window, property, type_, long_offset, long_length)
4018	}
4019	fn list_properties(&self, window: Window) -> Result<Cookie<'_, Self, ListPropertiesReply>, ConnectionError>
4020	{
4021	list_properties(self, window)
4022	}
4023	/// Sets the owner of a selection.
4024	///
4025	/// Makes `window` the owner of the selection `selection` and updates the
4026	/// last-change time of the specified selection.
4027	///
4028	/// TODO: briefly explain what a selection is.
4029	///
4030	/// # Fields
4031	///
4032	/// `selection` - The selection.*
4033	/// `owner` - The new owner of the selection.*
4034	///
4035	/// The special value `XCB_NONE` means that the selection will have no owner.
4036	/// `time` - Timestamp to avoid race conditions when running X over the network.*
4037	///
4038	/// The selection will not be changed if `time` is earlier than the current
4039	/// last-change time of the `selection` or is later than the current X server time.
4040	/// Otherwise, the last-change time is set to the specified time.
4041	///
4042	/// The special value `XCB_CURRENT_TIME` will be replaced with the current server
4043	/// time.
4044	///
4045	/// # Errors
4046	///
4047	/// `Atom` - `selection` does not refer to a valid atom.*
4048	///
4049	/// # See
4050	///
4051	/// `SetSelectionOwner`: request*
4052	fn set_selection_owner<A, B>(&self, owner: A, selection: Atom, time: B) -> Result<VoidCookie<'_, Self>, ConnectionError>
4053	where
4054	A: Into<Window>,
4055	B: Into<Timestamp>,
4056	{
4057	set_selection_owner(self, owner, selection, time)
4058	}
4059	/// Gets the owner of a selection.
4060	///
4061	/// Gets the owner of the specified selection.
4062	///
4063	/// TODO: briefly explain what a selection is.
4064	///
4065	/// # Fields
4066	///
4067	/// `selection` - The selection.*
4068	///
4069	/// # Errors
4070	///
4071	/// `Atom` - `selection` does not refer to a valid atom.*
4072	///
4073	/// # See
4074	///
4075	/// `SetSelectionOwner`: request*
4076	fn get_selection_owner(&self, selection: Atom) -> Result<Cookie<'_, Self, GetSelectionOwnerReply>, ConnectionError>
4077	{
4078	get_selection_owner(self, selection)
4079	}
4080	fn convert_selection<A, B>(&self, requestor: Window, selection: Atom, target: Atom, property: A, time: B) -> Result<VoidCookie<'_, Self>, ConnectionError>
4081	where
4082	A: Into<Atom>,
4083	B: Into<Timestamp>,
4084	{
4085	convert_selection(self, requestor, selection, target, property, time)
4086	}
4087	/// send an event.
4088	///
4089	/// Identifies the `destination` window, determines which clients should receive
4090	/// the specified event and ignores any active grabs.
4091	///
4092	/// The `event` must be one of the core events or an event defined by an extension,
4093	/// so that the X server can correctly byte-swap the contents as necessary. The
4094	/// contents of `event` are otherwise unaltered and unchecked except for the
4095	/// `send_event` field which is forced to 'true'.
4096	///
4097	/// # Fields
4098	///
4099	/// `destination` - The window to send this event to. Every client which selects any event within*
4100	/// `event_mask` on `destination` will get the event.
4101	///
4102	/// The special value `XCB_SEND_EVENT_DEST_POINTER_WINDOW` refers to the window
4103	/// that contains the mouse pointer.
4104	///
4105	/// The special value `XCB_SEND_EVENT_DEST_ITEM_FOCUS` refers to the window which
4106	/// has the keyboard focus.
4107	/// `event_mask` - Event_mask for determining which clients should receive the specified event.*
4108	/// See `destination` and `propagate`.
4109	/// `propagate` - If `propagate` is true and no clients have selected any event on `destination`,*
4110	/// the destination is replaced with the closest ancestor of `destination` for
4111	/// which some client has selected a type in `event_mask` and for which no
4112	/// intervening window has that type in its do-not-propagate-mask. If no such
4113	/// window exists or if the window is an ancestor of the focus window and
4114	/// `InputFocus` was originally specified as the destination, the event is not sent
4115	/// to any clients. Otherwise, the event is reported to every client selecting on
4116	/// the final destination any of the types specified in `event_mask`.
4117	/// `event` - The event to send to the specified `destination`.*
4118	///
4119	/// # Errors
4120	///
4121	/// `Window` - The specified `destination` window does not exist.*
4122	/// `Value` - The given `event` is neither a core event nor an event defined by an extension.*
4123	///
4124	/// # See
4125	///
4126	/// `ConfigureNotify`: event*
4127	///
4128	/// # Example
4129	///
4130	/// ```text
4131	/// /*
4132	/// Tell the given window that it was configured to a size of 800x600 pixels.*
4133	/// *
4134	/// /*
4135	/// void my_example(xcb_connection_t conn, xcb_window_t window) {*
4136	/// / Every X11 event is 32 bytes long. Therefore, XCB will copy 32 bytes.*
4137	/// In order to properly initialize these bytes, we allocate 32 bytes even*
4138	/// though we only need less for an xcb_configure_notify_event_t /
4139	/// xcb_configure_notify_event_t event = calloc(32, 1);*
4140	///
4141	/// event->event = window;
4142	/// event->window = window;
4143	/// event->response_type = XCB_CONFIGURE_NOTIFY;
4144	///
4145	/// event->x = 0;
4146	/// event->y = 0;
4147	/// event->width = 800;
4148	/// event->height = 600;
4149	///
4150	/// event->border_width = 0;
4151	/// event->above_sibling = XCB_NONE;
4152	/// event->override_redirect = false;
4153	///
4154	/// xcb_send_event(conn, false, window, XCB_EVENT_MASK_STRUCTURE_NOTIFY,
4155	/// (char)event);*
4156	/// xcb_flush(conn);
4157	/// free(event);
4158	/// }
4159	/// ```
4160	fn send_event<A, B>(&self, propagate: bool, destination: A, event_mask: EventMask, event: B) -> Result<VoidCookie<'_, Self>, ConnectionError>
4161	where
4162	A: Into<Window>,
4163	B: Into<[u8; `32`]>,
4164	{
4165	send_event(self, propagate, destination, event_mask, event)
4166	}
4167	/// Grab the pointer.
4168	///
4169	/// Actively grabs control of the pointer. Further pointer events are reported only to the grabbing client. Overrides any active pointer grab by this client.
4170	///
4171	/// # Fields
4172	///
4173	/// `event_mask` - Specifies which pointer events are reported to the client.*
4174	///
4175	/// TODO: which values?
4176	/// `confine_to` - Specifies the window to confine the pointer in (the user will not be able to*
4177	/// move the pointer out of that window).
4178	///
4179	/// The special value `XCB_NONE` means don't confine the pointer.
4180	/// `cursor` - Specifies the cursor that should be displayed or `XCB_NONE` to not change the*
4181	/// cursor.
4182	/// `owner_events` - If 1, the `grab_window` will still get the pointer events. If 0, events are not*
4183	/// reported to the `grab_window`.
4184	/// `grab_window` - Specifies the window on which the pointer should be grabbed.*
4185	/// `time` - The time argument allows you to avoid certain circumstances that come up if*
4186	/// applications take a long time to respond or if there are long network delays.
4187	/// Consider a situation where you have two applications, both of which normally
4188	/// grab the pointer when clicked on. If both applications specify the timestamp
4189	/// from the event, the second application may wake up faster and successfully grab
4190	/// the pointer before the first application. The first application then will get
4191	/// an indication that the other application grabbed the pointer before its request
4192	/// was processed.
4193	///
4194	/// The special value `XCB_CURRENT_TIME` will be replaced with the current server
4195	/// time.
4196	/// `pointer_mode` -*
4197	/// `keyboard_mode` -*
4198	///
4199	/// # Errors
4200	///
4201	/// `Value` - TODO: reasons?*
4202	/// `Window` - The specified `window` does not exist.*
4203	///
4204	/// # See
4205	///
4206	/// `GrabKeyboard`: request*
4207	///
4208	/// # Example
4209	///
4210	/// ```text
4211	/// /*
4212	/// Grabs the pointer actively*
4213	/// *
4214	/// /*
4215	/// void my_example(xcb_connection_t conn, xcb_screen_t screen, xcb_cursor_t cursor) {
4216	/// xcb_grab_pointer_cookie_t cookie;
4217	/// xcb_grab_pointer_reply_t reply;*
4218	///
4219	/// cookie = xcb_grab_pointer(
4220	/// conn,
4221	/// false, / get all pointer events specified by the following mask /
4222	/// screen->root, / grab the root window /
4223	/// XCB_NONE, / which events to let through /
4224	/// XCB_GRAB_MODE_ASYNC, / pointer events should continue as normal /
4225	/// XCB_GRAB_MODE_ASYNC, / keyboard mode /
4226	/// XCB_NONE, / confine_to = in which window should the cursor stay /
4227	/// cursor, / we change the cursor to whatever the user wanted /
4228	/// XCB_CURRENT_TIME
4229	/// );
4230	///
4231	/// if ((reply = xcb_grab_pointer_reply(conn, cookie, NULL))) {
4232	/// if (reply->status == XCB_GRAB_STATUS_SUCCESS)
4233	/// printf("successfully grabbed the pointer\\n");
4234	/// free(reply);
4235	/// }
4236	/// }
4237	/// ```
4238	fn grab_pointer<A, B, C>(&self, owner_events: bool, grab_window: Window, event_mask: EventMask, pointer_mode: GrabMode, keyboard_mode: GrabMode, confine_to: A, cursor: B, time: C) -> Result<Cookie<'_, Self, GrabPointerReply>, ConnectionError>
4239	where
4240	A: Into<Window>,
4241	B: Into<Cursor>,
4242	C: Into<Timestamp>,
4243	{
4244	grab_pointer(self, owner_events, grab_window, event_mask, pointer_mode, keyboard_mode, confine_to, cursor, time)
4245	}
4246	/// release the pointer.
4247	///
4248	/// Releases the pointer and any queued events if you actively grabbed the pointer
4249	/// before using `xcb_grab_pointer`, `xcb_grab_button` or within a normal button
4250	/// press.
4251	///
4252	/// EnterNotify and LeaveNotify events are generated.
4253	///
4254	/// # Fields
4255	///
4256	/// `time` - Timestamp to avoid race conditions when running X over the network.*
4257	///
4258	/// The pointer will not be released if `time` is earlier than the
4259	/// last-pointer-grab time or later than the current X server time.
4260	/// `name_len` - Length (in bytes) of `name`.*
4261	/// `name` - A pattern describing an X core font.*
4262	///
4263	/// # See
4264	///
4265	/// `GrabPointer`: request*
4266	/// `GrabButton`: request*
4267	/// `EnterNotify`: event*
4268	/// `LeaveNotify`: event*
4269	fn ungrab_pointer<A>(&self, time: A) -> Result<VoidCookie<'_, Self>, ConnectionError>
4270	where
4271	A: Into<Timestamp>,
4272	{
4273	ungrab_pointer(self, time)
4274	}
4275	/// Grab pointer button(s).
4276	///
4277	/// This request establishes a passive grab. The pointer is actively grabbed as
4278	/// described in GrabPointer, the last-pointer-grab time is set to the time at
4279	/// which the button was pressed (as transmitted in the ButtonPress event), and the
4280	/// ButtonPress event is reported if all of the following conditions are true:
4281	///
4282	/// The pointer is not grabbed and the specified button is logically pressed when
4283	/// the specified modifier keys are logically down, and no other buttons or
4284	/// modifier keys are logically down.
4285	///
4286	/// The grab-window contains the pointer.
4287	///
4288	/// The confine-to window (if any) is viewable.
4289	///
4290	/// A passive grab on the same button/key combination does not exist on any
4291	/// ancestor of grab-window.
4292	///
4293	/// The interpretation of the remaining arguments is the same as for GrabPointer.
4294	/// The active grab is terminated automatically when the logical state of the
4295	/// pointer has all buttons released, independent of the logical state of modifier
4296	/// keys. Note that the logical state of a device (as seen by means of the
4297	/// protocol) may lag the physical state if device event processing is frozen. This
4298	/// request overrides all previous passive grabs by the same client on the same
4299	/// button/key combinations on the same window. A modifier of AnyModifier is
4300	/// equivalent to issuing the request for all possible modifier combinations
4301	/// (including the combination of no modifiers). It is not required that all
4302	/// specified modifiers have currently assigned keycodes. A button of AnyButton is
4303	/// equivalent to issuing the request for all possible buttons. Otherwise, it is
4304	/// not required that the button specified currently be assigned to a physical
4305	/// button.
4306	///
4307	/// An Access error is generated if some other client has already issued a
4308	/// GrabButton request with the same button/key combination on the same window.
4309	/// When using AnyModifier or AnyButton, the request fails completely (no grabs are
4310	/// established), and an Access error is generated if there is a conflicting grab
4311	/// for any combination. The request has no effect on an active grab.
4312	///
4313	/// # Fields
4314	///
4315	/// `owner_events` - If 1, the `grab_window` will still get the pointer events. If 0, events are not*
4316	/// reported to the `grab_window`.
4317	/// `grab_window` - Specifies the window on which the pointer should be grabbed.*
4318	/// `event_mask` - Specifies which pointer events are reported to the client.*
4319	///
4320	/// TODO: which values?
4321	/// `confine_to` - Specifies the window to confine the pointer in (the user will not be able to*
4322	/// move the pointer out of that window).
4323	///
4324	/// The special value `XCB_NONE` means don't confine the pointer.
4325	/// `cursor` - Specifies the cursor that should be displayed or `XCB_NONE` to not change the*
4326	/// cursor.
4327	/// `modifiers` - The modifiers to grab.*
4328	///
4329	/// Using the special value `XCB_MOD_MASK_ANY` means grab the pointer with all
4330	/// possible modifier combinations.
4331	/// `pointer_mode` -*
4332	/// `keyboard_mode` -*
4333	/// `button` -*
4334	///
4335	/// # Errors
4336	///
4337	/// `Access` - Another client has already issued a GrabButton with the same button/key*
4338	/// combination on the same window.
4339	/// `Value` - TODO: reasons?*
4340	/// `Cursor` - The specified `cursor` does not exist.*
4341	/// `Window` - The specified `window` does not exist.*
4342	fn grab_button<A, B>(&self, owner_events: bool, grab_window: Window, event_mask: EventMask, pointer_mode: GrabMode, keyboard_mode: GrabMode, confine_to: A, cursor: B, button: ButtonIndex, modifiers: ModMask) -> Result<VoidCookie<'_, Self>, ConnectionError>
4343	where
4344	A: Into<Window>,
4345	B: Into<Cursor>,
4346	{
4347	grab_button(self, owner_events, grab_window, event_mask, pointer_mode, keyboard_mode, confine_to, cursor, button, modifiers)
4348	}
4349	fn ungrab_button(&self, button: ButtonIndex, grab_window: Window, modifiers: ModMask) -> Result<VoidCookie<'_, Self>, ConnectionError>
4350	{
4351	ungrab_button(self, button, grab_window, modifiers)
4352	}
4353	fn change_active_pointer_grab<A, B>(&self, cursor: A, time: B, event_mask: EventMask) -> Result<VoidCookie<'_, Self>, ConnectionError>
4354	where
4355	A: Into<Cursor>,
4356	B: Into<Timestamp>,
4357	{
4358	change_active_pointer_grab(self, cursor, time, event_mask)
4359	}
4360	/// Grab the keyboard.
4361	///
4362	/// Actively grabs control of the keyboard and generates FocusIn and FocusOut
4363	/// events. Further key events are reported only to the grabbing client.
4364	///
4365	/// Any active keyboard grab by this client is overridden. If the keyboard is
4366	/// actively grabbed by some other client, `AlreadyGrabbed` is returned. If
4367	/// `grab_window` is not viewable, `GrabNotViewable` is returned. If the keyboard
4368	/// is frozen by an active grab of another client, `GrabFrozen` is returned. If the
4369	/// specified `time` is earlier than the last-keyboard-grab time or later than the
4370	/// current X server time, `GrabInvalidTime` is returned. Otherwise, the
4371	/// last-keyboard-grab time is set to the specified time.
4372	///
4373	/// # Fields
4374	///
4375	/// `owner_events` - If 1, the `grab_window` will still get the pointer events. If 0, events are not*
4376	/// reported to the `grab_window`.
4377	/// `grab_window` - Specifies the window on which the pointer should be grabbed.*
4378	/// `time` - Timestamp to avoid race conditions when running X over the network.*
4379	///
4380	/// The special value `XCB_CURRENT_TIME` will be replaced with the current server
4381	/// time.
4382	/// `pointer_mode` -*
4383	/// `keyboard_mode` -*
4384	///
4385	/// # Errors
4386	///
4387	/// `Value` - TODO: reasons?*
4388	/// `Window` - The specified `window` does not exist.*
4389	///
4390	/// # See
4391	///
4392	/// `GrabPointer`: request*
4393	///
4394	/// # Example
4395	///
4396	/// ```text
4397	/// /*
4398	/// Grabs the keyboard actively*
4399	/// *
4400	/// /*
4401	/// void my_example(xcb_connection_t conn, xcb_screen_t screen) {
4402	/// xcb_grab_keyboard_cookie_t cookie;
4403	/// xcb_grab_keyboard_reply_t reply;*
4404	///
4405	/// cookie = xcb_grab_keyboard(
4406	/// conn,
4407	/// true, / report events /
4408	/// screen->root, / grab the root window /
4409	/// XCB_CURRENT_TIME,
4410	/// XCB_GRAB_MODE_ASYNC, / process events as normal, do not require sync /
4411	/// XCB_GRAB_MODE_ASYNC
4412	/// );
4413	///
4414	/// if ((reply = xcb_grab_keyboard_reply(conn, cookie, NULL))) {
4415	/// if (reply->status == XCB_GRAB_STATUS_SUCCESS)
4416	/// printf("successfully grabbed the keyboard\\n");
4417	///
4418	/// free(reply);
4419	/// }
4420	/// }
4421	/// ```
4422	fn grab_keyboard<A>(&self, owner_events: bool, grab_window: Window, time: A, pointer_mode: GrabMode, keyboard_mode: GrabMode) -> Result<Cookie<'_, Self, GrabKeyboardReply>, ConnectionError>
4423	where
4424	A: Into<Timestamp>,
4425	{
4426	grab_keyboard(self, owner_events, grab_window, time, pointer_mode, keyboard_mode)
4427	}
4428	fn ungrab_keyboard<A>(&self, time: A) -> Result<VoidCookie<'_, Self>, ConnectionError>
4429	where
4430	A: Into<Timestamp>,
4431	{
4432	ungrab_keyboard(self, time)
4433	}
4434	/// Grab keyboard key(s).
4435	///
4436	/// Establishes a passive grab on the keyboard. In the future, the keyboard is
4437	/// actively grabbed (as for `GrabKeyboard`), the last-keyboard-grab time is set to
4438	/// the time at which the key was pressed (as transmitted in the KeyPress event),
4439	/// and the KeyPress event is reported if all of the following conditions are true:
4440	///
4441	/// The keyboard is not grabbed and the specified key (which can itself be a
4442	/// modifier key) is logically pressed when the specified modifier keys are
4443	/// logically down, and no other modifier keys are logically down.
4444	///
4445	/// Either the grab_window is an ancestor of (or is) the focus window, or the
4446	/// grab_window is a descendant of the focus window and contains the pointer.
4447	///
4448	/// A passive grab on the same key combination does not exist on any ancestor of
4449	/// grab_window.
4450	///
4451	/// The interpretation of the remaining arguments is as for XGrabKeyboard. The active grab is terminated
4452	/// automatically when the logical state of the keyboard has the specified key released (independent of the
4453	/// logical state of the modifier keys), at which point a KeyRelease event is reported to the grabbing window.
4454	///
4455	/// Note that the logical state of a device (as seen by client applications) may lag the physical state if
4456	/// device event processing is frozen.
4457	///
4458	/// A modifiers argument of AnyModifier is equivalent to issuing the request for all possible modifier combinations (including the combination of no modifiers). It is not required that all modifiers specified
4459	/// have currently assigned KeyCodes. A keycode argument of AnyKey is equivalent to issuing the request for
4460	/// all possible KeyCodes. Otherwise, the specified keycode must be in the range specified by min_keycode
4461	/// and max_keycode in the connection setup, or a BadValue error results.
4462	///
4463	/// If some other client has issued a XGrabKey with the same key combination on the same window, a BadAccess
4464	/// error results. When using AnyModifier or AnyKey, the request fails completely, and a BadAccess error
4465	/// results (no grabs are established) if there is a conflicting grab for any combination.
4466	///
4467	/// # Fields
4468	///
4469	/// `owner_events` - If 1, the `grab_window` will still get the key events. If 0, events are not*
4470	/// reported to the `grab_window`.
4471	/// `grab_window` - Specifies the window on which the key should be grabbed.*
4472	/// `key` - The keycode of the key to grab.*
4473	///
4474	/// The special value `XCB_GRAB_ANY` means grab any key.
4475	/// `modifiers` - The modifiers to grab.*
4476	///
4477	/// Using the special value `XCB_MOD_MASK_ANY` means grab the key with all
4478	/// possible modifier combinations.
4479	/// `pointer_mode` -*
4480	/// `keyboard_mode` -*
4481	///
4482	/// # Errors
4483	///
4484	/// `Access` - Another client has already issued a GrabKey with the same button/key*
4485	/// combination on the same window.
4486	/// `Value` - The key is not `XCB_GRAB_ANY` and not in the range specified by `min_keycode`*
4487	/// and `max_keycode` in the connection setup.
4488	/// `Window` - The specified `window` does not exist.*
4489	///
4490	/// # See
4491	///
4492	/// `GrabKeyboard`: request*
4493	fn grab_key<A>(&self, owner_events: bool, grab_window: Window, modifiers: ModMask, key: A, pointer_mode: GrabMode, keyboard_mode: GrabMode) -> Result<VoidCookie<'_, Self>, ConnectionError>
4494	where
4495	A: Into<Keycode>,
4496	{
4497	grab_key(self, owner_events, grab_window, modifiers, key, pointer_mode, keyboard_mode)
4498	}
4499	/// release a key combination.
4500	///
4501	/// Releases the key combination on `grab_window` if you grabbed it using
4502	/// `xcb_grab_key` before.
4503	///
4504	/// # Fields
4505	///
4506	/// `key` - The keycode of the specified key combination.*
4507	///
4508	/// Using the special value `XCB_GRAB_ANY` means releasing all possible key codes.
4509	/// `grab_window` - The window on which the grabbed key combination will be released.*
4510	/// `modifiers` - The modifiers of the specified key combination.*
4511	///
4512	/// Using the special value `XCB_MOD_MASK_ANY` means releasing the key combination
4513	/// with every possible modifier combination.
4514	///
4515	/// # Errors
4516	///
4517	/// `Window` - The specified `grab_window` does not exist.*
4518	/// `Value` - TODO: reasons?*
4519	///
4520	/// # See
4521	///
4522	/// `GrabKey`: request*
4523	/// `xev`: program*
4524	fn ungrab_key<A>(&self, key: A, grab_window: Window, modifiers: ModMask) -> Result<VoidCookie<'_, Self>, ConnectionError>
4525	where
4526	A: Into<Keycode>,
4527	{
4528	ungrab_key(self, key, grab_window, modifiers)
4529	}
4530	/// release queued events.
4531	///
4532	/// Releases queued events if the client has caused a device (pointer/keyboard) to
4533	/// freeze due to grabbing it actively. This request has no effect if `time` is
4534	/// earlier than the last-grab time of the most recent active grab for this client
4535	/// or if `time` is later than the current X server time.
4536	///
4537	/// # Fields
4538	///
4539	/// `mode` -*
4540	/// `time` - Timestamp to avoid race conditions when running X over the network.*
4541	///
4542	/// The special value `XCB_CURRENT_TIME` will be replaced with the current server
4543	/// time.
4544	///
4545	/// # Errors
4546	///
4547	/// `Value` - You specified an invalid `mode`.*
4548	fn allow_events<A>(&self, mode: Allow, time: A) -> Result<VoidCookie<'_, Self>, ConnectionError>
4549	where
4550	A: Into<Timestamp>,
4551	{
4552	allow_events(self, mode, time)
4553	}
4554	fn grab_server(&self) -> Result<VoidCookie<'_, Self>, ConnectionError>
4555	{
4556	grab_server(self)
4557	}
4558	fn ungrab_server(&self) -> Result<VoidCookie<'_, Self>, ConnectionError>
4559	{
4560	ungrab_server(self)
4561	}
4562	/// get pointer coordinates.
4563	///
4564	/// Gets the root window the pointer is logically on and the pointer coordinates
4565	/// relative to the root window's origin.
4566	///
4567	/// # Fields
4568	///
4569	/// `window` - A window to check if the pointer is on the same screen as `window` (see the*
4570	/// `same_screen` field in the reply).
4571	///
4572	/// # Errors
4573	///
4574	/// `Window` - The specified `window` does not exist.*
4575	fn query_pointer(&self, window: Window) -> Result<Cookie<'_, Self, QueryPointerReply>, ConnectionError>
4576	{
4577	query_pointer(self, window)
4578	}
4579	fn get_motion_events<A, B>(&self, window: Window, start: A, stop: B) -> Result<Cookie<'_, Self, GetMotionEventsReply>, ConnectionError>
4580	where
4581	A: Into<Timestamp>,
4582	B: Into<Timestamp>,
4583	{
4584	get_motion_events(self, window, start, stop)
4585	}
4586	fn translate_coordinates(&self, src_window: Window, dst_window: Window, src_x: i16, src_y: i16) -> Result<Cookie<'_, Self, TranslateCoordinatesReply>, ConnectionError>
4587	{
4588	translate_coordinates(self, src_window, dst_window, src_x, src_y)
4589	}
4590	/// move mouse pointer.
4591	///
4592	/// Moves the mouse pointer to the specified position.
4593	///
4594	/// If `src_window` is not `XCB_NONE` (TODO), the move will only take place if the
4595	/// pointer is inside `src_window` and within the rectangle specified by (`src_x`,
4596	/// `src_y`, `src_width`, `src_height`). The rectangle coordinates are relative to
4597	/// `src_window`.
4598	///
4599	/// If `dst_window` is not `XCB_NONE` (TODO), the pointer will be moved to the
4600	/// offsets (`dst_x`, `dst_y`) relative to `dst_window`. If `dst_window` is
4601	/// `XCB_NONE` (TODO), the pointer will be moved by the offsets (`dst_x`, `dst_y`)
4602	/// relative to the current position of the pointer.
4603	///
4604	/// # Fields
4605	///
4606	/// `src_window` - If `src_window` is not `XCB_NONE` (TODO), the move will only take place if the*
4607	/// pointer is inside `src_window` and within the rectangle specified by (`src_x`,
4608	/// `src_y`, `src_width`, `src_height`). The rectangle coordinates are relative to
4609	/// `src_window`.
4610	/// `dst_window` - If `dst_window` is not `XCB_NONE` (TODO), the pointer will be moved to the*
4611	/// offsets (`dst_x`, `dst_y`) relative to `dst_window`. If `dst_window` is
4612	/// `XCB_NONE` (TODO), the pointer will be moved by the offsets (`dst_x`, `dst_y`)
4613	/// relative to the current position of the pointer.
4614	///
4615	/// # Errors
4616	///
4617	/// `Window` - TODO: reasons?*
4618	///
4619	/// # See
4620	///
4621	/// `SetInputFocus`: request*
4622	fn warp_pointer<A, B>(&self, src_window: A, dst_window: B, src_x: i16, src_y: i16, src_width: u16, src_height: u16, dst_x: i16, dst_y: i16) -> Result<VoidCookie<'_, Self>, ConnectionError>
4623	where
4624	A: Into<Window>,
4625	B: Into<Window>,
4626	{
4627	warp_pointer(self, src_window, dst_window, src_x, src_y, src_width, src_height, dst_x, dst_y)
4628	}
4629	/// Sets input focus.
4630	///
4631	/// Changes the input focus and the last-focus-change time. If the specified `time`
4632	/// is earlier than the current last-focus-change time, the request is ignored (to
4633	/// avoid race conditions when running X over the network).
4634	///
4635	/// A FocusIn and FocusOut event is generated when focus is changed.
4636	///
4637	/// # Fields
4638	///
4639	/// `focus` - The window to focus. All keyboard events will be reported to this window. The*
4640	/// window must be viewable (TODO), or a `xcb_match_error_t` occurs (TODO).
4641	///
4642	/// If `focus` is `XCB_NONE` (TODO), all keyboard events are
4643	/// discarded until a new focus window is set.
4644	///
4645	/// If `focus` is `XCB_POINTER_ROOT` (TODO), focus is on the root window of the
4646	/// screen on which the pointer is on currently.
4647	/// `time` - Timestamp to avoid race conditions when running X over the network.*
4648	///
4649	/// The special value `XCB_CURRENT_TIME` will be replaced with the current server
4650	/// time.
4651	/// `revert_to` - Specifies what happens when the `focus` window becomes unviewable (if `focus`*
4652	/// is neither `XCB_NONE` nor `XCB_POINTER_ROOT`).
4653	///
4654	/// # Errors
4655	///
4656	/// `Window` - The specified `focus` window does not exist.*
4657	/// `Match` - The specified `focus` window is not viewable.*
4658	/// `Value` - TODO: Reasons?*
4659	///
4660	/// # See
4661	///
4662	/// `FocusIn`: event*
4663	/// `FocusOut`: event*
4664	fn set_input_focus<A, B>(&self, revert_to: InputFocus, focus: A, time: B) -> Result<VoidCookie<'_, Self>, ConnectionError>
4665	where
4666	A: Into<Window>,
4667	B: Into<Timestamp>,
4668	{
4669	set_input_focus(self, revert_to, focus, time)
4670	}
4671	fn get_input_focus(&self) -> Result<Cookie<'_, Self, GetInputFocusReply>, ConnectionError>
4672	{
4673	get_input_focus(self)
4674	}
4675	fn query_keymap(&self) -> Result<Cookie<'_, Self, QueryKeymapReply>, ConnectionError>
4676	{
4677	query_keymap(self)
4678	}
4679	/// opens a font.
4680	///
4681	/// Opens any X core font matching the given `name` (for example "-misc-fixed-").*
4682	///
4683	/// Note that X core fonts are deprecated (but still supported) in favor of
4684	/// client-side rendering using Xft.
4685	///
4686	/// # Fields
4687	///
4688	/// `fid` - The ID with which you will refer to the font, created by `xcb_generate_id`.*
4689	/// `name_len` - Length (in bytes) of `name`.*
4690	/// `name` - A pattern describing an X core font.*
4691	///
4692	/// # Errors
4693	///
4694	/// `Name` - No font matches the given `name`.*
4695	///
4696	/// # See
4697	///
4698	/// `xcb_generate_id`: function*
4699	fn open_font<'c, 'input>(&'c self, fid: Font, name: &'input [u8]) -> Result<VoidCookie<'c, Self>, ConnectionError>
4700	{
4701	open_font(self, fid, name)
4702	}
4703	fn close_font(&self, font: Font) -> Result<VoidCookie<'_, Self>, ConnectionError>
4704	{
4705	close_font(self, font)
4706	}
4707	/// query font metrics.
4708	///
4709	/// Queries information associated with the font.
4710	///
4711	/// # Fields
4712	///
4713	/// `font` - The fontable (Font or Graphics Context) to query.*
4714	fn query_font(&self, font: Fontable) -> Result<Cookie<'_, Self, QueryFontReply>, ConnectionError>
4715	{
4716	query_font(self, font)
4717	}
4718	/// get text extents.
4719	///
4720	/// Query text extents from the X11 server. This request returns the bounding box
4721	/// of the specified 16-bit character string in the specified `font` or the font
4722	/// contained in the specified graphics context.
4723	///
4724	/// `font_ascent` is set to the maximum of the ascent metrics of all characters in
4725	/// the string. `font_descent` is set to the maximum of the descent metrics.
4726	/// `overall_width` is set to the sum of the character-width metrics of all
4727	/// characters in the string. For each character in the string, let W be the sum of
4728	/// the character-width metrics of all characters preceding it in the string. Let L
4729	/// be the left-side-bearing metric of the character plus W. Let R be the
4730	/// right-side-bearing metric of the character plus W. The lbearing member is set
4731	/// to the minimum L of all characters in the string. The rbearing member is set to
4732	/// the maximum R.
4733	///
4734	/// For fonts defined with linear indexing rather than 2-byte matrix indexing, each
4735	/// `xcb_char2b_t` structure is interpreted as a 16-bit number with byte1 as the
4736	/// most significant byte. If the font has no defined default character, undefined
4737	/// characters in the string are taken to have all zero metrics.
4738	///
4739	/// Characters with all zero metrics are ignored. If the font has no defined
4740	/// default_char, the undefined characters in the string are also ignored.
4741	///
4742	/// # Fields
4743	///
4744	/// `font` - The `font` to calculate text extents in. You can also pass a graphics context.*
4745	/// `string_len` - The number of characters in `string`.*
4746	/// `string` - The text to get text extents for.*
4747	///
4748	/// # Errors
4749	///
4750	/// `GContext` - The specified graphics context does not exist.*
4751	/// `Font` - The specified `font` does not exist.*
4752	fn query_text_extents<'c, 'input>(&'c self, font: Fontable, string: &'input [Char2b]) -> Result<Cookie<'c, Self, QueryTextExtentsReply>, ConnectionError>
4753	{
4754	query_text_extents(self, font, string)
4755	}
4756	/// get matching font names.
4757	///
4758	/// Gets a list of available font names which match the given `pattern`.
4759	///
4760	/// # Fields
4761	///
4762	/// `pattern_len` - The length (in bytes) of `pattern`.*
4763	/// `pattern` - A font pattern, for example "-misc-fixed-".
4764	///
4765	/// The asterisk () is a wildcard for any number of characters. The question mark*
4766	/// (?) is a wildcard for a single character. Use of uppercase or lowercase does
4767	/// not matter.
4768	/// `max_names` - The maximum number of fonts to be returned.*
4769	fn list_fonts<'c, 'input>(&'c self, max_names: u16, pattern: &'input [u8]) -> Result<Cookie<'c, Self, ListFontsReply>, ConnectionError>
4770	{
4771	list_fonts(self, max_names, pattern)
4772	}
4773	/// get matching font names and information.
4774	///
4775	/// Gets a list of available font names which match the given `pattern`.
4776	///
4777	/// # Fields
4778	///
4779	/// `pattern_len` - The length (in bytes) of `pattern`.*
4780	/// `pattern` - A font pattern, for example "-misc-fixed-".
4781	///
4782	/// The asterisk () is a wildcard for any number of characters. The question mark*
4783	/// (?) is a wildcard for a single character. Use of uppercase or lowercase does
4784	/// not matter.
4785	/// `max_names` - The maximum number of fonts to be returned.*
4786	fn list_fonts_with_info<'c, 'input>(&'c self, max_names: u16, pattern: &'input [u8]) -> Result<ListFontsWithInfoCookie<'c, Self>, ConnectionError>
4787	{
4788	list_fonts_with_info(self, max_names, pattern)
4789	}
4790	fn set_font_path<'c, 'input>(&'c self, font: &'input [Str]) -> Result<VoidCookie<'c, Self>, ConnectionError>
4791	{
4792	set_font_path(self, font)
4793	}
4794	fn get_font_path(&self) -> Result<Cookie<'_, Self, GetFontPathReply>, ConnectionError>
4795	{
4796	get_font_path(self)
4797	}
4798	/// Creates a pixmap.
4799	///
4800	/// Creates a pixmap. The pixmap can only be used on the same screen as `drawable`
4801	/// is on and only with drawables of the same `depth`.
4802	///
4803	/// # Fields
4804	///
4805	/// `depth` - TODO*
4806	/// `pid` - The ID with which you will refer to the new pixmap, created by*
4807	/// `xcb_generate_id`.
4808	/// `drawable` - Drawable to get the screen from.*
4809	/// `width` - The width of the new pixmap.*
4810	/// `height` - The height of the new pixmap.*
4811	///
4812	/// # Errors
4813	///
4814	/// `Value` - TODO: reasons?*
4815	/// `Drawable` - The specified `drawable` (Window or Pixmap) does not exist.*
4816	/// `Alloc` - The X server could not allocate the requested resources (no memory?).*
4817	///
4818	/// # See
4819	///
4820	/// `xcb_generate_id`: function*
4821	fn create_pixmap(&self, depth: u8, pid: Pixmap, drawable: Drawable, width: u16, height: u16) -> Result<VoidCookie<'_, Self>, ConnectionError>
4822	{
4823	create_pixmap(self, depth, pid, drawable, width, height)
4824	}
4825	/// Destroys a pixmap.
4826	///
4827	/// Deletes the association between the pixmap ID and the pixmap. The pixmap
4828	/// storage will be freed when there are no more references to it.
4829	///
4830	/// # Fields
4831	///
4832	/// `pixmap` - The pixmap to destroy.*
4833	///
4834	/// # Errors
4835	///
4836	/// `Pixmap` - The specified pixmap does not exist.*
4837	fn free_pixmap(&self, pixmap: Pixmap) -> Result<VoidCookie<'_, Self>, ConnectionError>
4838	{
4839	free_pixmap(self, pixmap)
4840	}
4841	/// Creates a graphics context.
4842	///
4843	/// Creates a graphics context. The graphics context can be used with any drawable
4844	/// that has the same root and depth as the specified drawable.
4845	///
4846	/// # Fields
4847	///
4848	/// `cid` - The ID with which you will refer to the graphics context, created by*
4849	/// `xcb_generate_id`.
4850	/// `drawable` - Drawable to get the root/depth from.*
4851	///
4852	/// # Errors
4853	///
4854	/// `Drawable` - The specified `drawable` (Window or Pixmap) does not exist.*
4855	/// `Match` - TODO: reasons?*
4856	/// `Font` - TODO: reasons?*
4857	/// `Pixmap` - TODO: reasons?*
4858	/// `Value` - TODO: reasons?*
4859	/// `Alloc` - The X server could not allocate the requested resources (no memory?).*
4860	///
4861	/// # See
4862	///
4863	/// `xcb_generate_id`: function*
4864	fn create_gc<'c, 'input>(&'c self, cid: Gcontext, drawable: Drawable, value_list: &'input CreateGCAux) -> Result<VoidCookie<'c, Self>, ConnectionError>
4865	{
4866	create_gc(self, cid, drawable, value_list)
4867	}
4868	/// change graphics context components.
4869	///
4870	/// Changes the components specified by `value_mask` for the specified graphics context.
4871	///
4872	/// # Fields
4873	///
4874	/// `gc` - The graphics context to change.*
4875	/// `value_mask` -*
4876	/// `value_list` - Values for each of the components specified in the bitmask `value_mask`. The*
4877	/// order has to correspond to the order of possible `value_mask` bits. See the
4878	/// example.
4879	///
4880	/// # Errors
4881	///
4882	/// `Font` - TODO: reasons?*
4883	/// `GContext` - TODO: reasons?*
4884	/// `Match` - TODO: reasons?*
4885	/// `Pixmap` - TODO: reasons?*
4886	/// `Value` - TODO: reasons?*
4887	/// `Alloc` - The X server could not allocate the requested resources (no memory?).*
4888	///
4889	/// # Example
4890	///
4891	/// ```text
4892	/// /*
4893	/// Changes the foreground color component of the specified graphics context.*
4894	/// *
4895	/// /*
4896	/// void my_example(xcb_connection_t conn, xcb_gcontext_t gc, uint32_t fg, uint32_t bg) {*
4897	/// / C99 allows us to use a compact way of changing a single component: /
4898	/// xcb_change_gc(conn, gc, XCB_GC_FOREGROUND, (uint32_t[]){ fg });
4899	///
4900	/// / The more explicit way. Beware that the order of values is important! /
4901	/// uint32_t mask = 0;
4902	/// mask \|= XCB_GC_FOREGROUND;
4903	/// mask \|= XCB_GC_BACKGROUND;
4904	///
4905	/// uint32_t values[] = {
4906	/// fg,
4907	/// bg
4908	/// };
4909	/// xcb_change_gc(conn, gc, mask, values);
4910	/// xcb_flush(conn);
4911	/// }
4912	/// ```
4913	fn change_gc<'c, 'input>(&'c self, gc: Gcontext, value_list: &'input ChangeGCAux) -> Result<VoidCookie<'c, Self>, ConnectionError>
4914	{
4915	change_gc(self, gc, value_list)
4916	}
4917	fn copy_gc(&self, src_gc: Gcontext, dst_gc: Gcontext, value_mask: GC) -> Result<VoidCookie<'_, Self>, ConnectionError>
4918	{
4919	copy_gc(self, src_gc, dst_gc, value_mask)
4920	}
4921	fn set_dashes<'c, 'input>(&'c self, gc: Gcontext, dash_offset: u16, dashes: &'input [u8]) -> Result<VoidCookie<'c, Self>, ConnectionError>
4922	{
4923	set_dashes(self, gc, dash_offset, dashes)
4924	}
4925	fn set_clip_rectangles<'c, 'input>(&'c self, ordering: ClipOrdering, gc: Gcontext, clip_x_origin: i16, clip_y_origin: i16, rectangles: &'input [Rectangle]) -> Result<VoidCookie<'c, Self>, ConnectionError>
4926	{
4927	set_clip_rectangles(self, ordering, gc, clip_x_origin, clip_y_origin, rectangles)
4928	}
4929	/// Destroys a graphics context.
4930	///
4931	/// Destroys the specified `gc` and all associated storage.
4932	///
4933	/// # Fields
4934	///
4935	/// `gc` - The graphics context to destroy.*
4936	///
4937	/// # Errors
4938	///
4939	/// `GContext` - The specified graphics context does not exist.*
4940	fn free_gc(&self, gc: Gcontext) -> Result<VoidCookie<'_, Self>, ConnectionError>
4941	{
4942	free_gc(self, gc)
4943	}
4944	fn clear_area(&self, exposures: bool, window: Window, x: i16, y: i16, width: u16, height: u16) -> Result<VoidCookie<'_, Self>, ConnectionError>
4945	{
4946	clear_area(self, exposures, window, x, y, width, height)
4947	}
4948	/// copy areas.
4949	///
4950	/// Copies the specified rectangle from `src_drawable` to `dst_drawable`.
4951	///
4952	/// # Fields
4953	///
4954	/// `dst_drawable` - The destination drawable (Window or Pixmap).*
4955	/// `src_drawable` - The source drawable (Window or Pixmap).*
4956	/// `gc` - The graphics context to use.*
4957	/// `src_x` - The source X coordinate.*
4958	/// `src_y` - The source Y coordinate.*
4959	/// `dst_x` - The destination X coordinate.*
4960	/// `dst_y` - The destination Y coordinate.*
4961	/// `width` - The width of the area to copy (in pixels).*
4962	/// `height` - The height of the area to copy (in pixels).*
4963	///
4964	/// # Errors
4965	///
4966	/// `Drawable` - The specified `drawable` (Window or Pixmap) does not exist.*
4967	/// `GContext` - The specified graphics context does not exist.*
4968	/// `Match` - `src_drawable` has a different root or depth than `dst_drawable`.*
4969	fn copy_area(&self, src_drawable: Drawable, dst_drawable: Drawable, gc: Gcontext, src_x: i16, src_y: i16, dst_x: i16, dst_y: i16, width: u16, height: u16) -> Result<VoidCookie<'_, Self>, ConnectionError>
4970	{
4971	copy_area(self, src_drawable, dst_drawable, gc, src_x, src_y, dst_x, dst_y, width, height)
4972	}
4973	fn copy_plane(&self, src_drawable: Drawable, dst_drawable: Drawable, gc: Gcontext, src_x: i16, src_y: i16, dst_x: i16, dst_y: i16, width: u16, height: u16, bit_plane: u32) -> Result<VoidCookie<'_, Self>, ConnectionError>
4974	{
4975	copy_plane(self, src_drawable, dst_drawable, gc, src_x, src_y, dst_x, dst_y, width, height, bit_plane)
4976	}
4977	fn poly_point<'c, 'input>(&'c self, coordinate_mode: CoordMode, drawable: Drawable, gc: Gcontext, points: &'input [Point]) -> Result<VoidCookie<'c, Self>, ConnectionError>
4978	{
4979	poly_point(self, coordinate_mode, drawable, gc, points)
4980	}
4981	/// draw lines.
4982	///
4983	/// Draws `points_len`-1 lines between each pair of points (point[i], point[i+1])
4984	/// in the `points` array. The lines are drawn in the order listed in the array.
4985	/// They join correctly at all intermediate points, and if the first and last
4986	/// points coincide, the first and last lines also join correctly. For any given
4987	/// line, a pixel is not drawn more than once. If thin (zero line-width) lines
4988	/// intersect, the intersecting pixels are drawn multiple times. If wide lines
4989	/// intersect, the intersecting pixels are drawn only once, as though the entire
4990	/// request were a single, filled shape.
4991	///
4992	/// # Fields
4993	///
4994	/// `drawable` - The drawable to draw the line(s) on.*
4995	/// `gc` - The graphics context to use.*
4996	/// `points_len` - The number of `xcb_point_t` structures in `points`.*
4997	/// `points` - An array of points.*
4998	/// `coordinate_mode` -*
4999	///
5000	/// # Errors
5001	///
5002	/// `Drawable` - TODO: reasons?*
5003	/// `GContext` - TODO: reasons?*
5004	/// `Match` - TODO: reasons?*
5005	/// `Value` - TODO: reasons?*
5006	///
5007	/// # Example
5008	///
5009	/// ```text
5010	/// /*
5011	/// Draw a straight line.*
5012	/// *
5013	/// /*
5014	/// void my_example(xcb_connection_t conn, xcb_drawable_t drawable, xcb_gcontext_t gc) {*
5015	/// xcb_poly_line(conn, XCB_COORD_MODE_ORIGIN, drawable, gc, 2,
5016	/// (xcb_point_t[]) { {10, 10}, {100, 10} });
5017	/// xcb_flush(conn);
5018	/// }
5019	/// ```
5020	fn poly_line<'c, 'input>(&'c self, coordinate_mode: CoordMode, drawable: Drawable, gc: Gcontext, points: &'input [Point]) -> Result<VoidCookie<'c, Self>, ConnectionError>
5021	{
5022	poly_line(self, coordinate_mode, drawable, gc, points)
5023	}
5024	/// draw lines.
5025	///
5026	/// Draws multiple, unconnected lines. For each segment, a line is drawn between
5027	/// (x1, y1) and (x2, y2). The lines are drawn in the order listed in the array of
5028	/// `xcb_segment_t` structures and does not perform joining at coincident
5029	/// endpoints. For any given line, a pixel is not drawn more than once. If lines
5030	/// intersect, the intersecting pixels are drawn multiple times.
5031	///
5032	/// TODO: include the xcb_segment_t data structure
5033	///
5034	/// TODO: an example
5035	///
5036	/// # Fields
5037	///
5038	/// `drawable` - A drawable (Window or Pixmap) to draw on.*
5039	/// `gc` - The graphics context to use.*
5040	///
5041	/// TODO: document which attributes of a gc are used
5042	/// `segments_len` - The number of `xcb_segment_t` structures in `segments`.*
5043	/// `segments` - An array of `xcb_segment_t` structures.*
5044	///
5045	/// # Errors
5046	///
5047	/// `Drawable` - The specified `drawable` does not exist.*
5048	/// `GContext` - The specified `gc` does not exist.*
5049	/// `Match` - TODO: reasons?*
5050	fn poly_segment<'c, 'input>(&'c self, drawable: Drawable, gc: Gcontext, segments: &'input [Segment]) -> Result<VoidCookie<'c, Self>, ConnectionError>
5051	{
5052	poly_segment(self, drawable, gc, segments)
5053	}
5054	fn poly_rectangle<'c, 'input>(&'c self, drawable: Drawable, gc: Gcontext, rectangles: &'input [Rectangle]) -> Result<VoidCookie<'c, Self>, ConnectionError>
5055	{
5056	poly_rectangle(self, drawable, gc, rectangles)
5057	}
5058	fn poly_arc<'c, 'input>(&'c self, drawable: Drawable, gc: Gcontext, arcs: &'input [Arc]) -> Result<VoidCookie<'c, Self>, ConnectionError>
5059	{
5060	poly_arc(self, drawable, gc, arcs)
5061	}
5062	fn fill_poly<'c, 'input>(&'c self, drawable: Drawable, gc: Gcontext, shape: PolyShape, coordinate_mode: CoordMode, points: &'input [Point]) -> Result<VoidCookie<'c, Self>, ConnectionError>
5063	{
5064	fill_poly(self, drawable, gc, shape, coordinate_mode, points)
5065	}
5066	/// Fills rectangles.
5067	///
5068	/// Fills the specified rectangle(s) in the order listed in the array. For any
5069	/// given rectangle, each pixel is not drawn more than once. If rectangles
5070	/// intersect, the intersecting pixels are drawn multiple times.
5071	///
5072	/// # Fields
5073	///
5074	/// `drawable` - The drawable (Window or Pixmap) to draw on.*
5075	/// `gc` - The graphics context to use.*
5076	///
5077	/// The following graphics context components are used: function, plane-mask,
5078	/// fill-style, subwindow-mode, clip-x-origin, clip-y-origin, and clip-mask.
5079	///
5080	/// The following graphics context mode-dependent components are used:
5081	/// foreground, background, tile, stipple, tile-stipple-x-origin, and
5082	/// tile-stipple-y-origin.
5083	/// `rectangles_len` - The number of `xcb_rectangle_t` structures in `rectangles`.*
5084	/// `rectangles` - The rectangles to fill.*
5085	///
5086	/// # Errors
5087	///
5088	/// `Drawable` - The specified `drawable` (Window or Pixmap) does not exist.*
5089	/// `GContext` - The specified graphics context does not exist.*
5090	/// `Match` - TODO: reasons?*
5091	fn poly_fill_rectangle<'c, 'input>(&'c self, drawable: Drawable, gc: Gcontext, rectangles: &'input [Rectangle]) -> Result<VoidCookie<'c, Self>, ConnectionError>
5092	{
5093	poly_fill_rectangle(self, drawable, gc, rectangles)
5094	}
5095	fn poly_fill_arc<'c, 'input>(&'c self, drawable: Drawable, gc: Gcontext, arcs: &'input [Arc]) -> Result<VoidCookie<'c, Self>, ConnectionError>
5096	{
5097	poly_fill_arc(self, drawable, gc, arcs)
5098	}
5099	fn put_image<'c, 'input>(&'c self, format: ImageFormat, drawable: Drawable, gc: Gcontext, width: u16, height: u16, dst_x: i16, dst_y: i16, left_pad: u8, depth: u8, data: &'input [u8]) -> Result<VoidCookie<'c, Self>, ConnectionError>
5100	{
5101	put_image(self, format, drawable, gc, width, height, dst_x, dst_y, left_pad, depth, data)
5102	}
5103	fn get_image(&self, format: ImageFormat, drawable: Drawable, x: i16, y: i16, width: u16, height: u16, plane_mask: u32) -> Result<Cookie<'_, Self, GetImageReply>, ConnectionError>
5104	{
5105	get_image(self, format, drawable, x, y, width, height, plane_mask)
5106	}
5107	fn poly_text8<'c, 'input>(&'c self, drawable: Drawable, gc: Gcontext, x: i16, y: i16, items: &'input [u8]) -> Result<VoidCookie<'c, Self>, ConnectionError>
5108	{
5109	poly_text8(self, drawable, gc, x, y, items)
5110	}
5111	fn poly_text16<'c, 'input>(&'c self, drawable: Drawable, gc: Gcontext, x: i16, y: i16, items: &'input [u8]) -> Result<VoidCookie<'c, Self>, ConnectionError>
5112	{
5113	poly_text16(self, drawable, gc, x, y, items)
5114	}
5115	/// Draws text.
5116	///
5117	/// Fills the destination rectangle with the background pixel from `gc`, then
5118	/// paints the text with the foreground pixel from `gc`. The upper-left corner of
5119	/// the filled rectangle is at [x, y - font-ascent]. The width is overall-width,
5120	/// the height is font-ascent + font-descent. The overall-width, font-ascent and
5121	/// font-descent are as returned by `xcb_query_text_extents` (TODO).
5122	///
5123	/// Note that using X core fonts is deprecated (but still supported) in favor of
5124	/// client-side rendering using Xft.
5125	///
5126	/// # Fields
5127	///
5128	/// `drawable` - The drawable (Window or Pixmap) to draw text on.*
5129	/// `string_len` - The length of the `string`. Note that this parameter limited by 255 due to*
5130	/// using 8 bits!
5131	/// `string` - The string to draw. Only the first 255 characters are relevant due to the data*
5132	/// type of `string_len`.
5133	/// `x` - The x coordinate of the first character, relative to the origin of `drawable`.*
5134	/// `y` - The y coordinate of the first character, relative to the origin of `drawable`.*
5135	/// `gc` - The graphics context to use.*
5136	///
5137	/// The following graphics context components are used: plane-mask, foreground,
5138	/// background, font, subwindow-mode, clip-x-origin, clip-y-origin, and clip-mask.
5139	///
5140	/// # Errors
5141	///
5142	/// `Drawable` - The specified `drawable` (Window or Pixmap) does not exist.*
5143	/// `GContext` - The specified graphics context does not exist.*
5144	/// `Match` - TODO: reasons?*
5145	///
5146	/// # See
5147	///
5148	/// `ImageText16`: request*
5149	fn image_text8<'c, 'input>(&'c self, drawable: Drawable, gc: Gcontext, x: i16, y: i16, string: &'input [u8]) -> Result<VoidCookie<'c, Self>, ConnectionError>
5150	{
5151	image_text8(self, drawable, gc, x, y, string)
5152	}
5153	/// Draws text.
5154	///
5155	/// Fills the destination rectangle with the background pixel from `gc`, then
5156	/// paints the text with the foreground pixel from `gc`. The upper-left corner of
5157	/// the filled rectangle is at [x, y - font-ascent]. The width is overall-width,
5158	/// the height is font-ascent + font-descent. The overall-width, font-ascent and
5159	/// font-descent are as returned by `xcb_query_text_extents` (TODO).
5160	///
5161	/// Note that using X core fonts is deprecated (but still supported) in favor of
5162	/// client-side rendering using Xft.
5163	///
5164	/// # Fields
5165	///
5166	/// `drawable` - The drawable (Window or Pixmap) to draw text on.*
5167	/// `string_len` - The length of the `string` in characters. Note that this parameter limited by*
5168	/// 255 due to using 8 bits!
5169	/// `string` - The string to draw. Only the first 255 characters are relevant due to the data*
5170	/// type of `string_len`. Every character uses 2 bytes (hence the 16 in this
5171	/// request's name).
5172	/// `x` - The x coordinate of the first character, relative to the origin of `drawable`.*
5173	/// `y` - The y coordinate of the first character, relative to the origin of `drawable`.*
5174	/// `gc` - The graphics context to use.*
5175	///
5176	/// The following graphics context components are used: plane-mask, foreground,
5177	/// background, font, subwindow-mode, clip-x-origin, clip-y-origin, and clip-mask.
5178	///
5179	/// # Errors
5180	///
5181	/// `Drawable` - The specified `drawable` (Window or Pixmap) does not exist.*
5182	/// `GContext` - The specified graphics context does not exist.*
5183	/// `Match` - TODO: reasons?*
5184	///
5185	/// # See
5186	///
5187	/// `ImageText8`: request*
5188	fn image_text16<'c, 'input>(&'c self, drawable: Drawable, gc: Gcontext, x: i16, y: i16, string: &'input [Char2b]) -> Result<VoidCookie<'c, Self>, ConnectionError>
5189	{
5190	image_text16(self, drawable, gc, x, y, string)
5191	}
5192	fn create_colormap(&self, alloc: ColormapAlloc, mid: Colormap, window: Window, visual: Visualid) -> Result<VoidCookie<'_, Self>, ConnectionError>
5193	{
5194	create_colormap(self, alloc, mid, window, visual)
5195	}
5196	fn free_colormap(&self, cmap: Colormap) -> Result<VoidCookie<'_, Self>, ConnectionError>
5197	{
5198	free_colormap(self, cmap)
5199	}
5200	fn copy_colormap_and_free(&self, mid: Colormap, src_cmap: Colormap) -> Result<VoidCookie<'_, Self>, ConnectionError>
5201	{
5202	copy_colormap_and_free(self, mid, src_cmap)
5203	}
5204	fn install_colormap(&self, cmap: Colormap) -> Result<VoidCookie<'_, Self>, ConnectionError>
5205	{
5206	install_colormap(self, cmap)
5207	}
5208	fn uninstall_colormap(&self, cmap: Colormap) -> Result<VoidCookie<'_, Self>, ConnectionError>
5209	{
5210	uninstall_colormap(self, cmap)
5211	}
5212	fn list_installed_colormaps(&self, window: Window) -> Result<Cookie<'_, Self, ListInstalledColormapsReply>, ConnectionError>
5213	{
5214	list_installed_colormaps(self, window)
5215	}
5216	/// Allocate a color.
5217	///
5218	/// Allocates a read-only colormap entry corresponding to the closest RGB value
5219	/// supported by the hardware. If you are using TrueColor, you can take a shortcut
5220	/// and directly calculate the color pixel value to avoid the round trip. But, for
5221	/// example, on 16-bit color setups (VNC), you can easily get the closest supported
5222	/// RGB value to the RGB value you are specifying.
5223	///
5224	/// # Fields
5225	///
5226	/// `cmap` - TODO*
5227	/// `red` - The red value of your color.*
5228	/// `green` - The green value of your color.*
5229	/// `blue` - The blue value of your color.*
5230	///
5231	/// # Errors
5232	///
5233	/// `Colormap` - The specified colormap `cmap` does not exist.*
5234	fn alloc_color(&self, cmap: Colormap, red: u16, green: u16, blue: u16) -> Result<Cookie<'_, Self, AllocColorReply>, ConnectionError>
5235	{
5236	alloc_color(self, cmap, red, green, blue)
5237	}
5238	fn alloc_named_color<'c, 'input>(&'c self, cmap: Colormap, name: &'input [u8]) -> Result<Cookie<'c, Self, AllocNamedColorReply>, ConnectionError>
5239	{
5240	alloc_named_color(self, cmap, name)
5241	}
5242	fn alloc_color_cells(&self, contiguous: bool, cmap: Colormap, colors: u16, planes: u16) -> Result<Cookie<'_, Self, AllocColorCellsReply>, ConnectionError>
5243	{
5244	alloc_color_cells(self, contiguous, cmap, colors, planes)
5245	}
5246	fn alloc_color_planes(&self, contiguous: bool, cmap: Colormap, colors: u16, reds: u16, greens: u16, blues: u16) -> Result<Cookie<'_, Self, AllocColorPlanesReply>, ConnectionError>
5247	{
5248	alloc_color_planes(self, contiguous, cmap, colors, reds, greens, blues)
5249	}
5250	fn free_colors<'c, 'input>(&'c self, cmap: Colormap, plane_mask: u32, pixels: &'input [u32]) -> Result<VoidCookie<'c, Self>, ConnectionError>
5251	{
5252	free_colors(self, cmap, plane_mask, pixels)
5253	}
5254	fn store_colors<'c, 'input>(&'c self, cmap: Colormap, items: &'input [Coloritem]) -> Result<VoidCookie<'c, Self>, ConnectionError>
5255	{
5256	store_colors(self, cmap, items)
5257	}
5258	fn store_named_color<'c, 'input>(&'c self, flags: ColorFlag, cmap: Colormap, pixel: u32, name: &'input [u8]) -> Result<VoidCookie<'c, Self>, ConnectionError>
5259	{
5260	store_named_color(self, flags, cmap, pixel, name)
5261	}
5262	fn query_colors<'c, 'input>(&'c self, cmap: Colormap, pixels: &'input [u32]) -> Result<Cookie<'c, Self, QueryColorsReply>, ConnectionError>
5263	{
5264	query_colors(self, cmap, pixels)
5265	}
5266	fn lookup_color<'c, 'input>(&'c self, cmap: Colormap, name: &'input [u8]) -> Result<Cookie<'c, Self, LookupColorReply>, ConnectionError>
5267	{
5268	lookup_color(self, cmap, name)
5269	}
5270	fn create_cursor<A>(&self, cid: Cursor, source: Pixmap, mask: A, fore_red: u16, fore_green: u16, fore_blue: u16, back_red: u16, back_green: u16, back_blue: u16, x: u16, y: u16) -> Result<VoidCookie<'_, Self>, ConnectionError>
5271	where
5272	A: Into<Pixmap>,
5273	{
5274	create_cursor(self, cid, source, mask, fore_red, fore_green, fore_blue, back_red, back_green, back_blue, x, y)
5275	}
5276	/// create cursor.
5277	///
5278	/// Creates a cursor from a font glyph. X provides a set of standard cursor shapes
5279	/// in a special font named cursor. Applications are encouraged to use this
5280	/// interface for their cursors because the font can be customized for the
5281	/// individual display type.
5282	///
5283	/// All pixels which are set to 1 in the source will use the foreground color (as
5284	/// specified by `fore_red`, `fore_green` and `fore_blue`). All pixels set to 0
5285	/// will use the background color (as specified by `back_red`, `back_green` and
5286	/// `back_blue`).
5287	///
5288	/// # Fields
5289	///
5290	/// `cid` - The ID with which you will refer to the cursor, created by `xcb_generate_id`.*
5291	/// `source_font` - In which font to look for the cursor glyph.*
5292	/// `mask_font` - In which font to look for the mask glyph.*
5293	/// `source_char` - The glyph of `source_font` to use.*
5294	/// `mask_char` - The glyph of `mask_font` to use as a mask: Pixels which are set to 1 define*
5295	/// which source pixels are displayed. All pixels which are set to 0 are not
5296	/// displayed.
5297	/// `fore_red` - The red value of the foreground color.*
5298	/// `fore_green` - The green value of the foreground color.*
5299	/// `fore_blue` - The blue value of the foreground color.*
5300	/// `back_red` - The red value of the background color.*
5301	/// `back_green` - The green value of the background color.*
5302	/// `back_blue` - The blue value of the background color.*
5303	///
5304	/// # Errors
5305	///
5306	/// `Alloc` - The X server could not allocate the requested resources (no memory?).*
5307	/// `Font` - The specified `source_font` or `mask_font` does not exist.*
5308	/// `Value` - Either `source_char` or `mask_char` are not defined in `source_font` or `mask_font`, respectively.*
5309	fn create_glyph_cursor<A>(&self, cid: Cursor, source_font: Font, mask_font: A, source_char: u16, mask_char: u16, fore_red: u16, fore_green: u16, fore_blue: u16, back_red: u16, back_green: u16, back_blue: u16) -> Result<VoidCookie<'_, Self>, ConnectionError>
5310	where
5311	A: Into<Font>,
5312	{
5313	create_glyph_cursor(self, cid, source_font, mask_font, source_char, mask_char, fore_red, fore_green, fore_blue, back_red, back_green, back_blue)
5314	}
5315	/// Deletes a cursor.
5316	///
5317	/// Deletes the association between the cursor resource ID and the specified
5318	/// cursor. The cursor is freed when no other resource references it.
5319	///
5320	/// # Fields
5321	///
5322	/// `cursor` - The cursor to destroy.*
5323	///
5324	/// # Errors
5325	///
5326	/// `Cursor` - The specified cursor does not exist.*
5327	fn free_cursor(&self, cursor: Cursor) -> Result<VoidCookie<'_, Self>, ConnectionError>
5328	{
5329	free_cursor(self, cursor)
5330	}
5331	fn recolor_cursor(&self, cursor: Cursor, fore_red: u16, fore_green: u16, fore_blue: u16, back_red: u16, back_green: u16, back_blue: u16) -> Result<VoidCookie<'_, Self>, ConnectionError>
5332	{
5333	recolor_cursor(self, cursor, fore_red, fore_green, fore_blue, back_red, back_green, back_blue)
5334	}
5335	fn query_best_size(&self, class: QueryShapeOf, drawable: Drawable, width: u16, height: u16) -> Result<Cookie<'_, Self, QueryBestSizeReply>, ConnectionError>
5336	{
5337	query_best_size(self, class, drawable, width, height)
5338	}
5339	/// check if extension is present.
5340	///
5341	/// Determines if the specified extension is present on this X11 server.
5342	///
5343	/// Every extension has a unique `major_opcode` to identify requests, the minor
5344	/// opcodes and request formats are extension-specific. If the extension provides
5345	/// events and errors, the `first_event` and `first_error` fields in the reply are
5346	/// set accordingly.
5347	///
5348	/// There should rarely be a need to use this request directly, XCB provides the
5349	/// `xcb_get_extension_data` function instead.
5350	///
5351	/// # Fields
5352	///
5353	/// `name_len` - The length of `name` in bytes.*
5354	/// `name` - The name of the extension to query, for example "RANDR". This is case*
5355	/// sensitive!
5356	///
5357	/// # See
5358	///
5359	/// `xdpyinfo`: program*
5360	/// `xcb_get_extension_data`: function*
5361	fn query_extension<'c, 'input>(&'c self, name: &'input [u8]) -> Result<Cookie<'c, Self, QueryExtensionReply>, ConnectionError>
5362	{
5363	query_extension(self, name)
5364	}
5365	fn list_extensions(&self) -> Result<Cookie<'_, Self, ListExtensionsReply>, ConnectionError>
5366	{
5367	list_extensions(self)
5368	}
5369	fn change_keyboard_mapping<'c, 'input>(&'c self, keycode_count: u8, first_keycode: Keycode, keysyms_per_keycode: u8, keysyms: &'input [Keysym]) -> Result<VoidCookie<'c, Self>, ConnectionError>
5370	{
5371	change_keyboard_mapping(self, keycode_count, first_keycode, keysyms_per_keycode, keysyms)
5372	}
5373	fn get_keyboard_mapping(&self, first_keycode: Keycode, count: u8) -> Result<Cookie<'_, Self, GetKeyboardMappingReply>, ConnectionError>
5374	{
5375	get_keyboard_mapping(self, first_keycode, count)
5376	}
5377	fn change_keyboard_control<'c, 'input>(&'c self, value_list: &'input ChangeKeyboardControlAux) -> Result<VoidCookie<'c, Self>, ConnectionError>
5378	{
5379	change_keyboard_control(self, value_list)
5380	}
5381	fn get_keyboard_control(&self) -> Result<Cookie<'_, Self, GetKeyboardControlReply>, ConnectionError>
5382	{
5383	get_keyboard_control(self)
5384	}
5385	fn bell(&self, percent: i8) -> Result<VoidCookie<'_, Self>, ConnectionError>
5386	{
5387	bell(self, percent)
5388	}
5389	fn change_pointer_control(&self, acceleration_numerator: i16, acceleration_denominator: i16, threshold: i16, do_acceleration: bool, do_threshold: bool) -> Result<VoidCookie<'_, Self>, ConnectionError>
5390	{
5391	change_pointer_control(self, acceleration_numerator, acceleration_denominator, threshold, do_acceleration, do_threshold)
5392	}
5393	fn get_pointer_control(&self) -> Result<Cookie<'_, Self, GetPointerControlReply>, ConnectionError>
5394	{
5395	get_pointer_control(self)
5396	}
5397	fn set_screen_saver(&self, timeout: i16, interval: i16, prefer_blanking: Blanking, allow_exposures: Exposures) -> Result<VoidCookie<'_, Self>, ConnectionError>
5398	{
5399	set_screen_saver(self, timeout, interval, prefer_blanking, allow_exposures)
5400	}
5401	fn get_screen_saver(&self) -> Result<Cookie<'_, Self, GetScreenSaverReply>, ConnectionError>
5402	{
5403	get_screen_saver(self)
5404	}
5405	fn change_hosts<'c, 'input>(&'c self, mode: HostMode, family: Family, address: &'input [u8]) -> Result<VoidCookie<'c, Self>, ConnectionError>
5406	{
5407	change_hosts(self, mode, family, address)
5408	}
5409	fn list_hosts(&self) -> Result<Cookie<'_, Self, ListHostsReply>, ConnectionError>
5410	{
5411	list_hosts(self)
5412	}
5413	fn set_access_control(&self, mode: AccessControl) -> Result<VoidCookie<'_, Self>, ConnectionError>
5414	{
5415	set_access_control(self, mode)
5416	}
5417	fn set_close_down_mode(&self, mode: CloseDown) -> Result<VoidCookie<'_, Self>, ConnectionError>
5418	{
5419	set_close_down_mode(self, mode)
5420	}
5421	/// kills a client.
5422	///
5423	/// Forces a close down of the client that created the specified `resource`.
5424	///
5425	/// # Fields
5426	///
5427	/// `resource` - Any resource belonging to the client (for example a Window), used to identify*
5428	/// the client connection.
5429	///
5430	/// The special value of `XCB_KILL_ALL_TEMPORARY`, the resources of all clients
5431	/// that have terminated in `RetainTemporary` (TODO) are destroyed.
5432	///
5433	/// # Errors
5434	///
5435	/// `Value` - The specified `resource` does not exist.*
5436	///
5437	/// # See
5438	///
5439	/// `xkill`: program*
5440	fn kill_client<A>(&self, resource: A) -> Result<VoidCookie<'_, Self>, ConnectionError>
5441	where
5442	A: Into<u32>,
5443	{
5444	kill_client(self, resource)
5445	}
5446	fn rotate_properties<'c, 'input>(&'c self, window: Window, delta: i16, atoms: &'input [Atom]) -> Result<VoidCookie<'c, Self>, ConnectionError>
5447	{
5448	rotate_properties(self, window, delta, atoms)
5449	}
5450	fn force_screen_saver(&self, mode: ScreenSaver) -> Result<VoidCookie<'_, Self>, ConnectionError>
5451	{
5452	force_screen_saver(self, mode)
5453	}
5454	fn set_pointer_mapping<'c, 'input>(&'c self, map: &'input [u8]) -> Result<Cookie<'c, Self, SetPointerMappingReply>, ConnectionError>
5455	{
5456	set_pointer_mapping(self, map)
5457	}
5458	fn get_pointer_mapping(&self) -> Result<Cookie<'_, Self, GetPointerMappingReply>, ConnectionError>
5459	{
5460	get_pointer_mapping(self)
5461	}
5462	fn set_modifier_mapping<'c, 'input>(&'c self, keycodes: &'input [Keycode]) -> Result<Cookie<'c, Self, SetModifierMappingReply>, ConnectionError>
5463	{
5464	set_modifier_mapping(self, keycodes)
5465	}
5466	fn get_modifier_mapping(&self) -> Result<Cookie<'_, Self, GetModifierMappingReply>, ConnectionError>
5467	{
5468	get_modifier_mapping(self)
5469	}
5470	fn no_operation(&self) -> Result<VoidCookie<'_, Self>, ConnectionError>
5471	{
5472	no_operation(self)
5473	}
5474	}
5475
5476	impl<C: RequestConnection + ?Sized> ConnectionExt for C {}
5477
5478	/// A RAII-like wrapper around a [Pixmap].
5479	///
5480	/// Instances of this struct represent a Pixmap that is freed in `Drop`.
5481	///
5482	/// Any errors during `Drop` are silently ignored. Most likely an error here means that your
5483	/// X11 connection is broken and later requests will also fail.
5484	#[derive(Debug)]
5485	pub struct PixmapWrapper<C: RequestConnection>(C, Pixmap);
5486
5487	impl<C: RequestConnection> PixmapWrapper<C>
5488	{
5489	/// Assume ownership of the given resource and destroy it in `Drop`.
5490	pub fn for_pixmap(conn: C, id: Pixmap) -> Self {
5491	PixmapWrapper(conn, id)
5492	}
5493
5494	/// Get the XID of the wrapped resource
5495	pub fn pixmap(&self) -> Pixmap {
5496	self.1
5497	}
5498
5499	/// Assume ownership of the XID of the wrapped resource
5500	///
5501	/// This function destroys this wrapper without freeing the underlying resource.
5502	pub fn into_pixmap(self) -> Pixmap {
5503	let id: u32 = self.1;
5504	std::mem::forget(self);
5505	id
5506	}
5507	}
5508
5509	impl<'c, C: X11Connection> PixmapWrapper<&'c C>
5510	{
5511	/// Create a new Pixmap and return a Pixmap wrapper and a cookie.
5512	///
5513	/// This is a thin wrapper around [create_pixmap] that allocates an id for the Pixmap.
5514	/// This function returns the resulting `PixmapWrapper` that owns the created Pixmap and frees
5515	/// it in `Drop`. This also returns a `VoidCookie` that comes from the call to
5516	/// [create_pixmap].
5517	///
5518	/// Errors can come from the call to [X11Connection::generate_id] or [create_pixmap].
5519	pub fn create_pixmap_and_get_cookie(conn: &'c C, depth: u8, drawable: Drawable, width: u16, height: u16) -> Result<(Self, VoidCookie<'c, C>), ReplyOrIdError>
5520	{
5521	let pid: u32 = conn.generate_id()?;
5522	let cookie: VoidCookie<'_, C> = create_pixmap(conn, depth, pid, drawable, width, height)?;
5523	Ok((Self::for_pixmap(conn, id:pid), cookie))
5524	}
5525	}
5526	impl<C: X11Connection> PixmapWrapper<C>
5527	{
5528	/// Create a new Pixmap and return a Pixmap wrapper
5529	///
5530	/// This is a thin wrapper around [create_pixmap] that allocates an id for the Pixmap.
5531	/// This function returns the resulting `PixmapWrapper` that owns the created Pixmap and frees
5532	/// it in `Drop`.
5533	///
5534	/// Errors can come from the call to [X11Connection::generate_id] or [create_pixmap].
5535	pub fn create_pixmap(conn: C, depth: u8, drawable: Drawable, width: u16, height: u16) -> Result<Self, ReplyOrIdError>
5536	{
5537	let pid: u32 = conn.generate_id()?;
5538	let _ = create_pixmap(&conn, depth, pid, drawable, width, height)?;
5539	Ok(Self::for_pixmap(conn, id:pid))
5540	}
5541	}
5542
5543	impl<C: RequestConnection> From<&PixmapWrapper<C>> for Pixmap {
5544	fn from(from: &PixmapWrapper<C>) -> Self {
5545	from.1
5546	}
5547	}
5548
5549	impl<C: RequestConnection> Drop for PixmapWrapper<C> {
5550	fn drop(&mut self) {
5551	let _ = free_pixmap(&self.0, self.1);
5552	}
5553	}
5554
5555	/// A RAII-like wrapper around a [Window].
5556	///
5557	/// Instances of this struct represent a Window that is freed in `Drop`.
5558	///
5559	/// Any errors during `Drop` are silently ignored. Most likely an error here means that your
5560	/// X11 connection is broken and later requests will also fail.
5561	#[derive(Debug)]
5562	pub struct WindowWrapper<C: RequestConnection>(C, Window);
5563
5564	impl<C: RequestConnection> WindowWrapper<C>
5565	{
5566	/// Assume ownership of the given resource and destroy it in `Drop`.
5567	pub fn for_window(conn: C, id: Window) -> Self {
5568	WindowWrapper(conn, id)
5569	}
5570
5571	/// Get the XID of the wrapped resource
5572	pub fn window(&self) -> Window {
5573	self.1
5574	}
5575
5576	/// Assume ownership of the XID of the wrapped resource
5577	///
5578	/// This function destroys this wrapper without freeing the underlying resource.
5579	pub fn into_window(self) -> Window {
5580	let id: u32 = self.1;
5581	std::mem::forget(self);
5582	id
5583	}
5584	}
5585
5586	impl<'c, C: X11Connection> WindowWrapper<&'c C>
5587	{
5588	/// Create a new Window and return a Window wrapper and a cookie.
5589	///
5590	/// This is a thin wrapper around [create_window] that allocates an id for the Window.
5591	/// This function returns the resulting `WindowWrapper` that owns the created Window and frees
5592	/// it in `Drop`. This also returns a `VoidCookie` that comes from the call to
5593	/// [create_window].
5594	///
5595	/// Errors can come from the call to [X11Connection::generate_id] or [create_window].
5596	pub fn create_window_and_get_cookie(conn: &'c C, depth: u8, parent: Window, x: i16, y: i16, width: u16, height: u16, border_width: u16, class: WindowClass, visual: Visualid, value_list: &CreateWindowAux) -> Result<(Self, VoidCookie<'c, C>), ReplyOrIdError>
5597	{
5598	let wid: u32 = conn.generate_id()?;
5599	let cookie: VoidCookie<'_, C> = create_window(conn, depth, wid, parent, x, y, width, height, border_width, class, visual, value_list)?;
5600	Ok((Self::for_window(conn, id:wid), cookie))
5601	}
5602	}
5603	impl<C: X11Connection> WindowWrapper<C>
5604	{
5605	/// Create a new Window and return a Window wrapper
5606	///
5607	/// This is a thin wrapper around [create_window] that allocates an id for the Window.
5608	/// This function returns the resulting `WindowWrapper` that owns the created Window and frees
5609	/// it in `Drop`.
5610	///
5611	/// Errors can come from the call to [X11Connection::generate_id] or [create_window].
5612	pub fn create_window(conn: C, depth: u8, parent: Window, x: i16, y: i16, width: u16, height: u16, border_width: u16, class: WindowClass, visual: Visualid, value_list: &CreateWindowAux) -> Result<Self, ReplyOrIdError>
5613	{
5614	let wid: u32 = conn.generate_id()?;
5615	let _ = create_window(&conn, depth, wid, parent, x, y, width, height, border_width, class, visual, value_list)?;
5616	Ok(Self::for_window(conn, id:wid))
5617	}
5618	}
5619
5620	impl<C: RequestConnection> From<&WindowWrapper<C>> for Window {
5621	fn from(from: &WindowWrapper<C>) -> Self {
5622	from.1
5623	}
5624	}
5625
5626	impl<C: RequestConnection> Drop for WindowWrapper<C> {
5627	fn drop(&mut self) {
5628	let _ = destroy_window(&self.0, self.1);
5629	}
5630	}
5631
5632	/// A RAII-like wrapper around a [Font].
5633	///
5634	/// Instances of this struct represent a Font that is freed in `Drop`.
5635	///
5636	/// Any errors during `Drop` are silently ignored. Most likely an error here means that your
5637	/// X11 connection is broken and later requests will also fail.
5638	#[derive(Debug)]
5639	pub struct FontWrapper<C: RequestConnection>(C, Font);
5640
5641	impl<C: RequestConnection> FontWrapper<C>
5642	{
5643	/// Assume ownership of the given resource and destroy it in `Drop`.
5644	pub fn for_font(conn: C, id: Font) -> Self {
5645	FontWrapper(conn, id)
5646	}
5647
5648	/// Get the XID of the wrapped resource
5649	pub fn font(&self) -> Font {
5650	self.1
5651	}
5652
5653	/// Assume ownership of the XID of the wrapped resource
5654	///
5655	/// This function destroys this wrapper without freeing the underlying resource.
5656	pub fn into_font(self) -> Font {
5657	let id: u32 = self.1;
5658	std::mem::forget(self);
5659	id
5660	}
5661	}
5662
5663	impl<'c, C: X11Connection> FontWrapper<&'c C>
5664	{
5665	/// Create a new Font and return a Font wrapper and a cookie.
5666	///
5667	/// This is a thin wrapper around [open_font] that allocates an id for the Font.
5668	/// This function returns the resulting `FontWrapper` that owns the created Font and frees
5669	/// it in `Drop`. This also returns a `VoidCookie` that comes from the call to
5670	/// [open_font].
5671	///
5672	/// Errors can come from the call to [X11Connection::generate_id] or [open_font].
5673	pub fn open_font_and_get_cookie(conn: &'c C, name: &[u8]) -> Result<(Self, VoidCookie<'c, C>), ReplyOrIdError>
5674	{
5675	let fid: u32 = conn.generate_id()?;
5676	let cookie: VoidCookie<'_, C> = open_font(conn, fid, name)?;
5677	Ok((Self::for_font(conn, id:fid), cookie))
5678	}
5679	}
5680	impl<C: X11Connection> FontWrapper<C>
5681	{
5682	/// Create a new Font and return a Font wrapper
5683	///
5684	/// This is a thin wrapper around [open_font] that allocates an id for the Font.
5685	/// This function returns the resulting `FontWrapper` that owns the created Font and frees
5686	/// it in `Drop`.
5687	///
5688	/// Errors can come from the call to [X11Connection::generate_id] or [open_font].
5689	pub fn open_font(conn: C, name: &[u8]) -> Result<Self, ReplyOrIdError>
5690	{
5691	let fid: u32 = conn.generate_id()?;
5692	let _ = open_font(&conn, fid, name)?;
5693	Ok(Self::for_font(conn, id:fid))
5694	}
5695	}
5696
5697	impl<C: RequestConnection> From<&FontWrapper<C>> for Font {
5698	fn from(from: &FontWrapper<C>) -> Self {
5699	from.1
5700	}
5701	}
5702
5703	impl<C: RequestConnection> Drop for FontWrapper<C> {
5704	fn drop(&mut self) {
5705	let _ = close_font(&self.0, self.1);
5706	}
5707	}
5708
5709	/// A RAII-like wrapper around a [Gcontext].
5710	///
5711	/// Instances of this struct represent a Gcontext that is freed in `Drop`.
5712	///
5713	/// Any errors during `Drop` are silently ignored. Most likely an error here means that your
5714	/// X11 connection is broken and later requests will also fail.
5715	#[derive(Debug)]
5716	pub struct GcontextWrapper<C: RequestConnection>(C, Gcontext);
5717
5718	impl<C: RequestConnection> GcontextWrapper<C>
5719	{
5720	/// Assume ownership of the given resource and destroy it in `Drop`.
5721	pub fn for_gcontext(conn: C, id: Gcontext) -> Self {
5722	GcontextWrapper(conn, id)
5723	}
5724
5725	/// Get the XID of the wrapped resource
5726	pub fn gcontext(&self) -> Gcontext {
5727	self.1
5728	}
5729
5730	/// Assume ownership of the XID of the wrapped resource
5731	///
5732	/// This function destroys this wrapper without freeing the underlying resource.
5733	pub fn into_gcontext(self) -> Gcontext {
5734	let id: u32 = self.1;
5735	std::mem::forget(self);
5736	id
5737	}
5738	}
5739
5740	impl<'c, C: X11Connection> GcontextWrapper<&'c C>
5741	{
5742	/// Create a new Gcontext and return a Gcontext wrapper and a cookie.
5743	///
5744	/// This is a thin wrapper around [create_gc] that allocates an id for the Gcontext.
5745	/// This function returns the resulting `GcontextWrapper` that owns the created Gcontext and frees
5746	/// it in `Drop`. This also returns a `VoidCookie` that comes from the call to
5747	/// [create_gc].
5748	///
5749	/// Errors can come from the call to [X11Connection::generate_id] or [create_gc].
5750	pub fn create_gc_and_get_cookie(conn: &'c C, drawable: Drawable, value_list: &CreateGCAux) -> Result<(Self, VoidCookie<'c, C>), ReplyOrIdError>
5751	{
5752	let cid: u32 = conn.generate_id()?;
5753	let cookie: VoidCookie<'_, C> = create_gc(conn, cid, drawable, value_list)?;
5754	Ok((Self::for_gcontext(conn, id:cid), cookie))
5755	}
5756	}
5757	impl<C: X11Connection> GcontextWrapper<C>
5758	{
5759	/// Create a new Gcontext and return a Gcontext wrapper
5760	///
5761	/// This is a thin wrapper around [create_gc] that allocates an id for the Gcontext.
5762	/// This function returns the resulting `GcontextWrapper` that owns the created Gcontext and frees
5763	/// it in `Drop`.
5764	///
5765	/// Errors can come from the call to [X11Connection::generate_id] or [create_gc].
5766	pub fn create_gc(conn: C, drawable: Drawable, value_list: &CreateGCAux) -> Result<Self, ReplyOrIdError>
5767	{
5768	let cid: u32 = conn.generate_id()?;
5769	let _ = create_gc(&conn, cid, drawable, value_list)?;
5770	Ok(Self::for_gcontext(conn, id:cid))
5771	}
5772	}
5773
5774	impl<C: RequestConnection> From<&GcontextWrapper<C>> for Gcontext {
5775	fn from(from: &GcontextWrapper<C>) -> Self {
5776	from.1
5777	}
5778	}
5779
5780	impl<C: RequestConnection> Drop for GcontextWrapper<C> {
5781	fn drop(&mut self) {
5782	let _ = free_gc(&self.0, self.1);
5783	}
5784	}
5785
5786	/// A RAII-like wrapper around a [Colormap].
5787	///
5788	/// Instances of this struct represent a Colormap that is freed in `Drop`.
5789	///
5790	/// Any errors during `Drop` are silently ignored. Most likely an error here means that your
5791	/// X11 connection is broken and later requests will also fail.
5792	#[derive(Debug)]
5793	pub struct ColormapWrapper<C: RequestConnection>(C, Colormap);
5794
5795	impl<C: RequestConnection> ColormapWrapper<C>
5796	{
5797	/// Assume ownership of the given resource and destroy it in `Drop`.
5798	pub fn for_colormap(conn: C, id: Colormap) -> Self {
5799	ColormapWrapper(conn, id)
5800	}
5801
5802	/// Get the XID of the wrapped resource
5803	pub fn colormap(&self) -> Colormap {
5804	self.1
5805	}
5806
5807	/// Assume ownership of the XID of the wrapped resource
5808	///
5809	/// This function destroys this wrapper without freeing the underlying resource.
5810	pub fn into_colormap(self) -> Colormap {
5811	let id: u32 = self.1;
5812	std::mem::forget(self);
5813	id
5814	}
5815	}
5816
5817	impl<'c, C: X11Connection> ColormapWrapper<&'c C>
5818	{
5819	/// Create a new Colormap and return a Colormap wrapper and a cookie.
5820	///
5821	/// This is a thin wrapper around [create_colormap] that allocates an id for the Colormap.
5822	/// This function returns the resulting `ColormapWrapper` that owns the created Colormap and frees
5823	/// it in `Drop`. This also returns a `VoidCookie` that comes from the call to
5824	/// [create_colormap].
5825	///
5826	/// Errors can come from the call to [X11Connection::generate_id] or [create_colormap].
5827	pub fn create_colormap_and_get_cookie(conn: &'c C, alloc: ColormapAlloc, window: Window, visual: Visualid) -> Result<(Self, VoidCookie<'c, C>), ReplyOrIdError>
5828	{
5829	let mid: u32 = conn.generate_id()?;
5830	let cookie: VoidCookie<'_, C> = create_colormap(conn, alloc, mid, window, visual)?;
5831	Ok((Self::for_colormap(conn, id:mid), cookie))
5832	}
5833	}
5834	impl<C: X11Connection> ColormapWrapper<C>
5835	{
5836	/// Create a new Colormap and return a Colormap wrapper
5837	///
5838	/// This is a thin wrapper around [create_colormap] that allocates an id for the Colormap.
5839	/// This function returns the resulting `ColormapWrapper` that owns the created Colormap and frees
5840	/// it in `Drop`.
5841	///
5842	/// Errors can come from the call to [X11Connection::generate_id] or [create_colormap].
5843	pub fn create_colormap(conn: C, alloc: ColormapAlloc, window: Window, visual: Visualid) -> Result<Self, ReplyOrIdError>
5844	{
5845	let mid: u32 = conn.generate_id()?;
5846	let _ = create_colormap(&conn, alloc, mid, window, visual)?;
5847	Ok(Self::for_colormap(conn, id:mid))
5848	}
5849	}
5850
5851	impl<C: RequestConnection> From<&ColormapWrapper<C>> for Colormap {
5852	fn from(from: &ColormapWrapper<C>) -> Self {
5853	from.1
5854	}
5855	}
5856
5857	impl<C: RequestConnection> Drop for ColormapWrapper<C> {
5858	fn drop(&mut self) {
5859	let _ = free_colormap(&self.0, self.1);
5860	}
5861	}
5862
5863	/// A RAII-like wrapper around a [Cursor].
5864	///
5865	/// Instances of this struct represent a Cursor that is freed in `Drop`.
5866	///
5867	/// Any errors during `Drop` are silently ignored. Most likely an error here means that your
5868	/// X11 connection is broken and later requests will also fail.
5869	#[derive(Debug)]
5870	pub struct CursorWrapper<C: RequestConnection>(C, Cursor);
5871
5872	impl<C: RequestConnection> CursorWrapper<C>
5873	{
5874	/// Assume ownership of the given resource and destroy it in `Drop`.
5875	pub fn for_cursor(conn: C, id: Cursor) -> Self {
5876	CursorWrapper(conn, id)
5877	}
5878
5879	/// Get the XID of the wrapped resource
5880	pub fn cursor(&self) -> Cursor {
5881	self.1
5882	}
5883
5884	/// Assume ownership of the XID of the wrapped resource
5885	///
5886	/// This function destroys this wrapper without freeing the underlying resource.
5887	pub fn into_cursor(self) -> Cursor {
5888	let id: u32 = self.1;
5889	std::mem::forget(self);
5890	id
5891	}
5892	}
5893
5894	impl<'c, C: X11Connection> CursorWrapper<&'c C>
5895	{
5896	/// Create a new Cursor and return a Cursor wrapper and a cookie.
5897	///
5898	/// This is a thin wrapper around [create_cursor] that allocates an id for the Cursor.
5899	/// This function returns the resulting `CursorWrapper` that owns the created Cursor and frees
5900	/// it in `Drop`. This also returns a `VoidCookie` that comes from the call to
5901	/// [create_cursor].
5902	///
5903	/// Errors can come from the call to [X11Connection::generate_id] or [create_cursor].
5904	pub fn create_cursor_and_get_cookie<A>(conn: &'c C, source: Pixmap, mask: A, fore_red: u16, fore_green: u16, fore_blue: u16, back_red: u16, back_green: u16, back_blue: u16, x: u16, y: u16) -> Result<(Self, VoidCookie<'c, C>), ReplyOrIdError>
5905	where
5906	A: Into<Pixmap>,
5907	{
5908	let cid: u32 = conn.generate_id()?;
5909	let cookie: VoidCookie<'_, C> = create_cursor(conn, cid, source, mask, fore_red, fore_green, fore_blue, back_red, back_green, back_blue, x, y)?;
5910	Ok((Self::for_cursor(conn, id:cid), cookie))
5911	}
5912	}
5913	impl<C: X11Connection> CursorWrapper<C>
5914	{
5915	/// Create a new Cursor and return a Cursor wrapper
5916	///
5917	/// This is a thin wrapper around [create_cursor] that allocates an id for the Cursor.
5918	/// This function returns the resulting `CursorWrapper` that owns the created Cursor and frees
5919	/// it in `Drop`.
5920	///
5921	/// Errors can come from the call to [X11Connection::generate_id] or [create_cursor].
5922	pub fn create_cursor<A>(conn: C, source: Pixmap, mask: A, fore_red: u16, fore_green: u16, fore_blue: u16, back_red: u16, back_green: u16, back_blue: u16, x: u16, y: u16) -> Result<Self, ReplyOrIdError>
5923	where
5924	A: Into<Pixmap>,
5925	{
5926	let cid: u32 = conn.generate_id()?;
5927	let _ = create_cursor(&conn, cid, source, mask, fore_red, fore_green, fore_blue, back_red, back_green, back_blue, x, y)?;
5928	Ok(Self::for_cursor(conn, id:cid))
5929	}
5930	}
5931
5932	impl<'c, C: X11Connection> CursorWrapper<&'c C>
5933	{
5934	/// Create a new Cursor and return a Cursor wrapper and a cookie.
5935	///
5936	/// This is a thin wrapper around [create_glyph_cursor] that allocates an id for the Cursor.
5937	/// This function returns the resulting `CursorWrapper` that owns the created Cursor and frees
5938	/// it in `Drop`. This also returns a `VoidCookie` that comes from the call to
5939	/// [create_glyph_cursor].
5940	///
5941	/// Errors can come from the call to [X11Connection::generate_id] or [create_glyph_cursor].
5942	pub fn create_glyph_cursor_and_get_cookie<A>(conn: &'c C, source_font: Font, mask_font: A, source_char: u16, mask_char: u16, fore_red: u16, fore_green: u16, fore_blue: u16, back_red: u16, back_green: u16, back_blue: u16) -> Result<(Self, VoidCookie<'c, C>), ReplyOrIdError>
5943	where
5944	A: Into<Font>,
5945	{
5946	let cid: u32 = conn.generate_id()?;
5947	let cookie: VoidCookie<'_, C> = create_glyph_cursor(conn, cid, source_font, mask_font, source_char, mask_char, fore_red, fore_green, fore_blue, back_red, back_green, back_blue)?;
5948	Ok((Self::for_cursor(conn, id:cid), cookie))
5949	}
5950	}
5951	impl<C: X11Connection> CursorWrapper<C>
5952	{
5953	/// Create a new Cursor and return a Cursor wrapper
5954	///
5955	/// This is a thin wrapper around [create_glyph_cursor] that allocates an id for the Cursor.
5956	/// This function returns the resulting `CursorWrapper` that owns the created Cursor and frees
5957	/// it in `Drop`.
5958	///
5959	/// Errors can come from the call to [X11Connection::generate_id] or [create_glyph_cursor].
5960	pub fn create_glyph_cursor<A>(conn: C, source_font: Font, mask_font: A, source_char: u16, mask_char: u16, fore_red: u16, fore_green: u16, fore_blue: u16, back_red: u16, back_green: u16, back_blue: u16) -> Result<Self, ReplyOrIdError>
5961	where
5962	A: Into<Font>,
5963	{
5964	let cid: u32 = conn.generate_id()?;
5965	let _ = create_glyph_cursor(&conn, cid, source_font, mask_font, source_char, mask_char, fore_red, fore_green, fore_blue, back_red, back_green, back_blue)?;
5966	Ok(Self::for_cursor(conn, id:cid))
5967	}
5968	}
5969
5970	impl<C: RequestConnection> From<&CursorWrapper<C>> for Cursor {
5971	fn from(from: &CursorWrapper<C>) -> Self {
5972	from.1
5973	}
5974	}
5975
5976	impl<C: RequestConnection> Drop for CursorWrapper<C> {
5977	fn drop(&mut self) {
5978	let _ = free_cursor(&self.0, self.1);
5979	}
5980	}
5981