x11rb_protocol/protocol/
shape.rs

1// This file contains generated code. Do not edit directly.
2// To regenerate this, run 'make'.
3
4//! Bindings to the `Shape` 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 = "SHAPE";
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, 1);
38
39pub type Op = u8;
40
41pub type Kind = u8;
42
43#[derive(Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
44#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
45pub struct SO(u8);
46impl SO {
47    pub const SET: Self = Self(0);
48    pub const UNION: Self = Self(1);
49    pub const INTERSECT: Self = Self(2);
50    pub const SUBTRACT: Self = Self(3);
51    pub const INVERT: Self = Self(4);
52}
53impl From<SO> for u8 {
54    #[inline]
55    fn from(input: SO) -> Self {
56        input.0
57    }
58}
59impl From<SO> for Option<u8> {
60    #[inline]
61    fn from(input: SO) -> Self {
62        Some(input.0)
63    }
64}
65impl From<SO> for u16 {
66    #[inline]
67    fn from(input: SO) -> Self {
68        u16::from(input.0)
69    }
70}
71impl From<SO> for Option<u16> {
72    #[inline]
73    fn from(input: SO) -> Self {
74        Some(u16::from(input.0))
75    }
76}
77impl From<SO> for u32 {
78    #[inline]
79    fn from(input: SO) -> Self {
80        u32::from(input.0)
81    }
82}
83impl From<SO> for Option<u32> {
84    #[inline]
85    fn from(input: SO) -> Self {
86        Some(u32::from(input.0))
87    }
88}
89impl From<u8> for SO {
90    #[inline]
91    fn from(value: u8) -> Self {
92        Self(value)
93    }
94}
95impl core::fmt::Debug for SO  {
96    fn fmt(&self, fmt: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
97        let variants = [
98            (Self::SET.0.into(), "SET", "Set"),
99            (Self::UNION.0.into(), "UNION", "Union"),
100            (Self::INTERSECT.0.into(), "INTERSECT", "Intersect"),
101            (Self::SUBTRACT.0.into(), "SUBTRACT", "Subtract"),
102            (Self::INVERT.0.into(), "INVERT", "Invert"),
103        ];
104        pretty_print_enum(fmt, self.0.into(), &variants)
105    }
106}
107
108#[derive(Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
109#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
110pub struct SK(u8);
111impl SK {
112    pub const BOUNDING: Self = Self(0);
113    pub const CLIP: Self = Self(1);
114    pub const INPUT: Self = Self(2);
115}
116impl From<SK> for u8 {
117    #[inline]
118    fn from(input: SK) -> Self {
119        input.0
120    }
121}
122impl From<SK> for Option<u8> {
123    #[inline]
124    fn from(input: SK) -> Self {
125        Some(input.0)
126    }
127}
128impl From<SK> for u16 {
129    #[inline]
130    fn from(input: SK) -> Self {
131        u16::from(input.0)
132    }
133}
134impl From<SK> for Option<u16> {
135    #[inline]
136    fn from(input: SK) -> Self {
137        Some(u16::from(input.0))
138    }
139}
140impl From<SK> for u32 {
141    #[inline]
142    fn from(input: SK) -> Self {
143        u32::from(input.0)
144    }
145}
146impl From<SK> for Option<u32> {
147    #[inline]
148    fn from(input: SK) -> Self {
149        Some(u32::from(input.0))
150    }
151}
152impl From<u8> for SK {
153    #[inline]
154    fn from(value: u8) -> Self {
155        Self(value)
156    }
157}
158impl core::fmt::Debug for SK  {
159    fn fmt(&self, fmt: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
160        let variants = [
161            (Self::BOUNDING.0.into(), "BOUNDING", "Bounding"),
162            (Self::CLIP.0.into(), "CLIP", "Clip"),
163            (Self::INPUT.0.into(), "INPUT", "Input"),
164        ];
165        pretty_print_enum(fmt, self.0.into(), &variants)
166    }
167}
168
169/// Opcode for the Notify event
170pub const NOTIFY_EVENT: u8 = 0;
171#[derive(Clone, Copy, Default)]
172#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
173#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
174pub struct NotifyEvent {
175    pub response_type: u8,
176    pub shape_kind: SK,
177    pub sequence: u16,
178    pub affected_window: xproto::Window,
179    pub extents_x: i16,
180    pub extents_y: i16,
181    pub extents_width: u16,
182    pub extents_height: u16,
183    pub server_time: xproto::Timestamp,
184    pub shaped: bool,
185}
186impl_debug_if_no_extra_traits!(NotifyEvent, "NotifyEvent");
187impl TryParse for NotifyEvent {
188    fn try_parse(initial_value: &[u8]) -> Result<(Self, &[u8]), ParseError> {
189        let remaining = initial_value;
190        let (response_type, remaining) = u8::try_parse(remaining)?;
191        let (shape_kind, remaining) = Kind::try_parse(remaining)?;
192        let (sequence, remaining) = u16::try_parse(remaining)?;
193        let (affected_window, remaining) = xproto::Window::try_parse(remaining)?;
194        let (extents_x, remaining) = i16::try_parse(remaining)?;
195        let (extents_y, remaining) = i16::try_parse(remaining)?;
196        let (extents_width, remaining) = u16::try_parse(remaining)?;
197        let (extents_height, remaining) = u16::try_parse(remaining)?;
198        let (server_time, remaining) = xproto::Timestamp::try_parse(remaining)?;
199        let (shaped, remaining) = bool::try_parse(remaining)?;
200        let remaining = remaining.get(11..).ok_or(ParseError::InsufficientData)?;
201        let shape_kind = shape_kind.into();
202        let result = NotifyEvent { response_type, shape_kind, sequence, affected_window, extents_x, extents_y, extents_width, extents_height, server_time, shaped };
203        let _ = remaining;
204        let remaining = initial_value.get(32..)
205            .ok_or(ParseError::InsufficientData)?;
206        Ok((result, remaining))
207    }
208}
209impl Serialize for NotifyEvent {
210    type Bytes = [u8; 32];
211    fn serialize(&self) -> [u8; 32] {
212        let response_type_bytes = self.response_type.serialize();
213        let shape_kind_bytes = Kind::from(self.shape_kind).serialize();
214        let sequence_bytes = self.sequence.serialize();
215        let affected_window_bytes = self.affected_window.serialize();
216        let extents_x_bytes = self.extents_x.serialize();
217        let extents_y_bytes = self.extents_y.serialize();
218        let extents_width_bytes = self.extents_width.serialize();
219        let extents_height_bytes = self.extents_height.serialize();
220        let server_time_bytes = self.server_time.serialize();
221        let shaped_bytes = self.shaped.serialize();
222        [
223            response_type_bytes[0],
224            shape_kind_bytes[0],
225            sequence_bytes[0],
226            sequence_bytes[1],
227            affected_window_bytes[0],
228            affected_window_bytes[1],
229            affected_window_bytes[2],
230            affected_window_bytes[3],
231            extents_x_bytes[0],
232            extents_x_bytes[1],
233            extents_y_bytes[0],
234            extents_y_bytes[1],
235            extents_width_bytes[0],
236            extents_width_bytes[1],
237            extents_height_bytes[0],
238            extents_height_bytes[1],
239            server_time_bytes[0],
240            server_time_bytes[1],
241            server_time_bytes[2],
242            server_time_bytes[3],
243            shaped_bytes[0],
244            0,
245            0,
246            0,
247            0,
248            0,
249            0,
250            0,
251            0,
252            0,
253            0,
254            0,
255        ]
256    }
257    fn serialize_into(&self, bytes: &mut Vec<u8>) {
258        bytes.reserve(32);
259        self.response_type.serialize_into(bytes);
260        Kind::from(self.shape_kind).serialize_into(bytes);
261        self.sequence.serialize_into(bytes);
262        self.affected_window.serialize_into(bytes);
263        self.extents_x.serialize_into(bytes);
264        self.extents_y.serialize_into(bytes);
265        self.extents_width.serialize_into(bytes);
266        self.extents_height.serialize_into(bytes);
267        self.server_time.serialize_into(bytes);
268        self.shaped.serialize_into(bytes);
269        bytes.extend_from_slice(&[0; 11]);
270    }
271}
272impl From<&NotifyEvent> for [u8; 32] {
273    fn from(input: &NotifyEvent) -> Self {
274        let response_type_bytes = input.response_type.serialize();
275        let shape_kind_bytes = Kind::from(input.shape_kind).serialize();
276        let sequence_bytes = input.sequence.serialize();
277        let affected_window_bytes = input.affected_window.serialize();
278        let extents_x_bytes = input.extents_x.serialize();
279        let extents_y_bytes = input.extents_y.serialize();
280        let extents_width_bytes = input.extents_width.serialize();
281        let extents_height_bytes = input.extents_height.serialize();
282        let server_time_bytes = input.server_time.serialize();
283        let shaped_bytes = input.shaped.serialize();
284        [
285            response_type_bytes[0],
286            shape_kind_bytes[0],
287            sequence_bytes[0],
288            sequence_bytes[1],
289            affected_window_bytes[0],
290            affected_window_bytes[1],
291            affected_window_bytes[2],
292            affected_window_bytes[3],
293            extents_x_bytes[0],
294            extents_x_bytes[1],
295            extents_y_bytes[0],
296            extents_y_bytes[1],
297            extents_width_bytes[0],
298            extents_width_bytes[1],
299            extents_height_bytes[0],
300            extents_height_bytes[1],
301            server_time_bytes[0],
302            server_time_bytes[1],
303            server_time_bytes[2],
304            server_time_bytes[3],
305            shaped_bytes[0],
306            0,
307            0,
308            0,
309            0,
310            0,
311            0,
312            0,
313            0,
314            0,
315            0,
316            0,
317        ]
318    }
319}
320impl From<NotifyEvent> for [u8; 32] {
321    fn from(input: NotifyEvent) -> Self {
322        Self::from(&input)
323    }
324}
325
326/// Opcode for the QueryVersion request
327pub const QUERY_VERSION_REQUEST: u8 = 0;
328#[derive(Clone, Copy, Default)]
329#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
330#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
331pub struct QueryVersionRequest;
332impl_debug_if_no_extra_traits!(QueryVersionRequest, "QueryVersionRequest");
333impl QueryVersionRequest {
334    /// Serialize this request into bytes for the provided connection
335    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'static, [u8]>; 1]> {
336        let length_so_far = 0;
337        let mut request0 = vec![
338            major_opcode,
339            QUERY_VERSION_REQUEST,
340            0,
341            0,
342        ];
343        let length_so_far = length_so_far + request0.len();
344        assert_eq!(length_so_far % 4, 0);
345        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
346        request0[2..4].copy_from_slice(&length.to_ne_bytes());
347        ([request0.into()], vec![])
348    }
349    /// Parse this request given its header, its body, and any fds that go along with it
350    #[cfg(feature = "request-parsing")]
351    pub fn try_parse_request(header: RequestHeader, value: &[u8]) -> Result<Self, ParseError> {
352        if header.minor_opcode != QUERY_VERSION_REQUEST {
353            return Err(ParseError::InvalidValue);
354        }
355        let _ = value;
356        Ok(QueryVersionRequest
357        )
358    }
359}
360impl Request for QueryVersionRequest {
361    const EXTENSION_NAME: Option<&'static str> = Some(X11_EXTENSION_NAME);
362
363    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
364        let (bufs, fds) = self.serialize(major_opcode);
365        // Flatten the buffers into a single vector
366        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
367        (buf, fds)
368    }
369}
370impl crate::x11_utils::ReplyRequest for QueryVersionRequest {
371    type Reply = QueryVersionReply;
372}
373
374#[derive(Clone, Copy, Default)]
375#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
376#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
377pub struct QueryVersionReply {
378    pub sequence: u16,
379    pub length: u32,
380    pub major_version: u16,
381    pub minor_version: u16,
382}
383impl_debug_if_no_extra_traits!(QueryVersionReply, "QueryVersionReply");
384impl TryParse for QueryVersionReply {
385    fn try_parse(initial_value: &[u8]) -> Result<(Self, &[u8]), ParseError> {
386        let remaining = initial_value;
387        let (response_type, remaining) = u8::try_parse(remaining)?;
388        let remaining = remaining.get(1..).ok_or(ParseError::InsufficientData)?;
389        let (sequence, remaining) = u16::try_parse(remaining)?;
390        let (length, remaining) = u32::try_parse(remaining)?;
391        let (major_version, remaining) = u16::try_parse(remaining)?;
392        let (minor_version, remaining) = u16::try_parse(remaining)?;
393        if response_type != 1 {
394            return Err(ParseError::InvalidValue);
395        }
396        let result = QueryVersionReply { sequence, length, major_version, minor_version };
397        let _ = remaining;
398        let remaining = initial_value.get(32 + length as usize * 4..)
399            .ok_or(ParseError::InsufficientData)?;
400        Ok((result, remaining))
401    }
402}
403impl Serialize for QueryVersionReply {
404    type Bytes = [u8; 12];
405    fn serialize(&self) -> [u8; 12] {
406        let response_type_bytes = &[1];
407        let sequence_bytes = self.sequence.serialize();
408        let length_bytes = self.length.serialize();
409        let major_version_bytes = self.major_version.serialize();
410        let minor_version_bytes = self.minor_version.serialize();
411        [
412            response_type_bytes[0],
413            0,
414            sequence_bytes[0],
415            sequence_bytes[1],
416            length_bytes[0],
417            length_bytes[1],
418            length_bytes[2],
419            length_bytes[3],
420            major_version_bytes[0],
421            major_version_bytes[1],
422            minor_version_bytes[0],
423            minor_version_bytes[1],
424        ]
425    }
426    fn serialize_into(&self, bytes: &mut Vec<u8>) {
427        bytes.reserve(12);
428        let response_type_bytes = &[1];
429        bytes.push(response_type_bytes[0]);
430        bytes.extend_from_slice(&[0; 1]);
431        self.sequence.serialize_into(bytes);
432        self.length.serialize_into(bytes);
433        self.major_version.serialize_into(bytes);
434        self.minor_version.serialize_into(bytes);
435    }
436}
437
438/// Opcode for the Rectangles request
439pub const RECTANGLES_REQUEST: u8 = 1;
440#[derive(Clone, Default)]
441#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
442#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
443pub struct RectanglesRequest<'input> {
444    pub operation: SO,
445    pub destination_kind: SK,
446    pub ordering: xproto::ClipOrdering,
447    pub destination_window: xproto::Window,
448    pub x_offset: i16,
449    pub y_offset: i16,
450    pub rectangles: Cow<'input, [xproto::Rectangle]>,
451}
452impl_debug_if_no_extra_traits!(RectanglesRequest<'_>, "RectanglesRequest");
453impl<'input> RectanglesRequest<'input> {
454    /// Serialize this request into bytes for the provided connection
455    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'input, [u8]>; 3]> {
456        let length_so_far = 0;
457        let operation_bytes = Op::from(self.operation).serialize();
458        let destination_kind_bytes = Kind::from(self.destination_kind).serialize();
459        let ordering_bytes = u8::from(self.ordering).serialize();
460        let destination_window_bytes = self.destination_window.serialize();
461        let x_offset_bytes = self.x_offset.serialize();
462        let y_offset_bytes = self.y_offset.serialize();
463        let mut request0 = vec![
464            major_opcode,
465            RECTANGLES_REQUEST,
466            0,
467            0,
468            operation_bytes[0],
469            destination_kind_bytes[0],
470            ordering_bytes[0],
471            0,
472            destination_window_bytes[0],
473            destination_window_bytes[1],
474            destination_window_bytes[2],
475            destination_window_bytes[3],
476            x_offset_bytes[0],
477            x_offset_bytes[1],
478            y_offset_bytes[0],
479            y_offset_bytes[1],
480        ];
481        let length_so_far = length_so_far + request0.len();
482        let rectangles_bytes = self.rectangles.serialize();
483        let length_so_far = length_so_far + rectangles_bytes.len();
484        let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4];
485        let length_so_far = length_so_far + padding0.len();
486        assert_eq!(length_so_far % 4, 0);
487        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
488        request0[2..4].copy_from_slice(&length.to_ne_bytes());
489        ([request0.into(), rectangles_bytes.into(), padding0.into()], vec![])
490    }
491    /// Parse this request given its header, its body, and any fds that go along with it
492    #[cfg(feature = "request-parsing")]
493    pub fn try_parse_request(header: RequestHeader, value: &'input [u8]) -> Result<Self, ParseError> {
494        if header.minor_opcode != RECTANGLES_REQUEST {
495            return Err(ParseError::InvalidValue);
496        }
497        let (operation, remaining) = Op::try_parse(value)?;
498        let operation = operation.into();
499        let (destination_kind, remaining) = Kind::try_parse(remaining)?;
500        let destination_kind = destination_kind.into();
501        let (ordering, remaining) = u8::try_parse(remaining)?;
502        let ordering = ordering.into();
503        let remaining = remaining.get(1..).ok_or(ParseError::InsufficientData)?;
504        let (destination_window, remaining) = xproto::Window::try_parse(remaining)?;
505        let (x_offset, remaining) = i16::try_parse(remaining)?;
506        let (y_offset, remaining) = i16::try_parse(remaining)?;
507        let mut remaining = remaining;
508        // Length is 'everything left in the input'
509        let mut rectangles = Vec::new();
510        while !remaining.is_empty() {
511            let (v, new_remaining) = xproto::Rectangle::try_parse(remaining)?;
512            remaining = new_remaining;
513            rectangles.push(v);
514        }
515        let _ = remaining;
516        Ok(RectanglesRequest {
517            operation,
518            destination_kind,
519            ordering,
520            destination_window,
521            x_offset,
522            y_offset,
523            rectangles: Cow::Owned(rectangles),
524        })
525    }
526    /// Clone all borrowed data in this RectanglesRequest.
527    pub fn into_owned(self) -> RectanglesRequest<'static> {
528        RectanglesRequest {
529            operation: self.operation,
530            destination_kind: self.destination_kind,
531            ordering: self.ordering,
532            destination_window: self.destination_window,
533            x_offset: self.x_offset,
534            y_offset: self.y_offset,
535            rectangles: Cow::Owned(self.rectangles.into_owned()),
536        }
537    }
538}
539impl<'input> Request for RectanglesRequest<'input> {
540    const EXTENSION_NAME: Option<&'static str> = Some(X11_EXTENSION_NAME);
541
542    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
543        let (bufs, fds) = self.serialize(major_opcode);
544        // Flatten the buffers into a single vector
545        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
546        (buf, fds)
547    }
548}
549impl<'input> crate::x11_utils::VoidRequest for RectanglesRequest<'input> {
550}
551
552/// Opcode for the Mask request
553pub const MASK_REQUEST: u8 = 2;
554#[derive(Clone, Copy, Default)]
555#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
556#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
557pub struct MaskRequest {
558    pub operation: SO,
559    pub destination_kind: SK,
560    pub destination_window: xproto::Window,
561    pub x_offset: i16,
562    pub y_offset: i16,
563    pub source_bitmap: xproto::Pixmap,
564}
565impl_debug_if_no_extra_traits!(MaskRequest, "MaskRequest");
566impl MaskRequest {
567    /// Serialize this request into bytes for the provided connection
568    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'static, [u8]>; 1]> {
569        let length_so_far = 0;
570        let operation_bytes = Op::from(self.operation).serialize();
571        let destination_kind_bytes = Kind::from(self.destination_kind).serialize();
572        let destination_window_bytes = self.destination_window.serialize();
573        let x_offset_bytes = self.x_offset.serialize();
574        let y_offset_bytes = self.y_offset.serialize();
575        let source_bitmap_bytes = self.source_bitmap.serialize();
576        let mut request0 = vec![
577            major_opcode,
578            MASK_REQUEST,
579            0,
580            0,
581            operation_bytes[0],
582            destination_kind_bytes[0],
583            0,
584            0,
585            destination_window_bytes[0],
586            destination_window_bytes[1],
587            destination_window_bytes[2],
588            destination_window_bytes[3],
589            x_offset_bytes[0],
590            x_offset_bytes[1],
591            y_offset_bytes[0],
592            y_offset_bytes[1],
593            source_bitmap_bytes[0],
594            source_bitmap_bytes[1],
595            source_bitmap_bytes[2],
596            source_bitmap_bytes[3],
597        ];
598        let length_so_far = length_so_far + request0.len();
599        assert_eq!(length_so_far % 4, 0);
600        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
601        request0[2..4].copy_from_slice(&length.to_ne_bytes());
602        ([request0.into()], vec![])
603    }
604    /// Parse this request given its header, its body, and any fds that go along with it
605    #[cfg(feature = "request-parsing")]
606    pub fn try_parse_request(header: RequestHeader, value: &[u8]) -> Result<Self, ParseError> {
607        if header.minor_opcode != MASK_REQUEST {
608            return Err(ParseError::InvalidValue);
609        }
610        let (operation, remaining) = Op::try_parse(value)?;
611        let operation = operation.into();
612        let (destination_kind, remaining) = Kind::try_parse(remaining)?;
613        let destination_kind = destination_kind.into();
614        let remaining = remaining.get(2..).ok_or(ParseError::InsufficientData)?;
615        let (destination_window, remaining) = xproto::Window::try_parse(remaining)?;
616        let (x_offset, remaining) = i16::try_parse(remaining)?;
617        let (y_offset, remaining) = i16::try_parse(remaining)?;
618        let (source_bitmap, remaining) = xproto::Pixmap::try_parse(remaining)?;
619        let _ = remaining;
620        Ok(MaskRequest {
621            operation,
622            destination_kind,
623            destination_window,
624            x_offset,
625            y_offset,
626            source_bitmap,
627        })
628    }
629}
630impl Request for MaskRequest {
631    const EXTENSION_NAME: Option<&'static str> = Some(X11_EXTENSION_NAME);
632
633    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
634        let (bufs, fds) = self.serialize(major_opcode);
635        // Flatten the buffers into a single vector
636        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
637        (buf, fds)
638    }
639}
640impl crate::x11_utils::VoidRequest for MaskRequest {
641}
642
643/// Opcode for the Combine request
644pub const COMBINE_REQUEST: u8 = 3;
645#[derive(Clone, Copy, Default)]
646#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
647#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
648pub struct CombineRequest {
649    pub operation: SO,
650    pub destination_kind: SK,
651    pub source_kind: SK,
652    pub destination_window: xproto::Window,
653    pub x_offset: i16,
654    pub y_offset: i16,
655    pub source_window: xproto::Window,
656}
657impl_debug_if_no_extra_traits!(CombineRequest, "CombineRequest");
658impl CombineRequest {
659    /// Serialize this request into bytes for the provided connection
660    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'static, [u8]>; 1]> {
661        let length_so_far = 0;
662        let operation_bytes = Op::from(self.operation).serialize();
663        let destination_kind_bytes = Kind::from(self.destination_kind).serialize();
664        let source_kind_bytes = Kind::from(self.source_kind).serialize();
665        let destination_window_bytes = self.destination_window.serialize();
666        let x_offset_bytes = self.x_offset.serialize();
667        let y_offset_bytes = self.y_offset.serialize();
668        let source_window_bytes = self.source_window.serialize();
669        let mut request0 = vec![
670            major_opcode,
671            COMBINE_REQUEST,
672            0,
673            0,
674            operation_bytes[0],
675            destination_kind_bytes[0],
676            source_kind_bytes[0],
677            0,
678            destination_window_bytes[0],
679            destination_window_bytes[1],
680            destination_window_bytes[2],
681            destination_window_bytes[3],
682            x_offset_bytes[0],
683            x_offset_bytes[1],
684            y_offset_bytes[0],
685            y_offset_bytes[1],
686            source_window_bytes[0],
687            source_window_bytes[1],
688            source_window_bytes[2],
689            source_window_bytes[3],
690        ];
691        let length_so_far = length_so_far + request0.len();
692        assert_eq!(length_so_far % 4, 0);
693        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
694        request0[2..4].copy_from_slice(&length.to_ne_bytes());
695        ([request0.into()], vec![])
696    }
697    /// Parse this request given its header, its body, and any fds that go along with it
698    #[cfg(feature = "request-parsing")]
699    pub fn try_parse_request(header: RequestHeader, value: &[u8]) -> Result<Self, ParseError> {
700        if header.minor_opcode != COMBINE_REQUEST {
701            return Err(ParseError::InvalidValue);
702        }
703        let (operation, remaining) = Op::try_parse(value)?;
704        let operation = operation.into();
705        let (destination_kind, remaining) = Kind::try_parse(remaining)?;
706        let destination_kind = destination_kind.into();
707        let (source_kind, remaining) = Kind::try_parse(remaining)?;
708        let source_kind = source_kind.into();
709        let remaining = remaining.get(1..).ok_or(ParseError::InsufficientData)?;
710        let (destination_window, remaining) = xproto::Window::try_parse(remaining)?;
711        let (x_offset, remaining) = i16::try_parse(remaining)?;
712        let (y_offset, remaining) = i16::try_parse(remaining)?;
713        let (source_window, remaining) = xproto::Window::try_parse(remaining)?;
714        let _ = remaining;
715        Ok(CombineRequest {
716            operation,
717            destination_kind,
718            source_kind,
719            destination_window,
720            x_offset,
721            y_offset,
722            source_window,
723        })
724    }
725}
726impl Request for CombineRequest {
727    const EXTENSION_NAME: Option<&'static str> = Some(X11_EXTENSION_NAME);
728
729    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
730        let (bufs, fds) = self.serialize(major_opcode);
731        // Flatten the buffers into a single vector
732        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
733        (buf, fds)
734    }
735}
736impl crate::x11_utils::VoidRequest for CombineRequest {
737}
738
739/// Opcode for the Offset request
740pub const OFFSET_REQUEST: u8 = 4;
741#[derive(Clone, Copy, Default)]
742#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
743#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
744pub struct OffsetRequest {
745    pub destination_kind: SK,
746    pub destination_window: xproto::Window,
747    pub x_offset: i16,
748    pub y_offset: i16,
749}
750impl_debug_if_no_extra_traits!(OffsetRequest, "OffsetRequest");
751impl OffsetRequest {
752    /// Serialize this request into bytes for the provided connection
753    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'static, [u8]>; 1]> {
754        let length_so_far = 0;
755        let destination_kind_bytes = Kind::from(self.destination_kind).serialize();
756        let destination_window_bytes = self.destination_window.serialize();
757        let x_offset_bytes = self.x_offset.serialize();
758        let y_offset_bytes = self.y_offset.serialize();
759        let mut request0 = vec![
760            major_opcode,
761            OFFSET_REQUEST,
762            0,
763            0,
764            destination_kind_bytes[0],
765            0,
766            0,
767            0,
768            destination_window_bytes[0],
769            destination_window_bytes[1],
770            destination_window_bytes[2],
771            destination_window_bytes[3],
772            x_offset_bytes[0],
773            x_offset_bytes[1],
774            y_offset_bytes[0],
775            y_offset_bytes[1],
776        ];
777        let length_so_far = length_so_far + request0.len();
778        assert_eq!(length_so_far % 4, 0);
779        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
780        request0[2..4].copy_from_slice(&length.to_ne_bytes());
781        ([request0.into()], vec![])
782    }
783    /// Parse this request given its header, its body, and any fds that go along with it
784    #[cfg(feature = "request-parsing")]
785    pub fn try_parse_request(header: RequestHeader, value: &[u8]) -> Result<Self, ParseError> {
786        if header.minor_opcode != OFFSET_REQUEST {
787            return Err(ParseError::InvalidValue);
788        }
789        let (destination_kind, remaining) = Kind::try_parse(value)?;
790        let destination_kind = destination_kind.into();
791        let remaining = remaining.get(3..).ok_or(ParseError::InsufficientData)?;
792        let (destination_window, remaining) = xproto::Window::try_parse(remaining)?;
793        let (x_offset, remaining) = i16::try_parse(remaining)?;
794        let (y_offset, remaining) = i16::try_parse(remaining)?;
795        let _ = remaining;
796        Ok(OffsetRequest {
797            destination_kind,
798            destination_window,
799            x_offset,
800            y_offset,
801        })
802    }
803}
804impl Request for OffsetRequest {
805    const EXTENSION_NAME: Option<&'static str> = Some(X11_EXTENSION_NAME);
806
807    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
808        let (bufs, fds) = self.serialize(major_opcode);
809        // Flatten the buffers into a single vector
810        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
811        (buf, fds)
812    }
813}
814impl crate::x11_utils::VoidRequest for OffsetRequest {
815}
816
817/// Opcode for the QueryExtents request
818pub const QUERY_EXTENTS_REQUEST: u8 = 5;
819#[derive(Clone, Copy, Default)]
820#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
821#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
822pub struct QueryExtentsRequest {
823    pub destination_window: xproto::Window,
824}
825impl_debug_if_no_extra_traits!(QueryExtentsRequest, "QueryExtentsRequest");
826impl QueryExtentsRequest {
827    /// Serialize this request into bytes for the provided connection
828    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'static, [u8]>; 1]> {
829        let length_so_far = 0;
830        let destination_window_bytes = self.destination_window.serialize();
831        let mut request0 = vec![
832            major_opcode,
833            QUERY_EXTENTS_REQUEST,
834            0,
835            0,
836            destination_window_bytes[0],
837            destination_window_bytes[1],
838            destination_window_bytes[2],
839            destination_window_bytes[3],
840        ];
841        let length_so_far = length_so_far + request0.len();
842        assert_eq!(length_so_far % 4, 0);
843        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
844        request0[2..4].copy_from_slice(&length.to_ne_bytes());
845        ([request0.into()], vec![])
846    }
847    /// Parse this request given its header, its body, and any fds that go along with it
848    #[cfg(feature = "request-parsing")]
849    pub fn try_parse_request(header: RequestHeader, value: &[u8]) -> Result<Self, ParseError> {
850        if header.minor_opcode != QUERY_EXTENTS_REQUEST {
851            return Err(ParseError::InvalidValue);
852        }
853        let (destination_window, remaining) = xproto::Window::try_parse(value)?;
854        let _ = remaining;
855        Ok(QueryExtentsRequest {
856            destination_window,
857        })
858    }
859}
860impl Request for QueryExtentsRequest {
861    const EXTENSION_NAME: Option<&'static str> = Some(X11_EXTENSION_NAME);
862
863    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
864        let (bufs, fds) = self.serialize(major_opcode);
865        // Flatten the buffers into a single vector
866        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
867        (buf, fds)
868    }
869}
870impl crate::x11_utils::ReplyRequest for QueryExtentsRequest {
871    type Reply = QueryExtentsReply;
872}
873
874#[derive(Clone, Copy, Default)]
875#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
876#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
877pub struct QueryExtentsReply {
878    pub sequence: u16,
879    pub length: u32,
880    pub bounding_shaped: bool,
881    pub clip_shaped: bool,
882    pub bounding_shape_extents_x: i16,
883    pub bounding_shape_extents_y: i16,
884    pub bounding_shape_extents_width: u16,
885    pub bounding_shape_extents_height: u16,
886    pub clip_shape_extents_x: i16,
887    pub clip_shape_extents_y: i16,
888    pub clip_shape_extents_width: u16,
889    pub clip_shape_extents_height: u16,
890}
891impl_debug_if_no_extra_traits!(QueryExtentsReply, "QueryExtentsReply");
892impl TryParse for QueryExtentsReply {
893    fn try_parse(initial_value: &[u8]) -> Result<(Self, &[u8]), ParseError> {
894        let remaining = initial_value;
895        let (response_type, remaining) = u8::try_parse(remaining)?;
896        let remaining = remaining.get(1..).ok_or(ParseError::InsufficientData)?;
897        let (sequence, remaining) = u16::try_parse(remaining)?;
898        let (length, remaining) = u32::try_parse(remaining)?;
899        let (bounding_shaped, remaining) = bool::try_parse(remaining)?;
900        let (clip_shaped, remaining) = bool::try_parse(remaining)?;
901        let remaining = remaining.get(2..).ok_or(ParseError::InsufficientData)?;
902        let (bounding_shape_extents_x, remaining) = i16::try_parse(remaining)?;
903        let (bounding_shape_extents_y, remaining) = i16::try_parse(remaining)?;
904        let (bounding_shape_extents_width, remaining) = u16::try_parse(remaining)?;
905        let (bounding_shape_extents_height, remaining) = u16::try_parse(remaining)?;
906        let (clip_shape_extents_x, remaining) = i16::try_parse(remaining)?;
907        let (clip_shape_extents_y, remaining) = i16::try_parse(remaining)?;
908        let (clip_shape_extents_width, remaining) = u16::try_parse(remaining)?;
909        let (clip_shape_extents_height, remaining) = u16::try_parse(remaining)?;
910        if response_type != 1 {
911            return Err(ParseError::InvalidValue);
912        }
913        let result = QueryExtentsReply { sequence, length, bounding_shaped, clip_shaped, bounding_shape_extents_x, bounding_shape_extents_y, bounding_shape_extents_width, bounding_shape_extents_height, clip_shape_extents_x, clip_shape_extents_y, clip_shape_extents_width, clip_shape_extents_height };
914        let _ = remaining;
915        let remaining = initial_value.get(32 + length as usize * 4..)
916            .ok_or(ParseError::InsufficientData)?;
917        Ok((result, remaining))
918    }
919}
920impl Serialize for QueryExtentsReply {
921    type Bytes = [u8; 28];
922    fn serialize(&self) -> [u8; 28] {
923        let response_type_bytes = &[1];
924        let sequence_bytes = self.sequence.serialize();
925        let length_bytes = self.length.serialize();
926        let bounding_shaped_bytes = self.bounding_shaped.serialize();
927        let clip_shaped_bytes = self.clip_shaped.serialize();
928        let bounding_shape_extents_x_bytes = self.bounding_shape_extents_x.serialize();
929        let bounding_shape_extents_y_bytes = self.bounding_shape_extents_y.serialize();
930        let bounding_shape_extents_width_bytes = self.bounding_shape_extents_width.serialize();
931        let bounding_shape_extents_height_bytes = self.bounding_shape_extents_height.serialize();
932        let clip_shape_extents_x_bytes = self.clip_shape_extents_x.serialize();
933        let clip_shape_extents_y_bytes = self.clip_shape_extents_y.serialize();
934        let clip_shape_extents_width_bytes = self.clip_shape_extents_width.serialize();
935        let clip_shape_extents_height_bytes = self.clip_shape_extents_height.serialize();
936        [
937            response_type_bytes[0],
938            0,
939            sequence_bytes[0],
940            sequence_bytes[1],
941            length_bytes[0],
942            length_bytes[1],
943            length_bytes[2],
944            length_bytes[3],
945            bounding_shaped_bytes[0],
946            clip_shaped_bytes[0],
947            0,
948            0,
949            bounding_shape_extents_x_bytes[0],
950            bounding_shape_extents_x_bytes[1],
951            bounding_shape_extents_y_bytes[0],
952            bounding_shape_extents_y_bytes[1],
953            bounding_shape_extents_width_bytes[0],
954            bounding_shape_extents_width_bytes[1],
955            bounding_shape_extents_height_bytes[0],
956            bounding_shape_extents_height_bytes[1],
957            clip_shape_extents_x_bytes[0],
958            clip_shape_extents_x_bytes[1],
959            clip_shape_extents_y_bytes[0],
960            clip_shape_extents_y_bytes[1],
961            clip_shape_extents_width_bytes[0],
962            clip_shape_extents_width_bytes[1],
963            clip_shape_extents_height_bytes[0],
964            clip_shape_extents_height_bytes[1],
965        ]
966    }
967    fn serialize_into(&self, bytes: &mut Vec<u8>) {
968        bytes.reserve(28);
969        let response_type_bytes = &[1];
970        bytes.push(response_type_bytes[0]);
971        bytes.extend_from_slice(&[0; 1]);
972        self.sequence.serialize_into(bytes);
973        self.length.serialize_into(bytes);
974        self.bounding_shaped.serialize_into(bytes);
975        self.clip_shaped.serialize_into(bytes);
976        bytes.extend_from_slice(&[0; 2]);
977        self.bounding_shape_extents_x.serialize_into(bytes);
978        self.bounding_shape_extents_y.serialize_into(bytes);
979        self.bounding_shape_extents_width.serialize_into(bytes);
980        self.bounding_shape_extents_height.serialize_into(bytes);
981        self.clip_shape_extents_x.serialize_into(bytes);
982        self.clip_shape_extents_y.serialize_into(bytes);
983        self.clip_shape_extents_width.serialize_into(bytes);
984        self.clip_shape_extents_height.serialize_into(bytes);
985    }
986}
987
988/// Opcode for the SelectInput request
989pub const SELECT_INPUT_REQUEST: u8 = 6;
990#[derive(Clone, Copy, Default)]
991#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
992#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
993pub struct SelectInputRequest {
994    pub destination_window: xproto::Window,
995    pub enable: bool,
996}
997impl_debug_if_no_extra_traits!(SelectInputRequest, "SelectInputRequest");
998impl SelectInputRequest {
999    /// Serialize this request into bytes for the provided connection
1000    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'static, [u8]>; 1]> {
1001        let length_so_far = 0;
1002        let destination_window_bytes = self.destination_window.serialize();
1003        let enable_bytes = self.enable.serialize();
1004        let mut request0 = vec![
1005            major_opcode,
1006            SELECT_INPUT_REQUEST,
1007            0,
1008            0,
1009            destination_window_bytes[0],
1010            destination_window_bytes[1],
1011            destination_window_bytes[2],
1012            destination_window_bytes[3],
1013            enable_bytes[0],
1014            0,
1015            0,
1016            0,
1017        ];
1018        let length_so_far = length_so_far + request0.len();
1019        assert_eq!(length_so_far % 4, 0);
1020        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
1021        request0[2..4].copy_from_slice(&length.to_ne_bytes());
1022        ([request0.into()], vec![])
1023    }
1024    /// Parse this request given its header, its body, and any fds that go along with it
1025    #[cfg(feature = "request-parsing")]
1026    pub fn try_parse_request(header: RequestHeader, value: &[u8]) -> Result<Self, ParseError> {
1027        if header.minor_opcode != SELECT_INPUT_REQUEST {
1028            return Err(ParseError::InvalidValue);
1029        }
1030        let (destination_window, remaining) = xproto::Window::try_parse(value)?;
1031        let (enable, remaining) = bool::try_parse(remaining)?;
1032        let remaining = remaining.get(3..).ok_or(ParseError::InsufficientData)?;
1033        let _ = remaining;
1034        Ok(SelectInputRequest {
1035            destination_window,
1036            enable,
1037        })
1038    }
1039}
1040impl Request for SelectInputRequest {
1041    const EXTENSION_NAME: Option<&'static str> = Some(X11_EXTENSION_NAME);
1042
1043    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
1044        let (bufs, fds) = self.serialize(major_opcode);
1045        // Flatten the buffers into a single vector
1046        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
1047        (buf, fds)
1048    }
1049}
1050impl crate::x11_utils::VoidRequest for SelectInputRequest {
1051}
1052
1053/// Opcode for the InputSelected request
1054pub const INPUT_SELECTED_REQUEST: u8 = 7;
1055#[derive(Clone, Copy, Default)]
1056#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
1057#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1058pub struct InputSelectedRequest {
1059    pub destination_window: xproto::Window,
1060}
1061impl_debug_if_no_extra_traits!(InputSelectedRequest, "InputSelectedRequest");
1062impl InputSelectedRequest {
1063    /// Serialize this request into bytes for the provided connection
1064    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'static, [u8]>; 1]> {
1065        let length_so_far = 0;
1066        let destination_window_bytes = self.destination_window.serialize();
1067        let mut request0 = vec![
1068            major_opcode,
1069            INPUT_SELECTED_REQUEST,
1070            0,
1071            0,
1072            destination_window_bytes[0],
1073            destination_window_bytes[1],
1074            destination_window_bytes[2],
1075            destination_window_bytes[3],
1076        ];
1077        let length_so_far = length_so_far + request0.len();
1078        assert_eq!(length_so_far % 4, 0);
1079        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
1080        request0[2..4].copy_from_slice(&length.to_ne_bytes());
1081        ([request0.into()], vec![])
1082    }
1083    /// Parse this request given its header, its body, and any fds that go along with it
1084    #[cfg(feature = "request-parsing")]
1085    pub fn try_parse_request(header: RequestHeader, value: &[u8]) -> Result<Self, ParseError> {
1086        if header.minor_opcode != INPUT_SELECTED_REQUEST {
1087            return Err(ParseError::InvalidValue);
1088        }
1089        let (destination_window, remaining) = xproto::Window::try_parse(value)?;
1090        let _ = remaining;
1091        Ok(InputSelectedRequest {
1092            destination_window,
1093        })
1094    }
1095}
1096impl Request for InputSelectedRequest {
1097    const EXTENSION_NAME: Option<&'static str> = Some(X11_EXTENSION_NAME);
1098
1099    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
1100        let (bufs, fds) = self.serialize(major_opcode);
1101        // Flatten the buffers into a single vector
1102        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
1103        (buf, fds)
1104    }
1105}
1106impl crate::x11_utils::ReplyRequest for InputSelectedRequest {
1107    type Reply = InputSelectedReply;
1108}
1109
1110#[derive(Clone, Copy, Default)]
1111#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
1112#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1113pub struct InputSelectedReply {
1114    pub enabled: bool,
1115    pub sequence: u16,
1116    pub length: u32,
1117}
1118impl_debug_if_no_extra_traits!(InputSelectedReply, "InputSelectedReply");
1119impl TryParse for InputSelectedReply {
1120    fn try_parse(initial_value: &[u8]) -> Result<(Self, &[u8]), ParseError> {
1121        let remaining = initial_value;
1122        let (response_type, remaining) = u8::try_parse(remaining)?;
1123        let (enabled, remaining) = bool::try_parse(remaining)?;
1124        let (sequence, remaining) = u16::try_parse(remaining)?;
1125        let (length, remaining) = u32::try_parse(remaining)?;
1126        if response_type != 1 {
1127            return Err(ParseError::InvalidValue);
1128        }
1129        let result = InputSelectedReply { enabled, sequence, length };
1130        let _ = remaining;
1131        let remaining = initial_value.get(32 + length as usize * 4..)
1132            .ok_or(ParseError::InsufficientData)?;
1133        Ok((result, remaining))
1134    }
1135}
1136impl Serialize for InputSelectedReply {
1137    type Bytes = [u8; 8];
1138    fn serialize(&self) -> [u8; 8] {
1139        let response_type_bytes = &[1];
1140        let enabled_bytes = self.enabled.serialize();
1141        let sequence_bytes = self.sequence.serialize();
1142        let length_bytes = self.length.serialize();
1143        [
1144            response_type_bytes[0],
1145            enabled_bytes[0],
1146            sequence_bytes[0],
1147            sequence_bytes[1],
1148            length_bytes[0],
1149            length_bytes[1],
1150            length_bytes[2],
1151            length_bytes[3],
1152        ]
1153    }
1154    fn serialize_into(&self, bytes: &mut Vec<u8>) {
1155        bytes.reserve(8);
1156        let response_type_bytes = &[1];
1157        bytes.push(response_type_bytes[0]);
1158        self.enabled.serialize_into(bytes);
1159        self.sequence.serialize_into(bytes);
1160        self.length.serialize_into(bytes);
1161    }
1162}
1163
1164/// Opcode for the GetRectangles request
1165pub const GET_RECTANGLES_REQUEST: u8 = 8;
1166#[derive(Clone, Copy, Default)]
1167#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
1168#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1169pub struct GetRectanglesRequest {
1170    pub window: xproto::Window,
1171    pub source_kind: SK,
1172}
1173impl_debug_if_no_extra_traits!(GetRectanglesRequest, "GetRectanglesRequest");
1174impl GetRectanglesRequest {
1175    /// Serialize this request into bytes for the provided connection
1176    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'static, [u8]>; 1]> {
1177        let length_so_far = 0;
1178        let window_bytes = self.window.serialize();
1179        let source_kind_bytes = Kind::from(self.source_kind).serialize();
1180        let mut request0 = vec![
1181            major_opcode,
1182            GET_RECTANGLES_REQUEST,
1183            0,
1184            0,
1185            window_bytes[0],
1186            window_bytes[1],
1187            window_bytes[2],
1188            window_bytes[3],
1189            source_kind_bytes[0],
1190            0,
1191            0,
1192            0,
1193        ];
1194        let length_so_far = length_so_far + request0.len();
1195        assert_eq!(length_so_far % 4, 0);
1196        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
1197        request0[2..4].copy_from_slice(&length.to_ne_bytes());
1198        ([request0.into()], vec![])
1199    }
1200    /// Parse this request given its header, its body, and any fds that go along with it
1201    #[cfg(feature = "request-parsing")]
1202    pub fn try_parse_request(header: RequestHeader, value: &[u8]) -> Result<Self, ParseError> {
1203        if header.minor_opcode != GET_RECTANGLES_REQUEST {
1204            return Err(ParseError::InvalidValue);
1205        }
1206        let (window, remaining) = xproto::Window::try_parse(value)?;
1207        let (source_kind, remaining) = Kind::try_parse(remaining)?;
1208        let source_kind = source_kind.into();
1209        let remaining = remaining.get(3..).ok_or(ParseError::InsufficientData)?;
1210        let _ = remaining;
1211        Ok(GetRectanglesRequest {
1212            window,
1213            source_kind,
1214        })
1215    }
1216}
1217impl Request for GetRectanglesRequest {
1218    const EXTENSION_NAME: Option<&'static str> = Some(X11_EXTENSION_NAME);
1219
1220    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
1221        let (bufs, fds) = self.serialize(major_opcode);
1222        // Flatten the buffers into a single vector
1223        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
1224        (buf, fds)
1225    }
1226}
1227impl crate::x11_utils::ReplyRequest for GetRectanglesRequest {
1228    type Reply = GetRectanglesReply;
1229}
1230
1231#[derive(Clone, Default)]
1232#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
1233#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1234pub struct GetRectanglesReply {
1235    pub ordering: xproto::ClipOrdering,
1236    pub sequence: u16,
1237    pub length: u32,
1238    pub rectangles: Vec<xproto::Rectangle>,
1239}
1240impl_debug_if_no_extra_traits!(GetRectanglesReply, "GetRectanglesReply");
1241impl TryParse for GetRectanglesReply {
1242    fn try_parse(initial_value: &[u8]) -> Result<(Self, &[u8]), ParseError> {
1243        let remaining = initial_value;
1244        let (response_type, remaining) = u8::try_parse(remaining)?;
1245        let (ordering, remaining) = u8::try_parse(remaining)?;
1246        let (sequence, remaining) = u16::try_parse(remaining)?;
1247        let (length, remaining) = u32::try_parse(remaining)?;
1248        let (rectangles_len, remaining) = u32::try_parse(remaining)?;
1249        let remaining = remaining.get(20..).ok_or(ParseError::InsufficientData)?;
1250        let (rectangles, remaining) = crate::x11_utils::parse_list::<xproto::Rectangle>(remaining, rectangles_len.try_to_usize()?)?;
1251        if response_type != 1 {
1252            return Err(ParseError::InvalidValue);
1253        }
1254        let ordering = ordering.into();
1255        let result = GetRectanglesReply { ordering, sequence, length, rectangles };
1256        let _ = remaining;
1257        let remaining = initial_value.get(32 + length as usize * 4..)
1258            .ok_or(ParseError::InsufficientData)?;
1259        Ok((result, remaining))
1260    }
1261}
1262impl Serialize for GetRectanglesReply {
1263    type Bytes = Vec<u8>;
1264    fn serialize(&self) -> Vec<u8> {
1265        let mut result = Vec::new();
1266        self.serialize_into(&mut result);
1267        result
1268    }
1269    fn serialize_into(&self, bytes: &mut Vec<u8>) {
1270        bytes.reserve(32);
1271        let response_type_bytes = &[1];
1272        bytes.push(response_type_bytes[0]);
1273        u8::from(self.ordering).serialize_into(bytes);
1274        self.sequence.serialize_into(bytes);
1275        self.length.serialize_into(bytes);
1276        let rectangles_len = u32::try_from(self.rectangles.len()).expect("`rectangles` has too many elements");
1277        rectangles_len.serialize_into(bytes);
1278        bytes.extend_from_slice(&[0; 20]);
1279        self.rectangles.serialize_into(bytes);
1280    }
1281}
1282impl GetRectanglesReply {
1283    /// Get the value of the `rectangles_len` field.
1284    ///
1285    /// The `rectangles_len` field is used as the length field of the `rectangles` field.
1286    /// This function computes the field's value again based on the length of the list.
1287    ///
1288    /// # Panics
1289    ///
1290    /// Panics if the value cannot be represented in the target type. This
1291    /// cannot happen with values of the struct received from the X11 server.
1292    pub fn rectangles_len(&self) -> u32 {
1293        self.rectangles.len()
1294            .try_into().unwrap()
1295    }
1296}
1297
x11rb_protocol/protocol/shape.rs

x11rb_protocol/protocol/
shape.rs
