x11rb_protocol/protocol/
screensaver.rs

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

x11rb_protocol/protocol/
screensaver.rs
