Update SCTK to 0.11.0

* Update SCTK to 0.11.0

Updates smithay-client-toolkit to 0.11.0. The major highlight
of that updated, is update of wayland-rs to 0.27.0. Switching
to wayland-cursor, instead of using libwayland-cursor. It
also fixes the following bugs:

  - Disabled repeat rate not being handled.
  - Decoration buttons not working after tty switch.
  - Scaling not being applied on output reenable.
  - Crash when `XCURSOR_SIZE` is `0`.
  - Pointer getting created in some cases without pointer capability.
  - On kwin, fix space between window and decorations on startup.
  - Incorrect size event when entering fullscreen when using
    client side decorations.
  - Client side decorations not being hided properly in fullscreen.
  - Size tracking between fullscreen/tiled state changes.
  - Repeat rate triggering multiple times from slow callback handler.
  - Resizable attribute not being applied properly on startup.
  - Not working IME

Besides those fixes it also adds a bunch of missing virtual key codes,
implements proper cursor grabbing, adds right click on decorations
to open application menu, disabled maximize button for non-resizeable
window, and fall back for cursor icon to similar ones, if the requested
is missing.

It also adds new methods to a `Theme` trait, such as:
  - `title_font(&self) -> Option<(String, f32)>` - The font for a title.
  - `title_color(&self, window_active: bool) -> [u8; 4]` - The color of
  the text in the title.

Fixes #1680.
Fixes #1678.
Fixes #1676.
Fixes #1646.
Fixes #1614.
Fixes #1601.
Fixes #1533.
Fixes #1509.
Fixes #952.
Fixes #947.

src/platform_impl/linux/wayland/seat/pointer/data.rs

@@ -0,0 +1,74 @@
+//! Data which is used in pointer callbacks.
+
+use std::cell::{Cell, RefCell};
+use std::rc::Rc;
+
+use sctk::reexports::client::protocol::wl_surface::WlSurface;
+use sctk::reexports::client::Attached;
+use sctk::reexports::protocols::unstable::pointer_constraints::v1::client::zwp_pointer_constraints_v1::{ZwpPointerConstraintsV1};
+use sctk::reexports::protocols::unstable::pointer_constraints::v1::client::zwp_confined_pointer_v1::ZwpConfinedPointerV1;
+
+use crate::event::{ModifiersState, TouchPhase};
+
+/// A data being used by pointer handlers.
+pub(super) struct PointerData {
+    /// Winit's surface the pointer is currently over.
+    pub surface: Option<WlSurface>,
+
+    /// Current modifiers state.
+    ///
+    /// This refers a state of modifiers from `WlKeyboard` on
+    /// the given seat.
+    pub modifiers_state: Rc<RefCell<ModifiersState>>,
+
+    /// Pointer constraints.
+    pub pointer_constraints: Option<Attached<ZwpPointerConstraintsV1>>,
+
+    pub confined_pointer: Rc<RefCell<Option<ZwpConfinedPointerV1>>>,
+
+    /// A latest event serial.
+    pub latest_serial: Rc<Cell<u32>>,
+
+    /// The currently accumulated axis data on a pointer.
+    pub axis_data: AxisData,
+}
+
+impl PointerData {
+    pub fn new(
+        confined_pointer: Rc<RefCell<Option<ZwpConfinedPointerV1>>>,
+        pointer_constraints: Option<Attached<ZwpPointerConstraintsV1>>,
+        modifiers_state: Rc<RefCell<ModifiersState>>,
+    ) -> Self {
+        Self {
+            surface: None,
+            latest_serial: Rc::new(Cell::new(0)),
+            confined_pointer,
+            modifiers_state,
+            pointer_constraints,
+            axis_data: AxisData::new(),
+        }
+    }
+}
+
+/// Axis data.
+#[derive(Clone, Copy)]
+pub(super) struct AxisData {
+    /// Current state of the axis.
+    pub axis_state: TouchPhase,
+
+    /// A buffer for `PixelDelta` event.
+    pub axis_buffer: Option<(f32, f32)>,
+
+    /// A buffer for `LineDelta` event.
+    pub axis_discrete_buffer: Option<(f32, f32)>,
+}
+
+impl AxisData {
+    pub fn new() -> Self {
+        Self {
+            axis_state: TouchPhase::Ended,
+            axis_buffer: None,
+            axis_discrete_buffer: None,
+        }
+    }
+}

