waybackend 0.10.1

A simple, low-level wayland client implementation
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

pub(crate) mod wl_display {
    pub(crate) mod req {
        pub(crate) const SYNC: u16 = 0u16;

        pub(crate) fn sync(
            backend: &mut crate::Waybackend,
            sender_id: crate::types::ObjectId,
            callback: crate::types::ObjectId,
        ) -> Result<(), crate::Errno> {
            let crate::Waybackend {
                wire_msg_builder,
                wayland_fd,
                ..
            } = backend;
            wire_msg_builder.ensure_space(wayland_fd, 3, 0)?;
            unsafe {
                wire_msg_builder.add_header(sender_id, SYNC, 3 * 4);
                wire_msg_builder.add_new_specified_id(callback);
            }
            Ok(())
        }
        pub(crate) const GET_REGISTRY: u16 = 1u16;

        pub(crate) fn get_registry(
            backend: &mut crate::Waybackend,
            sender_id: crate::types::ObjectId,
            registry: crate::types::ObjectId,
        ) -> Result<(), crate::Errno> {
            let crate::Waybackend {
                wire_msg_builder,
                wayland_fd,
                ..
            } = backend;
            wire_msg_builder.ensure_space(wayland_fd, 3, 0)?;
            unsafe {
                wire_msg_builder.add_header(sender_id, GET_REGISTRY, 3 * 4);
                wire_msg_builder.add_new_specified_id(registry);
            }
            Ok(())
        }
    }

    #[allow(non_camel_case_types)]
    #[repr(u32)]
    #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
    pub(crate) enum Error {
        invalid_object = 0u32,

        invalid_method = 1u32,

        no_memory = 2u32,

        implementation = 3u32,
    }
    impl core::convert::TryFrom<u32> for Error {
        type Error = crate::wire::Error;
        #[allow(non_upper_case_globals)]
        fn try_from(value: u32) -> Result<Self, Self::Error> {
            const invalid_object: u32 = Error::invalid_object as u32;
            const invalid_method: u32 = Error::invalid_method as u32;
            const no_memory: u32 = Error::no_memory as u32;
            const implementation: u32 = Error::implementation as u32;
            match value {
                invalid_object => Ok(Self::invalid_object),
                invalid_method => Ok(Self::invalid_method),
                no_memory => Ok(Self::no_memory),
                implementation => Ok(Self::implementation),
                otherwise => Err(crate::wire::Error::InvalidEnumDiscriminant(
                    "Error", otherwise,
                )),
            }
        }
    }
    impl core::convert::From<Error> for u32 {
        fn from(value: Error) -> u32 {
            value as u32
        }
    }
}

pub(crate) mod wl_registry {
    pub(crate) mod req {
        pub(crate) const BIND: u16 = 0u16;

        pub(crate) fn bind(
            backend: &mut crate::Waybackend,
            sender_id: crate::types::ObjectId,
            name: u32,
            id: crate::types::ObjectId,
            interface: &str,
            version: u32,
        ) -> Result<(), crate::Errno> {
            let crate::Waybackend {
                wire_msg_builder,
                wayland_fd,
                ..
            } = backend;
            let byte_size = 6 + (interface.len() + 1).div_ceil(4);
            wire_msg_builder.ensure_space(wayland_fd, byte_size, 0)?;
            unsafe {
                wire_msg_builder.add_header(sender_id, BIND, byte_size as u16 * 4);
                wire_msg_builder.add_u32(name);
                wire_msg_builder.add_new_unspecified_id(id, interface, version);
            }
            Ok(())
        }
    }
}