smithay 0.7.0

Smithay is a library for writing wayland compositors.
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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

use tracing::{error, info};

use super::{MissingExtensionError, X11Error};

/// The extension macro.
///
/// This macro generates a struct which checks for the presence of some X11 extensions and stores
/// the version supplied by the X server.
///
/// ```ignore(cannot-test-this-because-non-exported-macro)
/// extensions! {
///     // The extension to check for. This should correspond to the name of the extension inside x11rb's `x11rb::protocol::xproto::<name>` module path.
///     xfixes {
///         // The function used to query the available version of the extension. This will be inside the module path as explained above
///         xfixes_query_version,
///         // The minimum version of the extension that will be accepted.
///         minimum: (4, 0),
///         // The version of the extension to request.
///         request: (4, 0),
///     },
/// }
///
/// // The extensions may be checked then using the generated `Extensions` struct using the `check_extensions` function.
/// ```
macro_rules! extensions {
    (
        $(
            $extension:ident { // Extension name for path lookup
                $extension_fn:ident, // Function used to look up the version of the extension
                required: $required:expr,
                minimum: ($min_major:expr, $min_minor:expr),
                request: ($req_major:expr, $req_minor:expr),
            },
        )*
    ) => {
        #[allow(dead_code)]
        #[derive(Debug, Copy, Clone)]
        pub struct Extensions {
            $(
                #[doc = concat!(" The version of the `", stringify!($extension), "` extension.")]
                pub $extension: Option<(u32, u32)>,
            )*
        }

        impl Extensions {
            pub fn check_extensions<C: x11rb::connection::Connection>(connection: &C) -> Result<Extensions, X11Error> {
                $(
                    let $extension = {
                        use x11rb::protocol::$extension::{ConnectionExt as _, X11_EXTENSION_NAME};

                        if connection.extension_information(X11_EXTENSION_NAME)?.is_some() {
                            let version = connection.$extension_fn($req_major, $req_minor)?.reply()?;
                            let major_version = u32::from(version.major_version);
                            let minor_version = u32::from(version.minor_version);

                            #[allow(unused_comparisons)] // Macro comparisons
                            if major_version >= $req_major
                                || (major_version == $req_major && minor_version >= $req_minor)
                            {
                                info!(
                                    "Loaded extension {} version {}.{}",
                                    X11_EXTENSION_NAME,
                                    major_version,
                                    minor_version,
                                );

                                Some((major_version, minor_version))
                            } else {
                                if $required {
                                    error!(
                                        "required extension {} version is too low (have {}.{}, expected {}.{})",
                                        X11_EXTENSION_NAME,
                                        major_version,
                                        minor_version,
                                        $req_major,
                                        $req_minor,
                                    );

                                    return Err(MissingExtensionError::WrongVersion {
                                        name: X11_EXTENSION_NAME,
                                        required_major: $req_major,
                                        required_minor: $req_minor,
                                        available_major: major_version,
                                        available_minor: minor_version,
                                    }.into());
                                } else {
                                    None
                                }
                            }
                        } else {
                            if $required {
                                error!("required extension {} not found", X11_EXTENSION_NAME);

                                return Err(MissingExtensionError::NotFound {
                                    name: X11_EXTENSION_NAME,
                                    major: $min_major,
                                    minor: $min_minor,
                                }
                                .into());
                            } else {
                                None
                            }
                        }
                    };
                )*

                Ok(Extensions {
                    $(
                        $extension,
                    )*
                })
            }
        }
    };
}

extensions! {
    present {
        present_query_version,
        required: true,
        minimum: (1, 0),
        request: (1, 0),
    },

    xfixes {
        xfixes_query_version,
        required: true,
        minimum: (4, 0),
        request: (4, 0),
    },

    dri3 {
        dri3_query_version,
        required: true,
        minimum: (1, 0),
        request: (1, 2),
    },

    xinput {
        xinput_xi_query_version,
        required: true,
        minimum: (2, 0),
        request: (2, 4),
    },
}