Wayland support for set_cursor_grab and set_cursor_visible

CHANGELOG.md

@@ -18,6 +18,7 @@
 - On Windows, fix hovering the mouse over the active window creating an endless stream of CursorMoved events.
 - On X11, prevent stealing input focus when creating a new window.
   Only steal input focus when entering fullscreen mode.
+- Added support for set_cursor_visible and set_cursor_grab on wayland
 
 # 0.20.0 Alpha 3 (2019-08-14)
 

src/platform_impl/linux/wayland/event_loop.rs

@@ -7,11 +7,16 @@ use std::{
     time::Instant,
 };
 
+use smithay_client_toolkit::reexports::protocols::unstable::pointer_constraints::v1::client::{
+    zwp_locked_pointer_v1::ZwpLockedPointerV1, zwp_pointer_constraints_v1::ZwpPointerConstraintsV1,
+};
 use smithay_client_toolkit::reexports::protocols::unstable::relative_pointer::v1::client::{
     zwp_relative_pointer_manager_v1::ZwpRelativePointerManagerV1,
     zwp_relative_pointer_v1::ZwpRelativePointerV1,
 };
 
+use smithay_client_toolkit::reexports::client::protocol::wl_surface::WlSurface;
+
 use crate::{
     dpi::{PhysicalPosition, PhysicalSize},
     event::ModifiersState,
@@ -69,6 +74,68 @@ impl<T> WindowEventsSink<T> {
     }
 }
 
+pub struct CursorManager {
+    pointer_constraints_proxy: Arc<Mutex<Option<ZwpPointerConstraintsV1>>>,
+    pointers: Vec<wl_pointer::WlPointer>,
+    locked_pointers: Vec<ZwpLockedPointerV1>,
+    cursor_visible: Arc<Mutex<bool>>,
+}
+
+impl CursorManager {
+    fn new(constraints: Arc<Mutex<Option<ZwpPointerConstraintsV1>>>) -> CursorManager {
+        CursorManager {
+            pointer_constraints_proxy: constraints,
+            pointers: Vec::new(),
+            locked_pointers: Vec::new(),
+            cursor_visible: Arc::new(Mutex::new(true)),
+        }
+    }
+
+    fn register_pointer(&mut self, pointer: wl_pointer::WlPointer) {
+        self.pointers.push(pointer);
+    }
+
+    pub fn set_cursor_visible(&mut self, visible: bool) {
+        // If we want to hide the cursor do it immediately. There is a known
+        // limitation that the cursor will not become visible again until it
+        // enters a new surface
+        if !visible {
+            for pointer in self.pointers.iter() {
+                pointer.set_cursor(0, None, 0, 0);
+            }
+        }
+        (*self.cursor_visible.lock().unwrap()) = visible;
+    }
+
+    pub fn grab_pointer(&mut self, surface: Option<&WlSurface>) {
+        for lp in self.locked_pointers.drain(..) {
+            lp.destroy();
+        }
+
+        if let Some(surface) = surface {
+            for pointer in self.pointers.iter() {
+                let locked_pointer = self
+                    .pointer_constraints_proxy
+                    .lock()
+                    .unwrap()
+                    .as_ref()
+                    .and_then(|pointer_constraints| {
+                        super::pointer::implement_locked_pointer(
+                            surface,
+                            pointer,
+                            pointer_constraints,
+                        )
+                        .ok()
+                    });
+
+                if let Some(locked_pointer) = locked_pointer {
+                    self.locked_pointers.push(locked_pointer);
+                }
+            }
+        }
+    }
+}
+
 pub struct EventLoop<T: 'static> {
     // The loop
     inner_loop: ::calloop::EventLoop<()>,
@@ -79,6 +146,8 @@ pub struct EventLoop<T: 'static> {
     // our sink, shared with some handlers, buffering the events
     sink: Arc<Mutex<WindowEventsSink<T>>>,
     pending_user_events: Rc<RefCell<VecDeque<T>>>,
+    // Utility for grabbing the cursor and changing visibility
+    cursor_manager: Arc<Mutex<CursorManager>>,
     _user_source: ::calloop::Source<::calloop::channel::Channel<T>>,
     user_sender: ::calloop::channel::Sender<T>,
     _kbd_source: ::calloop::Source<
@@ -146,14 +215,20 @@ impl<T: 'static> EventLoop<T> {
             })
             .unwrap();
 
+        let pointer_constraints_proxy = Arc::new(Mutex::new(None));
+
         let mut seat_manager = SeatManager {
             sink: sink.clone(),
             relative_pointer_manager_proxy: None,
+            pointer_constraints_proxy: pointer_constraints_proxy.clone(),
             store: store.clone(),
             seats: seats.clone(),
             kbd_sender,
+            cursor_manager: Arc::new(Mutex::new(CursorManager::new(pointer_constraints_proxy))),
         };
 
