···

       
2
       
 
       


     

       
3
       
 
       
use wayland_client::{

     

       
4
       
 
       
    protocol::{

     

       
5
       
-
       
        wl_buffer, wl_compositor, wl_keyboard, wl_pointer, wl_registry, wl_seat, wl_shm,

     

       
6
       
-
       
        wl_shm_pool, wl_surface,

     

       
7
       
 
       
    },

     

       
8
       
 
       
    Connection, Dispatch, Proxy, QueueHandle,

     

       
9
       
 
       
};

     
···

       
26
       
 
       
    layer_surface: Option<zwlr_layer_surface_v1::ZwlrLayerSurfaceV1>,

     

       
27
       
 
       
    buffer: Option<wl_buffer::WlBuffer>,

     

       
28
       
 
       
    wm_base: Option<xdg_wm_base::XdgWmBase>,

     

       
29
       
-
       
    pointer: Option<wl_pointer::WlPointer>,

     

       
30
       
 
       
}

     

       
31
       
 
       


     

       
32
       
 
       
fn main() {

     
···

       
47
       
 
       
        layer_surface: None,

     

       
48
       
 
       
        buffer: None,

     

       
49
       
 
       
        wm_base: None,

     

       
50
       
-
       
        pointer: None,

     

       
51
       
 
       
    };

     

       
52
       
 
       


     

       
53
       
 
       
    event_queue.blocking_dispatch(&mut state).unwrap();

     
···

       
109
       
 
       
                    (),

     

       
110
       
 
       
                );

     

       
111
       
 
       
                state.buffer = Some(buffer);

     

       
112
       
-
       
            } else if interface == wl_seat::WlSeat::interface().name {

     

       
113
       
-
       
                let seat = registry.bind::<wl_seat::WlSeat, _, _>(name, version, qh, ());

     

       
114
       
-
       
                state.pointer = Some(seat.get_pointer(qh, ()));

     

       
115
       
 
       
            } else if interface == xdg_wm_base::XdgWmBase::interface().name {

     

       
116
       
 
       
                let wm_base = registry.bind::<xdg_wm_base::XdgWmBase, _, _>(name, 1, qh, ());

     

       
117
       
 
       
                state.wm_base = Some(wm_base);

     
···

       
120
       
 
       
    }

     

       
121
       
 
       
}

     

       
122
       
 
       


     

       
123
       
-
       
impl Dispatch<wl_pointer::WlPointer, ()> for State {

     

       
124
       
 
       
    fn event(

     

       
125
       
-
       
        state: &mut Self,

     

       
126
       
-
       
        _: &wl_pointer::WlPointer,

     

       
127
       
-
       
        event: wl_pointer::Event,

     

       
128
       
 
       
        _: &(),

     

       
129
       
 
       
        _: &Connection,

     

       
130
       
-
       
        qh: &QueueHandle<Self>,

     

       
131
       
 
       
    ) {

     

       
132
       
-
       
        eprintln!("WlPointer event {event:#?}");

     

       
133
       
-
       
        match event {

     

       
134
       
-
       
            wl_pointer::Event::Enter { .. } => {

     

       
135
       
-
       
                if let Some(surface) = &state.base_surface {

     

       
136
       
-
       
                    surface.destroy();

     

       
137
       
-
       
                }

     

       
138
       
-
       
                state.base_surface = None;

     

       
139
       
-
       
            }

     

       
140
       
-
       
            wl_pointer::Event::Leave { .. } => {

     

       
141
       
-
       
                let surface = state.compositor.as_ref().unwrap().create_surface(qh, ());

     

       
142
       
-
       
                state.base_surface = Some(surface);

     

       
143
       
-
       


     

       
144
       
-
       
                state.init_layer_surface(qh);

     

       
145
       
-
       
            }

     

       
146
       
-
       
            _ => {}

     

       
147
       
-
       
        }

     

       
148
       
 
       
    }

     

       
149
       
 
       
}

     

       
150
       
 
       


     
···

       
197
       
 
       
        // A negative value means we will be centered on the screen

     

       
198
       
 
       
        // independently of any other xdg_layer_shell

     

       
199
       
 
       
        layer.set_exclusive_zone(-1);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
200
       
 
       
        self.base_surface.as_ref().unwrap().commit();

     

       
201
       
 
       


     

       
202
       
 
       
        self.layer_surface = Some(layer);

     

···

       
2
       
 
       


     

       
3
       
 
       
use wayland_client::{

     

       
4
       
 
       
    protocol::{

     

       
5
       
+
       
        wl_buffer, wl_compositor, wl_keyboard, wl_region::WlRegion, wl_registry, wl_seat, wl_shm, wl_shm_pool, wl_surface

     

       
0
       
 
       

     

       
6
       
 
       
    },

     

       
7
       
 
       
    Connection, Dispatch, Proxy, QueueHandle,

     

       
8
       
 
       
};

     
···

       
25
       
 
       
    layer_surface: Option<zwlr_layer_surface_v1::ZwlrLayerSurfaceV1>,

     

       
26
       
 
       
    buffer: Option<wl_buffer::WlBuffer>,

     

       
27
       
 
       
    wm_base: Option<xdg_wm_base::XdgWmBase>,

     

       
0
       
 
       

     

       
28
       
 
       
}

     

       
29
       
 
       


     

       
30
       
 
       
fn main() {

     
···

       
45
       
 
       
        layer_surface: None,

     

       
46
       
 
       
        buffer: None,

     

       
47
       
 
       
        wm_base: None,

     

       
0
       
 
       

     

       
48
       
 
       
    };

     

       
49
       
 
       


     

       
50
       
 
       
    event_queue.blocking_dispatch(&mut state).unwrap();

     
···

       
106
       
 
       
                    (),

     

       
107
       
 
       
                );

     

       
108
       
 
       
                state.buffer = Some(buffer);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
109
       
 
       
            } else if interface == xdg_wm_base::XdgWmBase::interface().name {

     

       
110
       
 
       
                let wm_base = registry.bind::<xdg_wm_base::XdgWmBase, _, _>(name, 1, qh, ());

     

       
111
       
 
       
                state.wm_base = Some(wm_base);

     
···

       
114
       
 
       
    }

     

       
115
       
 
       
}

     

       
116
       
 
       


     

       
117
       
+
       
impl Dispatch<WlRegion, ()> for State {

     

       
118
       
 
       
    fn event(

     

       
119
       
+
       
        _: &mut Self,

     

       
120
       
+
       
        _: &WlRegion,

     

       
121
       
+
       
        _: <WlRegion as Proxy>::Event,

     

       
122
       
 
       
        _: &(),

     

       
123
       
 
       
        _: &Connection,

     

       
124
       
+
       
        _: &QueueHandle<Self>,

     

       
125
       
 
       
    ) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
126
       
 
       
    }

     

       
127
       
 
       
}

     

       
128
       
 
       


     
···

       
175
       
 
       
        // A negative value means we will be centered on the screen

     

       
176
       
 
       
        // independently of any other xdg_layer_shell

     

       
177
       
 
       
        layer.set_exclusive_zone(-1);

     

       
178
       
+
       
        // Set empty input region to allow clicking through the window.

     

       
179
       
+
       
        if let Some(compositor) = &self.compositor {

     

       
180
       
+
       
            let region = compositor.create_region(qh, ());

     

       
181
       
+
       
            self.base_surface.as_ref().unwrap().set_input_region(Some(&region));

     

       
182
       
+
       
        }

     

       
183
       
 
       
        self.base_surface.as_ref().unwrap().commit();

     

       
184
       
 
       


     

       
185
       
 
       
        self.layer_surface = Some(layer);