x11rb_protocol/protocol/
xinerama.rs

1// This file contains generated code. Do not edit directly.
2// To regenerate this, run 'make'.
3
4//! Bindings to the `Xinerama` 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 = "XINERAMA";
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)]
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 ScreenInfo {
43    pub x_org: i16,
44    pub y_org: i16,
45    pub width: u16,
46    pub height: u16,
47}
48impl_debug_if_no_extra_traits!(ScreenInfo, "ScreenInfo");
49impl TryParse for ScreenInfo {
50    fn try_parse(remaining: &[u8]) -> Result<(Self, &[u8]), ParseError> {
51        let (x_org, remaining) = i16::try_parse(remaining)?;
52        let (y_org, remaining) = i16::try_parse(remaining)?;
53        let (width, remaining) = u16::try_parse(remaining)?;
54        let (height, remaining) = u16::try_parse(remaining)?;
55        let result = ScreenInfo { x_org, y_org, width, height };
56        Ok((result, remaining))
57    }
58}
59impl Serialize for ScreenInfo {
60    type Bytes = [u8; 8];
61    fn serialize(&self) -> [u8; 8] {
62        let x_org_bytes = self.x_org.serialize();
63        let y_org_bytes = self.y_org.serialize();
64        let width_bytes = self.width.serialize();
65        let height_bytes = self.height.serialize();
66        [
67            x_org_bytes[0],
68            x_org_bytes[1],
69            y_org_bytes[0],
70            y_org_bytes[1],
71            width_bytes[0],
72            width_bytes[1],
73            height_bytes[0],
74            height_bytes[1],
75        ]
76    }
77    fn serialize_into(&self, bytes: &mut Vec<u8>) {
78        bytes.reserve(8);
79        self.x_org.serialize_into(bytes);
80        self.y_org.serialize_into(bytes);
81        self.width.serialize_into(bytes);
82        self.height.serialize_into(bytes);
83    }
84}
85
86/// Opcode for the QueryVersion request
87pub const QUERY_VERSION_REQUEST: u8 = 0;
88#[derive(Clone, Copy, Default)]
89#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
90#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
91pub struct QueryVersionRequest {
92    pub major: u8,
93    pub minor: u8,
94}
95impl_debug_if_no_extra_traits!(QueryVersionRequest, "QueryVersionRequest");
96impl QueryVersionRequest {
97    /// Serialize this request into bytes for the provided connection
98    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'static, [u8]>; 1]> {
99        let length_so_far = 0;
100        let major_bytes = self.major.serialize();
101        let minor_bytes = self.minor.serialize();
102        let mut request0 = vec![
103            major_opcode,
104            QUERY_VERSION_REQUEST,
105            0,
106            0,
107            major_bytes[0],
108            minor_bytes[0],
109            0,
110            0,
111        ];
112        let length_so_far = length_so_far + request0.len();
113        assert_eq!(length_so_far % 4, 0);
114        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
115        request0[2..4].copy_from_slice(&length.to_ne_bytes());
116        ([request0.into()], vec![])
117    }
118    /// Parse this request given its header, its body, and any fds that go along with it
119    #[cfg(feature = "request-parsing")]
120    pub fn try_parse_request(header: RequestHeader, value: &[u8]) -> Result<Self, ParseError> {
121        if header.minor_opcode != QUERY_VERSION_REQUEST {
122            return Err(ParseError::InvalidValue);
123        }
124        let (major, remaining) = u8::try_parse(value)?;
125        let (minor, remaining) = u8::try_parse(remaining)?;
126        let _ = remaining;
127        Ok(QueryVersionRequest {
128            major,
129            minor,
130        })
131    }
132}
133impl Request for QueryVersionRequest {
134    const EXTENSION_NAME: Option<&'static str> = Some(X11_EXTENSION_NAME);
135
136    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
137        let (bufs, fds) = self.serialize(major_opcode);
138        // Flatten the buffers into a single vector
139        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
140        (buf, fds)
141    }
142}
143impl crate::x11_utils::ReplyRequest for QueryVersionRequest {
144    type Reply = QueryVersionReply;
145}
146
147#[derive(Clone, Copy, Default)]
148#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
149#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
150pub struct QueryVersionReply {
151    pub sequence: u16,
152    pub length: u32,
153    pub major: u16,
154    pub minor: u16,
155}
156impl_debug_if_no_extra_traits!(QueryVersionReply, "QueryVersionReply");
157impl TryParse for QueryVersionReply {
158    fn try_parse(initial_value: &[u8]) -> Result<(Self, &[u8]), ParseError> {
159        let remaining = initial_value;
160        let (response_type, remaining) = u8::try_parse(remaining)?;
161        let remaining = remaining.get(1..).ok_or(ParseError::InsufficientData)?;
162        let (sequence, remaining) = u16::try_parse(remaining)?;
163        let (length, remaining) = u32::try_parse(remaining)?;
164        let (major, remaining) = u16::try_parse(remaining)?;
165        let (minor, remaining) = u16::try_parse(remaining)?;
166        if response_type != 1 {
167            return Err(ParseError::InvalidValue);
168        }
169        let result = QueryVersionReply { sequence, length, major, minor };
170        let _ = remaining;
171        let remaining = initial_value.get(32 + length as usize * 4..)
172            .ok_or(ParseError::InsufficientData)?;
173        Ok((result, remaining))
174    }
175}
176impl Serialize for QueryVersionReply {
177    type Bytes = [u8; 12];
178    fn serialize(&self) -> [u8; 12] {
179        let response_type_bytes = &[1];
180        let sequence_bytes = self.sequence.serialize();
181        let length_bytes = self.length.serialize();
182        let major_bytes = self.major.serialize();
183        let minor_bytes = self.minor.serialize();
184        [
185            response_type_bytes[0],
186            0,
187            sequence_bytes[0],
188            sequence_bytes[1],
189            length_bytes[0],
190            length_bytes[1],
191            length_bytes[2],
192            length_bytes[3],
193            major_bytes[0],
194            major_bytes[1],
195            minor_bytes[0],
196            minor_bytes[1],
197        ]
198    }
199    fn serialize_into(&self, bytes: &mut Vec<u8>) {
200        bytes.reserve(12);
201        let response_type_bytes = &[1];
202        bytes.push(response_type_bytes[0]);
203        bytes.extend_from_slice(&[0; 1]);
204        self.sequence.serialize_into(bytes);
205        self.length.serialize_into(bytes);
206        self.major.serialize_into(bytes);
207        self.minor.serialize_into(bytes);
208    }
209}
210
211/// Opcode for the GetState request
212pub const GET_STATE_REQUEST: u8 = 1;
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 GetStateRequest {
217    pub window: xproto::Window,
218}
219impl_debug_if_no_extra_traits!(GetStateRequest, "GetStateRequest");
220impl GetStateRequest {
221    /// Serialize this request into bytes for the provided connection
222    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'static, [u8]>; 1]> {
223        let length_so_far = 0;
224        let window_bytes = self.window.serialize();
225        let mut request0 = vec![
226            major_opcode,
227            GET_STATE_REQUEST,
228            0,
229            0,
230            window_bytes[0],
231            window_bytes[1],
232            window_bytes[2],
233            window_bytes[3],
234        ];
235        let length_so_far = length_so_far + request0.len();
236        assert_eq!(length_so_far % 4, 0);
237        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
238        request0[2..4].copy_from_slice(&length.to_ne_bytes());
239        ([request0.into()], vec![])
240    }
241    /// Parse this request given its header, its body, and any fds that go along with it
242    #[cfg(feature = "request-parsing")]
243    pub fn try_parse_request(header: RequestHeader, value: &[u8]) -> Result<Self, ParseError> {
244        if header.minor_opcode != GET_STATE_REQUEST {
245            return Err(ParseError::InvalidValue);
246        }
247        let (window, remaining) = xproto::Window::try_parse(value)?;
248        let _ = remaining;
249        Ok(GetStateRequest {
250            window,
251        })
252    }
253}
254impl Request for GetStateRequest {
255    const EXTENSION_NAME: Option<&'static str> = Some(X11_EXTENSION_NAME);
256
257    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
258        let (bufs, fds) = self.serialize(major_opcode);
259        // Flatten the buffers into a single vector
260        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
261        (buf, fds)
262    }
263}
264impl crate::x11_utils::ReplyRequest for GetStateRequest {
265    type Reply = GetStateReply;
266}
267
268#[derive(Clone, Copy, Default)]
269#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
270#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
271pub struct GetStateReply {
272    pub state: u8,
273    pub sequence: u16,
274    pub length: u32,
275    pub window: xproto::Window,
276}
277impl_debug_if_no_extra_traits!(GetStateReply, "GetStateReply");
278impl TryParse for GetStateReply {
279    fn try_parse(initial_value: &[u8]) -> Result<(Self, &[u8]), ParseError> {
280        let remaining = initial_value;
281        let (response_type, remaining) = u8::try_parse(remaining)?;
282        let (state, remaining) = u8::try_parse(remaining)?;
283        let (sequence, remaining) = u16::try_parse(remaining)?;
284        let (length, remaining) = u32::try_parse(remaining)?;
285        let (window, remaining) = xproto::Window::try_parse(remaining)?;
286        if response_type != 1 {
287            return Err(ParseError::InvalidValue);
288        }
289        let result = GetStateReply { state, sequence, length, window };
290        let _ = remaining;
291        let remaining = initial_value.get(32 + length as usize * 4..)
292            .ok_or(ParseError::InsufficientData)?;
293        Ok((result, remaining))
294    }
295}
296impl Serialize for GetStateReply {
297    type Bytes = [u8; 12];
298    fn serialize(&self) -> [u8; 12] {
299        let response_type_bytes = &[1];
300        let state_bytes = self.state.serialize();
301        let sequence_bytes = self.sequence.serialize();
302        let length_bytes = self.length.serialize();
303        let window_bytes = self.window.serialize();
304        [
305            response_type_bytes[0],
306            state_bytes[0],
307            sequence_bytes[0],
308            sequence_bytes[1],
309            length_bytes[0],
310            length_bytes[1],
311            length_bytes[2],
312            length_bytes[3],
313            window_bytes[0],
314            window_bytes[1],
315            window_bytes[2],
316            window_bytes[3],
317        ]
318    }
319    fn serialize_into(&self, bytes: &mut Vec<u8>) {
320        bytes.reserve(12);
321        let response_type_bytes = &[1];
322        bytes.push(response_type_bytes[0]);
323        self.state.serialize_into(bytes);
324        self.sequence.serialize_into(bytes);
325        self.length.serialize_into(bytes);
326        self.window.serialize_into(bytes);
327    }
328}
329
330/// Opcode for the GetScreenCount request
331pub const GET_SCREEN_COUNT_REQUEST: u8 = 2;
332#[derive(Clone, Copy, Default)]
333#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
334#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
335pub struct GetScreenCountRequest {
336    pub window: xproto::Window,
337}
338impl_debug_if_no_extra_traits!(GetScreenCountRequest, "GetScreenCountRequest");
339impl GetScreenCountRequest {
340    /// Serialize this request into bytes for the provided connection
341    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'static, [u8]>; 1]> {
342        let length_so_far = 0;
343        let window_bytes = self.window.serialize();
344        let mut request0 = vec![
345            major_opcode,
346            GET_SCREEN_COUNT_REQUEST,
347            0,
348            0,
349            window_bytes[0],
350            window_bytes[1],
351            window_bytes[2],
352            window_bytes[3],
353        ];
354        let length_so_far = length_so_far + request0.len();
355        assert_eq!(length_so_far % 4, 0);
356        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
357        request0[2..4].copy_from_slice(&length.to_ne_bytes());
358        ([request0.into()], vec![])
359    }
360    /// Parse this request given its header, its body, and any fds that go along with it
361    #[cfg(feature = "request-parsing")]
362    pub fn try_parse_request(header: RequestHeader, value: &[u8]) -> Result<Self, ParseError> {
363        if header.minor_opcode != GET_SCREEN_COUNT_REQUEST {
364            return Err(ParseError::InvalidValue);
365        }
366        let (window, remaining) = xproto::Window::try_parse(value)?;
367        let _ = remaining;
368        Ok(GetScreenCountRequest {
369            window,
370        })
371    }
372}
373impl Request for GetScreenCountRequest {
374    const EXTENSION_NAME: Option<&'static str> = Some(X11_EXTENSION_NAME);
375
376    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
377        let (bufs, fds) = self.serialize(major_opcode);
378        // Flatten the buffers into a single vector
379        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
380        (buf, fds)
381    }
382}
383impl crate::x11_utils::ReplyRequest for GetScreenCountRequest {
384    type Reply = GetScreenCountReply;
385}
386
387#[derive(Clone, Copy, Default)]
388#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
389#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
390pub struct GetScreenCountReply {
391    pub screen_count: u8,
392    pub sequence: u16,
393    pub length: u32,
394    pub window: xproto::Window,
395}
396impl_debug_if_no_extra_traits!(GetScreenCountReply, "GetScreenCountReply");
397impl TryParse for GetScreenCountReply {
398    fn try_parse(initial_value: &[u8]) -> Result<(Self, &[u8]), ParseError> {
399        let remaining = initial_value;
400        let (response_type, remaining) = u8::try_parse(remaining)?;
401        let (screen_count, remaining) = u8::try_parse(remaining)?;
402        let (sequence, remaining) = u16::try_parse(remaining)?;
403        let (length, remaining) = u32::try_parse(remaining)?;
404        let (window, remaining) = xproto::Window::try_parse(remaining)?;
405        if response_type != 1 {
406            return Err(ParseError::InvalidValue);
407        }
408        let result = GetScreenCountReply { screen_count, sequence, length, window };
409        let _ = remaining;
410        let remaining = initial_value.get(32 + length as usize * 4..)
411            .ok_or(ParseError::InsufficientData)?;
412        Ok((result, remaining))
413    }
414}
415impl Serialize for GetScreenCountReply {
416    type Bytes = [u8; 12];
417    fn serialize(&self) -> [u8; 12] {
418        let response_type_bytes = &[1];
419        let screen_count_bytes = self.screen_count.serialize();
420        let sequence_bytes = self.sequence.serialize();
421        let length_bytes = self.length.serialize();
422        let window_bytes = self.window.serialize();
423        [
424            response_type_bytes[0],
425            screen_count_bytes[0],
426            sequence_bytes[0],
427            sequence_bytes[1],
428            length_bytes[0],
429            length_bytes[1],
430            length_bytes[2],
431            length_bytes[3],
432            window_bytes[0],
433            window_bytes[1],
434            window_bytes[2],
435            window_bytes[3],
436        ]
437    }
438    fn serialize_into(&self, bytes: &mut Vec<u8>) {
439        bytes.reserve(12);
440        let response_type_bytes = &[1];
441        bytes.push(response_type_bytes[0]);
442        self.screen_count.serialize_into(bytes);
443        self.sequence.serialize_into(bytes);
444        self.length.serialize_into(bytes);
445        self.window.serialize_into(bytes);
446    }
447}
448
449/// Opcode for the GetScreenSize request
450pub const GET_SCREEN_SIZE_REQUEST: u8 = 3;
451#[derive(Clone, Copy, Default)]
452#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
453#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
454pub struct GetScreenSizeRequest {
455    pub window: xproto::Window,
456    pub screen: u32,
457}
458impl_debug_if_no_extra_traits!(GetScreenSizeRequest, "GetScreenSizeRequest");
459impl GetScreenSizeRequest {
460    /// Serialize this request into bytes for the provided connection
461    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'static, [u8]>; 1]> {
462        let length_so_far = 0;
463        let window_bytes = self.window.serialize();
464        let screen_bytes = self.screen.serialize();
465        let mut request0 = vec![
466            major_opcode,
467            GET_SCREEN_SIZE_REQUEST,
468            0,
469            0,
470            window_bytes[0],
471            window_bytes[1],
472            window_bytes[2],
473            window_bytes[3],
474            screen_bytes[0],
475            screen_bytes[1],
476            screen_bytes[2],
477            screen_bytes[3],
478        ];
479        let length_so_far = length_so_far + request0.len();
480        assert_eq!(length_so_far % 4, 0);
481        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
482        request0[2..4].copy_from_slice(&length.to_ne_bytes());
483        ([request0.into()], vec![])
484    }
485    /// Parse this request given its header, its body, and any fds that go along with it
486    #[cfg(feature = "request-parsing")]
487    pub fn try_parse_request(header: RequestHeader, value: &[u8]) -> Result<Self, ParseError> {
488        if header.minor_opcode != GET_SCREEN_SIZE_REQUEST {
489            return Err(ParseError::InvalidValue);
490        }
491        let (window, remaining) = xproto::Window::try_parse(value)?;
492        let (screen, remaining) = u32::try_parse(remaining)?;
493        let _ = remaining;
494        Ok(GetScreenSizeRequest {
495            window,
496            screen,
497        })
498    }
499}
500impl Request for GetScreenSizeRequest {
501    const EXTENSION_NAME: Option<&'static str> = Some(X11_EXTENSION_NAME);
502
503    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
504        let (bufs, fds) = self.serialize(major_opcode);
505        // Flatten the buffers into a single vector
506        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
507        (buf, fds)
508    }
509}
510impl crate::x11_utils::ReplyRequest for GetScreenSizeRequest {
511    type Reply = GetScreenSizeReply;
512}
513
514#[derive(Clone, Copy, Default)]
515#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
516#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
517pub struct GetScreenSizeReply {
518    pub sequence: u16,
519    pub length: u32,
520    pub width: u32,
521    pub height: u32,
522    pub window: xproto::Window,
523    pub screen: u32,
524}
525impl_debug_if_no_extra_traits!(GetScreenSizeReply, "GetScreenSizeReply");
526impl TryParse for GetScreenSizeReply {
527    fn try_parse(initial_value: &[u8]) -> Result<(Self, &[u8]), ParseError> {
528        let remaining = initial_value;
529        let (response_type, remaining) = u8::try_parse(remaining)?;
530        let remaining = remaining.get(1..).ok_or(ParseError::InsufficientData)?;
531        let (sequence, remaining) = u16::try_parse(remaining)?;
532        let (length, remaining) = u32::try_parse(remaining)?;
533        let (width, remaining) = u32::try_parse(remaining)?;
534        let (height, remaining) = u32::try_parse(remaining)?;
535        let (window, remaining) = xproto::Window::try_parse(remaining)?;
536        let (screen, remaining) = u32::try_parse(remaining)?;
537        if response_type != 1 {
538            return Err(ParseError::InvalidValue);
539        }
540        let result = GetScreenSizeReply { sequence, length, width, height, window, screen };
541        let _ = remaining;
542        let remaining = initial_value.get(32 + length as usize * 4..)
543            .ok_or(ParseError::InsufficientData)?;
544        Ok((result, remaining))
545    }
546}
547impl Serialize for GetScreenSizeReply {
548    type Bytes = [u8; 24];
549    fn serialize(&self) -> [u8; 24] {
550        let response_type_bytes = &[1];
551        let sequence_bytes = self.sequence.serialize();
552        let length_bytes = self.length.serialize();
553        let width_bytes = self.width.serialize();
554        let height_bytes = self.height.serialize();
555        let window_bytes = self.window.serialize();
556        let screen_bytes = self.screen.serialize();
557        [
558            response_type_bytes[0],
559            0,
560            sequence_bytes[0],
561            sequence_bytes[1],
562            length_bytes[0],
563            length_bytes[1],
564            length_bytes[2],
565            length_bytes[3],
566            width_bytes[0],
567            width_bytes[1],
568            width_bytes[2],
569            width_bytes[3],
570            height_bytes[0],
571            height_bytes[1],
572            height_bytes[2],
573            height_bytes[3],
574            window_bytes[0],
575            window_bytes[1],
576            window_bytes[2],
577            window_bytes[3],
578            screen_bytes[0],
579            screen_bytes[1],
580            screen_bytes[2],
581            screen_bytes[3],
582        ]
583    }
584    fn serialize_into(&self, bytes: &mut Vec<u8>) {
585        bytes.reserve(24);
586        let response_type_bytes = &[1];
587        bytes.push(response_type_bytes[0]);
588        bytes.extend_from_slice(&[0; 1]);
589        self.sequence.serialize_into(bytes);
590        self.length.serialize_into(bytes);
591        self.width.serialize_into(bytes);
592        self.height.serialize_into(bytes);
593        self.window.serialize_into(bytes);
594        self.screen.serialize_into(bytes);
595    }
596}
597
598/// Opcode for the IsActive request
599pub const IS_ACTIVE_REQUEST: u8 = 4;
600#[derive(Clone, Copy, Default)]
601#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
602#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
603pub struct IsActiveRequest;
604impl_debug_if_no_extra_traits!(IsActiveRequest, "IsActiveRequest");
605impl IsActiveRequest {
606    /// Serialize this request into bytes for the provided connection
607    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'static, [u8]>; 1]> {
608        let length_so_far = 0;
609        let mut request0 = vec![
610            major_opcode,
611            IS_ACTIVE_REQUEST,
612            0,
613            0,
614        ];
615        let length_so_far = length_so_far + request0.len();
616        assert_eq!(length_so_far % 4, 0);
617        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
618        request0[2..4].copy_from_slice(&length.to_ne_bytes());
619        ([request0.into()], vec![])
620    }
621    /// Parse this request given its header, its body, and any fds that go along with it
622    #[cfg(feature = "request-parsing")]
623    pub fn try_parse_request(header: RequestHeader, value: &[u8]) -> Result<Self, ParseError> {
624        if header.minor_opcode != IS_ACTIVE_REQUEST {
625            return Err(ParseError::InvalidValue);
626        }
627        let _ = value;
628        Ok(IsActiveRequest
629        )
630    }
631}
632impl Request for IsActiveRequest {
633    const EXTENSION_NAME: Option<&'static str> = Some(X11_EXTENSION_NAME);
634
635    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
636        let (bufs, fds) = self.serialize(major_opcode);
637        // Flatten the buffers into a single vector
638        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
639        (buf, fds)
640    }
641}
642impl crate::x11_utils::ReplyRequest for IsActiveRequest {
643    type Reply = IsActiveReply;
644}
645
646#[derive(Clone, Copy, Default)]
647#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
648#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
649pub struct IsActiveReply {
650    pub sequence: u16,
651    pub length: u32,
652    pub state: u32,
653}
654impl_debug_if_no_extra_traits!(IsActiveReply, "IsActiveReply");
655impl TryParse for IsActiveReply {
656    fn try_parse(initial_value: &[u8]) -> Result<(Self, &[u8]), ParseError> {
657        let remaining = initial_value;
658        let (response_type, remaining) = u8::try_parse(remaining)?;
659        let remaining = remaining.get(1..).ok_or(ParseError::InsufficientData)?;
660        let (sequence, remaining) = u16::try_parse(remaining)?;
661        let (length, remaining) = u32::try_parse(remaining)?;
662        let (state, remaining) = u32::try_parse(remaining)?;
663        if response_type != 1 {
664            return Err(ParseError::InvalidValue);
665        }
666        let result = IsActiveReply { sequence, length, state };
667        let _ = remaining;
668        let remaining = initial_value.get(32 + length as usize * 4..)
669            .ok_or(ParseError::InsufficientData)?;
670        Ok((result, remaining))
671    }
672}
673impl Serialize for IsActiveReply {
674    type Bytes = [u8; 12];
675    fn serialize(&self) -> [u8; 12] {
676        let response_type_bytes = &[1];
677        let sequence_bytes = self.sequence.serialize();
678        let length_bytes = self.length.serialize();
679        let state_bytes = self.state.serialize();
680        [
681            response_type_bytes[0],
682            0,
683            sequence_bytes[0],
684            sequence_bytes[1],
685            length_bytes[0],
686            length_bytes[1],
687            length_bytes[2],
688            length_bytes[3],
689            state_bytes[0],
690            state_bytes[1],
691            state_bytes[2],
692            state_bytes[3],
693        ]
694    }
695    fn serialize_into(&self, bytes: &mut Vec<u8>) {
696        bytes.reserve(12);
697        let response_type_bytes = &[1];
698        bytes.push(response_type_bytes[0]);
699        bytes.extend_from_slice(&[0; 1]);
700        self.sequence.serialize_into(bytes);
701        self.length.serialize_into(bytes);
702        self.state.serialize_into(bytes);
703    }
704}
705
706/// Opcode for the QueryScreens request
707pub const QUERY_SCREENS_REQUEST: u8 = 5;
708#[derive(Clone, Copy, Default)]
709#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
710#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
711pub struct QueryScreensRequest;
712impl_debug_if_no_extra_traits!(QueryScreensRequest, "QueryScreensRequest");
713impl QueryScreensRequest {
714    /// Serialize this request into bytes for the provided connection
715    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'static, [u8]>; 1]> {
716        let length_so_far = 0;
717        let mut request0 = vec![
718            major_opcode,
719            QUERY_SCREENS_REQUEST,
720            0,
721            0,
722        ];
723        let length_so_far = length_so_far + request0.len();
724        assert_eq!(length_so_far % 4, 0);
725        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
726        request0[2..4].copy_from_slice(&length.to_ne_bytes());
727        ([request0.into()], vec![])
728    }
729    /// Parse this request given its header, its body, and any fds that go along with it
730    #[cfg(feature = "request-parsing")]
731    pub fn try_parse_request(header: RequestHeader, value: &[u8]) -> Result<Self, ParseError> {
732        if header.minor_opcode != QUERY_SCREENS_REQUEST {
733            return Err(ParseError::InvalidValue);
734        }
735        let _ = value;
736        Ok(QueryScreensRequest
737        )
738    }
739}
740impl Request for QueryScreensRequest {
741    const EXTENSION_NAME: Option<&'static str> = Some(X11_EXTENSION_NAME);
742
743    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
744        let (bufs, fds) = self.serialize(major_opcode);
745        // Flatten the buffers into a single vector
746        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
747        (buf, fds)
748    }
749}
750impl crate::x11_utils::ReplyRequest for QueryScreensRequest {
751    type Reply = QueryScreensReply;
752}
753
754#[derive(Clone, Default)]
755#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
756#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
757pub struct QueryScreensReply {
758    pub sequence: u16,
759    pub length: u32,
760    pub screen_info: Vec<ScreenInfo>,
761}
762impl_debug_if_no_extra_traits!(QueryScreensReply, "QueryScreensReply");
763impl TryParse for QueryScreensReply {
764    fn try_parse(initial_value: &[u8]) -> Result<(Self, &[u8]), ParseError> {
765        let remaining = initial_value;
766        let (response_type, remaining) = u8::try_parse(remaining)?;
767        let remaining = remaining.get(1..).ok_or(ParseError::InsufficientData)?;
768        let (sequence, remaining) = u16::try_parse(remaining)?;
769        let (length, remaining) = u32::try_parse(remaining)?;
770        let (number, remaining) = u32::try_parse(remaining)?;
771        let remaining = remaining.get(20..).ok_or(ParseError::InsufficientData)?;
772        let (screen_info, remaining) = crate::x11_utils::parse_list::<ScreenInfo>(remaining, number.try_to_usize()?)?;
773        if response_type != 1 {
774            return Err(ParseError::InvalidValue);
775        }
776        let result = QueryScreensReply { sequence, length, screen_info };
777        let _ = remaining;
778        let remaining = initial_value.get(32 + length as usize * 4..)
779            .ok_or(ParseError::InsufficientData)?;
780        Ok((result, remaining))
781    }
782}
783impl Serialize for QueryScreensReply {
784    type Bytes = Vec<u8>;
785    fn serialize(&self) -> Vec<u8> {
786        let mut result = Vec::new();
787        self.serialize_into(&mut result);
788        result
789    }
790    fn serialize_into(&self, bytes: &mut Vec<u8>) {
791        bytes.reserve(32);
792        let response_type_bytes = &[1];
793        bytes.push(response_type_bytes[0]);
794        bytes.extend_from_slice(&[0; 1]);
795        self.sequence.serialize_into(bytes);
796        self.length.serialize_into(bytes);
797        let number = u32::try_from(self.screen_info.len()).expect("`screen_info` has too many elements");
798        number.serialize_into(bytes);
799        bytes.extend_from_slice(&[0; 20]);
800        self.screen_info.serialize_into(bytes);
801    }
802}
803impl QueryScreensReply {
804    /// Get the value of the `number` field.
805    ///
806    /// The `number` field is used as the length field of the `screen_info` field.
807    /// This function computes the field's value again based on the length of the list.
808    ///
809    /// # Panics
810    ///
811    /// Panics if the value cannot be represented in the target type. This
812    /// cannot happen with values of the struct received from the X11 server.
813    pub fn number(&self) -> u32 {
814        self.screen_info.len()
815            .try_into().unwrap()
816    }
817}
818
x11rb_protocol/protocol/xinerama.rs

x11rb_protocol/protocol/
xinerama.rs