+        let cursor_manager = seat_manager.cursor_manager.clone();
+
         let env = Environment::from_display_with_cb(
             &display,
             &mut event_queue,
@@ -172,6 +247,16 @@ impl<T: 'static> EventLoop<T> {
                                 .unwrap(),
                         )
                     }
+                    if interface == "zwp_pointer_constraints_v1" {
+                        let pointer_constraints_proxy = registry
+                            .bind(version, id, move |pointer_constraints| {
+                                pointer_constraints.implement_closure(|_, _| (), ())
+                            })
+                            .unwrap();
+
+                        *seat_manager.pointer_constraints_proxy.lock().unwrap() =
+                            Some(pointer_constraints_proxy);
+                    }
                     if interface == "wl_seat" {
                         seat_manager.add_seat(id, version, registry)
                     }
@@ -210,6 +295,7 @@ impl<T: 'static> EventLoop<T> {
             pending_user_events,
             display: display.clone(),
             outputs: env.outputs.clone(),
+            cursor_manager,
             _user_source: user_source,
             user_sender,
             _kbd_source: kbd_source,
@@ -449,7 +535,17 @@ impl<T> EventLoop<T> {
         }
         // process pending resize/refresh
         window_target.store.lock().unwrap().for_each(
-            |newsize, size, new_dpi, refresh, frame_refresh, closed, wid, frame| {
+            |newsize,
+             size,
+             new_dpi,
+             refresh,
+             frame_refresh,
+             closed,
+             cursor_visible,
+             cursor_grab,
+             surface,
+             wid,
+             frame| {
                 if let Some(frame) = frame {
                     if let Some((w, h)) = newsize {
                         frame.resize(w, h);
@@ -479,6 +575,20 @@ impl<T> EventLoop<T> {
                 if closed {
                     sink.send_window_event(crate::event::WindowEvent::CloseRequested, wid);
                 }
+                if let Some(grab) = cursor_grab {
+                    self.cursor_manager.lock().unwrap().grab_pointer(if grab {
+                        Some(surface)
+                    } else {
+                        None
+                    });
+                }
+
+                if let Some(visible) = cursor_visible {
+                    self.cursor_manager
+                        .lock()
+                        .unwrap()
+                        .set_cursor_visible(visible);
+                }
             },
         )
     }
@@ -494,6 +604,8 @@ struct SeatManager<T: 'static> {
     seats: Arc<Mutex<Vec<(u32, wl_seat::WlSeat)>>>,
     kbd_sender: ::calloop::channel::Sender<(crate::event::WindowEvent, super::WindowId)>,
     relative_pointer_manager_proxy: Option<ZwpRelativePointerManagerV1>,
+    pointer_constraints_proxy: Arc<Mutex<Option<ZwpPointerConstraintsV1>>>,
+    cursor_manager: Arc<Mutex<CursorManager>>,
 }
 
 impl<T: 'static> SeatManager<T> {
@@ -510,6 +622,7 @@ impl<T: 'static> SeatManager<T> {
             touch: None,
             kbd_sender: self.kbd_sender.clone(),
             modifiers_tracker: Arc::new(Mutex::new(ModifiersState::default())),
+            cursor_manager: self.cursor_manager.clone(),
         };
         let seat = registry
             .bind(min(version, 5), id, move |seat| {
@@ -541,6 +654,7 @@ struct SeatData<T> {
     keyboard: Option<wl_keyboard::WlKeyboard>,
     touch: Option<wl_touch::WlTouch>,
     modifiers_tracker: Arc<Mutex<ModifiersState>>,
+    cursor_manager: Arc<Mutex<CursorManager>>,
 }
 
 impl<T: 'static> SeatData<T> {
@@ -555,8 +669,14 @@ impl<T: 'static> SeatData<T> {
                         self.sink.clone(),
                         self.store.clone(),
                         self.modifiers_tracker.clone(),
+                        self.cursor_manager.lock().unwrap().cursor_visible.clone(),
                     ));
 
+                    self.cursor_manager
+                        .lock()
+                        .unwrap()
+                        .register_pointer(self.pointer.as_ref().unwrap().clone());
+
                     self.relative_pointer =
                         self.relative_pointer_manager_proxy
                             .as_ref()

src/platform_impl/linux/wayland/pointer.rs

@@ -17,11 +17,19 @@ use smithay_client_toolkit::reexports::protocols::unstable::relative_pointer::v1
     zwp_relative_pointer_v1::ZwpRelativePointerV1,
 };
 
+use smithay_client_toolkit::reexports::protocols::unstable::pointer_constraints::v1::client::{
+    zwp_locked_pointer_v1::ZwpLockedPointerV1, zwp_pointer_constraints_v1::Lifetime,
+    zwp_pointer_constraints_v1::ZwpPointerConstraintsV1,
+};
+
+use smithay_client_toolkit::reexports::client::protocol::wl_surface::WlSurface;
+
 pub fn implement_pointer<T: 'static>(
     seat: &wl_seat::WlSeat,
     sink: Arc<Mutex<WindowEventsSink<T>>>,
     store: Arc<Mutex<WindowStore>>,
     modifiers_tracker: Arc<Mutex<ModifiersState>>,
