Add support for ext-data-control

Since the protocol is more or less exactly the same as wlr-data-control, I
added some wrappers and macros to re-use the same existing code for both
protocols.

Author: YaLTeR

Diff for: Cargo.toml

@@ -38,12 +38,12 @@ thiserror = "2"
 tree_magic_mini = "3.1.6"
 wayland-backend = "0.3.8"
 wayland-client = "0.31.8"
-wayland-protocols = { version = "0.32.6", features = ["client"] }
+wayland-protocols = { version = "0.32.6", features = ["client", "staging"] }
 wayland-protocols-wlr = { version = "0.3.6", features = ["client"] }
 
 [dev-dependencies]
 wayland-server = "0.31.7"
-wayland-protocols = { version = "0.32.6", features = ["server"] }
+wayland-protocols = { version = "0.32.6", features = ["server", "staging"] }
 wayland-protocols-wlr = { version = "0.3.6", features = ["server"] }
 proptest = "1.6.0"
 proptest-derive = "0.5.1"

Diff for: README.md

@@ -15,10 +15,10 @@ please use the appropriate Wayland protocols for interacting with the Wayland cl
 primary selection), for example via the
 [smithay-clipboard](https://crates.io/crates/smithay-clipboard) crate.
 
-The protocol used for clipboard interaction is `data-control` from
-[wlroots](https://github.com/swaywm/wlr-protocols). When using the regular clipboard, the
-compositor must support the first version of the protocol. When using the "primary" clipboard,
-the compositor must support the second version of the protocol (or higher).
+The protocol used for clipboard interaction is `ext-data-control` or `wlr-data-control`. When
+using the regular clipboard, the compositor must support any version of either protocol. When
+using the "primary" clipboard, the compositor must support any version of `ext-data-control`,
+or the second version of the `wlr-data-control` protocol.
 
 For example applications using these features, see `wl-clipboard-rs-tools/src/bin/wl_copy.rs`
 and `wl-clipboard-rs-tools/src/bin/wl_paste.rs` which implement terminal apps similar to
@@ -72,19 +72,19 @@ use wl_clipboard_rs::utils::{is_primary_selection_supported, PrimarySelectionChe
 
 match is_primary_selection_supported() {
     Ok(supported) => {
-        // We have our definitive result. False means that either data-control version 1
-        // is present (which does not support the primary selection), or that data-control
-        // version 2 is present and it did not signal the primary selection support.
+        // We have our definitive result. False means that ext/wlr-data-control is present
+        // and did not signal the primary selection support, or that only wlr-data-control
+        // version 1 is present (which does not support primary selection).
     },
     Err(PrimarySelectionCheckError::NoSeats) => {
         // Impossible to give a definitive result. Primary selection may or may not be
         // supported.
 
-        // The required protocol (data-control version 2) is there, but there are no seats.
-        // Unfortunately, at least one seat is needed to check for the primary clipboard
-        // support.
+        // The required protocol (ext-data-control, or wlr-data-control version 2) is there,
+        // but there are no seats. Unfortunately, at least one seat is needed to check for the
+        // primary clipboard support.
     },
-    Err(PrimarySelectionCheckError::MissingProtocol { .. }) => {
+    Err(PrimarySelectionCheckError::MissingProtocol) => {
         // The data-control protocol (required for wl-clipboard-rs operation) is not
         // supported by the compositor.
     },

Diff for: src/common.rs

@@ -5,17 +5,19 @@ use std::path::PathBuf;
 use std::{env, io};
 
 use wayland_backend::client::WaylandError;
-use wayland_client::globals::{registry_queue_init, BindError, GlobalError, GlobalListContents};
+use wayland_client::globals::{registry_queue_init, GlobalError, GlobalListContents};
 use wayland_client::protocol::wl_registry::WlRegistry;
 use wayland_client::protocol::wl_seat::{self, WlSeat};
 use wayland_client::{ConnectError, Connection, Dispatch, EventQueue, Proxy};
+use wayland_protocols::ext::data_control::v1::client::ext_data_control_manager_v1::ExtDataControlManagerV1;
 use wayland_protocols_wlr::data_control::v1::client::zwlr_data_control_manager_v1::ZwlrDataControlManagerV1;
 
+use crate::data_control::Manager;
 use crate::seat_data::SeatData;
 
 pub struct State {
     pub seats: HashMap<WlSeat, SeatData>,
-    pub clipboard_manager: ZwlrDataControlManagerV1,
+    pub clipboard_manager: Manager,
 }
 
 #[derive(thiserror::Error, Debug)]
@@ -30,9 +32,10 @@ pub enum Error {
     WaylandCommunication(#[source] WaylandError),
 
     #[error(
-        "A required Wayland protocol ({name} version {version}) is not supported by the compositor"
+        "A required Wayland protocol (ext-data-control, or wlr-data-control version {version}) \
+         is not supported by the compositor"
     )]
-    MissingProtocol { name: &'static str, version: u32 },
+    MissingProtocol { version: u32 },
 }
 
 impl<S> Dispatch<WlSeat, (), S> for State
@@ -62,6 +65,7 @@ pub fn initialize<S>(
 where
     S: Dispatch<WlRegistry, GlobalListContents> + 'static,
     S: Dispatch<ZwlrDataControlManagerV1, ()>,
+    S: Dispatch<ExtDataControlManagerV1, ()>,
     S: Dispatch<WlSeat, ()>,
     S: AsMut<State>,
 {
@@ -95,18 +99,15 @@ where
                                        })?;
     let qh = &queue.handle();
 
-    let data_control_version = if primary { 2 } else { 1 };
-
     // Verify that we got the clipboard manager.
-    let clipboard_manager = match globals.bind(qh, data_control_version..=data_control_version, ())
-    {
-        Ok(manager) => manager,
-        Err(BindError::NotPresent | BindError::UnsupportedVersion) => {
-            return Err(Error::MissingProtocol {
-                name: ZwlrDataControlManagerV1::interface().name,
-                version: data_control_version,
-            })
-        }
+    let ext_manager = globals.bind(qh, 1..=1, ()).ok().map(Manager::Ext);
+
+    let wlr_v = if primary { 2 } else { 1 };
+    let wlr_manager = || globals.bind(qh, wlr_v..=wlr_v, ()).ok().map(Manager::Zwlr);
+
+    let clipboard_manager = match ext_manager.or_else(wlr_manager) {
+        Some(manager) => manager,
+        None => return Err(Error::MissingProtocol { version: wlr_v }),
     };
 
     let registry = globals.registry();

Diff for: src/copy.rs

@@ -16,18 +16,12 @@ use wayland_client::protocol::wl_registry::WlRegistry;
 use wayland_client::protocol::wl_seat::WlSeat;
 use wayland_client::{
     delegate_dispatch, event_created_child, ConnectError, Dispatch, DispatchError, EventQueue,
-    Proxy,
-};
-use wayland_protocols_wlr::data_control::v1::client::zwlr_data_control_device_v1::{
-    self, ZwlrDataControlDeviceV1,
-};
-use wayland_protocols_wlr::data_control::v1::client::zwlr_data_control_manager_v1::ZwlrDataControlManagerV1;
-use wayland_protocols_wlr::data_control::v1::client::zwlr_data_control_offer_v1::ZwlrDataControlOfferV1;
-use wayland_protocols_wlr::data_control::v1::client::zwlr_data_control_source_v1::{
-    self, ZwlrDataControlSourceV1,
 };
 
 use crate::common::{self, initialize};
+use crate::data_control::{
+    self, impl_dispatch_device, impl_dispatch_manager, impl_dispatch_offer, impl_dispatch_source,
+};
 use crate::seat_data::SeatData;
 use crate::utils::is_text;
 
@@ -40,8 +34,8 @@ pub enum ClipboardType {
     Regular,
     /// The "primary" clipboard.
     ///
-    /// Working with the "primary" clipboard requires the compositor to support the data-control
-    /// protocol of version 2 or above.
+    /// Working with the "primary" clipboard requires the compositor to support ext-data-control,
+    /// or wlr-data-control version 2 or above.
     Primary,
     /// Operate on both clipboards at once.
     ///
@@ -144,7 +138,7 @@ pub struct Options {
 pub struct PreparedCopy {
     queue: EventQueue<State>,
     state: State,
-    sources: Vec<ZwlrDataControlSourceV1>,
+    sources: Vec<data_control::Source>,
 }
 
 /// Errors that can occur for copying the source data to a temporary file.
@@ -194,11 +188,10 @@ pub enum Error {
     WaylandCommunication(#[source] DispatchError),
 
     #[error(
-        "A required Wayland protocol ({} version {}) is not supported by the compositor",
-        name,
-        version
+        "A required Wayland protocol (ext-data-control, or wlr-data-control version {version}) \
+         is not supported by the compositor"
     )]
-    MissingProtocol { name: &'static str, version: u32 },
+    MissingProtocol { version: u32 },
 
     #[error("The compositor does not support primary selection")]
     PrimarySelectionUnsupported,
@@ -227,7 +220,7 @@ impl From<common::Error> for Error {
             SocketOpenError(err) => Error::SocketOpenError(err),
             WaylandConnection(err) => Error::WaylandConnection(err),
             WaylandCommunication(err) => Error::WaylandCommunication(err.into()),
-            MissingProtocol { name, version } => Error::MissingProtocol { name, version },
+            MissingProtocol { version } => Error::MissingProtocol { version },
         }
     }
 }
@@ -273,115 +266,75 @@ impl Dispatch<WlRegistry, GlobalListContents> for State {
     }
 }
 
-impl Dispatch<ZwlrDataControlManagerV1, ()> for State {
-    fn event(
-        _state: &mut Self,
-        _proxy: &ZwlrDataControlManagerV1,
-        _event: <ZwlrDataControlManagerV1 as wayland_client::Proxy>::Event,
-        _data: &(),
-        _conn: &wayland_client::Connection,
-        _qhandle: &wayland_client::QueueHandle<Self>,
-    ) {
-    }
-}
+impl_dispatch_manager!(State);
 
-impl Dispatch<ZwlrDataControlDeviceV1, WlSeat> for State {
-    fn event(
-        state: &mut Self,
-        _device: &ZwlrDataControlDeviceV1,
-        event: <ZwlrDataControlDeviceV1 as Proxy>::Event,
-        seat: &WlSeat,
-        _conn: &wayland_client::Connection,
-        _qhandle: &wayland_client::QueueHandle<Self>,
-    ) {
-        match event {
-            zwlr_data_control_device_v1::Event::DataOffer { id } => id.destroy(),
-            zwlr_data_control_device_v1::Event::Finished => {
-                state.common.seats.get_mut(seat).unwrap().set_device(None);
-            }
-            zwlr_data_control_device_v1::Event::PrimarySelection { .. } => {
-                state.got_primary_selection = true;
-            }
-            _ => (),
+impl_dispatch_device!(State, WlSeat, |state: &mut Self, event, seat| {
+    match event {
+        Event::DataOffer { id } => id.destroy(),
+        Event::Finished => {
+            state.common.seats.get_mut(seat).unwrap().set_device(None);
         }
+        Event::PrimarySelection { .. } => {
+            state.got_primary_selection = true;
+        }
+        _ => (),
     }
+});
+
+impl_dispatch_offer!(State);
+
+impl_dispatch_source!(State, |state: &mut Self,
+                              source: data_control::Source,
+                              event| {
+    match event {
+        Event::Send { mime_type, fd } => {
+            // Check if some other source already handled a paste request and indicated that we should
+            // quit.
+            if state.should_quit {
+                source.destroy();
+                return;
+            }
 
-    event_created_child!(State, ZwlrDataControlDeviceV1, [
-        zwlr_data_control_device_v1::EVT_DATA_OFFER_OPCODE => (ZwlrDataControlOfferV1, ()),
-    ]);
-}
-
-impl Dispatch<ZwlrDataControlOfferV1, ()> for State {
-    fn event(
-        _state: &mut Self,
-        _offer: &ZwlrDataControlOfferV1,
-        _event: <ZwlrDataControlOfferV1 as wayland_client::Proxy>::Event,
-        _data: &(),
-        _conn: &wayland_client::Connection,
-        _qhandle: &wayland_client::QueueHandle<Self>,
-    ) {
-    }
-}
-
-impl Dispatch<ZwlrDataControlSourceV1, ()> for State {
-    fn event(
-        state: &mut Self,
-        source: &ZwlrDataControlSourceV1,
-        event: <ZwlrDataControlSourceV1 as Proxy>::Event,
-        _data: &(),
-        _conn: &wayland_client::Connection,
-        _qhandle: &wayland_client::QueueHandle<Self>,
-    ) {
-        match event {
-            zwlr_data_control_source_v1::Event::Send { mime_type, fd } => {
-                // Check if some other source already handled a paste request and indicated that we should
-                // quit.
-                if state.should_quit {
-                    source.destroy();
-                    return;
-                }
+            // I'm not sure if it's the compositor's responsibility to check that the mime type is
+            // valid. Let's check here just in case.
+            if !state.data_paths.contains_key(&mime_type) {
+                return;
+            }
 
-                // I'm not sure if it's the compositor's responsibility to check that the mime type is
-                // valid. Let's check here just in case.
-                if !state.data_paths.contains_key(&mime_type) {
-                    return;
-                }
+            let data_path = &state.data_paths[&mime_type];
 
-                let data_path = &state.data_paths[&mime_type];
+            let file = File::open(data_path).map_err(DataSourceError::FileOpen);
+            let result = file.and_then(|mut data_file| {
+                // Clear O_NONBLOCK, otherwise io::copy() will stop halfway.
+                fcntl_setfl(&fd, OFlags::empty())
+                    .map_err(io::Error::from)
+                    .map_err(DataSourceError::Copy)?;
 
-                let file = File::open(data_path).map_err(DataSourceError::FileOpen);
-                let result = file.and_then(|mut data_file| {
-                    // Clear O_NONBLOCK, otherwise io::copy() will stop halfway.
-                    fcntl_setfl(&fd, OFlags::empty())
-                        .map_err(io::Error::from)
-                        .map_err(DataSourceError::Copy)?;
+                let mut target_file = File::from(fd);
+                io::copy(&mut data_file, &mut target_file).map_err(DataSourceError::Copy)
+            });
 
-                    let mut target_file = File::from(fd);
-                    io::copy(&mut data_file, &mut target_file).map_err(DataSourceError::Copy)
-                });
+            if let Err(err) = result {
+                state.error = Some(err);
+            }
 
-                if let Err(err) = result {
-                    state.error = Some(err);
-                }
+            let done = if let ServeRequests::Only(left) = state.serve_requests {
+                let left = left.checked_sub(1).unwrap();
+                state.serve_requests = ServeRequests::Only(left);
+                left == 0
+            } else {
+                false
+            };
 
-                let done = if let ServeRequests::Only(left) = state.serve_requests {
-                    let left = left.checked_sub(1).unwrap();
-                    state.serve_requests = ServeRequests::Only(left);
-                    left == 0
-                } else {
-                    false
-                };
-
-                if done || state.error.is_some() {
-                    state.should_quit = true;
-                    source.destroy();
-                }
+            if done || state.error.is_some() {
+                state.should_quit = true;
+                source.destroy();
             }
-            zwlr_data_control_source_v1::Event::Cancelled => source.destroy(),
-            _ => (),
         }
+        Event::Cancelled => source.destroy(),
+        _ => (),
     }
-}
+});
 
 impl Options {
     /// Creates a blank new set of options ready for configuration.
@@ -676,7 +629,7 @@ fn get_devices(
     primary: bool,
     seat: Seat,
     socket_name: Option<OsString>,
-) -> Result<(EventQueue<State>, State, Vec<ZwlrDataControlDeviceV1>), Error> {
+) -> Result<(EventQueue<State>, State, Vec<data_control::Device>), Error> {
     let (mut queue, mut common) = initialize(primary, socket_name)?;
 
     // Check if there are no seats.
@@ -980,7 +933,7 @@ fn prepare_copy_internal(
             let data_source = state
                 .common
                 .clipboard_manager
-                .create_data_source(&queue.handle(), ());
+                .create_data_source(&queue.handle());
 
             for mime_type in state.data_paths.keys() {
                 data_source.offer(mime_type.clone());