feat: new clipboard manager module

src/clients/wayland/wlr_data_control/device.rs

@@ -0,0 +1,88 @@
+use super::offer::DataControlOffer;
+use super::source::DataControlSource;
+use crate::lock;
+use std::sync::{Arc, Mutex};
+use wayland_client::protocol::wl_seat::WlSeat;
+use wayland_client::{Attached, DispatchData, Main};
+use wayland_protocols::wlr::unstable::data_control::v1::client::{
+    zwlr_data_control_device_v1::{Event, ZwlrDataControlDeviceV1},
+    zwlr_data_control_manager_v1::ZwlrDataControlManagerV1,
+    zwlr_data_control_offer_v1::ZwlrDataControlOfferV1,
+};
+
+#[derive(Debug)]
+struct Inner {
+    offer: Option<Arc<DataControlOffer>>,
+}
+
+impl Inner {
+    fn new_offer(&mut self, offer: &Main<ZwlrDataControlOfferV1>) {
+        self.offer.replace(Arc::new(DataControlOffer::new(offer)));
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct DataControlDeviceEvent(pub Arc<DataControlOffer>);
+
+fn data_control_device_implem<F>(
+    event: Event,
+    inner: &mut Inner,
+    implem: &mut F,
+    ddata: DispatchData,
+) where
+    F: FnMut(DataControlDeviceEvent, DispatchData),
+{
+    match event {
+        Event::DataOffer { id } => {
+            inner.new_offer(&id);
+        }
+        Event::Selection { id: Some(offer) } => {
+            let inner_offer = inner
+                .offer
+                .clone()
+                .expect("Offer should exist at this stage");
+            if offer == inner_offer.offer {
+                implem(DataControlDeviceEvent(inner_offer), ddata);
+            }
+        }
+        _ => {}
+    }
+}
+
+pub struct DataControlDevice {
+    device: ZwlrDataControlDeviceV1,
+    _inner: Arc<Mutex<Inner>>,
+}
+
+impl DataControlDevice {
+    pub fn init_for_seat<F>(
+        manager: &Attached<ZwlrDataControlManagerV1>,
+        seat: &WlSeat,
+        mut callback: F,
+    ) -> Self
+    where
+        F: FnMut(DataControlDeviceEvent, DispatchData) + 'static,
+    {
+        let inner = Arc::new(Mutex::new(Inner { offer: None }));
+
+        let device = manager.get_data_device(seat);
+
+        {
+            let inner = inner.clone();
+            device.quick_assign(move |_handle, event, ddata| {
+                let mut inner = lock!(inner);
+                data_control_device_implem(event, &mut inner, &mut callback, ddata);
+            });
+        }
+
+        Self {
+            device: device.detach(),
+            _inner: inner,
+        }
+    }
+
+    pub fn set_selection(&self, source: &Option<DataControlSource>) {
+        self.device
+            .set_selection(source.as_ref().map(|s| &s.source));
+    }
+}

src/clients/wayland/wlr_data_control/manager.rs

@@ -0,0 +1,253 @@
+use super::device::{DataControlDevice, DataControlDeviceEvent};
+use super::source::DataControlSource;
+use smithay_client_toolkit::data_device::WritePipe;
+use smithay_client_toolkit::environment::{Environment, GlobalHandler};
+use smithay_client_toolkit::seat::{SeatHandling, SeatListener};
+use smithay_client_toolkit::MissingGlobal;
+use std::cell::RefCell;
+use std::rc::{self, Rc};
+use tracing::warn;
+use wayland_client::protocol::wl_registry::WlRegistry;
+use wayland_client::protocol::wl_seat::WlSeat;
+use wayland_client::{Attached, DispatchData};
+use wayland_protocols::wlr::unstable::data_control::v1::client::zwlr_data_control_manager_v1::ZwlrDataControlManagerV1;
+
+enum DataControlDeviceHandlerInner {
+    Ready {
+        manager: Attached<ZwlrDataControlManagerV1>,
+        devices: Vec<(WlSeat, DataControlDevice)>,
+        status_listeners: Rc<RefCell<Vec<rc::Weak<RefCell<DataControlDeviceStatusCallback>>>>>,
+    },
+    Pending {
+        seats: Vec<WlSeat>,
+        status_listeners: Rc<RefCell<Vec<rc::Weak<RefCell<DataControlDeviceStatusCallback>>>>>,
+    },
+}
+
+impl DataControlDeviceHandlerInner {
+    fn init_manager(&mut self, manager: Attached<ZwlrDataControlManagerV1>) {
+        let (seats, status_listeners) = if let Self::Pending {
+            seats,
+            status_listeners,
+        } = self
+        {
+            (std::mem::take(seats), status_listeners.clone())
+        } else {
+            warn!("Ignoring second zwlr_data_control_manager_v1");
+            return;
+        };
+
+        let mut devices = Vec::new();
+
+        for seat in seats {
+            let my_seat = seat.clone();
+            let status_listeners = status_listeners.clone();
+            let device =
+                DataControlDevice::init_for_seat(&manager, &seat, move |event, dispatch_data| {
+                    notify_status_listeners(&my_seat, &event, dispatch_data, &status_listeners);
+                });
+            devices.push((seat.clone(), device));
+        }
+
+        *self = Self::Ready {
+            manager,
+            devices,
+            status_listeners,
+        };
+    }
+
+    fn get_manager(&self) -> Option<Attached<ZwlrDataControlManagerV1>> {
+        match self {
+            Self::Ready { manager, .. } => Some(manager.clone()),
+            Self::Pending { .. } => None,
+        }
+    }
+
+    fn new_seat(&mut self, seat: &WlSeat) {
+        match self {
+            Self::Ready {
+                manager,
+                devices,
+                status_listeners,
+            } => {
+                if devices.iter().any(|(s, _)| s == seat) {
+                    // the seat already exists, nothing to do
+                    return;
+                }
+                let my_seat = seat.clone();
+                let status_listeners = status_listeners.clone();
+                let device =
+                    DataControlDevice::init_for_seat(manager, seat, move |event, dispatch_data| {
+                        notify_status_listeners(&my_seat, &event, dispatch_data, &status_listeners);
+                    });
+                devices.push((seat.clone(), device));
+            }
+            Self::Pending { seats, .. } => {
+                seats.push(seat.clone());
+            }
+        }
+    }
+
+    fn remove_seat(&mut self, seat: &WlSeat) {
+        match self {
+            Self::Ready { devices, .. } => devices.retain(|(s, _)| s != seat),
+            Self::Pending { seats, .. } => seats.retain(|s| s != seat),
+        }
+    }
+
+    fn create_source<F>(&self, mime_types: Vec<String>, callback: F) -> Option<DataControlSource>
+    where
+        F: FnMut(String, WritePipe, DispatchData) + 'static,
+    {
+        match self {
+            Self::Ready { manager, .. } => {
+                let source = DataControlSource::new(manager, mime_types, callback);
+                Some(source)
+            }
+            Self::Pending { .. } => None,
+        }
+    }
+
+    fn with_device<F>(&self, seat: &WlSeat, f: F) -> Result<(), MissingGlobal>
+    where
+        F: FnOnce(&DataControlDevice),
+    {
+        match self {
+            Self::Ready { devices, .. } => {
+                let device = devices
+                    .iter()
+                    .find_map(|(s, device)| if s == seat { Some(device) } else { None });
+
+                device.map_or(Err(MissingGlobal), |device| {
+                    f(device);
+                    Ok(())
+                })
+            }
+            Self::Pending { .. } => Err(MissingGlobal),
+        }
+    }
+}
+
+pub struct DataControlDeviceHandler {
+    inner: Rc<RefCell<DataControlDeviceHandlerInner>>,
+    status_listeners: Rc<RefCell<Vec<rc::Weak<RefCell<DataControlDeviceStatusCallback>>>>>,
+    _seat_listener: SeatListener,
+}
+
+impl DataControlDeviceHandler {
+    pub fn init<S>(seat_handler: &mut S) -> Self
+    where
+        S: SeatHandling,
+    {
+        let status_listeners = Rc::new(RefCell::new(Vec::new()));
+
+        let inner = Rc::new(RefCell::new(DataControlDeviceHandlerInner::Pending {
+            seats: Vec::new(),
+            status_listeners: status_listeners.clone(),
+        }));
+
+        let seat_inner = inner.clone();
+        let seat_listener = seat_handler.listen(move |seat, seat_data, _| {
+            if seat_data.defunct {
+                seat_inner.borrow_mut().remove_seat(&seat);
+            } else {
+                seat_inner.borrow_mut().new_seat(&seat);
+            }
+        });
+
+        Self {
+            inner,
+            _seat_listener: seat_listener,
+            status_listeners,
+        }
+    }
+}
+
+impl GlobalHandler<ZwlrDataControlManagerV1> for DataControlDeviceHandler {
+    fn created(
+        &mut self,
+        registry: Attached<WlRegistry>,
+        id: u32,
+        version: u32,
+        _ddata: DispatchData,
+    ) {
+        // data control manager is supported until version 2
+        let version = std::cmp::min(version, 2);
+
+        let manager = registry.bind::<ZwlrDataControlManagerV1>(version, id);
+        self.inner.borrow_mut().init_manager((*manager).clone());
+    }
+
+    fn get(&self) -> Option<Attached<ZwlrDataControlManagerV1>> {
+        RefCell::borrow(&self.inner).get_manager()
+    }
+}
+
+type DataControlDeviceStatusCallback =
+    dyn FnMut(WlSeat, DataControlDeviceEvent, DispatchData) + 'static;
+
+/// Notifies the callbacks of an event on the data device
+fn notify_status_listeners(
+    seat: &WlSeat,
+    event: &DataControlDeviceEvent,
+    mut ddata: DispatchData,
+    listeners: &RefCell<Vec<rc::Weak<RefCell<DataControlDeviceStatusCallback>>>>,
+) {
+    listeners.borrow_mut().retain(|lst| {
+        rc::Weak::upgrade(lst).map_or(false, |cb| {
+            (cb.borrow_mut())(seat.clone(), event.clone(), ddata.reborrow());
+            true
+        })
+    });
+}
+
+pub struct DataControlDeviceStatusListener {
+    _cb: Rc<RefCell<DataControlDeviceStatusCallback>>,
+}
+
+pub trait DataControlDeviceHandling {
+    fn listen<F>(&mut self, f: F) -> DataControlDeviceStatusListener
+    where
+        F: FnMut(WlSeat, DataControlDeviceEvent, DispatchData) + 'static;
+
+    fn with_data_control_device<F>(&self, seat: &WlSeat, f: F) -> Result<(), MissingGlobal>
+    where
+        F: FnOnce(&DataControlDevice);
+
+    fn create_source<F>(&self, mime_types: Vec<String>, callback: F) -> Option<DataControlSource>
+    where
+        F: FnMut(String, WritePipe, DispatchData) + 'static;
+}
+
+impl DataControlDeviceHandling for DataControlDeviceHandler {
+    fn listen<F>(&mut self, f: F) -> DataControlDeviceStatusListener
+    where
+        F: FnMut(WlSeat, DataControlDeviceEvent, DispatchData) + 'static,
+    {
+        let rc = Rc::new(RefCell::new(f)) as Rc<_>;
+        self.status_listeners.borrow_mut().push(Rc::downgrade(&rc));
+        DataControlDeviceStatusListener { _cb: rc }
+    }
+
+    fn with_data_control_device<F>(&self, seat: &WlSeat, f: F) -> Result<(), MissingGlobal>
+    where
+        F: FnOnce(&DataControlDevice),
+    {
+        RefCell::borrow(&self.inner).with_device(seat, f)
+    }
+
+    fn create_source<F>(&self, mime_types: Vec<String>, callback: F) -> Option<DataControlSource>
+    where
+        F: FnMut(String, WritePipe, DispatchData) + 'static,
+    {
+        RefCell::borrow(&self.inner).create_source(mime_types, callback)
+    }
+}
+
+pub fn listen_to_devices<E, F>(env: &Environment<E>, f: F) -> DataControlDeviceStatusListener
+where
+    E: DataControlDeviceHandling,
+    F: FnMut(WlSeat, DataControlDeviceEvent, DispatchData) + 'static,
+{
+    env.with_inner(move |inner| DataControlDeviceHandling::listen(inner, f))
+}

src/clients/wayland/wlr_data_control/mod.rs

@@ -0,0 +1,259 @@
+pub mod device;
+pub mod manager;
+pub mod offer;
+pub mod source;
+
+use super::Env;
+use crate::clients::wayland::DData;
+use crate::send;
+use color_eyre::Report;
+use device::{DataControlDevice, DataControlDeviceEvent};
+use glib::Bytes;
+use manager::{DataControlDeviceHandling, DataControlDeviceStatusListener};
+use smithay_client_toolkit::data_device::WritePipe;
+use smithay_client_toolkit::environment::Environment;
+use smithay_client_toolkit::reexports::calloop::LoopHandle;
+use smithay_client_toolkit::MissingGlobal;
+use source::DataControlSource;
+use std::fs::File;
+use std::io;
+use std::io::{Read, Write};
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::Arc;
+use std::time::UNIX_EPOCH;
+use tokio::sync::broadcast;
+use tracing::{debug, error, trace};
+use wayland_client::protocol::wl_seat::WlSeat;
+use wayland_client::DispatchData;
+
+static COUNTER: AtomicUsize = AtomicUsize::new(1);
+
+const INTERNAL_MIME_TYPE: &str = "x-ironbar-internal";
+
+fn get_id() -> usize {
+    COUNTER.fetch_add(1, Ordering::Relaxed)
+}
+
+#[derive(Debug, Clone, Eq)]
+pub struct ClipboardItem {
+    pub id: usize,
+    pub value: ClipboardValue,
+    pub mime_type: String,
+}
+
+impl PartialEq<Self> for ClipboardItem {
+    fn eq(&self, other: &Self) -> bool {
+        self.id == other.id
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum ClipboardValue {
+    Text(String),
+    Image(Bytes),
+    Other,
+}
+
+impl DataControlDeviceHandling for Env {
+    fn listen<F>(&mut self, f: F) -> DataControlDeviceStatusListener
+    where
+        F: FnMut(WlSeat, DataControlDeviceEvent, DispatchData) + 'static,
+    {
+        self.data_control_device.listen(f)
+    }
+
+    fn with_data_control_device<F>(&self, seat: &WlSeat, f: F) -> Result<(), MissingGlobal>
+    where
+        F: FnOnce(&DataControlDevice),
+    {
+        self.data_control_device.with_data_control_device(seat, f)
+    }
+
+    fn create_source<F>(&self, mime_types: Vec<String>, callback: F) -> Option<DataControlSource>
+    where
+        F: FnMut(String, WritePipe, DispatchData) + 'static,
+    {
+        self.data_control_device.create_source(mime_types, callback)
+    }
+}
+
+pub fn copy_to_clipboard<E>(
+    env: &Environment<E>,
+    seat: &WlSeat,
+    item: &ClipboardItem,
+) -> Result<(), MissingGlobal>
+where
+    E: DataControlDeviceHandling,
+{
+    debug!("Copying item with id {} [{}]", item.id, item.mime_type);
+    trace!("Copying: {item:?}");
+
+    let item = item.clone();
+
+    env.with_inner(|env| {
+        let mime_types = vec![INTERNAL_MIME_TYPE.to_string(), item.mime_type];
+        let source = env.create_source(mime_types, move |mime_type, mut pipe, _ddata| {
+            debug!(
+                "Triggering source callback for item with id {} [{}]",
+                item.id, mime_type
+            );
+
+            // FIXME: Not working for large (buffered) values in xwayland
+            let bytes = match &item.value {
+                ClipboardValue::Text(text) => text.as_bytes(),
+                ClipboardValue::Image(bytes) => bytes.as_ref(),
+                ClipboardValue::Other => panic!(
+                    "{:?}",
+                    io::Error::new(
+                        io::ErrorKind::Other,
+                        "Attempted to copy unsupported mime type",
+                    )
+                ),
+            };
+
+            if let Err(err) = pipe.write_all(bytes) {
+                error!("{err:?}");
+            }
+        });
+
+        env.with_data_control_device(seat, |device| device.set_selection(&source))
+    })
+}
+
+#[derive(Debug)]
+struct MimeType {
+    value: String,
+    category: MimeTypeCategory,
+}
+
+#[derive(Debug)]
+enum MimeTypeCategory {
+    Text,
+    Image,
+}
+
+impl MimeType {
+    fn parse(mime_types: &[String]) -> Option<Self> {
+        mime_types
+            .iter()
+            .map(|s| s.to_lowercase())
+            .find_map(|mime_type| match mime_type.as_str() {
+                "text"
+                | "string"
+                | "utf8_string"
+                | "text/plain"
+                | "text/plain;charset=utf-8"
+                | "text/plain;charset=iso-8859-1"
+                | "text/plain;charset=us-ascii"
+                | "text/plain;charset=unicode" => Some(Self {
+                    value: mime_type,
+                    category: MimeTypeCategory::Text,
+                }),
+                "image/png" | "image/jpg" | "image/jpeg" | "image/tiff" | "image/bmp"
+                | "image/x-bmp" | "image/icon" => Some(Self {
+                    value: mime_type,
+                    category: MimeTypeCategory::Image,
+                }),
+                _ => None,
+            })
+    }
+}
+
+pub fn receive_offer(
+    event: DataControlDeviceEvent,
+    handle: &LoopHandle<DData>,
+    tx: broadcast::Sender<Arc<ClipboardItem>>,
+    mut ddata: DispatchData,
+) {
+    let timestamp = std::time::SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .expect("Could not get epoch, system time is probably very wrong")
+        .as_nanos();
+
+    let offer = event.0;
+
+    let ddata = ddata
+        .get::<DData>()
+        .expect("Expected dispatch data to exist");
+
+    let handle2 = handle.clone();
+
+    let res = offer.with_mime_types(|mime_types| {
+        debug!("Offer mime types: {mime_types:?}");
+
+        if mime_types.contains(&INTERNAL_MIME_TYPE.to_string()) {
+            debug!("Skipping value provided by bar");
+            return Ok(());
+        }
+
+        let mime_type = MimeType::parse(mime_types);
+        debug!("Detected mime type: {mime_type:?}");
+
+        match mime_type {
+            Some(mime_type) => {
+                debug!("[{timestamp}] Sending clipboard read request ({mime_type:?})");
+                let read_pipe = offer.receive(mime_type.value.clone())?;
+                let source = handle.insert_source(read_pipe, move |(), file, ddata| {
+                    debug!(
+                        "[{timestamp}] Reading clipboard contents ({:?})",
+                        &mime_type.category
+                    );
+                    match read_file(&mime_type, file) {
+                        Ok(item) => {
+                            send!(tx, Arc::new(item));
+                        }
+                        Err(err) => error!("{err:?}"),
+                    }
+
+                    if let Some(src) = ddata.offer_tokens.remove(&timestamp) {
+                        handle2.remove(src);
+                    }
+                })?;
+
+                ddata.offer_tokens.insert(timestamp, source);
+            }
+            None => {
+                // send an event so the clipboard module is aware it's changed
+                send!(
+                    tx,
+                    Arc::new(ClipboardItem {
+                        id: usize::MAX,
+                        mime_type: String::new(),
+                        value: ClipboardValue::Other
+                    })
+                );
+            }
+        }
+
+        Ok::<(), Report>(())
+    });
+
+    if let Err(err) = res {
+        error!("{err:?}");
+    }
+}
+
+fn read_file(mime_type: &MimeType, file: &mut File) -> io::Result<ClipboardItem> {
+    let value = match mime_type.category {
+        MimeTypeCategory::Text => {
+            let mut txt = String::new();
+            file.read_to_string(&mut txt)?;
+
+            ClipboardValue::Text(txt)
+        }
+        MimeTypeCategory::Image => {
+            let mut bytes = vec![];
+            file.read_to_end(&mut bytes)?;
+            let bytes = Bytes::from(&bytes);
+
+            println!("Num bytes: {}", bytes.len());
+            ClipboardValue::Image(bytes)
+        }
+    };
+
+    Ok(ClipboardItem {
+        id: get_id(),
+        value,
+        mime_type: mime_type.value.clone(),
+    })
+}

src/clients/wayland/wlr_data_control/offer.rs

@@ -0,0 +1,74 @@
+use crate::lock;
+use nix::fcntl::OFlag;
+use nix::unistd::{close, pipe2};
+use smithay_client_toolkit::data_device::ReadPipe;
+use std::io;
+use std::os::fd::FromRawFd;
+use std::sync::{Arc, Mutex};
+use tracing::warn;
+use wayland_client::Main;
+use wayland_protocols::wlr::unstable::data_control::v1::client::zwlr_data_control_offer_v1::{
+    Event, ZwlrDataControlOfferV1,
+};
+
+#[derive(Debug, Clone)]
+struct Inner {
+    mime_types: Vec<String>,
+}
+
+#[derive(Debug, Clone)]
+pub struct DataControlOffer {
+    inner: Arc<Mutex<Inner>>,
+    pub(crate) offer: ZwlrDataControlOfferV1,
+}
+
+impl DataControlOffer {
+    pub(crate) fn new(offer: &Main<ZwlrDataControlOfferV1>) -> Self {
+        let inner = Arc::new(Mutex::new(Inner {
+            mime_types: Vec::new(),
+        }));
+
+        {
+            let inner = inner.clone();
+
+            offer.quick_assign(move |_, event, _| {
+                let mut inner = lock!(inner);
+                if let Event::Offer { mime_type } = event {
+                    inner.mime_types.push(mime_type);
+                }
+            });
+        }
+
+        Self {
+            offer: offer.detach(),
+            inner,
+        }
+    }
+
+    pub fn with_mime_types<F, T>(&self, f: F) -> T
+    where
+        F: FnOnce(&[String]) -> T,
+    {
+        let inner = lock!(self.inner);
+        f(&inner.mime_types)
+    }
+
+    pub fn receive(&self, mime_type: String) -> io::Result<ReadPipe> {
+        // create a pipe
+        let (readfd, writefd) = pipe2(OFlag::O_CLOEXEC)?;
+
+        self.offer.receive(mime_type, writefd);
+
+        if let Err(err) = close(writefd) {
+            warn!("Failed to close write pipe: {}", err);
+        }
+
+        Ok(unsafe { FromRawFd::from_raw_fd(readfd) })
+    }
+}
+
+impl Drop for DataControlOffer {
+    fn drop(&mut self) {
+        self.offer.destroy();
+    }
+}

src/clients/wayland/wlr_data_control/source.rs

@@ -0,0 +1,54 @@
+use smithay_client_toolkit::data_device::WritePipe;
+use std::os::fd::FromRawFd;
+use wayland_client::{Attached, DispatchData};
+use wayland_protocols::wlr::unstable::data_control::v1::client::{
+    zwlr_data_control_manager_v1::ZwlrDataControlManagerV1,
+    zwlr_data_control_source_v1::{Event, ZwlrDataControlSourceV1},
+};
+
+fn data_control_source_impl<F>(
+    source: &ZwlrDataControlSourceV1,
+    event: Event,
+    implem: &mut F,
+    ddata: DispatchData,
+) where
+    F: FnMut(String, WritePipe, DispatchData),
+{
+    match event {
+        Event::Send { mime_type, fd } => {
+            let pipe = unsafe { FromRawFd::from_raw_fd(fd) };
+            implem(mime_type, pipe, ddata);
+        }
+        Event::Cancelled => source.destroy(),
+        _ => unreachable!(),
+    }
+}
+
+pub struct DataControlSource {
+    pub(crate) source: ZwlrDataControlSourceV1,
+}
+
+impl DataControlSource {
+    pub fn new<F>(
+        manager: &Attached<ZwlrDataControlManagerV1>,
+        mime_types: Vec<String>,
+        mut callback: F,
+    ) -> Self
+    where
+        F: FnMut(String, WritePipe, DispatchData) + 'static,
+    {
+        let source = manager.create_data_source();
+
+        source.quick_assign(move |source, evt, ddata| {
+            data_control_source_impl(&source, evt, &mut callback, ddata);
+        });
+
+        for mime_type in mime_types {
+            source.offer(mime_type);
+        }
+
+        Self {
+            source: source.detach(),
+        }
+    }
+}