x11rb_protocol/protocol/
dri3.rs

1// This file contains generated code. Do not edit directly.
2// To regenerate this, run 'make'.
3
4//! Bindings to the `DRI3` 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#[allow(unused_imports)]
26use super::xproto;
27
28/// The X11 name of the extension for QueryExtension
29pub const X11_EXTENSION_NAME: &str = "DRI3";
30
31/// The version number of this extension that this client library supports.
32///
33/// This constant contains the version number of this extension that is supported
34/// by this build of x11rb. For most things, it does not make sense to use this
35/// information. If you need to send a `QueryVersion`, it is recommended to instead
36/// send the maximum version of the extension that you need.
37pub const X11_XML_VERSION: (u32, u32) = (1, 4);
38
39pub type Syncobj = u32;
40
41/// Opcode for the QueryVersion request
42pub const QUERY_VERSION_REQUEST: u8 = 0;
43#[derive(Clone, Copy, Default)]
44#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
45#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
46pub struct QueryVersionRequest {
47    pub major_version: u32,
48    pub minor_version: u32,
49}
50impl_debug_if_no_extra_traits!(QueryVersionRequest, "QueryVersionRequest");
51impl QueryVersionRequest {
52    /// Serialize this request into bytes for the provided connection
53    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'static, [u8]>; 1]> {
54        let length_so_far = 0;
55        let major_version_bytes = self.major_version.serialize();
56        let minor_version_bytes = self.minor_version.serialize();
57        let mut request0 = vec![
58            major_opcode,
59            QUERY_VERSION_REQUEST,
60            0,
61            0,
62            major_version_bytes[0],
63            major_version_bytes[1],
64            major_version_bytes[2],
65            major_version_bytes[3],
66            minor_version_bytes[0],
67            minor_version_bytes[1],
68            minor_version_bytes[2],
69            minor_version_bytes[3],
70        ];
71        let length_so_far = length_so_far + request0.len();
72        assert_eq!(length_so_far % 4, 0);
73        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
74        request0[2..4].copy_from_slice(&length.to_ne_bytes());
75        ([request0.into()], vec![])
76    }
77    /// Parse this request given its header, its body, and any fds that go along with it
78    #[cfg(feature = "request-parsing")]
79    pub fn try_parse_request(header: RequestHeader, value: &[u8]) -> Result<Self, ParseError> {
80        if header.minor_opcode != QUERY_VERSION_REQUEST {
81            return Err(ParseError::InvalidValue);
82        }
83        let (major_version, remaining) = u32::try_parse(value)?;
84        let (minor_version, remaining) = u32::try_parse(remaining)?;
85        let _ = remaining;
86        Ok(QueryVersionRequest {
87            major_version,
88            minor_version,
89        })
90    }
91}
92impl Request for QueryVersionRequest {
93    const EXTENSION_NAME: Option<&'static str> = Some(X11_EXTENSION_NAME);
94
95    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
96        let (bufs, fds) = self.serialize(major_opcode);
97        // Flatten the buffers into a single vector
98        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
99        (buf, fds)
100    }
101}
102impl crate::x11_utils::ReplyRequest for QueryVersionRequest {
103    type Reply = QueryVersionReply;
104}
105
106#[derive(Clone, Copy, Default)]
107#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
108#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
109pub struct QueryVersionReply {
110    pub sequence: u16,
111    pub length: u32,
112    pub major_version: u32,
113    pub minor_version: u32,
114}
115impl_debug_if_no_extra_traits!(QueryVersionReply, "QueryVersionReply");
116impl TryParse for QueryVersionReply {
117    fn try_parse(initial_value: &[u8]) -> Result<(Self, &[u8]), ParseError> {
118        let remaining = initial_value;
119        let (response_type, remaining) = u8::try_parse(remaining)?;
120        let remaining = remaining.get(1..).ok_or(ParseError::InsufficientData)?;
121        let (sequence, remaining) = u16::try_parse(remaining)?;
122        let (length, remaining) = u32::try_parse(remaining)?;
123        let (major_version, remaining) = u32::try_parse(remaining)?;
124        let (minor_version, remaining) = u32::try_parse(remaining)?;
125        if response_type != 1 {
126            return Err(ParseError::InvalidValue);
127        }
128        let result = QueryVersionReply { sequence, length, major_version, minor_version };
129        let _ = remaining;
130        let remaining = initial_value.get(32 + length as usize * 4..)
131            .ok_or(ParseError::InsufficientData)?;
132        Ok((result, remaining))
133    }
134}
135impl Serialize for QueryVersionReply {
136    type Bytes = [u8; 16];
137    fn serialize(&self) -> [u8; 16] {
138        let response_type_bytes = &[1];
139        let sequence_bytes = self.sequence.serialize();
140        let length_bytes = self.length.serialize();
141        let major_version_bytes = self.major_version.serialize();
142        let minor_version_bytes = self.minor_version.serialize();
143        [
144            response_type_bytes[0],
145            0,
146            sequence_bytes[0],
147            sequence_bytes[1],
148            length_bytes[0],
149            length_bytes[1],
150            length_bytes[2],
151            length_bytes[3],
152            major_version_bytes[0],
153            major_version_bytes[1],
154            major_version_bytes[2],
155            major_version_bytes[3],
156            minor_version_bytes[0],
157            minor_version_bytes[1],
158            minor_version_bytes[2],
159            minor_version_bytes[3],
160        ]
161    }
162    fn serialize_into(&self, bytes: &mut Vec<u8>) {
163        bytes.reserve(16);
164        let response_type_bytes = &[1];
165        bytes.push(response_type_bytes[0]);
166        bytes.extend_from_slice(&[0; 1]);
167        self.sequence.serialize_into(bytes);
168        self.length.serialize_into(bytes);
169        self.major_version.serialize_into(bytes);
170        self.minor_version.serialize_into(bytes);
171    }
172}
173
174/// Opcode for the Open request
175pub const OPEN_REQUEST: u8 = 1;
176#[derive(Clone, Copy, Default)]
177#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
178#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
179pub struct OpenRequest {
180    pub drawable: xproto::Drawable,
181    pub provider: u32,
182}
183impl_debug_if_no_extra_traits!(OpenRequest, "OpenRequest");
184impl OpenRequest {
185    /// Serialize this request into bytes for the provided connection
186    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'static, [u8]>; 1]> {
187        let length_so_far = 0;
188        let drawable_bytes = self.drawable.serialize();
189        let provider_bytes = self.provider.serialize();
190        let mut request0 = vec![
191            major_opcode,
192            OPEN_REQUEST,
193            0,
194            0,
195            drawable_bytes[0],
196            drawable_bytes[1],
197            drawable_bytes[2],
198            drawable_bytes[3],
199            provider_bytes[0],
200            provider_bytes[1],
201            provider_bytes[2],
202            provider_bytes[3],
203        ];
204        let length_so_far = length_so_far + request0.len();
205        assert_eq!(length_so_far % 4, 0);
206        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
207        request0[2..4].copy_from_slice(&length.to_ne_bytes());
208        ([request0.into()], vec![])
209    }
210    /// Parse this request given its header, its body, and any fds that go along with it
211    #[cfg(feature = "request-parsing")]
212    pub fn try_parse_request(header: RequestHeader, value: &[u8]) -> Result<Self, ParseError> {
213        if header.minor_opcode != OPEN_REQUEST {
214            return Err(ParseError::InvalidValue);
215        }
216        let (drawable, remaining) = xproto::Drawable::try_parse(value)?;
217        let (provider, remaining) = u32::try_parse(remaining)?;
218        let _ = remaining;
219        Ok(OpenRequest {
220            drawable,
221            provider,
222        })
223    }
224}
225impl Request for OpenRequest {
226    const EXTENSION_NAME: Option<&'static str> = Some(X11_EXTENSION_NAME);
227
228    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
229        let (bufs, fds) = self.serialize(major_opcode);
230        // Flatten the buffers into a single vector
231        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
232        (buf, fds)
233    }
234}
235impl crate::x11_utils::ReplyFDsRequest for OpenRequest {
236    type Reply = OpenReply;
237}
238
239#[cfg_attr(feature = "extra-traits", derive(Debug))]
240pub struct OpenReply {
241    pub nfd: u8,
242    pub sequence: u16,
243    pub length: u32,
244    pub device_fd: RawFdContainer,
245}
246impl_debug_if_no_extra_traits!(OpenReply, "OpenReply");
247impl TryParseFd for OpenReply {
248    fn try_parse_fd<'a>(initial_value: &'a [u8], fds: &mut Vec<RawFdContainer>) -> Result<(Self, &'a [u8]), ParseError> {
249        let remaining = initial_value;
250        let (response_type, remaining) = u8::try_parse(remaining)?;
251        let (nfd, remaining) = u8::try_parse(remaining)?;
252        let (sequence, remaining) = u16::try_parse(remaining)?;
253        let (length, remaining) = u32::try_parse(remaining)?;
254        if fds.is_empty() { return Err(ParseError::MissingFileDescriptors) }
255        let device_fd = fds.remove(0);
256        let remaining = remaining.get(24..).ok_or(ParseError::InsufficientData)?;
257        if response_type != 1 {
258            return Err(ParseError::InvalidValue);
259        }
260        let result = OpenReply { nfd, sequence, length, device_fd };
261        let _ = remaining;
262        let remaining = initial_value.get(32 + length as usize * 4..)
263            .ok_or(ParseError::InsufficientData)?;
264        Ok((result, remaining))
265    }
266}
267impl Serialize for OpenReply {
268    type Bytes = [u8; 32];
269    fn serialize(&self) -> [u8; 32] {
270        let response_type_bytes = &[1];
271        let nfd_bytes = self.nfd.serialize();
272        let sequence_bytes = self.sequence.serialize();
273        let length_bytes = self.length.serialize();
274        [
275            response_type_bytes[0],
276            nfd_bytes[0],
277            sequence_bytes[0],
278            sequence_bytes[1],
279            length_bytes[0],
280            length_bytes[1],
281            length_bytes[2],
282            length_bytes[3],
283            0,
284            0,
285            0,
286            0,
287            0,
288            0,
289            0,
290            0,
291            0,
292            0,
293            0,
294            0,
295            0,
296            0,
297            0,
298            0,
299            0,
300            0,
301            0,
302            0,
303            0,
304            0,
305            0,
306            0,
307        ]
308    }
309    fn serialize_into(&self, bytes: &mut Vec<u8>) {
310        bytes.reserve(32);
311        let response_type_bytes = &[1];
312        bytes.push(response_type_bytes[0]);
313        self.nfd.serialize_into(bytes);
314        self.sequence.serialize_into(bytes);
315        self.length.serialize_into(bytes);
316        bytes.extend_from_slice(&[0; 24]);
317    }
318}
319
320/// Opcode for the PixmapFromBuffer request
321pub const PIXMAP_FROM_BUFFER_REQUEST: u8 = 2;
322#[cfg_attr(feature = "extra-traits", derive(Debug))]
323pub struct PixmapFromBufferRequest {
324    pub pixmap: xproto::Pixmap,
325    pub drawable: xproto::Drawable,
326    pub size: u32,
327    pub width: u16,
328    pub height: u16,
329    pub stride: u16,
330    pub depth: u8,
331    pub bpp: u8,
332    pub pixmap_fd: RawFdContainer,
333}
334impl_debug_if_no_extra_traits!(PixmapFromBufferRequest, "PixmapFromBufferRequest");
335impl PixmapFromBufferRequest {
336    /// Serialize this request into bytes for the provided connection
337    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'static, [u8]>; 1]> {
338        let length_so_far = 0;
339        let pixmap_bytes = self.pixmap.serialize();
340        let drawable_bytes = self.drawable.serialize();
341        let size_bytes = self.size.serialize();
342        let width_bytes = self.width.serialize();
343        let height_bytes = self.height.serialize();
344        let stride_bytes = self.stride.serialize();
345        let depth_bytes = self.depth.serialize();
346        let bpp_bytes = self.bpp.serialize();
347        let mut request0 = vec![
348            major_opcode,
349            PIXMAP_FROM_BUFFER_REQUEST,
350            0,
351            0,
352            pixmap_bytes[0],
353            pixmap_bytes[1],
354            pixmap_bytes[2],
355            pixmap_bytes[3],
356            drawable_bytes[0],
357            drawable_bytes[1],
358            drawable_bytes[2],
359            drawable_bytes[3],
360            size_bytes[0],
361            size_bytes[1],
362            size_bytes[2],
363            size_bytes[3],
364            width_bytes[0],
365            width_bytes[1],
366            height_bytes[0],
367            height_bytes[1],
368            stride_bytes[0],
369            stride_bytes[1],
370            depth_bytes[0],
371            bpp_bytes[0],
372        ];
373        let length_so_far = length_so_far + request0.len();
374        assert_eq!(length_so_far % 4, 0);
375        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
376        request0[2..4].copy_from_slice(&length.to_ne_bytes());
377        ([request0.into()], vec![self.pixmap_fd])
378    }
379    /// Parse this request given its header, its body, and any fds that go along with it
380    #[cfg(feature = "request-parsing")]
381    pub fn try_parse_request_fd(header: RequestHeader, value: &[u8], fds: &mut Vec<RawFdContainer>) -> Result<Self, ParseError> {
382        if header.minor_opcode != PIXMAP_FROM_BUFFER_REQUEST {
383            return Err(ParseError::InvalidValue);
384        }
385        let (pixmap, remaining) = xproto::Pixmap::try_parse(value)?;
386        let (drawable, remaining) = xproto::Drawable::try_parse(remaining)?;
387        let (size, remaining) = u32::try_parse(remaining)?;
388        let (width, remaining) = u16::try_parse(remaining)?;
389        let (height, remaining) = u16::try_parse(remaining)?;
390        let (stride, remaining) = u16::try_parse(remaining)?;
391        let (depth, remaining) = u8::try_parse(remaining)?;
392        let (bpp, remaining) = u8::try_parse(remaining)?;
393        if fds.is_empty() { return Err(ParseError::MissingFileDescriptors) }
394        let pixmap_fd = fds.remove(0);
395        let _ = remaining;
396        Ok(PixmapFromBufferRequest {
397            pixmap,
398            drawable,
399            size,
400            width,
401            height,
402            stride,
403            depth,
404            bpp,
405            pixmap_fd,
406        })
407    }
408}
409impl Request for PixmapFromBufferRequest {
410    const EXTENSION_NAME: Option<&'static str> = Some(X11_EXTENSION_NAME);
411
412    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
413        let (bufs, fds) = self.serialize(major_opcode);
414        // Flatten the buffers into a single vector
415        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
416        (buf, fds)
417    }
418}
419impl crate::x11_utils::VoidRequest for PixmapFromBufferRequest {
420}
421
422/// Opcode for the BufferFromPixmap request
423pub const BUFFER_FROM_PIXMAP_REQUEST: u8 = 3;
424#[derive(Clone, Copy, Default)]
425#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
426#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
427pub struct BufferFromPixmapRequest {
428    pub pixmap: xproto::Pixmap,
429}
430impl_debug_if_no_extra_traits!(BufferFromPixmapRequest, "BufferFromPixmapRequest");
431impl BufferFromPixmapRequest {
432    /// Serialize this request into bytes for the provided connection
433    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'static, [u8]>; 1]> {
434        let length_so_far = 0;
435        let pixmap_bytes = self.pixmap.serialize();
436        let mut request0 = vec![
437            major_opcode,
438            BUFFER_FROM_PIXMAP_REQUEST,
439            0,
440            0,
441            pixmap_bytes[0],
442            pixmap_bytes[1],
443            pixmap_bytes[2],
444            pixmap_bytes[3],
445        ];
446        let length_so_far = length_so_far + request0.len();
447        assert_eq!(length_so_far % 4, 0);
448        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
449        request0[2..4].copy_from_slice(&length.to_ne_bytes());
450        ([request0.into()], vec![])
451    }
452    /// Parse this request given its header, its body, and any fds that go along with it
453    #[cfg(feature = "request-parsing")]
454    pub fn try_parse_request(header: RequestHeader, value: &[u8]) -> Result<Self, ParseError> {
455        if header.minor_opcode != BUFFER_FROM_PIXMAP_REQUEST {
456            return Err(ParseError::InvalidValue);
457        }
458        let (pixmap, remaining) = xproto::Pixmap::try_parse(value)?;
459        let _ = remaining;
460        Ok(BufferFromPixmapRequest {
461            pixmap,
462        })
463    }
464}
465impl Request for BufferFromPixmapRequest {
466    const EXTENSION_NAME: Option<&'static str> = Some(X11_EXTENSION_NAME);
467
468    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
469        let (bufs, fds) = self.serialize(major_opcode);
470        // Flatten the buffers into a single vector
471        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
472        (buf, fds)
473    }
474}
475impl crate::x11_utils::ReplyFDsRequest for BufferFromPixmapRequest {
476    type Reply = BufferFromPixmapReply;
477}
478
479#[cfg_attr(feature = "extra-traits", derive(Debug))]
480pub struct BufferFromPixmapReply {
481    pub nfd: u8,
482    pub sequence: u16,
483    pub length: u32,
484    pub size: u32,
485    pub width: u16,
486    pub height: u16,
487    pub stride: u16,
488    pub depth: u8,
489    pub bpp: u8,
490    pub pixmap_fd: RawFdContainer,
491}
492impl_debug_if_no_extra_traits!(BufferFromPixmapReply, "BufferFromPixmapReply");
493impl TryParseFd for BufferFromPixmapReply {
494    fn try_parse_fd<'a>(initial_value: &'a [u8], fds: &mut Vec<RawFdContainer>) -> Result<(Self, &'a [u8]), ParseError> {
495        let remaining = initial_value;
496        let (response_type, remaining) = u8::try_parse(remaining)?;
497        let (nfd, remaining) = u8::try_parse(remaining)?;
498        let (sequence, remaining) = u16::try_parse(remaining)?;
499        let (length, remaining) = u32::try_parse(remaining)?;
500        let (size, remaining) = u32::try_parse(remaining)?;
501        let (width, remaining) = u16::try_parse(remaining)?;
502        let (height, remaining) = u16::try_parse(remaining)?;
503        let (stride, remaining) = u16::try_parse(remaining)?;
504        let (depth, remaining) = u8::try_parse(remaining)?;
505        let (bpp, remaining) = u8::try_parse(remaining)?;
506        if fds.is_empty() { return Err(ParseError::MissingFileDescriptors) }
507        let pixmap_fd = fds.remove(0);
508        let remaining = remaining.get(12..).ok_or(ParseError::InsufficientData)?;
509        if response_type != 1 {
510            return Err(ParseError::InvalidValue);
511        }
512        let result = BufferFromPixmapReply { nfd, sequence, length, size, width, height, stride, depth, bpp, pixmap_fd };
513        let _ = remaining;
514        let remaining = initial_value.get(32 + length as usize * 4..)
515            .ok_or(ParseError::InsufficientData)?;
516        Ok((result, remaining))
517    }
518}
519impl Serialize for BufferFromPixmapReply {
520    type Bytes = [u8; 32];
521    fn serialize(&self) -> [u8; 32] {
522        let response_type_bytes = &[1];
523        let nfd_bytes = self.nfd.serialize();
524        let sequence_bytes = self.sequence.serialize();
525        let length_bytes = self.length.serialize();
526        let size_bytes = self.size.serialize();
527        let width_bytes = self.width.serialize();
528        let height_bytes = self.height.serialize();
529        let stride_bytes = self.stride.serialize();
530        let depth_bytes = self.depth.serialize();
531        let bpp_bytes = self.bpp.serialize();
532        [
533            response_type_bytes[0],
534            nfd_bytes[0],
535            sequence_bytes[0],
536            sequence_bytes[1],
537            length_bytes[0],
538            length_bytes[1],
539            length_bytes[2],
540            length_bytes[3],
541            size_bytes[0],
542            size_bytes[1],
543            size_bytes[2],
544            size_bytes[3],
545            width_bytes[0],
546            width_bytes[1],
547            height_bytes[0],
548            height_bytes[1],
549            stride_bytes[0],
550            stride_bytes[1],
551            depth_bytes[0],
552            bpp_bytes[0],
553            0,
554            0,
555            0,
556            0,
557            0,
558            0,
559            0,
560            0,
561            0,
562            0,
563            0,
564            0,
565        ]
566    }
567    fn serialize_into(&self, bytes: &mut Vec<u8>) {
568        bytes.reserve(32);
569        let response_type_bytes = &[1];
570        bytes.push(response_type_bytes[0]);
571        self.nfd.serialize_into(bytes);
572        self.sequence.serialize_into(bytes);
573        self.length.serialize_into(bytes);
574        self.size.serialize_into(bytes);
575        self.width.serialize_into(bytes);
576        self.height.serialize_into(bytes);
577        self.stride.serialize_into(bytes);
578        self.depth.serialize_into(bytes);
579        self.bpp.serialize_into(bytes);
580        bytes.extend_from_slice(&[0; 12]);
581    }
582}
583
584/// Opcode for the FenceFromFD request
585pub const FENCE_FROM_FD_REQUEST: u8 = 4;
586#[cfg_attr(feature = "extra-traits", derive(Debug))]
587pub struct FenceFromFDRequest {
588    pub drawable: xproto::Drawable,
589    pub fence: u32,
590    pub initially_triggered: bool,
591    pub fence_fd: RawFdContainer,
592}
593impl_debug_if_no_extra_traits!(FenceFromFDRequest, "FenceFromFDRequest");
594impl FenceFromFDRequest {
595    /// Serialize this request into bytes for the provided connection
596    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'static, [u8]>; 1]> {
597        let length_so_far = 0;
598        let drawable_bytes = self.drawable.serialize();
599        let fence_bytes = self.fence.serialize();
600        let initially_triggered_bytes = self.initially_triggered.serialize();
601        let mut request0 = vec![
602            major_opcode,
603            FENCE_FROM_FD_REQUEST,
604            0,
605            0,
606            drawable_bytes[0],
607            drawable_bytes[1],
608            drawable_bytes[2],
609            drawable_bytes[3],
610            fence_bytes[0],
611            fence_bytes[1],
612            fence_bytes[2],
613            fence_bytes[3],
614            initially_triggered_bytes[0],
615            0,
616            0,
617            0,
618        ];
619        let length_so_far = length_so_far + request0.len();
620        assert_eq!(length_so_far % 4, 0);
621        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
622        request0[2..4].copy_from_slice(&length.to_ne_bytes());
623        ([request0.into()], vec![self.fence_fd])
624    }
625    /// Parse this request given its header, its body, and any fds that go along with it
626    #[cfg(feature = "request-parsing")]
627    pub fn try_parse_request_fd(header: RequestHeader, value: &[u8], fds: &mut Vec<RawFdContainer>) -> Result<Self, ParseError> {
628        if header.minor_opcode != FENCE_FROM_FD_REQUEST {
629            return Err(ParseError::InvalidValue);
630        }
631        let (drawable, remaining) = xproto::Drawable::try_parse(value)?;
632        let (fence, remaining) = u32::try_parse(remaining)?;
633        let (initially_triggered, remaining) = bool::try_parse(remaining)?;
634        let remaining = remaining.get(3..).ok_or(ParseError::InsufficientData)?;
635        if fds.is_empty() { return Err(ParseError::MissingFileDescriptors) }
636        let fence_fd = fds.remove(0);
637        let _ = remaining;
638        Ok(FenceFromFDRequest {
639            drawable,
640            fence,
641            initially_triggered,
642            fence_fd,
643        })
644    }
645}
646impl Request for FenceFromFDRequest {
647    const EXTENSION_NAME: Option<&'static str> = Some(X11_EXTENSION_NAME);
648
649    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
650        let (bufs, fds) = self.serialize(major_opcode);
651        // Flatten the buffers into a single vector
652        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
653        (buf, fds)
654    }
655}
656impl crate::x11_utils::VoidRequest for FenceFromFDRequest {
657}
658
659/// Opcode for the FDFromFence request
660pub const FD_FROM_FENCE_REQUEST: u8 = 5;
661#[derive(Clone, Copy, Default)]
662#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
663#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
664pub struct FDFromFenceRequest {
665    pub drawable: xproto::Drawable,
666    pub fence: u32,
667}
668impl_debug_if_no_extra_traits!(FDFromFenceRequest, "FDFromFenceRequest");
669impl FDFromFenceRequest {
670    /// Serialize this request into bytes for the provided connection
671    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'static, [u8]>; 1]> {
672        let length_so_far = 0;
673        let drawable_bytes = self.drawable.serialize();
674        let fence_bytes = self.fence.serialize();
675        let mut request0 = vec![
676            major_opcode,
677            FD_FROM_FENCE_REQUEST,
678            0,
679            0,
680            drawable_bytes[0],
681            drawable_bytes[1],
682            drawable_bytes[2],
683            drawable_bytes[3],
684            fence_bytes[0],
685            fence_bytes[1],
686            fence_bytes[2],
687            fence_bytes[3],
688        ];
689        let length_so_far = length_so_far + request0.len();
690        assert_eq!(length_so_far % 4, 0);
691        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
692        request0[2..4].copy_from_slice(&length.to_ne_bytes());
693        ([request0.into()], vec![])
694    }
695    /// Parse this request given its header, its body, and any fds that go along with it
696    #[cfg(feature = "request-parsing")]
697    pub fn try_parse_request(header: RequestHeader, value: &[u8]) -> Result<Self, ParseError> {
698        if header.minor_opcode != FD_FROM_FENCE_REQUEST {
699            return Err(ParseError::InvalidValue);
700        }
701        let (drawable, remaining) = xproto::Drawable::try_parse(value)?;
702        let (fence, remaining) = u32::try_parse(remaining)?;
703        let _ = remaining;
704        Ok(FDFromFenceRequest {
705            drawable,
706            fence,
707        })
708    }
709}
710impl Request for FDFromFenceRequest {
711    const EXTENSION_NAME: Option<&'static str> = Some(X11_EXTENSION_NAME);
712
713    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
714        let (bufs, fds) = self.serialize(major_opcode);
715        // Flatten the buffers into a single vector
716        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
717        (buf, fds)
718    }
719}
720impl crate::x11_utils::ReplyFDsRequest for FDFromFenceRequest {
721    type Reply = FDFromFenceReply;
722}
723
724#[cfg_attr(feature = "extra-traits", derive(Debug))]
725pub struct FDFromFenceReply {
726    pub nfd: u8,
727    pub sequence: u16,
728    pub length: u32,
729    pub fence_fd: RawFdContainer,
730}
731impl_debug_if_no_extra_traits!(FDFromFenceReply, "FDFromFenceReply");
732impl TryParseFd for FDFromFenceReply {
733    fn try_parse_fd<'a>(initial_value: &'a [u8], fds: &mut Vec<RawFdContainer>) -> Result<(Self, &'a [u8]), ParseError> {
734        let remaining = initial_value;
735        let (response_type, remaining) = u8::try_parse(remaining)?;
736        let (nfd, remaining) = u8::try_parse(remaining)?;
737        let (sequence, remaining) = u16::try_parse(remaining)?;
738        let (length, remaining) = u32::try_parse(remaining)?;
739        if fds.is_empty() { return Err(ParseError::MissingFileDescriptors) }
740        let fence_fd = fds.remove(0);
741        let remaining = remaining.get(24..).ok_or(ParseError::InsufficientData)?;
742        if response_type != 1 {
743            return Err(ParseError::InvalidValue);
744        }
745        let result = FDFromFenceReply { nfd, sequence, length, fence_fd };
746        let _ = remaining;
747        let remaining = initial_value.get(32 + length as usize * 4..)
748            .ok_or(ParseError::InsufficientData)?;
749        Ok((result, remaining))
750    }
751}
752impl Serialize for FDFromFenceReply {
753    type Bytes = [u8; 32];
754    fn serialize(&self) -> [u8; 32] {
755        let response_type_bytes = &[1];
756        let nfd_bytes = self.nfd.serialize();
757        let sequence_bytes = self.sequence.serialize();
758        let length_bytes = self.length.serialize();
759        [
760            response_type_bytes[0],
761            nfd_bytes[0],
762            sequence_bytes[0],
763            sequence_bytes[1],
764            length_bytes[0],
765            length_bytes[1],
766            length_bytes[2],
767            length_bytes[3],
768            0,
769            0,
770            0,
771            0,
772            0,
773            0,
774            0,
775            0,
776            0,
777            0,
778            0,
779            0,
780            0,
781            0,
782            0,
783            0,
784            0,
785            0,
786            0,
787            0,
788            0,
789            0,
790            0,
791            0,
792        ]
793    }
794    fn serialize_into(&self, bytes: &mut Vec<u8>) {
795        bytes.reserve(32);
796        let response_type_bytes = &[1];
797        bytes.push(response_type_bytes[0]);
798        self.nfd.serialize_into(bytes);
799        self.sequence.serialize_into(bytes);
800        self.length.serialize_into(bytes);
801        bytes.extend_from_slice(&[0; 24]);
802    }
803}
804
805/// Opcode for the GetSupportedModifiers request
806pub const GET_SUPPORTED_MODIFIERS_REQUEST: u8 = 6;
807#[derive(Clone, Copy, Default)]
808#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
809#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
810pub struct GetSupportedModifiersRequest {
811    pub window: u32,
812    pub depth: u8,
813    pub bpp: u8,
814}
815impl_debug_if_no_extra_traits!(GetSupportedModifiersRequest, "GetSupportedModifiersRequest");
816impl GetSupportedModifiersRequest {
817    /// Serialize this request into bytes for the provided connection
818    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'static, [u8]>; 1]> {
819        let length_so_far = 0;
820        let window_bytes = self.window.serialize();
821        let depth_bytes = self.depth.serialize();
822        let bpp_bytes = self.bpp.serialize();
823        let mut request0 = vec![
824            major_opcode,
825            GET_SUPPORTED_MODIFIERS_REQUEST,
826            0,
827            0,
828            window_bytes[0],
829            window_bytes[1],
830            window_bytes[2],
831            window_bytes[3],
832            depth_bytes[0],
833            bpp_bytes[0],
834            0,
835            0,
836        ];
837        let length_so_far = length_so_far + request0.len();
838        assert_eq!(length_so_far % 4, 0);
839        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
840        request0[2..4].copy_from_slice(&length.to_ne_bytes());
841        ([request0.into()], vec![])
842    }
843    /// Parse this request given its header, its body, and any fds that go along with it
844    #[cfg(feature = "request-parsing")]
845    pub fn try_parse_request(header: RequestHeader, value: &[u8]) -> Result<Self, ParseError> {
846        if header.minor_opcode != GET_SUPPORTED_MODIFIERS_REQUEST {
847            return Err(ParseError::InvalidValue);
848        }
849        let (window, remaining) = u32::try_parse(value)?;
850        let (depth, remaining) = u8::try_parse(remaining)?;
851        let (bpp, remaining) = u8::try_parse(remaining)?;
852        let remaining = remaining.get(2..).ok_or(ParseError::InsufficientData)?;
853        let _ = remaining;
854        Ok(GetSupportedModifiersRequest {
855            window,
856            depth,
857            bpp,
858        })
859    }
860}
861impl Request for GetSupportedModifiersRequest {
862    const EXTENSION_NAME: Option<&'static str> = Some(X11_EXTENSION_NAME);
863
864    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
865        let (bufs, fds) = self.serialize(major_opcode);
866        // Flatten the buffers into a single vector
867        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
868        (buf, fds)
869    }
870}
871impl crate::x11_utils::ReplyRequest for GetSupportedModifiersRequest {
872    type Reply = GetSupportedModifiersReply;
873}
874
875#[derive(Clone, Default)]
876#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
877#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
878pub struct GetSupportedModifiersReply {
879    pub sequence: u16,
880    pub length: u32,
881    pub window_modifiers: Vec<u64>,
882    pub screen_modifiers: Vec<u64>,
883}
884impl_debug_if_no_extra_traits!(GetSupportedModifiersReply, "GetSupportedModifiersReply");
885impl TryParse for GetSupportedModifiersReply {
886    fn try_parse(initial_value: &[u8]) -> Result<(Self, &[u8]), ParseError> {
887        let remaining = initial_value;
888        let (response_type, remaining) = u8::try_parse(remaining)?;
889        let remaining = remaining.get(1..).ok_or(ParseError::InsufficientData)?;
890        let (sequence, remaining) = u16::try_parse(remaining)?;
891        let (length, remaining) = u32::try_parse(remaining)?;
892        let (num_window_modifiers, remaining) = u32::try_parse(remaining)?;
893        let (num_screen_modifiers, remaining) = u32::try_parse(remaining)?;
894        let remaining = remaining.get(16..).ok_or(ParseError::InsufficientData)?;
895        let (window_modifiers, remaining) = crate::x11_utils::parse_list::<u64>(remaining, num_window_modifiers.try_to_usize()?)?;
896        let (screen_modifiers, remaining) = crate::x11_utils::parse_list::<u64>(remaining, num_screen_modifiers.try_to_usize()?)?;
897        if response_type != 1 {
898            return Err(ParseError::InvalidValue);
899        }
900        let result = GetSupportedModifiersReply { sequence, length, window_modifiers, screen_modifiers };
901        let _ = remaining;
902        let remaining = initial_value.get(32 + length as usize * 4..)
903            .ok_or(ParseError::InsufficientData)?;
904        Ok((result, remaining))
905    }
906}
907impl Serialize for GetSupportedModifiersReply {
908    type Bytes = Vec<u8>;
909    fn serialize(&self) -> Vec<u8> {
910        let mut result = Vec::new();
911        self.serialize_into(&mut result);
912        result
913    }
914    fn serialize_into(&self, bytes: &mut Vec<u8>) {
915        bytes.reserve(32);
916        let response_type_bytes = &[1];
917        bytes.push(response_type_bytes[0]);
918        bytes.extend_from_slice(&[0; 1]);
919        self.sequence.serialize_into(bytes);
920        self.length.serialize_into(bytes);
921        let num_window_modifiers = u32::try_from(self.window_modifiers.len()).expect("`window_modifiers` has too many elements");
922        num_window_modifiers.serialize_into(bytes);
923        let num_screen_modifiers = u32::try_from(self.screen_modifiers.len()).expect("`screen_modifiers` has too many elements");
924        num_screen_modifiers.serialize_into(bytes);
925        bytes.extend_from_slice(&[0; 16]);
926        self.window_modifiers.serialize_into(bytes);
927        self.screen_modifiers.serialize_into(bytes);
928    }
929}
930impl GetSupportedModifiersReply {
931    /// Get the value of the `num_window_modifiers` field.
932    ///
933    /// The `num_window_modifiers` field is used as the length field of the `window_modifiers` field.
934    /// This function computes the field's value again based on the length of the list.
935    ///
936    /// # Panics
937    ///
938    /// Panics if the value cannot be represented in the target type. This
939    /// cannot happen with values of the struct received from the X11 server.
940    pub fn num_window_modifiers(&self) -> u32 {
941        self.window_modifiers.len()
942            .try_into().unwrap()
943    }
944    /// Get the value of the `num_screen_modifiers` field.
945    ///
946    /// The `num_screen_modifiers` field is used as the length field of the `screen_modifiers` field.
947    /// This function computes the field's value again based on the length of the list.
948    ///
949    /// # Panics
950    ///
951    /// Panics if the value cannot be represented in the target type. This
952    /// cannot happen with values of the struct received from the X11 server.
953    pub fn num_screen_modifiers(&self) -> u32 {
954        self.screen_modifiers.len()
955            .try_into().unwrap()
956    }
957}
958
959/// Opcode for the PixmapFromBuffers request
960pub const PIXMAP_FROM_BUFFERS_REQUEST: u8 = 7;
961#[cfg_attr(feature = "extra-traits", derive(Debug))]
962pub struct PixmapFromBuffersRequest {
963    pub pixmap: xproto::Pixmap,
964    pub window: xproto::Window,
965    pub width: u16,
966    pub height: u16,
967    pub stride0: u32,
968    pub offset0: u32,
969    pub stride1: u32,
970    pub offset1: u32,
971    pub stride2: u32,
972    pub offset2: u32,
973    pub stride3: u32,
974    pub offset3: u32,
975    pub depth: u8,
976    pub bpp: u8,
977    pub modifier: u64,
978    pub buffers: Vec<RawFdContainer>,
979}
980impl_debug_if_no_extra_traits!(PixmapFromBuffersRequest, "PixmapFromBuffersRequest");
981impl PixmapFromBuffersRequest {
982    /// Serialize this request into bytes for the provided connection
983    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'static, [u8]>; 1]> {
984        let length_so_far = 0;
985        let pixmap_bytes = self.pixmap.serialize();
986        let window_bytes = self.window.serialize();
987        let num_buffers = u8::try_from(self.buffers.len()).expect("`buffers` has too many elements");
988        let num_buffers_bytes = num_buffers.serialize();
989        let width_bytes = self.width.serialize();
990        let height_bytes = self.height.serialize();
991        let stride0_bytes = self.stride0.serialize();
992        let offset0_bytes = self.offset0.serialize();
993        let stride1_bytes = self.stride1.serialize();
994        let offset1_bytes = self.offset1.serialize();
995        let stride2_bytes = self.stride2.serialize();
996        let offset2_bytes = self.offset2.serialize();
997        let stride3_bytes = self.stride3.serialize();
998        let offset3_bytes = self.offset3.serialize();
999        let depth_bytes = self.depth.serialize();
1000        let bpp_bytes = self.bpp.serialize();
1001        let modifier_bytes = self.modifier.serialize();
1002        let mut request0 = vec![
1003            major_opcode,
1004            PIXMAP_FROM_BUFFERS_REQUEST,
1005            0,
1006            0,
1007            pixmap_bytes[0],
1008            pixmap_bytes[1],
1009            pixmap_bytes[2],
1010            pixmap_bytes[3],
1011            window_bytes[0],
1012            window_bytes[1],
1013            window_bytes[2],
1014            window_bytes[3],
1015            num_buffers_bytes[0],
1016            0,
1017            0,
1018            0,
1019            width_bytes[0],
1020            width_bytes[1],
1021            height_bytes[0],
1022            height_bytes[1],
1023            stride0_bytes[0],
1024            stride0_bytes[1],
1025            stride0_bytes[2],
1026            stride0_bytes[3],
1027            offset0_bytes[0],
1028            offset0_bytes[1],
1029            offset0_bytes[2],
1030            offset0_bytes[3],
1031            stride1_bytes[0],
1032            stride1_bytes[1],
1033            stride1_bytes[2],
1034            stride1_bytes[3],
1035            offset1_bytes[0],
1036            offset1_bytes[1],
1037            offset1_bytes[2],
1038            offset1_bytes[3],
1039            stride2_bytes[0],
1040            stride2_bytes[1],
1041            stride2_bytes[2],
1042            stride2_bytes[3],
1043            offset2_bytes[0],
1044            offset2_bytes[1],
1045            offset2_bytes[2],
1046            offset2_bytes[3],
1047            stride3_bytes[0],
1048            stride3_bytes[1],
1049            stride3_bytes[2],
1050            stride3_bytes[3],
1051            offset3_bytes[0],
1052            offset3_bytes[1],
1053            offset3_bytes[2],
1054            offset3_bytes[3],
1055            depth_bytes[0],
1056            bpp_bytes[0],
1057            0,
1058            0,
1059            modifier_bytes[0],
1060            modifier_bytes[1],
1061            modifier_bytes[2],
1062            modifier_bytes[3],
1063            modifier_bytes[4],
1064            modifier_bytes[5],
1065            modifier_bytes[6],
1066            modifier_bytes[7],
1067        ];
1068        let length_so_far = length_so_far + request0.len();
1069        assert_eq!(length_so_far % 4, 0);
1070        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
1071        request0[2..4].copy_from_slice(&length.to_ne_bytes());
1072        ([request0.into()], self.buffers)
1073    }
1074    /// Parse this request given its header, its body, and any fds that go along with it
1075    #[cfg(feature = "request-parsing")]
1076    pub fn try_parse_request_fd(header: RequestHeader, value: &[u8], fds: &mut Vec<RawFdContainer>) -> Result<Self, ParseError> {
1077        if header.minor_opcode != PIXMAP_FROM_BUFFERS_REQUEST {
1078            return Err(ParseError::InvalidValue);
1079        }
1080        let (pixmap, remaining) = xproto::Pixmap::try_parse(value)?;
1081        let (window, remaining) = xproto::Window::try_parse(remaining)?;
1082        let (num_buffers, remaining) = u8::try_parse(remaining)?;
1083        let remaining = remaining.get(3..).ok_or(ParseError::InsufficientData)?;
1084        let (width, remaining) = u16::try_parse(remaining)?;
1085        let (height, remaining) = u16::try_parse(remaining)?;
1086        let (stride0, remaining) = u32::try_parse(remaining)?;
1087        let (offset0, remaining) = u32::try_parse(remaining)?;
1088        let (stride1, remaining) = u32::try_parse(remaining)?;
1089        let (offset1, remaining) = u32::try_parse(remaining)?;
1090        let (stride2, remaining) = u32::try_parse(remaining)?;
1091        let (offset2, remaining) = u32::try_parse(remaining)?;
1092        let (stride3, remaining) = u32::try_parse(remaining)?;
1093        let (offset3, remaining) = u32::try_parse(remaining)?;
1094        let (depth, remaining) = u8::try_parse(remaining)?;
1095        let (bpp, remaining) = u8::try_parse(remaining)?;
1096        let remaining = remaining.get(2..).ok_or(ParseError::InsufficientData)?;
1097        let (modifier, remaining) = u64::try_parse(remaining)?;
1098        let fds_len = num_buffers.try_to_usize()?;
1099        if fds.len() < fds_len { return Err(ParseError::MissingFileDescriptors) }
1100        let mut buffers = fds.split_off(fds_len);
1101        core::mem::swap(fds, &mut buffers);
1102        let _ = remaining;
1103        Ok(PixmapFromBuffersRequest {
1104            pixmap,
1105            window,
1106            width,
1107            height,
1108            stride0,
1109            offset0,
1110            stride1,
1111            offset1,
1112            stride2,
1113            offset2,
1114            stride3,
1115            offset3,
1116            depth,
1117            bpp,
1118            modifier,
1119            buffers,
1120        })
1121    }
1122}
1123impl Request for PixmapFromBuffersRequest {
1124    const EXTENSION_NAME: Option<&'static str> = Some(X11_EXTENSION_NAME);
1125
1126    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
1127        let (bufs, fds) = self.serialize(major_opcode);
1128        // Flatten the buffers into a single vector
1129        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
1130        (buf, fds)
1131    }
1132}
1133impl crate::x11_utils::VoidRequest for PixmapFromBuffersRequest {
1134}
1135
1136/// Opcode for the BuffersFromPixmap request
1137pub const BUFFERS_FROM_PIXMAP_REQUEST: u8 = 8;
1138#[derive(Clone, Copy, Default)]
1139#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
1140#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1141pub struct BuffersFromPixmapRequest {
1142    pub pixmap: xproto::Pixmap,
1143}
1144impl_debug_if_no_extra_traits!(BuffersFromPixmapRequest, "BuffersFromPixmapRequest");
1145impl BuffersFromPixmapRequest {
1146    /// Serialize this request into bytes for the provided connection
1147    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'static, [u8]>; 1]> {
1148        let length_so_far = 0;
1149        let pixmap_bytes = self.pixmap.serialize();
1150        let mut request0 = vec![
1151            major_opcode,
1152            BUFFERS_FROM_PIXMAP_REQUEST,
1153            0,
1154            0,
1155            pixmap_bytes[0],
1156            pixmap_bytes[1],
1157            pixmap_bytes[2],
1158            pixmap_bytes[3],
1159        ];
1160        let length_so_far = length_so_far + request0.len();
1161        assert_eq!(length_so_far % 4, 0);
1162        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
1163        request0[2..4].copy_from_slice(&length.to_ne_bytes());
1164        ([request0.into()], vec![])
1165    }
1166    /// Parse this request given its header, its body, and any fds that go along with it
1167    #[cfg(feature = "request-parsing")]
1168    pub fn try_parse_request(header: RequestHeader, value: &[u8]) -> Result<Self, ParseError> {
1169        if header.minor_opcode != BUFFERS_FROM_PIXMAP_REQUEST {
1170            return Err(ParseError::InvalidValue);
1171        }
1172        let (pixmap, remaining) = xproto::Pixmap::try_parse(value)?;
1173        let _ = remaining;
1174        Ok(BuffersFromPixmapRequest {
1175            pixmap,
1176        })
1177    }
1178}
1179impl Request for BuffersFromPixmapRequest {
1180    const EXTENSION_NAME: Option<&'static str> = Some(X11_EXTENSION_NAME);
1181
1182    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
1183        let (bufs, fds) = self.serialize(major_opcode);
1184        // Flatten the buffers into a single vector
1185        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
1186        (buf, fds)
1187    }
1188}
1189impl crate::x11_utils::ReplyFDsRequest for BuffersFromPixmapRequest {
1190    type Reply = BuffersFromPixmapReply;
1191}
1192
1193#[cfg_attr(feature = "extra-traits", derive(Debug))]
1194pub struct BuffersFromPixmapReply {
1195    pub sequence: u16,
1196    pub length: u32,
1197    pub width: u16,
1198    pub height: u16,
1199    pub modifier: u64,
1200    pub depth: u8,
1201    pub bpp: u8,
1202    pub strides: Vec<u32>,
1203    pub offsets: Vec<u32>,
1204    pub buffers: Vec<RawFdContainer>,
1205}
1206impl_debug_if_no_extra_traits!(BuffersFromPixmapReply, "BuffersFromPixmapReply");
1207impl TryParseFd for BuffersFromPixmapReply {
1208    fn try_parse_fd<'a>(initial_value: &'a [u8], fds: &mut Vec<RawFdContainer>) -> Result<(Self, &'a [u8]), ParseError> {
1209        let remaining = initial_value;
1210        let (response_type, remaining) = u8::try_parse(remaining)?;
1211        let (nfd, remaining) = u8::try_parse(remaining)?;
1212        let (sequence, remaining) = u16::try_parse(remaining)?;
1213        let (length, remaining) = u32::try_parse(remaining)?;
1214        let (width, remaining) = u16::try_parse(remaining)?;
1215        let (height, remaining) = u16::try_parse(remaining)?;
1216        let remaining = remaining.get(4..).ok_or(ParseError::InsufficientData)?;
1217        let (modifier, remaining) = u64::try_parse(remaining)?;
1218        let (depth, remaining) = u8::try_parse(remaining)?;
1219        let (bpp, remaining) = u8::try_parse(remaining)?;
1220        let remaining = remaining.get(6..).ok_or(ParseError::InsufficientData)?;
1221        let (strides, remaining) = crate::x11_utils::parse_list::<u32>(remaining, nfd.try_to_usize()?)?;
1222        let (offsets, remaining) = crate::x11_utils::parse_list::<u32>(remaining, nfd.try_to_usize()?)?;
1223        let fds_len = nfd.try_to_usize()?;
1224        if fds.len() < fds_len { return Err(ParseError::MissingFileDescriptors) }
1225        let mut buffers = fds.split_off(fds_len);
1226        core::mem::swap(fds, &mut buffers);
1227        if response_type != 1 {
1228            return Err(ParseError::InvalidValue);
1229        }
1230        let result = BuffersFromPixmapReply { sequence, length, width, height, modifier, depth, bpp, strides, offsets, buffers };
1231        let _ = remaining;
1232        let remaining = initial_value.get(32 + length as usize * 4..)
1233            .ok_or(ParseError::InsufficientData)?;
1234        Ok((result, remaining))
1235    }
1236}
1237impl Serialize for BuffersFromPixmapReply {
1238    type Bytes = Vec<u8>;
1239    fn serialize(&self) -> Vec<u8> {
1240        let mut result = Vec::new();
1241        self.serialize_into(&mut result);
1242        result
1243    }
1244    fn serialize_into(&self, bytes: &mut Vec<u8>) {
1245        bytes.reserve(32);
1246        let response_type_bytes = &[1];
1247        bytes.push(response_type_bytes[0]);
1248        let nfd = u8::try_from(self.strides.len()).expect("`strides` has too many elements");
1249        nfd.serialize_into(bytes);
1250        self.sequence.serialize_into(bytes);
1251        self.length.serialize_into(bytes);
1252        self.width.serialize_into(bytes);
1253        self.height.serialize_into(bytes);
1254        bytes.extend_from_slice(&[0; 4]);
1255        self.modifier.serialize_into(bytes);
1256        self.depth.serialize_into(bytes);
1257        self.bpp.serialize_into(bytes);
1258        bytes.extend_from_slice(&[0; 6]);
1259        self.strides.serialize_into(bytes);
1260        assert_eq!(self.offsets.len(), usize::try_from(nfd).unwrap(), "`offsets` has an incorrect length");
1261        self.offsets.serialize_into(bytes);
1262        assert_eq!(self.buffers.len(), usize::try_from(nfd).unwrap(), "`buffers` has an incorrect length");
1263    }
1264}
1265impl BuffersFromPixmapReply {
1266    /// Get the value of the `nfd` field.
1267    ///
1268    /// The `nfd` field is used as the length field of the `strides` field.
1269    /// This function computes the field's value again based on the length of the list.
1270    ///
1271    /// # Panics
1272    ///
1273    /// Panics if the value cannot be represented in the target type. This
1274    /// cannot happen with values of the struct received from the X11 server.
1275    pub fn nfd(&self) -> u8 {
1276        self.strides.len()
1277            .try_into().unwrap()
1278    }
1279}
1280
1281/// Opcode for the SetDRMDeviceInUse request
1282pub const SET_DRM_DEVICE_IN_USE_REQUEST: u8 = 9;
1283#[derive(Clone, Copy, Default)]
1284#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
1285#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1286pub struct SetDRMDeviceInUseRequest {
1287    pub window: xproto::Window,
1288    pub drm_major: u32,
1289    pub drm_minor: u32,
1290}
1291impl_debug_if_no_extra_traits!(SetDRMDeviceInUseRequest, "SetDRMDeviceInUseRequest");
1292impl SetDRMDeviceInUseRequest {
1293    /// Serialize this request into bytes for the provided connection
1294    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'static, [u8]>; 1]> {
1295        let length_so_far = 0;
1296        let window_bytes = self.window.serialize();
1297        let drm_major_bytes = self.drm_major.serialize();
1298        let drm_minor_bytes = self.drm_minor.serialize();
1299        let mut request0 = vec![
1300            major_opcode,
1301            SET_DRM_DEVICE_IN_USE_REQUEST,
1302            0,
1303            0,
1304            window_bytes[0],
1305            window_bytes[1],
1306            window_bytes[2],
1307            window_bytes[3],
1308            drm_major_bytes[0],
1309            drm_major_bytes[1],
1310            drm_major_bytes[2],
1311            drm_major_bytes[3],
1312            drm_minor_bytes[0],
1313            drm_minor_bytes[1],
1314            drm_minor_bytes[2],
1315            drm_minor_bytes[3],
1316        ];
1317        let length_so_far = length_so_far + request0.len();
1318        assert_eq!(length_so_far % 4, 0);
1319        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
1320        request0[2..4].copy_from_slice(&length.to_ne_bytes());
1321        ([request0.into()], vec![])
1322    }
1323    /// Parse this request given its header, its body, and any fds that go along with it
1324    #[cfg(feature = "request-parsing")]
1325    pub fn try_parse_request(header: RequestHeader, value: &[u8]) -> Result<Self, ParseError> {
1326        if header.minor_opcode != SET_DRM_DEVICE_IN_USE_REQUEST {
1327            return Err(ParseError::InvalidValue);
1328        }
1329        let (window, remaining) = xproto::Window::try_parse(value)?;
1330        let (drm_major, remaining) = u32::try_parse(remaining)?;
1331        let (drm_minor, remaining) = u32::try_parse(remaining)?;
1332        let _ = remaining;
1333        Ok(SetDRMDeviceInUseRequest {
1334            window,
1335            drm_major,
1336            drm_minor,
1337        })
1338    }
1339}
1340impl Request for SetDRMDeviceInUseRequest {
1341    const EXTENSION_NAME: Option<&'static str> = Some(X11_EXTENSION_NAME);
1342
1343    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
1344        let (bufs, fds) = self.serialize(major_opcode);
1345        // Flatten the buffers into a single vector
1346        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
1347        (buf, fds)
1348    }
1349}
1350impl crate::x11_utils::VoidRequest for SetDRMDeviceInUseRequest {
1351}
1352
1353/// Opcode for the ImportSyncobj request
1354pub const IMPORT_SYNCOBJ_REQUEST: u8 = 10;
1355#[cfg_attr(feature = "extra-traits", derive(Debug))]
1356pub struct ImportSyncobjRequest {
1357    pub syncobj: Syncobj,
1358    pub drawable: xproto::Drawable,
1359    pub syncobj_fd: RawFdContainer,
1360}
1361impl_debug_if_no_extra_traits!(ImportSyncobjRequest, "ImportSyncobjRequest");
1362impl ImportSyncobjRequest {
1363    /// Serialize this request into bytes for the provided connection
1364    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'static, [u8]>; 1]> {
1365        let length_so_far = 0;
1366        let syncobj_bytes = self.syncobj.serialize();
1367        let drawable_bytes = self.drawable.serialize();
1368        let mut request0 = vec![
1369            major_opcode,
1370            IMPORT_SYNCOBJ_REQUEST,
1371            0,
1372            0,
1373            syncobj_bytes[0],
1374            syncobj_bytes[1],
1375            syncobj_bytes[2],
1376            syncobj_bytes[3],
1377            drawable_bytes[0],
1378            drawable_bytes[1],
1379            drawable_bytes[2],
1380            drawable_bytes[3],
1381        ];
1382        let length_so_far = length_so_far + request0.len();
1383        assert_eq!(length_so_far % 4, 0);
1384        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
1385        request0[2..4].copy_from_slice(&length.to_ne_bytes());
1386        ([request0.into()], vec![self.syncobj_fd])
1387    }
1388    /// Parse this request given its header, its body, and any fds that go along with it
1389    #[cfg(feature = "request-parsing")]
1390    pub fn try_parse_request_fd(header: RequestHeader, value: &[u8], fds: &mut Vec<RawFdContainer>) -> Result<Self, ParseError> {
1391        if header.minor_opcode != IMPORT_SYNCOBJ_REQUEST {
1392            return Err(ParseError::InvalidValue);
1393        }
1394        let (syncobj, remaining) = Syncobj::try_parse(value)?;
1395        let (drawable, remaining) = xproto::Drawable::try_parse(remaining)?;
1396        if fds.is_empty() { return Err(ParseError::MissingFileDescriptors) }
1397        let syncobj_fd = fds.remove(0);
1398        let _ = remaining;
1399        Ok(ImportSyncobjRequest {
1400            syncobj,
1401            drawable,
1402            syncobj_fd,
1403        })
1404    }
1405}
1406impl Request for ImportSyncobjRequest {
1407    const EXTENSION_NAME: Option<&'static str> = Some(X11_EXTENSION_NAME);
1408
1409    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
1410        let (bufs, fds) = self.serialize(major_opcode);
1411        // Flatten the buffers into a single vector
1412        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
1413        (buf, fds)
1414    }
1415}
1416impl crate::x11_utils::VoidRequest for ImportSyncobjRequest {
1417}
1418
1419/// Opcode for the FreeSyncobj request
1420pub const FREE_SYNCOBJ_REQUEST: u8 = 11;
1421#[derive(Clone, Copy, Default)]
1422#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
1423#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1424pub struct FreeSyncobjRequest {
1425    pub syncobj: Syncobj,
1426}
1427impl_debug_if_no_extra_traits!(FreeSyncobjRequest, "FreeSyncobjRequest");
1428impl FreeSyncobjRequest {
1429    /// Serialize this request into bytes for the provided connection
1430    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'static, [u8]>; 1]> {
1431        let length_so_far = 0;
1432        let syncobj_bytes = self.syncobj.serialize();
1433        let mut request0 = vec![
1434            major_opcode,
1435            FREE_SYNCOBJ_REQUEST,
1436            0,
1437            0,
1438            syncobj_bytes[0],
1439            syncobj_bytes[1],
1440            syncobj_bytes[2],
1441            syncobj_bytes[3],
1442        ];
1443        let length_so_far = length_so_far + request0.len();
1444        assert_eq!(length_so_far % 4, 0);
1445        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
1446        request0[2..4].copy_from_slice(&length.to_ne_bytes());
1447        ([request0.into()], vec![])
1448    }
1449    /// Parse this request given its header, its body, and any fds that go along with it
1450    #[cfg(feature = "request-parsing")]
1451    pub fn try_parse_request(header: RequestHeader, value: &[u8]) -> Result<Self, ParseError> {
1452        if header.minor_opcode != FREE_SYNCOBJ_REQUEST {
1453            return Err(ParseError::InvalidValue);
1454        }
1455        let (syncobj, remaining) = Syncobj::try_parse(value)?;
1456        let _ = remaining;
1457        Ok(FreeSyncobjRequest {
1458            syncobj,
1459        })
1460    }
1461}
1462impl Request for FreeSyncobjRequest {
1463    const EXTENSION_NAME: Option<&'static str> = Some(X11_EXTENSION_NAME);
1464
1465    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
1466        let (bufs, fds) = self.serialize(major_opcode);
1467        // Flatten the buffers into a single vector
1468        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
1469        (buf, fds)
1470    }
1471}
1472impl crate::x11_utils::VoidRequest for FreeSyncobjRequest {
1473}
1474
x11rb_protocol/protocol/dri3.rs

x11rb_protocol/protocol/
dri3.rs
