1// This file contains generated code. Do not edit directly.
2// To regenerate this, run 'make'.
3
4//! Bindings to the `XCMisc` X11 extension.
5
6#![allow(clippy::too_many_arguments)]
7// The code generator is simpler if it can always use conversions
8#![allow(clippy::useless_conversion)]
9
10#[allow(unused_imports)]
11use alloc::borrow::Cow;
12#[allow(unused_imports)]
13use core::convert::TryInto;
14use alloc::vec;
15use alloc::vec::Vec;
16use core::convert::TryFrom;
17use crate::errors::ParseError;
18#[allow(unused_imports)]
19use crate::x11_utils::TryIntoUSize;
20use crate::BufWithFds;
21#[allow(unused_imports)]
22use crate::utils::{RawFdContainer, pretty_print_bitmask, pretty_print_enum};
23#[allow(unused_imports)]
24use crate::x11_utils::{Request, RequestHeader, Serialize, TryParse, TryParseFd};
25
26/// The X11 name of the extension for QueryExtension
27pub const X11_EXTENSION_NAME: &str = "XC-MISC";
28
29/// The version number of this extension that this client library supports.
30///
31/// This constant contains the version number of this extension that is supported
32/// by this build of x11rb. For most things, it does not make sense to use this
33/// information. If you need to send a `QueryVersion`, it is recommended to instead
34/// send the maximum version of the extension that you need.
35pub const X11_XML_VERSION: (u32, u32) = (1, 1);
36
37/// Opcode for the GetVersion request
38pub const GET_VERSION_REQUEST: u8 = 0;
39#[derive(Clone, Copy, Default)]
40#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
41#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
42pub struct GetVersionRequest {
43 pub client_major_version: u16,
44 pub client_minor_version: u16,
45}
46impl_debug_if_no_extra_traits!(GetVersionRequest, "GetVersionRequest");
47impl GetVersionRequest {
48 /// Serialize this request into bytes for the provided connection
49 pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'static, [u8]>; 1]> {
50 let length_so_far = 0;
51 let client_major_version_bytes = self.client_major_version.serialize();
52 let client_minor_version_bytes = self.client_minor_version.serialize();
53 let mut request0 = vec![
54 major_opcode,
55 GET_VERSION_REQUEST,
56 0,
57 0,
58 client_major_version_bytes[0],
59 client_major_version_bytes[1],
60 client_minor_version_bytes[0],
61 client_minor_version_bytes[1],
62 ];
63 let length_so_far = length_so_far + request0.len();
64 assert_eq!(length_so_far % 4, 0);
65 let length = u16::try_from(length_so_far / 4).unwrap_or(0);
66 request0[2..4].copy_from_slice(&length.to_ne_bytes());
67 ([request0.into()], vec![])
68 }
69 /// Parse this request given its header, its body, and any fds that go along with it
70 #[cfg(feature = "request-parsing")]
71 pub fn try_parse_request(header: RequestHeader, value: &[u8]) -> Result<Self, ParseError> {
72 if header.minor_opcode != GET_VERSION_REQUEST {
73 return Err(ParseError::InvalidValue);
74 }
75 let (client_major_version, remaining) = u16::try_parse(value)?;
76 let (client_minor_version, remaining) = u16::try_parse(remaining)?;
77 let _ = remaining;
78 Ok(GetVersionRequest {
79 client_major_version,
80 client_minor_version,
81 })
82 }
83}
84impl Request for GetVersionRequest {
85 const EXTENSION_NAME: Option<&'static str> = Some(X11_EXTENSION_NAME);
86
87 fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
88 let (bufs: [Cow<'static, [u8]>; 1], fds: Vec) = self.serialize(major_opcode);
89 // Flatten the buffers into a single vector
90 let buf: Vec = bufs.iter().flat_map(|buf: &Cow<'_, [u8]>| buf.iter().copied()).collect();
91 (buf, fds)
92 }
93}
94impl crate::x11_utils::ReplyRequest for GetVersionRequest {
95 type Reply = GetVersionReply;
96}
97
98#[derive(Clone, Copy, Default)]
99#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
100#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
101pub struct GetVersionReply {
102 pub sequence: u16,
103 pub length: u32,
104 pub server_major_version: u16,
105 pub server_minor_version: u16,
106}
107impl_debug_if_no_extra_traits!(GetVersionReply, "GetVersionReply");
108impl TryParse for GetVersionReply {
109 fn try_parse(initial_value: &[u8]) -> Result<(Self, &[u8]), ParseError> {
110 let remaining: &[u8] = initial_value;
111 let (response_type: u8, remaining: &[u8]) = u8::try_parse(remaining)?;
112 let remaining: &[u8] = remaining.get(1..).ok_or(err:ParseError::InsufficientData)?;
113 let (sequence: u16, remaining: &[u8]) = u16::try_parse(remaining)?;
114 let (length: u32, remaining: &[u8]) = u32::try_parse(remaining)?;
115 let (server_major_version: u16, remaining: &[u8]) = u16::try_parse(remaining)?;
116 let (server_minor_version: u16, remaining: &[u8]) = u16::try_parse(remaining)?;
117 if response_type != 1 {
118 return Err(ParseError::InvalidValue);
119 }
120 let result: GetVersionReply = GetVersionReply { sequence, length, server_major_version, server_minor_version };
121 let _ = remaining;
122 let remaining: &[u8] = initial_value.get(32 + length as usize * 4..)
123 .ok_or(err:ParseError::InsufficientData)?;
124 Ok((result, remaining))
125 }
126}
127impl Serialize for GetVersionReply {
128 type Bytes = [u8; 12];
129 fn serialize(&self) -> [u8; 12] {
130 let response_type_bytes = &[1];
131 let sequence_bytes = self.sequence.serialize();
132 let length_bytes = self.length.serialize();
133 let server_major_version_bytes = self.server_major_version.serialize();
134 let server_minor_version_bytes = self.server_minor_version.serialize();
135 [
136 response_type_bytes[0],
137 0,
138 sequence_bytes[0],
139 sequence_bytes[1],
140 length_bytes[0],
141 length_bytes[1],
142 length_bytes[2],
143 length_bytes[3],
144 server_major_version_bytes[0],
145 server_major_version_bytes[1],
146 server_minor_version_bytes[0],
147 server_minor_version_bytes[1],
148 ]
149 }
150 fn serialize_into(&self, bytes: &mut Vec<u8>) {
151 bytes.reserve(12);
152 let response_type_bytes = &[1];
153 bytes.push(response_type_bytes[0]);
154 bytes.extend_from_slice(&[0; 1]);
155 self.sequence.serialize_into(bytes);
156 self.length.serialize_into(bytes);
157 self.server_major_version.serialize_into(bytes);
158 self.server_minor_version.serialize_into(bytes);
159 }
160}
161
162/// Opcode for the GetXIDRange request
163pub const GET_XID_RANGE_REQUEST: u8 = 1;
164#[derive(Clone, Copy, Default)]
165#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
166#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
167pub struct GetXIDRangeRequest;
168impl_debug_if_no_extra_traits!(GetXIDRangeRequest, "GetXIDRangeRequest");
169impl GetXIDRangeRequest {
170 /// Serialize this request into bytes for the provided connection
171 pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'static, [u8]>; 1]> {
172 let length_so_far = 0;
173 let mut request0 = vec![
174 major_opcode,
175 GET_XID_RANGE_REQUEST,
176 0,
177 0,
178 ];
179 let length_so_far = length_so_far + request0.len();
180 assert_eq!(length_so_far % 4, 0);
181 let length = u16::try_from(length_so_far / 4).unwrap_or(0);
182 request0[2..4].copy_from_slice(&length.to_ne_bytes());
183 ([request0.into()], vec![])
184 }
185 /// Parse this request given its header, its body, and any fds that go along with it
186 #[cfg(feature = "request-parsing")]
187 pub fn try_parse_request(header: RequestHeader, value: &[u8]) -> Result<Self, ParseError> {
188 if header.minor_opcode != GET_XID_RANGE_REQUEST {
189 return Err(ParseError::InvalidValue);
190 }
191 let _ = value;
192 Ok(GetXIDRangeRequest
193 )
194 }
195}
196impl Request for GetXIDRangeRequest {
197 const EXTENSION_NAME: Option<&'static str> = Some(X11_EXTENSION_NAME);
198
199 fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
200 let (bufs: [Cow<'static, [u8]>; 1], fds: Vec) = self.serialize(major_opcode);
201 // Flatten the buffers into a single vector
202 let buf: Vec = bufs.iter().flat_map(|buf: &Cow<'_, [u8]>| buf.iter().copied()).collect();
203 (buf, fds)
204 }
205}
206impl crate::x11_utils::ReplyRequest for GetXIDRangeRequest {
207 type Reply = GetXIDRangeReply;
208}
209
210#[derive(Clone, Copy, Default)]
211#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
212#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
213pub struct GetXIDRangeReply {
214 pub sequence: u16,
215 pub length: u32,
216 pub start_id: u32,
217 pub count: u32,
218}
219impl_debug_if_no_extra_traits!(GetXIDRangeReply, "GetXIDRangeReply");
220impl TryParse for GetXIDRangeReply {
221 fn try_parse(initial_value: &[u8]) -> Result<(Self, &[u8]), ParseError> {
222 let remaining: &[u8] = initial_value;
223 let (response_type: u8, remaining: &[u8]) = u8::try_parse(remaining)?;
224 let remaining: &[u8] = remaining.get(1..).ok_or(err:ParseError::InsufficientData)?;
225 let (sequence: u16, remaining: &[u8]) = u16::try_parse(remaining)?;
226 let (length: u32, remaining: &[u8]) = u32::try_parse(remaining)?;
227 let (start_id: u32, remaining: &[u8]) = u32::try_parse(remaining)?;
228 let (count: u32, remaining: &[u8]) = u32::try_parse(remaining)?;
229 if response_type != 1 {
230 return Err(ParseError::InvalidValue);
231 }
232 let result: GetXIDRangeReply = GetXIDRangeReply { sequence, length, start_id, count };
233 let _ = remaining;
234 let remaining: &[u8] = initial_value.get(32 + length as usize * 4..)
235 .ok_or(err:ParseError::InsufficientData)?;
236 Ok((result, remaining))
237 }
238}
239impl Serialize for GetXIDRangeReply {
240 type Bytes = [u8; 16];
241 fn serialize(&self) -> [u8; 16] {
242 let response_type_bytes = &[1];
243 let sequence_bytes = self.sequence.serialize();
244 let length_bytes = self.length.serialize();
245 let start_id_bytes = self.start_id.serialize();
246 let count_bytes = self.count.serialize();
247 [
248 response_type_bytes[0],
249 0,
250 sequence_bytes[0],
251 sequence_bytes[1],
252 length_bytes[0],
253 length_bytes[1],
254 length_bytes[2],
255 length_bytes[3],
256 start_id_bytes[0],
257 start_id_bytes[1],
258 start_id_bytes[2],
259 start_id_bytes[3],
260 count_bytes[0],
261 count_bytes[1],
262 count_bytes[2],
263 count_bytes[3],
264 ]
265 }
266 fn serialize_into(&self, bytes: &mut Vec<u8>) {
267 bytes.reserve(16);
268 let response_type_bytes = &[1];
269 bytes.push(response_type_bytes[0]);
270 bytes.extend_from_slice(&[0; 1]);
271 self.sequence.serialize_into(bytes);
272 self.length.serialize_into(bytes);
273 self.start_id.serialize_into(bytes);
274 self.count.serialize_into(bytes);
275 }
276}
277
278/// Opcode for the GetXIDList request
279pub const GET_XID_LIST_REQUEST: u8 = 2;
280#[derive(Clone, Copy, Default)]
281#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
282#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
283pub struct GetXIDListRequest {
284 pub count: u32,
285}
286impl_debug_if_no_extra_traits!(GetXIDListRequest, "GetXIDListRequest");
287impl GetXIDListRequest {
288 /// Serialize this request into bytes for the provided connection
289 pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'static, [u8]>; 1]> {
290 let length_so_far = 0;
291 let count_bytes = self.count.serialize();
292 let mut request0 = vec![
293 major_opcode,
294 GET_XID_LIST_REQUEST,
295 0,
296 0,
297 count_bytes[0],
298 count_bytes[1],
299 count_bytes[2],
300 count_bytes[3],
301 ];
302 let length_so_far = length_so_far + request0.len();
303 assert_eq!(length_so_far % 4, 0);
304 let length = u16::try_from(length_so_far / 4).unwrap_or(0);
305 request0[2..4].copy_from_slice(&length.to_ne_bytes());
306 ([request0.into()], vec![])
307 }
308 /// Parse this request given its header, its body, and any fds that go along with it
309 #[cfg(feature = "request-parsing")]
310 pub fn try_parse_request(header: RequestHeader, value: &[u8]) -> Result<Self, ParseError> {
311 if header.minor_opcode != GET_XID_LIST_REQUEST {
312 return Err(ParseError::InvalidValue);
313 }
314 let (count, remaining) = u32::try_parse(value)?;
315 let _ = remaining;
316 Ok(GetXIDListRequest {
317 count,
318 })
319 }
320}
321impl Request for GetXIDListRequest {
322 const EXTENSION_NAME: Option<&'static str> = Some(X11_EXTENSION_NAME);
323
324 fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
325 let (bufs: [Cow<'static, [u8]>; 1], fds: Vec) = self.serialize(major_opcode);
326 // Flatten the buffers into a single vector
327 let buf: Vec = bufs.iter().flat_map(|buf: &Cow<'_, [u8]>| buf.iter().copied()).collect();
328 (buf, fds)
329 }
330}
331impl crate::x11_utils::ReplyRequest for GetXIDListRequest {
332 type Reply = GetXIDListReply;
333}
334
335#[derive(Clone, Default)]
336#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
337#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
338pub struct GetXIDListReply {
339 pub sequence: u16,
340 pub length: u32,
341 pub ids: Vec<u32>,
342}
343impl_debug_if_no_extra_traits!(GetXIDListReply, "GetXIDListReply");
344impl TryParse for GetXIDListReply {
345 fn try_parse(initial_value: &[u8]) -> Result<(Self, &[u8]), ParseError> {
346 let remaining: &[u8] = initial_value;
347 let (response_type: u8, remaining: &[u8]) = u8::try_parse(remaining)?;
348 let remaining: &[u8] = remaining.get(1..).ok_or(err:ParseError::InsufficientData)?;
349 let (sequence: u16, remaining: &[u8]) = u16::try_parse(remaining)?;
350 let (length: u32, remaining: &[u8]) = u32::try_parse(remaining)?;
351 let (ids_len: u32, remaining: &[u8]) = u32::try_parse(remaining)?;
352 let remaining: &[u8] = remaining.get(20..).ok_or(err:ParseError::InsufficientData)?;
353 let (ids: Vec, remaining: &[u8]) = crate::x11_utils::parse_list::<u32>(data:remaining, list_length:ids_len.try_to_usize()?)?;
354 if response_type != 1 {
355 return Err(ParseError::InvalidValue);
356 }
357 let result: GetXIDListReply = GetXIDListReply { sequence, length, ids };
358 let _ = remaining;
359 let remaining: &[u8] = initial_value.get(32 + length as usize * 4..)
360 .ok_or(err:ParseError::InsufficientData)?;
361 Ok((result, remaining))
362 }
363}
364impl Serialize for GetXIDListReply {
365 type Bytes = Vec<u8>;
366 fn serialize(&self) -> Vec<u8> {
367 let mut result: Vec = Vec::new();
368 self.serialize_into(&mut result);
369 result
370 }
371 fn serialize_into(&self, bytes: &mut Vec<u8>) {
372 bytes.reserve(additional:32);
373 let response_type_bytes: &[u8; 1] = &[1];
374 bytes.push(response_type_bytes[0]);
375 bytes.extend_from_slice(&[0; 1]);
376 self.sequence.serialize_into(bytes);
377 self.length.serialize_into(bytes);
378 let ids_len: u32 = u32::try_from(self.ids.len()).expect(msg:"`ids` has too many elements");
379 ids_len.serialize_into(bytes);
380 bytes.extend_from_slice(&[0; 20]);
381 self.ids.serialize_into(bytes);
382 }
383}
384impl GetXIDListReply {
385 /// Get the value of the `ids_len` field.
386 ///
387 /// The `ids_len` field is used as the length field of the `ids` field.
388 /// This function computes the field's value again based on the length of the list.
389 ///
390 /// # Panics
391 ///
392 /// Panics if the value cannot be represented in the target type. This
393 /// cannot happen with values of the struct received from the X11 server.
394 pub fn ids_len(&self) -> u32 {
395 self.ids.len()
396 .try_into().unwrap()
397 }
398}
399
400