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
146
147
148
149
150
151
152

use wayland_protocols::wp::alpha_modifier::v1::server::{
    wp_alpha_modifier_surface_v1::{self, WpAlphaModifierSurfaceV1},
    wp_alpha_modifier_v1::{self, WpAlphaModifierV1},
};

use wayland_server::{
    backend::ClientId, Client, DataInit, Dispatch, DisplayHandle, GlobalDispatch, New, Resource,
};

use super::{
    AlphaModifierState, AlphaModifierSurfaceCachedState, AlphaModifierSurfaceData,
    AlphaModifierSurfaceUserData,
};
use crate::wayland::compositor;

impl<D> GlobalDispatch<WpAlphaModifierV1, (), D> for AlphaModifierState
where
    D: GlobalDispatch<WpAlphaModifierV1, ()>,
    D: Dispatch<WpAlphaModifierV1, ()>,
    D: Dispatch<WpAlphaModifierSurfaceV1, AlphaModifierSurfaceUserData>,
    D: 'static,
{
    fn bind(
        _state: &mut D,
        _: &DisplayHandle,
        _: &Client,
        resource: New<WpAlphaModifierV1>,
        _: &(),
        data_init: &mut DataInit<'_, D>,
    ) {
        data_init.init(resource, ());
    }
}

impl<D> Dispatch<WpAlphaModifierV1, (), D> for AlphaModifierState
where
    D: Dispatch<WpAlphaModifierV1, ()>,
    D: Dispatch<WpAlphaModifierSurfaceV1, AlphaModifierSurfaceUserData>,
    D: 'static,
{
    fn request(
        _state: &mut D,
        _: &Client,
        manager: &WpAlphaModifierV1,
        request: wp_alpha_modifier_v1::Request,
        _data: &(),
        _dh: &DisplayHandle,
        data_init: &mut DataInit<'_, D>,
    ) {
        match request {
            wp_alpha_modifier_v1::Request::GetSurface { id, surface } => {
                let already_taken = compositor::with_states(&surface, |states| {
                    states
                        .data_map
                        .insert_if_missing_threadsafe(AlphaModifierSurfaceData::new);
                    let data = states.data_map.get::<AlphaModifierSurfaceData>().unwrap();

                    let already_taken = data.is_resource_attached();

                    if !already_taken {
                        data.set_is_resource_attached(true);
                    }

                    already_taken
                });

                if already_taken {
                    manager.post_error(
                        wp_alpha_modifier_v1::Error::AlreadyConstructed,
                        "wl_surface already has a alpha modifier object attached",
                    )
                } else {
                    data_init.init(id, AlphaModifierSurfaceUserData::new(surface));
                }
            }

            wp_alpha_modifier_v1::Request::Destroy => {}
            _ => unreachable!(),
        }
    }
}

impl<D> Dispatch<WpAlphaModifierSurfaceV1, AlphaModifierSurfaceUserData, D> for AlphaModifierState
where
    D: Dispatch<WpAlphaModifierSurfaceV1, AlphaModifierSurfaceUserData>,
{
    fn request(
        _state: &mut D,
        _: &Client,
        obj: &WpAlphaModifierSurfaceV1,
        request: wp_alpha_modifier_surface_v1::Request,
        data: &AlphaModifierSurfaceUserData,
        _dh: &DisplayHandle,
        _: &mut DataInit<'_, D>,
    ) {
        match request {
            wp_alpha_modifier_surface_v1::Request::SetMultiplier { factor } => {
                let Some(surface) = data.wl_surface() else {
                    obj.post_error(
                        wp_alpha_modifier_surface_v1::Error::NoSurface,
                        "wl_surface was destroyed",
                    );
                    return;
                };

                compositor::with_states(&surface, |states| {
                    states
                        .cached_state
                        .get::<AlphaModifierSurfaceCachedState>()
                        .pending()
                        .multiplier = Some(factor);
                })
            }
            // Switch back to not specifying the alpha multiplier of this surface.
            wp_alpha_modifier_surface_v1::Request::Destroy => {
                let Some(surface) = data.wl_surface() else {
                    obj.post_error(
                        wp_alpha_modifier_surface_v1::Error::NoSurface,
                        "wl_surface was destroyed",
                    );
                    return;
                };

                compositor::with_states(&surface, |states| {
                    states
                        .data_map
                        .get::<AlphaModifierSurfaceData>()
                        .unwrap()
                        .set_is_resource_attached(false);

                    states
                        .cached_state
                        .get::<AlphaModifierSurfaceCachedState>()
                        .pending()
                        .multiplier = None;
                });
            }
            _ => unreachable!(),
        }
    }

    fn destroyed(
        _state: &mut D,
        _client: ClientId,
        _object: &WpAlphaModifierSurfaceV1,
        _data: &AlphaModifierSurfaceUserData,
    ) {
        // Nothing to do here, graceful Destroy is already handled with double buffering
        // and in case of client close WlSurface destroyed handler will clean up the data anyway,
        // so there is no point in queuing new update
    }
}