Update wayland-client version to 0.30

GuillaumeGomez · GuillaumeGomez · commit e9db20abf2b3 · 2023-02-06T21:33:55.000+01:00
diff --git a/gdkwayland/Cargo.toml b/gdkwayland/Cargo.toml
@@ -25,7 +25,8 @@ ffi = { path = "./sys", package = "gdkwayland-sys" }
 gdk = { path = "../gdk" }
 glib = { git = "https://github.com/gtk-rs/gtk-rs-core" }
 libc = "0.2"
-wayland-client = { version = "0.29", features = ["use_system_lib"] }
+wayland-client = "0.30"
+wayland-backend = { version = "0.1", features = ["client_system"] }
 
 [dev-dependencies]
 gir-format-check = "^0.1"
diff --git a/gdkwayland/src/wayland_device.rs b/gdkwayland/src/wayland_device.rs
@@ -1,10 +1,11 @@
 // Take a look at the license at the top of the repository in the LICENSE file.
 
+use gdk::prelude::*;
 use gdk::DevicePadFeature;
 use glib::translate::*;
 
+use wayland_client::backend::ObjectId;
 use wayland_client::protocol::{wl_keyboard::WlKeyboard, wl_pointer::WlPointer, wl_seat::WlSeat};
-use wayland_client::sys::client::wl_proxy;
 use wayland_client::Proxy;
 
 glib::wrapper! {
@@ -31,28 +32,53 @@ impl WaylandDevice {
 
     #[doc(alias = "gdk_wayland_device_get_wl_seat")]
     #[doc(alias = "get_wl_seat")]
-    pub fn wl_seat(&self) -> WlSeat {
+    pub fn wl_seat(&self) -> Option<WlSeat> {
         unsafe {
-            let ptr = ffi::gdk_wayland_device_get_wl_seat(self.to_glib_none().0);
-            Proxy::from_c_ptr(ptr as *mut wl_proxy).into()
+            let seat_ptr = ffi::gdk_wayland_device_get_wl_seat(self.to_glib_none().0);
+            if seat_ptr.is_null() {
+                None
+            } else {
+                let display = self.display().unsafe_cast::<crate::WaylandDisplay>();
+                let cnx = display.connection();
+                let id = ObjectId::from_ptr(WlSeat::interface(), seat_ptr as *mut _).unwrap();
+
+                WlSeat::from_id(&cnx, id).ok()
+            }
         }
     }
 
     #[doc(alias = "gdk_wayland_device_get_wl_keyboard")]
     #[doc(alias = "get_wl_keyboard")]
-    pub fn wl_keyboard(&self) -> WlKeyboard {
+    pub fn wl_keyboard(&self) -> Option<WlKeyboard> {
+        let display = self.display().downcast::<crate::WaylandDisplay>().unwrap();
         unsafe {
-            let ptr = ffi::gdk_wayland_device_get_wl_keyboard(self.to_glib_none().0);
-            Proxy::from_c_ptr(ptr as *mut wl_proxy).into()
+            let keyboard_ptr = ffi::gdk_wayland_device_get_wl_keyboard(self.to_glib_none().0);
+            if keyboard_ptr.is_null() {
+                None
+            } else {
+                let cnx = display.connection();
+                let id =
+                    ObjectId::from_ptr(WlKeyboard::interface(), keyboard_ptr as *mut _).unwrap();
+
+                WlKeyboard::from_id(&cnx, id).ok()
+            }
         }
     }
 
     #[doc(alias = "gdk_wayland_device_get_wl_pointer")]
     #[doc(alias = "get_wl_pointer")]
-    pub fn wl_pointer(&self) -> WlPointer {
+    pub fn wl_pointer(&self) -> Option<WlPointer> {
+        let display = self.display().downcast::<crate::WaylandDisplay>().unwrap();
         unsafe {
-            let ptr = ffi::gdk_wayland_device_get_wl_pointer(self.to_glib_none().0);
-            Proxy::from_c_ptr(ptr as *mut wl_proxy).into()
+            let pointer_ptr = ffi::gdk_wayland_device_get_wl_pointer(self.to_glib_none().0);
+            if pointer_ptr.is_null() {
+                None
+            } else {
+                let cnx = display.connection();
+                let id = ObjectId::from_ptr(WlPointer::interface(), pointer_ptr as *mut _).unwrap();
+
+                WlPointer::from_id(&cnx, id).ok()
+            }
         }
     }
 }
diff --git a/gdkwayland/src/wayland_display.rs b/gdkwayland/src/wayland_display.rs
@@ -1,11 +1,16 @@
 // Take a look at the license at the top of the repository in the LICENSE file.
 
+use glib::once_cell::sync::Lazy;
 use glib::translate::*;
+use glib::{ObjectExt, Quark};
 
+use wayland_client::backend::ObjectId;
 use wayland_client::protocol::{wl_compositor::WlCompositor, wl_display::WlDisplay};
-use wayland_client::sys::client::wl_proxy;
 use wayland_client::Proxy;
 
+static WAYLAND_DISPLAY_CONNECTION_QUARK: Lazy<Quark> =
+    Lazy::new(|| Quark::from_str("gtk-rs-wayland-display-connection-quark"));
+
 glib::wrapper! {
     #[doc(alias = "GdkWaylandDisplay")]
     pub struct WaylandDisplay(Object<ffi::GdkWaylandDisplay>) @extends gdk::Display;
@@ -18,19 +23,34 @@ glib::wrapper! {
 impl WaylandDisplay {
     #[doc(alias = "gdk_wayland_display_get_wl_compositor")]
     #[doc(alias = "get_wl_compositor")]
-    pub fn wl_compositor(&self) -> WlCompositor {
+    pub fn wl_compositor(&self) -> Option<WlCompositor> {
         unsafe {
-            let ptr = ffi::gdk_wayland_display_get_wl_compositor(self.to_glib_none().0);
-            Proxy::from_c_ptr(ptr as *mut wl_proxy).into()
+            let compositor_ptr = ffi::gdk_wayland_display_get_wl_compositor(self.to_glib_none().0);
+            if compositor_ptr.is_null() {
+                None
+            } else {
+                let cnx = self.connection();
+                let id = ObjectId::from_ptr(WlCompositor::interface(), compositor_ptr as *mut _)
+                    .unwrap();
+
+                WlCompositor::from_id(&cnx, id).ok()
+            }
         }
     }
 
     #[doc(alias = "gdk_wayland_display_get_wl_display")]
     #[doc(alias = "get_wl_display")]
-    pub fn wl_display(&self) -> WlDisplay {
+    pub fn wl_display(&self) -> Option<WlDisplay> {
         unsafe {
-            let ptr = ffi::gdk_wayland_display_get_wl_display(self.to_glib_none().0);
-            Proxy::from_c_ptr(ptr as *mut wl_proxy).into()
+            let display_ptr = ffi::gdk_wayland_display_get_wl_display(self.to_glib_none().0);
+            if display_ptr.is_null() {
+                None
+            } else {
+                let cnx = self.connection();
+                let id = ObjectId::from_ptr(WlDisplay::interface(), display_ptr as *mut _).unwrap();
+
+                WlDisplay::from_id(&cnx, id).ok()
+            }
         }
     }
 
@@ -69,4 +89,25 @@ impl WaylandDisplay {
             ))
         }
     }
+
+    pub(crate) fn connection(&self) -> wayland_client::Connection {
+        unsafe {
+            match self
+                .qdata::<Option<wayland_client::Connection>>(*WAYLAND_DISPLAY_CONNECTION_QUARK)
+            {
+                Some(conn) => conn.as_ref().clone().unwrap(),
+                None => {
+                    let display_ptr =
+                        ffi::gdk_wayland_display_get_wl_display(self.to_glib_none().0);
+                    let backend = wayland_backend::sys::client::Backend::from_foreign_display(
+                        display_ptr as *mut _,
+                    );
+                    let conn = wayland_client::Connection::from_backend(backend);
+                    self.set_qdata(*WAYLAND_DISPLAY_CONNECTION_QUARK, conn.clone());
+
+                    conn
+                }
+            }
+        }
+    }
 }
diff --git a/gdkwayland/src/wayland_monitor.rs b/gdkwayland/src/wayland_monitor.rs
@@ -1,8 +1,10 @@
 // Take a look at the license at the top of the repository in the LICENSE file.
 
+use gdk::prelude::*;
 use glib::translate::ToGlibPtr;
+
+use wayland_client::backend::ObjectId;
 use wayland_client::protocol::wl_output::WlOutput;
-use wayland_client::sys::client::wl_proxy;
 use wayland_client::Proxy;
 
 glib::wrapper! {
@@ -17,10 +19,18 @@ glib::wrapper! {
 impl WaylandMonitor {
     #[doc(alias = "gdk_wayland_monitor_get_wl_output")]
     #[doc(alias = "get_wl_output")]
-    pub fn wl_output(&self) -> WlOutput {
+    pub fn wl_output(&self) -> Option<WlOutput> {
         unsafe {
-            let ptr = ffi::gdk_wayland_monitor_get_wl_output(self.to_glib_none().0);
-            Proxy::from_c_ptr(ptr as *mut wl_proxy).into()
+            let output_ptr = ffi::gdk_wayland_monitor_get_wl_output(self.to_glib_none().0);
+            if output_ptr.is_null() {
+                None
+            } else {
+                let display = self.display()?.unsafe_cast::<crate::WaylandDisplay>();
+                let cnx = display.connection();
+                let id = ObjectId::from_ptr(WlOutput::interface(), output_ptr as *mut _).unwrap();
+
+                WlOutput::from_id(&cnx, id).ok()
+            }
         }
     }
 }
diff --git a/gdkwayland/src/wayland_seat.rs b/gdkwayland/src/wayland_seat.rs
@@ -1,8 +1,10 @@
 // Take a look at the license at the top of the repository in the LICENSE file.
 
+use gdk::prelude::*;
 use glib::translate::ToGlibPtr;
+
+use wayland_client::backend::ObjectId;
 use wayland_client::protocol::wl_seat::WlSeat;
-use wayland_client::sys::client::wl_proxy;
 use wayland_client::Proxy;
 
 glib::wrapper! {
@@ -17,10 +19,18 @@ glib::wrapper! {
 impl WaylandSeat {
     #[doc(alias = "gdk_wayland_seat_get_wl_seat")]
     #[doc(alias = "get_wl_seat")]
-    pub fn wl_seat(&self) -> WlSeat {
+    pub fn wl_seat(&self) -> Option<WlSeat> {
         unsafe {
-            let ptr = ffi::gdk_wayland_seat_get_wl_seat(self.to_glib_none().0);
-            Proxy::from_c_ptr(ptr as *mut wl_proxy).into()
+            let seat_ptr = ffi::gdk_wayland_seat_get_wl_seat(self.to_glib_none().0);
+            if seat_ptr.is_null() {
+                None
+            } else {
+                let display = self.display()?.unsafe_cast::<crate::WaylandDisplay>();
+                let cnx = display.connection();
+                let id = ObjectId::from_ptr(WlSeat::interface(), seat_ptr as *mut _).unwrap();
+
+                WlSeat::from_id(&cnx, id).ok()
+            }
         }
     }
 }
