WIP update for wayland-rs git

Author: ids1024

Cargo.toml

@@ -95,3 +95,14 @@ wasm-bindgen-futures = "0.4.43"
 wasm-bindgen-test = "0.3"
 web-time = "1"
 web_sys = { package = "web-sys", version = "0.3.70" }
+
+[patch.crates-io]
+wayland-client = { git = "https://github.com/smithay/wayland-rs" }
+wayland-protocols = { git = "https://github.com/smithay/wayland-rs" }
+wayland-protocols-wlr = { git = "https://github.com/smithay/wayland-rs" }
+wayland-protocols-misc = { git = "https://github.com/smithay/wayland-rs" }
+wayland-protocols-plasma = { git = "https://github.com/smithay/wayland-rs" }
+wayland-protocols-experimental = { git = "https://github.com/smithay/wayland-rs" }
+wayland-cursor = { git = "https://github.com/smithay/wayland-rs" }
+wayland-backend = { git = "https://github.com/smithay/wayland-rs" }
+wayland-scanner = { git = "https://github.com/smithay/wayland-rs" }

winit-wayland/Cargo.toml

@@ -35,7 +35,7 @@ libc.workspace = true
 memmap2.workspace = true
 rustix = { workspace = true, features = ["std", "system", "thread", "process", "event", "pipe"] }
 # sctk = { package = "smithay-client-toolkit", version = "0.20.0", default-features = false, features = [