src/platform_impl/linux/wayland/seat/pointer/handlers.rs

@@ -0,0 +1,297 @@
+//! Handlers for the pointers we're using.
+
+use std::cell::RefCell;
+use std::rc::Rc;
+
+use sctk::reexports::client::protocol::wl_pointer::{self, Event as PointerEvent};
+use sctk::reexports::protocols::unstable::relative_pointer::v1::client::zwp_relative_pointer_v1::Event as RelativePointerEvent;
+
+use sctk::seat::pointer::ThemedPointer;
+
+use crate::dpi::LogicalPosition;
+use crate::event::{
+    DeviceEvent, ElementState, MouseButton, MouseScrollDelta, TouchPhase, WindowEvent,
+};
+use crate::platform_impl::wayland::event_loop::WinitState;
+use crate::platform_impl::wayland::{self, DeviceId};
+
+use super::{PointerData, WinitPointer};
+
+#[inline]
+pub(super) fn handle_pointer(
+    pointer: ThemedPointer,
+    event: PointerEvent,
+    pointer_data: &Rc<RefCell<PointerData>>,
+    winit_state: &mut WinitState,
+) {
+    let event_sink = &mut winit_state.event_sink;
+    let mut pointer_data = pointer_data.borrow_mut();
+    match event {
+        PointerEvent::Enter {
+            surface,
+            surface_x,
+            surface_y,
+            serial,
+            ..
+        } => {
+            pointer_data.latest_serial.replace(serial);
+
+            let window_id = wayland::make_wid(&surface);
+            if !winit_state.window_map.contains_key(&window_id) {
+                return;
+            }
+            let window_handle = match winit_state.window_map.get_mut(&window_id) {
+                Some(window_handle) => window_handle,
+                None => return,
+            };
+
+            let scale_factor = sctk::get_surface_scale_factor(&surface) as f64;
+            pointer_data.surface = Some(surface);
+
+            // Notify window that pointer entered the surface.
+            let winit_pointer = WinitPointer {
+                pointer,
+                confined_pointer: Rc::downgrade(&pointer_data.confined_pointer),
+                pointer_constraints: pointer_data.pointer_constraints.clone(),
+                latest_serial: pointer_data.latest_serial.clone(),
+            };
+            window_handle.pointer_entered(winit_pointer);
+
+            event_sink.push_window_event(
+                WindowEvent::CursorEntered {
+                    device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(
+                        DeviceId,
+                    )),
+                },
+                window_id,
+            );
+
+            let position = LogicalPosition::new(surface_x, surface_y).to_physical(scale_factor);
+
+            event_sink.push_window_event(
+                WindowEvent::CursorMoved {
+                    device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(
+                        DeviceId,
+                    )),
+                    position,
+                    modifiers: *pointer_data.modifiers_state.borrow(),
+                },
+                window_id,
+            );
+        }
+        PointerEvent::Leave { surface, serial } => {
+            pointer_data.surface = None;
+            pointer_data.latest_serial.replace(serial);
+
+            let window_id = wayland::make_wid(&surface);
+
+            let window_handle = match winit_state.window_map.get_mut(&window_id) {
+                Some(window_handle) => window_handle,
+                None => return,
+            };
+
+            // Notify a window that pointer is no longer observing it.
+            let winit_pointer = WinitPointer {
+                pointer,
+                confined_pointer: Rc::downgrade(&pointer_data.confined_pointer),
+                pointer_constraints: pointer_data.pointer_constraints.clone(),
+                latest_serial: pointer_data.latest_serial.clone(),
+            };
+            window_handle.pointer_left(winit_pointer);
+
+            event_sink.push_window_event(
+                WindowEvent::CursorLeft {
+                    device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(
+                        DeviceId,
+                    )),
+                },
+                window_id,
+            );
+        }
+        PointerEvent::Motion {
+            surface_x,
+            surface_y,
+            ..
+        } => {
+            let surface = match pointer_data.surface.as_ref() {
+                Some(surface) => surface,
+                None => return,
+            };
+
+            let window_id = wayland::make_wid(surface);
+
+            let scale_factor = sctk::get_surface_scale_factor(&surface) as f64;
+            let position = LogicalPosition::new(surface_x, surface_y).to_physical(scale_factor);
+
+            event_sink.push_window_event(
+                WindowEvent::CursorMoved {
+                    device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(
+                        DeviceId,
+                    )),
+                    position,
+                    modifiers: *pointer_data.modifiers_state.borrow(),
+                },
+                window_id,
+            );
+        }
+        PointerEvent::Button {
+            button,
+            state,
+            serial,
+            ..
+        } => {
+            pointer_data.latest_serial.replace(serial);
+            let window_id = match pointer_data.surface.as_ref().map(wayland::make_wid) {
+                Some(window_id) => window_id,
+                None => return,
+            };
+
+            let state = match state {
+                wl_pointer::ButtonState::Pressed => ElementState::Pressed,
+                wl_pointer::ButtonState::Released => ElementState::Released,
+                _ => unreachable!(),
+            };
+
+            let button = match button {
+                0x110 => MouseButton::Left,
+                0x111 => MouseButton::Right,
+                0x112 => MouseButton::Middle,
+                // TODO - figure out the translation.
+                _ => return,
+            };
+
+            event_sink.push_window_event(
+                WindowEvent::MouseInput {
+                    device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(
+                        DeviceId,
+                    )),
+                    state,
+                    button,
+                    modifiers: *pointer_data.modifiers_state.borrow(),
+                },
+                window_id,
+            );
+        }
+        PointerEvent::Axis { axis, value, .. } => {
+            let surface = match pointer_data.surface.as_ref() {
+                Some(surface) => surface,
+                None => return,
+            };
+
+            let window_id = wayland::make_wid(&surface);
+
+            if pointer.as_ref().version() < 5 {
+                let (mut x, mut y) = (0.0, 0.0);
+
+                // Old seat compatibility.
+                match axis {
+                    // Wayland vertical sign convention is the inverse of winit.
+                    wl_pointer::Axis::VerticalScroll => y -= value as f32,
+                    wl_pointer::Axis::HorizontalScroll => x += value as f32,
+                    _ => unreachable!(),
+                }
+
+                let scale_factor = sctk::get_surface_scale_factor(&surface) as f64;
+                let delta = LogicalPosition::new(x as f64, y as f64).to_physical(scale_factor);
+
+                event_sink.push_window_event(
+                    WindowEvent::MouseWheel {
+                        device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(
+                            DeviceId,
+                        )),
+                        delta: MouseScrollDelta::PixelDelta(delta),
+                        phase: TouchPhase::Moved,
+                        modifiers: *pointer_data.modifiers_state.borrow(),
+                    },
+                    window_id,
+                );
+            } else {
+                let (mut x, mut y) = pointer_data.axis_data.axis_buffer.unwrap_or((0.0, 0.0));
+                match axis {
+                    // Wayland vertical sign convention is the inverse of winit.
+                    wl_pointer::Axis::VerticalScroll => y -= value as f32,
+                    wl_pointer::Axis::HorizontalScroll => x += value as f32,
+                    _ => unreachable!(),
+                }
+
+                pointer_data.axis_data.axis_buffer = Some((x, y));
+
+                pointer_data.axis_data.axis_state = match pointer_data.axis_data.axis_state {
+                    TouchPhase::Started | TouchPhase::Moved => TouchPhase::Moved,
+                    _ => TouchPhase::Started,
+                }
+            }
+        }
+        PointerEvent::AxisDiscrete { axis, discrete } => {
+            let (mut x, mut y) = pointer_data
+                .axis_data
+                .axis_discrete_buffer
+                .unwrap_or((0., 0.));
+
+            match axis {
+                // Wayland vertical sign convention is the inverse of winit.
+                wl_pointer::Axis::VerticalScroll => y -= discrete as f32,
+                wl_pointer::Axis::HorizontalScroll => x += discrete as f32,
+                _ => unreachable!(),
+            }
+
+            pointer_data.axis_data.axis_discrete_buffer = Some((x, y));
+
+            pointer_data.axis_data.axis_state = match pointer_data.axis_data.axis_state {
+                TouchPhase::Started | TouchPhase::Moved => TouchPhase::Moved,
+                _ => TouchPhase::Started,
+            }
+        }
+        PointerEvent::AxisSource { .. } => (),
+        PointerEvent::AxisStop { .. } => {
+            pointer_data.axis_data.axis_state = TouchPhase::Ended;
+        }
+        PointerEvent::Frame => {
+            let axis_buffer = pointer_data.axis_data.axis_buffer.take();
+            let axis_discrete_buffer = pointer_data.axis_data.axis_discrete_buffer.take();
+
+            let surface = match pointer_data.surface.as_ref() {
+                Some(surface) => surface,
+                None => return,
+            };
+            let window_id = wayland::make_wid(&surface);
+
+            let window_event = if let Some((x, y)) = axis_discrete_buffer {
+                WindowEvent::MouseWheel {
+                    device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(
+                        DeviceId,
+                    )),
+                    delta: MouseScrollDelta::LineDelta(x, y),
+                    phase: pointer_data.axis_data.axis_state,
+                    modifiers: *pointer_data.modifiers_state.borrow(),
+                }
+            } else if let Some((x, y)) = axis_buffer {
+                let scale_factor = sctk::get_surface_scale_factor(&surface) as f64;
+                let delta = LogicalPosition::new(x, y).to_physical(scale_factor);
+
+                WindowEvent::MouseWheel {
+                    device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(
+                        DeviceId,
+                    )),
+                    delta: MouseScrollDelta::PixelDelta(delta),
+                    phase: pointer_data.axis_data.axis_state,
+                    modifiers: *pointer_data.modifiers_state.borrow(),
+                }
+            } else {
+                return;
+            };
+
+            event_sink.push_window_event(window_event, window_id);
+        }
+        _ => (),
+    }
+}
+
+#[inline]
+pub(super) fn handle_relative_pointer(event: RelativePointerEvent, winit_state: &mut WinitState) {
+    if let RelativePointerEvent::RelativeMotion { dx, dy, .. } = event {
+        winit_state
+            .event_sink
+            .push_device_event(DeviceEvent::MouseMotion { delta: (dx, dy) }, DeviceId)
+    }
+}

