x11rb_protocol/protocol/
present.rs

1// This file contains generated code. Do not edit directly.
2// To regenerate this, run 'make'.
3
4//! Bindings to the `Present` 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::dri3;
27#[allow(unused_imports)]
28use super::randr;
29#[allow(unused_imports)]
30use super::sync;
31#[allow(unused_imports)]
32use super::xfixes;
33#[allow(unused_imports)]
34use super::xproto;
35
36/// The X11 name of the extension for QueryExtension
37pub const X11_EXTENSION_NAME: &str = "Present";
38
39/// The version number of this extension that this client library supports.
40///
41/// This constant contains the version number of this extension that is supported
42/// by this build of x11rb. For most things, it does not make sense to use this
43/// information. If you need to send a `QueryVersion`, it is recommended to instead
44/// send the maximum version of the extension that you need.
45pub const X11_XML_VERSION: (u32, u32) = (1, 4);
46
47#[derive(Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
48#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
49pub struct EventEnum(u8);
50impl EventEnum {
51    pub const CONFIGURE_NOTIFY: Self = Self(0);
52    pub const COMPLETE_NOTIFY: Self = Self(1);
53    pub const IDLE_NOTIFY: Self = Self(2);
54    pub const REDIRECT_NOTIFY: Self = Self(3);
55}
56impl From<EventEnum> for u8 {
57    #[inline]
58    fn from(input: EventEnum) -> Self {
59        input.0
60    }
61}
62impl From<EventEnum> for core::option::Option<u8> {
63    #[inline]
64    fn from(input: EventEnum) -> Self {
65        Some(input.0)
66    }
67}
68impl From<EventEnum> for u16 {
69    #[inline]
70    fn from(input: EventEnum) -> Self {
71        u16::from(input.0)
72    }
73}
74impl From<EventEnum> for core::option::Option<u16> {
75    #[inline]
76    fn from(input: EventEnum) -> Self {
77        Some(u16::from(input.0))
78    }
79}
80impl From<EventEnum> for u32 {
81    #[inline]
82    fn from(input: EventEnum) -> Self {
83        u32::from(input.0)
84    }
85}
86impl From<EventEnum> for core::option::Option<u32> {
87    #[inline]
88    fn from(input: EventEnum) -> Self {
89        Some(u32::from(input.0))
90    }
91}
92impl From<u8> for EventEnum {
93    #[inline]
94    fn from(value: u8) -> Self {
95        Self(value)
96    }
97}
98impl core::fmt::Debug for EventEnum  {
99    fn fmt(&self, fmt: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
100        let variants = [
101            (Self::CONFIGURE_NOTIFY.0.into(), "CONFIGURE_NOTIFY", "ConfigureNotify"),
102            (Self::COMPLETE_NOTIFY.0.into(), "COMPLETE_NOTIFY", "CompleteNotify"),
103            (Self::IDLE_NOTIFY.0.into(), "IDLE_NOTIFY", "IdleNotify"),
104            (Self::REDIRECT_NOTIFY.0.into(), "REDIRECT_NOTIFY", "RedirectNotify"),
105        ];
106        pretty_print_enum(fmt, self.0.into(), &variants)
107    }
108}
109
110#[derive(Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
111#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
112pub struct EventMask(u32);
113impl EventMask {
114    pub const NO_EVENT: Self = Self(0);
115    pub const CONFIGURE_NOTIFY: Self = Self(1 << 0);
116    pub const COMPLETE_NOTIFY: Self = Self(1 << 1);
117    pub const IDLE_NOTIFY: Self = Self(1 << 2);
118    pub const REDIRECT_NOTIFY: Self = Self(1 << 3);
119}
120impl From<EventMask> for u32 {
121    #[inline]
122    fn from(input: EventMask) -> Self {
123        input.0
124    }
125}
126impl From<EventMask> for core::option::Option<u32> {
127    #[inline]
128    fn from(input: EventMask) -> Self {
129        Some(input.0)
130    }
131}
132impl From<u8> for EventMask {
133    #[inline]
134    fn from(value: u8) -> Self {
135        Self(value.into())
136    }
137}
138impl From<u16> for EventMask {
139    #[inline]
140    fn from(value: u16) -> Self {
141        Self(value.into())
142    }
143}
144impl From<u32> for EventMask {
145    #[inline]
146    fn from(value: u32) -> Self {
147        Self(value)
148    }
149}
150impl core::fmt::Debug for EventMask  {
151    fn fmt(&self, fmt: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
152        let variants = [
153            (Self::NO_EVENT.0, "NO_EVENT", "NoEvent"),
154            (Self::CONFIGURE_NOTIFY.0, "CONFIGURE_NOTIFY", "ConfigureNotify"),
155            (Self::COMPLETE_NOTIFY.0, "COMPLETE_NOTIFY", "CompleteNotify"),
156            (Self::IDLE_NOTIFY.0, "IDLE_NOTIFY", "IdleNotify"),
157            (Self::REDIRECT_NOTIFY.0, "REDIRECT_NOTIFY", "RedirectNotify"),
158        ];
159        pretty_print_bitmask(fmt, self.0, &variants)
160    }
161}
162bitmask_binop!(EventMask, u32);
163
164#[derive(Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
165#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
166pub struct Option(u8);
167impl Option {
168    pub const NONE: Self = Self(0);
169    pub const ASYNC: Self = Self(1 << 0);
170    pub const COPY: Self = Self(1 << 1);
171    pub const UST: Self = Self(1 << 2);
172    pub const SUBOPTIMAL: Self = Self(1 << 3);
173    pub const ASYNC_MAY_TEAR: Self = Self(1 << 4);
174}
175impl From<Option> for u8 {
176    #[inline]
177    fn from(input: Option) -> Self {
178        input.0
179    }
180}
181impl From<Option> for core::option::Option<u8> {
182    #[inline]
183    fn from(input: Option) -> Self {
184        Some(input.0)
185    }
186}
187impl From<Option> for u16 {
188    #[inline]
189    fn from(input: Option) -> Self {
190        u16::from(input.0)
191    }
192}
193impl From<Option> for core::option::Option<u16> {
194    #[inline]
195    fn from(input: Option) -> Self {
196        Some(u16::from(input.0))
197    }
198}
199impl From<Option> for u32 {
200    #[inline]
201    fn from(input: Option) -> Self {
202        u32::from(input.0)
203    }
204}
205impl From<Option> for core::option::Option<u32> {
206    #[inline]
207    fn from(input: Option) -> Self {
208        Some(u32::from(input.0))
209    }
210}
211impl From<u8> for Option {
212    #[inline]
213    fn from(value: u8) -> Self {
214        Self(value)
215    }
216}
217impl core::fmt::Debug for Option  {
218    fn fmt(&self, fmt: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
219        let variants = [
220            (Self::NONE.0.into(), "NONE", "None"),
221            (Self::ASYNC.0.into(), "ASYNC", "Async"),
222            (Self::COPY.0.into(), "COPY", "Copy"),
223            (Self::UST.0.into(), "UST", "UST"),
224            (Self::SUBOPTIMAL.0.into(), "SUBOPTIMAL", "Suboptimal"),
225            (Self::ASYNC_MAY_TEAR.0.into(), "ASYNC_MAY_TEAR", "AsyncMayTear"),
226        ];
227        pretty_print_bitmask(fmt, self.0.into(), &variants)
228    }
229}
230bitmask_binop!(Option, u8);
231
232#[derive(Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
233#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
234pub struct Capability(u8);
235impl Capability {
236    pub const NONE: Self = Self(0);
237    pub const ASYNC: Self = Self(1 << 0);
238    pub const FENCE: Self = Self(1 << 1);
239    pub const UST: Self = Self(1 << 2);
240    pub const ASYNC_MAY_TEAR: Self = Self(1 << 3);
241    pub const SYNCOBJ: Self = Self(1 << 4);
242}
243impl From<Capability> for u8 {
244    #[inline]
245    fn from(input: Capability) -> Self {
246        input.0
247    }
248}
249impl From<Capability> for core::option::Option<u8> {
250    #[inline]
251    fn from(input: Capability) -> Self {
252        Some(input.0)
253    }
254}
255impl From<Capability> for u16 {
256    #[inline]
257    fn from(input: Capability) -> Self {
258        u16::from(input.0)
259    }
260}
261impl From<Capability> for core::option::Option<u16> {
262    #[inline]
263    fn from(input: Capability) -> Self {
264        Some(u16::from(input.0))
265    }
266}
267impl From<Capability> for u32 {
268    #[inline]
269    fn from(input: Capability) -> Self {
270        u32::from(input.0)
271    }
272}
273impl From<Capability> for core::option::Option<u32> {
274    #[inline]
275    fn from(input: Capability) -> Self {
276        Some(u32::from(input.0))
277    }
278}
279impl From<u8> for Capability {
280    #[inline]
281    fn from(value: u8) -> Self {
282        Self(value)
283    }
284}
285impl core::fmt::Debug for Capability  {
286    fn fmt(&self, fmt: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
287        let variants = [
288            (Self::NONE.0.into(), "NONE", "None"),
289            (Self::ASYNC.0.into(), "ASYNC", "Async"),
290            (Self::FENCE.0.into(), "FENCE", "Fence"),
291            (Self::UST.0.into(), "UST", "UST"),
292            (Self::ASYNC_MAY_TEAR.0.into(), "ASYNC_MAY_TEAR", "AsyncMayTear"),
293            (Self::SYNCOBJ.0.into(), "SYNCOBJ", "Syncobj"),
294        ];
295        pretty_print_bitmask(fmt, self.0.into(), &variants)
296    }
297}
298bitmask_binop!(Capability, u8);
299
300#[derive(Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
301#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
302pub struct CompleteKind(u8);
303impl CompleteKind {
304    pub const PIXMAP: Self = Self(0);
305    pub const NOTIFY_MSC: Self = Self(1);
306}
307impl From<CompleteKind> for u8 {
308    #[inline]
309    fn from(input: CompleteKind) -> Self {
310        input.0
311    }
312}
313impl From<CompleteKind> for core::option::Option<u8> {
314    #[inline]
315    fn from(input: CompleteKind) -> Self {
316        Some(input.0)
317    }
318}
319impl From<CompleteKind> for u16 {
320    #[inline]
321    fn from(input: CompleteKind) -> Self {
322        u16::from(input.0)
323    }
324}
325impl From<CompleteKind> for core::option::Option<u16> {
326    #[inline]
327    fn from(input: CompleteKind) -> Self {
328        Some(u16::from(input.0))
329    }
330}
331impl From<CompleteKind> for u32 {
332    #[inline]
333    fn from(input: CompleteKind) -> Self {
334        u32::from(input.0)
335    }
336}
337impl From<CompleteKind> for core::option::Option<u32> {
338    #[inline]
339    fn from(input: CompleteKind) -> Self {
340        Some(u32::from(input.0))
341    }
342}
343impl From<u8> for CompleteKind {
344    #[inline]
345    fn from(value: u8) -> Self {
346        Self(value)
347    }
348}
349impl core::fmt::Debug for CompleteKind  {
350    fn fmt(&self, fmt: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
351        let variants = [
352            (Self::PIXMAP.0.into(), "PIXMAP", "Pixmap"),
353            (Self::NOTIFY_MSC.0.into(), "NOTIFY_MSC", "NotifyMSC"),
354        ];
355        pretty_print_enum(fmt, self.0.into(), &variants)
356    }
357}
358
359#[derive(Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
360#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
361pub struct CompleteMode(u8);
362impl CompleteMode {
363    pub const COPY: Self = Self(0);
364    pub const FLIP: Self = Self(1);
365    pub const SKIP: Self = Self(2);
366    pub const SUBOPTIMAL_COPY: Self = Self(3);
367}
368impl From<CompleteMode> for u8 {
369    #[inline]
370    fn from(input: CompleteMode) -> Self {
371        input.0
372    }
373}
374impl From<CompleteMode> for core::option::Option<u8> {
375    #[inline]
376    fn from(input: CompleteMode) -> Self {
377        Some(input.0)
378    }
379}
380impl From<CompleteMode> for u16 {
381    #[inline]
382    fn from(input: CompleteMode) -> Self {
383        u16::from(input.0)
384    }
385}
386impl From<CompleteMode> for core::option::Option<u16> {
387    #[inline]
388    fn from(input: CompleteMode) -> Self {
389        Some(u16::from(input.0))
390    }
391}
392impl From<CompleteMode> for u32 {
393    #[inline]
394    fn from(input: CompleteMode) -> Self {
395        u32::from(input.0)
396    }
397}
398impl From<CompleteMode> for core::option::Option<u32> {
399    #[inline]
400    fn from(input: CompleteMode) -> Self {
401        Some(u32::from(input.0))
402    }
403}
404impl From<u8> for CompleteMode {
405    #[inline]
406    fn from(value: u8) -> Self {
407        Self(value)
408    }
409}
410impl core::fmt::Debug for CompleteMode  {
411    fn fmt(&self, fmt: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
412        let variants = [
413            (Self::COPY.0.into(), "COPY", "Copy"),
414            (Self::FLIP.0.into(), "FLIP", "Flip"),
415            (Self::SKIP.0.into(), "SKIP", "Skip"),
416            (Self::SUBOPTIMAL_COPY.0.into(), "SUBOPTIMAL_COPY", "SuboptimalCopy"),
417        ];
418        pretty_print_enum(fmt, self.0.into(), &variants)
419    }
420}
421
422#[derive(Clone, Copy, Default)]
423#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
424#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
425pub struct Notify {
426    pub window: xproto::Window,
427    pub serial: u32,
428}
429impl_debug_if_no_extra_traits!(Notify, "Notify");
430impl TryParse for Notify {
431    fn try_parse(remaining: &[u8]) -> Result<(Self, &[u8]), ParseError> {
432        let (window, remaining) = xproto::Window::try_parse(remaining)?;
433        let (serial, remaining) = u32::try_parse(remaining)?;
434        let result = Notify { window, serial };
435        Ok((result, remaining))
436    }
437}
438impl Serialize for Notify {
439    type Bytes = [u8; 8];
440    fn serialize(&self) -> [u8; 8] {
441        let window_bytes = self.window.serialize();
442        let serial_bytes = self.serial.serialize();
443        [
444            window_bytes[0],
445            window_bytes[1],
446            window_bytes[2],
447            window_bytes[3],
448            serial_bytes[0],
449            serial_bytes[1],
450            serial_bytes[2],
451            serial_bytes[3],
452        ]
453    }
454    fn serialize_into(&self, bytes: &mut Vec<u8>) {
455        bytes.reserve(8);
456        self.window.serialize_into(bytes);
457        self.serial.serialize_into(bytes);
458    }
459}
460
461/// Opcode for the QueryVersion request
462pub const QUERY_VERSION_REQUEST: u8 = 0;
463#[derive(Clone, Copy, Default)]
464#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
465#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
466pub struct QueryVersionRequest {
467    pub major_version: u32,
468    pub minor_version: u32,
469}
470impl_debug_if_no_extra_traits!(QueryVersionRequest, "QueryVersionRequest");
471impl QueryVersionRequest {
472    /// Serialize this request into bytes for the provided connection
473    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'static, [u8]>; 1]> {
474        let length_so_far = 0;
475        let major_version_bytes = self.major_version.serialize();
476        let minor_version_bytes = self.minor_version.serialize();
477        let mut request0 = vec![
478            major_opcode,
479            QUERY_VERSION_REQUEST,
480            0,
481            0,
482            major_version_bytes[0],
483            major_version_bytes[1],
484            major_version_bytes[2],
485            major_version_bytes[3],
486            minor_version_bytes[0],
487            minor_version_bytes[1],
488            minor_version_bytes[2],
489            minor_version_bytes[3],
490        ];
491        let length_so_far = length_so_far + request0.len();
492        assert_eq!(length_so_far % 4, 0);
493        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
494        request0[2..4].copy_from_slice(&length.to_ne_bytes());
495        ([request0.into()], vec![])
496    }
497    /// Parse this request given its header, its body, and any fds that go along with it
498    #[cfg(feature = "request-parsing")]
499    pub fn try_parse_request(header: RequestHeader, value: &[u8]) -> Result<Self, ParseError> {
500        if header.minor_opcode != QUERY_VERSION_REQUEST {
501            return Err(ParseError::InvalidValue);
502        }
503        let (major_version, remaining) = u32::try_parse(value)?;
504        let (minor_version, remaining) = u32::try_parse(remaining)?;
505        let _ = remaining;
506        Ok(QueryVersionRequest {
507            major_version,
508            minor_version,
509        })
510    }
511}
512impl Request for QueryVersionRequest {
513    const EXTENSION_NAME: core::option::Option<&'static str> = Some(X11_EXTENSION_NAME);
514
515    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
516        let (bufs, fds) = self.serialize(major_opcode);
517        // Flatten the buffers into a single vector
518        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
519        (buf, fds)
520    }
521}
522impl crate::x11_utils::ReplyRequest for QueryVersionRequest {
523    type Reply = QueryVersionReply;
524}
525
526#[derive(Clone, Copy, Default)]
527#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
528#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
529pub struct QueryVersionReply {
530    pub sequence: u16,
531    pub length: u32,
532    pub major_version: u32,
533    pub minor_version: u32,
534}
535impl_debug_if_no_extra_traits!(QueryVersionReply, "QueryVersionReply");
536impl TryParse for QueryVersionReply {
537    fn try_parse(initial_value: &[u8]) -> Result<(Self, &[u8]), ParseError> {
538        let remaining = initial_value;
539        let (response_type, remaining) = u8::try_parse(remaining)?;
540        let remaining = remaining.get(1..).ok_or(ParseError::InsufficientData)?;
541        let (sequence, remaining) = u16::try_parse(remaining)?;
542        let (length, remaining) = u32::try_parse(remaining)?;
543        let (major_version, remaining) = u32::try_parse(remaining)?;
544        let (minor_version, remaining) = u32::try_parse(remaining)?;
545        if response_type != 1 {
546            return Err(ParseError::InvalidValue);
547        }
548        let result = QueryVersionReply { sequence, length, major_version, minor_version };
549        let _ = remaining;
550        let remaining = initial_value.get(32 + length as usize * 4..)
551            .ok_or(ParseError::InsufficientData)?;
552        Ok((result, remaining))
553    }
554}
555impl Serialize for QueryVersionReply {
556    type Bytes = [u8; 16];
557    fn serialize(&self) -> [u8; 16] {
558        let response_type_bytes = &[1];
559        let sequence_bytes = self.sequence.serialize();
560        let length_bytes = self.length.serialize();
561        let major_version_bytes = self.major_version.serialize();
562        let minor_version_bytes = self.minor_version.serialize();
563        [
564            response_type_bytes[0],
565            0,
566            sequence_bytes[0],
567            sequence_bytes[1],
568            length_bytes[0],
569            length_bytes[1],
570            length_bytes[2],
571            length_bytes[3],
572            major_version_bytes[0],
573            major_version_bytes[1],
574            major_version_bytes[2],
575            major_version_bytes[3],
576            minor_version_bytes[0],
577            minor_version_bytes[1],
578            minor_version_bytes[2],
579            minor_version_bytes[3],
580        ]
581    }
582    fn serialize_into(&self, bytes: &mut Vec<u8>) {
583        bytes.reserve(16);
584        let response_type_bytes = &[1];
585        bytes.push(response_type_bytes[0]);
586        bytes.extend_from_slice(&[0; 1]);
587        self.sequence.serialize_into(bytes);
588        self.length.serialize_into(bytes);
589        self.major_version.serialize_into(bytes);
590        self.minor_version.serialize_into(bytes);
591    }
592}
593
594/// Opcode for the Pixmap request
595pub const PIXMAP_REQUEST: u8 = 1;
596#[derive(Clone, Default)]
597#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
598#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
599pub struct PixmapRequest<'input> {
600    pub window: xproto::Window,
601    pub pixmap: xproto::Pixmap,
602    pub serial: u32,
603    pub valid: xfixes::Region,
604    pub update: xfixes::Region,
605    pub x_off: i16,
606    pub y_off: i16,
607    pub target_crtc: randr::Crtc,
608    pub wait_fence: sync::Fence,
609    pub idle_fence: sync::Fence,
610    pub options: u32,
611    pub target_msc: u64,
612    pub divisor: u64,
613    pub remainder: u64,
614    pub notifies: Cow<'input, [Notify]>,
615}
616impl_debug_if_no_extra_traits!(PixmapRequest<'_>, "PixmapRequest");
617impl<'input> PixmapRequest<'input> {
618    /// Serialize this request into bytes for the provided connection
619    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'input, [u8]>; 3]> {
620        let length_so_far = 0;
621        let window_bytes = self.window.serialize();
622        let pixmap_bytes = self.pixmap.serialize();
623        let serial_bytes = self.serial.serialize();
624        let valid_bytes = self.valid.serialize();
625        let update_bytes = self.update.serialize();
626        let x_off_bytes = self.x_off.serialize();
627        let y_off_bytes = self.y_off.serialize();
628        let target_crtc_bytes = self.target_crtc.serialize();
629        let wait_fence_bytes = self.wait_fence.serialize();
630        let idle_fence_bytes = self.idle_fence.serialize();
631        let options_bytes = self.options.serialize();
632        let target_msc_bytes = self.target_msc.serialize();
633        let divisor_bytes = self.divisor.serialize();
634        let remainder_bytes = self.remainder.serialize();
635        let mut request0 = vec![
636            major_opcode,
637            PIXMAP_REQUEST,
638            0,
639            0,
640            window_bytes[0],
641            window_bytes[1],
642            window_bytes[2],
643            window_bytes[3],
644            pixmap_bytes[0],
645            pixmap_bytes[1],
646            pixmap_bytes[2],
647            pixmap_bytes[3],
648            serial_bytes[0],
649            serial_bytes[1],
650            serial_bytes[2],
651            serial_bytes[3],
652            valid_bytes[0],
653            valid_bytes[1],
654            valid_bytes[2],
655            valid_bytes[3],
656            update_bytes[0],
657            update_bytes[1],
658            update_bytes[2],
659            update_bytes[3],
660            x_off_bytes[0],
661            x_off_bytes[1],
662            y_off_bytes[0],
663            y_off_bytes[1],
664            target_crtc_bytes[0],
665            target_crtc_bytes[1],
666            target_crtc_bytes[2],
667            target_crtc_bytes[3],
668            wait_fence_bytes[0],
669            wait_fence_bytes[1],
670            wait_fence_bytes[2],
671            wait_fence_bytes[3],
672            idle_fence_bytes[0],
673            idle_fence_bytes[1],
674            idle_fence_bytes[2],
675            idle_fence_bytes[3],
676            options_bytes[0],
677            options_bytes[1],
678            options_bytes[2],
679            options_bytes[3],
680            0,
681            0,
682            0,
683            0,
684            target_msc_bytes[0],
685            target_msc_bytes[1],
686            target_msc_bytes[2],
687            target_msc_bytes[3],
688            target_msc_bytes[4],
689            target_msc_bytes[5],
690            target_msc_bytes[6],
691            target_msc_bytes[7],
692            divisor_bytes[0],
693            divisor_bytes[1],
694            divisor_bytes[2],
695            divisor_bytes[3],
696            divisor_bytes[4],
697            divisor_bytes[5],
698            divisor_bytes[6],
699            divisor_bytes[7],
700            remainder_bytes[0],
701            remainder_bytes[1],
702            remainder_bytes[2],
703            remainder_bytes[3],
704            remainder_bytes[4],
705            remainder_bytes[5],
706            remainder_bytes[6],
707            remainder_bytes[7],
708        ];
709        let length_so_far = length_so_far + request0.len();
710        let notifies_bytes = self.notifies.serialize();
711        let length_so_far = length_so_far + notifies_bytes.len();
712        let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4];
713        let length_so_far = length_so_far + padding0.len();
714        assert_eq!(length_so_far % 4, 0);
715        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
716        request0[2..4].copy_from_slice(&length.to_ne_bytes());
717        ([request0.into(), notifies_bytes.into(), padding0.into()], vec![])
718    }
719    /// Parse this request given its header, its body, and any fds that go along with it
720    #[cfg(feature = "request-parsing")]
721    pub fn try_parse_request(header: RequestHeader, value: &'input [u8]) -> Result<Self, ParseError> {
722        if header.minor_opcode != PIXMAP_REQUEST {
723            return Err(ParseError::InvalidValue);
724        }
725        let (window, remaining) = xproto::Window::try_parse(value)?;
726        let (pixmap, remaining) = xproto::Pixmap::try_parse(remaining)?;
727        let (serial, remaining) = u32::try_parse(remaining)?;
728        let (valid, remaining) = xfixes::Region::try_parse(remaining)?;
729        let (update, remaining) = xfixes::Region::try_parse(remaining)?;
730        let (x_off, remaining) = i16::try_parse(remaining)?;
731        let (y_off, remaining) = i16::try_parse(remaining)?;
732        let (target_crtc, remaining) = randr::Crtc::try_parse(remaining)?;
733        let (wait_fence, remaining) = sync::Fence::try_parse(remaining)?;
734        let (idle_fence, remaining) = sync::Fence::try_parse(remaining)?;
735        let (options, remaining) = u32::try_parse(remaining)?;
736        let remaining = remaining.get(4..).ok_or(ParseError::InsufficientData)?;
737        let (target_msc, remaining) = u64::try_parse(remaining)?;
738        let (divisor, remaining) = u64::try_parse(remaining)?;
739        let (remainder, remaining) = u64::try_parse(remaining)?;
740        let mut remaining = remaining;
741        // Length is 'everything left in the input'
742        let mut notifies = Vec::new();
743        while !remaining.is_empty() {
744            let (v, new_remaining) = Notify::try_parse(remaining)?;
745            remaining = new_remaining;
746            notifies.push(v);
747        }
748        let _ = remaining;
749        Ok(PixmapRequest {
750            window,
751            pixmap,
752            serial,
753            valid,
754            update,
755            x_off,
756            y_off,
757            target_crtc,
758            wait_fence,
759            idle_fence,
760            options,
761            target_msc,
762            divisor,
763            remainder,
764            notifies: Cow::Owned(notifies),
765        })
766    }
767    /// Clone all borrowed data in this PixmapRequest.
768    pub fn into_owned(self) -> PixmapRequest<'static> {
769        PixmapRequest {
770            window: self.window,
771            pixmap: self.pixmap,
772            serial: self.serial,
773            valid: self.valid,
774            update: self.update,
775            x_off: self.x_off,
776            y_off: self.y_off,
777            target_crtc: self.target_crtc,
778            wait_fence: self.wait_fence,
779            idle_fence: self.idle_fence,
780            options: self.options,
781            target_msc: self.target_msc,
782            divisor: self.divisor,
783            remainder: self.remainder,
784            notifies: Cow::Owned(self.notifies.into_owned()),
785        }
786    }
787}
788impl<'input> Request for PixmapRequest<'input> {
789    const EXTENSION_NAME: core::option::Option<&'static str> = Some(X11_EXTENSION_NAME);
790
791    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
792        let (bufs, fds) = self.serialize(major_opcode);
793        // Flatten the buffers into a single vector
794        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
795        (buf, fds)
796    }
797}
798impl<'input> crate::x11_utils::VoidRequest for PixmapRequest<'input> {
799}
800
801/// Opcode for the NotifyMSC request
802pub const NOTIFY_MSC_REQUEST: u8 = 2;
803#[derive(Clone, Copy, Default)]
804#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
805#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
806pub struct NotifyMSCRequest {
807    pub window: xproto::Window,
808    pub serial: u32,
809    pub target_msc: u64,
810    pub divisor: u64,
811    pub remainder: u64,
812}
813impl_debug_if_no_extra_traits!(NotifyMSCRequest, "NotifyMSCRequest");
814impl NotifyMSCRequest {
815    /// Serialize this request into bytes for the provided connection
816    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'static, [u8]>; 1]> {
817        let length_so_far = 0;
818        let window_bytes = self.window.serialize();
819        let serial_bytes = self.serial.serialize();
820        let target_msc_bytes = self.target_msc.serialize();
821        let divisor_bytes = self.divisor.serialize();
822        let remainder_bytes = self.remainder.serialize();
823        let mut request0 = vec![
824            major_opcode,
825            NOTIFY_MSC_REQUEST,
826            0,
827            0,
828            window_bytes[0],
829            window_bytes[1],
830            window_bytes[2],
831            window_bytes[3],
832            serial_bytes[0],
833            serial_bytes[1],
834            serial_bytes[2],
835            serial_bytes[3],
836            0,
837            0,
838            0,
839            0,
840            target_msc_bytes[0],
841            target_msc_bytes[1],
842            target_msc_bytes[2],
843            target_msc_bytes[3],
844            target_msc_bytes[4],
845            target_msc_bytes[5],
846            target_msc_bytes[6],
847            target_msc_bytes[7],
848            divisor_bytes[0],
849            divisor_bytes[1],
850            divisor_bytes[2],
851            divisor_bytes[3],
852            divisor_bytes[4],
853            divisor_bytes[5],
854            divisor_bytes[6],
855            divisor_bytes[7],
856            remainder_bytes[0],
857            remainder_bytes[1],
858            remainder_bytes[2],
859            remainder_bytes[3],
860            remainder_bytes[4],
861            remainder_bytes[5],
862            remainder_bytes[6],
863            remainder_bytes[7],
864        ];
865        let length_so_far = length_so_far + request0.len();
866        assert_eq!(length_so_far % 4, 0);
867        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
868        request0[2..4].copy_from_slice(&length.to_ne_bytes());
869        ([request0.into()], vec![])
870    }
871    /// Parse this request given its header, its body, and any fds that go along with it
872    #[cfg(feature = "request-parsing")]
873    pub fn try_parse_request(header: RequestHeader, value: &[u8]) -> Result<Self, ParseError> {
874        if header.minor_opcode != NOTIFY_MSC_REQUEST {
875            return Err(ParseError::InvalidValue);
876        }
877        let (window, remaining) = xproto::Window::try_parse(value)?;
878        let (serial, remaining) = u32::try_parse(remaining)?;
879        let remaining = remaining.get(4..).ok_or(ParseError::InsufficientData)?;
880        let (target_msc, remaining) = u64::try_parse(remaining)?;
881        let (divisor, remaining) = u64::try_parse(remaining)?;
882        let (remainder, remaining) = u64::try_parse(remaining)?;
883        let _ = remaining;
884        Ok(NotifyMSCRequest {
885            window,
886            serial,
887            target_msc,
888            divisor,
889            remainder,
890        })
891    }
892}
893impl Request for NotifyMSCRequest {
894    const EXTENSION_NAME: core::option::Option<&'static str> = Some(X11_EXTENSION_NAME);
895
896    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
897        let (bufs, fds) = self.serialize(major_opcode);
898        // Flatten the buffers into a single vector
899        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
900        (buf, fds)
901    }
902}
903impl crate::x11_utils::VoidRequest for NotifyMSCRequest {
904}
905
906pub type Event = u32;
907
908/// Opcode for the SelectInput request
909pub const SELECT_INPUT_REQUEST: u8 = 3;
910#[derive(Clone, Copy, Default)]
911#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
912#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
913pub struct SelectInputRequest {
914    pub eid: Event,
915    pub window: xproto::Window,
916    pub event_mask: EventMask,
917}
918impl_debug_if_no_extra_traits!(SelectInputRequest, "SelectInputRequest");
919impl SelectInputRequest {
920    /// Serialize this request into bytes for the provided connection
921    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'static, [u8]>; 1]> {
922        let length_so_far = 0;
923        let eid_bytes = self.eid.serialize();
924        let window_bytes = self.window.serialize();
925        let event_mask_bytes = u32::from(self.event_mask).serialize();
926        let mut request0 = vec![
927            major_opcode,
928            SELECT_INPUT_REQUEST,
929            0,
930            0,
931            eid_bytes[0],
932            eid_bytes[1],
933            eid_bytes[2],
934            eid_bytes[3],
935            window_bytes[0],
936            window_bytes[1],
937            window_bytes[2],
938            window_bytes[3],
939            event_mask_bytes[0],
940            event_mask_bytes[1],
941            event_mask_bytes[2],
942            event_mask_bytes[3],
943        ];
944        let length_so_far = length_so_far + request0.len();
945        assert_eq!(length_so_far % 4, 0);
946        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
947        request0[2..4].copy_from_slice(&length.to_ne_bytes());
948        ([request0.into()], vec![])
949    }
950    /// Parse this request given its header, its body, and any fds that go along with it
951    #[cfg(feature = "request-parsing")]
952    pub fn try_parse_request(header: RequestHeader, value: &[u8]) -> Result<Self, ParseError> {
953        if header.minor_opcode != SELECT_INPUT_REQUEST {
954            return Err(ParseError::InvalidValue);
955        }
956        let (eid, remaining) = Event::try_parse(value)?;
957        let (window, remaining) = xproto::Window::try_parse(remaining)?;
958        let (event_mask, remaining) = u32::try_parse(remaining)?;
959        let event_mask = event_mask.into();
960        let _ = remaining;
961        Ok(SelectInputRequest {
962            eid,
963            window,
964            event_mask,
965        })
966    }
967}
968impl Request for SelectInputRequest {
969    const EXTENSION_NAME: core::option::Option<&'static str> = Some(X11_EXTENSION_NAME);
970
971    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
972        let (bufs, fds) = self.serialize(major_opcode);
973        // Flatten the buffers into a single vector
974        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
975        (buf, fds)
976    }
977}
978impl crate::x11_utils::VoidRequest for SelectInputRequest {
979}
980
981/// Opcode for the QueryCapabilities request
982pub const QUERY_CAPABILITIES_REQUEST: u8 = 4;
983#[derive(Clone, Copy, Default)]
984#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
985#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
986pub struct QueryCapabilitiesRequest {
987    pub target: u32,
988}
989impl_debug_if_no_extra_traits!(QueryCapabilitiesRequest, "QueryCapabilitiesRequest");
990impl QueryCapabilitiesRequest {
991    /// Serialize this request into bytes for the provided connection
992    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'static, [u8]>; 1]> {
993        let length_so_far = 0;
994        let target_bytes = self.target.serialize();
995        let mut request0 = vec![
996            major_opcode,
997            QUERY_CAPABILITIES_REQUEST,
998            0,
999            0,
1000            target_bytes[0],
1001            target_bytes[1],
1002            target_bytes[2],
1003            target_bytes[3],
1004        ];
1005        let length_so_far = length_so_far + request0.len();
1006        assert_eq!(length_so_far % 4, 0);
1007        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
1008        request0[2..4].copy_from_slice(&length.to_ne_bytes());
1009        ([request0.into()], vec![])
1010    }
1011    /// Parse this request given its header, its body, and any fds that go along with it
1012    #[cfg(feature = "request-parsing")]
1013    pub fn try_parse_request(header: RequestHeader, value: &[u8]) -> Result<Self, ParseError> {
1014        if header.minor_opcode != QUERY_CAPABILITIES_REQUEST {
1015            return Err(ParseError::InvalidValue);
1016        }
1017        let (target, remaining) = u32::try_parse(value)?;
1018        let _ = remaining;
1019        Ok(QueryCapabilitiesRequest {
1020            target,
1021        })
1022    }
1023}
1024impl Request for QueryCapabilitiesRequest {
1025    const EXTENSION_NAME: core::option::Option<&'static str> = Some(X11_EXTENSION_NAME);
1026
1027    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
1028        let (bufs, fds) = self.serialize(major_opcode);
1029        // Flatten the buffers into a single vector
1030        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
1031        (buf, fds)
1032    }
1033}
1034impl crate::x11_utils::ReplyRequest for QueryCapabilitiesRequest {
1035    type Reply = QueryCapabilitiesReply;
1036}
1037
1038#[derive(Clone, Copy, Default)]
1039#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
1040#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1041pub struct QueryCapabilitiesReply {
1042    pub sequence: u16,
1043    pub length: u32,
1044    pub capabilities: u32,
1045}
1046impl_debug_if_no_extra_traits!(QueryCapabilitiesReply, "QueryCapabilitiesReply");
1047impl TryParse for QueryCapabilitiesReply {
1048    fn try_parse(initial_value: &[u8]) -> Result<(Self, &[u8]), ParseError> {
1049        let remaining = initial_value;
1050        let (response_type, remaining) = u8::try_parse(remaining)?;
1051        let remaining = remaining.get(1..).ok_or(ParseError::InsufficientData)?;
1052        let (sequence, remaining) = u16::try_parse(remaining)?;
1053        let (length, remaining) = u32::try_parse(remaining)?;
1054        let (capabilities, remaining) = u32::try_parse(remaining)?;
1055        if response_type != 1 {
1056            return Err(ParseError::InvalidValue);
1057        }
1058        let result = QueryCapabilitiesReply { sequence, length, capabilities };
1059        let _ = remaining;
1060        let remaining = initial_value.get(32 + length as usize * 4..)
1061            .ok_or(ParseError::InsufficientData)?;
1062        Ok((result, remaining))
1063    }
1064}
1065impl Serialize for QueryCapabilitiesReply {
1066    type Bytes = [u8; 12];
1067    fn serialize(&self) -> [u8; 12] {
1068        let response_type_bytes = &[1];
1069        let sequence_bytes = self.sequence.serialize();
1070        let length_bytes = self.length.serialize();
1071        let capabilities_bytes = self.capabilities.serialize();
1072        [
1073            response_type_bytes[0],
1074            0,
1075            sequence_bytes[0],
1076            sequence_bytes[1],
1077            length_bytes[0],
1078            length_bytes[1],
1079            length_bytes[2],
1080            length_bytes[3],
1081            capabilities_bytes[0],
1082            capabilities_bytes[1],
1083            capabilities_bytes[2],
1084            capabilities_bytes[3],
1085        ]
1086    }
1087    fn serialize_into(&self, bytes: &mut Vec<u8>) {
1088        bytes.reserve(12);
1089        let response_type_bytes = &[1];
1090        bytes.push(response_type_bytes[0]);
1091        bytes.extend_from_slice(&[0; 1]);
1092        self.sequence.serialize_into(bytes);
1093        self.length.serialize_into(bytes);
1094        self.capabilities.serialize_into(bytes);
1095    }
1096}
1097
1098/// Opcode for the PixmapSynced request
1099pub const PIXMAP_SYNCED_REQUEST: u8 = 5;
1100#[derive(Clone, Default)]
1101#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
1102#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1103pub struct PixmapSyncedRequest<'input> {
1104    pub window: xproto::Window,
1105    pub pixmap: xproto::Pixmap,
1106    pub serial: u32,
1107    pub valid: xfixes::Region,
1108    pub update: xfixes::Region,
1109    pub x_off: i16,
1110    pub y_off: i16,
1111    pub target_crtc: randr::Crtc,
1112    pub acquire_syncobj: dri3::Syncobj,
1113    pub release_syncobj: dri3::Syncobj,
1114    pub acquire_point: u64,
1115    pub release_point: u64,
1116    pub options: u32,
1117    pub target_msc: u64,
1118    pub divisor: u64,
1119    pub remainder: u64,
1120    pub notifies: Cow<'input, [Notify]>,
1121}
1122impl_debug_if_no_extra_traits!(PixmapSyncedRequest<'_>, "PixmapSyncedRequest");
1123impl<'input> PixmapSyncedRequest<'input> {
1124    /// Serialize this request into bytes for the provided connection
1125    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'input, [u8]>; 3]> {
1126        let length_so_far = 0;
1127        let window_bytes = self.window.serialize();
1128        let pixmap_bytes = self.pixmap.serialize();
1129        let serial_bytes = self.serial.serialize();
1130        let valid_bytes = self.valid.serialize();
1131        let update_bytes = self.update.serialize();
1132        let x_off_bytes = self.x_off.serialize();
1133        let y_off_bytes = self.y_off.serialize();
1134        let target_crtc_bytes = self.target_crtc.serialize();
1135        let acquire_syncobj_bytes = self.acquire_syncobj.serialize();
1136        let release_syncobj_bytes = self.release_syncobj.serialize();
1137        let acquire_point_bytes = self.acquire_point.serialize();
1138        let release_point_bytes = self.release_point.serialize();
1139        let options_bytes = self.options.serialize();
1140        let target_msc_bytes = self.target_msc.serialize();
1141        let divisor_bytes = self.divisor.serialize();
1142        let remainder_bytes = self.remainder.serialize();
1143        let mut request0 = vec![
1144            major_opcode,
1145            PIXMAP_SYNCED_REQUEST,
1146            0,
1147            0,
1148            window_bytes[0],
1149            window_bytes[1],
1150            window_bytes[2],
1151            window_bytes[3],
1152            pixmap_bytes[0],
1153            pixmap_bytes[1],
1154            pixmap_bytes[2],
1155            pixmap_bytes[3],
1156            serial_bytes[0],
1157            serial_bytes[1],
1158            serial_bytes[2],
1159            serial_bytes[3],
1160            valid_bytes[0],
1161            valid_bytes[1],
1162            valid_bytes[2],
1163            valid_bytes[3],
1164            update_bytes[0],
1165            update_bytes[1],
1166            update_bytes[2],
1167            update_bytes[3],
1168            x_off_bytes[0],
1169            x_off_bytes[1],
1170            y_off_bytes[0],
1171            y_off_bytes[1],
1172            target_crtc_bytes[0],
1173            target_crtc_bytes[1],
1174            target_crtc_bytes[2],
1175            target_crtc_bytes[3],
1176            acquire_syncobj_bytes[0],
1177            acquire_syncobj_bytes[1],
1178            acquire_syncobj_bytes[2],
1179            acquire_syncobj_bytes[3],
1180            release_syncobj_bytes[0],
1181            release_syncobj_bytes[1],
1182            release_syncobj_bytes[2],
1183            release_syncobj_bytes[3],
1184            acquire_point_bytes[0],
1185            acquire_point_bytes[1],
1186            acquire_point_bytes[2],
1187            acquire_point_bytes[3],
1188            acquire_point_bytes[4],
1189            acquire_point_bytes[5],
1190            acquire_point_bytes[6],
1191            acquire_point_bytes[7],
1192            release_point_bytes[0],
1193            release_point_bytes[1],
1194            release_point_bytes[2],
1195            release_point_bytes[3],
1196            release_point_bytes[4],
1197            release_point_bytes[5],
1198            release_point_bytes[6],
1199            release_point_bytes[7],
1200            options_bytes[0],
1201            options_bytes[1],
1202            options_bytes[2],
1203            options_bytes[3],
1204            0,
1205            0,
1206            0,
1207            0,
1208            target_msc_bytes[0],
1209            target_msc_bytes[1],
1210            target_msc_bytes[2],
1211            target_msc_bytes[3],
1212            target_msc_bytes[4],
1213            target_msc_bytes[5],
1214            target_msc_bytes[6],
1215            target_msc_bytes[7],
1216            divisor_bytes[0],
1217            divisor_bytes[1],
1218            divisor_bytes[2],
1219            divisor_bytes[3],
1220            divisor_bytes[4],
1221            divisor_bytes[5],
1222            divisor_bytes[6],
1223            divisor_bytes[7],
1224            remainder_bytes[0],
1225            remainder_bytes[1],
1226            remainder_bytes[2],
1227            remainder_bytes[3],
1228            remainder_bytes[4],
1229            remainder_bytes[5],
1230            remainder_bytes[6],
1231            remainder_bytes[7],
1232        ];
1233        let length_so_far = length_so_far + request0.len();
1234        let notifies_bytes = self.notifies.serialize();
1235        let length_so_far = length_so_far + notifies_bytes.len();
1236        let padding0 = &[0; 3][..(4 - (length_so_far % 4)) % 4];
1237        let length_so_far = length_so_far + padding0.len();
1238        assert_eq!(length_so_far % 4, 0);
1239        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
1240        request0[2..4].copy_from_slice(&length.to_ne_bytes());
1241        ([request0.into(), notifies_bytes.into(), padding0.into()], vec![])
1242    }
1243    /// Parse this request given its header, its body, and any fds that go along with it
1244    #[cfg(feature = "request-parsing")]
1245    pub fn try_parse_request(header: RequestHeader, value: &'input [u8]) -> Result<Self, ParseError> {
1246        if header.minor_opcode != PIXMAP_SYNCED_REQUEST {
1247            return Err(ParseError::InvalidValue);
1248        }
1249        let (window, remaining) = xproto::Window::try_parse(value)?;
1250        let (pixmap, remaining) = xproto::Pixmap::try_parse(remaining)?;
1251        let (serial, remaining) = u32::try_parse(remaining)?;
1252        let (valid, remaining) = xfixes::Region::try_parse(remaining)?;
1253        let (update, remaining) = xfixes::Region::try_parse(remaining)?;
1254        let (x_off, remaining) = i16::try_parse(remaining)?;
1255        let (y_off, remaining) = i16::try_parse(remaining)?;
1256        let (target_crtc, remaining) = randr::Crtc::try_parse(remaining)?;
1257        let (acquire_syncobj, remaining) = dri3::Syncobj::try_parse(remaining)?;
1258        let (release_syncobj, remaining) = dri3::Syncobj::try_parse(remaining)?;
1259        let (acquire_point, remaining) = u64::try_parse(remaining)?;
1260        let (release_point, remaining) = u64::try_parse(remaining)?;
1261        let (options, remaining) = u32::try_parse(remaining)?;
1262        let remaining = remaining.get(4..).ok_or(ParseError::InsufficientData)?;
1263        let (target_msc, remaining) = u64::try_parse(remaining)?;
1264        let (divisor, remaining) = u64::try_parse(remaining)?;
1265        let (remainder, remaining) = u64::try_parse(remaining)?;
1266        let mut remaining = remaining;
1267        // Length is 'everything left in the input'
1268        let mut notifies = Vec::new();
1269        while !remaining.is_empty() {
1270            let (v, new_remaining) = Notify::try_parse(remaining)?;
1271            remaining = new_remaining;
1272            notifies.push(v);
1273        }
1274        let _ = remaining;
1275        Ok(PixmapSyncedRequest {
1276            window,
1277            pixmap,
1278            serial,
1279            valid,
1280            update,
1281            x_off,
1282            y_off,
1283            target_crtc,
1284            acquire_syncobj,
1285            release_syncobj,
1286            acquire_point,
1287            release_point,
1288            options,
1289            target_msc,
1290            divisor,
1291            remainder,
1292            notifies: Cow::Owned(notifies),
1293        })
1294    }
1295    /// Clone all borrowed data in this PixmapSyncedRequest.
1296    pub fn into_owned(self) -> PixmapSyncedRequest<'static> {
1297        PixmapSyncedRequest {
1298            window: self.window,
1299            pixmap: self.pixmap,
1300            serial: self.serial,
1301            valid: self.valid,
1302            update: self.update,
1303            x_off: self.x_off,
1304            y_off: self.y_off,
1305            target_crtc: self.target_crtc,
1306            acquire_syncobj: self.acquire_syncobj,
1307            release_syncobj: self.release_syncobj,
1308            acquire_point: self.acquire_point,
1309            release_point: self.release_point,
1310            options: self.options,
1311            target_msc: self.target_msc,
1312            divisor: self.divisor,
1313            remainder: self.remainder,
1314            notifies: Cow::Owned(self.notifies.into_owned()),
1315        }
1316    }
1317}
1318impl<'input> Request for PixmapSyncedRequest<'input> {
1319    const EXTENSION_NAME: core::option::Option<&'static str> = Some(X11_EXTENSION_NAME);
1320
1321    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
1322        let (bufs, fds) = self.serialize(major_opcode);
1323        // Flatten the buffers into a single vector
1324        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
1325        (buf, fds)
1326    }
1327}
1328impl<'input> crate::x11_utils::VoidRequest for PixmapSyncedRequest<'input> {
1329}
1330
1331/// Opcode for the Generic event
1332pub const GENERIC_EVENT: u8 = 0;
1333#[derive(Clone, Copy, Default)]
1334#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
1335#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1336pub struct GenericEvent {
1337    pub response_type: u8,
1338    pub extension: u8,
1339    pub sequence: u16,
1340    pub length: u32,
1341    pub evtype: u16,
1342    pub event: Event,
1343}
1344impl_debug_if_no_extra_traits!(GenericEvent, "GenericEvent");
1345impl TryParse for GenericEvent {
1346    fn try_parse(initial_value: &[u8]) -> Result<(Self, &[u8]), ParseError> {
1347        let remaining = initial_value;
1348        let (response_type, remaining) = u8::try_parse(remaining)?;
1349        let (extension, remaining) = u8::try_parse(remaining)?;
1350        let (sequence, remaining) = u16::try_parse(remaining)?;
1351        let (length, remaining) = u32::try_parse(remaining)?;
1352        let (evtype, remaining) = u16::try_parse(remaining)?;
1353        let remaining = remaining.get(2..).ok_or(ParseError::InsufficientData)?;
1354        let (event, remaining) = Event::try_parse(remaining)?;
1355        let result = GenericEvent { response_type, extension, sequence, length, evtype, event };
1356        let _ = remaining;
1357        let remaining = initial_value.get(32..)
1358            .ok_or(ParseError::InsufficientData)?;
1359        Ok((result, remaining))
1360    }
1361}
1362impl Serialize for GenericEvent {
1363    type Bytes = [u8; 16];
1364    fn serialize(&self) -> [u8; 16] {
1365        let response_type_bytes = self.response_type.serialize();
1366        let extension_bytes = self.extension.serialize();
1367        let sequence_bytes = self.sequence.serialize();
1368        let length_bytes = self.length.serialize();
1369        let evtype_bytes = self.evtype.serialize();
1370        let event_bytes = self.event.serialize();
1371        [
1372            response_type_bytes[0],
1373            extension_bytes[0],
1374            sequence_bytes[0],
1375            sequence_bytes[1],
1376            length_bytes[0],
1377            length_bytes[1],
1378            length_bytes[2],
1379            length_bytes[3],
1380            evtype_bytes[0],
1381            evtype_bytes[1],
1382            0,
1383            0,
1384            event_bytes[0],
1385            event_bytes[1],
1386            event_bytes[2],
1387            event_bytes[3],
1388        ]
1389    }
1390    fn serialize_into(&self, bytes: &mut Vec<u8>) {
1391        bytes.reserve(16);
1392        self.response_type.serialize_into(bytes);
1393        self.extension.serialize_into(bytes);
1394        self.sequence.serialize_into(bytes);
1395        self.length.serialize_into(bytes);
1396        self.evtype.serialize_into(bytes);
1397        bytes.extend_from_slice(&[0; 2]);
1398        self.event.serialize_into(bytes);
1399    }
1400}
1401impl From<&GenericEvent> for [u8; 32] {
1402    fn from(input: &GenericEvent) -> Self {
1403        let response_type_bytes = input.response_type.serialize();
1404        let extension_bytes = input.extension.serialize();
1405        let sequence_bytes = input.sequence.serialize();
1406        let length_bytes = input.length.serialize();
1407        let evtype_bytes = input.evtype.serialize();
1408        let event_bytes = input.event.serialize();
1409        [
1410            response_type_bytes[0],
1411            extension_bytes[0],
1412            sequence_bytes[0],
1413            sequence_bytes[1],
1414            length_bytes[0],
1415            length_bytes[1],
1416            length_bytes[2],
1417            length_bytes[3],
1418            evtype_bytes[0],
1419            evtype_bytes[1],
1420            0,
1421            0,
1422            event_bytes[0],
1423            event_bytes[1],
1424            event_bytes[2],
1425            event_bytes[3],
1426            // trailing padding
1427            0,
1428            0,
1429            0,
1430            0,
1431            0,
1432            0,
1433            0,
1434            0,
1435            0,
1436            0,
1437            0,
1438            0,
1439            0,
1440            0,
1441            0,
1442            0,
1443        ]
1444    }
1445}
1446impl From<GenericEvent> for [u8; 32] {
1447    fn from(input: GenericEvent) -> Self {
1448        Self::from(&input)
1449    }
1450}
1451
1452/// Opcode for the ConfigureNotify event
1453pub const CONFIGURE_NOTIFY_EVENT: u16 = 0;
1454#[derive(Clone, Copy, Default)]
1455#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
1456#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1457pub struct ConfigureNotifyEvent {
1458    pub response_type: u8,
1459    pub extension: u8,
1460    pub sequence: u16,
1461    pub length: u32,
1462    pub event_type: u16,
1463    pub event: Event,
1464    pub window: xproto::Window,
1465    pub x: i16,
1466    pub y: i16,
1467    pub width: u16,
1468    pub height: u16,
1469    pub off_x: i16,
1470    pub off_y: i16,
1471    pub pixmap_width: u16,
1472    pub pixmap_height: u16,
1473    pub pixmap_flags: u32,
1474}
1475impl_debug_if_no_extra_traits!(ConfigureNotifyEvent, "ConfigureNotifyEvent");
1476impl TryParse for ConfigureNotifyEvent {
1477    fn try_parse(initial_value: &[u8]) -> Result<(Self, &[u8]), ParseError> {
1478        let remaining = initial_value;
1479        let (response_type, remaining) = u8::try_parse(remaining)?;
1480        let (extension, remaining) = u8::try_parse(remaining)?;
1481        let (sequence, remaining) = u16::try_parse(remaining)?;
1482        let (length, remaining) = u32::try_parse(remaining)?;
1483        let (event_type, remaining) = u16::try_parse(remaining)?;
1484        let remaining = remaining.get(2..).ok_or(ParseError::InsufficientData)?;
1485        let (event, remaining) = Event::try_parse(remaining)?;
1486        let (window, remaining) = xproto::Window::try_parse(remaining)?;
1487        let (x, remaining) = i16::try_parse(remaining)?;
1488        let (y, remaining) = i16::try_parse(remaining)?;
1489        let (width, remaining) = u16::try_parse(remaining)?;
1490        let (height, remaining) = u16::try_parse(remaining)?;
1491        let (off_x, remaining) = i16::try_parse(remaining)?;
1492        let (off_y, remaining) = i16::try_parse(remaining)?;
1493        let (pixmap_width, remaining) = u16::try_parse(remaining)?;
1494        let (pixmap_height, remaining) = u16::try_parse(remaining)?;
1495        let (pixmap_flags, remaining) = u32::try_parse(remaining)?;
1496        let result = ConfigureNotifyEvent { response_type, extension, sequence, length, event_type, event, window, x, y, width, height, off_x, off_y, pixmap_width, pixmap_height, pixmap_flags };
1497        let _ = remaining;
1498        let remaining = initial_value.get(32 + length as usize * 4..)
1499            .ok_or(ParseError::InsufficientData)?;
1500        Ok((result, remaining))
1501    }
1502}
1503impl Serialize for ConfigureNotifyEvent {
1504    type Bytes = [u8; 40];
1505    fn serialize(&self) -> [u8; 40] {
1506        let response_type_bytes = self.response_type.serialize();
1507        let extension_bytes = self.extension.serialize();
1508        let sequence_bytes = self.sequence.serialize();
1509        let length_bytes = self.length.serialize();
1510        let event_type_bytes = self.event_type.serialize();
1511        let event_bytes = self.event.serialize();
1512        let window_bytes = self.window.serialize();
1513        let x_bytes = self.x.serialize();
1514        let y_bytes = self.y.serialize();
1515        let width_bytes = self.width.serialize();
1516        let height_bytes = self.height.serialize();
1517        let off_x_bytes = self.off_x.serialize();
1518        let off_y_bytes = self.off_y.serialize();
1519        let pixmap_width_bytes = self.pixmap_width.serialize();
1520        let pixmap_height_bytes = self.pixmap_height.serialize();
1521        let pixmap_flags_bytes = self.pixmap_flags.serialize();
1522        [
1523            response_type_bytes[0],
1524            extension_bytes[0],
1525            sequence_bytes[0],
1526            sequence_bytes[1],
1527            length_bytes[0],
1528            length_bytes[1],
1529            length_bytes[2],
1530            length_bytes[3],
1531            event_type_bytes[0],
1532            event_type_bytes[1],
1533            0,
1534            0,
1535            event_bytes[0],
1536            event_bytes[1],
1537            event_bytes[2],
1538            event_bytes[3],
1539            window_bytes[0],
1540            window_bytes[1],
1541            window_bytes[2],
1542            window_bytes[3],
1543            x_bytes[0],
1544            x_bytes[1],
1545            y_bytes[0],
1546            y_bytes[1],
1547            width_bytes[0],
1548            width_bytes[1],
1549            height_bytes[0],
1550            height_bytes[1],
1551            off_x_bytes[0],
1552            off_x_bytes[1],
1553            off_y_bytes[0],
1554            off_y_bytes[1],
1555            pixmap_width_bytes[0],
1556            pixmap_width_bytes[1],
1557            pixmap_height_bytes[0],
1558            pixmap_height_bytes[1],
1559            pixmap_flags_bytes[0],
1560            pixmap_flags_bytes[1],
1561            pixmap_flags_bytes[2],
1562            pixmap_flags_bytes[3],
1563        ]
1564    }
1565    fn serialize_into(&self, bytes: &mut Vec<u8>) {
1566        bytes.reserve(40);
1567        self.response_type.serialize_into(bytes);
1568        self.extension.serialize_into(bytes);
1569        self.sequence.serialize_into(bytes);
1570        self.length.serialize_into(bytes);
1571        self.event_type.serialize_into(bytes);
1572        bytes.extend_from_slice(&[0; 2]);
1573        self.event.serialize_into(bytes);
1574        self.window.serialize_into(bytes);
1575        self.x.serialize_into(bytes);
1576        self.y.serialize_into(bytes);
1577        self.width.serialize_into(bytes);
1578        self.height.serialize_into(bytes);
1579        self.off_x.serialize_into(bytes);
1580        self.off_y.serialize_into(bytes);
1581        self.pixmap_width.serialize_into(bytes);
1582        self.pixmap_height.serialize_into(bytes);
1583        self.pixmap_flags.serialize_into(bytes);
1584    }
1585}
1586
1587/// Opcode for the CompleteNotify event
1588pub const COMPLETE_NOTIFY_EVENT: u16 = 1;
1589#[derive(Clone, Copy, Default)]
1590#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
1591#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1592pub struct CompleteNotifyEvent {
1593    pub response_type: u8,
1594    pub extension: u8,
1595    pub sequence: u16,
1596    pub length: u32,
1597    pub event_type: u16,
1598    pub kind: CompleteKind,
1599    pub mode: CompleteMode,
1600    pub event: Event,
1601    pub window: xproto::Window,
1602    pub serial: u32,
1603    pub ust: u64,
1604    pub msc: u64,
1605}
1606impl_debug_if_no_extra_traits!(CompleteNotifyEvent, "CompleteNotifyEvent");
1607impl TryParse for CompleteNotifyEvent {
1608    fn try_parse(initial_value: &[u8]) -> Result<(Self, &[u8]), ParseError> {
1609        let remaining = initial_value;
1610        let (response_type, remaining) = u8::try_parse(remaining)?;
1611        let (extension, remaining) = u8::try_parse(remaining)?;
1612        let (sequence, remaining) = u16::try_parse(remaining)?;
1613        let (length, remaining) = u32::try_parse(remaining)?;
1614        let (event_type, remaining) = u16::try_parse(remaining)?;
1615        let (kind, remaining) = u8::try_parse(remaining)?;
1616        let (mode, remaining) = u8::try_parse(remaining)?;
1617        let (event, remaining) = Event::try_parse(remaining)?;
1618        let (window, remaining) = xproto::Window::try_parse(remaining)?;
1619        let (serial, remaining) = u32::try_parse(remaining)?;
1620        let (ust, remaining) = u64::try_parse(remaining)?;
1621        let (msc, remaining) = u64::try_parse(remaining)?;
1622        let kind = kind.into();
1623        let mode = mode.into();
1624        let result = CompleteNotifyEvent { response_type, extension, sequence, length, event_type, kind, mode, event, window, serial, ust, msc };
1625        let _ = remaining;
1626        let remaining = initial_value.get(32 + length as usize * 4..)
1627            .ok_or(ParseError::InsufficientData)?;
1628        Ok((result, remaining))
1629    }
1630}
1631impl Serialize for CompleteNotifyEvent {
1632    type Bytes = [u8; 40];
1633    fn serialize(&self) -> [u8; 40] {
1634        let response_type_bytes = self.response_type.serialize();
1635        let extension_bytes = self.extension.serialize();
1636        let sequence_bytes = self.sequence.serialize();
1637        let length_bytes = self.length.serialize();
1638        let event_type_bytes = self.event_type.serialize();
1639        let kind_bytes = u8::from(self.kind).serialize();
1640        let mode_bytes = u8::from(self.mode).serialize();
1641        let event_bytes = self.event.serialize();
1642        let window_bytes = self.window.serialize();
1643        let serial_bytes = self.serial.serialize();
1644        let ust_bytes = self.ust.serialize();
1645        let msc_bytes = self.msc.serialize();
1646        [
1647            response_type_bytes[0],
1648            extension_bytes[0],
1649            sequence_bytes[0],
1650            sequence_bytes[1],
1651            length_bytes[0],
1652            length_bytes[1],
1653            length_bytes[2],
1654            length_bytes[3],
1655            event_type_bytes[0],
1656            event_type_bytes[1],
1657            kind_bytes[0],
1658            mode_bytes[0],
1659            event_bytes[0],
1660            event_bytes[1],
1661            event_bytes[2],
1662            event_bytes[3],
1663            window_bytes[0],
1664            window_bytes[1],
1665            window_bytes[2],
1666            window_bytes[3],
1667            serial_bytes[0],
1668            serial_bytes[1],
1669            serial_bytes[2],
1670            serial_bytes[3],
1671            ust_bytes[0],
1672            ust_bytes[1],
1673            ust_bytes[2],
1674            ust_bytes[3],
1675            ust_bytes[4],
1676            ust_bytes[5],
1677            ust_bytes[6],
1678            ust_bytes[7],
1679            msc_bytes[0],
1680            msc_bytes[1],
1681            msc_bytes[2],
1682            msc_bytes[3],
1683            msc_bytes[4],
1684            msc_bytes[5],
1685            msc_bytes[6],
1686            msc_bytes[7],
1687        ]
1688    }
1689    fn serialize_into(&self, bytes: &mut Vec<u8>) {
1690        bytes.reserve(40);
1691        self.response_type.serialize_into(bytes);
1692        self.extension.serialize_into(bytes);
1693        self.sequence.serialize_into(bytes);
1694        self.length.serialize_into(bytes);
1695        self.event_type.serialize_into(bytes);
1696        u8::from(self.kind).serialize_into(bytes);
1697        u8::from(self.mode).serialize_into(bytes);
1698        self.event.serialize_into(bytes);
1699        self.window.serialize_into(bytes);
1700        self.serial.serialize_into(bytes);
1701        self.ust.serialize_into(bytes);
1702        self.msc.serialize_into(bytes);
1703    }
1704}
1705
1706/// Opcode for the IdleNotify event
1707pub const IDLE_NOTIFY_EVENT: u16 = 2;
1708#[derive(Clone, Copy, Default)]
1709#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
1710#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1711pub struct IdleNotifyEvent {
1712    pub response_type: u8,
1713    pub extension: u8,
1714    pub sequence: u16,
1715    pub length: u32,
1716    pub event_type: u16,
1717    pub event: Event,
1718    pub window: xproto::Window,
1719    pub serial: u32,
1720    pub pixmap: xproto::Pixmap,
1721    pub idle_fence: sync::Fence,
1722}
1723impl_debug_if_no_extra_traits!(IdleNotifyEvent, "IdleNotifyEvent");
1724impl TryParse for IdleNotifyEvent {
1725    fn try_parse(initial_value: &[u8]) -> Result<(Self, &[u8]), ParseError> {
1726        let remaining = initial_value;
1727        let (response_type, remaining) = u8::try_parse(remaining)?;
1728        let (extension, remaining) = u8::try_parse(remaining)?;
1729        let (sequence, remaining) = u16::try_parse(remaining)?;
1730        let (length, remaining) = u32::try_parse(remaining)?;
1731        let (event_type, remaining) = u16::try_parse(remaining)?;
1732        let remaining = remaining.get(2..).ok_or(ParseError::InsufficientData)?;
1733        let (event, remaining) = Event::try_parse(remaining)?;
1734        let (window, remaining) = xproto::Window::try_parse(remaining)?;
1735        let (serial, remaining) = u32::try_parse(remaining)?;
1736        let (pixmap, remaining) = xproto::Pixmap::try_parse(remaining)?;
1737        let (idle_fence, remaining) = sync::Fence::try_parse(remaining)?;
1738        let result = IdleNotifyEvent { response_type, extension, sequence, length, event_type, event, window, serial, pixmap, idle_fence };
1739        let _ = remaining;
1740        let remaining = initial_value.get(32 + length as usize * 4..)
1741            .ok_or(ParseError::InsufficientData)?;
1742        Ok((result, remaining))
1743    }
1744}
1745impl Serialize for IdleNotifyEvent {
1746    type Bytes = [u8; 32];
1747    fn serialize(&self) -> [u8; 32] {
1748        let response_type_bytes = self.response_type.serialize();
1749        let extension_bytes = self.extension.serialize();
1750        let sequence_bytes = self.sequence.serialize();
1751        let length_bytes = self.length.serialize();
1752        let event_type_bytes = self.event_type.serialize();
1753        let event_bytes = self.event.serialize();
1754        let window_bytes = self.window.serialize();
1755        let serial_bytes = self.serial.serialize();
1756        let pixmap_bytes = self.pixmap.serialize();
1757        let idle_fence_bytes = self.idle_fence.serialize();
1758        [
1759            response_type_bytes[0],
1760            extension_bytes[0],
1761            sequence_bytes[0],
1762            sequence_bytes[1],
1763            length_bytes[0],
1764            length_bytes[1],
1765            length_bytes[2],
1766            length_bytes[3],
1767            event_type_bytes[0],
1768            event_type_bytes[1],
1769            0,
1770            0,
1771            event_bytes[0],
1772            event_bytes[1],
1773            event_bytes[2],
1774            event_bytes[3],
1775            window_bytes[0],
1776            window_bytes[1],
1777            window_bytes[2],
1778            window_bytes[3],
1779            serial_bytes[0],
1780            serial_bytes[1],
1781            serial_bytes[2],
1782            serial_bytes[3],
1783            pixmap_bytes[0],
1784            pixmap_bytes[1],
1785            pixmap_bytes[2],
1786            pixmap_bytes[3],
1787            idle_fence_bytes[0],
1788            idle_fence_bytes[1],
1789            idle_fence_bytes[2],
1790            idle_fence_bytes[3],
1791        ]
1792    }
1793    fn serialize_into(&self, bytes: &mut Vec<u8>) {
1794        bytes.reserve(32);
1795        self.response_type.serialize_into(bytes);
1796        self.extension.serialize_into(bytes);
1797        self.sequence.serialize_into(bytes);
1798        self.length.serialize_into(bytes);
1799        self.event_type.serialize_into(bytes);
1800        bytes.extend_from_slice(&[0; 2]);
1801        self.event.serialize_into(bytes);
1802        self.window.serialize_into(bytes);
1803        self.serial.serialize_into(bytes);
1804        self.pixmap.serialize_into(bytes);
1805        self.idle_fence.serialize_into(bytes);
1806    }
1807}
1808
1809/// Opcode for the RedirectNotify event
1810pub const REDIRECT_NOTIFY_EVENT: u16 = 3;
1811#[derive(Clone, Default)]
1812#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
1813#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1814pub struct RedirectNotifyEvent {
1815    pub response_type: u8,
1816    pub extension: u8,
1817    pub sequence: u16,
1818    pub length: u32,
1819    pub event_type: u16,
1820    pub update_window: bool,
1821    pub event: Event,
1822    pub event_window: xproto::Window,
1823    pub window: xproto::Window,
1824    pub pixmap: xproto::Pixmap,
1825    pub serial: u32,
1826    pub valid_region: xfixes::Region,
1827    pub update_region: xfixes::Region,
1828    pub valid_rect: xproto::Rectangle,
1829    pub update_rect: xproto::Rectangle,
1830    pub x_off: i16,
1831    pub y_off: i16,
1832    pub target_crtc: randr::Crtc,
1833    pub wait_fence: sync::Fence,
1834    pub idle_fence: sync::Fence,
1835    pub options: u32,
1836    pub target_msc: u64,
1837    pub divisor: u64,
1838    pub remainder: u64,
1839    pub notifies: Vec<Notify>,
1840}
1841impl_debug_if_no_extra_traits!(RedirectNotifyEvent, "RedirectNotifyEvent");
1842impl TryParse for RedirectNotifyEvent {
1843    fn try_parse(initial_value: &[u8]) -> Result<(Self, &[u8]), ParseError> {
1844        let remaining = initial_value;
1845        let (response_type, remaining) = u8::try_parse(remaining)?;
1846        let (extension, remaining) = u8::try_parse(remaining)?;
1847        let (sequence, remaining) = u16::try_parse(remaining)?;
1848        let (length, remaining) = u32::try_parse(remaining)?;
1849        let (event_type, remaining) = u16::try_parse(remaining)?;
1850        let (update_window, remaining) = bool::try_parse(remaining)?;
1851        let remaining = remaining.get(1..).ok_or(ParseError::InsufficientData)?;
1852        let (event, remaining) = Event::try_parse(remaining)?;
1853        let (event_window, remaining) = xproto::Window::try_parse(remaining)?;
1854        let (window, remaining) = xproto::Window::try_parse(remaining)?;
1855        let (pixmap, remaining) = xproto::Pixmap::try_parse(remaining)?;
1856        let (serial, remaining) = u32::try_parse(remaining)?;
1857        let (valid_region, remaining) = xfixes::Region::try_parse(remaining)?;
1858        let (update_region, remaining) = xfixes::Region::try_parse(remaining)?;
1859        let (valid_rect, remaining) = xproto::Rectangle::try_parse(remaining)?;
1860        let (update_rect, remaining) = xproto::Rectangle::try_parse(remaining)?;
1861        let (x_off, remaining) = i16::try_parse(remaining)?;
1862        let (y_off, remaining) = i16::try_parse(remaining)?;
1863        let (target_crtc, remaining) = randr::Crtc::try_parse(remaining)?;
1864        let (wait_fence, remaining) = sync::Fence::try_parse(remaining)?;
1865        let (idle_fence, remaining) = sync::Fence::try_parse(remaining)?;
1866        let (options, remaining) = u32::try_parse(remaining)?;
1867        let remaining = remaining.get(4..).ok_or(ParseError::InsufficientData)?;
1868        let (target_msc, remaining) = u64::try_parse(remaining)?;
1869        let (divisor, remaining) = u64::try_parse(remaining)?;
1870        let (remainder, remaining) = u64::try_parse(remaining)?;
1871        let mut remaining = remaining;
1872        // Length is 'everything left in the input'
1873        let mut notifies = Vec::new();
1874        while !remaining.is_empty() {
1875            let (v, new_remaining) = Notify::try_parse(remaining)?;
1876            remaining = new_remaining;
1877            notifies.push(v);
1878        }
1879        let result = RedirectNotifyEvent { response_type, extension, sequence, length, event_type, update_window, event, event_window, window, pixmap, serial, valid_region, update_region, valid_rect, update_rect, x_off, y_off, target_crtc, wait_fence, idle_fence, options, target_msc, divisor, remainder, notifies };
1880        let _ = remaining;
1881        let remaining = initial_value.get(32 + length as usize * 4..)
1882            .ok_or(ParseError::InsufficientData)?;
1883        Ok((result, remaining))
1884    }
1885}
1886impl Serialize for RedirectNotifyEvent {
1887    type Bytes = Vec<u8>;
1888    fn serialize(&self) -> Vec<u8> {
1889        let mut result = Vec::new();
1890        self.serialize_into(&mut result);
1891        result
1892    }
1893    fn serialize_into(&self, bytes: &mut Vec<u8>) {
1894        bytes.reserve(104);
1895        self.response_type.serialize_into(bytes);
1896        self.extension.serialize_into(bytes);
1897        self.sequence.serialize_into(bytes);
1898        self.length.serialize_into(bytes);
1899        self.event_type.serialize_into(bytes);
1900        self.update_window.serialize_into(bytes);
1901        bytes.extend_from_slice(&[0; 1]);
1902        self.event.serialize_into(bytes);
1903        self.event_window.serialize_into(bytes);
1904        self.window.serialize_into(bytes);
1905        self.pixmap.serialize_into(bytes);
1906        self.serial.serialize_into(bytes);
1907        self.valid_region.serialize_into(bytes);
1908        self.update_region.serialize_into(bytes);
1909        self.valid_rect.serialize_into(bytes);
1910        self.update_rect.serialize_into(bytes);
1911        self.x_off.serialize_into(bytes);
1912        self.y_off.serialize_into(bytes);
1913        self.target_crtc.serialize_into(bytes);
1914        self.wait_fence.serialize_into(bytes);
1915        self.idle_fence.serialize_into(bytes);
1916        self.options.serialize_into(bytes);
1917        bytes.extend_from_slice(&[0; 4]);
1918        self.target_msc.serialize_into(bytes);
1919        self.divisor.serialize_into(bytes);
1920        self.remainder.serialize_into(bytes);
1921        self.notifies.serialize_into(bytes);
1922        let notifies_len_bytes = u32::try_from(self.notifies.len()).unwrap();
1923        let notifies_len_bytes = notifies_len_bytes.to_ne_bytes();
1924        bytes.extend_from_slice(&notifies_len_bytes);
1925    }
1926}
1927
x11rb_protocol/protocol/present.rs

x11rb_protocol/protocol/
present.rs