-sctk = { package = "smithay-client-toolkit", git = "https://github.com/ids1024/client-toolkit", branch = "dispatch2", default-features = false, features = [
+sctk = { package = "smithay-client-toolkit", git = "https://github.com/ids1024/client-toolkit", branch = "wayland-update", default-features = false, features = [
     "calloop",
 ] }
 #sctk-adwaita = { version = "0.11.0", default-features = false, optional = true }

winit-wayland/src/event_loop/mod.rs

@@ -716,8 +716,7 @@ impl rwh_06::HasDisplayHandle for OwnedDisplayHandle {
         use sctk::reexports::client::Proxy;
 
         let raw = rwh_06::WaylandDisplayHandle::new({
-            let ptr = self.connection.display().id().as_ptr();
-            std::ptr::NonNull::new(ptr as *mut _).expect("wl_display should never be null")
+            self.connection.display().id().as_ptr().expect("wl_display should never be null").cast()
         });
 
         Ok(unsafe { rwh_06::DisplayHandle::borrow_raw(raw.into()) })

winit-wayland/src/lib.rs

@@ -146,7 +146,7 @@ impl PlatformWindowAttributes for WindowAttributesWayland {
 /// Get the WindowId out of the surface.
 #[inline]
 fn make_wid(surface: &WlSurface) -> WindowId {
-    WindowId::from_raw(surface.id().as_ptr() as usize)
+    WindowId::from_raw(surface.id().as_ptr().map_or(0, |ptr| ptr.as_ptr() as usize))
 }
 
 /// The default routine does floor, but we need round on Wayland.

winit-wayland/src/seat/keyboard/mod.rs

@@ -9,7 +9,7 @@ use sctk::reexports::client::protocol::wl_keyboard::{
     Event as WlKeyboardEvent, KeyState as WlKeyState, KeymapFormat as WlKeymapFormat, WlKeyboard,
 };
 use sctk::reexports::client::protocol::wl_seat::WlSeat;
-use sctk::reexports::client::{Connection, Dispatch, Proxy, QueueHandle, WEnum};
+use sctk::reexports::client::{Connection, Dispatch, Proxy, QueueHandle};
 use tracing::warn;
 use winit_common::xkb::Context;
 use winit_core::event::{ElementState, WindowEvent};
@@ -19,16 +19,16 @@ use crate::WindowId;
 use crate::event_loop::sink::EventSink;
 use crate::state::WinitState;
 
-impl Dispatch<WlKeyboard, KeyboardData, WinitState> for WinitState {
+impl Dispatch<WlKeyboard, WinitState> for KeyboardData {
     fn event(
+        &self,
         state: &mut WinitState,
         wl_keyboard: &WlKeyboard,
         event: <WlKeyboard as Proxy>::Event,
-        data: &KeyboardData,
         _: &Connection,
         _: &QueueHandle<WinitState>,
     ) {
-        let seat_state = match state.seats.get_mut(&data.seat.id()) {
+        let seat_state = match state.seats.get_mut(&self.seat.id()) {
             Some(seat_state) => seat_state,
             None => {
                 warn!("Received keyboard event {event:?} without seat");
@@ -45,19 +45,14 @@ impl Dispatch<WlKeyboard, KeyboardData, WinitState> for WinitState {
 
         match event {
             WlKeyboardEvent::Keymap { format, fd, size } => match format {
-                WEnum::Value(format) => match format {
-                    WlKeymapFormat::NoKeymap => {
-                        warn!("non-xkb compatible keymap")
-                    },
-                    WlKeymapFormat::XkbV1 => {
-                        let context = &mut keyboard_state.xkb_context;
-                        context.set_keymap_from_fd(fd, size as usize);
-                    },
-                    _ => unreachable!(),
+                WlKeymapFormat::NoKeymap => {
+                    warn!("non-xkb compatible keymap")
                 },
-                WEnum::Unknown(value) => {
-                    warn!("unknown keymap format 0x{:x}", value)
+                WlKeymapFormat::XkbV1 => {
+                    let context = &mut keyboard_state.xkb_context;
+                    context.set_keymap_from_fd(fd, size as usize);
                 },
+                _ => warn!("unknown keymap format {:?}", format),
             },
             WlKeyboardEvent::Enter { surface, .. } => {
                 let window_id = crate::make_wid(&surface);
@@ -67,7 +62,7 @@ impl Dispatch<WlKeyboard, KeyboardData, WinitState> for WinitState {
                     Some(window) => {
                         let mut window = window.lock().unwrap();
                         let was_unfocused = !window.has_focus();
-                        window.add_seat_focus(data.seat.id());
+                        window.add_seat_focus(self.seat.id());
                         was_unfocused
                     },
                     None => return,
@@ -79,7 +74,7 @@ impl Dispatch<WlKeyboard, KeyboardData, WinitState> for WinitState {
                     keyboard_state.loop_handle.remove(token);
                 }
 
-                *data.window_id.lock().unwrap() = Some(window_id);
+                *self.window_id.lock().unwrap() = Some(window_id);
 
                 // The keyboard focus is considered as general focus.
                 if was_unfocused {
@@ -109,15 +104,15 @@ impl Dispatch<WlKeyboard, KeyboardData, WinitState> for WinitState {
                 let focused = match state.windows.get_mut().get(&window_id) {
                     Some(window) => {
                         let mut window = window.lock().unwrap();
-                        window.remove_seat_focus(&data.seat.id());
+                        window.remove_seat_focus(&self.seat.id());
                         window.has_focus()
                     },
                     None => return,
                 };
 
                 // We don't need to update it above, because the next `Enter` will overwrite
                 // anyway.
-                *data.window_id.lock().unwrap() = None;
+                *self.window_id.lock().unwrap() = None;
 
                 if !focused {
                     // Notify that no modifiers are being pressed.
@@ -129,14 +124,14 @@ impl Dispatch<WlKeyboard, KeyboardData, WinitState> for WinitState {
                     state.events_sink.push_window_event(WindowEvent::Focused(false), window_id);
                 }
             },
-            WlKeyboardEvent::Key { key, state: WEnum::Value(key_state), .. }
+            WlKeyboardEvent::Key { key, state: key_state, .. }
                 if matches!(key_state, WlKeyState::Repeated | WlKeyState::Pressed) =>
             {
                 let key = key + 8;
                 key_input(
                     keyboard_state,
                     &mut state.events_sink,
-                    data,
+                    self,
                     key,
                     ElementState::Pressed,
                     key_state == WlKeyState::Repeated,
@@ -204,13 +199,13 @@ impl Dispatch<WlKeyboard, KeyboardData, WinitState> for WinitState {
                     })
                     .ok();
             },
-            WlKeyboardEvent::Key { key, state: WEnum::Value(WlKeyState::Released), .. } => {
+            WlKeyboardEvent::Key { key, state: WlKeyState::Released, .. } => {
                 let key = key + 8;
 
                 key_input(
                     keyboard_state,
                     &mut state.events_sink,
-                    data,
+                    self,
                     key,
                     ElementState::Released,
                     false,
@@ -239,7 +234,7 @@ impl Dispatch<WlKeyboard, KeyboardData, WinitState> for WinitState {
                 seat_state.modifiers = xkb_state.modifiers().into();
 
                 // HACK: part of the workaround from `WlKeyboardEvent::Enter`.
-                let window_id = match *data.window_id.lock().unwrap() {
+                let window_id = match *self.window_id.lock().unwrap() {
                     Some(window_id) => window_id,
                     None => {
                         seat_state.modifiers_pending = true;

winit-wayland/src/seat/pointer/mod.rs

@@ -6,7 +6,6 @@ use std::time::Duration;
 
 use tracing::warn;
 
-use sctk::reexports::client::delegate_dispatch;
 use sctk::reexports::client::protocol::wl_pointer::WlPointer;
 use sctk::reexports::client::protocol::wl_surface::WlSurface;
 use sctk::reexports::client::{Connection, Proxy, QueueHandle, Dispatch};
@@ -408,7 +407,7 @@ impl PointerConstraintsState {
         globals: &GlobalList,
         queue_handle: &QueueHandle<WinitState>,
     ) -> Result<Self, BindError> {
-        let pointer_constraints = globals.bind(queue_handle, 1..=1, GlobalData)?;
+        let pointer_constraints = globals.bind_singleton(queue_handle, 1..=1, GlobalData)?;
         Ok(Self { pointer_constraints })
     }
 }
@@ -421,42 +420,38 @@ impl Deref for PointerConstraintsState {
     }
 }
 
-impl Dispatch<ZwpPointerConstraintsV1, GlobalData, WinitState> for PointerConstraintsState {
+impl Dispatch<ZwpPointerConstraintsV1, WinitState> for GlobalData {
     fn event(
+        &self,
         _state: &mut WinitState,
         _proxy: &ZwpPointerConstraintsV1,
         _event: <ZwpPointerConstraintsV1 as wayland_client::Proxy>::Event,
-        _data: &GlobalData,
         _conn: &Connection,
         _qhandle: &QueueHandle<WinitState>,
     ) {
     }
 }
 
-impl Dispatch<ZwpLockedPointerV1, GlobalData, WinitState> for PointerConstraintsState {
+impl Dispatch<ZwpLockedPointerV1, WinitState> for GlobalData {
     fn event(
+        &self,
         _state: &mut WinitState,
         _proxy: &ZwpLockedPointerV1,
         _event: <ZwpLockedPointerV1 as wayland_client::Proxy>::Event,
-        _data: &GlobalData,
         _conn: &Connection,
         _qhandle: &QueueHandle<WinitState>,
     ) {
     }
 }
 
-impl Dispatch<ZwpConfinedPointerV1, GlobalData, WinitState> for PointerConstraintsState {
+impl Dispatch<ZwpConfinedPointerV1, WinitState> for GlobalData {
     fn event(
+        &self,
         _state: &mut WinitState,
         _proxy: &ZwpConfinedPointerV1,
         _event: <ZwpConfinedPointerV1 as wayland_client::Proxy>::Event,
-        _data: &GlobalData,
         _conn: &Connection,
         _qhandle: &QueueHandle<WinitState>,
     ) {
     }
 }
-
-delegate_dispatch!(WinitState: [ZwpPointerConstraintsV1: GlobalData] => PointerConstraintsState);
-delegate_dispatch!(WinitState: [ZwpLockedPointerV1: GlobalData] => PointerConstraintsState);
-delegate_dispatch!(WinitState: [ZwpConfinedPointerV1: GlobalData] => PointerConstraintsState);

winit-wayland/src/seat/pointer/pointer_gesture.rs

@@ -5,7 +5,7 @@ use dpi::{LogicalPosition, PhysicalPosition};
 use sctk::compositor::SurfaceData;
 use sctk::globals::GlobalData;
 use sctk::reexports::client::globals::{BindError, GlobalList};
-use sctk::reexports::client::{Connection, Dispatch, Proxy, QueueHandle, delegate_dispatch};
+use sctk::reexports::client::{Connection, Dispatch, Proxy, QueueHandle};
 use sctk::reexports::protocols::wp::pointer_gestures::zv1::client::zwp_pointer_gesture_pinch_v1::{
     Event as PinchEvent, ZwpPointerGesturePinchV1,
 };
@@ -30,7 +30,7 @@ impl PointerGesturesState {
         globals: &GlobalList,
         queue_handle: &QueueHandle<WinitState>,
     ) -> Result<Self, BindError> {
-        let pointer_gestures = globals.bind(queue_handle, 3..=3, GlobalData)?;
+        let pointer_gestures = globals.bind_singleton(queue_handle, 3..=3, GlobalData)?;
         Ok(Self { pointer_gestures })
     }
 }
@@ -60,29 +60,29 @@ impl Deref for PointerGesturesState {
     }
 }
 
-impl Dispatch<ZwpPointerGesturesV1, GlobalData, WinitState> for PointerGesturesState {
+impl Dispatch<ZwpPointerGesturesV1, WinitState> for GlobalData {
     fn event(
+        &self,
         _state: &mut WinitState,
         _proxy: &ZwpPointerGesturesV1,
         _event: <ZwpPointerGesturesV1 as wayland_client::Proxy>::Event,
-        _data: &GlobalData,
         _conn: &Connection,
         _qhandle: &QueueHandle<WinitState>,
     ) {
         unreachable!("zwp_pointer_gestures_v1 has no events")
     }
 }
 
-impl Dispatch<ZwpPointerGestureHoldV1, PointerGestureData, WinitState> for PointerGesturesState {
+impl Dispatch<ZwpPointerGestureHoldV1, WinitState> for PointerGestureData {
     fn event(
+        &self,
         state: &mut WinitState,
         _proxy: &ZwpPointerGestureHoldV1,
         event: <ZwpPointerGestureHoldV1 as wayland_client::Proxy>::Event,
-        data: &PointerGestureData,
         _conn: &Connection,
         _qhandle: &QueueHandle<WinitState>,
     ) {
-        let mut pointer_gesture_data = data.inner.lock().unwrap();
+        let mut pointer_gesture_data = self.inner.lock().unwrap();
         let (window_id, phase) = match event {
             HoldEvent::Begin { surface, fingers, .. } => {
                 if fingers < 2 {
@@ -116,16 +116,16 @@ impl Dispatch<ZwpPointerGestureHoldV1, PointerGestureData, WinitState> for Point
     }
 }
 
-impl Dispatch<ZwpPointerGesturePinchV1, PointerGestureData, WinitState> for PointerGesturesState {
+impl Dispatch<ZwpPointerGesturePinchV1, WinitState> for PointerGestureData {
     fn event(
+        &self,
         state: &mut WinitState,
         _proxy: &ZwpPointerGesturePinchV1,
         event: <ZwpPointerGesturePinchV1 as Proxy>::Event,
-        data: &PointerGestureData,
         _conn: &Connection,
         _qhandle: &QueueHandle<WinitState>,
     ) {
-        let mut pointer_gesture_data = data.inner.lock().unwrap();
+        let mut pointer_gesture_data = self.inner.lock().unwrap();
         let (window_id, phase, pan_delta, pinch_delta, rotation_delta) = match event {
             PinchEvent::Begin { surface, fingers, .. } => {
                 // We only support two fingers for now.
@@ -200,7 +200,3 @@ impl Dispatch<ZwpPointerGesturePinchV1, PointerGestureData, WinitState> for Poin
         );
     }
 }
-
-delegate_dispatch!(WinitState: [ZwpPointerGesturesV1: GlobalData] => PointerGesturesState);
-delegate_dispatch!(WinitState: [ZwpPointerGesturePinchV1: PointerGestureData] => PointerGesturesState);
-delegate_dispatch!(WinitState: [ZwpPointerGestureHoldV1: PointerGestureData] => PointerGesturesState);

winit-wayland/src/seat/pointer/relative_pointer.rs

@@ -4,7 +4,7 @@ use std::ops::Deref;
 
 use sctk::reexports::client::globals::{BindError, GlobalList};
 use sctk::reexports::client::{Connection, QueueHandle};
-use sctk::reexports::client::{Dispatch, delegate_dispatch};
+use sctk::reexports::client::{Dispatch};
 use sctk::reexports::protocols::wp::relative_pointer::zv1::{
     client::zwp_relative_pointer_manager_v1::ZwpRelativePointerManagerV1,
     client::zwp_relative_pointer_v1::{self, ZwpRelativePointerV1},
@@ -27,7 +27,7 @@ impl RelativePointerState {
         globals: &GlobalList,
         queue_handle: &QueueHandle<WinitState>,
     ) -> Result<Self, BindError> {
-        let manager = globals.bind(queue_handle, 1..=1, GlobalData)?;
+        let manager = globals.bind_singleton(queue_handle, 1..=1, GlobalData)?;
         Ok(Self { manager })
     }
 }
@@ -40,24 +40,24 @@ impl Deref for RelativePointerState {
     }
 }
 
-impl Dispatch<ZwpRelativePointerManagerV1, GlobalData, WinitState> for RelativePointerState {
+impl Dispatch<ZwpRelativePointerManagerV1, WinitState> for GlobalData {
     fn event(
+        &self,
         _state: &mut WinitState,
         _proxy: &ZwpRelativePointerManagerV1,
         _event: <ZwpRelativePointerManagerV1 as wayland_client::Proxy>::Event,
-        _data: &GlobalData,
         _conn: &Connection,
         _qhandle: &QueueHandle<WinitState>,
     ) {
     }
 }
 
-impl Dispatch<ZwpRelativePointerV1, GlobalData, WinitState> for RelativePointerState {
+impl Dispatch<ZwpRelativePointerV1, WinitState> for GlobalData {
     fn event(
+        &self,
         state: &mut WinitState,
         _proxy: &ZwpRelativePointerV1,
         event: <ZwpRelativePointerV1 as wayland_client::Proxy>::Event,
-        _data: &GlobalData,
         _conn: &Connection,
         _qhandle: &QueueHandle<WinitState>,
     ) {
@@ -72,6 +72,3 @@ impl Dispatch<ZwpRelativePointerV1, GlobalData, WinitState> for RelativePointerS
             .push_device_event(DeviceEvent::PointerMotion { delta: (dx_unaccel, dy_unaccel) });
     }
 }
-
-delegate_dispatch!(WinitState: [ZwpRelativePointerV1: GlobalData] => RelativePointerState);
-delegate_dispatch!(WinitState: [ZwpRelativePointerManagerV1: GlobalData] => RelativePointerState);