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/text_input/handlers.rs

@@ -0,0 +1,78 @@
+//! Handling of IME events.
+
+use sctk::reexports::client::Main;
+use sctk::reexports::protocols::unstable::text_input::v3::client::zwp_text_input_v3::{
+    Event as TextInputEvent, ZwpTextInputV3,
+};
+
+use crate::event::WindowEvent;
+use crate::platform_impl::wayland;
+use crate::platform_impl::wayland::event_loop::WinitState;
+
+use super::{TextInputHandler, TextInputInner};
+
+#[inline]
+pub(super) fn handle_text_input(
+    text_input: Main<ZwpTextInputV3>,
+    inner: &mut TextInputInner,
+    event: TextInputEvent,
+    winit_state: &mut WinitState,
+) {
+    let event_sink = &mut winit_state.event_sink;
+    match event {
+        TextInputEvent::Enter { surface } => {
+            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,
+            };
+            inner.target_window_id = Some(window_id);
+
+            // Enable text input on that surface.
+            text_input.enable();
+            text_input.commit();
+
+            // Notify a window we're currently over about text input handler.
+            let text_input_handler = TextInputHandler {
+                text_input: text_input.detach(),
+            };
+            window_handle.text_input_entered(text_input_handler);
+        }
+        TextInputEvent::Leave { surface } => {
+            // Always issue a disable.
+            text_input.disable();
+            text_input.commit();
+
+            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,
+            };
+
+            inner.target_window_id = None;
+
+            // Remove text input handler from the window we're leaving.
+            let text_input_handler = TextInputHandler {
+                text_input: text_input.detach(),
+            };
+            window_handle.text_input_left(text_input_handler);
+        }
+        TextInputEvent::CommitString { text } => {
+            // Update currenly commited string.
+            inner.commit_string = text;
+        }
+        TextInputEvent::Done { .. } => {
+            let (window_id, text) = match (inner.target_window_id, inner.commit_string.take()) {
+                (Some(window_id), Some(text)) => (window_id, text),
+                _ => return,
+            };
+
+            for ch in text.chars() {
+                event_sink.push_window_event(WindowEvent::ReceivedCharacter(ch), window_id);
+            }
+        }
+        _ => (),
+    }
+}

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

@@ -0,0 +1,66 @@
+use sctk::reexports::client::protocol::wl_seat::WlSeat;
+use sctk::reexports::client::Attached;
+use sctk::reexports::protocols::unstable::text_input::v3::client::zwp_text_input_manager_v3::ZwpTextInputManagerV3;
+use sctk::reexports::protocols::unstable::text_input::v3::client::zwp_text_input_v3::ZwpTextInputV3;
+
+use crate::platform_impl::wayland::event_loop::WinitState;
+use crate::platform_impl::wayland::WindowId;
+
+mod handlers;
+
+/// A handler for text input that we're advertising for `WindowHandle`.
+#[derive(Eq, PartialEq)]
+pub struct TextInputHandler {
+    text_input: ZwpTextInputV3,
+}
+
+impl TextInputHandler {
+    #[inline]
+    pub fn set_ime_position(&self, x: i32, y: i32) {
+        self.text_input.set_cursor_rectangle(x, y, 0, 0);
+        self.text_input.commit();
+    }
+}
+
+/// A wrapper around text input to automatically destroy the object on `Drop`.
+pub struct TextInput {
+    text_input: Attached<ZwpTextInputV3>,
+}
+
+impl TextInput {
+    pub fn new(seat: &Attached<WlSeat>, text_input_manager: &ZwpTextInputManagerV3) -> Self {
+        let text_input = text_input_manager.get_text_input(seat);
+        let mut text_input_inner = TextInputInner::new();
+        text_input.quick_assign(move |text_input, event, mut dispatch_data| {
+            let winit_state = dispatch_data.get::<WinitState>().unwrap();
+            handlers::handle_text_input(text_input, &mut text_input_inner, event, winit_state);
+        });
+
+        let text_input: Attached<ZwpTextInputV3> = text_input.into();
+
+        Self { text_input }
+    }
+}
+
+impl Drop for TextInput {
+    fn drop(&mut self) {
+        self.text_input.destroy();
+    }
+}
+
+struct TextInputInner {
+    /// Currently focused surface.
+    target_window_id: Option<WindowId>,
+
+    /// Pending string to commit.
+    commit_string: Option<String>,
+}
+
+impl TextInputInner {
+    fn new() -> Self {
+        Self {
+            target_window_id: None,
+            commit_string: None,
+        }
+    }
+}