src/platform_impl/linux/wayland/seat/pointer/mod.rs

@@ -0,0 +1,242 @@
+//! All pointer related handling.
+
+use std::cell::{Cell, RefCell};
+use std::rc::{Rc, Weak};
+
+use sctk::reexports::client::protocol::wl_pointer::WlPointer;
+use sctk::reexports::client::protocol::wl_seat::WlSeat;
+use sctk::reexports::client::protocol::wl_surface::WlSurface;
+use sctk::reexports::client::Attached;
+use sctk::reexports::protocols::unstable::relative_pointer::v1::client::zwp_relative_pointer_manager_v1::ZwpRelativePointerManagerV1;
+use sctk::reexports::protocols::unstable::relative_pointer::v1::client::zwp_relative_pointer_v1::ZwpRelativePointerV1;
+use sctk::reexports::protocols::unstable::pointer_constraints::v1::client::zwp_pointer_constraints_v1::{ZwpPointerConstraintsV1, Lifetime};
+use sctk::reexports::protocols::unstable::pointer_constraints::v1::client::zwp_confined_pointer_v1::ZwpConfinedPointerV1;
+
+use sctk::seat::pointer::{ThemeManager, ThemedPointer};
+
+use crate::event::ModifiersState;
+use crate::platform_impl::wayland::event_loop::WinitState;
+use crate::window::CursorIcon;
+
+mod data;
+mod handlers;
+
+use data::PointerData;
+
+/// A proxy to Wayland pointer, which serves requests from a `WindowHandle`.
+pub struct WinitPointer {
+    pointer: ThemedPointer,
+
+    /// Create confined pointers.
+    pointer_constraints: Option<Attached<ZwpPointerConstraintsV1>>,
+
+    /// Cursor to handle confine requests.
+    confined_pointer: Weak<RefCell<Option<ZwpConfinedPointerV1>>>,
+
+    /// Latest observed serial in pointer events.
+    latest_serial: Rc<Cell<u32>>,
+}
+
+impl PartialEq for WinitPointer {
+    fn eq(&self, other: &Self) -> bool {
+        *self.pointer == *other.pointer
+    }
+}
+
+impl Eq for WinitPointer {}
+
+impl WinitPointer {
+    /// Set the cursor icon.
+    ///
+    /// Providing `None` will hide the cursor.
+    pub fn set_cursor(&self, cursor_icon: Option<CursorIcon>) {
+        let cursor_icon = match cursor_icon {
+            Some(cursor_icon) => cursor_icon,
+            None => {
+                // Hide the cursor.
+                (*self.pointer).set_cursor(self.latest_serial.get(), None, 0, 0);
+                return;
+            }
+        };
+
+        let cursors: &[&str] = match cursor_icon {
+            CursorIcon::Alias => &["link"],
+            CursorIcon::Arrow => &["arrow"],
+            CursorIcon::Cell => &["plus"],
+            CursorIcon::Copy => &["copy"],
+            CursorIcon::Crosshair => &["crosshair"],
+            CursorIcon::Default => &["left_ptr"],
+            CursorIcon::Hand => &["hand"],
+            CursorIcon::Help => &["question_arrow"],
+            CursorIcon::Move => &["move"],
+            CursorIcon::Grab => &["openhand", "grab"],
+            CursorIcon::Grabbing => &["closedhand", "grabbing"],
+            CursorIcon::Progress => &["progress"],
+            CursorIcon::AllScroll => &["all-scroll"],
+            CursorIcon::ContextMenu => &["context-menu"],
+
+            CursorIcon::NoDrop => &["no-drop", "circle"],
+            CursorIcon::NotAllowed => &["crossed_circle"],
+
+            // Resize cursors
+            CursorIcon::EResize => &["right_side"],
+            CursorIcon::NResize => &["top_side"],
+            CursorIcon::NeResize => &["top_right_corner"],
+            CursorIcon::NwResize => &["top_left_corner"],
+            CursorIcon::SResize => &["bottom_side"],
+            CursorIcon::SeResize => &["bottom_right_corner"],
+            CursorIcon::SwResize => &["bottom_left_corner"],
+            CursorIcon::WResize => &["left_side"],
+            CursorIcon::EwResize => &["h_double_arrow"],
+            CursorIcon::NsResize => &["v_double_arrow"],
+            CursorIcon::NwseResize => &["bd_double_arrow", "size_bdiag"],
+            CursorIcon::NeswResize => &["fd_double_arrow", "size_fdiag"],
+            CursorIcon::ColResize => &["split_h", "h_double_arrow"],
+            CursorIcon::RowResize => &["split_v", "v_double_arrow"],
+            CursorIcon::Text => &["text", "xterm"],
+            CursorIcon::VerticalText => &["vertical-text"],
+
+            CursorIcon::Wait => &["watch"],
+
+            CursorIcon::ZoomIn => &["zoom-in"],
+            CursorIcon::ZoomOut => &["zoom-out"],
+        };
+
+        let serial = Some(self.latest_serial.get());
+        for cursor in cursors {
+            if self.pointer.set_cursor(cursor, serial).is_ok() {
+                break;
+            }
+        }
+    }
+
+    /// Confine the pointer to a surface.
+    pub fn confine(&self, surface: &WlSurface) {
+        let pointer_constraints = match &self.pointer_constraints {
+            Some(pointer_constraints) => pointer_constraints,
+            None => return,
+        };
+
+        let confined_pointer = match self.confined_pointer.upgrade() {
+            Some(confined_pointer) => confined_pointer,
+            // A pointer is gone.
+            None => return,
+        };
+
+        *confined_pointer.borrow_mut() = Some(init_confined_pointer(
+            &pointer_constraints,
+            &surface,
+            &*self.pointer,
+        ));
+    }
+
+    /// Tries to unconfine the pointer if the current pointer is confined.
+    pub fn unconfine(&self) {
+        let confined_pointer = match self.confined_pointer.upgrade() {
+            Some(confined_pointer) => confined_pointer,
+            // A pointer is gone.
+            None => return,
+        };
+
+        let mut confined_pointer = confined_pointer.borrow_mut();
+
+        if let Some(confined_pointer) = confined_pointer.take() {
+            confined_pointer.destroy();
+        }
+    }
+}
+
+/// A pointer wrapper for easy releasing and managing pointers.
+pub(super) struct Pointers {
+    /// A pointer itself.
+    pointer: ThemedPointer,
+
+    /// A relative pointer handler.
+    relative_pointer: Option<ZwpRelativePointerV1>,
+
+    /// Confined pointer.
+    confined_pointer: Rc<RefCell<Option<ZwpConfinedPointerV1>>>,
+}
+
+impl Pointers {
+    pub(super) fn new(
+        seat: &Attached<WlSeat>,
+        theme_manager: &ThemeManager,
+        relative_pointer_manager: &Option<Attached<ZwpRelativePointerManagerV1>>,
+        pointer_constraints: &Option<Attached<ZwpPointerConstraintsV1>>,
+        modifiers_state: Rc<RefCell<ModifiersState>>,
+    ) -> Self {
+        let confined_pointer = Rc::new(RefCell::new(None));
+        let pointer_data = Rc::new(RefCell::new(PointerData::new(
+            confined_pointer.clone(),
+            pointer_constraints.clone(),
+            modifiers_state,
+        )));
+        let pointer = theme_manager.theme_pointer_with_impl(
+            seat,
+            move |event, pointer, mut dispatch_data| {
+                let winit_state = dispatch_data.get::<WinitState>().unwrap();
+                handlers::handle_pointer(pointer, event, &pointer_data, winit_state);
+            },
+        );
+
+        // Setup relative_pointer if it's available.
+        let relative_pointer = match relative_pointer_manager.as_ref() {
+            Some(relative_pointer_manager) => {
+                Some(init_relative_pointer(&relative_pointer_manager, &*pointer))
+            }
+            None => None,
+        };
+
+        Self {
+            pointer,
+            relative_pointer,
+            confined_pointer,
+        }
+    }
+}
+
+impl Drop for Pointers {
+    fn drop(&mut self) {
+        // Drop relative pointer.
+        if let Some(relative_pointer) = self.relative_pointer.take() {
+            relative_pointer.destroy();
+        }
+
+        // Drop confined pointer.
+        if let Some(confined_pointer) = self.confined_pointer.borrow_mut().take() {
+            confined_pointer.destroy();
+        }
+
+        // Drop the pointer itself in case it's possible.
+        if self.pointer.as_ref().version() >= 3 {
+            self.pointer.release();
+        }
+    }
+}
+
+pub(super) fn init_relative_pointer(
+    relative_pointer_manager: &ZwpRelativePointerManagerV1,
+    pointer: &WlPointer,
+) -> ZwpRelativePointerV1 {
+    let relative_pointer = relative_pointer_manager.get_relative_pointer(&*pointer);
+    relative_pointer.quick_assign(move |_, event, mut dispatch_data| {
+        let winit_state = dispatch_data.get::<WinitState>().unwrap();
+        handlers::handle_relative_pointer(event, winit_state);
+    });
+
+    relative_pointer.detach()
+}
+
+pub(super) fn init_confined_pointer(
+    pointer_constraints: &Attached<ZwpPointerConstraintsV1>,
+    surface: &WlSurface,
+    pointer: &WlPointer,
+) -> ZwpConfinedPointerV1 {
+    let confined_pointer =
+        pointer_constraints.confine_pointer(surface, pointer, None, Lifetime::Persistent.to_raw());
+
+    confined_pointer.quick_assign(move |_, _, _| {});
+
+    confined_pointer.detach()
+}