commit 2f8e211f25a4fe77cfaacd3788991e55ebbd4da5 · belsanti.xyz/wl-crosshair

+11 -28
src/main.rs
···

       2
       2
        
       

     

       3
       3
        
       use wayland_client::{

     

       4
       4
        
           protocol::{

     

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

     

       6
       6
       -
               wl_shm_pool, wl_surface,

     

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

     

       7
       6
        
           },

     

       8
       7
        
           Connection, Dispatch, Proxy, QueueHandle,

     

       9
       8
        
       };

     
···

       26
       25
        
           layer_surface: Option<zwlr_layer_surface_v1::ZwlrLayerSurfaceV1>,

     

       27
       26
        
           buffer: Option<wl_buffer::WlBuffer>,

     

       28
       27
        
           wm_base: Option<xdg_wm_base::XdgWmBase>,

     

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

     

       30
       28
        
       }

     

       31
       29
        
       

     

       32
       30
        
       fn main() {

     
···

       47
       45
        
               layer_surface: None,

     

       48
       46
        
               buffer: None,

     

       49
       47
        
               wm_base: None,

     

       50
       50
       -
               pointer: None,

     

       51
       48
        
           };

     

       52
       49
        
       

     

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

     
···

       109
       106
        
                           (),

     

       110
       107
        
                       );

     

       111
       108
        
                       state.buffer = Some(buffer);

     

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

     

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

     

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

     

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

     

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

     

       117
       111
        
                       state.wm_base = Some(wm_base);

     
···

       120
       114
        
           }

     

       121
       115
        
       }

     

       122
       116
        
       

     

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

     

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

     

       124
       118
        
           fn event(

     

       125
       125
       -
               state: &mut Self,

     

       126
       126
       -
               _: &wl_pointer::WlPointer,

     

       127
       127
       -
               event: wl_pointer::Event,

     

       119
       119
       +
               _: &mut Self,

     

       120
       120
       +
               _: &WlRegion,

     

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

     

       128
       122
        
               _: &(),

     

       129
       123
        
               _: &Connection,

     

       130
       130
       -
               qh: &QueueHandle<Self>,

     

       124
       124
       +
               _: &QueueHandle<Self>,

     

       131
       125
        
           ) {

     

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

     

       133
       133
       -
               match event {

     

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

     

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

     

       136
       136
       -
                           surface.destroy();

     

       137
       137
       -
                       }

     

       138
       138
       -
                       state.base_surface = None;

     

       139
       139
       -
                   }

     

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

     

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

     

       142
       142
       -
                       state.base_surface = Some(surface);

     

       143
       143
       -
       

     

       144
       144
       -
                       state.init_layer_surface(qh);

     

       145
       145
       -
                   }

     

       146
       146
       -
                   _ => {}

     

       147
       147
       -
               }

     

       148
       126
        
           }

     

       149
       127
        
       }

     

       150
       128
        
       

     
···

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

     

       198
       176
        
               // independently of any other xdg_layer_shell

     

       199
       177
        
               layer.set_exclusive_zone(-1);

     

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

     

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

     

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

     

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

     

       182
       182
       +
               }

     

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

     

       201
       184
        
       

     

       202
       185
        
               self.layer_surface = Some(layer);