+    cursor_visible: Arc<Mutex<bool>>,
 ) -> WlPointer {
     seat.get_pointer(|pointer| {
         let mut mouse_focus = None;
@@ -62,6 +70,10 @@ pub fn implement_pointer<T: 'static>(
                                 wid,
                             );
                         }
+
+                        if *cursor_visible.lock().unwrap() == false {
+                            pointer.set_cursor(0, None, 0, 0);
+                        }
                     }
                     PtrEvent::Leave { surface, .. } => {
                         mouse_focus = None;
@@ -241,3 +253,13 @@ pub fn implement_relative_pointer<T: 'static>(
         )
     })
 }
+
+pub fn implement_locked_pointer(
+    surface: &WlSurface,
+    pointer: &WlPointer,
+    constraints: &ZwpPointerConstraintsV1,
+) -> Result<ZwpLockedPointerV1, ()> {
+    constraints.lock_pointer(surface, pointer, None, Lifetime::Persistent.to_raw(), |c| {
+        c.implement_closure(|_, _| (), ())
+    })
+}

src/platform_impl/linux/wayland/window.rs

@@ -38,6 +38,8 @@ pub struct Window {
     need_frame_refresh: Arc<Mutex<bool>>,
     need_refresh: Arc<Mutex<bool>>,
     fullscreen: Arc<Mutex<bool>>,
+    cursor_grab_changed: Arc<Mutex<Option<bool>>>,
+    cursor_visible_changed: Arc<Mutex<Option<bool>>>,
 }
 
 impl Window {
@@ -140,6 +142,8 @@ impl Window {
         let need_frame_refresh = Arc::new(Mutex::new(true));
         let frame = Arc::new(Mutex::new(frame));
         let need_refresh = Arc::new(Mutex::new(true));
+        let cursor_grab_changed = Arc::new(Mutex::new(None));
+        let cursor_visible_changed = Arc::new(Mutex::new(None));
 
         evlp.store.lock().unwrap().windows.push(InternalWindow {
             closed: false,
@@ -148,6 +152,8 @@ impl Window {
             need_refresh: need_refresh.clone(),
             fullscreen: fullscreen.clone(),
             need_frame_refresh: need_frame_refresh.clone(),
+            cursor_grab_changed: cursor_grab_changed.clone(),
+            cursor_visible_changed: cursor_visible_changed.clone(),
             surface: surface.clone(),
             kill_switch: kill_switch.clone(),
             frame: Arc::downgrade(&frame),
@@ -166,6 +172,8 @@ impl Window {
             need_frame_refresh,
             need_refresh,
             fullscreen,
+            cursor_grab_changed,
+            cursor_visible_changed,
         })
     }
 
@@ -297,13 +305,14 @@ impl Window {
     }
 
     #[inline]
-    pub fn set_cursor_visible(&self, _visible: bool) {
-        // TODO: This isn't possible on Wayland yet
+    pub fn set_cursor_visible(&self, visible: bool) {
+        *self.cursor_visible_changed.lock().unwrap() = Some(visible);
     }
 
     #[inline]
-    pub fn set_cursor_grab(&self, _grab: bool) -> Result<(), ExternalError> {
-        Err(ExternalError::NotSupported(NotSupportedError::new()))
+    pub fn set_cursor_grab(&self, grab: bool) -> Result<(), ExternalError> {
+        *self.cursor_grab_changed.lock().unwrap() = Some(grab);
+        Ok(())
     }
 
     #[inline]
@@ -362,6 +371,8 @@ struct InternalWindow {
     need_refresh: Arc<Mutex<bool>>,
     fullscreen: Arc<Mutex<bool>>,
     need_frame_refresh: Arc<Mutex<bool>>,
+    cursor_grab_changed: Arc<Mutex<Option<bool>>>,
+    cursor_visible_changed: Arc<Mutex<Option<bool>>>,
     closed: bool,
     kill_switch: Arc<Mutex<bool>>,
     frame: Weak<Mutex<SWindow<ConceptFrame>>>,
@@ -429,6 +440,9 @@ impl WindowStore {
             bool,
             bool,
             bool,
+            Option<bool>,
+            Option<bool>,
+            &wl_surface::WlSurface,
             WindowId,
             Option<&mut SWindow<ConceptFrame>>,
         ),
@@ -443,6 +457,9 @@ impl WindowStore {
                 ::std::mem::replace(&mut *window.need_refresh.lock().unwrap(), false),
                 ::std::mem::replace(&mut *window.need_frame_refresh.lock().unwrap(), false),
                 window.closed,
+                window.cursor_visible_changed.lock().unwrap().take(),
+                window.cursor_grab_changed.lock().unwrap().take(),
+                &window.surface,
                 make_wid(&window.surface),
                 opt_mutex_lock.as_mut().map(|m| &mut **m),
             );