x11rb_protocol/protocol/
xevie.rs

1// This file contains generated code. Do not edit directly.
2// To regenerate this, run 'make'.
3
4//! Bindings to the `Xevie` X11 extension.
5
6#![allow(clippy::too_many_arguments)]
7// The code generator is simpler if it can always use conversions
8#![allow(clippy::useless_conversion)]
9
10#[allow(unused_imports)]
11use alloc::borrow::Cow;
12#[allow(unused_imports)]
13use core::convert::TryInto;
14use alloc::vec;
15use alloc::vec::Vec;
16use core::convert::TryFrom;
17use crate::errors::ParseError;
18#[allow(unused_imports)]
19use crate::x11_utils::TryIntoUSize;
20use crate::BufWithFds;
21#[allow(unused_imports)]
22use crate::utils::{RawFdContainer, pretty_print_bitmask, pretty_print_enum};
23#[allow(unused_imports)]
24use crate::x11_utils::{Request, RequestHeader, Serialize, TryParse, TryParseFd};
25
26/// The X11 name of the extension for QueryExtension
27pub const X11_EXTENSION_NAME: &str = "XEVIE";
28
29/// The version number of this extension that this client library supports.
30///
31/// This constant contains the version number of this extension that is supported
32/// by this build of x11rb. For most things, it does not make sense to use this
33/// information. If you need to send a `QueryVersion`, it is recommended to instead
34/// send the maximum version of the extension that you need.
35pub const X11_XML_VERSION: (u32, u32) = (1, 0);
36
37/// Opcode for the QueryVersion request
38pub const QUERY_VERSION_REQUEST: u8 = 0;
39#[derive(Clone, Copy, Default)]
40#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
41#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
42pub struct QueryVersionRequest {
43    pub client_major_version: u16,
44    pub client_minor_version: u16,
45}
46impl_debug_if_no_extra_traits!(QueryVersionRequest, "QueryVersionRequest");
47impl QueryVersionRequest {
48    /// Serialize this request into bytes for the provided connection
49    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'static, [u8]>; 1]> {
50        let length_so_far = 0;
51        let client_major_version_bytes = self.client_major_version.serialize();
52        let client_minor_version_bytes = self.client_minor_version.serialize();
53        let mut request0 = vec![
54            major_opcode,
55            QUERY_VERSION_REQUEST,
56            0,
57            0,
58            client_major_version_bytes[0],
59            client_major_version_bytes[1],
60            client_minor_version_bytes[0],
61            client_minor_version_bytes[1],
62        ];
63        let length_so_far = length_so_far + request0.len();
64        assert_eq!(length_so_far % 4, 0);
65        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
66        request0[2..4].copy_from_slice(&length.to_ne_bytes());
67        ([request0.into()], vec![])
68    }
69    /// Parse this request given its header, its body, and any fds that go along with it
70    #[cfg(feature = "request-parsing")]
71    pub fn try_parse_request(header: RequestHeader, value: &[u8]) -> Result<Self, ParseError> {
72        if header.minor_opcode != QUERY_VERSION_REQUEST {
73            return Err(ParseError::InvalidValue);
74        }
75        let (client_major_version, remaining) = u16::try_parse(value)?;
76        let (client_minor_version, remaining) = u16::try_parse(remaining)?;
77        let _ = remaining;
78        Ok(QueryVersionRequest {
79            client_major_version,
80            client_minor_version,
81        })
82    }
83}
84impl Request for QueryVersionRequest {
85    const EXTENSION_NAME: Option<&'static str> = Some(X11_EXTENSION_NAME);
86
87    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
88        let (bufs, fds) = self.serialize(major_opcode);
89        // Flatten the buffers into a single vector
90        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
91        (buf, fds)
92    }
93}
94impl crate::x11_utils::ReplyRequest for QueryVersionRequest {
95    type Reply = QueryVersionReply;
96}
97
98#[derive(Clone, Copy, Default)]
99#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
100#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
101pub struct QueryVersionReply {
102    pub sequence: u16,
103    pub length: u32,
104    pub server_major_version: u16,
105    pub server_minor_version: u16,
106}
107impl_debug_if_no_extra_traits!(QueryVersionReply, "QueryVersionReply");
108impl TryParse for QueryVersionReply {
109    fn try_parse(initial_value: &[u8]) -> Result<(Self, &[u8]), ParseError> {
110        let remaining = initial_value;
111        let (response_type, remaining) = u8::try_parse(remaining)?;
112        let remaining = remaining.get(1..).ok_or(ParseError::InsufficientData)?;
113        let (sequence, remaining) = u16::try_parse(remaining)?;
114        let (length, remaining) = u32::try_parse(remaining)?;
115        let (server_major_version, remaining) = u16::try_parse(remaining)?;
116        let (server_minor_version, remaining) = u16::try_parse(remaining)?;
117        let remaining = remaining.get(20..).ok_or(ParseError::InsufficientData)?;
118        if response_type != 1 {
119            return Err(ParseError::InvalidValue);
120        }
121        let result = QueryVersionReply { sequence, length, server_major_version, server_minor_version };
122        let _ = remaining;
123        let remaining = initial_value.get(32 + length as usize * 4..)
124            .ok_or(ParseError::InsufficientData)?;
125        Ok((result, remaining))
126    }
127}
128impl Serialize for QueryVersionReply {
129    type Bytes = [u8; 32];
130    fn serialize(&self) -> [u8; 32] {
131        let response_type_bytes = &[1];
132        let sequence_bytes = self.sequence.serialize();
133        let length_bytes = self.length.serialize();
134        let server_major_version_bytes = self.server_major_version.serialize();
135        let server_minor_version_bytes = self.server_minor_version.serialize();
136        [
137            response_type_bytes[0],
138            0,
139            sequence_bytes[0],
140            sequence_bytes[1],
141            length_bytes[0],
142            length_bytes[1],
143            length_bytes[2],
144            length_bytes[3],
145            server_major_version_bytes[0],
146            server_major_version_bytes[1],
147            server_minor_version_bytes[0],
148            server_minor_version_bytes[1],
149            0,
150            0,
151            0,
152            0,
153            0,
154            0,
155            0,
156            0,
157            0,
158            0,
159            0,
160            0,
161            0,
162            0,
163            0,
164            0,
165            0,
166            0,
167            0,
168            0,
169        ]
170    }
171    fn serialize_into(&self, bytes: &mut Vec<u8>) {
172        bytes.reserve(32);
173        let response_type_bytes = &[1];
174        bytes.push(response_type_bytes[0]);
175        bytes.extend_from_slice(&[0; 1]);
176        self.sequence.serialize_into(bytes);
177        self.length.serialize_into(bytes);
178        self.server_major_version.serialize_into(bytes);
179        self.server_minor_version.serialize_into(bytes);
180        bytes.extend_from_slice(&[0; 20]);
181    }
182}
183
184/// Opcode for the Start request
185pub const START_REQUEST: u8 = 1;
186#[derive(Clone, Copy, Default)]
187#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
188#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
189pub struct StartRequest {
190    pub screen: u32,
191}
192impl_debug_if_no_extra_traits!(StartRequest, "StartRequest");
193impl StartRequest {
194    /// Serialize this request into bytes for the provided connection
195    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'static, [u8]>; 1]> {
196        let length_so_far = 0;
197        let screen_bytes = self.screen.serialize();
198        let mut request0 = vec![
199            major_opcode,
200            START_REQUEST,
201            0,
202            0,
203            screen_bytes[0],
204            screen_bytes[1],
205            screen_bytes[2],
206            screen_bytes[3],
207        ];
208        let length_so_far = length_so_far + request0.len();
209        assert_eq!(length_so_far % 4, 0);
210        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
211        request0[2..4].copy_from_slice(&length.to_ne_bytes());
212        ([request0.into()], vec![])
213    }
214    /// Parse this request given its header, its body, and any fds that go along with it
215    #[cfg(feature = "request-parsing")]
216    pub fn try_parse_request(header: RequestHeader, value: &[u8]) -> Result<Self, ParseError> {
217        if header.minor_opcode != START_REQUEST {
218            return Err(ParseError::InvalidValue);
219        }
220        let (screen, remaining) = u32::try_parse(value)?;
221        let _ = remaining;
222        Ok(StartRequest {
223            screen,
224        })
225    }
226}
227impl Request for StartRequest {
228    const EXTENSION_NAME: Option<&'static str> = Some(X11_EXTENSION_NAME);
229
230    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
231        let (bufs, fds) = self.serialize(major_opcode);
232        // Flatten the buffers into a single vector
233        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
234        (buf, fds)
235    }
236}
237impl crate::x11_utils::ReplyRequest for StartRequest {
238    type Reply = StartReply;
239}
240
241#[derive(Clone, Copy, Default)]
242#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
243#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
244pub struct StartReply {
245    pub sequence: u16,
246    pub length: u32,
247}
248impl_debug_if_no_extra_traits!(StartReply, "StartReply");
249impl TryParse for StartReply {
250    fn try_parse(initial_value: &[u8]) -> Result<(Self, &[u8]), ParseError> {
251        let remaining = initial_value;
252        let (response_type, remaining) = u8::try_parse(remaining)?;
253        let remaining = remaining.get(1..).ok_or(ParseError::InsufficientData)?;
254        let (sequence, remaining) = u16::try_parse(remaining)?;
255        let (length, remaining) = u32::try_parse(remaining)?;
256        let remaining = remaining.get(24..).ok_or(ParseError::InsufficientData)?;
257        if response_type != 1 {
258            return Err(ParseError::InvalidValue);
259        }
260        let result = StartReply { sequence, length };
261        let _ = remaining;
262        let remaining = initial_value.get(32 + length as usize * 4..)
263            .ok_or(ParseError::InsufficientData)?;
264        Ok((result, remaining))
265    }
266}
267impl Serialize for StartReply {
268    type Bytes = [u8; 32];
269    fn serialize(&self) -> [u8; 32] {
270        let response_type_bytes = &[1];
271        let sequence_bytes = self.sequence.serialize();
272        let length_bytes = self.length.serialize();
273        [
274            response_type_bytes[0],
275            0,
276            sequence_bytes[0],
277            sequence_bytes[1],
278            length_bytes[0],
279            length_bytes[1],
280            length_bytes[2],
281            length_bytes[3],
282            0,
283            0,
284            0,
285            0,
286            0,
287            0,
288            0,
289            0,
290            0,
291            0,
292            0,
293            0,
294            0,
295            0,
296            0,
297            0,
298            0,
299            0,
300            0,
301            0,
302            0,
303            0,
304            0,
305            0,
306        ]
307    }
308    fn serialize_into(&self, bytes: &mut Vec<u8>) {
309        bytes.reserve(32);
310        let response_type_bytes = &[1];
311        bytes.push(response_type_bytes[0]);
312        bytes.extend_from_slice(&[0; 1]);
313        self.sequence.serialize_into(bytes);
314        self.length.serialize_into(bytes);
315        bytes.extend_from_slice(&[0; 24]);
316    }
317}
318
319/// Opcode for the End request
320pub const END_REQUEST: u8 = 2;
321#[derive(Clone, Copy, Default)]
322#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
323#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
324pub struct EndRequest {
325    pub cmap: u32,
326}
327impl_debug_if_no_extra_traits!(EndRequest, "EndRequest");
328impl EndRequest {
329    /// Serialize this request into bytes for the provided connection
330    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'static, [u8]>; 1]> {
331        let length_so_far = 0;
332        let cmap_bytes = self.cmap.serialize();
333        let mut request0 = vec![
334            major_opcode,
335            END_REQUEST,
336            0,
337            0,
338            cmap_bytes[0],
339            cmap_bytes[1],
340            cmap_bytes[2],
341            cmap_bytes[3],
342        ];
343        let length_so_far = length_so_far + request0.len();
344        assert_eq!(length_so_far % 4, 0);
345        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
346        request0[2..4].copy_from_slice(&length.to_ne_bytes());
347        ([request0.into()], vec![])
348    }
349    /// Parse this request given its header, its body, and any fds that go along with it
350    #[cfg(feature = "request-parsing")]
351    pub fn try_parse_request(header: RequestHeader, value: &[u8]) -> Result<Self, ParseError> {
352        if header.minor_opcode != END_REQUEST {
353            return Err(ParseError::InvalidValue);
354        }
355        let (cmap, remaining) = u32::try_parse(value)?;
356        let _ = remaining;
357        Ok(EndRequest {
358            cmap,
359        })
360    }
361}
362impl Request for EndRequest {
363    const EXTENSION_NAME: Option<&'static str> = Some(X11_EXTENSION_NAME);
364
365    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
366        let (bufs, fds) = self.serialize(major_opcode);
367        // Flatten the buffers into a single vector
368        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
369        (buf, fds)
370    }
371}
372impl crate::x11_utils::ReplyRequest for EndRequest {
373    type Reply = EndReply;
374}
375
376#[derive(Clone, Copy, Default)]
377#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
378#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
379pub struct EndReply {
380    pub sequence: u16,
381    pub length: u32,
382}
383impl_debug_if_no_extra_traits!(EndReply, "EndReply");
384impl TryParse for EndReply {
385    fn try_parse(initial_value: &[u8]) -> Result<(Self, &[u8]), ParseError> {
386        let remaining = initial_value;
387        let (response_type, remaining) = u8::try_parse(remaining)?;
388        let remaining = remaining.get(1..).ok_or(ParseError::InsufficientData)?;
389        let (sequence, remaining) = u16::try_parse(remaining)?;
390        let (length, remaining) = u32::try_parse(remaining)?;
391        let remaining = remaining.get(24..).ok_or(ParseError::InsufficientData)?;
392        if response_type != 1 {
393            return Err(ParseError::InvalidValue);
394        }
395        let result = EndReply { sequence, length };
396        let _ = remaining;
397        let remaining = initial_value.get(32 + length as usize * 4..)
398            .ok_or(ParseError::InsufficientData)?;
399        Ok((result, remaining))
400    }
401}
402impl Serialize for EndReply {
403    type Bytes = [u8; 32];
404    fn serialize(&self) -> [u8; 32] {
405        let response_type_bytes = &[1];
406        let sequence_bytes = self.sequence.serialize();
407        let length_bytes = self.length.serialize();
408        [
409            response_type_bytes[0],
410            0,
411            sequence_bytes[0],
412            sequence_bytes[1],
413            length_bytes[0],
414            length_bytes[1],
415            length_bytes[2],
416            length_bytes[3],
417            0,
418            0,
419            0,
420            0,
421            0,
422            0,
423            0,
424            0,
425            0,
426            0,
427            0,
428            0,
429            0,
430            0,
431            0,
432            0,
433            0,
434            0,
435            0,
436            0,
437            0,
438            0,
439            0,
440            0,
441        ]
442    }
443    fn serialize_into(&self, bytes: &mut Vec<u8>) {
444        bytes.reserve(32);
445        let response_type_bytes = &[1];
446        bytes.push(response_type_bytes[0]);
447        bytes.extend_from_slice(&[0; 1]);
448        self.sequence.serialize_into(bytes);
449        self.length.serialize_into(bytes);
450        bytes.extend_from_slice(&[0; 24]);
451    }
452}
453
454#[derive(Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
455#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
456pub struct Datatype(bool);
457impl Datatype {
458    pub const UNMODIFIED: Self = Self(false);
459    pub const MODIFIED: Self = Self(true);
460}
461impl From<Datatype> for bool {
462    #[inline]
463    fn from(input: Datatype) -> Self {
464        input.0
465    }
466}
467impl From<Datatype> for Option<bool> {
468    #[inline]
469    fn from(input: Datatype) -> Self {
470        Some(input.0)
471    }
472}
473impl From<Datatype> for u8 {
474    #[inline]
475    fn from(input: Datatype) -> Self {
476        u8::from(input.0)
477    }
478}
479impl From<Datatype> for Option<u8> {
480    #[inline]
481    fn from(input: Datatype) -> Self {
482        Some(u8::from(input.0))
483    }
484}
485impl From<Datatype> for u16 {
486    #[inline]
487    fn from(input: Datatype) -> Self {
488        u16::from(input.0)
489    }
490}
491impl From<Datatype> for Option<u16> {
492    #[inline]
493    fn from(input: Datatype) -> Self {
494        Some(u16::from(input.0))
495    }
496}
497impl From<Datatype> for u32 {
498    #[inline]
499    fn from(input: Datatype) -> Self {
500        u32::from(input.0)
501    }
502}
503impl From<Datatype> for Option<u32> {
504    #[inline]
505    fn from(input: Datatype) -> Self {
506        Some(u32::from(input.0))
507    }
508}
509impl From<bool> for Datatype {
510    #[inline]
511    fn from(value: bool) -> Self {
512        Self(value)
513    }
514}
515impl core::fmt::Debug for Datatype  {
516    fn fmt(&self, fmt: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
517        let variants = [
518            (Self::UNMODIFIED.0.into(), "UNMODIFIED", "Unmodified"),
519            (Self::MODIFIED.0.into(), "MODIFIED", "Modified"),
520        ];
521        pretty_print_enum(fmt, self.0.into(), &variants)
522    }
523}
524
525#[derive(Clone, Copy, Default)]
526#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
527#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
528pub struct Event {
529}
530impl_debug_if_no_extra_traits!(Event, "Event");
531impl TryParse for Event {
532    fn try_parse(remaining: &[u8]) -> Result<(Self, &[u8]), ParseError> {
533        let remaining = remaining.get(32..).ok_or(ParseError::InsufficientData)?;
534        let result = Event {  };
535        Ok((result, remaining))
536    }
537}
538impl Serialize for Event {
539    type Bytes = [u8; 32];
540    fn serialize(&self) -> [u8; 32] {
541        [
542            0,
543            0,
544            0,
545            0,
546            0,
547            0,
548            0,
549            0,
550            0,
551            0,
552            0,
553            0,
554            0,
555            0,
556            0,
557            0,
558            0,
559            0,
560            0,
561            0,
562            0,
563            0,
564            0,
565            0,
566            0,
567            0,
568            0,
569            0,
570            0,
571            0,
572            0,
573            0,
574        ]
575    }
576    fn serialize_into(&self, bytes: &mut Vec<u8>) {
577        bytes.reserve(32);
578        bytes.extend_from_slice(&[0; 32]);
579    }
580}
581
582/// Opcode for the Send request
583pub const SEND_REQUEST: u8 = 3;
584#[derive(Clone, Copy, Default)]
585#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
586#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
587pub struct SendRequest {
588    pub event: Event,
589    pub data_type: u32,
590}
591impl_debug_if_no_extra_traits!(SendRequest, "SendRequest");
592impl SendRequest {
593    /// Serialize this request into bytes for the provided connection
594    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'static, [u8]>; 1]> {
595        let length_so_far = 0;
596        let event_bytes = self.event.serialize();
597        let data_type_bytes = self.data_type.serialize();
598        let mut request0 = vec![
599            major_opcode,
600            SEND_REQUEST,
601            0,
602            0,
603            event_bytes[0],
604            event_bytes[1],
605            event_bytes[2],
606            event_bytes[3],
607            event_bytes[4],
608            event_bytes[5],
609            event_bytes[6],
610            event_bytes[7],
611            event_bytes[8],
612            event_bytes[9],
613            event_bytes[10],
614            event_bytes[11],
615            event_bytes[12],
616            event_bytes[13],
617            event_bytes[14],
618            event_bytes[15],
619            event_bytes[16],
620            event_bytes[17],
621            event_bytes[18],
622            event_bytes[19],
623            event_bytes[20],
624            event_bytes[21],
625            event_bytes[22],
626            event_bytes[23],
627            event_bytes[24],
628            event_bytes[25],
629            event_bytes[26],
630            event_bytes[27],
631            event_bytes[28],
632            event_bytes[29],
633            event_bytes[30],
634            event_bytes[31],
635            data_type_bytes[0],
636            data_type_bytes[1],
637            data_type_bytes[2],
638            data_type_bytes[3],
639            0,
640            0,
641            0,
642            0,
643            0,
644            0,
645            0,
646            0,
647            0,
648            0,
649            0,
650            0,
651            0,
652            0,
653            0,
654            0,
655            0,
656            0,
657            0,
658            0,
659            0,
660            0,
661            0,
662            0,
663            0,
664            0,
665            0,
666            0,
667            0,
668            0,
669            0,
670            0,
671            0,
672            0,
673            0,
674            0,
675            0,
676            0,
677            0,
678            0,
679            0,
680            0,
681            0,
682            0,
683            0,
684            0,
685            0,
686            0,
687            0,
688            0,
689            0,
690            0,
691            0,
692            0,
693            0,
694            0,
695            0,
696            0,
697            0,
698            0,
699            0,
700            0,
701            0,
702            0,
703        ];
704        let length_so_far = length_so_far + request0.len();
705        assert_eq!(length_so_far % 4, 0);
706        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
707        request0[2..4].copy_from_slice(&length.to_ne_bytes());
708        ([request0.into()], vec![])
709    }
710    /// Parse this request given its header, its body, and any fds that go along with it
711    #[cfg(feature = "request-parsing")]
712    pub fn try_parse_request(header: RequestHeader, value: &[u8]) -> Result<Self, ParseError> {
713        if header.minor_opcode != SEND_REQUEST {
714            return Err(ParseError::InvalidValue);
715        }
716        let (event, remaining) = Event::try_parse(value)?;
717        let (data_type, remaining) = u32::try_parse(remaining)?;
718        let remaining = remaining.get(64..).ok_or(ParseError::InsufficientData)?;
719        let _ = remaining;
720        Ok(SendRequest {
721            event,
722            data_type,
723        })
724    }
725}
726impl Request for SendRequest {
727    const EXTENSION_NAME: Option<&'static str> = Some(X11_EXTENSION_NAME);
728
729    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
730        let (bufs, fds) = self.serialize(major_opcode);
731        // Flatten the buffers into a single vector
732        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
733        (buf, fds)
734    }
735}
736impl crate::x11_utils::ReplyRequest for SendRequest {
737    type Reply = SendReply;
738}
739
740#[derive(Clone, Copy, Default)]
741#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
742#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
743pub struct SendReply {
744    pub sequence: u16,
745    pub length: u32,
746}
747impl_debug_if_no_extra_traits!(SendReply, "SendReply");
748impl TryParse for SendReply {
749    fn try_parse(initial_value: &[u8]) -> Result<(Self, &[u8]), ParseError> {
750        let remaining = initial_value;
751        let (response_type, remaining) = u8::try_parse(remaining)?;
752        let remaining = remaining.get(1..).ok_or(ParseError::InsufficientData)?;
753        let (sequence, remaining) = u16::try_parse(remaining)?;
754        let (length, remaining) = u32::try_parse(remaining)?;
755        let remaining = remaining.get(24..).ok_or(ParseError::InsufficientData)?;
756        if response_type != 1 {
757            return Err(ParseError::InvalidValue);
758        }
759        let result = SendReply { sequence, length };
760        let _ = remaining;
761        let remaining = initial_value.get(32 + length as usize * 4..)
762            .ok_or(ParseError::InsufficientData)?;
763        Ok((result, remaining))
764    }
765}
766impl Serialize for SendReply {
767    type Bytes = [u8; 32];
768    fn serialize(&self) -> [u8; 32] {
769        let response_type_bytes = &[1];
770        let sequence_bytes = self.sequence.serialize();
771        let length_bytes = self.length.serialize();
772        [
773            response_type_bytes[0],
774            0,
775            sequence_bytes[0],
776            sequence_bytes[1],
777            length_bytes[0],
778            length_bytes[1],
779            length_bytes[2],
780            length_bytes[3],
781            0,
782            0,
783            0,
784            0,
785            0,
786            0,
787            0,
788            0,
789            0,
790            0,
791            0,
792            0,
793            0,
794            0,
795            0,
796            0,
797            0,
798            0,
799            0,
800            0,
801            0,
802            0,
803            0,
804            0,
805        ]
806    }
807    fn serialize_into(&self, bytes: &mut Vec<u8>) {
808        bytes.reserve(32);
809        let response_type_bytes = &[1];
810        bytes.push(response_type_bytes[0]);
811        bytes.extend_from_slice(&[0; 1]);
812        self.sequence.serialize_into(bytes);
813        self.length.serialize_into(bytes);
814        bytes.extend_from_slice(&[0; 24]);
815    }
816}
817
818/// Opcode for the SelectInput request
819pub const SELECT_INPUT_REQUEST: u8 = 4;
820#[derive(Clone, Copy, Default)]
821#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
822#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
823pub struct SelectInputRequest {
824    pub event_mask: u32,
825}
826impl_debug_if_no_extra_traits!(SelectInputRequest, "SelectInputRequest");
827impl SelectInputRequest {
828    /// Serialize this request into bytes for the provided connection
829    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'static, [u8]>; 1]> {
830        let length_so_far = 0;
831        let event_mask_bytes = self.event_mask.serialize();
832        let mut request0 = vec![
833            major_opcode,
834            SELECT_INPUT_REQUEST,
835            0,
836            0,
837            event_mask_bytes[0],
838            event_mask_bytes[1],
839            event_mask_bytes[2],
840            event_mask_bytes[3],
841        ];
842        let length_so_far = length_so_far + request0.len();
843        assert_eq!(length_so_far % 4, 0);
844        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
845        request0[2..4].copy_from_slice(&length.to_ne_bytes());
846        ([request0.into()], vec![])
847    }
848    /// Parse this request given its header, its body, and any fds that go along with it
849    #[cfg(feature = "request-parsing")]
850    pub fn try_parse_request(header: RequestHeader, value: &[u8]) -> Result<Self, ParseError> {
851        if header.minor_opcode != SELECT_INPUT_REQUEST {
852            return Err(ParseError::InvalidValue);
853        }
854        let (event_mask, remaining) = u32::try_parse(value)?;
855        let _ = remaining;
856        Ok(SelectInputRequest {
857            event_mask,
858        })
859    }
860}
861impl Request for SelectInputRequest {
862    const EXTENSION_NAME: Option<&'static str> = Some(X11_EXTENSION_NAME);
863
864    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
865        let (bufs, fds) = self.serialize(major_opcode);
866        // Flatten the buffers into a single vector
867        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
868        (buf, fds)
869    }
870}
871impl crate::x11_utils::ReplyRequest for SelectInputRequest {
872    type Reply = SelectInputReply;
873}
874
875#[derive(Clone, Copy, Default)]
876#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
877#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
878pub struct SelectInputReply {
879    pub sequence: u16,
880    pub length: u32,
881}
882impl_debug_if_no_extra_traits!(SelectInputReply, "SelectInputReply");
883impl TryParse for SelectInputReply {
884    fn try_parse(initial_value: &[u8]) -> Result<(Self, &[u8]), ParseError> {
885        let remaining = initial_value;
886        let (response_type, remaining) = u8::try_parse(remaining)?;
887        let remaining = remaining.get(1..).ok_or(ParseError::InsufficientData)?;
888        let (sequence, remaining) = u16::try_parse(remaining)?;
889        let (length, remaining) = u32::try_parse(remaining)?;
890        let remaining = remaining.get(24..).ok_or(ParseError::InsufficientData)?;
891        if response_type != 1 {
892            return Err(ParseError::InvalidValue);
893        }
894        let result = SelectInputReply { sequence, length };
895        let _ = remaining;
896        let remaining = initial_value.get(32 + length as usize * 4..)
897            .ok_or(ParseError::InsufficientData)?;
898        Ok((result, remaining))
899    }
900}
901impl Serialize for SelectInputReply {
902    type Bytes = [u8; 32];
903    fn serialize(&self) -> [u8; 32] {
904        let response_type_bytes = &[1];
905        let sequence_bytes = self.sequence.serialize();
906        let length_bytes = self.length.serialize();
907        [
908            response_type_bytes[0],
909            0,
910            sequence_bytes[0],
911            sequence_bytes[1],
912            length_bytes[0],
913            length_bytes[1],
914            length_bytes[2],
915            length_bytes[3],
916            0,
917            0,
918            0,
919            0,
920            0,
921            0,
922            0,
923            0,
924            0,
925            0,
926            0,
927            0,
928            0,
929            0,
930            0,
931            0,
932            0,
933            0,
934            0,
935            0,
936            0,
937            0,
938            0,
939            0,
940        ]
941    }
942    fn serialize_into(&self, bytes: &mut Vec<u8>) {
943        bytes.reserve(32);
944        let response_type_bytes = &[1];
945        bytes.push(response_type_bytes[0]);
946        bytes.extend_from_slice(&[0; 1]);
947        self.sequence.serialize_into(bytes);
948        self.length.serialize_into(bytes);
949        bytes.extend_from_slice(&[0; 24]);
950    }
951}
952
x11rb_protocol/protocol/xevie.rs

x11rb_protocol/protocol/
xevie.rs
